copy.h File Reference

#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.

Typedefs
typedef struct CopyStateData *	CopyState
typedef int(*	copy_data_source_cb) (void *outbuf, int minread, int maxread)

Functions
void	DoCopy (ParseState *state, const CopyStmt *stmt, int stmt_location, int stmt_len, uint64 *processed)
void	ProcessCopyOptions (ParseState *pstate, CopyState cstate, bool is_from, List *options)
CopyState	BeginCopyFrom (ParseState *pstate, Relation rel, const char *filename, bool is_program, copy_data_source_cb data_source_cb, List *attnamelist, List *options)
void	EndCopyFrom (CopyState cstate)
bool	NextCopyFrom (CopyState cstate, ExprContext *econtext, Datum *values, bool *nulls)
bool	NextCopyFromRawFields (CopyState cstate, char ***fields, int *nfields)
void	CopyFromErrorCallback (void *arg)
uint64	CopyFrom (CopyState cstate)
DestReceiver *	CreateCopyDestReceiver (void)

Typedef Documentation

copy_data_source_cb

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

Definition at line 24 of file copy.h.

CopyState

typedef struct CopyStateData* CopyState

Definition at line 23 of file copy.h.

Function Documentation

BeginCopyFrom()

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

Definition at line 3334 of file copy.c.

References AllocateFile(), Assert, attnum, CopyStateData::attnumlist, CopyStateData::attribute_buf, BeginCopy(), CopyStateData::binary, BinarySignature, build_column_default(), contain_volatile_functions_not_nextval(), COPY_CALLBACK, CopyStateData::copy_dest, CopyStateData::copy_file, CopyStateData::copycontext, CopyGetData(), CopyGetInt32(), CopyStateData::cur_attname, CopyStateData::cur_attval, CopyStateData::cur_lineno, CopyStateData::cur_relname, CopyStateData::data_source_cb, CopyStateData::defexprs, CopyStateData::defmap, DestRemote, CopyStateData::eol_type, EOL_UNKNOWN, ereport, errcode(), errcode_for_file_access(), errhint(), errmsg(), ERROR, ExecInitExpr(), expression_planner(), CopyStateData::filename, fmgr_info(), getTypeBinaryInputInfo(), getTypeInputInfo(), CopyStateData::in_functions, initStringInfo(), InvalidOid, CopyStateData::is_program, CopyStateData::line_buf, CopyStateData::line_buf_converted, list_length(), list_member_int(), CopyStateData::max_fields, MemoryContextSwitchTo(), TupleDescData::natts, CopyStateData::num_defaults, OpenPipeStream(), ParseState::p_rtable, palloc(), PG_BINARY_R, pstrdup(), CopyStateData::range_table, CopyStateData::raw_buf, CopyStateData::raw_buf_index, CopyStateData::raw_buf_len, RAW_BUF_SIZE, CopyStateData::raw_fields, CopyStateData::reached_eof, ReceiveCopyBegin(), CopyStateData::rel, RelationGetDescr, RelationGetRelationName, S_ISDIR, stat, TupleDescAttr, CopyStateData::typioparams, CopyStateData::volatile_defexprs, and whereToSendOutput.

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

{
    CopyState   cstate;
    bool        pipe = (filename == NULL);
    TupleDesc   tupDesc;
    AttrNumber  num_phys_attrs,
                num_defaults;
    FmgrInfo   *in_functions;
    Oid        *typioparams;
    int         attnum;
    Oid         in_func_oid;
    int        *defmap;
    ExprState **defexprs;
    MemoryContext oldcontext;
    bool        volatile_defexprs;

    cstate = BeginCopy(pstate, true, rel, NULL, InvalidOid, attnamelist, options);
    oldcontext = MemoryContextSwitchTo(cstate->copycontext);

    /* Initialize state variables */
    cstate->reached_eof = false;
    cstate->eol_type = EOL_UNKNOWN;
    cstate->cur_relname = RelationGetRelationName(cstate->rel);
    cstate->cur_lineno = 0;
    cstate->cur_attname = NULL;
    cstate->cur_attval = NULL;

    /* Set up variables to avoid per-attribute overhead. */
    initStringInfo(&cstate->attribute_buf);
    initStringInfo(&cstate->line_buf);
    cstate->line_buf_converted = false;
    cstate->raw_buf = (char *) palloc(RAW_BUF_SIZE + 1);
    cstate->raw_buf_index = cstate->raw_buf_len = 0;

    /* Assign range table, we'll need it in CopyFrom. */
    if (pstate)
        cstate->range_table = pstate->p_rtable;

    tupDesc = RelationGetDescr(cstate->rel);
    num_phys_attrs = tupDesc->natts;
    num_defaults = 0;
    volatile_defexprs = false;

    /*
     * Pick up the required catalog information for each attribute in the
     * relation, including the input function, the element type (to pass to
     * the input function), and info about defaults and constraints. (Which
     * input function we use depends on text/binary format choice.)
     */
    in_functions = (FmgrInfo *) palloc(num_phys_attrs * sizeof(FmgrInfo));
    typioparams = (Oid *) palloc(num_phys_attrs * sizeof(Oid));
    defmap = (int *) palloc(num_phys_attrs * sizeof(int));
    defexprs = (ExprState **) palloc(num_phys_attrs * sizeof(ExprState *));

    for (attnum = 1; attnum <= num_phys_attrs; attnum++)
    {
        Form_pg_attribute att = TupleDescAttr(tupDesc, attnum - 1);

        /* We don't need info for dropped attributes */
        if (att->attisdropped)
            continue;

        /* Fetch the input function and typioparam info */
        if (cstate->binary)
            getTypeBinaryInputInfo(att->atttypid,
                                   &in_func_oid, &typioparams[attnum - 1]);
        else
            getTypeInputInfo(att->atttypid,
                             &in_func_oid, &typioparams[attnum - 1]);
        fmgr_info(in_func_oid, &in_functions[attnum - 1]);

        /* Get default info if needed */
        if (!list_member_int(cstate->attnumlist, attnum) && !att->attgenerated)
        {
            /* attribute is NOT to be copied from input */
            /* use default value if one exists */
            Expr       *defexpr = (Expr *) build_column_default(cstate->rel,
                                                                attnum);

            if (defexpr != NULL)
            {
                /* Run the expression through planner */
                defexpr = expression_planner(defexpr);

                /* Initialize executable expression in copycontext */
                defexprs[num_defaults] = ExecInitExpr(defexpr, NULL);
                defmap[num_defaults] = attnum - 1;
                num_defaults++;

                /*
                 * If a default expression looks at the table being loaded,
                 * then it could give the wrong answer when using
                 * multi-insert. Since database access can be dynamic this is
                 * hard to test for exactly, so we use the much wider test of
                 * whether the default expression is volatile. We allow for
                 * the special case of when the default expression is the
                 * nextval() of a sequence which in this specific case is
                 * known to be safe for use with the multi-insert
                 * optimization. Hence we use this special case function
                 * checker rather than the standard check for
                 * contain_volatile_functions().
                 */
                if (!volatile_defexprs)
                    volatile_defexprs = contain_volatile_functions_not_nextval((Node *) defexpr);
            }
        }
    }

    /* 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)
    {
        cstate->copy_dest = COPY_CALLBACK;
        cstate->data_source_cb = data_source_cb;
    }
    else if (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)
        {
            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;

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

    if (cstate->binary)
    {
        /* Read and verify binary header */
        char        readSig[11];
        int32       tmp;

        /* Signature */
        if (CopyGetData(cstate, readSig, 11, 11) != 11 ||
            memcmp(readSig, BinarySignature, 11) != 0)
            ereport(ERROR,
                    (errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
                     errmsg("COPY file signature not recognized")));
        /* Flags field */
        if (!CopyGetInt32(cstate, &tmp))
            ereport(ERROR,
                    (errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
                     errmsg("invalid COPY file header (missing flags)")));
        if ((tmp & (1 << 16)) != 0)
            ereport(ERROR,
                    (errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
                     errmsg("invalid COPY file header (WITH OIDS)")));
        tmp &= ~(1 << 16);
        if ((tmp >> 16) != 0)
            ereport(ERROR,
                    (errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
                     errmsg("unrecognized critical flags in COPY file header")));
        /* Header extension length */
        if (!CopyGetInt32(cstate, &tmp) ||
            tmp < 0)
            ereport(ERROR,
                    (errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
                     errmsg("invalid COPY file header (missing length)")));
        /* Skip extension header, if present */
        while (tmp-- > 0)
        {
            if (CopyGetData(cstate, readSig, 1, 1) != 1)
                ereport(ERROR,
                        (errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
                         errmsg("invalid COPY file header (wrong length)")));
        }
    }

    /* create workspace for CopyReadAttributes results */
    if (!cstate->binary)
    {
        AttrNumber  attr_count = list_length(cstate->attnumlist);

        cstate->max_fields = attr_count;
        cstate->raw_fields = (char **) palloc(attr_count * sizeof(char *));
    }

    MemoryContextSwitchTo(oldcontext);

    return cstate;
}

