#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

Macros
#define	COPY_HEADER_MATCH -1

#define	COPY_HEADER_FALSE 0

#define	COPY_HEADER_TRUE 1

Typedefs
typedef enum CopyOnErrorChoice	CopyOnErrorChoice

typedef enum CopyLogVerbosityChoice	CopyLogVerbosityChoice

typedef struct CopyFormatOptions	CopyFormatOptions

typedef struct CopyFromStateData *	CopyFromState

typedef struct CopyToStateData *	CopyToState

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

typedef void(*	copy_data_dest_cb) (void *data, int len)

Enumerations
enum	CopyOnErrorChoice { COPY_ON_ERROR_STOP = 0 , COPY_ON_ERROR_IGNORE }

enum	CopyLogVerbosityChoice { COPY_LOG_VERBOSITY_SILENT = -1 , COPY_LOG_VERBOSITY_DEFAULT = 0 , COPY_LOG_VERBOSITY_VERBOSE }

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

void	ProcessCopyOptions (ParseState pstate, CopyFormatOptions opts_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)

char *	CopyLimitPrintoutLength (const char *str)

uint64	CopyFrom (CopyFromState cstate)

DestReceiver *	CreateCopyDestReceiver (void)

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

void	EndCopyTo (CopyToState cstate)

uint64	DoCopyTo (CopyToState cstate)

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

Macro Definition Documentation

◆ COPY_HEADER_FALSE

#define COPY_HEADER_FALSE 0

Definition at line 27 of file copy.h.

◆ COPY_HEADER_MATCH

#define COPY_HEADER_MATCH -1

Definition at line 26 of file copy.h.

◆ COPY_HEADER_TRUE

#define COPY_HEADER_TRUE 1

Definition at line 28 of file copy.h.

Typedef Documentation

◆ copy_data_dest_cb

typedef void(* copy_data_dest_cb) (void *data, int len)

Definition at line 95 of file copy.h.

◆ copy_data_source_cb

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

Definition at line 94 of file copy.h.

◆ CopyFormatOptions

typedef struct CopyFormatOptions CopyFormatOptions

◆ CopyFromState

typedef struct CopyFromStateData* CopyFromState

Definition at line 91 of file copy.h.

◆ CopyLogVerbosityChoice

typedef enum CopyLogVerbosityChoice CopyLogVerbosityChoice

◆ CopyOnErrorChoice

typedef enum CopyOnErrorChoice CopyOnErrorChoice

◆ CopyToState

typedef struct CopyToStateData* CopyToState

Definition at line 92 of file copy.h.

Enumeration Type Documentation

◆ CopyLogVerbosityChoice

enum CopyLogVerbosityChoice

Enumerator
COPY_LOG_VERBOSITY_SILENT
COPY_LOG_VERBOSITY_DEFAULT
COPY_LOG_VERBOSITY_VERBOSE

Definition at line 43 of file copy.h.

{
    COPY_LOG_VERBOSITY_SILENT = -1, /* logs none */
    COPY_LOG_VERBOSITY_DEFAULT = 0, /* logs no additional messages. As this is
                                     * the default, assign 0 */
    COPY_LOG_VERBOSITY_VERBOSE, /* logs additional messages */
} CopyLogVerbosityChoice;

◆ CopyOnErrorChoice

enum CopyOnErrorChoice

Enumerator
COPY_ON_ERROR_STOP
COPY_ON_ERROR_IGNORE

Definition at line 34 of file copy.h.

{
    COPY_ON_ERROR_STOP = 0,     /* immediately throw errors, default */
    COPY_ON_ERROR_IGNORE,       /* ignore errors */
} CopyOnErrorChoice;

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 1529 of file copyfrom.c.

