#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, Oid tupleOid)

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

void	CopyFromErrorCallback (void *arg)

uint64	CopyFrom (CopyState cstate)

DestReceiver *	CreateCopyDestReceiver (void)

Typedef Documentation

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

Definition at line 24 of file copy.h.

typedef struct CopyStateData* CopyState

Definition at line 23 of file copy.h.

Function Documentation

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 2964 of file copy.c.

References AllocateFile(), Assert, 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::fe_eof, CopyStateData::file_has_oids, 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(), tupleDesc::natts, NULL, CopyStateData::num_defaults, CopyStateData::oid_in_function, CopyStateData::oid_typioparam, OIDOID, CopyStateData::oids, 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, ReceiveCopyBegin(), CopyStateData::rel, RelationGetDescr, RelationGetRelationName, 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->fe_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))
         {
             /* 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)
     {
         /* must rely on user to tell us... */
         cstate->file_has_oids = cstate->oids;
     }
     else
     {
         /* 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)")));
         cstate->file_has_oids = (tmp & (1 << 16)) != 0;
         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)")));
         }
     }
 
     if (cstate->file_has_oids && cstate->binary)
     {
         getTypeBinaryInputInfo(OIDOID,
                                &in_func_oid, &cstate->oid_typioparam);
         fmgr_info(in_func_oid, &cstate->oid_in_function);
     }
 
     /* create workspace for CopyReadAttributes results */
     if (!cstate->binary)
     {
         AttrNumber  attr_count = list_length(cstate->attnumlist);
         int         nfields = cstate->file_has_oids ? (attr_count + 1) : attr_count;
 
         cstate->max_fields = nfields;
         cstate->raw_fields = (char **) palloc(nfields * sizeof(char *));
     }
 
     MemoryContextSwitchTo(oldcontext);
 
     return cstate;
 }

uint64 CopyFrom ( CopyState cstate )

Definition at line 2273 of file copy.c.

References AfterTriggerBeginQuery(), AfterTriggerEndQuery(), ErrorContextCallback::arg, Assert, ErrorContextCallback::callback, CHECK_FOR_INTERRUPTS, tupleDesc::constr, convert_tuples_by_name(), CopyStateData::copy_dest, COPY_OLD_FE, CopyFromErrorCallback(), CopyFromInsertBatch(), CreateExecutorState(), CopyStateData::cur_lineno, CurrentMemoryContext, do_convert_tuple(), ereport, errcode(), errhint(), errmsg(), ERROR, error_context_stack, EState::es_num_result_relations, EState::es_range_table, EState::es_result_relation_info, EState::es_result_relations, EState::es_trig_tuple_slot, EState::es_tupleTable, ExecARInsertTriggers(), ExecASInsertTriggers(), ExecBRInsertTriggers(), ExecBSInsertTriggers(), ExecCleanUpTriggerState(), ExecCloseIndices(), ExecConstraints(), ExecDropSingleTupleTableSlot(), ExecFindPartition(), ExecInitExtraTupleSlot(), ExecInsertIndexTuples(), ExecIRInsertTriggers(), ExecMaterializeSlot(), ExecOpenIndices(), ExecResetTupleTable(), ExecSetSlotDescriptor(), ExecSetupPartitionTupleRouting(), ExecStoreTuple(), FreeBulkInsertState(), FreeExecutorState(), CopyStateData::freeze, GetBulkInsertState(), GetCurrentCommandId(), GetCurrentSubTransactionId(), GetPerTupleExprContext, GetPerTupleMemoryContext, gettext_noop, heap_close, heap_form_tuple(), heap_insert(), HEAP_INSERT_FROZEN, HEAP_INSERT_SKIP_FSM, HEAP_INSERT_SKIP_WAL, heap_sync(), HeapTupleSetOid, i, InitResultRelInfo(), InvalidBuffer, InvalidOid, InvalidSubTransactionId, list_free(), makeNode, MakeTransitionCaptureState(), MAX_BUFFERED_TUPLES, MemoryContextSwitchTo(), tupleDesc::natts, NextCopyFrom(), NIL, NoLock, NULL, CopyStateData::num_dispatch, CopyStateData::num_partitions, palloc(), palloc0(), CopyStateData::partition_dispatch_info, CopyStateData::partition_tupconv_maps, CopyStateData::partition_tuple_slot, CopyStateData::partitions, pfree(), pq_endmsgread(), ErrorContextCallback::previous, CopyStateData::range_table, RelationData::rd_att, RelationData::rd_createSubid, RelationData::rd_newRelfilenodeSubid, RelationData::rd_rel, CopyStateData::rel, RelationGetDescr, RelationGetRelationName, RelationGetRelid, PartitionDispatchData::reldesc, ReleaseBulkInsertStatePin(), RELKIND_FOREIGN_TABLE, RELKIND_MATVIEW, RELKIND_PARTITIONED_TABLE, RELKIND_RELATION, RELKIND_SEQUENCE, RELKIND_VIEW, ResetPerTupleExprContext, ResultRelInfo::ri_FdwRoutine, ResultRelInfo::ri_NumIndices, ResultRelInfo::ri_PartitionCheck, ResultRelInfo::ri_RelationDesc, ResultRelInfo::ri_TrigDesc, HeapTupleData::t_len, HeapTupleData::t_self, HeapTupleData::t_tableOid, TransitionCaptureState::tcs_map, TransitionCaptureState::tcs_original_insert_tuple, ThereAreNoPriorRegisteredSnapshots(), ThereAreNoReadyPortals(), CopyStateData::transition_capture, CopyStateData::transition_tupconv_maps, TriggerDesc::trig_insert_before_row, TriggerDesc::trig_insert_instead_row, RelationData::trigdesc, PartitionDispatchData::tupslot, values, CopyStateData::volatile_defexprs, and XLogIsNeeded.