CopyFrom()

uint64 CopyFrom

(

CopyState

cstate

)

Definition at line 2653 of file copy.c.

References AfterTriggerBeginQuery(), AfterTriggerEndQuery(), ErrorContextCallback::arg, Assert, TupleConversionMap::attrMap, FdwRoutine::BeginForeignInsert, ErrorContextCallback::callback, castNode, CHECK_FOR_INTERRUPTS, CheckValidResultRel(), CIM_MULTI, CIM_MULTI_CONDITIONAL, CIM_SINGLE, CMD_INSERT, TupleDescData::constr, contain_volatile_functions(), CopyStateData::copy_dest, COPY_OLD_FE, CopyFromErrorCallback(), CopyMultiInsertInfoCleanup(), CopyMultiInsertInfoFlush(), CopyMultiInsertInfoInit(), CopyMultiInsertInfoIsEmpty(), CopyMultiInsertInfoIsFull(), CopyMultiInsertInfoNextFreeSlot(), CopyMultiInsertInfoSetupBuffer(), CopyMultiInsertInfoStore(), CreateExecutorState(), CopyStateData::cur_lineno, CurrentMemoryContext, ExprContext::ecxt_scantuple, FdwRoutine::EndForeignInsert, ereport, errcode(), errhint(), errmsg(), ERROR, error_context_stack, EState::es_num_result_relations, EState::es_result_relation_info, EState::es_result_relations, EState::es_tupleTable, ExecARInsertTriggers(), ExecASInsertTriggers(), ExecBRInsertTriggers(), ExecBSInsertTriggers(), ExecCleanUpTriggerState(), ExecCleanupTupleRouting(), ExecClearTuple(), ExecCloseIndices(), ExecComputeStoredGenerated(), ExecConstraints(), ExecCopySlot(), ExecFindPartition(), FdwRoutine::ExecForeignInsert, ExecInitQual(), ExecInitRangeTable(), ExecInsertIndexTuples(), ExecIRInsertTriggers(), ExecMaterializeSlot(), ExecOpenIndices(), ExecPartitionCheck(), ExecQual(), ExecResetTupleTable(), ExecSetupPartitionTupleRouting(), ExecStoreVirtualTuple(), execute_attr_map_slot(), FreeBulkInsertState(), FreeExecutorState(), CopyStateData::freeze, GetBulkInsertState(), GetCurrentCommandId(), GetCurrentSubTransactionId(), GetPerTupleExprContext, GetPerTupleMemoryContext, TupleConstr::has_generated_stored, InitResultRelInfo(), InvalidateCatalogSnapshot(), InvalidSubTransactionId, StringInfoData::len, CopyStateData::line_buf, list_free(), makeNode, MakeTransitionCaptureState(), MemoryContextSwitchTo(), ModifyTableState::mt_transition_capture, NextCopyFrom(), NIL, ModifyTableState::operation, PartitionRoutingInfo::pi_PartitionToRootMap, PartitionRoutingInfo::pi_PartitionTupleSlot, PartitionRoutingInfo::pi_RootToPartitionMap, PlanState::plan, pq_endmsgread(), ErrorContextCallback::previous, ModifyTableState::ps, CopyStateData::qualexpr, CopyStateData::range_table, RelationData::rd_att, RelationData::rd_createSubid, RelationData::rd_firstRelfilenodeSubid, RelationData::rd_newRelfilenodeSubid, RelationData::rd_rel, CopyStateData::rel, RelationGetRelationName, RelationGetRelid, ReleaseBulkInsertStatePin(), ResetPerTupleExprContext, ModifyTableState::resultRelInfo, ResultRelInfo::ri_CopyMultiInsertBuffer, ResultRelInfo::ri_FdwRoutine, ResultRelInfo::ri_NumIndices, ResultRelInfo::ri_PartitionCheck, ResultRelInfo::ri_PartitionInfo, ResultRelInfo::ri_RelationDesc, ResultRelInfo::ri_TrigDesc, PlanState::state, TABLE_INSERT_FROZEN, TABLE_INSERT_SKIP_FSM, table_slot_create(), table_tuple_insert(), TransitionCaptureState::tcs_map, TransitionCaptureState::tcs_original_insert_tuple, ThereAreNoPriorRegisteredSnapshots(), ThereAreNoReadyPortals(), CopyStateData::transition_capture, TriggerDesc::trig_insert_before_row, TriggerDesc::trig_insert_instead_row, TriggerDesc::trig_insert_new_table, RelationData::trigdesc, TupleTableSlot::tts_isnull, TupleTableSlot::tts_tableOid, TupleTableSlot::tts_values, CopyStateData::volatile_defexprs, and CopyStateData::whereClause.

Referenced by copy_table(), and DoCopy().

