#include "nodes/execnodes.h"
#include "nodes/parsenodes.h"
#include "parser/parse_node.h"
#include "tcop/dest.h"

Include dependency graph for copy.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	CopyFormatOptions

Typedefs
typedef struct CopyFormatOptions	CopyFormatOptions

typedef struct CopyFromStateData *	CopyFromState

typedef struct CopyToStateData *	CopyToState

typedef int(*	copy_data_source_cb) (void *outbuf, int minread, int maxread)

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

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

CopyFromState	BeginCopyFrom (ParseState pstate, Relation rel, Node whereClause, const char filename, bool is_program, copy_data_source_cb data_source_cb, List attnamelist, List *options)

void	EndCopyFrom (CopyFromState cstate)

bool	NextCopyFrom (CopyFromState cstate, ExprContext econtext, Datum values, bool *nulls)

bool	NextCopyFromRawFields (CopyFromState cstate, char **fields, int nfields)

void	CopyFromErrorCallback (void *arg)

uint64	CopyFrom (CopyFromState cstate)

DestReceiver *	CreateCopyDestReceiver (void)

CopyToState	BeginCopyTo (ParseState pstate, Relation rel, RawStmt query, Oid queryRelId, const char filename, bool is_program, List attnamelist, List *options)

void	EndCopyTo (CopyToState cstate)

uint64	DoCopyTo (CopyToState cstate)

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

Typedef Documentation

◆ copy_data_source_cb

typedef int(* copy_data_source_cb) (void *outbuf, int minread, int maxread)

Definition at line 57 of file copy.h.

◆ CopyFormatOptions

typedef struct CopyFormatOptions CopyFormatOptions

◆ CopyFromState

typedef struct CopyFromStateData* CopyFromState

Definition at line 54 of file copy.h.

◆ CopyToState

typedef struct CopyToStateData* CopyToState

Definition at line 55 of file copy.h.

Function Documentation

◆ BeginCopyFrom()

CopyFromState BeginCopyFrom	(	ParseState *	pstate,
		Relation	rel,
		Node *	whereClause,
		const char *	filename,
		bool	is_program,
		copy_data_source_cb	data_source_cb,
		List *	attnamelist,
		List *	options
	)

Definition at line 1186 of file copyfrom.c.

Referenced by copy_table(), DoCopy(), file_acquire_sample_rows(), fileBeginForeignScan(), and fileReScanForeignScan().

 {
     CopyFromState cstate;
     bool        pipe = (filename == NULL);
     TupleDesc   tupDesc;
     AttrNumber  num_phys_attrs,
                 num_defaults;
     FmgrInfo   *in_functions;
     Oid        *typioparams;
     int         attnum;
     Oid         in_func_oid;
     int        *defmap;
     ExprState **defexprs;
     MemoryContext oldcontext;
     bool        volatile_defexprs;
     const int   progress_cols[] = {
         PROGRESS_COPY_COMMAND,
         PROGRESS_COPY_TYPE,
         PROGRESS_COPY_BYTES_TOTAL
     };
     int64       progress_vals[] = {
         PROGRESS_COPY_COMMAND_FROM,
         0,
         0
     };
 
     /* Allocate workspace and zero all fields */
     cstate = (CopyFromStateData *) palloc0(sizeof(CopyFromStateData));
 
     /*
      * We allocate everything used by a cstate in a new memory context. This
      * avoids memory leaks during repeated use of COPY in a query.
      */
     cstate->copycontext = AllocSetContextCreate(CurrentMemoryContext,
                                                 "COPY",
                                                 ALLOCSET_DEFAULT_SIZES);
 
     oldcontext = MemoryContextSwitchTo(cstate->copycontext);
 
     /* Extract options from the statement node tree */
     ProcessCopyOptions(pstate, &cstate->opts, true /* is_from */ , options);
 
     /* Process the target relation */
     cstate->rel = rel;
 
     tupDesc = RelationGetDescr(cstate->rel);
 
     /* process commmon options or initialization */
 
     /* Generate or convert list of attributes to process */
     cstate->attnumlist = CopyGetAttnums(tupDesc, cstate->rel, attnamelist);
 
     num_phys_attrs = tupDesc->natts;
 
     /* Convert FORCE_NOT_NULL name list to per-column flags, check validity */
     cstate->opts.force_notnull_flags = (bool *) palloc0(num_phys_attrs * sizeof(bool));
     if (cstate->opts.force_notnull)
     {
         List       *attnums;
         ListCell   *cur;
 
         attnums = CopyGetAttnums(tupDesc, cstate->rel, cstate->opts.force_notnull);
 
         foreach(cur, attnums)
         {
             int         attnum = lfirst_int(cur);
             Form_pg_attribute attr = TupleDescAttr(tupDesc, attnum - 1);
 
             if (!list_member_int(cstate->attnumlist, attnum))
                 ereport(ERROR,
                         (errcode(ERRCODE_INVALID_COLUMN_REFERENCE),
                          errmsg("FORCE_NOT_NULL column \"%s\" not referenced by COPY",
                                 NameStr(attr->attname))));
             cstate->opts.force_notnull_flags[attnum - 1] = true;
         }
     }
 
     /* Convert FORCE_NULL name list to per-column flags, check validity */
     cstate->opts.force_null_flags = (bool *) palloc0(num_phys_attrs * sizeof(bool));
     if (cstate->opts.force_null)
     {
         List       *attnums;
         ListCell   *cur;
 
         attnums = CopyGetAttnums(tupDesc, cstate->rel, cstate->opts.force_null);
 
         foreach(cur, attnums)
         {
             int         attnum = lfirst_int(cur);
             Form_pg_attribute attr = TupleDescAttr(tupDesc, attnum - 1);
 
             if (!list_member_int(cstate->attnumlist, attnum))
                 ereport(ERROR,
                         (errcode(ERRCODE_INVALID_COLUMN_REFERENCE),
                          errmsg("FORCE_NULL column \"%s\" not referenced by COPY",
                                 NameStr(attr->attname))));
             cstate->opts.force_null_flags[attnum - 1] = true;
         }
     }
 
     /* Convert convert_selectively name list to per-column flags */
     if (cstate->opts.convert_selectively)
     {
         List       *attnums;
         ListCell   *cur;
 
         cstate->convert_select_flags = (bool *) palloc0(num_phys_attrs * sizeof(bool));
 
         attnums = CopyGetAttnums(tupDesc, cstate->rel, cstate->opts.convert_select);
 
         foreach(cur, attnums)
         {
             int         attnum = lfirst_int(cur);
             Form_pg_attribute attr = TupleDescAttr(tupDesc, attnum - 1);
 
             if (!list_member_int(cstate->attnumlist, attnum))
                 ereport(ERROR,
                         (errcode(ERRCODE_INVALID_COLUMN_REFERENCE),
                          errmsg_internal("selected column \"%s\" not referenced by COPY",
                                          NameStr(attr->attname))));
             cstate->convert_select_flags[attnum - 1] = true;
         }
     }
 
     /* Use client encoding when ENCODING option is not specified. */
     if (cstate->opts.file_encoding < 0)
         cstate->file_encoding = pg_get_client_encoding();
     else
         cstate->file_encoding = cstate->opts.file_encoding;
 
     /*
      * Look up encoding conversion function.
      */
     if (cstate->file_encoding == GetDatabaseEncoding() ||
         cstate->file_encoding == PG_SQL_ASCII ||
         GetDatabaseEncoding() == PG_SQL_ASCII)
     {
         cstate->need_transcoding = false;
     }
     else
     {
         cstate->need_transcoding = true;
         cstate->conversion_proc = FindDefaultConversionProc(cstate->file_encoding,
                                                             GetDatabaseEncoding());
     }
 
     cstate->copy_src = COPY_FILE;   /* default */
 
     cstate->whereClause = whereClause;
 
     MemoryContextSwitchTo(oldcontext);
 
     oldcontext = MemoryContextSwitchTo(cstate->copycontext);
 
     /* Initialize state variables */
     cstate->eol_type = EOL_UNKNOWN;
     cstate->cur_relname = RelationGetRelationName(cstate->rel);
     cstate->cur_lineno = 0;
     cstate->cur_attname = NULL;
     cstate->cur_attval = NULL;
 
     /*
      * Allocate buffers for the input pipeline.
      *
      * attribute_buf and raw_buf are used in both text and binary modes, but
      * input_buf and line_buf only in text mode.
      */
     cstate->raw_buf = palloc(RAW_BUF_SIZE + 1);
     cstate->raw_buf_index = cstate->raw_buf_len = 0;
     cstate->raw_reached_eof = false;
 
     if (!cstate->opts.binary)
     {
         /*
          * If encoding conversion is needed, we need another buffer to hold
          * the converted input data.  Otherwise, we can just point input_buf
          * to the same buffer as raw_buf.
          */
         if (cstate->need_transcoding)
         {
             cstate->input_buf = (char *) palloc(INPUT_BUF_SIZE + 1);
             cstate->input_buf_index = cstate->input_buf_len = 0;
         }
         else
             cstate->input_buf = cstate->raw_buf;
         cstate->input_reached_eof = false;
 
         initStringInfo(&cstate->line_buf);
     }
 
     initStringInfo(&cstate->attribute_buf);
 
     /* Assign range table, we'll need it in CopyFrom. */
     if (pstate)
         cstate->range_table = pstate->p_rtable;
 
     tupDesc = RelationGetDescr(cstate->rel);
     num_phys_attrs = tupDesc->natts;
     num_defaults = 0;
     volatile_defexprs = false;
 
     /*
      * Pick up the required catalog information for each attribute in the
      * relation, including the input function, the element type (to pass to
      * the input function), and info about defaults and constraints. (Which
      * input function we use depends on text/binary format choice.)
      */
     in_functions = (FmgrInfo *) palloc(num_phys_attrs * sizeof(FmgrInfo));
     typioparams = (Oid *) palloc(num_phys_attrs * sizeof(Oid));
     defmap = (int *) palloc(num_phys_attrs * sizeof(int));
     defexprs = (ExprState **) palloc(num_phys_attrs * sizeof(ExprState *));
 
     for (attnum = 1; attnum <= num_phys_attrs; attnum++)
     {
         Form_pg_attribute att = TupleDescAttr(tupDesc, attnum - 1);
 
         /* We don't need info for dropped attributes */
         if (att->attisdropped)
             continue;
 
         /* Fetch the input function and typioparam info */
         if (cstate->opts.binary)
             getTypeBinaryInputInfo(att->atttypid,
                                    &in_func_oid, &typioparams[attnum - 1]);
         else
             getTypeInputInfo(att->atttypid,
                              &in_func_oid, &typioparams[attnum - 1]);
         fmgr_info(in_func_oid, &in_functions[attnum - 1]);
 
         /* Get default info if needed */
         if (!list_member_int(cstate->attnumlist, attnum) && !att->attgenerated)
         {
             /* attribute is NOT to be copied from input */
             /* use default value if one exists */
             Expr       *defexpr = (Expr *) build_column_default(cstate->rel,
                                                                 attnum);
 
             if (defexpr != NULL)
             {
                 /* Run the expression through planner */
                 defexpr = expression_planner(defexpr);
 
                 /* Initialize executable expression in copycontext */
                 defexprs[num_defaults] = ExecInitExpr(defexpr, NULL);
                 defmap[num_defaults] = attnum - 1;
                 num_defaults++;
 
                 /*
                  * If a default expression looks at the table being loaded,
                  * then it could give the wrong answer when using
                  * multi-insert. Since database access can be dynamic this is
                  * hard to test for exactly, so we use the much wider test of
                  * whether the default expression is volatile. We allow for
                  * the special case of when the default expression is the
                  * nextval() of a sequence which in this specific case is
                  * known to be safe for use with the multi-insert
                  * optimization. Hence we use this special case function
                  * checker rather than the standard check for
                  * contain_volatile_functions().
                  */
                 if (!volatile_defexprs)
                     volatile_defexprs = contain_volatile_functions_not_nextval((Node *) defexpr);
             }
         }
     }
 
 
     /* initialize progress */
     pgstat_progress_start_command(PROGRESS_COMMAND_COPY,
                                   cstate->rel ? RelationGetRelid(cstate->rel) : InvalidOid);
     cstate->bytes_processed = 0;
 
     /* We keep those variables in cstate. */
     cstate->in_functions = in_functions;
     cstate->typioparams = typioparams;
     cstate->defmap = defmap;
     cstate->defexprs = defexprs;
     cstate->volatile_defexprs = volatile_defexprs;
     cstate->num_defaults = num_defaults;
     cstate->is_program = is_program;
 
     if (data_source_cb)
     {
         progress_vals[1] = PROGRESS_COPY_TYPE_CALLBACK;
         cstate->copy_src = COPY_CALLBACK;
         cstate->data_source_cb = data_source_cb;
     }
     else if (pipe)
     {
         progress_vals[1] = PROGRESS_COPY_TYPE_PIPE;
         Assert(!is_program);    /* the grammar does not allow this */
         if (whereToSendOutput == DestRemote)
             ReceiveCopyBegin(cstate);
         else
             cstate->copy_file = stdin;
     }
     else
     {
         cstate->filename = pstrdup(filename);
 
         if (cstate->is_program)
         {
             progress_vals[1] = PROGRESS_COPY_TYPE_PROGRAM;
             cstate->copy_file = OpenPipeStream(cstate->filename, PG_BINARY_R);
             if (cstate->copy_file == NULL)
                 ereport(ERROR,
                         (errcode_for_file_access(),
                          errmsg("could not execute command \"%s\": %m",
                                 cstate->filename)));
         }
         else
         {
             struct stat st;
 
             progress_vals[1] = PROGRESS_COPY_TYPE_FILE;
             cstate->copy_file = AllocateFile(cstate->filename, PG_BINARY_R);
             if (cstate->copy_file == NULL)
             {
                 /* copy errno because ereport subfunctions might change it */
                 int         save_errno = errno;
 
                 ereport(ERROR,
                         (errcode_for_file_access(),
                          errmsg("could not open file \"%s\" for reading: %m",
                                 cstate->filename),
                          (save_errno == ENOENT || save_errno == EACCES) ?
                          errhint("COPY FROM instructs the PostgreSQL server process to read a file. "
                                  "You may want a client-side facility such as psql's \\copy.") : 0));
             }
 
             if (fstat(fileno(cstate->copy_file), &st))
                 ereport(ERROR,
                         (errcode_for_file_access(),
                          errmsg("could not stat file \"%s\": %m",
                                 cstate->filename)));
 
             if (S_ISDIR(st.st_mode))
                 ereport(ERROR,
                         (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                          errmsg("\"%s\" is a directory", cstate->filename)));
 
             progress_vals[2] = st.st_size;
         }
     }
 
     pgstat_progress_update_multi_param(3, progress_cols, progress_vals);
 
     if (cstate->opts.binary)
     {
         /* Read and verify binary header */
         ReceiveCopyBinaryHeader(cstate);
     }
 
     /* create workspace for CopyReadAttributes results */
     if (!cstate->opts.binary)
     {
         AttrNumber  attr_count = list_length(cstate->attnumlist);
 
         cstate->max_fields = attr_count;
         cstate->raw_fields = (char **) palloc(attr_count * sizeof(char *));
     }
 
     MemoryContextSwitchTo(oldcontext);
 
     return cstate;
 }