Referenced by copy_table(), and DoCopy().

 {
     HeapTuple   tuple;
     TupleDesc   tupDesc;
     Datum      *values;
     bool       *nulls;
     ResultRelInfo *resultRelInfo;
     ResultRelInfo *saved_resultRelInfo = NULL;
     EState     *estate = CreateExecutorState(); /* for ExecConstraints() */
     ExprContext *econtext;
     TupleTableSlot *myslot;
     MemoryContext oldcontext = CurrentMemoryContext;
 
     ErrorContextCallback errcallback;
     CommandId   mycid = GetCurrentCommandId(true);
     int         hi_options = 0; /* start with default heap_insert options */
     BulkInsertState bistate;
     uint64      processed = 0;
     bool        useHeapMultiInsert;
     int         nBufferedTuples = 0;
     int         prev_leaf_part_index = -1;
 
 #define MAX_BUFFERED_TUPLES 1000
     HeapTuple  *bufferedTuples = NULL;  /* initialize to silence warning */
     Size        bufferedTuplesSize = 0;
     int         firstBufferedLineNo = 0;
 
     Assert(cstate->rel);
 
     /*
      * The target must be a plain 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_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_FOREIGN_TABLE)
             ereport(ERROR,
                     (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                      errmsg("cannot copy to foreign table \"%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))));
     }
 
     tupDesc = RelationGetDescr(cstate->rel);
 
     /*----------
      * Check to see if we can avoid writing WAL
      *
      * If archive logging/streaming is not enabled *and* either
      *  - table was created in same transaction as this COPY
      *  - data is being written to relfilenode created in this transaction
      * then we can skip writing WAL.  It's safe because if the transaction
      * doesn't commit, we'll discard the table (or the new relfilenode file).
      * If it does commit, we'll have done the heap_sync at the bottom of this
      * routine first.
      *
      * As mentioned in comments in utils/rel.h, the in-same-transaction test
      * is not always set correctly, since in rare cases rd_newRelfilenodeSubid
      * can be cleared before the end of the transaction. The exact case is
      * when a relation sets a new relfilenode twice in same transaction, yet
      * the second one fails in an aborted subtransaction, e.g.
      *
      * BEGIN;
      * TRUNCATE t;
      * SAVEPOINT save;
      * TRUNCATE t;
      * ROLLBACK TO save;
      * COPY ...
      *
      * Also, if the target file is new-in-transaction, we assume that checking
      * FSM for free space is a waste of time, even if we must use WAL because
      * of archiving.  This could possibly be wrong, but it's unlikely.
      *
      * The comments for heap_insert and RelationGetBufferForTuple specify that
      * skipping WAL logging is only safe if we ensure that our tuples do not
      * go into pages containing tuples from any other transactions --- but this
      * must be the case if we have a new table or new relfilenode, so we need
      * no additional work to enforce that.
      *----------
      */
     /* createSubid is creation check, newRelfilenodeSubid is truncation check */
     if (cstate->rel->rd_createSubid != InvalidSubTransactionId ||
         cstate->rel->rd_newRelfilenodeSubid != InvalidSubTransactionId)
     {
         hi_options |= HEAP_INSERT_SKIP_FSM;
         if (!XLogIsNeeded())
             hi_options |= HEAP_INSERT_SKIP_WAL;
     }
 
     /*
      * 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. This ensures that if this subtransaction
      * 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.
      */
     if (cstate->freeze)
     {
         if (!ThereAreNoPriorRegisteredSnapshots() || !ThereAreNoReadyPortals())
             ereport(ERROR,
                     (errcode(ERRCODE_INVALID_TRANSACTION_STATE),
                      errmsg("cannot perform 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 FREEZE because the table was not created or truncated in the current subtransaction")));
 
         hi_options |= HEAP_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,        /* dummy rangetable index */
                       NULL,
                       0);
 
     ExecOpenIndices(resultRelInfo, false);
 
     estate->es_result_relations = resultRelInfo;
     estate->es_num_result_relations = 1;
     estate->es_result_relation_info = resultRelInfo;
     estate->es_range_table = cstate->range_table;
 
     /* Set up a tuple slot too */
     myslot = ExecInitExtraTupleSlot(estate);
     ExecSetSlotDescriptor(myslot, tupDesc);
     /* Triggers might need a slot as well */
     estate->es_trig_tuple_slot = ExecInitExtraTupleSlot(estate);
 
     /*
      * If there are any triggers with transition tables on the named relation,
      * we need to be prepared to capture transition tuples.
      */
     cstate->transition_capture =
         MakeTransitionCaptureState(cstate->rel->trigdesc);
 
     /*
      * If the named relation is a partitioned table, initialize state for
      * CopyFrom tuple routing.
      */
     if (cstate->rel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE)
     {
         PartitionDispatch *partition_dispatch_info;
         ResultRelInfo *partitions;
         TupleConversionMap **partition_tupconv_maps;
         TupleTableSlot *partition_tuple_slot;
         int         num_parted,
                     num_partitions;
 
         ExecSetupPartitionTupleRouting(cstate->rel,
                                        1,
                                        estate,
                                        &partition_dispatch_info,
                                        &partitions,
                                        &partition_tupconv_maps,
                                        &partition_tuple_slot,
                                        &num_parted, &num_partitions);
         cstate->partition_dispatch_info = partition_dispatch_info;
         cstate->num_dispatch = num_parted;
         cstate->partitions = partitions;
         cstate->num_partitions = num_partitions;
         cstate->partition_tupconv_maps = partition_tupconv_maps;
         cstate->partition_tuple_slot = partition_tuple_slot;
 
         /*
          * If we are capturing transition tuples, they may need to be
          * converted from partition format back to partitioned table format
          * (this is only ever necessary if a BEFORE trigger modifies the
          * tuple).
          */
         if (cstate->transition_capture != NULL)
         {
             int         i;
 
             cstate->transition_tupconv_maps = (TupleConversionMap **)
                 palloc0(sizeof(TupleConversionMap *) * cstate->num_partitions);
             for (i = 0; i < cstate->num_partitions; ++i)
             {
                 cstate->transition_tupconv_maps[i] =
                     convert_tuples_by_name(RelationGetDescr(cstate->partitions[i].ri_RelationDesc),
                                            RelationGetDescr(cstate->rel),
                                            gettext_noop("could not convert row type"));
             }
         }
     }
 
     /*
      * It's more efficient to prepare a bunch of tuples for insertion, and
      * insert them in one heap_multi_insert() call, than call heap_insert()
      * separately for every tuple. However, we can't do that if there are
      * BEFORE/INSTEAD OF triggers, or we need to evaluate volatile default
      * expressions. Such triggers or expressions might query the table we're
      * inserting to, and act differently if the tuples that have already been
      * processed and prepared for insertion are not there.  We also can't do
      * it if the table is partitioned.
      */
     if ((resultRelInfo->ri_TrigDesc != NULL &&
          (resultRelInfo->ri_TrigDesc->trig_insert_before_row ||
           resultRelInfo->ri_TrigDesc->trig_insert_instead_row)) ||
         cstate->partition_dispatch_info != NULL ||
         cstate->volatile_defexprs)
     {
         useHeapMultiInsert = false;
     }
     else
     {
         useHeapMultiInsert = true;
         bufferedTuples = palloc(MAX_BUFFERED_TUPLES * sizeof(HeapTuple));
     }
 
     /* Prepare to catch AFTER triggers. */
     AfterTriggerBeginQuery();
 
     /*
      * 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);
 
     values = (Datum *) palloc(tupDesc->natts * sizeof(Datum));
     nulls = (bool *) palloc(tupDesc->natts * sizeof(bool));
 
     bistate = GetBulkInsertState();
     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 *slot;
         bool        skip_tuple;
         Oid         loaded_oid = InvalidOid;
 
         CHECK_FOR_INTERRUPTS();
 
         if (nBufferedTuples == 0)
         {
             /*
              * Reset the per-tuple exprcontext. We can only do this if the
              * tuple buffer is empty. (Calling the context the per-tuple
              * memory context is a bit of a misnomer now.)
              */
             ResetPerTupleExprContext(estate);
         }
 
         /* Switch into its memory context */
         MemoryContextSwitchTo(GetPerTupleMemoryContext(estate));
 
         if (!NextCopyFrom(cstate, econtext, values, nulls, &loaded_oid))
             break;
 
         /* And now we can form the input tuple. */
         tuple = heap_form_tuple(tupDesc, values, nulls);
 
         if (loaded_oid != InvalidOid)
             HeapTupleSetOid(tuple, loaded_oid);
 
         /*
          * Constraints might reference the tableoid column, so initialize
          * t_tableOid before evaluating them.
          */
         tuple->t_tableOid = RelationGetRelid(resultRelInfo->ri_RelationDesc);
 
         /* Triggers and stuff need to be invoked in query context. */
         MemoryContextSwitchTo(oldcontext);
 
         /* Place tuple in tuple slot --- but slot shouldn't free it */
         slot = myslot;
         ExecStoreTuple(tuple, slot, InvalidBuffer, false);
 
         /* Determine the partition to heap_insert the tuple into */
         if (cstate->partition_dispatch_info)
         {
             int         leaf_part_index;
             TupleConversionMap *map;
 
             /*
              * Away we go ... If we end up not finding a partition after all,
              * ExecFindPartition() does not return and errors out instead.
              * Otherwise, the returned value is to be used as an index into
              * arrays mt_partitions[] and mt_partition_tupconv_maps[] that
              * will get us the ResultRelInfo and TupleConversionMap for the
              * partition, respectively.
              */
             leaf_part_index = ExecFindPartition(resultRelInfo,
                                                 cstate->partition_dispatch_info,
                                                 slot,
                                                 estate);
             Assert(leaf_part_index >= 0 &&
                    leaf_part_index < cstate->num_partitions);
 
             /*
              * If this tuple is mapped to a partition that is not same as the
              * previous one, we'd better make the bulk insert mechanism gets a
              * new buffer.
              */
             if (prev_leaf_part_index != leaf_part_index)
             {
                 ReleaseBulkInsertStatePin(bistate);
                 prev_leaf_part_index = leaf_part_index;
             }
 
             /*
              * Save the old ResultRelInfo and switch to the one corresponding
              * to the selected partition.
              */
             saved_resultRelInfo = resultRelInfo;
             resultRelInfo = cstate->partitions + leaf_part_index;
 
             /* We do not yet have a way to insert into a foreign partition */
             if (resultRelInfo->ri_FdwRoutine)
                 ereport(ERROR,
                         (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                          errmsg("cannot route inserted tuples to a foreign table")));
 
             /*
              * 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 parent rowtype.
              */
             if (cstate->transition_capture != NULL)
             {
                 if (resultRelInfo->ri_TrigDesc &&
                     (resultRelInfo->ri_TrigDesc->trig_insert_before_row ||
                      resultRelInfo->ri_TrigDesc->trig_insert_instead_row))
                 {
                     /*
                      * If there are any BEFORE or INSTEAD 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 =
                         cstate->transition_tupconv_maps[leaf_part_index];
                 }
                 else
                 {
                     /*
                      * Otherwise, just remember the original unconverted
                      * tuple, to avoid a needless round trip conversion.
                      */
                     cstate->transition_capture->tcs_original_insert_tuple = tuple;
                     cstate->transition_capture->tcs_map = NULL;
                 }
             }
 
             /*
              * We might need to convert from the parent rowtype to the
              * partition rowtype.
              */
             map = cstate->partition_tupconv_maps[leaf_part_index];
             if (map)
             {
                 Relation    partrel = resultRelInfo->ri_RelationDesc;
 
                 tuple = do_convert_tuple(tuple, map);
 
                 /*
                  * We must use the partition's tuple descriptor from this
                  * point on.  Use a dedicated slot from this point on until
                  * we're finished dealing with the partition.
                  */
                 slot = cstate->partition_tuple_slot;
                 Assert(slot != NULL);
                 ExecSetSlotDescriptor(slot, RelationGetDescr(partrel));
                 ExecStoreTuple(tuple, slot, InvalidBuffer, true);
             }
 
             tuple->t_tableOid = RelationGetRelid(resultRelInfo->ri_RelationDesc);
         }
 
         skip_tuple = false;
 
         /* BEFORE ROW INSERT Triggers */
         if (resultRelInfo->ri_TrigDesc &&
             resultRelInfo->ri_TrigDesc->trig_insert_before_row)
         {
             slot = ExecBRInsertTriggers(estate, resultRelInfo, slot);
 
             if (slot == NULL)   /* "do nothing" */
                 skip_tuple = true;
             else                /* trigger might have changed tuple */
                 tuple = ExecMaterializeSlot(slot);
         }
 
         if (!skip_tuple)
         {
             if (resultRelInfo->ri_TrigDesc &&
                 resultRelInfo->ri_TrigDesc->trig_insert_instead_row)
             {
                 /* Pass the data to the INSTEAD ROW INSERT trigger */
                 ExecIRInsertTriggers(estate, resultRelInfo, slot);
             }
             else
             {
                 /*
                  * We always check the partition constraint, including when
                  * the tuple got here via tuple-routing.  However we don't
                  * need to in the latter case if no BR trigger is defined on
                  * the partition.  Note that a BR trigger might modify the
                  * tuple such that the partition constraint is no longer
                  * satisfied, so we need to check in that case.
                  */
                 bool        check_partition_constr =
                 (resultRelInfo->ri_PartitionCheck != NIL);
 
                 if (saved_resultRelInfo != NULL &&
                     !(resultRelInfo->ri_TrigDesc &&
                       resultRelInfo->ri_TrigDesc->trig_insert_before_row))
                     check_partition_constr = false;
 
                 /* Check the constraints of the tuple */
                 if (cstate->rel->rd_att->constr || check_partition_constr)
                     ExecConstraints(resultRelInfo, slot, estate);
 
                 if (useHeapMultiInsert)
                 {
                     /* Add this tuple to the tuple buffer */
                     if (nBufferedTuples == 0)
                         firstBufferedLineNo = cstate->cur_lineno;
                     bufferedTuples[nBufferedTuples++] = tuple;
                     bufferedTuplesSize += tuple->t_len;
 
                     /*
                      * If the buffer filled up, flush it.  Also flush if the
                      * total size of all the tuples in the buffer becomes
                      * large, to avoid using large amounts of memory for the
                      * buffer when the tuples are exceptionally wide.
                      */
                     if (nBufferedTuples == MAX_BUFFERED_TUPLES ||
                         bufferedTuplesSize > 65535)
                     {
                         CopyFromInsertBatch(cstate, estate, mycid, hi_options,
                                             resultRelInfo, myslot, bistate,
                                             nBufferedTuples, bufferedTuples,
                                             firstBufferedLineNo);
                         nBufferedTuples = 0;
                         bufferedTuplesSize = 0;
                     }
                 }
                 else
                 {
                     List       *recheckIndexes = NIL;
 
                     /* OK, store the tuple and create index entries for it */
                     heap_insert(resultRelInfo->ri_RelationDesc, tuple, mycid,
                                 hi_options, bistate);
 
                     if (resultRelInfo->ri_NumIndices > 0)
                         recheckIndexes = ExecInsertIndexTuples(slot,
                                                                &(tuple->t_self),
                                                                estate,
                                                                false,
                                                                NULL,
                                                                NIL);
 
                     /* AFTER ROW INSERT Triggers */
                     ExecARInsertTriggers(estate, resultRelInfo, tuple,
                                          recheckIndexes, cstate->transition_capture);
 
                     list_free(recheckIndexes);
                 }
             }
 
             /*
              * We count only tuples not suppressed by a BEFORE INSERT trigger;
              * this is the same definition used by execMain.c for counting
              * tuples inserted by an INSERT command.
              */
             processed++;
 
             if (saved_resultRelInfo)
             {
                 resultRelInfo = saved_resultRelInfo;
                 estate->es_result_relation_info = resultRelInfo;
             }
         }
     }
 
     /* Flush any remaining buffered tuples */
     if (nBufferedTuples > 0)
         CopyFromInsertBatch(cstate, estate, mycid, hi_options,
                             resultRelInfo, myslot, bistate,
                             nBufferedTuples, bufferedTuples,
                             firstBufferedLineNo);
 
     /* Done, clean up */
     error_context_stack = errcallback.previous;
 
     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, resultRelInfo, cstate->transition_capture);
 
     /* Handle queued AFTER triggers */
     AfterTriggerEndQuery(estate);
 
     pfree(values);
     pfree(nulls);
 
     ExecResetTupleTable(estate->es_tupleTable, false);
 
     ExecCloseIndices(resultRelInfo);
 
     /* Close all the partitioned tables, leaf partitions, and their indices */
     if (cstate->partition_dispatch_info)
     {
         int         i;
 
         /*
          * Remember cstate->partition_dispatch_info[0] corresponds to the root
          * partitioned table, which we must not try to close, because it is
          * the main target table of COPY that will be closed eventually by
          * DoCopy().  Also, tupslot is NULL for the root partitioned table.
          */
         for (i = 1; i < cstate->num_dispatch; i++)
         {
             PartitionDispatch pd = cstate->partition_dispatch_info[i];
 
             heap_close(pd->reldesc, NoLock);
             ExecDropSingleTupleTableSlot(pd->tupslot);
         }
         for (i = 0; i < cstate->num_partitions; i++)
         {
             ResultRelInfo *resultRelInfo = cstate->partitions + i;
 
             ExecCloseIndices(resultRelInfo);
             heap_close(resultRelInfo->ri_RelationDesc, NoLock);
         }
 
         /* Release the standalone partition tuple descriptor */
         ExecDropSingleTupleTableSlot(cstate->partition_tuple_slot);
     }
 
     /* Close any trigger target relations */
     ExecCleanUpTriggerState(estate);
 
     FreeExecutorState(estate);
 
     /*
      * If we skipped writing WAL, then we need to sync the heap (but not
      * indexes since those use WAL anyway)
      */
     if (hi_options & HEAP_INSERT_SKIP_WAL)
         heap_sync(cstate->rel);
 
     return processed;
 }