{
    ResultRelInfo *resultRelInfo;
    ResultRelInfo *target_resultRelInfo;
    ResultRelInfo *prevResultRelInfo = NULL;
    EState     *estate = CreateExecutorState(); /* for ExecConstraints() */
    ModifyTableState *mtstate;
    ExprContext *econtext;
    TupleTableSlot *singleslot = NULL;
    MemoryContext oldcontext = CurrentMemoryContext;

    PartitionTupleRouting *proute = NULL;
    ErrorContextCallback errcallback;
    CommandId   mycid = GetCurrentCommandId(true);
    int         ti_options = 0; /* start with default options for insert */
    BulkInsertState bistate = NULL;
    CopyInsertMethod insertMethod;
    CopyMultiInsertInfo multiInsertInfo = {0};  /* pacify compiler */
    uint64      processed = 0;
    bool        has_before_insert_row_trig;
    bool        has_instead_insert_row_trig;
    bool        leafpart_use_multi_insert = false;

    Assert(cstate->rel);

    /*
     * The target must be a plain, foreign, or partitioned relation, or have
     * an INSTEAD OF INSERT row trigger.  (Currently, such triggers are only
     * allowed on views, so we only hint about them in the view case.)
     */
    if (cstate->rel->rd_rel->relkind != RELKIND_RELATION &&
        cstate->rel->rd_rel->relkind != RELKIND_FOREIGN_TABLE &&
        cstate->rel->rd_rel->relkind != RELKIND_PARTITIONED_TABLE &&
        !(cstate->rel->trigdesc &&
          cstate->rel->trigdesc->trig_insert_instead_row))
    {
        if (cstate->rel->rd_rel->relkind == RELKIND_VIEW)
            ereport(ERROR,
                    (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                     errmsg("cannot copy to view \"%s\"",
                            RelationGetRelationName(cstate->rel)),
                     errhint("To enable copying to a view, provide an INSTEAD OF INSERT trigger.")));
        else if (cstate->rel->rd_rel->relkind == RELKIND_MATVIEW)
            ereport(ERROR,
                    (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                     errmsg("cannot copy to materialized view \"%s\"",
                            RelationGetRelationName(cstate->rel))));
        else if (cstate->rel->rd_rel->relkind == RELKIND_SEQUENCE)
            ereport(ERROR,
                    (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                     errmsg("cannot copy to sequence \"%s\"",
                            RelationGetRelationName(cstate->rel))));
        else
            ereport(ERROR,
                    (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                     errmsg("cannot copy to non-table relation \"%s\"",
                            RelationGetRelationName(cstate->rel))));
    }

    /*
     * If the target file is new-in-transaction, we assume that checking FSM
     * for free space is a waste of time.  This could possibly be wrong, but
     * it's unlikely.
     */
    if (RELKIND_HAS_STORAGE(cstate->rel->rd_rel->relkind) &&
        (cstate->rel->rd_createSubid != InvalidSubTransactionId ||
         cstate->rel->rd_firstRelfilenodeSubid != InvalidSubTransactionId))
        ti_options |= TABLE_INSERT_SKIP_FSM;

    /*
     * Optimize if new relfilenode was created in this subxact or one of its
     * committed children and we won't see those rows later as part of an
     * earlier scan or command. The subxact test ensures that if this subxact
     * aborts then the frozen rows won't be visible after xact cleanup.  Note
     * that the stronger test of exactly which subtransaction created it is
     * crucial for correctness of this optimization. The test for an earlier
     * scan or command tolerates false negatives. FREEZE causes other sessions
     * to see rows they would not see under MVCC, and a false negative merely
     * spreads that anomaly to the current session.
     */
    if (cstate->freeze)
    {
        /*
         * We currently disallow COPY FREEZE on partitioned tables.  The
         * reason for this is that we've simply not yet opened the partitions
         * to determine if the optimization can be applied to them.  We could
         * go and open them all here, but doing so may be quite a costly
         * overhead for small copies.  In any case, we may just end up routing
         * tuples to a small number of partitions.  It seems better just to
         * raise an ERROR for partitioned tables.
         */
        if (cstate->rel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE)
        {
            ereport(ERROR,
                    (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                     errmsg("cannot perform COPY FREEZE on a partitioned table")));
        }

        /*
         * Tolerate one registration for the benefit of FirstXactSnapshot.
         * Scan-bearing queries generally create at least two registrations,
         * though relying on that is fragile, as is ignoring ActiveSnapshot.
         * Clear CatalogSnapshot to avoid counting its registration.  We'll
         * still detect ongoing catalog scans, each of which separately
         * registers the snapshot it uses.
         */
        InvalidateCatalogSnapshot();
        if (!ThereAreNoPriorRegisteredSnapshots() || !ThereAreNoReadyPortals())
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_TRANSACTION_STATE),
                     errmsg("cannot perform COPY FREEZE because of prior transaction activity")));

        if (cstate->rel->rd_createSubid != GetCurrentSubTransactionId() &&
            cstate->rel->rd_newRelfilenodeSubid != GetCurrentSubTransactionId())
            ereport(ERROR,
                    (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
                     errmsg("cannot perform COPY FREEZE because the table was not created or truncated in the current subtransaction")));

        ti_options |= TABLE_INSERT_FROZEN;
    }

    /*
     * We need a ResultRelInfo so we can use the regular executor's
     * index-entry-making machinery.  (There used to be a huge amount of code
     * here that basically duplicated execUtils.c ...)
     */
    resultRelInfo = makeNode(ResultRelInfo);
    InitResultRelInfo(resultRelInfo,
                      cstate->rel,
                      1,        /* must match rel's position in range_table */
                      NULL,
                      0);
    target_resultRelInfo = resultRelInfo;

    /* Verify the named relation is a valid target for INSERT */
    CheckValidResultRel(resultRelInfo, CMD_INSERT);

    ExecOpenIndices(resultRelInfo, false);

    estate->es_result_relations = resultRelInfo;
    estate->es_num_result_relations = 1;
    estate->es_result_relation_info = resultRelInfo;

    ExecInitRangeTable(estate, cstate->range_table);

    /*
     * 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->resultRelInfo = estate->es_result_relations;

    if (resultRelInfo->ri_FdwRoutine != NULL &&
        resultRelInfo->ri_FdwRoutine->BeginForeignInsert != NULL)
        resultRelInfo->ri_FdwRoutine->BeginForeignInsert(mtstate,
                                                         resultRelInfo);

    /* Prepare to catch AFTER triggers. */
    AfterTriggerBeginQuery();

    /*
     * If there are any triggers with transition tables on the named relation,
     * we need to be prepared to capture transition tuples.
     *
     * Because partition tuple routing would like to know about whether
     * transition capture is active, we also set it in mtstate, which is
     * passed to ExecFindPartition() below.
     */
    cstate->transition_capture = mtstate->mt_transition_capture =
        MakeTransitionCaptureState(cstate->rel->trigdesc,
                                   RelationGetRelid(cstate->rel),
                                   CMD_INSERT);

    /*
     * If the named relation is a partitioned table, initialize state for
     * CopyFrom tuple routing.
     */
    if (cstate->rel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE)
        proute = ExecSetupPartitionTupleRouting(estate, NULL, cstate->rel);

    if (cstate->whereClause)
        cstate->qualexpr = ExecInitQual(castNode(List, cstate->whereClause),
                                        &mtstate->ps);

    /*
     * It's generally more efficient to prepare a bunch of tuples for
     * insertion, and insert them in one table_multi_insert() call, than call
     * table_tuple_insert() separately for every tuple. However, there are a
     * number of reasons why we might not be able to do this.  These are
     * explained below.
     */
    if (resultRelInfo->ri_TrigDesc != NULL &&
        (resultRelInfo->ri_TrigDesc->trig_insert_before_row ||
         resultRelInfo->ri_TrigDesc->trig_insert_instead_row))
    {
        /*
         * Can't support multi-inserts when there are any BEFORE/INSTEAD OF
         * triggers on the table. Such triggers might query the table we're
         * inserting into and act differently if the tuples that have already
         * been processed and prepared for insertion are not there.
         */
        insertMethod = CIM_SINGLE;
    }
    else if (proute != NULL && resultRelInfo->ri_TrigDesc != NULL &&
             resultRelInfo->ri_TrigDesc->trig_insert_new_table)
    {
        /*
         * For partitioned tables we can't support multi-inserts when there
         * are any statement level insert triggers. It might be possible to
         * allow partitioned tables with such triggers in the future, but for
         * now, CopyMultiInsertInfoFlush expects that any before row insert
         * and statement level insert triggers are on the same relation.
         */
        insertMethod = CIM_SINGLE;
    }
    else if (resultRelInfo->ri_FdwRoutine != NULL ||
             cstate->volatile_defexprs)
    {
        /*
         * Can't support multi-inserts to foreign tables or if there are any
         * volatile default expressions in the table.  Similarly to the
         * trigger case above, such expressions may query the table we're
         * inserting into.
         *
         * Note: It does not matter if any partitions have any volatile
         * default expressions as we use the defaults from the target of the
         * COPY command.
         */
        insertMethod = CIM_SINGLE;
    }
    else if (contain_volatile_functions(cstate->whereClause))
    {
        /*
         * Can't support multi-inserts if there are any volatile function
         * expressions in WHERE clause.  Similarly to the trigger case above,
         * such expressions may query the table we're inserting into.
         */
        insertMethod = CIM_SINGLE;
    }
    else
    {
        /*
         * For partitioned tables, we may still be able to perform bulk
         * inserts.  However, the possibility of this depends on which types
         * of triggers exist on the partition.  We must disable bulk inserts
         * if the partition is a foreign table or it has any before row insert
         * or insert instead triggers (same as we checked above for the parent
         * table).  Since the partition's resultRelInfos are initialized only
         * when we actually need to insert the first tuple into them, we must
         * have the intermediate insert method of CIM_MULTI_CONDITIONAL to
         * flag that we must later determine if we can use bulk-inserts for
         * the partition being inserted into.
         */
        if (proute)
            insertMethod = CIM_MULTI_CONDITIONAL;
        else
            insertMethod = CIM_MULTI;

        CopyMultiInsertInfoInit(&multiInsertInfo, resultRelInfo, cstate,
                                estate, mycid, ti_options);
    }

    /*
     * If not using batch mode (which allocates slots as needed) set up a
     * tuple slot too. When inserting into a partitioned table, we also need
     * one, even if we might batch insert, to read the tuple in the root
     * partition's form.
     */
    if (insertMethod == CIM_SINGLE || insertMethod == CIM_MULTI_CONDITIONAL)
    {
        singleslot = table_slot_create(resultRelInfo->ri_RelationDesc,
                                       &estate->es_tupleTable);
        bistate = GetBulkInsertState();
    }

    has_before_insert_row_trig = (resultRelInfo->ri_TrigDesc &&
                                  resultRelInfo->ri_TrigDesc->trig_insert_before_row);

    has_instead_insert_row_trig = (resultRelInfo->ri_TrigDesc &&
                                   resultRelInfo->ri_TrigDesc->trig_insert_instead_row);

    /*
     * Check BEFORE STATEMENT insertion triggers. It's debatable whether we
     * should do this for COPY, since it's not really an "INSERT" statement as
     * such. However, executing these triggers maintains consistency with the
     * EACH ROW triggers that we already fire on COPY.
     */
    ExecBSInsertTriggers(estate, resultRelInfo);

    econtext = GetPerTupleExprContext(estate);

    /* Set up callback to identify error line number */
    errcallback.callback = CopyFromErrorCallback;
    errcallback.arg = (void *) cstate;
    errcallback.previous = error_context_stack;
    error_context_stack = &errcallback;

    for (;;)
    {
        TupleTableSlot *myslot;
        bool        skip_tuple;

        CHECK_FOR_INTERRUPTS();

        /*
         * Reset the per-tuple exprcontext. We do this after every tuple, to
         * clean-up after expression evaluations etc.
         */
        ResetPerTupleExprContext(estate);

        /* select slot to (initially) load row into */
        if (insertMethod == CIM_SINGLE || proute)
        {
            myslot = singleslot;
            Assert(myslot != NULL);
        }
        else
        {
            Assert(resultRelInfo == target_resultRelInfo);
            Assert(insertMethod == CIM_MULTI);

            myslot = CopyMultiInsertInfoNextFreeSlot(&multiInsertInfo,
                                                     resultRelInfo);
        }

        /*
         * Switch to per-tuple context before calling NextCopyFrom, which does
         * evaluate default expressions etc. and requires per-tuple context.
         */
        MemoryContextSwitchTo(GetPerTupleMemoryContext(estate));

        ExecClearTuple(myslot);

        /* Directly store the values/nulls array in the slot */
        if (!NextCopyFrom(cstate, econtext, myslot->tts_values, myslot->tts_isnull))
            break;

        ExecStoreVirtualTuple(myslot);

        /*
         * Constraints and where clause might reference the tableoid column,
         * so (re-)initialize tts_tableOid before evaluating them.
         */
        myslot->tts_tableOid = RelationGetRelid(target_resultRelInfo->ri_RelationDesc);

        /* Triggers and stuff need to be invoked in query context. */
        MemoryContextSwitchTo(oldcontext);

        if (cstate->whereClause)
        {
            econtext->ecxt_scantuple = myslot;
            /* Skip items that don't match COPY's WHERE clause */
            if (!ExecQual(cstate->qualexpr, econtext))
                continue;
        }

        /* Determine the partition to insert the tuple into */
        if (proute)
        {
            TupleConversionMap *map;

            /*
             * Attempt to find a partition suitable for this tuple.
             * ExecFindPartition() will raise an error if none can be found or
             * if the found partition is not suitable for INSERTs.
             */
            resultRelInfo = ExecFindPartition(mtstate, target_resultRelInfo,
                                              proute, myslot, estate);

            if (prevResultRelInfo != resultRelInfo)
            {
                /* Determine which triggers exist on this partition */
                has_before_insert_row_trig = (resultRelInfo->ri_TrigDesc &&
                                              resultRelInfo->ri_TrigDesc->trig_insert_before_row);

                has_instead_insert_row_trig = (resultRelInfo->ri_TrigDesc &&
                                               resultRelInfo->ri_TrigDesc->trig_insert_instead_row);

                /*
                 * Disable multi-inserts when the partition has BEFORE/INSTEAD
                 * OF triggers, or if the partition is a foreign partition.
                 */
                leafpart_use_multi_insert = insertMethod == CIM_MULTI_CONDITIONAL &&
                    !has_before_insert_row_trig &&
                    !has_instead_insert_row_trig &&
                    resultRelInfo->ri_FdwRoutine == NULL;

                /* Set the multi-insert buffer to use for this partition. */
                if (leafpart_use_multi_insert)
                {
                    if (resultRelInfo->ri_CopyMultiInsertBuffer == NULL)
                        CopyMultiInsertInfoSetupBuffer(&multiInsertInfo,
                                                       resultRelInfo);
                }
                else if (insertMethod == CIM_MULTI_CONDITIONAL &&
                         !CopyMultiInsertInfoIsEmpty(&multiInsertInfo))
                {
                    /*
                     * Flush pending inserts if this partition can't use
                     * batching, so rows are visible to triggers etc.
                     */
                    CopyMultiInsertInfoFlush(&multiInsertInfo, resultRelInfo);
                }

                if (bistate != NULL)
                    ReleaseBulkInsertStatePin(bistate);
                prevResultRelInfo = resultRelInfo;
            }

            /*
             * For ExecInsertIndexTuples() to work on the partition's indexes
             */
            estate->es_result_relation_info = resultRelInfo;

            /*
             * If we're capturing transition tuples, we might need to convert
             * from the partition rowtype to root rowtype.
             */
            if (cstate->transition_capture != NULL)
            {
                if (has_before_insert_row_trig)
                {
                    /*
                     * If there are any BEFORE triggers on the partition,
                     * we'll have to be ready to convert their result back to
                     * tuplestore format.
                     */
                    cstate->transition_capture->tcs_original_insert_tuple = NULL;
                    cstate->transition_capture->tcs_map =
                        resultRelInfo->ri_PartitionInfo->pi_PartitionToRootMap;
                }
                else
                {
                    /*
                     * Otherwise, just remember the original unconverted
                     * tuple, to avoid a needless round trip conversion.
                     */
                    cstate->transition_capture->tcs_original_insert_tuple = myslot;
                    cstate->transition_capture->tcs_map = NULL;
                }
            }

            /*
             * We might need to convert from the root rowtype to the partition
             * rowtype.
             */
            map = resultRelInfo->ri_PartitionInfo->pi_RootToPartitionMap;
            if (insertMethod == CIM_SINGLE || !leafpart_use_multi_insert)
            {
                /* non batch insert */
                if (map != NULL)
                {
                    TupleTableSlot *new_slot;

                    new_slot = resultRelInfo->ri_PartitionInfo->pi_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(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_PartitionCheck &&
                    (proute == NULL || has_before_insert_row_trig))
                    ExecPartitionCheck(resultRelInfo, myslot, estate, true);

                /* Store the slot in the multi-insert buffer, when enabled. */
                if (insertMethod == CIM_MULTI || leafpart_use_multi_insert)
                {
                    /*
                     * The slot previously might point into the per-tuple
                     * context. For batching it needs to be longer lived.
                     */
                    ExecMaterializeSlot(myslot);

                    /* Add this tuple to the tuple buffer */
                    CopyMultiInsertInfoStore(&multiInsertInfo,
                                             resultRelInfo, myslot,
                                             cstate->line_buf.len,
                                             cstate->cur_lineno);

                    /*
                     * If enough inserts have queued up, then flush all
                     * buffers out to their tables.
                     */
                    if (CopyMultiInsertInfoIsFull(&multiInsertInfo))
                        CopyMultiInsertInfoFlush(&multiInsertInfo, resultRelInfo);
                }
                else
                {
                    List       *recheckIndexes = NIL;

                    /* OK, store the tuple */
                    if (resultRelInfo->ri_FdwRoutine != NULL)
                    {
                        myslot = resultRelInfo->ri_FdwRoutine->ExecForeignInsert(estate,
                                                                                 resultRelInfo,
                                                                                 myslot,
                                                                                 NULL);

                        if (myslot == NULL) /* "do nothing" */
                            continue;   /* next tuple please */

                        /*
                         * AFTER ROW Triggers might reference the tableoid
                         * column, so (re-)initialize tts_tableOid before
                         * evaluating them.
                         */
                        myslot->tts_tableOid = RelationGetRelid(resultRelInfo->ri_RelationDesc);
                    }
                    else
                    {
                        /* OK, store the tuple and create index entries for it */
                        table_tuple_insert(resultRelInfo->ri_RelationDesc,
                                           myslot, mycid, ti_options, bistate);

                        if (resultRelInfo->ri_NumIndices > 0)
                            recheckIndexes = ExecInsertIndexTuples(myslot,
                                                                   estate,
                                                                   false,
                                                                   NULL,
                                                                   NIL);
                    }

                    /* AFTER ROW INSERT Triggers */
                    ExecARInsertTriggers(estate, resultRelInfo, myslot,
                                         recheckIndexes, cstate->transition_capture);

                    list_free(recheckIndexes);
                }
            }

            /*
             * We count only tuples not suppressed by a BEFORE INSERT trigger
             * or FDW; this is the same definition used by nodeModifyTable.c
             * for counting tuples inserted by an INSERT command.
             */
            processed++;
        }
    }

    /* Flush any remaining buffered tuples */
    if (insertMethod != CIM_SINGLE)
    {
        if (!CopyMultiInsertInfoIsEmpty(&multiInsertInfo))
            CopyMultiInsertInfoFlush(&multiInsertInfo, NULL);
    }

    /* Done, clean up */
    error_context_stack = errcallback.previous;

    if (bistate != NULL)
        FreeBulkInsertState(bistate);

    MemoryContextSwitchTo(oldcontext);

    /*
     * In the old protocol, tell pqcomm that we can process normal protocol
     * messages again.
     */
    if (cstate->copy_dest == COPY_OLD_FE)
        pq_endmsgread();

    /* 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);

    ExecCloseIndices(target_resultRelInfo);

    /* Close all the partitioned tables, leaf partitions, and their indices */
    if (proute)
        ExecCleanupTupleRouting(mtstate, proute);

    /* Close any trigger target relations */
    ExecCleanUpTriggerState(estate);

    FreeExecutorState(estate);

    return processed;
}