◆ BeginCopyTo()

CopyToState BeginCopyTo	(	ParseState *	pstate,
		Relation	rel,
		RawStmt *	query,
		Oid	queryRelId,
		const char *	filename,
		bool	is_program,
		List *	attnamelist,
		List *	options
	)

Definition at line 342 of file copyto.c.

Referenced by DoCopy().

 {
     CopyToState cstate;
     bool        pipe = (filename == NULL);
     TupleDesc   tupDesc;
     int         num_phys_attrs;
     MemoryContext oldcontext;
     const int   progress_cols[] = {
         PROGRESS_COPY_COMMAND,
         PROGRESS_COPY_TYPE
     };
     int64       progress_vals[] = {
         PROGRESS_COPY_COMMAND_TO,
         0
     };
 
     if (rel != NULL && rel->rd_rel->relkind != RELKIND_RELATION)
     {
         if (rel->rd_rel->relkind == RELKIND_VIEW)
             ereport(ERROR,
                     (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                      errmsg("cannot copy from view \"%s\"",
                             RelationGetRelationName(rel)),
                      errhint("Try the COPY (SELECT ...) TO variant.")));
         else if (rel->rd_rel->relkind == RELKIND_MATVIEW)
             ereport(ERROR,
                     (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                      errmsg("cannot copy from materialized view \"%s\"",
                             RelationGetRelationName(rel)),
                      errhint("Try the COPY (SELECT ...) TO variant.")));
         else if (rel->rd_rel->relkind == RELKIND_FOREIGN_TABLE)
             ereport(ERROR,
                     (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                      errmsg("cannot copy from foreign table \"%s\"",
                             RelationGetRelationName(rel)),
                      errhint("Try the COPY (SELECT ...) TO variant.")));
         else if (rel->rd_rel->relkind == RELKIND_SEQUENCE)
             ereport(ERROR,
                     (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                      errmsg("cannot copy from sequence \"%s\"",
                             RelationGetRelationName(rel))));
         else if (rel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE)
             ereport(ERROR,
                     (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                      errmsg("cannot copy from partitioned table \"%s\"",
                             RelationGetRelationName(rel)),
                      errhint("Try the COPY (SELECT ...) TO variant.")));
         else
             ereport(ERROR,
                     (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                      errmsg("cannot copy from non-table relation \"%s\"",
                             RelationGetRelationName(rel))));
     }
 
 
     /* Allocate workspace and zero all fields */
     cstate = (CopyToStateData *) palloc0(sizeof(CopyToStateData));
 
     /*
      * We allocate everything used by a cstate in a new memory context. This
      * avoids memory leaks during repeated use of COPY in a query.
      */
     cstate->copycontext = AllocSetContextCreate(CurrentMemoryContext,
                                                 "COPY",
                                                 ALLOCSET_DEFAULT_SIZES);
 
     oldcontext = MemoryContextSwitchTo(cstate->copycontext);
 
     /* Extract options from the statement node tree */
     ProcessCopyOptions(pstate, &cstate->opts, false /* is_from */ , options);
 
     /* Process the source/target relation or query */
     if (rel)
     {
         Assert(!raw_query);
 
         cstate->rel = rel;
 
         tupDesc = RelationGetDescr(cstate->rel);
     }
     else
     {
         List       *rewritten;
         Query      *query;
         PlannedStmt *plan;
         DestReceiver *dest;
 
         cstate->rel = NULL;
 
         /*
          * Run parse analysis and rewrite.  Note this also acquires sufficient
          * locks on the source table(s).
          *
          * Because the parser and planner tend to scribble on their input, we
          * make a preliminary copy of the source querytree.  This prevents
          * problems in the case that the COPY is in a portal or plpgsql
          * function and is executed repeatedly.  (See also the same hack in
          * DECLARE CURSOR and PREPARE.)  XXX FIXME someday.
          */
         rewritten = pg_analyze_and_rewrite(copyObject(raw_query),
                                            pstate->p_sourcetext, NULL, 0,
                                            NULL);
 
         /* check that we got back something we can work with */
         if (rewritten == NIL)
         {
             ereport(ERROR,
                     (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                      errmsg("DO INSTEAD NOTHING rules are not supported for COPY")));
         }
         else if (list_length(rewritten) > 1)
         {
             ListCell   *lc;
 
             /* examine queries to determine which error message to issue */
             foreach(lc, rewritten)
             {
                 Query      *q = lfirst_node(Query, lc);
 
                 if (q->querySource == QSRC_QUAL_INSTEAD_RULE)
                     ereport(ERROR,
                             (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                              errmsg("conditional DO INSTEAD rules are not supported for COPY")));
                 if (q->querySource == QSRC_NON_INSTEAD_RULE)
                     ereport(ERROR,
                             (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                              errmsg("DO ALSO rules are not supported for the COPY")));
             }
 
             ereport(ERROR,
                     (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                      errmsg("multi-statement DO INSTEAD rules are not supported for COPY")));
         }
 
         query = linitial_node(Query, rewritten);
 
         /* The grammar allows SELECT INTO, but we don't support that */
         if (query->utilityStmt != NULL &&
             IsA(query->utilityStmt, CreateTableAsStmt))
             ereport(ERROR,
                     (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                      errmsg("COPY (SELECT INTO) is not supported")));
 
         Assert(query->utilityStmt == NULL);
 
         /*
          * Similarly the grammar doesn't enforce the presence of a RETURNING
          * clause, but this is required here.
          */
         if (query->commandType != CMD_SELECT &&
             query->returningList == NIL)
         {
             Assert(query->commandType == CMD_INSERT ||
                    query->commandType == CMD_UPDATE ||
                    query->commandType == CMD_DELETE);
 
             ereport(ERROR,
                     (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                      errmsg("COPY query must have a RETURNING clause")));
         }
 
         /* plan the query */
         plan = pg_plan_query(query, pstate->p_sourcetext,
                              CURSOR_OPT_PARALLEL_OK, NULL);
 
         /*
          * With row-level security and a user using "COPY relation TO", we
          * have to convert the "COPY relation TO" to a query-based COPY (eg:
          * "COPY (SELECT * FROM relation) TO"), to allow the rewriter to add
          * in any RLS clauses.
          *
          * When this happens, we are passed in the relid of the originally
          * found relation (which we have locked).  As the planner will look up
          * the relation again, we double-check here to make sure it found the
          * same one that we have locked.
          */
         if (queryRelId != InvalidOid)
         {
             /*
              * Note that with RLS involved there may be multiple relations,
              * and while the one we need is almost certainly first, we don't
              * make any guarantees of that in the planner, so check the whole
              * list and make sure we find the original relation.
              */
             if (!list_member_oid(plan->relationOids, queryRelId))
                 ereport(ERROR,
                         (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
                          errmsg("relation referenced by COPY statement has changed")));
         }
 
         /*
          * Use a snapshot with an updated command ID to ensure this query sees
          * results of any previously executed queries.
          */
         PushCopiedSnapshot(GetActiveSnapshot());
         UpdateActiveSnapshotCommandId();
 
         /* Create dest receiver for COPY OUT */
         dest = CreateDestReceiver(DestCopyOut);
         ((DR_copy *) dest)->cstate = cstate;
 
         /* Create a QueryDesc requesting no output */
         cstate->queryDesc = CreateQueryDesc(plan, pstate->p_sourcetext,
                                             GetActiveSnapshot(),
                                             InvalidSnapshot,
                                             dest, NULL, NULL, 0);
 
         /*
          * Call ExecutorStart to prepare the plan for execution.
          *
          * ExecutorStart computes a result tupdesc for us
          */
         ExecutorStart(cstate->queryDesc, 0);
 
         tupDesc = cstate->queryDesc->tupDesc;
     }
 
     /* Generate or convert list of attributes to process */
     cstate->attnumlist = CopyGetAttnums(tupDesc, cstate->rel, attnamelist);
 
     num_phys_attrs = tupDesc->natts;
 
     /* Convert FORCE_QUOTE name list to per-column flags, check validity */
     cstate->opts.force_quote_flags = (bool *) palloc0(num_phys_attrs * sizeof(bool));
     if (cstate->opts.force_quote_all)
     {
         int         i;
 
         for (i = 0; i < num_phys_attrs; i++)
             cstate->opts.force_quote_flags[i] = true;
     }
     else if (cstate->opts.force_quote)
     {
         List       *attnums;
         ListCell   *cur;
 
         attnums = CopyGetAttnums(tupDesc, cstate->rel, cstate->opts.force_quote);
 
         foreach(cur, attnums)
         {
             int         attnum = lfirst_int(cur);
             Form_pg_attribute attr = TupleDescAttr(tupDesc, attnum - 1);
 
             if (!list_member_int(cstate->attnumlist, attnum))
                 ereport(ERROR,
                         (errcode(ERRCODE_INVALID_COLUMN_REFERENCE),
                          errmsg("FORCE_QUOTE column \"%s\" not referenced by COPY",
                                 NameStr(attr->attname))));
             cstate->opts.force_quote_flags[attnum - 1] = true;
         }
     }
 
     /* Convert FORCE_NOT_NULL name list to per-column flags, check validity */
     cstate->opts.force_notnull_flags = (bool *) palloc0(num_phys_attrs * sizeof(bool));
     if (cstate->opts.force_notnull)
     {
         List       *attnums;
         ListCell   *cur;
 
         attnums = CopyGetAttnums(tupDesc, cstate->rel, cstate->opts.force_notnull);
 
         foreach(cur, attnums)
         {
             int         attnum = lfirst_int(cur);
             Form_pg_attribute attr = TupleDescAttr(tupDesc, attnum - 1);
 
             if (!list_member_int(cstate->attnumlist, attnum))
                 ereport(ERROR,
                         (errcode(ERRCODE_INVALID_COLUMN_REFERENCE),
                          errmsg("FORCE_NOT_NULL column \"%s\" not referenced by COPY",
                                 NameStr(attr->attname))));
             cstate->opts.force_notnull_flags[attnum - 1] = true;
         }
     }
 
     /* Convert FORCE_NULL name list to per-column flags, check validity */
     cstate->opts.force_null_flags = (bool *) palloc0(num_phys_attrs * sizeof(bool));
     if (cstate->opts.force_null)
     {
         List       *attnums;
         ListCell   *cur;
 
         attnums = CopyGetAttnums(tupDesc, cstate->rel, cstate->opts.force_null);
 
         foreach(cur, attnums)
         {
             int         attnum = lfirst_int(cur);
             Form_pg_attribute attr = TupleDescAttr(tupDesc, attnum - 1);
 
             if (!list_member_int(cstate->attnumlist, attnum))
                 ereport(ERROR,
                         (errcode(ERRCODE_INVALID_COLUMN_REFERENCE),
                          errmsg("FORCE_NULL column \"%s\" not referenced by COPY",
                                 NameStr(attr->attname))));
             cstate->opts.force_null_flags[attnum - 1] = true;
         }
     }
 
     /* Use client encoding when ENCODING option is not specified. */
     if (cstate->opts.file_encoding < 0)
         cstate->file_encoding = pg_get_client_encoding();
     else
         cstate->file_encoding = cstate->opts.file_encoding;
 
     /*
      * Set up encoding conversion info.  Even if the file and server encodings
      * are the same, we must apply pg_any_to_server() to validate data in
      * multibyte encodings.
      */
     cstate->need_transcoding =
         (cstate->file_encoding != GetDatabaseEncoding() ||
          pg_database_encoding_max_length() > 1);
     /* See Multibyte encoding comment above */
     cstate->encoding_embeds_ascii = PG_ENCODING_IS_CLIENT_ONLY(cstate->file_encoding);
 
     cstate->copy_dest = COPY_FILE;  /* default */
 
     MemoryContextSwitchTo(oldcontext);
 
     if (pipe)
     {
         progress_vals[1] = PROGRESS_COPY_TYPE_PIPE;
 
         Assert(!is_program);    /* the grammar does not allow this */
         if (whereToSendOutput != DestRemote)
             cstate->copy_file = stdout;
     }
     else
     {
         cstate->filename = pstrdup(filename);
         cstate->is_program = is_program;
 
         if (is_program)
         {
             progress_vals[1] = PROGRESS_COPY_TYPE_PROGRAM;
             cstate->copy_file = OpenPipeStream(cstate->filename, PG_BINARY_W);
             if (cstate->copy_file == NULL)
                 ereport(ERROR,
                         (errcode_for_file_access(),
                          errmsg("could not execute command \"%s\": %m",
                                 cstate->filename)));
         }
         else
         {
             mode_t      oumask; /* Pre-existing umask value */
             struct stat st;
 
             progress_vals[1] = PROGRESS_COPY_TYPE_FILE;
 
             /*
              * Prevent write to relative path ... too easy to shoot oneself in
              * the foot by overwriting a database file ...
              */
             if (!is_absolute_path(filename))
                 ereport(ERROR,
                         (errcode(ERRCODE_INVALID_NAME),
                          errmsg("relative path not allowed for COPY to file")));
 
             oumask = umask(S_IWGRP | S_IWOTH);
             PG_TRY();
             {
                 cstate->copy_file = AllocateFile(cstate->filename, PG_BINARY_W);
             }
             PG_FINALLY();
             {
                 umask(oumask);
             }
             PG_END_TRY();
             if (cstate->copy_file == NULL)
             {
                 /* copy errno because ereport subfunctions might change it */
                 int         save_errno = errno;
 
                 ereport(ERROR,
                         (errcode_for_file_access(),
                          errmsg("could not open file \"%s\" for writing: %m",
                                 cstate->filename),
                          (save_errno == ENOENT || save_errno == EACCES) ?
                          errhint("COPY TO instructs the PostgreSQL server process to write a file. "
                                  "You may want a client-side facility such as psql's \\copy.") : 0));
             }
 
             if (fstat(fileno(cstate->copy_file), &st))
                 ereport(ERROR,
                         (errcode_for_file_access(),
                          errmsg("could not stat file \"%s\": %m",
                                 cstate->filename)));
 
             if (S_ISDIR(st.st_mode))
                 ereport(ERROR,
                         (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                          errmsg("\"%s\" is a directory", cstate->filename)));
         }
     }
 
     /* initialize progress */
     pgstat_progress_start_command(PROGRESS_COMMAND_COPY,
                                   cstate->rel ? RelationGetRelid(cstate->rel) : InvalidOid);
     pgstat_progress_update_multi_param(2, progress_cols, progress_vals);
 
     cstate->bytes_processed = 0;
 
     MemoryContextSwitchTo(oldcontext);
 
     return cstate;
 }