{
    CopyFromState cstate;
    bool        pipe = (filename == NULL);
    TupleDesc   tupDesc;
    AttrNumber  num_phys_attrs,
                num_defaults;
    FmgrInfo   *in_functions;
    Oid        *typioparams;
    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);
 
    /* Set the format routine */
    cstate->routine = CopyFromGetRoutine(&cstate->opts);
 
    /* Process the target relation */
    cstate->rel = rel;
 
    tupDesc = RelationGetDescr(cstate->rel);
 
    /* process common 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_all)
        MemSet(cstate->opts.force_notnull_flags, true, num_phys_attrs * sizeof(bool));
    else 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),
                /*- translator: first %s is the name of a COPY option, e.g. FORCE_NOT_NULL */
                         errmsg("%s column \"%s\" not referenced by COPY",
                                "FORCE_NOT_NULL", NameStr(attr->attname))));
            cstate->opts.force_notnull_flags[attnum - 1] = true;
        }
    }
 
    /* Set up soft error handler for ON_ERROR */
    if (cstate->opts.on_error != COPY_ON_ERROR_STOP)
    {
        cstate->escontext = makeNode(ErrorSaveContext);
        cstate->escontext->type = T_ErrorSaveContext;
        cstate->escontext->error_occurred = false;
 
        /*
         * Currently we only support COPY_ON_ERROR_IGNORE. We'll add other
         * options later
         */
        if (cstate->opts.on_error == COPY_ON_ERROR_IGNORE)
            cstate->escontext->details_wanted = false;
    }
    else
        cstate->escontext = NULL;
 
    /* 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_all)
        MemSet(cstate->opts.force_null_flags, true, num_phys_attrs * sizeof(bool));
    else 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),
                /*- translator: first %s is the name of a COPY option, e.g. FORCE_NOT_NULL */
                         errmsg("%s column \"%s\" not referenced by COPY",
                                "FORCE_NULL", 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());
        if (!OidIsValid(cstate->conversion_proc))
            ereport(ERROR,
                    (errcode(ERRCODE_UNDEFINED_FUNCTION),
                     errmsg("default conversion function for encoding \"%s\" to \"%s\" does not exist",
                            pg_encoding_to_char(cstate->file_encoding),
                            pg_encoding_to_char(GetDatabaseEncoding()))));
    }
 
    cstate->copy_src = COPY_FILE;   /* default */
 
    cstate->whereClause = whereClause;
 
    /* 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;
    cstate->relname_only = false;
 
    /*
     * 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;
 
    initStringInfo(&cstate->attribute_buf);
 
    /* Assign range table and rteperminfos, we'll need them in CopyFrom. */
    if (pstate)
    {
        cstate->range_table = pstate->p_rtable;
        cstate->rteperminfos = pstate->p_rteperminfos;
    }
 
    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 (int 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 */
        cstate->routine->CopyFromInFunc(cstate, att->atttypid,
                                        &in_functions[attnum - 1],
                                        &typioparams[attnum - 1]);
 
        /* Get default info if available */
        defexprs[attnum - 1] = NULL;
 
        /*
         * We only need the default values for columns that do not appear in
         * the column list, unless the DEFAULT option was given. We never need
         * default values for generated columns.
         */
        if ((cstate->opts.default_print != NULL ||
             !list_member_int(cstate->attnumlist, attnum)) &&
            !att->attgenerated)
        {
            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[attnum - 1] = ExecInitExpr(defexpr, NULL);
 
                /* if NOT copied from input */
                /* use default value if one exists */
                if (!list_member_int(cstate->attnumlist, attnum))
                {
                    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().  Note also that we already
                 * ran the expression through expression_planner().
                 */
                if (!volatile_defexprs)
                    volatile_defexprs = contain_volatile_functions_not_nextval((Node *) defexpr);
            }
        }
    }
 
    cstate->defaults = (bool *) palloc0(tupDesc->natts * sizeof(bool));
 
    /* 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);
 
    cstate->routine->CopyFromStart(cstate, tupDesc);
 
    MemoryContextSwitchTo(oldcontext);
 
    return cstate;
}

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

◆ BeginCopyTo()

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

Definition at line 632 of file copyto.c.

{
    CopyToState cstate;
    bool        pipe = (filename == NULL && data_dest_cb == 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
    };
    List       *children = NIL;
 
    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)
        {
            if (!RelationIsPopulated(rel))
                ereport(ERROR,
                        errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                        errmsg("cannot copy from unpopulated materialized view \"%s\"",
                               RelationGetRelationName(rel)),
                        errhint("Use the REFRESH MATERIALIZED VIEW command."));
        }
        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)
        {
            /*
             * Collect OIDs of relation containing data, so that later
             * DoCopyTo can copy the data from them.
             */
            children = find_all_inheritors(RelationGetRelid(rel), AccessShareLock, NULL);
 
            foreach_oid(child, children)
            {
                char        relkind = get_rel_relkind(child);
 
                if (relkind == RELKIND_FOREIGN_TABLE)
                {
                    char       *relation_name = get_rel_name(child);
 
                    ereport(ERROR,
                            errcode(ERRCODE_WRONG_OBJECT_TYPE),
                            errmsg("cannot copy from foreign table \"%s\"", relation_name),
                            errdetail("Partition \"%s\" is a foreign table in partitioned table \"%s\"",
                                      relation_name, RelationGetRelationName(rel)),
                            errhint("Try the COPY (SELECT ...) TO variant."));
                }
 
                /* Exclude tables with no data */
                if (RELKIND_HAS_PARTITIONS(relkind))
                    children = foreach_delete_current(children, child);
            }
        }
        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);
 
    /* Set format routine */
    cstate->routine = CopyToGetRoutine(&cstate->opts);
 
    /* Process the source/target relation or query */
    if (rel)
    {
        Assert(!raw_query);
 
        cstate->rel = rel;
 
        tupDesc = RelationGetDescr(cstate->rel);
        cstate->partitions = children;
    }
    else
    {
        List       *rewritten;
        Query      *query;
        PlannedStmt *plan;
        DestReceiver *dest;
 
        cstate->rel = NULL;
        cstate->partitions = NIL;
 
        /*
         * Run parse analysis and rewrite.  Note this also acquires sufficient
         * locks on the source table(s).
         */
        rewritten = pg_analyze_and_rewrite_fixedparams(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 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")));
 
        /* The only other utility command we could see is NOTIFY */
        if (query->utilityStmt != NULL)
            ereport(ERROR,
                    (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                     errmsg("COPY query must not be a utility command")));
 
        /*
         * 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 ||
                   query->commandType == CMD_MERGE);
 
            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, 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 ONLY 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)
    {
        MemSet(cstate->opts.force_quote_flags, true, num_phys_attrs * sizeof(bool));
    }
    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),
                /*- translator: %s is the name of a COPY option, e.g. FORCE_NOT_NULL */
                         errmsg("%s column \"%s\" not referenced by COPY",
                                "FORCE_QUOTE", NameStr(attr->attname))));
            cstate->opts.force_quote_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 if the file and server encodings differ
     * (see also pg_server_to_any).
     */
    if (cstate->file_encoding == GetDatabaseEncoding() ||
        cstate->file_encoding == PG_SQL_ASCII)
        cstate->need_transcoding = false;
    else
        cstate->need_transcoding = true;
 
    /* See Multibyte encoding comment above */
    cstate->encoding_embeds_ascii = PG_ENCODING_IS_CLIENT_ONLY(cstate->file_encoding);
 
    cstate->copy_dest = COPY_FILE;  /* default */
 
    if (data_dest_cb)
    {
        progress_vals[1] = PROGRESS_COPY_TYPE_CALLBACK;
        cstate->copy_dest = COPY_CALLBACK;
        cstate->data_dest_cb = data_dest_cb;
    }
    else 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;
}