CopyFromErrorCallback()

void CopyFromErrorCallback

(

void *

arg

)

Definition at line 2234 of file copy.c.

References CopyStateData::binary, CopyStateData::cur_attname, CopyStateData::cur_attval, CopyStateData::cur_lineno, CopyStateData::cur_relname, StringInfoData::data, errcontext, limit_printout_length(), CopyStateData::line_buf, CopyStateData::line_buf_converted, CopyStateData::line_buf_valid, CopyStateData::need_transcoding, pfree(), snprintf, and UINT64_FORMAT.

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

{
    CopyState   cstate = (CopyState) arg;
    char        curlineno_str[32];

    snprintf(curlineno_str, sizeof(curlineno_str), UINT64_FORMAT,
             cstate->cur_lineno);

    if (cstate->binary)
    {
        /* can't usefully display the data */
        if (cstate->cur_attname)
            errcontext("COPY %s, line %s, column %s",
                       cstate->cur_relname, curlineno_str,
                       cstate->cur_attname);
        else
            errcontext("COPY %s, line %s",
                       cstate->cur_relname, curlineno_str);
    }
    else
    {
        if (cstate->cur_attname && cstate->cur_attval)
        {
            /* error is relevant to a particular column */
            char       *attval;

            attval = limit_printout_length(cstate->cur_attval);
            errcontext("COPY %s, line %s, column %s: \"%s\"",
                       cstate->cur_relname, curlineno_str,
                       cstate->cur_attname, attval);
            pfree(attval);
        }
        else if (cstate->cur_attname)
        {
            /* error is relevant to a particular column, value is NULL */
            errcontext("COPY %s, line %s, column %s: null input",
                       cstate->cur_relname, curlineno_str,
                       cstate->cur_attname);
        }
        else
        {
            /*
             * Error is relevant to a particular line.
             *
             * If line_buf still contains the correct line, and it's already
             * transcoded, print it. If it's still in a foreign encoding, it's
             * quite likely that the error is precisely a failure to do
             * encoding conversion (ie, bad data). We dare not try to convert
             * it, and at present there's no way to regurgitate it without
             * conversion. So we have to punt and just report the line number.
             */
            if (cstate->line_buf_valid &&
                (cstate->line_buf_converted || !cstate->need_transcoding))
            {
                char       *lineval;

                lineval = limit_printout_length(cstate->line_buf.data);
                errcontext("COPY %s, line %s: \"%s\"",
                           cstate->cur_relname, curlineno_str, lineval);
                pfree(lineval);
            }
            else
            {
                errcontext("COPY %s, line %s",
                           cstate->cur_relname, curlineno_str);
            }
        }
    }
}