◆ CopyFrom()

uint64 CopyFrom ( CopyFromState cstate )

Definition at line 525 of file copyfrom.c.

Referenced by copy_table(), and DoCopy().

 {
     ResultRelInfo *resultRelInfo;
     ResultRelInfo *target_resultRelInfo;
     ResultRelInfo *prevResultRelInfo = NULL;
     EState     *estate = CreateExecutorState(); /* for ExecConstraints() */
     ModifyTableState *mtstate;
     ExprContext *econtext;
     TupleTableSlot *singleslot = NULL;
     MemoryContext oldcontext = CurrentMemoryContext;
 
     PartitionTupleRouting *proute = NULL;
     ErrorContextCallback errcallback;
     CommandId   mycid = GetCurrentCommandId(true);
     int         ti_options = 0; /* start with default options for insert */
     BulkInsertState bistate = NULL;
     CopyInsertMethod insertMethod;
     CopyMultiInsertInfo multiInsertInfo = {0};  /* pacify compiler */
     int64       processed = 0;
     int64       excluded = 0;
     bool        has_before_insert_row_trig;
     bool        has_instead_insert_row_trig;
     bool        leafpart_use_multi_insert = false;
 
     Assert(cstate->rel);
     Assert(list_length(cstate->range_table) == 1);
 
     /*
      * The target must be a plain, foreign, or partitioned relation, or have
      * an INSTEAD OF INSERT row trigger.  (Currently, such triggers are only
      * allowed on views, so we only hint about them in the view case.)
      */
     if (cstate->rel->rd_rel->relkind != RELKIND_RELATION &&
         cstate->rel->rd_rel->relkind != RELKIND_FOREIGN_TABLE &&
         cstate->rel->rd_rel->relkind != RELKIND_PARTITIONED_TABLE &&
         !(cstate->rel->trigdesc &&
           cstate->rel->trigdesc->trig_insert_instead_row))
     {
         if (cstate->rel->rd_rel->relkind == RELKIND_VIEW)
             ereport(ERROR,
                     (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                      errmsg("cannot copy to view \"%s\"",
                             RelationGetRelationName(cstate->rel)),
                      errhint("To enable copying to a view, provide an INSTEAD OF INSERT trigger.")));
         else if (cstate->rel->rd_rel->relkind == RELKIND_MATVIEW)
             ereport(ERROR,
                     (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                      errmsg("cannot copy to materialized view \"%s\"",
                             RelationGetRelationName(cstate->rel))));
         else if (cstate->rel->rd_rel->relkind == RELKIND_SEQUENCE)
             ereport(ERROR,
                     (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                      errmsg("cannot copy to sequence \"%s\"",
                             RelationGetRelationName(cstate->rel))));
         else
             ereport(ERROR,
                     (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                      errmsg("cannot copy to non-table relation \"%s\"",
                             RelationGetRelationName(cstate->rel))));
     }
 
     /*
      * If the target file is new-in-transaction, we assume that checking FSM
      * for free space is a waste of time.  This could possibly be wrong, but
      * it's unlikely.
      */
     if (RELKIND_HAS_STORAGE(cstate->rel->rd_rel->relkind) &&
         (cstate->rel->rd_createSubid != InvalidSubTransactionId ||
          cstate->rel->rd_firstRelfilenodeSubid != InvalidSubTransactionId))
         ti_options |= TABLE_INSERT_SKIP_FSM;
 
     /*
      * Optimize if new relfilenode was created in this subxact or one of its
      * committed children and we won't see those rows later as part of an
      * earlier scan or command. The subxact test ensures that if this subxact
      * aborts then the frozen rows won't be visible after xact cleanup.  Note
      * that the stronger test of exactly which subtransaction created it is
      * crucial for correctness of this optimization. The test for an earlier
      * scan or command tolerates false negatives. FREEZE causes other sessions
      * to see rows they would not see under MVCC, and a false negative merely
      * spreads that anomaly to the current session.
      */
     if (cstate->opts.freeze)
     {
         /*
          * We currently disallow COPY FREEZE on partitioned tables.  The
          * reason for this is that we've simply not yet opened the partitions
          * to determine if the optimization can be applied to them.  We could
          * go and open them all here, but doing so may be quite a costly
          * overhead for small copies.  In any case, we may just end up routing
          * tuples to a small number of partitions.  It seems better just to
          * raise an ERROR for partitioned tables.
          */
         if (cstate->rel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE)
         {
             ereport(ERROR,
                     (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                      errmsg("cannot perform COPY FREEZE on a partitioned table")));
         }
 
         /*
          * Tolerate one registration for the benefit of FirstXactSnapshot.
          * Scan-bearing queries generally create at least two registrations,
          * though relying on that is fragile, as is ignoring ActiveSnapshot.
          * Clear CatalogSnapshot to avoid counting its registration.  We'll
          * still detect ongoing catalog scans, each of which separately
          * registers the snapshot it uses.
          */
         InvalidateCatalogSnapshot();
         if (!ThereAreNoPriorRegisteredSnapshots() || !ThereAreNoReadyPortals())
             ereport(ERROR,
                     (errcode(ERRCODE_INVALID_TRANSACTION_STATE),
                      errmsg("cannot perform COPY FREEZE because of prior transaction activity")));
 
         if (cstate->rel->rd_createSubid != GetCurrentSubTransactionId() &&
             cstate->rel->rd_newRelfilenodeSubid != GetCurrentSubTransactionId())
             ereport(ERROR,
                     (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
                      errmsg("cannot perform COPY FREEZE because the table was not created or truncated in the current subtransaction")));
 
         ti_options |= TABLE_INSERT_FROZEN;
     }
 
     /*
      * We need a ResultRelInfo so we can use the regular executor's
      * index-entry-making machinery.  (There used to be a huge amount of code
      * here that basically duplicated execUtils.c ...)
      */
     ExecInitRangeTable(estate, cstate->range_table);
     resultRelInfo = target_resultRelInfo = makeNode(ResultRelInfo);
     ExecInitResultRelation(estate, resultRelInfo, 1);
 
     /* Verify the named relation is a valid target for INSERT */
     CheckValidResultRel(resultRelInfo, CMD_INSERT);
 
     ExecOpenIndices(resultRelInfo, false);
 
     /*
      * Set up a ModifyTableState so we can let FDW(s) init themselves for
      * foreign-table result relation(s).
      */
     mtstate = makeNode(ModifyTableState);
     mtstate->ps.plan = NULL;
     mtstate->ps.state = estate;
     mtstate->operation = CMD_INSERT;
     mtstate->mt_nrels = 1;
     mtstate->resultRelInfo = resultRelInfo;
     mtstate->rootResultRelInfo = resultRelInfo;
 
     if (resultRelInfo->ri_FdwRoutine != NULL &&
         resultRelInfo->ri_FdwRoutine->BeginForeignInsert != NULL)
         resultRelInfo->ri_FdwRoutine->BeginForeignInsert(mtstate,
                                                          resultRelInfo);
 
     /* Prepare to catch AFTER triggers. */
     AfterTriggerBeginQuery();
 
     /*
      * If there are any triggers with transition tables on the named relation,
      * we need to be prepared to capture transition tuples.
      *
      * Because partition tuple routing would like to know about whether
      * transition capture is active, we also set it in mtstate, which is
      * passed to ExecFindPartition() below.
      */
     cstate->transition_capture = mtstate->mt_transition_capture =
         MakeTransitionCaptureState(cstate->rel->trigdesc,
                                    RelationGetRelid(cstate->rel),
                                    CMD_INSERT);
 
     /*
      * If the named relation is a partitioned table, initialize state for
      * CopyFrom tuple routing.
      */
     if (cstate->rel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE)
         proute = ExecSetupPartitionTupleRouting(estate, cstate->rel);
 
     if (cstate->whereClause)
         cstate->qualexpr = ExecInitQual(castNode(List, cstate->whereClause),
                                         &mtstate->ps);
 
     /*
      * It's generally more efficient to prepare a bunch of tuples for
      * insertion, and insert them in one table_multi_insert() call, than call
      * table_tuple_insert() separately for every tuple. However, there are a
      * number of reasons why we might not be able to do this.  These are
      * explained below.
      */
     if (resultRelInfo->ri_TrigDesc != NULL &&
         (resultRelInfo->ri_TrigDesc->trig_insert_before_row ||
          resultRelInfo->ri_TrigDesc->trig_insert_instead_row))
     {
         /*
          * Can't support multi-inserts when there are any BEFORE/INSTEAD OF
          * triggers on the table. Such triggers might query the table we're
          * inserting into and act differently if the tuples that have already
          * been processed and prepared for insertion are not there.
          */
         insertMethod = CIM_SINGLE;
     }
     else if (proute != NULL && resultRelInfo->ri_TrigDesc != NULL &&
              resultRelInfo->ri_TrigDesc->trig_insert_new_table)
     {
         /*
          * For partitioned tables we can't support multi-inserts when there
          * are any statement level insert triggers. It might be possible to
          * allow partitioned tables with such triggers in the future, but for
          * now, CopyMultiInsertInfoFlush expects that any before row insert
          * and statement level insert triggers are on the same relation.
          */
         insertMethod = CIM_SINGLE;
     }
     else if (resultRelInfo->ri_FdwRoutine != NULL ||
              cstate->volatile_defexprs)
     {
         /*
          * Can't support multi-inserts to foreign tables or if there are any
          * volatile default expressions in the table.  Similarly to the
          * trigger case above, such expressions may query the table we're
          * inserting into.
          *
          * Note: It does not matter if any partitions have any volatile
          * default expressions as we use the defaults from the target of the
          * COPY command.
          */
         insertMethod = CIM_SINGLE;
     }
     else if (contain_volatile_functions(cstate->whereClause))
     {
         /*
          * Can't support multi-inserts if there are any volatile function
          * expressions in WHERE clause.  Similarly to the trigger case above,
          * such expressions may query the table we're inserting into.
          */
         insertMethod = CIM_SINGLE;
     }
     else
     {
         /*
          * For partitioned tables, we may still be able to perform bulk
          * inserts.  However, the possibility of this depends on which types
          * of triggers exist on the partition.  We must disable bulk inserts
          * if the partition is a foreign table or it has any before row insert
          * or insert instead triggers (same as we checked above for the parent
          * table).  Since the partition's resultRelInfos are initialized only
          * when we actually need to insert the first tuple into them, we must
          * have the intermediate insert method of CIM_MULTI_CONDITIONAL to
          * flag that we must later determine if we can use bulk-inserts for
          * the partition being inserted into.
          */
         if (proute)
             insertMethod = CIM_MULTI_CONDITIONAL;
         else
             insertMethod = CIM_MULTI;
 
         CopyMultiInsertInfoInit(&multiInsertInfo, resultRelInfo, cstate,
                                 estate, mycid, ti_options);
     }
 
     /*
      * If not using batch mode (which allocates slots as needed) set up a
      * tuple slot too. When inserting into a partitioned table, we also need
      * one, even if we might batch insert, to read the tuple in the root
      * partition's form.
      */
     if (insertMethod == CIM_SINGLE || insertMethod == CIM_MULTI_CONDITIONAL)
     {
         singleslot = table_slot_create(resultRelInfo->ri_RelationDesc,
                                        &estate->es_tupleTable);
         bistate = GetBulkInsertState();
     }
 
     has_before_insert_row_trig = (resultRelInfo->ri_TrigDesc &&
                                   resultRelInfo->ri_TrigDesc->trig_insert_before_row);
 
     has_instead_insert_row_trig = (resultRelInfo->ri_TrigDesc &&
                                    resultRelInfo->ri_TrigDesc->trig_insert_instead_row);
 
     /*
      * Check BEFORE STATEMENT insertion triggers. It's debatable whether we
      * should do this for COPY, since it's not really an "INSERT" statement as
      * such. However, executing these triggers maintains consistency with the
      * EACH ROW triggers that we already fire on COPY.
      */
     ExecBSInsertTriggers(estate, resultRelInfo);
 
     econtext = GetPerTupleExprContext(estate);
 
     /* Set up callback to identify error line number */
     errcallback.callback = CopyFromErrorCallback;
     errcallback.arg = (void *) cstate;
     errcallback.previous = error_context_stack;
     error_context_stack = &errcallback;
 
     for (;;)
     {
         TupleTableSlot *myslot;
         bool        skip_tuple;
 
         CHECK_FOR_INTERRUPTS();
 
         /*
          * Reset the per-tuple exprcontext. We do this after every tuple, to
          * clean-up after expression evaluations etc.
          */
         ResetPerTupleExprContext(estate);
 
         /* select slot to (initially) load row into */
         if (insertMethod == CIM_SINGLE || proute)
         {
             myslot = singleslot;
             Assert(myslot != NULL);
         }
         else
         {
             Assert(resultRelInfo == target_resultRelInfo);
             Assert(insertMethod == CIM_MULTI);
 
             myslot = CopyMultiInsertInfoNextFreeSlot(&multiInsertInfo,
                                                      resultRelInfo);
         }
 
         /*
          * Switch to per-tuple context before calling NextCopyFrom, which does
          * evaluate default expressions etc. and requires per-tuple context.
          */
         MemoryContextSwitchTo(GetPerTupleMemoryContext(estate));
 
         ExecClearTuple(myslot);
 
         /* Directly store the values/nulls array in the slot */
         if (!NextCopyFrom(cstate, econtext, myslot->tts_values, myslot->tts_isnull))
             break;
 
         ExecStoreVirtualTuple(myslot);
 
         /*
          * Constraints and where clause might reference the tableoid column,
          * so (re-)initialize tts_tableOid before evaluating them.
          */
         myslot->tts_tableOid = RelationGetRelid(target_resultRelInfo->ri_RelationDesc);
 
         /* Triggers and stuff need to be invoked in query context. */
         MemoryContextSwitchTo(oldcontext);
 
         if (cstate->whereClause)
         {
             econtext->ecxt_scantuple = myslot;
             /* Skip items that don't match COPY's WHERE clause */
             if (!ExecQual(cstate->qualexpr, econtext))
             {
                 /*
                  * Report that this tuple was filtered out by the WHERE
                  * clause.
                  */
                 pgstat_progress_update_param(PROGRESS_COPY_TUPLES_EXCLUDED,
                                              ++excluded);
                 continue;
             }
         }
 
         /* Determine the partition to insert the tuple into */
         if (proute)
         {
             TupleConversionMap *map;
 
             /*
              * Attempt to find a partition suitable for this tuple.
              * ExecFindPartition() will raise an error if none can be found or
              * if the found partition is not suitable for INSERTs.
              */
             resultRelInfo = ExecFindPartition(mtstate, target_resultRelInfo,
                                               proute, myslot, estate);
 
             if (prevResultRelInfo != resultRelInfo)
             {
                 /* Determine which triggers exist on this partition */
                 has_before_insert_row_trig = (resultRelInfo->ri_TrigDesc &&
                                               resultRelInfo->ri_TrigDesc->trig_insert_before_row);
 
                 has_instead_insert_row_trig = (resultRelInfo->ri_TrigDesc &&
                                                resultRelInfo->ri_TrigDesc->trig_insert_instead_row);
 
                 /*
                  * Disable multi-inserts when the partition has BEFORE/INSTEAD
                  * OF triggers, or if the partition is a foreign partition.
                  */
                 leafpart_use_multi_insert = insertMethod == CIM_MULTI_CONDITIONAL &&
                     !has_before_insert_row_trig &&
                     !has_instead_insert_row_trig &&
                     resultRelInfo->ri_FdwRoutine == NULL;
 
                 /* Set the multi-insert buffer to use for this partition. */
                 if (leafpart_use_multi_insert)
                 {
                     if (resultRelInfo->ri_CopyMultiInsertBuffer == NULL)
                         CopyMultiInsertInfoSetupBuffer(&multiInsertInfo,
                                                        resultRelInfo);
                 }
                 else if (insertMethod == CIM_MULTI_CONDITIONAL &&
                          !CopyMultiInsertInfoIsEmpty(&multiInsertInfo))
                 {
                     /*
                      * Flush pending inserts if this partition can't use
                      * batching, so rows are visible to triggers etc.
                      */
                     CopyMultiInsertInfoFlush(&multiInsertInfo, resultRelInfo);
                 }
 
                 if (bistate != NULL)
                     ReleaseBulkInsertStatePin(bistate);
                 prevResultRelInfo = resultRelInfo;
             }
 
             /*
              * If we're capturing transition tuples, we might need to convert
              * from the partition rowtype to root rowtype. But if there are no
              * BEFORE triggers on the partition that could change the tuple,
              * we can just remember the original unconverted tuple to avoid a
              * needless round trip conversion.
              */
             if (cstate->transition_capture != NULL)
                 cstate->transition_capture->tcs_original_insert_tuple =
                     !has_before_insert_row_trig ? myslot : NULL;
 
             /*
              * We might need to convert from the root rowtype to the partition
              * rowtype.
              */
             map = resultRelInfo->ri_RootToPartitionMap;
             if (insertMethod == CIM_SINGLE || !leafpart_use_multi_insert)
             {
                 /* non batch insert */
                 if (map != NULL)
                 {
                     TupleTableSlot *new_slot;
 
                     new_slot = resultRelInfo->ri_PartitionTupleSlot;
                     myslot = execute_attr_map_slot(map->attrMap, myslot, new_slot);
                 }
             }
             else
             {
                 /*
                  * Prepare to queue up tuple for later batch insert into
                  * current partition.
                  */
                 TupleTableSlot *batchslot;
 
                 /* no other path available for partitioned table */
                 Assert(insertMethod == CIM_MULTI_CONDITIONAL);
 
                 batchslot = CopyMultiInsertInfoNextFreeSlot(&multiInsertInfo,
                                                             resultRelInfo);
 
                 if (map != NULL)
                     myslot = execute_attr_map_slot(map->attrMap, myslot,
                                                    batchslot);
                 else
                 {
                     /*
                      * This looks more expensive than it is (Believe me, I
                      * optimized it away. Twice.). The input is in virtual
                      * form, and we'll materialize the slot below - for most
                      * slot types the copy performs the work materialization
                      * would later require anyway.
                      */
                     ExecCopySlot(batchslot, myslot);
                     myslot = batchslot;
                 }
             }
 
             /* ensure that triggers etc see the right relation  */
             myslot->tts_tableOid = RelationGetRelid(resultRelInfo->ri_RelationDesc);
         }
 
         skip_tuple = false;
 
         /* BEFORE ROW INSERT Triggers */
         if (has_before_insert_row_trig)
         {
             if (!ExecBRInsertTriggers(estate, resultRelInfo, myslot))
                 skip_tuple = true;  /* "do nothing" */
         }
 
         if (!skip_tuple)
         {
             /*
              * If there is an INSTEAD OF INSERT ROW trigger, let it handle the
              * tuple.  Otherwise, proceed with inserting the tuple into the
              * table or foreign table.
              */
             if (has_instead_insert_row_trig)
             {
                 ExecIRInsertTriggers(estate, resultRelInfo, myslot);
             }
             else
             {
                 /* Compute stored generated columns */
                 if (resultRelInfo->ri_RelationDesc->rd_att->constr &&
                     resultRelInfo->ri_RelationDesc->rd_att->constr->has_generated_stored)
                     ExecComputeStoredGenerated(resultRelInfo, estate, myslot,
                                                CMD_INSERT);
 
                 /*
                  * If the target is a plain table, check the constraints of
                  * the tuple.
                  */
                 if (resultRelInfo->ri_FdwRoutine == NULL &&
                     resultRelInfo->ri_RelationDesc->rd_att->constr)
                     ExecConstraints(resultRelInfo, myslot, estate);
 
                 /*
                  * Also check the tuple against the partition constraint, if
                  * there is one; except that if we got here via tuple-routing,
                  * we don't need to if there's no BR trigger defined on the
                  * partition.
                  */
                 if (resultRelInfo->ri_RelationDesc->rd_rel->relispartition &&
                     (proute == NULL || has_before_insert_row_trig))
                     ExecPartitionCheck(resultRelInfo, myslot, estate, true);
 
                 /* Store the slot in the multi-insert buffer, when enabled. */
                 if (insertMethod == CIM_MULTI || leafpart_use_multi_insert)
                 {
                     /*
                      * The slot previously might point into the per-tuple
                      * context. For batching it needs to be longer lived.
                      */
                     ExecMaterializeSlot(myslot);
 
                     /* Add this tuple to the tuple buffer */
                     CopyMultiInsertInfoStore(&multiInsertInfo,
                                              resultRelInfo, myslot,
                                              cstate->line_buf.len,
                                              cstate->cur_lineno);
 
                     /*
                      * If enough inserts have queued up, then flush all
                      * buffers out to their tables.
                      */
                     if (CopyMultiInsertInfoIsFull(&multiInsertInfo))
                         CopyMultiInsertInfoFlush(&multiInsertInfo, resultRelInfo);
                 }
                 else
                 {
                     List       *recheckIndexes = NIL;
 
                     /* OK, store the tuple */
                     if (resultRelInfo->ri_FdwRoutine != NULL)
                     {
                         myslot = resultRelInfo->ri_FdwRoutine->ExecForeignInsert(estate,
                                                                                  resultRelInfo,
                                                                                  myslot,
                                                                                  NULL);
 
                         if (myslot == NULL) /* "do nothing" */
                             continue;   /* next tuple please */
 
                         /*
                          * AFTER ROW Triggers might reference the tableoid
                          * column, so (re-)initialize tts_tableOid before
                          * evaluating them.
                          */
                         myslot->tts_tableOid = RelationGetRelid(resultRelInfo->ri_RelationDesc);
                     }
                     else
                     {
                         /* OK, store the tuple and create index entries for it */
                         table_tuple_insert(resultRelInfo->ri_RelationDesc,
                                            myslot, mycid, ti_options, bistate);
 
                         if (resultRelInfo->ri_NumIndices > 0)
                             recheckIndexes = ExecInsertIndexTuples(resultRelInfo,
                                                                    myslot,
                                                                    estate,
                                                                    false,
                                                                    false,
                                                                    NULL,
                                                                    NIL);
                     }
 
                     /* AFTER ROW INSERT Triggers */
                     ExecARInsertTriggers(estate, resultRelInfo, myslot,
                                          recheckIndexes, cstate->transition_capture);
 
                     list_free(recheckIndexes);
                 }
             }
 
             /*
              * We count only tuples not suppressed by a BEFORE INSERT trigger
              * or FDW; this is the same definition used by nodeModifyTable.c
              * for counting tuples inserted by an INSERT command.  Update
              * progress of the COPY command as well.
              */
             pgstat_progress_update_param(PROGRESS_COPY_TUPLES_PROCESSED,
                                          ++processed);
         }
     }
 
     /* Flush any remaining buffered tuples */
     if (insertMethod != CIM_SINGLE)
     {
         if (!CopyMultiInsertInfoIsEmpty(&multiInsertInfo))
             CopyMultiInsertInfoFlush(&multiInsertInfo, NULL);
     }
 
     /* Done, clean up */
     error_context_stack = errcallback.previous;
 
     if (bistate != NULL)
         FreeBulkInsertState(bistate);
 
     MemoryContextSwitchTo(oldcontext);
 
     /* Execute AFTER STATEMENT insertion triggers */
     ExecASInsertTriggers(estate, target_resultRelInfo, cstate->transition_capture);
 
     /* Handle queued AFTER triggers */
     AfterTriggerEndQuery(estate);
 
     ExecResetTupleTable(estate->es_tupleTable, false);
 
     /* Allow the FDW to shut down */
     if (target_resultRelInfo->ri_FdwRoutine != NULL &&
         target_resultRelInfo->ri_FdwRoutine->EndForeignInsert != NULL)
         target_resultRelInfo->ri_FdwRoutine->EndForeignInsert(estate,
                                                               target_resultRelInfo);
 
     /* Tear down the multi-insert buffer data */
     if (insertMethod != CIM_SINGLE)
         CopyMultiInsertInfoCleanup(&multiInsertInfo);
 
     /* Close all the partitioned tables, leaf partitions, and their indices */
     if (proute)
         ExecCleanupTupleRouting(mtstate, proute);
 
     /* Close the result relations, including any trigger target relations */
     ExecCloseResultRelations(estate);
     ExecCloseRangeTableRelations(estate);
 
     FreeExecutorState(estate);
 
     return processed;
 }