References AccessShareLock, AllocateFile(), ALLOCSET_DEFAULT_SIZES, AllocSetContextCreate, Assert(), attnum, CopyToStateData::attnumlist, CopyToStateData::bytes_processed, CMD_DELETE, CMD_INSERT, CMD_MERGE, CMD_SELECT, CMD_UPDATE, Query::commandType, COPY_CALLBACK, CopyToStateData::copy_dest, COPY_FILE, CopyToStateData::copy_file, CopyToStateData::copycontext, CopyGetAttnums(), CopyToGetRoutine(), CreateDestReceiver(), CreateQueryDesc(), cur, CurrentMemoryContext, CURSOR_OPT_PARALLEL_OK, CopyToStateData::data_dest_cb, generate_unaccent_rules::dest, DestCopyOut, DestRemote, CopyToStateData::encoding_embeds_ascii, ereport, errcode(), errcode_for_file_access(), errdetail(), errhint(), errmsg(), ERROR, ExecutorStart(), CopyToStateData::file_encoding, CopyFormatOptions::file_encoding, CopyToStateData::filename, filename, find_all_inheritors(), CopyFormatOptions::force_quote, CopyFormatOptions::force_quote_all, CopyFormatOptions::force_quote_flags, foreach_delete_current, foreach_oid, fstat, get_rel_name(), get_rel_relkind(), GetActiveSnapshot(), GetDatabaseEncoding(), InvalidOid, InvalidSnapshot, is_absolute_path, CopyToStateData::is_program, IsA, lfirst_int, lfirst_node, linitial_node, list_length(), list_member_int(), list_member_oid(), MemoryContextSwitchTo(), MemSet, NameStr, TupleDescData::natts, CopyToStateData::need_transcoding, NIL, OpenPipeStream(), CopyToStateData::opts, ParseState::p_sourcetext, palloc0(), CopyToStateData::partitions, pg_analyze_and_rewrite_fixedparams(), PG_BINARY_W, PG_ENCODING_IS_CLIENT_ONLY, PG_END_TRY, PG_FINALLY, pg_get_client_encoding(), pg_plan_query(), PG_SQL_ASCII, PG_TRY, pgstat_progress_start_command(), pgstat_progress_update_multi_param(), plan, ProcessCopyOptions(), PROGRESS_COMMAND_COPY, PROGRESS_COPY_COMMAND, PROGRESS_COPY_COMMAND_TO, PROGRESS_COPY_TYPE, PROGRESS_COPY_TYPE_CALLBACK, PROGRESS_COPY_TYPE_FILE, PROGRESS_COPY_TYPE_PIPE, PROGRESS_COPY_TYPE_PROGRAM, pstrdup(), PushCopiedSnapshot(), QSRC_NON_INSTEAD_RULE, QSRC_QUAL_INSTEAD_RULE, CopyToStateData::queryDesc, RelationData::rd_rel, CopyToStateData::rel, RelationGetDescr, RelationGetRelationName, RelationGetRelid, RelationIsPopulated, Query::returningList, CopyToStateData::routine, S_ISDIR, S_IWGRP, S_IWOTH, stat::st_mode, generate_unaccent_rules::stdout, QueryDesc::tupDesc, TupleDescAttr(), UpdateActiveSnapshotCommandId(), Query::utilityStmt, and whereToSendOutput.

Referenced by DoCopy(), and test_copy_to_callback().

◆ CopyFrom()

uint64 CopyFrom ( CopyFromState cstate )

Definition at line 779 of file copyfrom.c.