void CopyFromErrorCallback ( void * arg )

Definition at line 2168 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, and pfree().

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

 {
     CopyState   cstate = (CopyState) arg;
 
     if (cstate->binary)
     {
         /* can't usefully display the data */
         if (cstate->cur_attname)
             errcontext("COPY %s, line %d, column %s",
                        cstate->cur_relname, cstate->cur_lineno,
                        cstate->cur_attname);
         else
             errcontext("COPY %s, line %d",
                        cstate->cur_relname, cstate->cur_lineno);
     }
     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 %d, 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 %d, 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, 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 %d: \"%s\"",
                            cstate->cur_relname, cstate->cur_lineno, lineval);
                 pfree(lineval);
             }
             else
             {
                 errcontext("COPY %s, line %d",
                            cstate->cur_relname, cstate->cur_lineno);
             }
         }
     }
 }

DestReceiver* CreateCopyDestReceiver ( void )

Definition at line 4827 of file copy.c.

References copy_dest_destroy(), copy_dest_receive(), copy_dest_shutdown(), copy_dest_startup(), DestCopyOut, NULL, 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;
 }

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

Definition at line 783 of file copy.c.

References AccessShareLock, ACL_INSERT, ACL_SELECT, addRangeTableEntryForRelation(), Assert, CopyStmt::attlist, BeginCopyFrom(), BeginCopyTo(), bms_add_member(), check_enable_rls(), CopyFrom(), CopyGetAttnums(), cur, DoCopyTo(), EndCopyFrom(), EndCopyTo(), ereport, errcode(), errhint(), errmsg(), ERROR, ExecCheckRTPerms(), ColumnRef::fields, CopyStmt::filename, FirstLowInvalidHeapAttributeNumber, SelectStmt::fromClause, get_namespace_name(), heap_close, heap_openrv(), ResTarget::indirection, RangeTblEntry::insertedCols, InvalidOid, CopyStmt::is_from, CopyStmt::is_program, lappend(), lfirst, lfirst_int, list_make1, ColumnRef::location, ResTarget::location, makeNode, makeRangeVar(), ResTarget::name, NIL, NoLock, NULL, CopyStmt::options, ParseState::p_rtable, PreventCommandIfParallelMode(), PreventCommandIfReadOnly(), pstrdup(), CopyStmt::query, RelationData::rd_islocaltemp, CopyStmt::relation, RelationGetDescr, RelationGetNamespace, RelationGetRelationName, RelationGetRelid, RangeTblEntry::relid, RangeTblEntry::requiredPerms, RLS_ENABLED, RowExclusiveLock, select, RangeTblEntry::selectedCols, RawStmt::stmt, RawStmt::stmt_len, RawStmt::stmt_location, superuser(), SelectStmt::targetList, ResTarget::val, 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;
 
     /* Disallow COPY to/from file or program except to superusers. */
     if (!pipe && !superuser())
     {
         if (stmt->is_program)
             ereport(ERROR,
                     (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
                      errmsg("must be superuser 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
             ereport(ERROR,
                     (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
                      errmsg("must be superuser to COPY to or from a file"),
                      errhint("Anyone can COPY to stdout or from stdin. "
                              "psql's \\copy command also works for anyone.")));
     }
 
     if (stmt->relation)
     {
         TupleDesc   tupDesc;
         List       *attnums;
         ListCell   *cur;
         RangeTblEntry *rte;
 
         Assert(!stmt->query);
 
         /* Open and lock the relation, using the appropriate lock type. */
         rel = heap_openrv(stmt->relation,
                           (is_from ? RowExclusiveLock : AccessShareLock));
 
         relid = RelationGetRelid(rel);
 
         rte = addRangeTableEntryForRelation(pstate, rel, NULL, false, false);
         rte->requiredPerms = (is_from ? ACL_INSERT : ACL_SELECT);
 
         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.
              */
             heap_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");
         PreventCommandIfParallelMode("COPY FROM");
 
         cstate = BeginCopyFrom(pstate, rel, stmt->filename, stmt->is_program,
                                NULL, stmt->attlist, stmt->options);
         *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);
     }
 
     /*
      * Close the relation. If reading, we can release the AccessShareLock we
      * got; if writing, we should hold the lock until end of transaction to
      * ensure that updates will be committed before lock is released.
      */
     if (rel != NULL)
         heap_close(rel, (is_from ? NoLock : AccessShareLock));
 }

void EndCopyFrom ( CopyState cstate )

Definition at line 3516 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);
 }

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