◆ CopyFromErrorCallback()

void CopyFromErrorCallback ( void * arg )

Definition at line 115 of file copyfrom.c.

References CopyFormatOptions::binary, CopyFromStateData::cur_attname, CopyFromStateData::cur_attval, CopyFromStateData::cur_lineno, CopyFromStateData::cur_relname, StringInfoData::data, errcontext, limit_printout_length(), CopyFromStateData::line_buf, CopyFromStateData::line_buf_valid, CopyFromStateData::opts, pfree(), snprintf, and UINT64_FORMAT.

Referenced by CopyFrom(), file_acquire_sample_rows(), and fileIterateForeignScan().

 {
     CopyFromState cstate = (CopyFromState) arg;
     char        curlineno_str[32];
 
     snprintf(curlineno_str, sizeof(curlineno_str), UINT64_FORMAT,
              cstate->cur_lineno);
 
     if (cstate->opts.binary)
     {
         /* can't usefully display the data */
         if (cstate->cur_attname)
             errcontext("COPY %s, line %s, column %s",
                        cstate->cur_relname, curlineno_str,
                        cstate->cur_attname);
         else
             errcontext("COPY %s, line %s",
                        cstate->cur_relname, curlineno_str);
     }
     else
     {
         if (cstate->cur_attname && cstate->cur_attval)
         {
             /* error is relevant to a particular column */
             char       *attval;
 
             attval = limit_printout_length(cstate->cur_attval);
             errcontext("COPY %s, line %s, column %s: \"%s\"",
                        cstate->cur_relname, curlineno_str,
                        cstate->cur_attname, attval);
             pfree(attval);
         }
         else if (cstate->cur_attname)
         {
             /* error is relevant to a particular column, value is NULL */
             errcontext("COPY %s, line %s, column %s: null input",
                        cstate->cur_relname, curlineno_str,
                        cstate->cur_attname);
         }
         else
         {
             /*
              * Error is relevant to a particular line.
              *
              * If line_buf still contains the correct line, print it.
              */
             if (cstate->line_buf_valid)
             {
                 char       *lineval;
 
                 lineval = limit_printout_length(cstate->line_buf.data);
                 errcontext("COPY %s, line %s: \"%s\"",
                            cstate->cur_relname, curlineno_str, lineval);
                 pfree(lineval);
             }
             else
             {
                 errcontext("COPY %s, line %s",
                            cstate->cur_relname, curlineno_str);
             }
         }
     }
 }