{
    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);
 
    if (cstate->opts.on_error != COPY_ON_ERROR_STOP)
        Assert(cstate->escontext);
 
    /*
     * 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_firstRelfilelocatorSubid != InvalidSubTransactionId))
        ti_options |= TABLE_INSERT_SKIP_FSM;
 
    /*
     * Optimize if new relation storage 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")));
        }
 
        /* There's currently no support for COPY FREEZE on foreign tables. */
        if (cstate->rel->rd_rel->relkind == RELKIND_FOREIGN_TABLE)
            ereport(ERROR,
                    (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                     errmsg("cannot perform COPY FREEZE on a foreign 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_newRelfilelocatorSubid != 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, cstate->rteperminfos,
                       bms_make_singleton(1));
    resultRelInfo = target_resultRelInfo = makeNode(ResultRelInfo);
    ExecInitResultRelation(estate, resultRelInfo, 1);
 
    /* Verify the named relation is a valid target for INSERT */
    CheckValidResultRel(resultRelInfo, CMD_INSERT, ONCONFLICT_NONE, NIL);
 
    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);
 
    /*
     * Also, if the named relation is a foreign table, determine if the FDW
     * supports batch insert and determine the batch size (a FDW may support
     * batching, but it may be disabled for the server/table).
     *
     * If the FDW does not support batching, we set the batch size to 1.
     */
    if (resultRelInfo->ri_FdwRoutine != NULL &&
        resultRelInfo->ri_FdwRoutine->GetForeignModifyBatchSize &&
        resultRelInfo->ri_FdwRoutine->ExecForeignBatchInsert)
        resultRelInfo->ri_BatchSize =
            resultRelInfo->ri_FdwRoutine->GetForeignModifyBatchSize(resultRelInfo);
    else
        resultRelInfo->ri_BatchSize = 1;
 
    Assert(resultRelInfo->ri_BatchSize >= 1);
 
    /* 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()/ExecForeignBatchInsert() call, than call
     * table_tuple_insert()/ExecForeignInsert() 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 (resultRelInfo->ri_FdwRoutine != NULL &&
             resultRelInfo->ri_BatchSize == 1)
    {
        /*
         * Can't support multi-inserts to a foreign table if the FDW does not
         * support batching, or it's disabled for the server or foreign table.
         */
        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 after row insert and
         * statement level insert triggers are on the same relation.
         */
        insertMethod = CIM_SINGLE;
    }
    else if (cstate->volatile_defexprs)
    {
        /*
         * Can't support multi-inserts 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.
         *
         * Note: the whereClause was already preprocessed in DoCopy(), so it's
         * okay to use contain_volatile_functions() directly.
         */
        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 that can't use batching 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 = 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;
 
        if (cstate->opts.on_error == COPY_ON_ERROR_IGNORE &&
            cstate->escontext->error_occurred)
        {
            /*
             * Soft error occurred, skip this tuple and just make
             * ErrorSaveContext ready for the next NextCopyFrom. Since we
             * don't set details_wanted and error_data is not to be filled,
             * just resetting error_occurred is enough.
             */
            cstate->escontext->error_occurred = false;
 
            /* Report that this tuple was skipped by the ON_ERROR clause */
            pgstat_progress_update_param(PROGRESS_COPY_TUPLES_SKIPPED,
                                         cstate->num_errors);
 
            if (cstate->opts.reject_limit > 0 &&
                cstate->num_errors > cstate->opts.reject_limit)
                ereport(ERROR,
                        (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
                         errmsg("skipped more than REJECT_LIMIT (%" PRId64 ") rows due to data type incompatibility",
                                cstate->opts.reject_limit)));
 
            /* Repeat NextCopyFrom() until no soft error occurs */
            continue;
        }
 
        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 table that
                 * can't use batching.
                 */
                leafpart_use_multi_insert = insertMethod == CIM_MULTI_CONDITIONAL &&
                    !has_before_insert_row_trig &&
                    !has_instead_insert_row_trig &&
                    (resultRelInfo->ri_FdwRoutine == NULL ||
                     resultRelInfo->ri_BatchSize > 1);
 
                /* 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,
                                             &processed);
                }
 
                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 = ExecGetRootToChildMap(resultRelInfo, estate);
            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,
                                                 &processed);
 
                    /*
                     * We delay updating the row counter and progress of the
                     * COPY command until after writing the tuples stored in
                     * the buffer out to the table, as in single insert mode.
                     * See CopyMultiInsertBufferFlush().
                     */
                    continue;   /* next tuple please */
                }
                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,
                                                                   false);
                    }
 
                    /* 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, &processed);
    }
 
    /* Done, clean up */
    error_context_stack = errcallback.previous;
 
    if (cstate->opts.on_error != COPY_ON_ERROR_STOP &&
        cstate->num_errors > 0 &&
        cstate->opts.log_verbosity >= COPY_LOG_VERBOSITY_DEFAULT)
        ereport(NOTICE,
                errmsg_plural("%" PRIu64 " row was skipped due to data type incompatibility",
                              "%" PRIu64 " rows were skipped due to data type incompatibility",
                              cstate->num_errors,
                              cstate->num_errors));
 
    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;
}