Definition at line 3275 of file copy.c.

References Assert, CopyStateData::attnumlist, CopyStateData::binary, CopyStateData::convert_select_flags, CopyStateData::copy_dest, COPY_OLD_FE, CopyGetData(), CopyGetInt16(), CopyReadBinaryAttribute(), CStringGetDatum, CopyStateData::csv_mode, cur, CopyStateData::cur_attname, CopyStateData::cur_attval, CopyStateData::cur_lineno, CurrentMemoryContext, DatumGetObjectId, CopyStateData::defexprs, CopyStateData::defmap, DirectFunctionCall1, ExprContext::ecxt_per_tuple_memory, ereport, errcode(), errmsg(), ERROR, ExecEvalExpr(), CopyStateData::file_has_oids, CopyStateData::force_notnull_flags, CopyStateData::force_null_flags, i, CopyStateData::in_functions, InputFunctionCall(), InvalidOid, lfirst_int, list_length(), MemSet, NameStr, tupleDesc::natts, NextCopyFromRawFields(), NULL, CopyStateData::null_print, CopyStateData::num_defaults, CopyStateData::oid_in_function, CopyStateData::oid_typioparam, oidin(), CopyStateData::oids, 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         nfields;
     bool        isnull;
     bool        file_has_oids = cstate->file_has_oids;
     int        *defmap = cstate->defmap;
     ExprState **defexprs = cstate->defexprs;
 
     tupDesc = RelationGetDescr(cstate->rel);
     num_phys_attrs = tupDesc->natts;
     attr_count = list_length(cstate->attnumlist);
     nfields = file_has_oids ? (attr_count + 1) : attr_count;
 
     /* 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 (nfields > 0 && fldct > nfields)
             ereport(ERROR,
                     (errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
                      errmsg("extra data after last expected column")));
 
         fieldno = 0;
 
         /* Read the OID field if present */
         if (file_has_oids)
         {
             if (fieldno >= fldct)
                 ereport(ERROR,
                         (errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
                          errmsg("missing data for OID column")));
             string = field_strings[fieldno++];
 
             if (string == NULL)
                 ereport(ERROR,
                         (errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
                          errmsg("null OID in COPY data")));
             else if (cstate->oids && tupleOid != NULL)
             {
                 cstate->cur_attname = "oid";
                 cstate->cur_attval = string;
                 *tupleOid = DatumGetObjectId(DirectFunctionCall1(oidin,
                                                                  CStringGetDatum(string)));
                 if (*tupleOid == InvalidOid)
                     ereport(ERROR,
                             (errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
                              errmsg("invalid OID in COPY data")));
                 cstate->cur_attname = NULL;
                 cstate->cur_attval = NULL;
             }
         }
 
         /* 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 == nfields);
     }
     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)));
 
         if (file_has_oids)
         {
             Oid         loaded_oid;
 
             cstate->cur_attname = "oid";
             loaded_oid =
                 DatumGetObjectId(CopyReadBinaryAttribute(cstate,
                                                          0,
                                                          &cstate->oid_in_function,
                                                          cstate->oid_typioparam,
                                                          -1,
                                                          &isnull));
             if (isnull || loaded_oid == InvalidOid)
                 ereport(ERROR,
                         (errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
                          errmsg("invalid OID in COPY data")));
             cstate->cur_attname = NULL;
             if (cstate->oids && tupleOid != NULL)
                 *tupleOid = loaded_oid;
         }
 
         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;
 }

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

Definition at line 3223 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;
 }

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

Definition at line 1016 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, IsA, lfirst_node, DefElem::location, NIL, NULL, CopyStateData::null_print, CopyStateData::null_print_len, CopyStateData::oids, 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->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, "oids") == 0)
         {
             if (cstate->oids)
                 ereport(ERROR,
                         (errcode(ERRCODE_SYNTAX_ERROR),
                          errmsg("conflicting or redundant options"),
                          parser_errposition(pstate, defel->location)));
             cstate->oids = defGetBoolean(defel);
         }
         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")));
 }

Typedefs

Functions

Typedef Documentation

Function Documentation