◆ CopyGetAttnums()

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

Definition at line 686 of file copy.c.

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().

 {
     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;
 }

◆ CreateCopyDestReceiver()

DestReceiver* CreateCopyDestReceiver ( void )

Definition at line 1302 of file copyto.c.

References copy_dest_destroy(), copy_dest_receive(), copy_dest_shutdown(), copy_dest_startup(), DestCopyOut, and palloc().

Referenced by CreateDestReceiver().

 {
     DR_copy    *self = (DR_copy *) palloc(sizeof(DR_copy));
 
     self->pub.receiveSlot = copy_dest_receive;
     self->pub.rStartup = copy_dest_startup;
     self->pub.rShutdown = copy_dest_shutdown;
     self->pub.rDestroy = copy_dest_destroy;
     self->pub.mydest = DestCopyOut;
 
     self->cstate = NULL;        /* will be set later */
     self->processed = 0;
 
     return (DestReceiver *) self;
 }

◆ DoCopy()

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

Definition at line 64 of file copy.c.

References AccessShareLock, ACL_INSERT, ACL_SELECT, addNSItemToQuery(), addRangeTableEntryForRelation(), Assert, assign_expr_collations(), CopyStmt::attlist, BeginCopyFrom(), BeginCopyTo(), bms_add_member(), canonicalize_qual(), check_enable_rls(), coerce_to_boolean(), CopyFrom(), CopyGetAttnums(), cur, DoCopyTo(), EndCopyFrom(), EndCopyTo(), ereport, errcode(), errhint(), errmsg(), ERROR, eval_const_expressions(), ExecCheckRTPerms(), EXPR_KIND_COPY_WHERE, ColumnRef::fields, CopyStmt::filename, FirstLowInvalidHeapAttributeNumber, SelectStmt::fromClause, get_namespace_name(), GetUserId(), ResTarget::indirection, RangeTblEntry::insertedCols, InvalidOid, CopyStmt::is_from, is_member_of_role(), CopyStmt::is_program, lappend(), lfirst, lfirst_int, list_make1, ColumnRef::location, ResTarget::location, make_ands_implicit(), makeNode, makeRangeVar(), ResTarget::name, NIL, NoLock, CopyStmt::options, ParseState::p_rtable, ParseNamespaceItem::p_rte, PreventCommandIfReadOnly(), pstrdup(), CopyStmt::query, RelationData::rd_islocaltemp, CopyStmt::relation, RelationGetDescr, RelationGetNamespace, RelationGetRelationName, RelationGetRelid, RangeTblEntry::relid, RangeTblEntry::requiredPerms, RLS_ENABLED, RowExclusiveLock, select, RangeTblEntry::selectedCols, RawStmt::stmt, RawStmt::stmt_len, RawStmt::stmt_location, table_close(), table_openrv(), SelectStmt::targetList, transformExpr(), ResTarget::val, CopyStmt::whereClause, and XactReadOnly.