Referenced by copy_table(), and DoCopy().

◆ CopyFromErrorCallback()

void CopyFromErrorCallback ( void * arg )

Definition at line 254 of file copyfrom.c.

{
    CopyFromState cstate = (CopyFromState) arg;
 
    if (cstate->relname_only)
    {
        errcontext("COPY %s",
                   cstate->cur_relname);
        return;
    }
    if (cstate->opts.binary)
    {
        /* can't usefully display the data */
        if (cstate->cur_attname)
            errcontext("COPY %s, line %" PRIu64 ", column %s",
                       cstate->cur_relname,
                       cstate->cur_lineno,
                       cstate->cur_attname);
        else
            errcontext("COPY %s, line %" PRIu64,
                       cstate->cur_relname,
                       cstate->cur_lineno);
    }
    else
    {
        if (cstate->cur_attname && cstate->cur_attval)
        {
            /* error is relevant to a particular column */
            char       *attval;
 
            attval = CopyLimitPrintoutLength(cstate->cur_attval);
            errcontext("COPY %s, line %" PRIu64 ", column %s: \"%s\"",
                       cstate->cur_relname,
                       cstate->cur_lineno,
                       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 %" PRIu64 ", column %s: null input",
                       cstate->cur_relname,
                       cstate->cur_lineno,
                       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 = CopyLimitPrintoutLength(cstate->line_buf.data);
                errcontext("COPY %s, line %" PRIu64 ": \"%s\"",
                           cstate->cur_relname,
                           cstate->cur_lineno, lineval);
                pfree(lineval);
            }
            else
            {
                errcontext("COPY %s, line %" PRIu64,
                           cstate->cur_relname,
                           cstate->cur_lineno);
            }
        }
    }
}

References arg, CopyFormatOptions::binary, CopyLimitPrintoutLength(), CopyFromStateData::cur_attname, CopyFromStateData::cur_attval, CopyFromStateData::cur_lineno, CopyFromStateData::cur_relname, StringInfoData::data, errcontext, CopyFromStateData::line_buf, CopyFromStateData::line_buf_valid, CopyFromStateData::opts, pfree(), and CopyFromStateData::relname_only.

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

◆ CopyGetAttnums()

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

Definition at line 998 of file copy.c.

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

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

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

◆ CopyLimitPrintoutLength()

char * CopyLimitPrintoutLength ( const char * str )

Definition at line 333 of file copyfrom.c.

{
#define MAX_COPY_DATA_DISPLAY 100
 
    int         slen = strlen(str);
    int         len;
    char       *res;
 
    /* Fast path if definitely okay */
    if (slen <= MAX_COPY_DATA_DISPLAY)
        return pstrdup(str);
 
    /* Apply encoding-dependent truncation */
    len = pg_mbcliplen(str, slen, MAX_COPY_DATA_DISPLAY);
 
    /*
     * Truncate, and add "..." to show we truncated the input.
     */
    res = (char *) palloc(len + 4);
    memcpy(res, str, len);
    strcpy(res + len, "...");
 
    return res;
}

References len, MAX_COPY_DATA_DISPLAY, palloc(), pg_mbcliplen(), pstrdup(), and str.

Referenced by CopyFromErrorCallback(), and CopyFromTextLikeOneRow().

◆ CreateCopyDestReceiver()

DestReceiver * CreateCopyDestReceiver ( void )

Definition at line 1528 of file copyto.c.

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

References copy_dest_destroy(), copy_dest_receive(), copy_dest_shutdown(), copy_dest_startup(), DR_copy::cstate, DestCopyOut, _DestReceiver::mydest, palloc(), DR_copy::processed, DR_copy::pub, _DestReceiver::rDestroy, _DestReceiver::receiveSlot, _DestReceiver::rShutdown, and _DestReceiver::rStartup.

Referenced by CreateDestReceiver().

◆ DoCopy()

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

Definition at line 62 of file copy.c.