CreateCopyDestReceiver()

DestReceiver* CreateCopyDestReceiver

(

void

)

Definition at line 5149 of file copy.c.

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

Referenced by CreateDestReceiver().

{
    DR_copy    *self = (DR_copy *) palloc(sizeof(DR_copy));

    self->pub.receiveSlot = copy_dest_receive;
    self->pub.rStartup = copy_dest_startup;
    self->pub.rShutdown = copy_dest_shutdown;
    self->pub.rDestroy = copy_dest_destroy;
    self->pub.mydest = DestCopyOut;

    self->cstate = NULL;        /* will be set later */
    self->processed = 0;

    return (DestReceiver *) self;
}

DoCopy()

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

Definition at line 838 of file copy.c.

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

Referenced by standard_ProcessUtility().

{
    CopyState   cstate;
    bool        is_from = stmt->is_from;
    bool        pipe = (stmt->filename == NULL);
    Relation    rel;
    Oid         relid;
    RawStmt    *query = NULL;
    Node       *whereClause = NULL;

    /*
     * Disallow COPY to/from file or program except to users with the
     * appropriate role.
     */
    if (!pipe)
    {
        if (stmt->is_program)
        {
            if (!is_member_of_role(GetUserId(), DEFAULT_ROLE_EXECUTE_SERVER_PROGRAM))
                ereport(ERROR,
                        (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
                         errmsg("must be superuser or a member of the pg_execute_server_program role to COPY to or from an external program"),
                         errhint("Anyone can COPY to stdout or from stdin. "
                                 "psql's \\copy command also works for anyone.")));
        }
        else
        {
            if (is_from && !is_member_of_role(GetUserId(), DEFAULT_ROLE_READ_SERVER_FILES))
                ereport(ERROR,
                        (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
                         errmsg("must be superuser or a member of the pg_read_server_files role to COPY from a file"),
                         errhint("Anyone can COPY to stdout or from stdin. "
                                 "psql's \\copy command also works for anyone.")));

            if (!is_from && !is_member_of_role(GetUserId(), DEFAULT_ROLE_WRITE_SERVER_FILES))
                ereport(ERROR,
                        (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
                         errmsg("must be superuser or a member of the pg_write_server_files role to COPY to a file"),
                         errhint("Anyone can COPY to stdout or from stdin. "
                                 "psql's \\copy command also works for anyone.")));
        }
    }

    if (stmt->relation)
    {
        LOCKMODE    lockmode = is_from ? RowExclusiveLock : AccessShareLock;
        ParseNamespaceItem *nsitem;
        RangeTblEntry *rte;
        TupleDesc   tupDesc;
        List       *attnums;
        ListCell   *cur;

        Assert(!stmt->query);

        /* Open and lock the relation, using the appropriate lock type. */
        rel = table_openrv(stmt->relation, lockmode);

        relid = RelationGetRelid(rel);

        nsitem = addRangeTableEntryForRelation(pstate, rel, lockmode,
                                               NULL, false, false);
        rte = nsitem->p_rte;
        rte->requiredPerms = (is_from ? ACL_INSERT : ACL_SELECT);

        if (stmt->whereClause)
        {
            /* add nsitem to query namespace */
            addNSItemToQuery(pstate, nsitem, false, true, true);

            /* Transform the raw expression tree */
            whereClause = transformExpr(pstate, stmt->whereClause, EXPR_KIND_COPY_WHERE);

            /* Make sure it yields a boolean result. */
            whereClause = coerce_to_boolean(pstate, whereClause, "WHERE");

            /* we have to fix its collations too */
            assign_expr_collations(pstate, whereClause);

            whereClause = eval_const_expressions(NULL, whereClause);

            whereClause = (Node *) canonicalize_qual((Expr *) whereClause, false);
            whereClause = (Node *) make_ands_implicit((Expr *) whereClause);
        }

        tupDesc = RelationGetDescr(rel);
        attnums = CopyGetAttnums(tupDesc, rel, stmt->attlist);
        foreach(cur, attnums)
        {
            int         attno = lfirst_int(cur) -
            FirstLowInvalidHeapAttributeNumber;

            if (is_from)
                rte->insertedCols = bms_add_member(rte->insertedCols, attno);
            else
                rte->selectedCols = bms_add_member(rte->selectedCols, attno);
        }
        ExecCheckRTPerms(pstate->p_rtable, true);

        /*
         * Permission check for row security policies.
         *
         * check_enable_rls will ereport(ERROR) if the user has requested
         * something invalid and will otherwise indicate if we should enable
         * RLS (returns RLS_ENABLED) or not for this COPY statement.
         *
         * If the relation has a row security policy and we are to apply it
         * then perform a "query" copy and allow the normal query processing
         * to handle the policies.
         *
         * If RLS is not enabled for this, then just fall through to the
         * normal non-filtering relation handling.
         */
        if (check_enable_rls(rte->relid, InvalidOid, false) == RLS_ENABLED)
        {
            SelectStmt *select;
            ColumnRef  *cr;
            ResTarget  *target;
            RangeVar   *from;
            List       *targetList = NIL;

            if (is_from)
                ereport(ERROR,
                        (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                         errmsg("COPY FROM not supported with row-level security"),
                         errhint("Use INSERT statements instead.")));

            /*
             * Build target list
             *
             * If no columns are specified in the attribute list of the COPY
             * command, then the target list is 'all' columns. Therefore, '*'
             * should be used as the target list for the resulting SELECT
             * statement.
             *
             * In the case that columns are specified in the attribute list,
             * create a ColumnRef and ResTarget for each column and add them
             * to the target list for the resulting SELECT statement.
             */
            if (!stmt->attlist)
            {
                cr = makeNode(ColumnRef);
                cr->fields = list_make1(makeNode(A_Star));
                cr->location = -1;

                target = makeNode(ResTarget);
                target->name = NULL;
                target->indirection = NIL;
                target->val = (Node *) cr;
                target->location = -1;

                targetList = list_make1(target);
            }
            else
            {
                ListCell   *lc;

                foreach(lc, stmt->attlist)
                {
                    /*
                     * Build the ColumnRef for each column.  The ColumnRef
                     * 'fields' property is a String 'Value' node (see
                     * nodes/value.h) that corresponds to the column name
                     * respectively.
                     */
                    cr = makeNode(ColumnRef);
                    cr->fields = list_make1(lfirst(lc));
                    cr->location = -1;

                    /* Build the ResTarget and add the ColumnRef to it. */
                    target = makeNode(ResTarget);
                    target->name = NULL;
                    target->indirection = NIL;
                    target->val = (Node *) cr;
                    target->location = -1;

                    /* Add each column to the SELECT statement's target list */
                    targetList = lappend(targetList, target);
                }
            }

            /*
             * Build RangeVar for from clause, fully qualified based on the
             * relation which we have opened and locked.
             */
            from = makeRangeVar(get_namespace_name(RelationGetNamespace(rel)),
                                pstrdup(RelationGetRelationName(rel)),
                                -1);

            /* Build query */
            select = makeNode(SelectStmt);
            select->targetList = targetList;
            select->fromClause = list_make1(from);

            query = makeNode(RawStmt);
            query->stmt = (Node *) select;
            query->stmt_location = stmt_location;
            query->stmt_len = stmt_len;

            /*
             * Close the relation for now, but keep the lock on it to prevent
             * changes between now and when we start the query-based COPY.
             *
             * We'll reopen it later as part of the query-based COPY.
             */
            table_close(rel, NoLock);
            rel = NULL;
        }
    }
    else
    {
        Assert(stmt->query);

        query = makeNode(RawStmt);
        query->stmt = stmt->query;
        query->stmt_location = stmt_location;
        query->stmt_len = stmt_len;

        relid = InvalidOid;
        rel = NULL;
    }

    if (is_from)
    {
        Assert(rel);

        /* check read-only transaction and parallel mode */
        if (XactReadOnly && !rel->rd_islocaltemp)
            PreventCommandIfReadOnly("COPY FROM");

        cstate = BeginCopyFrom(pstate, rel, stmt->filename, stmt->is_program,
                               NULL, stmt->attlist, stmt->options);
        cstate->whereClause = whereClause;
        *processed = CopyFrom(cstate);  /* copy from file to database */
        EndCopyFrom(cstate);
    }
    else
    {
        cstate = BeginCopyTo(pstate, rel, query, relid,
                             stmt->filename, stmt->is_program,
                             stmt->attlist, stmt->options);
        *processed = DoCopyTo(cstate);  /* copy from database to file */
        EndCopyTo(cstate);
    }

    if (rel != NULL)
        table_close(rel, NoLock);
}