Referenced by standard_ProcessUtility().

 {
     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 (!is_member_of_role(GetUserId(), ROLE_PG_EXECUTE_SERVER_PROGRAM))
                 ereport(ERROR,
                         (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
                          errmsg("must be superuser or a member of the pg_execute_server_program role to COPY to or from an external program"),
                          errhint("Anyone can COPY to stdout or from stdin. "
                                  "psql's \\copy command also works for anyone.")));
         }
         else
         {
             if (is_from && !is_member_of_role(GetUserId(), ROLE_PG_READ_SERVER_FILES))
                 ereport(ERROR,
                         (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
                          errmsg("must be superuser or a member of the pg_read_server_files role to COPY from a file"),
                          errhint("Anyone can COPY to stdout or from stdin. "
                                  "psql's \\copy command also works for anyone.")));
 
             if (!is_from && !is_member_of_role(GetUserId(), ROLE_PG_WRITE_SERVER_FILES))
                 ereport(ERROR,
                         (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
                          errmsg("must be superuser or a member of the pg_write_server_files role to COPY to a file"),
                          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;
         RangeTblEntry *rte;
         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);
         rte = nsitem->p_rte;
         rte->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 = lfirst_int(cur) -
             FirstLowInvalidHeapAttributeNumber;
 
             if (is_from)
                 rte->insertedCols = bms_add_member(rte->insertedCols, attno);
             else
                 rte->selectedCols = bms_add_member(rte->selectedCols, attno);
         }
         ExecCheckRTPerms(pstate->p_rtable, 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(rte->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 'Value' node (see
                      * nodes/value.h) 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.
              */
             from = makeRangeVar(get_namespace_name(RelationGetNamespace(rel)),
                                 pstrdup(RelationGetRelationName(rel)),
                                 -1);
 
             /* 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,
                              stmt->attlist, stmt->options);
         *processed = DoCopyTo(cstate);  /* copy from database to file */
         EndCopyTo(cstate);
     }
 
     if (rel != NULL)
         table_close(rel, NoLock);
 }

◆ DoCopyTo()

uint64 DoCopyTo ( CopyToState cstate )

Definition at line 779 of file copyto.c.

References ALLOCSET_DEFAULT_SIZES, AllocSetContextCreate, attname, attnum, CopyToStateData::attnumlist, CopyFormatOptions::binary, BinarySignature, CHECK_FOR_INTERRUPTS, CopyAttributeOutCSV(), CopyOneRowTo(), CopySendChar(), CopySendData(), CopySendEndOfRow(), CopySendInt16(), CopySendInt32(), cur, CurrentMemoryContext, CopyFormatOptions::delim, QueryDesc::dest, DestRemote, ExecDropSingleTupleTableSlot(), ExecutorRun(), CopyToStateData::fe_msgbuf, CopyToStateData::file_encoding, CopyToStateData::filename, fmgr_info(), ForwardScanDirection, GetActiveSnapshot(), getTypeBinaryOutputInfo(), getTypeOutputInfo(), CopyFormatOptions::header_line, lfirst_int, list_length(), makeStringInfo(), MemoryContextDelete(), NameStr, TupleDescData::natts, CopyToStateData::need_transcoding, CopyFormatOptions::null_print, CopyFormatOptions::null_print_client, CopyFormatOptions::null_print_len, CopyToStateData::opts, CopyToStateData::out_functions, palloc(), pg_server_to_any(), pgstat_progress_update_param(), PROGRESS_COPY_TUPLES_PROCESSED, CopyToStateData::queryDesc, CopyToStateData::rel, RelationGetDescr, CopyToStateData::rowcontext, SendCopyBegin(), SendCopyEnd(), slot_getallattrs(), table_beginscan(), table_endscan(), table_scan_getnextslot(), table_slot_create(), QueryDesc::tupDesc, TupleDescAttr, and whereToSendOutput.

Referenced by DoCopy().

 {
     bool        pipe = (cstate->filename == NULL);
     bool        fe_copy = (pipe && whereToSendOutput == DestRemote);
     TupleDesc   tupDesc;
     int         num_phys_attrs;
     ListCell   *cur;
     uint64      processed;
 
     if (fe_copy)
         SendCopyBegin(cstate);
 
     if (cstate->rel)
         tupDesc = RelationGetDescr(cstate->rel);
     else
         tupDesc = cstate->queryDesc->tupDesc;
     num_phys_attrs = tupDesc->natts;
     cstate->opts.null_print_client = cstate->opts.null_print;   /* default */
 
     /* We use fe_msgbuf as a per-row buffer regardless of copy_dest */
     cstate->fe_msgbuf = makeStringInfo();
 
     /* Get info about the columns we need to process. */
     cstate->out_functions = (FmgrInfo *) palloc(num_phys_attrs * sizeof(FmgrInfo));
     foreach(cur, cstate->attnumlist)
     {
         int         attnum = lfirst_int(cur);
         Oid         out_func_oid;
         bool        isvarlena;
         Form_pg_attribute attr = TupleDescAttr(tupDesc, attnum - 1);
 
         if (cstate->opts.binary)
             getTypeBinaryOutputInfo(attr->atttypid,
                                     &out_func_oid,
                                     &isvarlena);
         else
             getTypeOutputInfo(attr->atttypid,
                               &out_func_oid,
                               &isvarlena);
         fmgr_info(out_func_oid, &cstate->out_functions[attnum - 1]);
     }
 
     /*
      * Create a temporary memory context that we can reset once per row to
      * recover palloc'd memory.  This avoids any problems with leaks inside
      * datatype output routines, and should be faster than retail pfree's
      * anyway.  (We don't need a whole econtext as CopyFrom does.)
      */
     cstate->rowcontext = AllocSetContextCreate(CurrentMemoryContext,
                                                "COPY TO",
                                                ALLOCSET_DEFAULT_SIZES);
 
     if (cstate->opts.binary)
     {
         /* Generate header for a binary copy */
         int32       tmp;
 
         /* Signature */
         CopySendData(cstate, BinarySignature, 11);
         /* Flags field */
         tmp = 0;
         CopySendInt32(cstate, tmp);
         /* No header extension */
         tmp = 0;
         CopySendInt32(cstate, tmp);
     }
     else
     {
         /*
          * For non-binary copy, we need to convert null_print to file
          * encoding, because it will be sent directly with CopySendString.
          */
         if (cstate->need_transcoding)
             cstate->opts.null_print_client = pg_server_to_any(cstate->opts.null_print,
                                                               cstate->opts.null_print_len,
                                                               cstate->file_encoding);
 
         /* if a header has been requested send the line */
         if (cstate->opts.header_line)
         {
             bool        hdr_delim = false;
 
             foreach(cur, cstate->attnumlist)
             {
                 int         attnum = lfirst_int(cur);
                 char       *colname;
 
                 if (hdr_delim)
                     CopySendChar(cstate, cstate->opts.delim[0]);
                 hdr_delim = true;
 
                 colname = NameStr(TupleDescAttr(tupDesc, attnum - 1)->attname);
 
                 CopyAttributeOutCSV(cstate, colname, false,
                                     list_length(cstate->attnumlist) == 1);
             }
 
             CopySendEndOfRow(cstate);
         }
     }
 
     if (cstate->rel)
     {
         TupleTableSlot *slot;
         TableScanDesc scandesc;
 
         scandesc = table_beginscan(cstate->rel, GetActiveSnapshot(), 0, NULL);
         slot = table_slot_create(cstate->rel, NULL);
 
         processed = 0;
         while (table_scan_getnextslot(scandesc, ForwardScanDirection, slot))
         {
             CHECK_FOR_INTERRUPTS();
 
             /* Deconstruct the tuple ... */
             slot_getallattrs(slot);
 
             /* Format and send the data */
             CopyOneRowTo(cstate, slot);
 
             /*
              * Increment the number of processed tuples, and report the
              * progress.
              */
             pgstat_progress_update_param(PROGRESS_COPY_TUPLES_PROCESSED,
                                          ++processed);
         }
 
         ExecDropSingleTupleTableSlot(slot);
         table_endscan(scandesc);
     }
     else
     {
         /* run the plan --- the dest receiver will send tuples */
         ExecutorRun(cstate->queryDesc, ForwardScanDirection, 0L, true);
         processed = ((DR_copy *) cstate->queryDesc->dest)->processed;
     }
 
     if (cstate->opts.binary)
     {
         /* Generate trailer for a binary copy */
         CopySendInt16(cstate, -1);
         /* Need to flush out the trailer */
         CopySendEndOfRow(cstate);
     }
 
     MemoryContextDelete(cstate->rowcontext);
 
     if (fe_copy)
         SendCopyEnd(cstate);
 
     return processed;
 }

◆ EndCopyFrom()

void EndCopyFrom ( CopyFromState cstate )

Definition at line 1564 of file copyfrom.c.

References ClosePipeFromProgram(), CopyFromStateData::copy_file, CopyFromStateData::copycontext, ereport, errcode_for_file_access(), errmsg(), ERROR, CopyFromStateData::filename, FreeFile(), CopyFromStateData::is_program, MemoryContextDelete(), pfree(), and pgstat_progress_end_command().

Referenced by DoCopy(), file_acquire_sample_rows(), fileEndForeignScan(), and fileReScanForeignScan().

 {
     /* No COPY FROM related resources except memory. */
     if (cstate->is_program)
     {
         ClosePipeFromProgram(cstate);
     }
     else
     {
         if (cstate->filename != NULL && FreeFile(cstate->copy_file))
             ereport(ERROR,
                     (errcode_for_file_access(),
                      errmsg("could not close file \"%s\": %m",
                             cstate->filename)));
     }
 
     pgstat_progress_end_command();
 
     MemoryContextDelete(cstate->copycontext);
     pfree(cstate);
 }

◆ EndCopyTo()

void EndCopyTo ( CopyToState cstate )

Definition at line 760 of file copyto.c.

References EndCopy(), ExecutorEnd(), ExecutorFinish(), FreeQueryDesc(), PopActiveSnapshot(), and CopyToStateData::queryDesc.

Referenced by DoCopy().

 {
     if (cstate->queryDesc != NULL)
     {
         /* Close down the query and free resources. */
         ExecutorFinish(cstate->queryDesc);
         ExecutorEnd(cstate->queryDesc);
         FreeQueryDesc(cstate->queryDesc);
         PopActiveSnapshot();
     }
 
     /* Clean up storage */
     EndCopy(cstate);
 }

◆ NextCopyFrom()

bool NextCopyFrom	(	CopyFromState	cstate,
		ExprContext *	econtext,
		Datum *	values,
		bool *	nulls
	)

Definition at line 804 of file copyfromparse.c.

References Assert, attnum, CopyFromStateData::attnumlist, CopyFormatOptions::binary, CopyFromStateData::convert_select_flags, CopyGetInt16(), CopyReadBinaryAttribute(), CopyReadBinaryData(), CopyFormatOptions::csv_mode, cur, CopyFromStateData::cur_attname, CopyFromStateData::cur_attval, CopyFromStateData::cur_lineno, CurrentMemoryContext, CopyFromStateData::defexprs, CopyFromStateData::defmap, ExprContext::ecxt_per_tuple_memory, ereport, errcode(), errmsg(), ERROR, ExecEvalExpr(), CopyFormatOptions::force_notnull_flags, CopyFormatOptions::force_null_flags, i, CopyFromStateData::in_functions, InputFunctionCall(), lfirst_int, list_length(), MemSet, NameStr, TupleDescData::natts, NextCopyFromRawFields(), CopyFormatOptions::null_print, CopyFromStateData::num_defaults, CopyFromStateData::opts, CopyFromStateData::rel, RelationGetDescr, TupleDescAttr, and CopyFromStateData::typioparams.

Referenced by CopyFrom(), file_acquire_sample_rows(), and fileIterateForeignScan().

 {
     TupleDesc   tupDesc;
     AttrNumber  num_phys_attrs,
                 attr_count,
                 num_defaults = cstate->num_defaults;
     FmgrInfo   *in_functions = cstate->in_functions;
     Oid        *typioparams = cstate->typioparams;
     int         i;
     int        *defmap = cstate->defmap;
     ExprState **defexprs = cstate->defexprs;
 
     tupDesc = RelationGetDescr(cstate->rel);
     num_phys_attrs = tupDesc->natts;
     attr_count = list_length(cstate->attnumlist);
 
     /* Initialize all values for row to NULL */
     MemSet(values, 0, num_phys_attrs * sizeof(Datum));
     MemSet(nulls, true, num_phys_attrs * sizeof(bool));
 
     if (!cstate->opts.binary)
     {
         char      **field_strings;
         ListCell   *cur;
         int         fldct;
         int         fieldno;
         char       *string;
 
         /* read raw fields in the next line */
         if (!NextCopyFromRawFields(cstate, &field_strings, &fldct))
             return false;
 
         /* check for overflowing fields */
         if (attr_count > 0 && fldct > attr_count)
             ereport(ERROR,
                     (errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
                      errmsg("extra data after last expected column")));
 
         fieldno = 0;
 
         /* Loop to read the user attributes on the line. */
         foreach(cur, cstate->attnumlist)
         {
             int         attnum = lfirst_int(cur);
             int         m = attnum - 1;
             Form_pg_attribute att = TupleDescAttr(tupDesc, m);
 
             if (fieldno >= fldct)
                 ereport(ERROR,
                         (errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
                          errmsg("missing data for column \"%s\"",
                                 NameStr(att->attname))));
             string = field_strings[fieldno++];
 
             if (cstate->convert_select_flags &&
                 !cstate->convert_select_flags[m])
             {
                 /* ignore input field, leaving column as NULL */
                 continue;
             }
 
             if (cstate->opts.csv_mode)
             {
                 if (string == NULL &&
                     cstate->opts.force_notnull_flags[m])
                 {
                     /*
                      * FORCE_NOT_NULL option is set and column is NULL -
                      * convert it to the NULL string.
                      */
                     string = cstate->opts.null_print;
                 }
                 else if (string != NULL && cstate->opts.force_null_flags[m]
                          && strcmp(string, cstate->opts.null_print) == 0)
                 {
                     /*
                      * FORCE_NULL option is set and column matches the NULL
                      * string. It must have been quoted, or otherwise the
                      * string would already have been set to NULL. Convert it
                      * to NULL as specified.
                      */
                     string = NULL;
                 }
             }
 
             cstate->cur_attname = NameStr(att->attname);
             cstate->cur_attval = string;
             values[m] = InputFunctionCall(&in_functions[m],
                                           string,
                                           typioparams[m],
                                           att->atttypmod);
             if (string != NULL)
                 nulls[m] = false;
             cstate->cur_attname = NULL;
             cstate->cur_attval = NULL;
         }
 
         Assert(fieldno == attr_count);
     }
     else
     {
         /* binary */
         int16       fld_count;
         ListCell   *cur;
 
         cstate->cur_lineno++;
 
         if (!CopyGetInt16(cstate, &fld_count))
         {
             /* EOF detected (end of file, or protocol-level EOF) */
             return false;
         }
 
         if (fld_count == -1)
         {
             /*
              * Received EOF marker.  Wait for the protocol-level EOF, and
              * complain if it doesn't come immediately.  In COPY FROM STDIN,
              * this ensures that we correctly handle CopyFail, if client
              * chooses to send that now.  When copying from file, we could
              * ignore the rest of the file like in text mode, but we choose to
              * be consistent with the COPY FROM STDIN case.
              */
             char        dummy;
 
             if (CopyReadBinaryData(cstate, &dummy, 1) > 0)
                 ereport(ERROR,
                         (errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
                          errmsg("received copy data after EOF marker")));
             return false;
         }
 
         if (fld_count != attr_count)
             ereport(ERROR,
                     (errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
                      errmsg("row field count is %d, expected %d",
                             (int) fld_count, attr_count)));
 
         foreach(cur, cstate->attnumlist)
         {
             int         attnum = lfirst_int(cur);
             int         m = attnum - 1;
             Form_pg_attribute att = TupleDescAttr(tupDesc, m);
 
             cstate->cur_attname = NameStr(att->attname);
             values[m] = CopyReadBinaryAttribute(cstate,
                                                 &in_functions[m],
                                                 typioparams[m],
                                                 att->atttypmod,
                                                 &nulls[m]);
             cstate->cur_attname = NULL;
         }
     }
 
     /*
      * Now compute and insert any defaults available for the columns not
      * provided by the input data.  Anything not processed here or above will
      * remain NULL.
      */
     for (i = 0; i < num_defaults; i++)
     {
         /*
          * The caller must supply econtext and have switched into the
          * per-tuple memory context in it.
          */
         Assert(econtext != NULL);
         Assert(CurrentMemoryContext == econtext->ecxt_per_tuple_memory);
 
         values[defmap[i]] = ExecEvalExpr(defexprs[i], econtext,
                                          &nulls[defmap[i]]);
     }
 
     return true;
 }

◆ NextCopyFromRawFields()

bool NextCopyFromRawFields	(	CopyFromState	cstate,
		char ***	fields,
		int *	nfields
	)

Definition at line 753 of file copyfromparse.c.

References Assert, CopyFormatOptions::binary, CopyReadAttributesCSV(), CopyReadAttributesText(), CopyReadLine(), CopyFormatOptions::csv_mode, CopyFromStateData::cur_lineno, CopyFormatOptions::header_line, StringInfoData::len, CopyFromStateData::line_buf, CopyFromStateData::opts, and CopyFromStateData::raw_fields.

Referenced by NextCopyFrom().

 {
     int         fldct;
     bool        done;
 
     /* only available for text or csv input */
     Assert(!cstate->opts.binary);
 
     /* on input just throw the header line away */
     if (cstate->cur_lineno == 0 && cstate->opts.header_line)
     {
         cstate->cur_lineno++;
         if (CopyReadLine(cstate))
             return false;       /* done */
     }
 
     cstate->cur_lineno++;
 
     /* Actually read the line into memory here */
     done = CopyReadLine(cstate);
 
     /*
      * EOF at start of line means we're done.  If we see EOF after some
      * characters, we act as though it was newline followed by EOF, ie,
      * process the line and then exit loop on next iteration.
      */
     if (done && cstate->line_buf.len == 0)
         return false;
 
     /* Parse the line into de-escaped field values */
     if (cstate->opts.csv_mode)
         fldct = CopyReadAttributesCSV(cstate);
     else
         fldct = CopyReadAttributesText(cstate);
 
     *fields = cstate->raw_fields;
     *nfields = fldct;
     return true;
 }

◆ ProcessCopyOptions()

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

Definition at line 334 of file copy.c.

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

 {
     bool        format_specified = false;
     bool        freeze_specified = false;
     bool        header_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)
                 ereport(ERROR,
                         (errcode(ERRCODE_SYNTAX_ERROR),
                          errmsg("conflicting or redundant options"),
                          parser_errposition(pstate, defel->location)));
             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)
                 ereport(ERROR,
                         (errcode(ERRCODE_SYNTAX_ERROR),
                          errmsg("conflicting or redundant options"),
                          parser_errposition(pstate, defel->location)));
             freeze_specified = true;
             opts_out->freeze = defGetBoolean(defel);
         }
         else if (strcmp(defel->defname, "delimiter") == 0)
         {
             if (opts_out->delim)
                 ereport(ERROR,
                         (errcode(ERRCODE_SYNTAX_ERROR),
                          errmsg("conflicting or redundant options"),
                          parser_errposition(pstate, defel->location)));
             opts_out->delim = defGetString(defel);
         }
         else if (strcmp(defel->defname, "null") == 0)
         {
             if (opts_out->null_print)
                 ereport(ERROR,
                         (errcode(ERRCODE_SYNTAX_ERROR),
                          errmsg("conflicting or redundant options"),
                          parser_errposition(pstate, defel->location)));
             opts_out->null_print = defGetString(defel);
         }
         else if (strcmp(defel->defname, "header") == 0)
         {
             if (header_specified)
                 ereport(ERROR,
                         (errcode(ERRCODE_SYNTAX_ERROR),
                          errmsg("conflicting or redundant options"),
                          parser_errposition(pstate, defel->location)));
             header_specified = true;
             opts_out->header_line = defGetBoolean(defel);
         }
         else if (strcmp(defel->defname, "quote") == 0)
         {
             if (opts_out->quote)
                 ereport(ERROR,
                         (errcode(ERRCODE_SYNTAX_ERROR),
                          errmsg("conflicting or redundant options"),
                          parser_errposition(pstate, defel->location)));
             opts_out->quote = defGetString(defel);
         }
         else if (strcmp(defel->defname, "escape") == 0)
         {
             if (opts_out->escape)
                 ereport(ERROR,
                         (errcode(ERRCODE_SYNTAX_ERROR),
                          errmsg("conflicting or redundant options"),
                          parser_errposition(pstate, defel->location)));
             opts_out->escape = defGetString(defel);
         }
         else if (strcmp(defel->defname, "force_quote") == 0)
         {
             if (opts_out->force_quote || opts_out->force_quote_all)
                 ereport(ERROR,
                         (errcode(ERRCODE_SYNTAX_ERROR),
                          errmsg("conflicting or redundant options"),
                          parser_errposition(pstate, defel->location)));
             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)
                 ereport(ERROR,
                         (errcode(ERRCODE_SYNTAX_ERROR),
                          errmsg("conflicting or redundant options"),
                          parser_errposition(pstate, defel->location)));
             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)
                 ereport(ERROR,
                         (errcode(ERRCODE_SYNTAX_ERROR),
                          errmsg("conflicting or redundant options")));
             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)
                 ereport(ERROR,
                         (errcode(ERRCODE_SYNTAX_ERROR),
                          errmsg("conflicting or redundant options"),
                          parser_errposition(pstate, defel->location)));
             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)
                 ereport(ERROR,
                         (errcode(ERRCODE_SYNTAX_ERROR),
                          errmsg("conflicting or redundant options"),
                          parser_errposition(pstate, defel->location)));
             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
             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 two before inserting
      * defaults)
      */
     if (opts_out->binary && opts_out->delim)
         ereport(ERROR,
                 (errcode(ERRCODE_SYNTAX_ERROR),
                  errmsg("cannot specify DELIMITER in BINARY mode")));
 
     if (opts_out->binary && opts_out->null_print)
         ereport(ERROR,
                 (errcode(ERRCODE_SYNTAX_ERROR),
                  errmsg("cannot specify NULL in BINARY mode")));
 
     /* 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")));
 
     /*
      * 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->csv_mode && opts_out->header_line)
         ereport(ERROR,
                 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                  errmsg("COPY HEADER available only in CSV mode")));
 
     /* Check quote */
     if (!opts_out->csv_mode && opts_out->quote != NULL)
         ereport(ERROR,
                 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                  errmsg("COPY quote available only in CSV mode")));
 
     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),
                  errmsg("COPY escape available only in CSV mode")));
 
     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),
                  errmsg("COPY force quote available only in CSV mode")));
     if ((opts_out->force_quote || opts_out->force_quote_all) && is_from)
         ereport(ERROR,
                 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                  errmsg("COPY force quote only available using COPY TO")));
 
     /* Check force_notnull */
     if (!opts_out->csv_mode && opts_out->force_notnull != NIL)
         ereport(ERROR,
                 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                  errmsg("COPY force not null available only in CSV mode")));
     if (opts_out->force_notnull != NIL && !is_from)
         ereport(ERROR,
                 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                  errmsg("COPY force not null only available using COPY FROM")));
 
     /* Check force_null */
     if (!opts_out->csv_mode && opts_out->force_null != NIL)
         ereport(ERROR,
                 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                  errmsg("COPY force null available only in CSV mode")));
 
     if (opts_out->force_null != NIL && !is_from)
         ereport(ERROR,
                 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                  errmsg("COPY force null only available using COPY FROM")));
 
     /* 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_FEATURE_NOT_SUPPORTED),
                  errmsg("COPY delimiter must not appear in the NULL specification")));
 
     /* 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_FEATURE_NOT_SUPPORTED),
                  errmsg("CSV quote character must not appear in the NULL specification")));
 }

Data Structures

Typedefs

Functions

Typedef Documentation

◆ copy_data_source_cb

◆ CopyFormatOptions

◆ CopyFromState

◆ CopyToState

Function Documentation

◆ BeginCopyFrom()

◆ BeginCopyTo()

◆ CopyFrom()

◆ CopyFromErrorCallback()

◆ CopyGetAttnums()

◆ CreateCopyDestReceiver()

◆ DoCopy()

◆ DoCopyTo()

◆ EndCopyFrom()

◆ EndCopyTo()

◆ NextCopyFrom()

◆ NextCopyFromRawFields()

◆ ProcessCopyOptions()