{
    bool        is_from = stmt->is_from;
    bool        pipe = (stmt->filename == NULL);
    Relation    rel;
    Oid         relid;
    RawStmt    *query = NULL;
    Node       *whereClause = NULL;
 
    /*
     * Disallow COPY to/from file or program except to users with the
     * appropriate role.
     */
    if (!pipe)
    {
        if (stmt->is_program)
        {
            if (!has_privs_of_role(GetUserId(), ROLE_PG_EXECUTE_SERVER_PROGRAM))
                ereport(ERROR,
                        (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
                         errmsg("permission denied to COPY to or from an external program"),
                         errdetail("Only roles with privileges of the \"%s\" role may COPY to or from an external program.",
                                   "pg_execute_server_program"),
                         errhint("Anyone can COPY to stdout or from stdin. "
                                 "psql's \\copy command also works for anyone.")));
        }
        else
        {
            if (is_from && !has_privs_of_role(GetUserId(), ROLE_PG_READ_SERVER_FILES))
                ereport(ERROR,
                        (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
                         errmsg("permission denied to COPY from a file"),
                         errdetail("Only roles with privileges of the \"%s\" role may COPY from a file.",
                                   "pg_read_server_files"),
                         errhint("Anyone can COPY to stdout or from stdin. "
                                 "psql's \\copy command also works for anyone.")));
 
            if (!is_from && !has_privs_of_role(GetUserId(), ROLE_PG_WRITE_SERVER_FILES))
                ereport(ERROR,
                        (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
                         errmsg("permission denied to COPY to a file"),
                         errdetail("Only roles with privileges of the \"%s\" role may COPY to a file.",
                                   "pg_write_server_files"),
                         errhint("Anyone can COPY to stdout or from stdin. "
                                 "psql's \\copy command also works for anyone.")));
        }
    }
 
    if (stmt->relation)
    {
        LOCKMODE    lockmode = is_from ? RowExclusiveLock : AccessShareLock;
        ParseNamespaceItem *nsitem;
        RTEPermissionInfo *perminfo;
        TupleDesc   tupDesc;
        List       *attnums;
        ListCell   *cur;
 
        Assert(!stmt->query);
 
        /* Open and lock the relation, using the appropriate lock type. */
        rel = table_openrv(stmt->relation, lockmode);
 
        relid = RelationGetRelid(rel);
 
        nsitem = addRangeTableEntryForRelation(pstate, rel, lockmode,
                                               NULL, false, false);
 
        perminfo = nsitem->p_perminfo;
        perminfo->requiredPerms = (is_from ? ACL_INSERT : ACL_SELECT);
 
        if (stmt->whereClause)
        {
            Bitmapset  *expr_attrs = NULL;
            int         i;
 
            /* 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);
 
            /*
             * Examine all the columns in the WHERE clause expression.  When
             * the whole-row reference is present, examine all the columns of
             * the table.
             */
            pull_varattnos(whereClause, 1, &expr_attrs);
            if (bms_is_member(0 - FirstLowInvalidHeapAttributeNumber, expr_attrs))
            {
                expr_attrs = bms_add_range(expr_attrs,
                                           1 - FirstLowInvalidHeapAttributeNumber,
                                           RelationGetNumberOfAttributes(rel) - FirstLowInvalidHeapAttributeNumber);
                expr_attrs = bms_del_member(expr_attrs, 0 - FirstLowInvalidHeapAttributeNumber);
            }
 
            i = -1;
            while ((i = bms_next_member(expr_attrs, i)) >= 0)
            {
                AttrNumber  attno = i + FirstLowInvalidHeapAttributeNumber;
 
                Assert(attno != 0);
 
                /*
                 * Prohibit generated columns in the WHERE clause.  Stored
                 * generated columns are not yet computed when the filtering
                 * happens.  Virtual generated columns could probably work (we
                 * would need to expand them somewhere around here), but for
                 * now we keep them consistent with the stored variant.
                 */
                if (TupleDescAttr(RelationGetDescr(rel), attno - 1)->attgenerated)
                    ereport(ERROR,
                            errcode(ERRCODE_INVALID_COLUMN_REFERENCE),
                            errmsg("generated columns are not supported in COPY FROM WHERE conditions"),
                            errdetail("Column \"%s\" is a generated column.",
                                      get_attname(RelationGetRelid(rel), attno, false)));
            }
 
            whereClause = eval_const_expressions(NULL, whereClause);
 
            whereClause = (Node *) canonicalize_qual((Expr *) whereClause, false);
            whereClause = (Node *) make_ands_implicit((Expr *) whereClause);
        }
 
        tupDesc = RelationGetDescr(rel);
        attnums = CopyGetAttnums(tupDesc, rel, stmt->attlist);
        foreach(cur, attnums)
        {
            int         attno;
            Bitmapset **bms;
 
            attno = lfirst_int(cur) - FirstLowInvalidHeapAttributeNumber;
            bms = is_from ? &perminfo->insertedCols : &perminfo->selectedCols;
 
            *bms = bms_add_member(*bms, attno);
        }
        ExecCheckPermissions(pstate->p_rtable, list_make1(perminfo), true);
 
        /*
         * Permission check for row security policies.
         *
         * check_enable_rls will ereport(ERROR) if the user has requested
         * something invalid and will otherwise indicate if we should enable
         * RLS (returns RLS_ENABLED) or not for this COPY statement.
         *
         * If the relation has a row security policy and we are to apply it
         * then perform a "query" copy and allow the normal query processing
         * to handle the policies.
         *
         * If RLS is not enabled for this, then just fall through to the
         * normal non-filtering relation handling.
         */
        if (check_enable_rls(relid, InvalidOid, false) == RLS_ENABLED)
        {
            SelectStmt *select;
            ColumnRef  *cr;
            ResTarget  *target;
            RangeVar   *from;
            List       *targetList = NIL;
 
            if (is_from)
                ereport(ERROR,
                        (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                         errmsg("COPY FROM not supported with row-level security"),
                         errhint("Use INSERT statements instead.")));
 
            /*
             * Build target list
             *
             * If no columns are specified in the attribute list of the COPY
             * command, then the target list is 'all' columns. Therefore, '*'
             * should be used as the target list for the resulting SELECT
             * statement.
             *
             * In the case that columns are specified in the attribute list,
             * create a ColumnRef and ResTarget for each column and add them
             * to the target list for the resulting SELECT statement.
             */
            if (!stmt->attlist)
            {
                cr = makeNode(ColumnRef);
                cr->fields = list_make1(makeNode(A_Star));
                cr->location = -1;
 
                target = makeNode(ResTarget);
                target->name = NULL;
                target->indirection = NIL;
                target->val = (Node *) cr;
                target->location = -1;
 
                targetList = list_make1(target);
            }
            else
            {
                ListCell   *lc;
 
                foreach(lc, stmt->attlist)
                {
                    /*
                     * Build the ColumnRef for each column.  The ColumnRef
                     * 'fields' property is a String node that corresponds to
                     * the column name respectively.
                     */
                    cr = makeNode(ColumnRef);
                    cr->fields = list_make1(lfirst(lc));
                    cr->location = -1;
 
                    /* Build the ResTarget and add the ColumnRef to it. */
                    target = makeNode(ResTarget);
                    target->name = NULL;
                    target->indirection = NIL;
                    target->val = (Node *) cr;
                    target->location = -1;
 
                    /* Add each column to the SELECT statement's target list */
                    targetList = lappend(targetList, target);
                }
            }
 
            /*
             * Build RangeVar for from clause, fully qualified based on the
             * relation which we have opened and locked.  Use "ONLY" so that
             * COPY retrieves rows from only the target table not any
             * inheritance children, the same as when RLS doesn't apply.
             *
             * However, when copying data from a partitioned table, we don't
             * use "ONLY", since we need to retrieve rows from its descendant
             * tables too.
             */
            from = makeRangeVar(get_namespace_name(RelationGetNamespace(rel)),
                                pstrdup(RelationGetRelationName(rel)),
                                -1);
            from->inh = (rel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE);
 
            /* Build query */
            select = makeNode(SelectStmt);
            select->targetList = targetList;
            select->fromClause = list_make1(from);
 
            query = makeNode(RawStmt);
            query->stmt = (Node *) select;
            query->stmt_location = stmt_location;
            query->stmt_len = stmt_len;
 
            /*
             * Close the relation for now, but keep the lock on it to prevent
             * changes between now and when we start the query-based COPY.
             *
             * We'll reopen it later as part of the query-based COPY.
             */
            table_close(rel, NoLock);
            rel = NULL;
        }
    }
    else
    {
        Assert(stmt->query);
 
        query = makeNode(RawStmt);
        query->stmt = stmt->query;
        query->stmt_location = stmt_location;
        query->stmt_len = stmt_len;
 
        relid = InvalidOid;
        rel = NULL;
    }
 
    if (is_from)
    {
        CopyFromState cstate;
 
        Assert(rel);
 
        /* check read-only transaction and parallel mode */
        if (XactReadOnly && !rel->rd_islocaltemp)
            PreventCommandIfReadOnly("COPY FROM");
 
        cstate = BeginCopyFrom(pstate, rel, whereClause,
                               stmt->filename, stmt->is_program,
                               NULL, stmt->attlist, stmt->options);
        *processed = CopyFrom(cstate);  /* copy from file to database */
        EndCopyFrom(cstate);
    }
    else
    {
        CopyToState cstate;
 
        cstate = BeginCopyTo(pstate, rel, query, relid,
                             stmt->filename, stmt->is_program,
                             NULL, stmt->attlist, stmt->options);
        *processed = DoCopyTo(cstate);  /* copy from database to file */
        EndCopyTo(cstate);
    }
 
    if (rel != NULL)
        table_close(rel, NoLock);
}

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