EndCopyFrom()

void EndCopyFrom

(

CopyState

cstate

)

Definition at line 3823 of file copy.c.

References EndCopy().

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

{
    /* No COPY FROM related resources except memory. */

    EndCopy(cstate);
}

NextCopyFrom()

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

Definition at line 3635 of file copy.c.

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

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

{
    TupleDesc   tupDesc;
    AttrNumber  num_phys_attrs,
                attr_count,
                num_defaults = cstate->num_defaults;
    FmgrInfo   *in_functions = cstate->in_functions;
    Oid        *typioparams = cstate->typioparams;
    int         i;
    int        *defmap = cstate->defmap;
    ExprState **defexprs = cstate->defexprs;

    tupDesc = RelationGetDescr(cstate->rel);
    num_phys_attrs = tupDesc->natts;
    attr_count = list_length(cstate->attnumlist);

    /* Initialize all values for row to NULL */
    MemSet(values, 0, num_phys_attrs * sizeof(Datum));
    MemSet(nulls, true, num_phys_attrs * sizeof(bool));

    if (!cstate->binary)
    {
        char      **field_strings;
        ListCell   *cur;
        int         fldct;
        int         fieldno;
        char       *string;

        /* read raw fields in the next line */
        if (!NextCopyFromRawFields(cstate, &field_strings, &fldct))
            return false;

        /* check for overflowing fields */
        if (attr_count > 0 && fldct > attr_count)
            ereport(ERROR,
                    (errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
                     errmsg("extra data after last expected column")));

        fieldno = 0;

        /* Loop to read the user attributes on the line. */
        foreach(cur, cstate->attnumlist)
        {
            int         attnum = lfirst_int(cur);
            int         m = attnum - 1;
            Form_pg_attribute att = TupleDescAttr(tupDesc, m);

            if (fieldno >= fldct)
                ereport(ERROR,
                        (errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
                         errmsg("missing data for column \"%s\"",
                                NameStr(att->attname))));
            string = field_strings[fieldno++];

            if (cstate->convert_select_flags &&
                !cstate->convert_select_flags[m])
            {
                /* ignore input field, leaving column as NULL */
                continue;
            }

            if (cstate->csv_mode)
            {
                if (string == NULL &&
                    cstate->force_notnull_flags[m])
                {
                    /*
                     * FORCE_NOT_NULL option is set and column is NULL -
                     * convert it to the NULL string.
                     */
                    string = cstate->null_print;
                }
                else if (string != NULL && cstate->force_null_flags[m]
                         && strcmp(string, cstate->null_print) == 0)
                {
                    /*
                     * FORCE_NULL option is set and column matches the NULL
                     * string. It must have been quoted, or otherwise the
                     * string would already have been set to NULL. Convert it
                     * to NULL as specified.
                     */
                    string = NULL;
                }
            }

            cstate->cur_attname = NameStr(att->attname);
            cstate->cur_attval = string;
            values[m] = InputFunctionCall(&in_functions[m],
                                          string,
                                          typioparams[m],
                                          att->atttypmod);
            if (string != NULL)
                nulls[m] = false;
            cstate->cur_attname = NULL;
            cstate->cur_attval = NULL;
        }

        Assert(fieldno == attr_count);
    }
    else
    {
        /* binary */
        int16       fld_count;
        ListCell   *cur;

        cstate->cur_lineno++;

        if (!CopyGetInt16(cstate, &fld_count))
        {
            /* EOF detected (end of file, or protocol-level EOF) */
            return false;
        }

        if (fld_count == -1)
        {
            /*
             * Received EOF marker.  In a V3-protocol copy, wait for the
             * protocol-level EOF, and complain if it doesn't come
             * immediately.  This ensures that we correctly handle CopyFail,
             * if client chooses to send that now.
             *
             * Note that we MUST NOT try to read more data in an old-protocol
             * copy, since there is no protocol-level EOF marker then.  We
             * could go either way for copy from file, but choose to throw
             * error if there's data after the EOF marker, for consistency
             * with the new-protocol case.
             */
            char        dummy;

            if (cstate->copy_dest != COPY_OLD_FE &&
                CopyGetData(cstate, &dummy, 1, 1) > 0)
                ereport(ERROR,
                        (errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
                         errmsg("received copy data after EOF marker")));
            return false;
        }

        if (fld_count != attr_count)
            ereport(ERROR,
                    (errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
                     errmsg("row field count is %d, expected %d",
                            (int) fld_count, attr_count)));

        i = 0;
        foreach(cur, cstate->attnumlist)
        {
            int         attnum = lfirst_int(cur);
            int         m = attnum - 1;
            Form_pg_attribute att = TupleDescAttr(tupDesc, m);

            cstate->cur_attname = NameStr(att->attname);
            i++;
            values[m] = CopyReadBinaryAttribute(cstate,
                                                i,
                                                &in_functions[m],
                                                typioparams[m],
                                                att->atttypmod,
                                                &nulls[m]);
            cstate->cur_attname = NULL;
        }
    }

    /*
     * Now compute and insert any defaults available for the columns not
     * provided by the input data.  Anything not processed here or above will
     * remain NULL.
     */
    for (i = 0; i < num_defaults; i++)
    {
        /*
         * The caller must supply econtext and have switched into the
         * per-tuple memory context in it.
         */
        Assert(econtext != NULL);
        Assert(CurrentMemoryContext == econtext->ecxt_per_tuple_memory);

        values[defmap[i]] = ExecEvalExpr(defexprs[i], econtext,
                                         &nulls[defmap[i]]);
    }

    return true;
}