Referenced by standard_ProcessUtility().

◆ DoCopyTo()

uint64 DoCopyTo ( CopyToState cstate )

Definition at line 1061 of file copyto.c.

{
    bool        pipe = (cstate->filename == NULL && cstate->data_dest_cb == NULL);
    bool        fe_copy = (pipe && whereToSendOutput == DestRemote);
    TupleDesc   tupDesc;
    int         num_phys_attrs;
    ListCell   *cur;
    uint64      processed = 0;
 
    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);
        Form_pg_attribute attr = TupleDescAttr(tupDesc, attnum - 1);
 
        cstate->routine->CopyToOutFunc(cstate, attr->atttypid,
                                       &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);
 
    cstate->routine->CopyToStart(cstate, tupDesc);
 
    if (cstate->rel)
    {
        /*
         * If COPY TO source table is a partitioned table, then open each
         * partition and process each individual partition.
         */
        if (cstate->rel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE)
        {
            foreach_oid(child, cstate->partitions)
            {
                Relation    scan_rel;
 
                /* We already got the lock in BeginCopyTo */
                scan_rel = table_open(child, NoLock);
                CopyRelationTo(cstate, scan_rel, cstate->rel, &processed);
                table_close(scan_rel, NoLock);
            }
        }
        else
            CopyRelationTo(cstate, cstate->rel, NULL, &processed);
    }
    else
    {
        /* run the plan --- the dest receiver will send tuples */
        ExecutorRun(cstate->queryDesc, ForwardScanDirection, 0);
        processed = ((DR_copy *) cstate->queryDesc->dest)->processed;
    }
 
    cstate->routine->CopyToEnd(cstate);
 
    MemoryContextDelete(cstate->rowcontext);
 
    if (fe_copy)
        SendCopyEnd(cstate);
 
    return processed;
}