NextCopyFromRawFields()

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

Definition at line 3583 of file copy.c.

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

Referenced by NextCopyFrom().

{
    int         fldct;
    bool        done;

    /* only available for text or csv input */
    Assert(!cstate->binary);

    /* on input just throw the header line away */
    if (cstate->cur_lineno == 0 && cstate->header_line)
    {
        cstate->cur_lineno++;
        if (CopyReadLine(cstate))
            return false;       /* done */
    }

    cstate->cur_lineno++;

    /* Actually read the line into memory here */
    done = CopyReadLine(cstate);

    /*
     * EOF at start of line means we're done.  If we see EOF after some
     * characters, we act as though it was newline followed by EOF, ie,
     * process the line and then exit loop on next iteration.
     */
    if (done && cstate->line_buf.len == 0)
        return false;

    /* Parse the line into de-escaped field values */
    if (cstate->csv_mode)
        fldct = CopyReadAttributesCSV(cstate);
    else
        fldct = CopyReadAttributesText(cstate);

    *fields = cstate->raw_fields;
    *nfields = fldct;
    return true;
}

ProcessCopyOptions()

void ProcessCopyOptions	(	ParseState *	pstate,
		CopyState	cstate,
		bool	is_from,
		List *	options
	)

Definition at line 1106 of file copy.c.

References DefElem::arg, CopyStateData::binary, castNode, CopyStateData::convert_select, CopyStateData::convert_selectively, CopyStateData::csv_mode, defGetBoolean(), defGetString(), DefElem::defname, CopyStateData::delim, ereport, errcode(), errmsg(), ERROR, CopyStateData::escape, CopyStateData::file_encoding, CopyStateData::force_notnull, CopyStateData::force_null, CopyStateData::force_quote, CopyStateData::force_quote_all, CopyStateData::freeze, CopyStateData::header_line, CopyStateData::is_copy_from, IsA, lfirst_node, DefElem::location, NIL, CopyStateData::null_print, CopyStateData::null_print_len, palloc0(), parser_errposition(), pg_char_to_encoding(), and CopyStateData::quote.

Referenced by BeginCopy(), and file_fdw_validator().

{
    bool        format_specified = false;
    ListCell   *option;

    /* Support external use for option sanity checking */
    if (cstate == NULL)
        cstate = (CopyStateData *) palloc0(sizeof(CopyStateData));

    cstate->is_copy_from = is_from;

    cstate->file_encoding = -1;

    /* Extract options from the statement node tree */
    foreach(option, options)
    {
        DefElem    *defel = lfirst_node(DefElem, option);

        if (strcmp(defel->defname, "format") == 0)
        {
            char       *fmt = defGetString(defel);

            if (format_specified)
                ereport(ERROR,
                        (errcode(ERRCODE_SYNTAX_ERROR),
                         errmsg("conflicting or redundant options"),
                         parser_errposition(pstate, defel->location)));
            format_specified = true;
            if (strcmp(fmt, "text") == 0)
                 /* default format */ ;
            else if (strcmp(fmt, "csv") == 0)
                cstate->csv_mode = true;
            else if (strcmp(fmt, "binary") == 0)
                cstate->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 (cstate->freeze)
                ereport(ERROR,
                        (errcode(ERRCODE_SYNTAX_ERROR),
                         errmsg("conflicting or redundant options"),
                         parser_errposition(pstate, defel->location)));
            cstate->freeze = defGetBoolean(defel);
        }
        else if (strcmp(defel->defname, "delimiter") == 0)
        {
            if (cstate->delim)
                ereport(ERROR,
                        (errcode(ERRCODE_SYNTAX_ERROR),
                         errmsg("conflicting or redundant options"),
                         parser_errposition(pstate, defel->location)));
            cstate->delim = defGetString(defel);
        }
        else if (strcmp(defel->defname, "null") == 0)
        {
            if (cstate->null_print)
                ereport(ERROR,
                        (errcode(ERRCODE_SYNTAX_ERROR),
                         errmsg("conflicting or redundant options"),
                         parser_errposition(pstate, defel->location)));
            cstate->null_print = defGetString(defel);
        }
        else if (strcmp(defel->defname, "header") == 0)
        {
            if (cstate->header_line)
                ereport(ERROR,
                        (errcode(ERRCODE_SYNTAX_ERROR),
                         errmsg("conflicting or redundant options"),
                         parser_errposition(pstate, defel->location)));
            cstate->header_line = defGetBoolean(defel);
        }
        else if (strcmp(defel->defname, "quote") == 0)
        {
            if (cstate->quote)
                ereport(ERROR,
                        (errcode(ERRCODE_SYNTAX_ERROR),
                         errmsg("conflicting or redundant options"),
                         parser_errposition(pstate, defel->location)));
            cstate->quote = defGetString(defel);
        }
        else if (strcmp(defel->defname, "escape") == 0)
        {
            if (cstate->escape)
                ereport(ERROR,
                        (errcode(ERRCODE_SYNTAX_ERROR),
                         errmsg("conflicting or redundant options"),
                         parser_errposition(pstate, defel->location)));
            cstate->escape = defGetString(defel);
        }
        else if (strcmp(defel->defname, "force_quote") == 0)
        {
            if (cstate->force_quote || cstate->force_quote_all)
                ereport(ERROR,
                        (errcode(ERRCODE_SYNTAX_ERROR),
                         errmsg("conflicting or redundant options"),
                         parser_errposition(pstate, defel->location)));
            if (defel->arg && IsA(defel->arg, A_Star))
                cstate->force_quote_all = true;
            else if (defel->arg && IsA(defel->arg, List))
                cstate->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 (cstate->force_notnull)
                ereport(ERROR,
                        (errcode(ERRCODE_SYNTAX_ERROR),
                         errmsg("conflicting or redundant options"),
                         parser_errposition(pstate, defel->location)));
            if (defel->arg && IsA(defel->arg, List))
                cstate->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 (cstate->force_null)
                ereport(ERROR,
                        (errcode(ERRCODE_SYNTAX_ERROR),
                         errmsg("conflicting or redundant options")));
            if (defel->arg && IsA(defel->arg, List))
                cstate->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 (cstate->convert_selectively)
                ereport(ERROR,
                        (errcode(ERRCODE_SYNTAX_ERROR),
                         errmsg("conflicting or redundant options"),
                         parser_errposition(pstate, defel->location)));
            cstate->convert_selectively = true;
            if (defel->arg == NULL || IsA(defel->arg, List))
                cstate->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 (cstate->file_encoding >= 0)
                ereport(ERROR,
                        (errcode(ERRCODE_SYNTAX_ERROR),
                         errmsg("conflicting or redundant options"),
                         parser_errposition(pstate, defel->location)));
            cstate->file_encoding = pg_char_to_encoding(defGetString(defel));
            if (cstate->file_encoding < 0)
                ereport(ERROR,
                        (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                         errmsg("argument to option \"%s\" must be a valid encoding name",
                                defel->defname),
                         parser_errposition(pstate, defel->location)));
        }
        else
            ereport(ERROR,
                    (errcode(ERRCODE_SYNTAX_ERROR),
                     errmsg("option \"%s\" not recognized",
                            defel->defname),
                     parser_errposition(pstate, defel->location)));
    }

    /*
     * Check for incompatible options (must do these two before inserting
     * defaults)
     */
    if (cstate->binary && cstate->delim)
        ereport(ERROR,
                (errcode(ERRCODE_SYNTAX_ERROR),
                 errmsg("cannot specify DELIMITER in BINARY mode")));

    if (cstate->binary && cstate->null_print)
        ereport(ERROR,
                (errcode(ERRCODE_SYNTAX_ERROR),
                 errmsg("cannot specify NULL in BINARY mode")));

    /* Set defaults for omitted options */
    if (!cstate->delim)
        cstate->delim = cstate->csv_mode ? "," : "\t";

    if (!cstate->null_print)
        cstate->null_print = cstate->csv_mode ? "" : "\\N";
    cstate->null_print_len = strlen(cstate->null_print);

    if (cstate->csv_mode)
    {
        if (!cstate->quote)
            cstate->quote = "\"";
        if (!cstate->escape)
            cstate->escape = cstate->quote;
    }

    /* Only single-byte delimiter strings are supported. */
    if (strlen(cstate->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(cstate->delim, '\r') != NULL ||
        strchr(cstate->delim, '\n') != NULL)
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                 errmsg("COPY delimiter cannot be newline or carriage return")));

    if (strchr(cstate->null_print, '\r') != NULL ||
        strchr(cstate->null_print, '\n') != NULL)
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                 errmsg("COPY null representation cannot use newline or carriage return")));

    /*
     * Disallow unsafe delimiter characters in non-CSV mode.  We can't allow
     * backslash because it would be ambiguous.  We can't allow the other
     * cases because data characters matching the delimiter must be
     * backslashed, and certain backslash combinations are interpreted
     * non-literally by COPY IN.  Disallowing all lower case ASCII letters is
     * more than strictly necessary, but seems best for consistency and
     * future-proofing.  Likewise we disallow all digits though only octal
     * digits are actually dangerous.
     */
    if (!cstate->csv_mode &&
        strchr("\\.abcdefghijklmnopqrstuvwxyz0123456789",
               cstate->delim[0]) != NULL)
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                 errmsg("COPY delimiter cannot be \"%s\"", cstate->delim)));

    /* Check header */
    if (!cstate->csv_mode && cstate->header_line)
        ereport(ERROR,
                (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                 errmsg("COPY HEADER available only in CSV mode")));

    /* Check quote */
    if (!cstate->csv_mode && cstate->quote != NULL)
        ereport(ERROR,
                (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                 errmsg("COPY quote available only in CSV mode")));

    if (cstate->csv_mode && strlen(cstate->quote) != 1)
        ereport(ERROR,
                (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                 errmsg("COPY quote must be a single one-byte character")));

    if (cstate->csv_mode && cstate->delim[0] == cstate->quote[0])
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                 errmsg("COPY delimiter and quote must be different")));

    /* Check escape */
    if (!cstate->csv_mode && cstate->escape != NULL)
        ereport(ERROR,
                (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                 errmsg("COPY escape available only in CSV mode")));

    if (cstate->csv_mode && strlen(cstate->escape) != 1)
        ereport(ERROR,
                (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                 errmsg("COPY escape must be a single one-byte character")));

    /* Check force_quote */
    if (!cstate->csv_mode && (cstate->force_quote || cstate->force_quote_all))
        ereport(ERROR,
                (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                 errmsg("COPY force quote available only in CSV mode")));
    if ((cstate->force_quote || cstate->force_quote_all) && is_from)
        ereport(ERROR,
                (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                 errmsg("COPY force quote only available using COPY TO")));

    /* Check force_notnull */
    if (!cstate->csv_mode && cstate->force_notnull != NIL)
        ereport(ERROR,
                (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                 errmsg("COPY force not null available only in CSV mode")));
    if (cstate->force_notnull != NIL && !is_from)
        ereport(ERROR,
                (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                 errmsg("COPY force not null only available using COPY FROM")));

    /* Check force_null */
    if (!cstate->csv_mode && cstate->force_null != NIL)
        ereport(ERROR,
                (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                 errmsg("COPY force null available only in CSV mode")));

    if (cstate->force_null != NIL && !is_from)
        ereport(ERROR,
                (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                 errmsg("COPY force null only available using COPY FROM")));

    /* Don't allow the delimiter to appear in the null string. */
    if (strchr(cstate->null_print, cstate->delim[0]) != NULL)
        ereport(ERROR,
                (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                 errmsg("COPY delimiter must not appear in the NULL specification")));

    /* Don't allow the CSV quote char to appear in the null string. */
    if (cstate->csv_mode &&
        strchr(cstate->null_print, cstate->quote[0]) != NULL)
        ereport(ERROR,
                (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                 errmsg("CSV quote character must not appear in the NULL specification")));
}