References ALLOCSET_DEFAULT_SIZES, AllocSetContextCreate, attnum, CopyToStateData::attnumlist, CopyRelationTo(), CopyToRoutine::CopyToEnd, CopyToRoutine::CopyToOutFunc, CopyToRoutine::CopyToStart, cur, CurrentMemoryContext, CopyToStateData::data_dest_cb, QueryDesc::dest, DestRemote, ExecutorRun(), CopyToStateData::fe_msgbuf, CopyToStateData::filename, foreach_oid, ForwardScanDirection, lfirst_int, makeStringInfo(), MemoryContextDelete(), TupleDescData::natts, NoLock, CopyFormatOptions::null_print, CopyFormatOptions::null_print_client, CopyToStateData::opts, CopyToStateData::out_functions, palloc(), CopyToStateData::partitions, CopyToStateData::queryDesc, RelationData::rd_rel, CopyToStateData::rel, RelationGetDescr, CopyToStateData::routine, CopyToStateData::rowcontext, SendCopyBegin(), SendCopyEnd(), table_close(), table_open(), QueryDesc::tupDesc, TupleDescAttr(), and whereToSendOutput.

Referenced by DoCopy(), and test_copy_to_callback().

◆ EndCopyFrom()

void EndCopyFrom ( CopyFromState cstate )

Definition at line 1914 of file copyfrom.c.

{
    /* Invoke the end callback */
    cstate->routine->CopyFromEnd(cstate);
 
    /* 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);
}

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

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

◆ EndCopyTo()

void EndCopyTo ( CopyToState cstate )

Definition at line 1040 of file copyto.c.

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

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

Referenced by DoCopy(), and test_copy_to_callback().

◆ NextCopyFrom()

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

Definition at line 880 of file copyfromparse.c.

{
    TupleDesc   tupDesc;
    AttrNumber  num_phys_attrs,
                num_defaults = cstate->num_defaults;
    int         i;
    int        *defmap = cstate->defmap;
    ExprState **defexprs = cstate->defexprs;
 
    tupDesc = RelationGetDescr(cstate->rel);
    num_phys_attrs = tupDesc->natts;
 
    /* Initialize all values for row to NULL */
    MemSet(values, 0, num_phys_attrs * sizeof(Datum));
    MemSet(nulls, true, num_phys_attrs * sizeof(bool));
    MemSet(cstate->defaults, false, num_phys_attrs * sizeof(bool));
 
    /* Get one row from source */
    if (!cstate->routine->CopyFromOneRow(cstate, econtext, values, nulls))
        return false;
 
    /*
     * 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[defmap[i]], econtext,
                                         &nulls[defmap[i]]);
    }
 
    return true;
}

References Assert(), CopyFromRoutine::CopyFromOneRow, CurrentMemoryContext, CopyFromStateData::defaults, CopyFromStateData::defexprs, CopyFromStateData::defmap, ExprContext::ecxt_per_tuple_memory, ExecEvalExpr(), i, MemSet, TupleDescData::natts, CopyFromStateData::num_defaults, CopyFromStateData::rel, RelationGetDescr, CopyFromStateData::routine, and values.

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

◆ NextCopyFromRawFields()

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

Definition at line 747 of file copyfromparse.c.

{
    return NextCopyFromRawFieldsInternal(cstate, fields, nfields,
                                         cstate->opts.csv_mode);
}

References CopyFormatOptions::csv_mode, NextCopyFromRawFieldsInternal(), and CopyFromStateData::opts.

◆ ProcessCopyOptions()

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

Definition at line 549 of file copy.c.

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

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

Data Structures

Macros

Typedefs

Enumerations

Functions

Macro Definition Documentation

◆ COPY_HEADER_FALSE

◆ COPY_HEADER_MATCH

◆ COPY_HEADER_TRUE

Typedef Documentation

◆ copy_data_dest_cb

◆ copy_data_source_cb

◆ CopyFormatOptions

◆ CopyFromState

◆ CopyLogVerbosityChoice

◆ CopyOnErrorChoice

◆ CopyToState

Enumeration Type Documentation

◆ CopyLogVerbosityChoice

◆ CopyOnErrorChoice

Function Documentation

◆ BeginCopyFrom()

◆ BeginCopyTo()

◆ CopyFrom()

◆ CopyFromErrorCallback()

◆ CopyGetAttnums()

◆ CopyLimitPrintoutLength()

◆ CreateCopyDestReceiver()

◆ DoCopy()

◆ DoCopyTo()

◆ EndCopyFrom()

◆ EndCopyTo()

◆ NextCopyFrom()

◆ NextCopyFromRawFields()

◆ ProcessCopyOptions()