#include "postgres.h"
#include <ctype.h>
#include <unistd.h>
#include <sys/stat.h>
#include "access/heapam.h"
#include "access/htup_details.h"
#include "access/sysattr.h"
#include "access/tableam.h"
#include "access/xact.h"
#include "access/xlog.h"
#include "catalog/dependency.h"
#include "catalog/pg_authid.h"
#include "catalog/pg_type.h"
#include "commands/copy.h"
#include "commands/defrem.h"
#include "commands/trigger.h"
#include "executor/execPartition.h"
#include "executor/executor.h"
#include "executor/nodeModifyTable.h"
#include "executor/tuptable.h"
#include "foreign/fdwapi.h"
#include "libpq/libpq.h"
#include "libpq/pqformat.h"
#include "mb/pg_wchar.h"
#include "miscadmin.h"
#include "nodes/makefuncs.h"
#include "optimizer/optimizer.h"
#include "parser/parse_coerce.h"
#include "parser/parse_collate.h"
#include "parser/parse_expr.h"
#include "parser/parse_relation.h"
#include "port/pg_bswap.h"
#include "rewrite/rewriteHandler.h"
#include "storage/fd.h"
#include "tcop/tcopprot.h"
#include "utils/acl.h"
#include "utils/builtins.h"
#include "utils/lsyscache.h"
#include "utils/memutils.h"
#include "utils/partcache.h"
#include "utils/portal.h"
#include "utils/rel.h"
#include "utils/rls.h"
#include "utils/snapmgr.h"

Include dependency graph for copy.c:

Data Structures
struct	CopyStateData

struct	DR_copy

struct	CopyMultiInsertBuffer

struct	CopyMultiInsertInfo

Macros
#define	ISOCTAL(c) (((c) >= '0') && ((c) <= '7'))

#define	OCTVALUE(c) ((c) - '0')

#define	RAW_BUF_SIZE 65536 /* we palloc RAW_BUF_SIZE+1 bytes */

#define	MAX_BUFFERED_TUPLES 1000

#define	MAX_BUFFERED_BYTES 65535

#define	MAX_PARTITION_BUFFERS 32

#define	IF_NEED_REFILL_AND_NOT_EOF_CONTINUE(extralen)

#define	IF_NEED_REFILL_AND_EOF_BREAK(extralen)

#define	REFILL_LINEBUF

#define	NO_END_OF_COPY_GOTO

#define	MAX_COPY_DATA_DISPLAY 100

#define	DUMPSOFAR()

Typedefs
typedef enum CopyDest	CopyDest

typedef enum EolType	EolType

typedef enum CopyInsertMethod	CopyInsertMethod

typedef struct CopyStateData	CopyStateData

typedef struct CopyMultiInsertBuffer	CopyMultiInsertBuffer

typedef struct CopyMultiInsertInfo	CopyMultiInsertInfo

Enumerations
enum	CopyDest { COPY_FILE, COPY_OLD_FE, COPY_NEW_FE, COPY_CALLBACK }

enum	EolType { EOL_UNKNOWN, EOL_NL, EOL_CR, EOL_CRNL }

enum	CopyInsertMethod { CIM_SINGLE, CIM_MULTI, CIM_MULTI_CONDITIONAL }

Functions
static CopyState	BeginCopy (ParseState pstate, bool is_from, Relation rel, RawStmt raw_query, Oid queryRelId, List attnamelist, List options)

static void	EndCopy (CopyState cstate)

static void	ClosePipeToProgram (CopyState cstate)

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

static void	EndCopyTo (CopyState cstate)

static uint64	DoCopyTo (CopyState cstate)

static uint64	CopyTo (CopyState cstate)

static void	CopyOneRowTo (CopyState cstate, TupleTableSlot *slot)

static bool	CopyReadLine (CopyState cstate)

static bool	CopyReadLineText (CopyState cstate)

static int	CopyReadAttributesText (CopyState cstate)

static int	CopyReadAttributesCSV (CopyState cstate)

static Datum	CopyReadBinaryAttribute (CopyState cstate, FmgrInfo flinfo, Oid typioparam, int32 typmod, bool isnull)

static void	CopyAttributeOutText (CopyState cstate, char *string)

static void	CopyAttributeOutCSV (CopyState cstate, char *string, bool use_quote, bool single_attr)

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

static char *	limit_printout_length (const char *str)

static void	SendCopyBegin (CopyState cstate)

static void	ReceiveCopyBegin (CopyState cstate)

static void	SendCopyEnd (CopyState cstate)

static void	CopySendData (CopyState cstate, const void *databuf, int datasize)

static void	CopySendString (CopyState cstate, const char *str)

static void	CopySendChar (CopyState cstate, char c)

static void	CopySendEndOfRow (CopyState cstate)

static int	CopyGetData (CopyState cstate, void *databuf, int minread, int maxread)

static void	CopySendInt32 (CopyState cstate, int32 val)

static bool	CopyGetInt32 (CopyState cstate, int32 *val)

static void	CopySendInt16 (CopyState cstate, int16 val)

static bool	CopyGetInt16 (CopyState cstate, int16 *val)

static bool	CopyLoadRawBuf (CopyState cstate)

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

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

void	CopyFromErrorCallback (void *arg)

static CopyMultiInsertBuffer *	CopyMultiInsertBufferInit (ResultRelInfo *rri)

static void	CopyMultiInsertInfoSetupBuffer (CopyMultiInsertInfo miinfo, ResultRelInfo rri)

static void	CopyMultiInsertInfoInit (CopyMultiInsertInfo miinfo, ResultRelInfo rri, CopyState cstate, EState *estate, CommandId mycid, int ti_options)

static bool	CopyMultiInsertInfoIsFull (CopyMultiInsertInfo *miinfo)

static bool	CopyMultiInsertInfoIsEmpty (CopyMultiInsertInfo *miinfo)

static void	CopyMultiInsertBufferFlush (CopyMultiInsertInfo miinfo, CopyMultiInsertBuffer buffer)

static void	CopyMultiInsertBufferCleanup (CopyMultiInsertInfo miinfo, CopyMultiInsertBuffer buffer)

static void	CopyMultiInsertInfoFlush (CopyMultiInsertInfo miinfo, ResultRelInfo curr_rri)

static void	CopyMultiInsertInfoCleanup (CopyMultiInsertInfo *miinfo)

static TupleTableSlot *	CopyMultiInsertInfoNextFreeSlot (CopyMultiInsertInfo miinfo, ResultRelInfo rri)

static void	CopyMultiInsertInfoStore (CopyMultiInsertInfo miinfo, ResultRelInfo rri, TupleTableSlot *slot, int tuplen, uint64 lineno)

uint64	CopyFrom (CopyState cstate)

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

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

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

void	EndCopyFrom (CopyState cstate)

static int	GetDecimalFromHex (char hex)

static void	copy_dest_startup (DestReceiver *self, int operation, TupleDesc typeinfo)

static bool	copy_dest_receive (TupleTableSlot slot, DestReceiver self)

static void	copy_dest_shutdown (DestReceiver *self)

static void	copy_dest_destroy (DestReceiver *self)

DestReceiver *	CreateCopyDestReceiver (void)

Variables
static const char	BinarySignature [11] = "PGCOPY\n\377\r\n\0"

Macro Definition Documentation

◆ DUMPSOFAR

#define DUMPSOFAR ( )

Value:

do { \
        if (ptr > start) \
            CopySendData(cstate, start, ptr - start); \
    } while (0)

Definition at line 4760 of file copy.c.

Referenced by CopyAttributeOutCSV(), and CopyAttributeOutText().

◆ IF_NEED_REFILL_AND_EOF_BREAK

#define IF_NEED_REFILL_AND_EOF_BREAK ( extralen )

Value:

if (1) \
{ \
    if (raw_buf_ptr + (extralen) >= copy_buf_len && hit_eof) \
    { \
        if (extralen) \
            raw_buf_ptr = copy_buf_len; /* consume the partial character */ \
        /* backslash just before EOF, treat as data char */ \
        result = true; \
        break; \
    } \
} else ((void) 0)

Definition at line 313 of file copy.c.

Referenced by CopyReadLineText().

◆ IF_NEED_REFILL_AND_NOT_EOF_CONTINUE

#define IF_NEED_REFILL_AND_NOT_EOF_CONTINUE ( extralen )

Value:

if (1) \
{ \
    if (raw_buf_ptr + (extralen) >= copy_buf_len && !hit_eof) \
    { \
        raw_buf_ptr = prev_raw_ptr; /* undo fetch */ \
        need_data = true; \
        continue; \
    } \
} else ((void) 0)

Definition at line 301 of file copy.c.

Referenced by CopyReadLineText().

◆ ISOCTAL

#define ISOCTAL ( c ) (((c) >= '0') && ((c) <= '7'))

Definition at line 62 of file copy.c.

Referenced by CopyReadAttributesText().

◆ MAX_BUFFERED_BYTES

#define MAX_BUFFERED_BYTES 65535

Definition at line 252 of file copy.c.

Referenced by CopyMultiInsertInfoIsFull().

◆ MAX_BUFFERED_TUPLES

#define MAX_BUFFERED_TUPLES 1000

Definition at line 246 of file copy.c.

Referenced by CopyMultiInsertBufferCleanup(), CopyMultiInsertBufferInit(), CopyMultiInsertInfoIsFull(), and CopyMultiInsertInfoNextFreeSlot().

◆ MAX_COPY_DATA_DISPLAY

#define MAX_COPY_DATA_DISPLAY 100

Referenced by limit_printout_length().

◆ MAX_PARTITION_BUFFERS

#define MAX_PARTITION_BUFFERS 32

Definition at line 255 of file copy.c.

Referenced by CopyMultiInsertInfoFlush().

◆ NO_END_OF_COPY_GOTO

#define NO_END_OF_COPY_GOTO

Value:

if (1) \
{ \
    raw_buf_ptr = prev_raw_ptr + 1; \
    goto not_end_of_copy; \
} else ((void) 0)

Definition at line 343 of file copy.c.

Referenced by CopyReadLineText().

◆ OCTVALUE

#define OCTVALUE ( c ) ((c) - '0')

Definition at line 63 of file copy.c.

Referenced by CopyReadAttributesText().

◆ RAW_BUF_SIZE

#define RAW_BUF_SIZE 65536 /* we palloc RAW_BUF_SIZE+1 bytes */

Definition at line 222 of file copy.c.

Referenced by BeginCopyFrom(), and CopyLoadRawBuf().

◆ REFILL_LINEBUF

#define REFILL_LINEBUF

Value:

if (1) \
{ \
    if (raw_buf_ptr > cstate->raw_buf_index) \
    { \
        appendBinaryStringInfo(&cstate->line_buf, \
                             cstate->raw_buf + cstate->raw_buf_index, \
                               raw_buf_ptr - cstate->raw_buf_index); \
        cstate->raw_buf_index = raw_buf_ptr; \
    } \
} else ((void) 0)

Definition at line 330 of file copy.c.

Referenced by CopyReadLineText().

Typedef Documentation

◆ CopyDest

typedef enum CopyDest CopyDest

◆ CopyInsertMethod

typedef enum CopyInsertMethod CopyInsertMethod

◆ CopyMultiInsertBuffer

typedef struct CopyMultiInsertBuffer CopyMultiInsertBuffer

◆ CopyMultiInsertInfo

typedef struct CopyMultiInsertInfo CopyMultiInsertInfo

◆ CopyStateData

typedef struct CopyStateData CopyStateData

◆ EolType

typedef enum EolType EolType

Enumeration Type Documentation

◆ CopyDest

enum CopyDest

Enumerator
COPY_FILE
COPY_OLD_FE
COPY_NEW_FE
COPY_CALLBACK

Definition at line 69 of file copy.c.

 {
     COPY_FILE,                  /* to/from file (or a piped program) */
     COPY_OLD_FE,                /* to/from frontend (2.0 protocol) */
     COPY_NEW_FE,                /* to/from frontend (3.0 protocol) */
     COPY_CALLBACK               /* to/from callback function */
 } CopyDest;

◆ CopyInsertMethod

enum CopyInsertMethod

Enumerator
CIM_SINGLE
CIM_MULTI
CIM_MULTI_CONDITIONAL

Definition at line 91 of file copy.c.

 {
     CIM_SINGLE,                 /* use table_tuple_insert or fdw routine */
     CIM_MULTI,                  /* always use table_multi_insert */
     CIM_MULTI_CONDITIONAL       /* use table_multi_insert only if valid */
 } CopyInsertMethod;

◆ EolType

enum EolType

Enumerator
EOL_UNKNOWN
EOL_NL
EOL_CR
EOL_CRNL

Definition at line 80 of file copy.c.

 {
     EOL_UNKNOWN,
     EOL_NL,
     EOL_CR,
     EOL_CRNL
 } EolType;

Function Documentation

◆ BeginCopy()

static CopyState BeginCopy	(	ParseState *	pstate,
		bool	is_from,
		Relation	rel,
		RawStmt *	raw_query,
		Oid	queryRelId,
		List *	attnamelist,
		List *	options
	)

static

Definition at line 1456 of file copy.c.

References ALLOCSET_DEFAULT_SIZES, AllocSetContextCreate, Assert, attnum, CopyStateData::attnumlist, CMD_DELETE, CMD_INSERT, CMD_SELECT, CMD_UPDATE, Query::commandType, CopyStateData::convert_select, CopyStateData::convert_select_flags, CopyStateData::convert_selectively, CopyStateData::copy_dest, COPY_FILE, CopyStateData::copycontext, CopyGetAttnums(), copyObject, CreateDestReceiver(), CreateQueryDesc(), cur, CurrentMemoryContext, CURSOR_OPT_PARALLEL_OK, generate_unaccent_rules::dest, DestCopyOut, CopyStateData::encoding_embeds_ascii, ereport, errcode(), errmsg(), errmsg_internal(), ERROR, ExecutorStart(), CopyStateData::file_encoding, CopyStateData::force_notnull, CopyStateData::force_notnull_flags, CopyStateData::force_null, CopyStateData::force_null_flags, CopyStateData::force_quote, CopyStateData::force_quote_all, CopyStateData::force_quote_flags, GetActiveSnapshot(), GetDatabaseEncoding(), i, InvalidOid, InvalidSnapshot, IsA, lfirst_int, lfirst_node, linitial_node, list_length(), list_member_int(), list_member_oid(), MemoryContextSwitchTo(), NameStr, TupleDescData::natts, CopyStateData::need_transcoding, NIL, ParseState::p_sourcetext, palloc0(), pg_analyze_and_rewrite(), pg_database_encoding_max_length(), PG_ENCODING_IS_CLIENT_ONLY, pg_get_client_encoding(), pg_plan_query(), ProcessCopyOptions(), PushCopiedSnapshot(), QSRC_NON_INSTEAD_RULE, QSRC_QUAL_INSTEAD_RULE, CopyStateData::queryDesc, Query::querySource, CopyStateData::rel, RelationGetDescr, PlannedStmt::relationOids, Query::returningList, QueryDesc::tupDesc, TupleDescAttr, UpdateActiveSnapshotCommandId(), and Query::utilityStmt.

Referenced by BeginCopyFrom(), and BeginCopyTo().

 {
     CopyState   cstate;
     TupleDesc   tupDesc;
     int         num_phys_attrs;
     MemoryContext oldcontext;
 
     /* Allocate workspace and zero all fields */
     cstate = (CopyStateData *) palloc0(sizeof(CopyStateData));
 
     /*
      * We allocate everything used by a cstate in a new memory context. This
      * avoids memory leaks during repeated use of COPY in a query.
      */
     cstate->copycontext = AllocSetContextCreate(CurrentMemoryContext,
                                                 "COPY",
                                                 ALLOCSET_DEFAULT_SIZES);
 
     oldcontext = MemoryContextSwitchTo(cstate->copycontext);
 
     /* Extract options from the statement node tree */
     ProcessCopyOptions(pstate, cstate, is_from, options);
 
     /* Process the source/target relation or query */
     if (rel)
     {
         Assert(!raw_query);
 
         cstate->rel = rel;
 
         tupDesc = RelationGetDescr(cstate->rel);
     }
     else
     {
         List       *rewritten;
         Query      *query;
         PlannedStmt *plan;
         DestReceiver *dest;
 
         Assert(!is_from);
         cstate->rel = NULL;
 
         /*
          * Run parse analysis and rewrite.  Note this also acquires sufficient
          * locks on the source table(s).
          *
          * Because the parser and planner tend to scribble on their input, we
          * make a preliminary copy of the source querytree.  This prevents
          * problems in the case that the COPY is in a portal or plpgsql
          * function and is executed repeatedly.  (See also the same hack in
          * DECLARE CURSOR and PREPARE.)  XXX FIXME someday.
          */
         rewritten = pg_analyze_and_rewrite(copyObject(raw_query),
                                            pstate->p_sourcetext, NULL, 0,
                                            NULL);
 
         /* check that we got back something we can work with */
         if (rewritten == NIL)
         {
             ereport(ERROR,
                     (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                      errmsg("DO INSTEAD NOTHING rules are not supported for COPY")));
         }
         else if (list_length(rewritten) > 1)
         {
             ListCell   *lc;
 
             /* examine queries to determine which error message to issue */
             foreach(lc, rewritten)
             {
                 Query      *q = lfirst_node(Query, lc);
 
                 if (q->querySource == QSRC_QUAL_INSTEAD_RULE)
                     ereport(ERROR,
                             (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                              errmsg("conditional DO INSTEAD rules are not supported for COPY")));
                 if (q->querySource == QSRC_NON_INSTEAD_RULE)
                     ereport(ERROR,
                             (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                              errmsg("DO ALSO rules are not supported for the COPY")));
             }
 
             ereport(ERROR,
                     (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                      errmsg("multi-statement DO INSTEAD rules are not supported for COPY")));
         }
 
         query = linitial_node(Query, rewritten);
 
         /* The grammar allows SELECT INTO, but we don't support that */
         if (query->utilityStmt != NULL &&
             IsA(query->utilityStmt, CreateTableAsStmt))
             ereport(ERROR,
                     (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                      errmsg("COPY (SELECT INTO) is not supported")));
 
         Assert(query->utilityStmt == NULL);
 
         /*
          * Similarly the grammar doesn't enforce the presence of a RETURNING
          * clause, but this is required here.
          */
         if (query->commandType != CMD_SELECT &&
             query->returningList == NIL)
         {
             Assert(query->commandType == CMD_INSERT ||
                    query->commandType == CMD_UPDATE ||
                    query->commandType == CMD_DELETE);
 
             ereport(ERROR,
                     (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                      errmsg("COPY query must have a RETURNING clause")));
         }
 
         /* plan the query */
         plan = pg_plan_query(query, pstate->p_sourcetext,
                              CURSOR_OPT_PARALLEL_OK, NULL);
 
         /*
          * With row level security and a user using "COPY relation TO", we
          * have to convert the "COPY relation TO" to a query-based COPY (eg:
          * "COPY (SELECT * FROM relation) TO"), to allow the rewriter to add
          * in any RLS clauses.
          *
          * When this happens, we are passed in the relid of the originally
          * found relation (which we have locked).  As the planner will look up
          * the relation again, we double-check here to make sure it found the
          * same one that we have locked.
          */
         if (queryRelId != InvalidOid)
         {
             /*
              * Note that with RLS involved there may be multiple relations,
              * and while the one we need is almost certainly first, we don't
              * make any guarantees of that in the planner, so check the whole
              * list and make sure we find the original relation.
              */
             if (!list_member_oid(plan->relationOids, queryRelId))
                 ereport(ERROR,
                         (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
                          errmsg("relation referenced by COPY statement has changed")));
         }
 
         /*
          * Use a snapshot with an updated command ID to ensure this query sees
          * results of any previously executed queries.
          */
         PushCopiedSnapshot(GetActiveSnapshot());
         UpdateActiveSnapshotCommandId();
 
         /* Create dest receiver for COPY OUT */
         dest = CreateDestReceiver(DestCopyOut);
         ((DR_copy *) dest)->cstate = cstate;
 
         /* Create a QueryDesc requesting no output */
         cstate->queryDesc = CreateQueryDesc(plan, pstate->p_sourcetext,
                                             GetActiveSnapshot(),
                                             InvalidSnapshot,
                                             dest, NULL, NULL, 0);
 
         /*
          * Call ExecutorStart to prepare the plan for execution.
          *
          * ExecutorStart computes a result tupdesc for us
          */
         ExecutorStart(cstate->queryDesc, 0);
 
         tupDesc = cstate->queryDesc->tupDesc;
     }
 
     /* Generate or convert list of attributes to process */
     cstate->attnumlist = CopyGetAttnums(tupDesc, cstate->rel, attnamelist);
 
     num_phys_attrs = tupDesc->natts;
 
     /* Convert FORCE_QUOTE name list to per-column flags, check validity */
     cstate->force_quote_flags = (bool *) palloc0(num_phys_attrs * sizeof(bool));
     if (cstate->force_quote_all)
     {
         int         i;
 
         for (i = 0; i < num_phys_attrs; i++)
             cstate->force_quote_flags[i] = true;
     }
     else if (cstate->force_quote)
     {
         List       *attnums;
         ListCell   *cur;
 
         attnums = CopyGetAttnums(tupDesc, cstate->rel, cstate->force_quote);
 
         foreach(cur, attnums)
         {
             int         attnum = lfirst_int(cur);
             Form_pg_attribute attr = TupleDescAttr(tupDesc, attnum - 1);
 
             if (!list_member_int(cstate->attnumlist, attnum))
                 ereport(ERROR,
                         (errcode(ERRCODE_INVALID_COLUMN_REFERENCE),
                          errmsg("FORCE_QUOTE column \"%s\" not referenced by COPY",
                                 NameStr(attr->attname))));
             cstate->force_quote_flags[attnum - 1] = true;
         }
     }
 
     /* Convert FORCE_NOT_NULL name list to per-column flags, check validity */
     cstate->force_notnull_flags = (bool *) palloc0(num_phys_attrs * sizeof(bool));
     if (cstate->force_notnull)
     {
         List       *attnums;
         ListCell   *cur;
 
         attnums = CopyGetAttnums(tupDesc, cstate->rel, cstate->force_notnull);
 
         foreach(cur, attnums)
         {
             int         attnum = lfirst_int(cur);
             Form_pg_attribute attr = TupleDescAttr(tupDesc, attnum - 1);
 
             if (!list_member_int(cstate->attnumlist, attnum))
                 ereport(ERROR,
                         (errcode(ERRCODE_INVALID_COLUMN_REFERENCE),
                          errmsg("FORCE_NOT_NULL column \"%s\" not referenced by COPY",
                                 NameStr(attr->attname))));
             cstate->force_notnull_flags[attnum - 1] = true;
         }
     }
 
     /* Convert FORCE_NULL name list to per-column flags, check validity */
     cstate->force_null_flags = (bool *) palloc0(num_phys_attrs * sizeof(bool));
     if (cstate->force_null)
     {
         List       *attnums;
         ListCell   *cur;
 
         attnums = CopyGetAttnums(tupDesc, cstate->rel, cstate->force_null);
 
         foreach(cur, attnums)
         {
             int         attnum = lfirst_int(cur);
             Form_pg_attribute attr = TupleDescAttr(tupDesc, attnum - 1);
 
             if (!list_member_int(cstate->attnumlist, attnum))
                 ereport(ERROR,
                         (errcode(ERRCODE_INVALID_COLUMN_REFERENCE),
                          errmsg("FORCE_NULL column \"%s\" not referenced by COPY",
                                 NameStr(attr->attname))));
             cstate->force_null_flags[attnum - 1] = true;
         }
     }
 
     /* Convert convert_selectively name list to per-column flags */
     if (cstate->convert_selectively)
     {
         List       *attnums;
         ListCell   *cur;
 
         cstate->convert_select_flags = (bool *) palloc0(num_phys_attrs * sizeof(bool));
 
         attnums = CopyGetAttnums(tupDesc, cstate->rel, cstate->convert_select);
 
         foreach(cur, attnums)
         {
             int         attnum = lfirst_int(cur);
             Form_pg_attribute attr = TupleDescAttr(tupDesc, attnum - 1);
 
             if (!list_member_int(cstate->attnumlist, attnum))
                 ereport(ERROR,
                         (errcode(ERRCODE_INVALID_COLUMN_REFERENCE),
                          errmsg_internal("selected column \"%s\" not referenced by COPY",
                                          NameStr(attr->attname))));
             cstate->convert_select_flags[attnum - 1] = true;
         }
     }
 
     /* Use client encoding when ENCODING option is not specified. */
     if (cstate->file_encoding < 0)
         cstate->file_encoding = pg_get_client_encoding();
 
     /*
      * Set up encoding conversion info.  Even if the file and server encodings
      * are the same, we must apply pg_any_to_server() to validate data in
      * multibyte encodings.
      */
     cstate->need_transcoding =
         (cstate->file_encoding != GetDatabaseEncoding() ||
          pg_database_encoding_max_length() > 1);
     /* See Multibyte encoding comment above */
     cstate->encoding_embeds_ascii = PG_ENCODING_IS_CLIENT_ONLY(cstate->file_encoding);
 
     cstate->copy_dest = COPY_FILE;  /* default */
 
     MemoryContextSwitchTo(oldcontext);
 
     return cstate;
 }

◆ 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 3329 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;
 }

◆ BeginCopyTo()

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

static

Definition at line 1821 of file copy.c.

References AllocateFile(), Assert, BeginCopy(), CopyStateData::copy_file, CopyStateData::copycontext, DestRemote, ereport, errcode(), errcode_for_file_access(), errhint(), errmsg(), ERROR, CopyStateData::filename, is_absolute_path, CopyStateData::is_program, MemoryContextSwitchTo(), OpenPipeStream(), PG_BINARY_W, PG_END_TRY, PG_FINALLY, PG_TRY, pstrdup(), RelationData::rd_rel, RelationGetRelationName, S_ISDIR, S_IWGRP, S_IWOTH, stat, generate_unaccent_rules::stdout, and whereToSendOutput.

Referenced by DoCopy().

 {
     CopyState   cstate;
     bool        pipe = (filename == NULL);
     MemoryContext oldcontext;
 
     if (rel != NULL && rel->rd_rel->relkind != RELKIND_RELATION)
     {
         if (rel->rd_rel->relkind == RELKIND_VIEW)
             ereport(ERROR,
                     (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                      errmsg("cannot copy from view \"%s\"",
                             RelationGetRelationName(rel)),
                      errhint("Try the COPY (SELECT ...) TO variant.")));
         else if (rel->rd_rel->relkind == RELKIND_MATVIEW)
             ereport(ERROR,
                     (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                      errmsg("cannot copy from materialized view \"%s\"",
                             RelationGetRelationName(rel)),
                      errhint("Try the COPY (SELECT ...) TO variant.")));
         else if (rel->rd_rel->relkind == RELKIND_FOREIGN_TABLE)
             ereport(ERROR,
                     (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                      errmsg("cannot copy from foreign table \"%s\"",
                             RelationGetRelationName(rel)),
                      errhint("Try the COPY (SELECT ...) TO variant.")));
         else if (rel->rd_rel->relkind == RELKIND_SEQUENCE)
             ereport(ERROR,
                     (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                      errmsg("cannot copy from sequence \"%s\"",
                             RelationGetRelationName(rel))));
         else if (rel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE)
             ereport(ERROR,
                     (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                      errmsg("cannot copy from partitioned table \"%s\"",
                             RelationGetRelationName(rel)),
                      errhint("Try the COPY (SELECT ...) TO variant.")));
         else
             ereport(ERROR,
                     (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                      errmsg("cannot copy from non-table relation \"%s\"",
                             RelationGetRelationName(rel))));
     }
 
     cstate = BeginCopy(pstate, false, rel, query, queryRelId, attnamelist,
                        options);
     oldcontext = MemoryContextSwitchTo(cstate->copycontext);
 
     if (pipe)
     {
         Assert(!is_program);    /* the grammar does not allow this */
         if (whereToSendOutput != DestRemote)
             cstate->copy_file = stdout;
     }
     else
     {
         cstate->filename = pstrdup(filename);
         cstate->is_program = is_program;
 
         if (is_program)
         {
             cstate->copy_file = OpenPipeStream(cstate->filename, PG_BINARY_W);
             if (cstate->copy_file == NULL)
                 ereport(ERROR,
                         (errcode_for_file_access(),
                          errmsg("could not execute command \"%s\": %m",
                                 cstate->filename)));
         }
         else
         {
             mode_t      oumask; /* Pre-existing umask value */
             struct stat st;
 
             /*
              * Prevent write to relative path ... too easy to shoot oneself in
              * the foot by overwriting a database file ...
              */
             if (!is_absolute_path(filename))
                 ereport(ERROR,
                         (errcode(ERRCODE_INVALID_NAME),
                          errmsg("relative path not allowed for COPY to file")));
 
             oumask = umask(S_IWGRP | S_IWOTH);
             PG_TRY();
             {
                 cstate->copy_file = AllocateFile(cstate->filename, PG_BINARY_W);
             }
             PG_FINALLY();
             {
                 umask(oumask);
             }
             PG_END_TRY();
             if (cstate->copy_file == NULL)
             {
                 /* copy errno because ereport subfunctions might change it */
                 int         save_errno = errno;
 
                 ereport(ERROR,
                         (errcode_for_file_access(),
                          errmsg("could not open file \"%s\" for writing: %m",
                                 cstate->filename),
                          (save_errno == ENOENT || save_errno == EACCES) ?
                          errhint("COPY TO instructs the PostgreSQL server process to write a file. "
                                  "You may want a client-side facility such as psql's \\copy.") : 0));
             }
 
             if (fstat(fileno(cstate->copy_file), &st))
                 ereport(ERROR,
                         (errcode_for_file_access(),
                          errmsg("could not stat file \"%s\": %m",
                                 cstate->filename)));
 
             if (S_ISDIR(st.st_mode))
                 ereport(ERROR,
                         (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                          errmsg("\"%s\" is a directory", cstate->filename)));
         }
     }
 
     MemoryContextSwitchTo(oldcontext);
 
     return cstate;
 }

◆ ClosePipeToProgram()

static void ClosePipeToProgram ( CopyState cstate )

static

Definition at line 1763 of file copy.c.

References Assert, ClosePipeStream(), CopyStateData::copy_file, ereport, errcode(), errcode_for_file_access(), errdetail_internal(), errmsg(), ERROR, CopyStateData::filename, CopyStateData::is_copy_from, CopyStateData::is_program, CopyStateData::reached_eof, SIGPIPE, wait_result_is_signal(), and wait_result_to_str().

Referenced by CopySendEndOfRow(), and EndCopy().

 {
     int         pclose_rc;
 
     Assert(cstate->is_program);
 
     pclose_rc = ClosePipeStream(cstate->copy_file);
     if (pclose_rc == -1)
         ereport(ERROR,
                 (errcode_for_file_access(),
                  errmsg("could not close pipe to external command: %m")));
     else if (pclose_rc != 0)
     {
         /*
          * If we ended a COPY FROM PROGRAM before reaching EOF, then it's
          * expectable for the called program to fail with SIGPIPE, and we
          * should not report that as an error.  Otherwise, SIGPIPE indicates a
          * problem.
          */
         if (cstate->is_copy_from && !cstate->reached_eof &&
             wait_result_is_signal(pclose_rc, SIGPIPE))
             return;
 
         ereport(ERROR,
                 (errcode(ERRCODE_EXTERNAL_ROUTINE_EXCEPTION),
                  errmsg("program \"%s\" failed",
                         cstate->filename),
                  errdetail_internal("%s", wait_result_to_str(pclose_rc))));
     }
 }

◆ copy_dest_destroy()

static void copy_dest_destroy ( DestReceiver * self )

static

Definition at line 5131 of file copy.c.

References pfree().

Referenced by CreateCopyDestReceiver().

 {
     pfree(self);
 }

◆ copy_dest_receive()

static bool copy_dest_receive	(	TupleTableSlot *	slot,
		DestReceiver *	self
	)

static

Definition at line 5106 of file copy.c.

References CopyOneRowTo(), DR_copy::cstate, and DR_copy::processed.

Referenced by CreateCopyDestReceiver().

 {
     DR_copy    *myState = (DR_copy *) self;
     CopyState   cstate = myState->cstate;
 
     /* Send the data */
     CopyOneRowTo(cstate, slot);
     myState->processed++;
 
     return true;
 }

◆ copy_dest_shutdown()

static void copy_dest_shutdown ( DestReceiver * self )

static

Definition at line 5122 of file copy.c.

Referenced by CreateCopyDestReceiver().

 {
     /* no-op */
 }

◆ copy_dest_startup()

static void copy_dest_startup	(	DestReceiver *	self,
		int	operation,
		TupleDesc	typeinfo
	)

static

Definition at line 5097 of file copy.c.

Referenced by CreateCopyDestReceiver().

 {
     /* no-op */
 }

◆ CopyAttributeOutCSV()

static void CopyAttributeOutCSV	(	CopyState	cstate,
		char *	string,
		bool	use_quote,
		bool	single_attr
	)

static

Definition at line 4920 of file copy.c.

References CopySendChar(), CopySendString(), CopyStateData::delim, DUMPSOFAR, CopyStateData::encoding_embeds_ascii, CopyStateData::escape, CopyStateData::file_encoding, IS_HIGHBIT_SET, CopyStateData::need_transcoding, CopyStateData::null_print, pg_encoding_mblen(), pg_server_to_any(), and CopyStateData::quote.

Referenced by CopyOneRowTo(), and CopyTo().

 {
     char       *ptr;
     char       *start;
     char        c;
     char        delimc = cstate->delim[0];
     char        quotec = cstate->quote[0];
     char        escapec = cstate->escape[0];
 
     /* force quoting if it matches null_print (before conversion!) */
     if (!use_quote && strcmp(string, cstate->null_print) == 0)
         use_quote = true;
 
     if (cstate->need_transcoding)
         ptr = pg_server_to_any(string, strlen(string), cstate->file_encoding);
     else
         ptr = string;
 
     /*
      * Make a preliminary pass to discover if it needs quoting
      */
     if (!use_quote)
     {
         /*
          * Because '\.' can be a data value, quote it if it appears alone on a
          * line so it is not interpreted as the end-of-data marker.
          */
         if (single_attr && strcmp(ptr, "\\.") == 0)
             use_quote = true;
         else
         {
             char       *tptr = ptr;
 
             while ((c = *tptr) != '\0')
             {
                 if (c == delimc || c == quotec || c == '\n' || c == '\r')
                 {
                     use_quote = true;
                     break;
                 }
                 if (IS_HIGHBIT_SET(c) && cstate->encoding_embeds_ascii)
                     tptr += pg_encoding_mblen(cstate->file_encoding, tptr);
                 else
                     tptr++;
             }
         }
     }
 
     if (use_quote)
     {
         CopySendChar(cstate, quotec);
 
         /*
          * We adopt the same optimization strategy as in CopyAttributeOutText
          */
         start = ptr;
         while ((c = *ptr) != '\0')
         {
             if (c == quotec || c == escapec)
             {
                 DUMPSOFAR();
                 CopySendChar(cstate, escapec);
                 start = ptr;    /* we include char in next run */
             }
             if (IS_HIGHBIT_SET(c) && cstate->encoding_embeds_ascii)
                 ptr += pg_encoding_mblen(cstate->file_encoding, ptr);
             else
                 ptr++;
         }
         DUMPSOFAR();
 
         CopySendChar(cstate, quotec);
     }
     else
     {
         /* If it doesn't need quoting, we can just dump it as-is */
         CopySendString(cstate, ptr);
     }
 }

◆ CopyAttributeOutText()

static void CopyAttributeOutText	(	CopyState	cstate,
		char *	string
	)

static

Definition at line 4767 of file copy.c.

References CopySendChar(), CopyStateData::delim, DUMPSOFAR, CopyStateData::encoding_embeds_ascii, CopyStateData::file_encoding, IS_HIGHBIT_SET, CopyStateData::need_transcoding, pg_encoding_mblen(), and pg_server_to_any().

Referenced by CopyOneRowTo().

 {
     char       *ptr;
     char       *start;
     char        c;
     char        delimc = cstate->delim[0];
 
     if (cstate->need_transcoding)
         ptr = pg_server_to_any(string, strlen(string), cstate->file_encoding);
     else
         ptr = string;
 
     /*
      * We have to grovel through the string searching for control characters
      * and instances of the delimiter character.  In most cases, though, these
      * are infrequent.  To avoid overhead from calling CopySendData once per
      * character, we dump out all characters between escaped characters in a
      * single call.  The loop invariant is that the data from "start" to "ptr"
      * can be sent literally, but hasn't yet been.
      *
      * We can skip pg_encoding_mblen() overhead when encoding is safe, because
      * in valid backend encodings, extra bytes of a multibyte character never
      * look like ASCII.  This loop is sufficiently performance-critical that
      * it's worth making two copies of it to get the IS_HIGHBIT_SET() test out
      * of the normal safe-encoding path.
      */
     if (cstate->encoding_embeds_ascii)
     {
         start = ptr;
         while ((c = *ptr) != '\0')
         {
             if ((unsigned char) c < (unsigned char) 0x20)
             {
                 /*
                  * \r and \n must be escaped, the others are traditional. We
                  * prefer to dump these using the C-like notation, rather than
                  * a backslash and the literal character, because it makes the
                  * dump file a bit more proof against Microsoftish data
                  * mangling.
                  */
                 switch (c)
                 {
                     case '\b':
                         c = 'b';
                         break;
                     case '\f':
                         c = 'f';
                         break;
                     case '\n':
                         c = 'n';
                         break;
                     case '\r':
                         c = 'r';
                         break;
                     case '\t':
                         c = 't';
                         break;
                     case '\v':
                         c = 'v';
                         break;
                     default:
                         /* If it's the delimiter, must backslash it */
                         if (c == delimc)
                             break;
                         /* All ASCII control chars are length 1 */
                         ptr++;
                         continue;   /* fall to end of loop */
                 }
                 /* if we get here, we need to convert the control char */
                 DUMPSOFAR();
                 CopySendChar(cstate, '\\');
                 CopySendChar(cstate, c);
                 start = ++ptr;  /* do not include char in next run */
             }
             else if (c == '\\' || c == delimc)
             {
                 DUMPSOFAR();
                 CopySendChar(cstate, '\\');
                 start = ptr++;  /* we include char in next run */
             }
             else if (IS_HIGHBIT_SET(c))
                 ptr += pg_encoding_mblen(cstate->file_encoding, ptr);
             else
                 ptr++;
         }
     }
     else
     {
         start = ptr;
         while ((c = *ptr) != '\0')
         {
             if ((unsigned char) c < (unsigned char) 0x20)
             {
                 /*
                  * \r and \n must be escaped, the others are traditional. We
                  * prefer to dump these using the C-like notation, rather than
                  * a backslash and the literal character, because it makes the
                  * dump file a bit more proof against Microsoftish data
                  * mangling.
                  */
                 switch (c)
                 {
                     case '\b':
                         c = 'b';
                         break;
                     case '\f':
                         c = 'f';
                         break;
                     case '\n':
                         c = 'n';
                         break;
                     case '\r':
                         c = 'r';
                         break;
                     case '\t':
                         c = 't';
                         break;
                     case '\v':
                         c = 'v';
                         break;
                     default:
                         /* If it's the delimiter, must backslash it */
                         if (c == delimc)
                             break;
                         /* All ASCII control chars are length 1 */
                         ptr++;
                         continue;   /* fall to end of loop */
                 }
                 /* if we get here, we need to convert the control char */
                 DUMPSOFAR();
                 CopySendChar(cstate, '\\');
                 CopySendChar(cstate, c);
                 start = ++ptr;  /* do not include char in next run */
             }
             else if (c == '\\' || c == delimc)
             {
                 DUMPSOFAR();
                 CopySendChar(cstate, '\\');
                 start = ptr++;  /* we include char in next run */
             }
             else
                 ptr++;
         }
     }
 
     DUMPSOFAR();
 }

◆ CopyFrom()

uint64 CopyFrom ( CopyState cstate )

Definition at line 2648 of file copy.c.

Referenced by copy_table(), and DoCopy().

 {
     ResultRelInfo *resultRelInfo;
     ResultRelInfo *target_resultRelInfo;
     ResultRelInfo *prevResultRelInfo = NULL;
     EState     *estate = CreateExecutorState(); /* for ExecConstraints() */
     ModifyTableState *mtstate;
     ExprContext *econtext;
     TupleTableSlot *singleslot = NULL;
     MemoryContext oldcontext = CurrentMemoryContext;
 
     PartitionTupleRouting *proute = NULL;
     ErrorContextCallback errcallback;
     CommandId   mycid = GetCurrentCommandId(true);
     int         ti_options = 0; /* start with default options for insert */
     BulkInsertState bistate = NULL;
     CopyInsertMethod insertMethod;
     CopyMultiInsertInfo multiInsertInfo = {0};  /* pacify compiler */
     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 2233 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);
             }
         }
     }
 }

◆ CopyGetAttnums()

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

static

Definition at line 5016 of file copy.c.

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

Referenced by BeginCopy(), and DoCopy().

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

◆ CopyGetData()

static int CopyGetData	(	CopyState	cstate,
		void *	databuf,
		int	minread,
		int	maxread
	)

static

Definition at line 610 of file copy.c.

References COPY_CALLBACK, CopyStateData::copy_dest, COPY_FILE, CopyStateData::copy_file, COPY_NEW_FE, COPY_OLD_FE, StringInfoData::cursor, CopyStateData::data_source_cb, ereport, errcode(), errcode_for_file_access(), errmsg(), ERROR, CopyStateData::fe_msgbuf, HOLD_CANCEL_INTERRUPTS, StringInfoData::len, pq_copymsgbytes(), pq_getbyte(), pq_getbytes(), pq_getmessage(), pq_getmsgstring(), pq_startmsgread(), CopyStateData::reached_eof, and RESUME_CANCEL_INTERRUPTS.

Referenced by BeginCopyFrom(), CopyGetInt16(), CopyGetInt32(), CopyLoadRawBuf(), CopyReadBinaryAttribute(), and NextCopyFrom().

 {
     int         bytesread = 0;
 
     switch (cstate->copy_dest)
     {
         case COPY_FILE:
             bytesread = fread(databuf, 1, maxread, cstate->copy_file);
             if (ferror(cstate->copy_file))
                 ereport(ERROR,
                         (errcode_for_file_access(),
                          errmsg("could not read from COPY file: %m")));
             if (bytesread == 0)
                 cstate->reached_eof = true;
             break;
         case COPY_OLD_FE:
 
             /*
              * We cannot read more than minread bytes (which in practice is 1)
              * because old protocol doesn't have any clear way of separating
              * the COPY stream from following data.  This is slow, but not any
              * slower than the code path was originally, and we don't care
              * much anymore about the performance of old protocol.
              */
             if (pq_getbytes((char *) databuf, minread))
             {
                 /* Only a \. terminator is legal EOF in old protocol */
                 ereport(ERROR,
                         (errcode(ERRCODE_CONNECTION_FAILURE),
                          errmsg("unexpected EOF on client connection with an open transaction")));
             }
             bytesread = minread;
             break;
         case COPY_NEW_FE:
             while (maxread > 0 && bytesread < minread && !cstate->reached_eof)
             {
                 int         avail;
 
                 while (cstate->fe_msgbuf->cursor >= cstate->fe_msgbuf->len)
                 {
                     /* Try to receive another message */
                     int         mtype;
 
             readmessage:
                     HOLD_CANCEL_INTERRUPTS();
                     pq_startmsgread();
                     mtype = pq_getbyte();
                     if (mtype == EOF)
                         ereport(ERROR,
                                 (errcode(ERRCODE_CONNECTION_FAILURE),
                                  errmsg("unexpected EOF on client connection with an open transaction")));
                     if (pq_getmessage(cstate->fe_msgbuf, 0))
                         ereport(ERROR,
                                 (errcode(ERRCODE_CONNECTION_FAILURE),
                                  errmsg("unexpected EOF on client connection with an open transaction")));
                     RESUME_CANCEL_INTERRUPTS();
                     switch (mtype)
                     {
                         case 'd':   /* CopyData */
                             break;
                         case 'c':   /* CopyDone */
                             /* COPY IN correctly terminated by frontend */
                             cstate->reached_eof = true;
                             return bytesread;
                         case 'f':   /* CopyFail */
                             ereport(ERROR,
                                     (errcode(ERRCODE_QUERY_CANCELED),
                                      errmsg("COPY from stdin failed: %s",
                                             pq_getmsgstring(cstate->fe_msgbuf))));
                             break;
                         case 'H':   /* Flush */
                         case 'S':   /* Sync */
 
                             /*
                              * Ignore Flush/Sync for the convenience of client
                              * libraries (such as libpq) that may send those
                              * without noticing that the command they just
                              * sent was COPY.
                              */
                             goto readmessage;
                         default:
                             ereport(ERROR,
                                     (errcode(ERRCODE_PROTOCOL_VIOLATION),
                                      errmsg("unexpected message type 0x%02X during COPY from stdin",
                                             mtype)));
                             break;
                     }
                 }
                 avail = cstate->fe_msgbuf->len - cstate->fe_msgbuf->cursor;
                 if (avail > maxread)
                     avail = maxread;
                 pq_copymsgbytes(cstate->fe_msgbuf, databuf, avail);
                 databuf = (void *) ((char *) databuf + avail);
                 maxread -= avail;
                 bytesread += avail;
             }
             break;
         case COPY_CALLBACK:
             bytesread = cstate->data_source_cb(databuf, minread, maxread);
             break;
     }
 
     return bytesread;
 }

◆ CopyGetInt16()

static bool CopyGetInt16	(	CopyState	cstate,
		int16 *	val
	)

static

Definition at line 767 of file copy.c.

References buf, CopyGetData(), and pg_ntoh16.

Referenced by NextCopyFrom().

 {
     uint16      buf;
 
     if (CopyGetData(cstate, &buf, sizeof(buf), sizeof(buf)) != sizeof(buf))
     {
         *val = 0;               /* suppress compiler warning */
         return false;
     }
     *val = (int16) pg_ntoh16(buf);
     return true;
 }

◆ CopyGetInt32()

static bool CopyGetInt32	(	CopyState	cstate,
		int32 *	val
	)

static

Definition at line 738 of file copy.c.

References buf, CopyGetData(), and pg_ntoh32.

Referenced by BeginCopyFrom(), and CopyReadBinaryAttribute().

 {
     uint32      buf;
 
     if (CopyGetData(cstate, &buf, sizeof(buf), sizeof(buf)) != sizeof(buf))
     {
         *val = 0;               /* suppress compiler warning */
         return false;
     }
     *val = (int32) pg_ntoh32(buf);
     return true;
 }

◆ CopyLoadRawBuf()

static bool CopyLoadRawBuf ( CopyState cstate )

static

Definition at line 792 of file copy.c.

References CopyGetData(), CopyStateData::raw_buf, CopyStateData::raw_buf_index, CopyStateData::raw_buf_len, and RAW_BUF_SIZE.

Referenced by CopyReadLine(), and CopyReadLineText().

 {
     int         nbytes;
     int         inbytes;
 
     if (cstate->raw_buf_index < cstate->raw_buf_len)
     {
         /* Copy down the unprocessed data */
         nbytes = cstate->raw_buf_len - cstate->raw_buf_index;
         memmove(cstate->raw_buf, cstate->raw_buf + cstate->raw_buf_index,
                 nbytes);
     }
     else
         nbytes = 0;             /* no data need be saved */
 
     inbytes = CopyGetData(cstate, cstate->raw_buf + nbytes,
                           1, RAW_BUF_SIZE - nbytes);
     nbytes += inbytes;
     cstate->raw_buf[nbytes] = '\0';
     cstate->raw_buf_index = 0;
     cstate->raw_buf_len = nbytes;
     return (inbytes > 0);
 }

◆ CopyMultiInsertBufferCleanup()

static void CopyMultiInsertBufferCleanup	(	CopyMultiInsertInfo *	miinfo,
		CopyMultiInsertBuffer *	buffer
	)

inlinestatic

Definition at line 2510 of file copy.c.

References Assert, CopyMultiInsertBuffer::bistate, ExecDropSingleTupleTableSlot(), FreeBulkInsertState(), i, MAX_BUFFERED_TUPLES, CopyMultiInsertBuffer::nused, pfree(), CopyMultiInsertBuffer::resultRelInfo, ResultRelInfo::ri_CopyMultiInsertBuffer, ResultRelInfo::ri_RelationDesc, CopyMultiInsertBuffer::slots, table_finish_bulk_insert(), and CopyMultiInsertInfo::ti_options.

Referenced by CopyMultiInsertInfoCleanup(), and CopyMultiInsertInfoFlush().

 {
     int         i;
 
     /* Ensure buffer was flushed */
     Assert(buffer->nused == 0);
 
     /* Remove back-link to ourself */
     buffer->resultRelInfo->ri_CopyMultiInsertBuffer = NULL;
 
     FreeBulkInsertState(buffer->bistate);
 
     /* Since we only create slots on demand, just drop the non-null ones. */
     for (i = 0; i < MAX_BUFFERED_TUPLES && buffer->slots[i] != NULL; i++)
         ExecDropSingleTupleTableSlot(buffer->slots[i]);
 
     table_finish_bulk_insert(buffer->resultRelInfo->ri_RelationDesc,
                              miinfo->ti_options);
 
     pfree(buffer);
 }

◆ CopyMultiInsertBufferFlush()

static void CopyMultiInsertBufferFlush	(	CopyMultiInsertInfo *	miinfo,
		CopyMultiInsertBuffer *	buffer
	)

inlinestatic

Definition at line 2422 of file copy.c.

References CopyMultiInsertBuffer::bistate, CopyMultiInsertInfo::cstate, CopyStateData::cur_lineno, EState::es_result_relation_info, CopyMultiInsertInfo::estate, ExecARInsertTriggers(), ExecClearTuple(), ExecInsertIndexTuples(), GetPerTupleMemoryContext, i, CopyStateData::line_buf_valid, CopyMultiInsertBuffer::linenos, list_free(), MemoryContextSwitchTo(), CopyMultiInsertInfo::mycid, NIL, CopyMultiInsertBuffer::nused, CopyMultiInsertBuffer::resultRelInfo, ResultRelInfo::ri_NumIndices, ResultRelInfo::ri_RelationDesc, ResultRelInfo::ri_TrigDesc, CopyMultiInsertBuffer::slots, table_multi_insert(), CopyMultiInsertInfo::ti_options, CopyStateData::transition_capture, TriggerDesc::trig_insert_after_row, and TriggerDesc::trig_insert_new_table.

Referenced by CopyMultiInsertInfoFlush().

 {
     MemoryContext oldcontext;
     int         i;
     uint64      save_cur_lineno;
     CopyState   cstate = miinfo->cstate;
     EState     *estate = miinfo->estate;
     CommandId   mycid = miinfo->mycid;
     int         ti_options = miinfo->ti_options;
     bool        line_buf_valid = cstate->line_buf_valid;
     int         nused = buffer->nused;
     ResultRelInfo *resultRelInfo = buffer->resultRelInfo;
     TupleTableSlot **slots = buffer->slots;
 
     /* Set es_result_relation_info to the ResultRelInfo we're flushing. */
     estate->es_result_relation_info = resultRelInfo;
 
     /*
      * Print error context information correctly, if one of the operations
      * below fail.
      */
     cstate->line_buf_valid = false;
     save_cur_lineno = cstate->cur_lineno;
 
     /*
      * table_multi_insert may leak memory, so switch to short-lived memory
      * context before calling it.
      */
     oldcontext = MemoryContextSwitchTo(GetPerTupleMemoryContext(estate));
     table_multi_insert(resultRelInfo->ri_RelationDesc,
                        slots,
                        nused,
                        mycid,
                        ti_options,
                        buffer->bistate);
     MemoryContextSwitchTo(oldcontext);
 
     for (i = 0; i < nused; i++)
     {
         /*
          * If there are any indexes, update them for all the inserted tuples,
          * and run AFTER ROW INSERT triggers.
          */
         if (resultRelInfo->ri_NumIndices > 0)
         {
             List       *recheckIndexes;
 
             cstate->cur_lineno = buffer->linenos[i];
             recheckIndexes =
                 ExecInsertIndexTuples(buffer->slots[i], estate, false, NULL,
                                       NIL);
             ExecARInsertTriggers(estate, resultRelInfo,
                                  slots[i], recheckIndexes,
                                  cstate->transition_capture);
             list_free(recheckIndexes);
         }
 
         /*
          * There's no indexes, but see if we need to run AFTER ROW INSERT
          * triggers anyway.
          */
         else if (resultRelInfo->ri_TrigDesc != NULL &&
                  (resultRelInfo->ri_TrigDesc->trig_insert_after_row ||
                   resultRelInfo->ri_TrigDesc->trig_insert_new_table))
         {
             cstate->cur_lineno = buffer->linenos[i];
             ExecARInsertTriggers(estate, resultRelInfo,
                                  slots[i], NIL, cstate->transition_capture);
         }
 
         ExecClearTuple(slots[i]);
     }
 
     /* Mark that all slots are free */
     buffer->nused = 0;
 
     /* reset cur_lineno and line_buf_valid to what they were */
     cstate->line_buf_valid = line_buf_valid;
     cstate->cur_lineno = save_cur_lineno;
 }

◆ CopyMultiInsertBufferInit()

static CopyMultiInsertBuffer* CopyMultiInsertBufferInit ( ResultRelInfo * rri )

static

Definition at line 2339 of file copy.c.

References CopyMultiInsertBuffer::bistate, GetBulkInsertState(), MAX_BUFFERED_TUPLES, CopyMultiInsertBuffer::nused, palloc(), CopyMultiInsertBuffer::resultRelInfo, and CopyMultiInsertBuffer::slots.

Referenced by CopyMultiInsertInfoSetupBuffer().

 {
     CopyMultiInsertBuffer *buffer;
 
     buffer = (CopyMultiInsertBuffer *) palloc(sizeof(CopyMultiInsertBuffer));
     memset(buffer->slots, 0, sizeof(TupleTableSlot *) * MAX_BUFFERED_TUPLES);
     buffer->resultRelInfo = rri;
     buffer->bistate = GetBulkInsertState();
     buffer->nused = 0;
 
     return buffer;
 }

◆ CopyMultiInsertInfoCleanup()

static void CopyMultiInsertInfoCleanup ( CopyMultiInsertInfo * miinfo )

inlinestatic

Definition at line 2590 of file copy.c.

References CopyMultiInsertBufferCleanup(), lfirst, list_free(), and CopyMultiInsertInfo::multiInsertBuffers.

Referenced by CopyFrom().

 {
     ListCell   *lc;
 
     foreach(lc, miinfo->multiInsertBuffers)
         CopyMultiInsertBufferCleanup(miinfo, lfirst(lc));
 
     list_free(miinfo->multiInsertBuffers);
 }

◆ CopyMultiInsertInfoFlush()

static void CopyMultiInsertInfoFlush	(	CopyMultiInsertInfo *	miinfo,
		ResultRelInfo *	curr_rri
	)

inlinestatic

Definition at line 2544 of file copy.c.

References CopyMultiInsertInfo::bufferedBytes, CopyMultiInsertInfo::bufferedTuples, CopyMultiInsertBufferCleanup(), CopyMultiInsertBufferFlush(), lappend(), lfirst, linitial, list_delete_first(), list_length(), MAX_PARTITION_BUFFERS, CopyMultiInsertInfo::multiInsertBuffers, and CopyMultiInsertBuffer::resultRelInfo.

Referenced by CopyFrom().

 {
     ListCell   *lc;
 
     foreach(lc, miinfo->multiInsertBuffers)
     {
         CopyMultiInsertBuffer *buffer = (CopyMultiInsertBuffer *) lfirst(lc);
 
         CopyMultiInsertBufferFlush(miinfo, buffer);
     }
 
     miinfo->bufferedTuples = 0;
     miinfo->bufferedBytes = 0;
 
     /*
      * Trim the list of tracked buffers down if it exceeds the limit.  Here we
      * remove buffers starting with the ones we created first.  It seems more
      * likely that these older ones are less likely to be needed than ones
      * that were just created.
      */
     while (list_length(miinfo->multiInsertBuffers) > MAX_PARTITION_BUFFERS)
     {
         CopyMultiInsertBuffer *buffer;
 
         buffer = (CopyMultiInsertBuffer *) linitial(miinfo->multiInsertBuffers);
 
         /*
          * We never want to remove the buffer that's currently being used, so
          * if we happen to find that then move it to the end of the list.
          */
         if (buffer->resultRelInfo == curr_rri)
         {
             miinfo->multiInsertBuffers = list_delete_first(miinfo->multiInsertBuffers);
             miinfo->multiInsertBuffers = lappend(miinfo->multiInsertBuffers, buffer);
             buffer = (CopyMultiInsertBuffer *) linitial(miinfo->multiInsertBuffers);
         }
 
         CopyMultiInsertBufferCleanup(miinfo, buffer);
         miinfo->multiInsertBuffers = list_delete_first(miinfo->multiInsertBuffers);
     }
 }

◆ CopyMultiInsertInfoInit()

static void CopyMultiInsertInfoInit	(	CopyMultiInsertInfo *	miinfo,
		ResultRelInfo *	rri,
		CopyState	cstate,
		EState *	estate,
		CommandId	mycid,
		int	ti_options
	)

static

Definition at line 2376 of file copy.c.

References CopyMultiInsertInfo::bufferedBytes, CopyMultiInsertInfo::bufferedTuples, CopyMultiInsertInfoSetupBuffer(), CopyMultiInsertInfo::cstate, CopyMultiInsertInfo::estate, CopyMultiInsertInfo::multiInsertBuffers, CopyMultiInsertInfo::mycid, NIL, RelationData::rd_rel, ResultRelInfo::ri_RelationDesc, and CopyMultiInsertInfo::ti_options.

Referenced by CopyFrom().

 {
     miinfo->multiInsertBuffers = NIL;
     miinfo->bufferedTuples = 0;
     miinfo->bufferedBytes = 0;
     miinfo->cstate = cstate;
     miinfo->estate = estate;
     miinfo->mycid = mycid;
     miinfo->ti_options = ti_options;
 
     /*
      * Only setup the buffer when not dealing with a partitioned table.
      * Buffers for partitioned tables will just be setup when we need to send
      * tuples their way for the first time.
      */
     if (rri->ri_RelationDesc->rd_rel->relkind != RELKIND_PARTITIONED_TABLE)
         CopyMultiInsertInfoSetupBuffer(miinfo, rri);
 }

◆ CopyMultiInsertInfoIsEmpty()

static bool CopyMultiInsertInfoIsEmpty ( CopyMultiInsertInfo * miinfo )

inlinestatic

Definition at line 2413 of file copy.c.

References CopyMultiInsertInfo::bufferedTuples.

Referenced by CopyFrom().

 {
     return miinfo->bufferedTuples == 0;
 }

◆ CopyMultiInsertInfoIsFull()

static bool CopyMultiInsertInfoIsFull ( CopyMultiInsertInfo * miinfo )

inlinestatic

Definition at line 2401 of file copy.c.

References CopyMultiInsertInfo::bufferedBytes, CopyMultiInsertInfo::bufferedTuples, MAX_BUFFERED_BYTES, and MAX_BUFFERED_TUPLES.

Referenced by CopyFrom().

 {
     if (miinfo->bufferedTuples >= MAX_BUFFERED_TUPLES ||
         miinfo->bufferedBytes >= MAX_BUFFERED_BYTES)
         return true;
     return false;
 }

◆ CopyMultiInsertInfoNextFreeSlot()

static TupleTableSlot* CopyMultiInsertInfoNextFreeSlot	(	CopyMultiInsertInfo *	miinfo,
		ResultRelInfo *	rri
	)

inlinestatic

Definition at line 2606 of file copy.c.

References Assert, MAX_BUFFERED_TUPLES, CopyMultiInsertBuffer::nused, ResultRelInfo::ri_CopyMultiInsertBuffer, ResultRelInfo::ri_RelationDesc, CopyMultiInsertBuffer::slots, and table_slot_create().

Referenced by CopyFrom().

 {
     CopyMultiInsertBuffer *buffer = rri->ri_CopyMultiInsertBuffer;
     int         nused = buffer->nused;
 
     Assert(buffer != NULL);
     Assert(nused < MAX_BUFFERED_TUPLES);
 
     if (buffer->slots[nused] == NULL)
         buffer->slots[nused] = table_slot_create(rri->ri_RelationDesc, NULL);
     return buffer->slots[nused];
 }

◆ CopyMultiInsertInfoSetupBuffer()

static void CopyMultiInsertInfoSetupBuffer	(	CopyMultiInsertInfo *	miinfo,
		ResultRelInfo *	rri
	)

inlinestatic

Definition at line 2356 of file copy.c.

References CopyMultiInsertBufferInit(), lappend(), CopyMultiInsertInfo::multiInsertBuffers, and ResultRelInfo::ri_CopyMultiInsertBuffer.

Referenced by CopyFrom(), and CopyMultiInsertInfoInit().

 {
     CopyMultiInsertBuffer *buffer;
 
     buffer = CopyMultiInsertBufferInit(rri);
 
     /* Setup back-link so we can easily find this buffer again */
     rri->ri_CopyMultiInsertBuffer = buffer;
     /* Record that we're tracking this buffer */
     miinfo->multiInsertBuffers = lappend(miinfo->multiInsertBuffers, buffer);
 }

◆ CopyMultiInsertInfoStore()

static void CopyMultiInsertInfoStore	(	CopyMultiInsertInfo *	miinfo,
		ResultRelInfo *	rri,
		TupleTableSlot *	slot,
		int	tuplen,
		uint64	lineno
	)

inlinestatic

Definition at line 2625 of file copy.c.

References Assert, CopyMultiInsertInfo::bufferedBytes, CopyMultiInsertInfo::bufferedTuples, CopyMultiInsertBuffer::linenos, CopyMultiInsertBuffer::nused, ResultRelInfo::ri_CopyMultiInsertBuffer, and CopyMultiInsertBuffer::slots.

Referenced by CopyFrom().

 {
     CopyMultiInsertBuffer *buffer = rri->ri_CopyMultiInsertBuffer;
 
     Assert(buffer != NULL);
     Assert(slot == buffer->slots[buffer->nused]);
 
     /* Store the line number so we can properly report any errors later */
     buffer->linenos[buffer->nused] = lineno;
 
     /* Record this slot as being used */
     buffer->nused++;
 
     /* Update how many tuples are stored and their size */
     miinfo->bufferedTuples++;
     miinfo->bufferedBytes += tuplen;
 }

◆ CopyOneRowTo()

static void CopyOneRowTo	(	CopyState	cstate,
		TupleTableSlot *	slot
	)

static

Definition at line 2155 of file copy.c.

References attnum, CopyStateData::attnumlist, CopyStateData::binary, CopyAttributeOutCSV(), CopyAttributeOutText(), CopySendChar(), CopySendData(), CopySendEndOfRow(), CopySendInt16(), CopySendInt32(), CopySendString(), CopyStateData::csv_mode, cur, CopyStateData::delim, CopyStateData::force_quote_flags, lfirst_int, list_length(), MemoryContextReset(), MemoryContextSwitchTo(), CopyStateData::null_print_client, CopyStateData::out_functions, OutputFunctionCall(), CopyStateData::rowcontext, SendFunctionCall(), slot_getallattrs(), TupleTableSlot::tts_isnull, TupleTableSlot::tts_values, value, VARDATA, VARHDRSZ, and VARSIZE.

Referenced by copy_dest_receive(), and CopyTo().

 {
     bool        need_delim = false;
     FmgrInfo   *out_functions = cstate->out_functions;
     MemoryContext oldcontext;
     ListCell   *cur;
     char       *string;
 
     MemoryContextReset(cstate->rowcontext);
     oldcontext = MemoryContextSwitchTo(cstate->rowcontext);
 
     if (cstate->binary)
     {
         /* Binary per-tuple header */
         CopySendInt16(cstate, list_length(cstate->attnumlist));
     }
 
     /* Make sure the tuple is fully deconstructed */
     slot_getallattrs(slot);
 
     foreach(cur, cstate->attnumlist)
     {
         int         attnum = lfirst_int(cur);
         Datum       value = slot->tts_values[attnum - 1];
         bool        isnull = slot->tts_isnull[attnum - 1];
 
         if (!cstate->binary)
         {
             if (need_delim)
                 CopySendChar(cstate, cstate->delim[0]);
             need_delim = true;
         }
 
         if (isnull)
         {
             if (!cstate->binary)
                 CopySendString(cstate, cstate->null_print_client);
             else
                 CopySendInt32(cstate, -1);
         }
         else
         {
             if (!cstate->binary)
             {
                 string = OutputFunctionCall(&out_functions[attnum - 1],
                                             value);
                 if (cstate->csv_mode)
                     CopyAttributeOutCSV(cstate, string,
                                         cstate->force_quote_flags[attnum - 1],
                                         list_length(cstate->attnumlist) == 1);
                 else
                     CopyAttributeOutText(cstate, string);
             }
             else
             {
                 bytea      *outputbytes;
 
                 outputbytes = SendFunctionCall(&out_functions[attnum - 1],
                                                value);
                 CopySendInt32(cstate, VARSIZE(outputbytes) - VARHDRSZ);
                 CopySendData(cstate, VARDATA(outputbytes),
                              VARSIZE(outputbytes) - VARHDRSZ);
             }
         }
     }
 
     CopySendEndOfRow(cstate);
 
     MemoryContextSwitchTo(oldcontext);
 }

◆ CopyReadAttributesCSV()

static int CopyReadAttributesCSV ( CopyState cstate )

static

Definition at line 4540 of file copy.c.

References Assert, CopyStateData::attribute_buf, StringInfoData::data, CopyStateData::delim, enlargeStringInfo(), ereport, errcode(), errmsg(), ERROR, CopyStateData::escape, StringInfoData::len, CopyStateData::line_buf, CopyStateData::max_fields, StringInfoData::maxlen, CopyStateData::null_print, CopyStateData::null_print_len, CopyStateData::quote, CopyStateData::raw_fields, repalloc(), and resetStringInfo().

Referenced by NextCopyFromRawFields().

 {
     char        delimc = cstate->delim[0];
     char        quotec = cstate->quote[0];
     char        escapec = cstate->escape[0];
     int         fieldno;
     char       *output_ptr;
     char       *cur_ptr;
     char       *line_end_ptr;
 
     /*
      * We need a special case for zero-column tables: check that the input
      * line is empty, and return.
      */
     if (cstate->max_fields <= 0)
     {
         if (cstate->line_buf.len != 0)
             ereport(ERROR,
                     (errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
                      errmsg("extra data after last expected column")));
         return 0;
     }
 
     resetStringInfo(&cstate->attribute_buf);
 
     /*
      * The de-escaped attributes will certainly not be longer than the input
      * data line, so we can just force attribute_buf to be large enough and
      * then transfer data without any checks for enough space.  We need to do
      * it this way because enlarging attribute_buf mid-stream would invalidate
      * pointers already stored into cstate->raw_fields[].
      */
     if (cstate->attribute_buf.maxlen <= cstate->line_buf.len)
         enlargeStringInfo(&cstate->attribute_buf, cstate->line_buf.len);
     output_ptr = cstate->attribute_buf.data;
 
     /* set pointer variables for loop */
     cur_ptr = cstate->line_buf.data;
     line_end_ptr = cstate->line_buf.data + cstate->line_buf.len;
 
     /* Outer loop iterates over fields */
     fieldno = 0;
     for (;;)
     {
         bool        found_delim = false;
         bool        saw_quote = false;
         char       *start_ptr;
         char       *end_ptr;
         int         input_len;
 
         /* Make sure there is enough space for the next value */
         if (fieldno >= cstate->max_fields)
         {
             cstate->max_fields *= 2;
             cstate->raw_fields =
                 repalloc(cstate->raw_fields, cstate->max_fields * sizeof(char *));
         }
 
         /* Remember start of field on both input and output sides */
         start_ptr = cur_ptr;
         cstate->raw_fields[fieldno] = output_ptr;
 
         /*
          * Scan data for field,
          *
          * The loop starts in "not quote" mode and then toggles between that
          * and "in quote" mode. The loop exits normally if it is in "not
          * quote" mode and a delimiter or line end is seen.
          */
         for (;;)
         {
             char        c;
 
             /* Not in quote */
             for (;;)
             {
                 end_ptr = cur_ptr;
                 if (cur_ptr >= line_end_ptr)
                     goto endfield;
                 c = *cur_ptr++;
                 /* unquoted field delimiter */
                 if (c == delimc)
                 {
                     found_delim = true;
                     goto endfield;
                 }
                 /* start of quoted field (or part of field) */
                 if (c == quotec)
                 {
                     saw_quote = true;
                     break;
                 }
                 /* Add c to output string */
                 *output_ptr++ = c;
             }
 
             /* In quote */
             for (;;)
             {
                 end_ptr = cur_ptr;
                 if (cur_ptr >= line_end_ptr)
                     ereport(ERROR,
                             (errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
                              errmsg("unterminated CSV quoted field")));
 
                 c = *cur_ptr++;
 
                 /* escape within a quoted field */
                 if (c == escapec)
                 {
                     /*
                      * peek at the next char if available, and escape it if it
                      * is an escape char or a quote char
                      */
                     if (cur_ptr < line_end_ptr)
                     {
                         char        nextc = *cur_ptr;
 
                         if (nextc == escapec || nextc == quotec)
                         {
                             *output_ptr++ = nextc;
                             cur_ptr++;
                             continue;
                         }
                     }
                 }
 
                 /*
                  * end of quoted field. Must do this test after testing for
                  * escape in case quote char and escape char are the same
                  * (which is the common case).
                  */
                 if (c == quotec)
                     break;
 
                 /* Add c to output string */
                 *output_ptr++ = c;
             }
         }
 endfield:
 
         /* Terminate attribute value in output area */
         *output_ptr++ = '\0';
 
         /* Check whether raw input matched null marker */
         input_len = end_ptr - start_ptr;
         if (!saw_quote && input_len == cstate->null_print_len &&
             strncmp(start_ptr, cstate->null_print, input_len) == 0)
             cstate->raw_fields[fieldno] = NULL;
 
         fieldno++;
         /* Done if we hit EOL instead of a delim */
         if (!found_delim)
             break;
     }
 
     /* Clean up state of attribute_buf */
     output_ptr--;
     Assert(*output_ptr == '\0');
     cstate->attribute_buf.len = (output_ptr - cstate->attribute_buf.data);
 
     return fieldno;
 }

◆ CopyReadAttributesText()

static int CopyReadAttributesText ( CopyState cstate )

static

Definition at line 4312 of file copy.c.

References Assert, CopyStateData::attribute_buf, StringInfoData::data, CopyStateData::delim, enlargeStringInfo(), ereport, errcode(), errmsg(), ERROR, GetDecimalFromHex(), IS_HIGHBIT_SET, ISOCTAL, StringInfoData::len, CopyStateData::line_buf, CopyStateData::max_fields, StringInfoData::maxlen, CopyStateData::null_print, CopyStateData::null_print_len, OCTVALUE, pg_verifymbstr(), CopyStateData::raw_fields, repalloc(), resetStringInfo(), and val.

Referenced by NextCopyFromRawFields().

 {
     char        delimc = cstate->delim[0];
     int         fieldno;
     char       *output_ptr;
     char       *cur_ptr;
     char       *line_end_ptr;
 
     /*
      * We need a special case for zero-column tables: check that the input
      * line is empty, and return.
      */
     if (cstate->max_fields <= 0)
     {
         if (cstate->line_buf.len != 0)
             ereport(ERROR,
                     (errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
                      errmsg("extra data after last expected column")));
         return 0;
     }
 
     resetStringInfo(&cstate->attribute_buf);
 
     /*
      * The de-escaped attributes will certainly not be longer than the input
      * data line, so we can just force attribute_buf to be large enough and
      * then transfer data without any checks for enough space.  We need to do
      * it this way because enlarging attribute_buf mid-stream would invalidate
      * pointers already stored into cstate->raw_fields[].
      */
     if (cstate->attribute_buf.maxlen <= cstate->line_buf.len)
         enlargeStringInfo(&cstate->attribute_buf, cstate->line_buf.len);
     output_ptr = cstate->attribute_buf.data;
 
     /* set pointer variables for loop */
     cur_ptr = cstate->line_buf.data;
     line_end_ptr = cstate->line_buf.data + cstate->line_buf.len;
 
     /* Outer loop iterates over fields */
     fieldno = 0;
     for (;;)
     {
         bool        found_delim = false;
         char       *start_ptr;
         char       *end_ptr;
         int         input_len;
         bool        saw_non_ascii = false;
 
         /* Make sure there is enough space for the next value */
         if (fieldno >= cstate->max_fields)
         {
             cstate->max_fields *= 2;
             cstate->raw_fields =
                 repalloc(cstate->raw_fields, cstate->max_fields * sizeof(char *));
         }
 
         /* Remember start of field on both input and output sides */
         start_ptr = cur_ptr;
         cstate->raw_fields[fieldno] = output_ptr;
 
         /*
          * Scan data for field.
          *
          * Note that in this loop, we are scanning to locate the end of field
          * and also speculatively performing de-escaping.  Once we find the
          * end-of-field, we can match the raw field contents against the null
          * marker string.  Only after that comparison fails do we know that
          * de-escaping is actually the right thing to do; therefore we *must
          * not* throw any syntax errors before we've done the null-marker
          * check.
          */
         for (;;)
         {
             char        c;
 
             end_ptr = cur_ptr;
             if (cur_ptr >= line_end_ptr)
                 break;
             c = *cur_ptr++;
             if (c == delimc)
             {
                 found_delim = true;
                 break;
             }
             if (c == '\\')
             {
                 if (cur_ptr >= line_end_ptr)
                     break;
                 c = *cur_ptr++;
                 switch (c)
                 {
                     case '0':
                     case '1':
                     case '2':
                     case '3':
                     case '4':
                     case '5':
                     case '6':
                     case '7':
                         {
                             /* handle \013 */
                             int         val;
 
                             val = OCTVALUE(c);
                             if (cur_ptr < line_end_ptr)
                             {
                                 c = *cur_ptr;
                                 if (ISOCTAL(c))
                                 {
                                     cur_ptr++;
                                     val = (val << 3) + OCTVALUE(c);
                                     if (cur_ptr < line_end_ptr)
                                     {
                                         c = *cur_ptr;
                                         if (ISOCTAL(c))
                                         {
                                             cur_ptr++;
                                             val = (val << 3) + OCTVALUE(c);
                                         }
                                     }
                                 }
                             }
                             c = val & 0377;
                             if (c == '\0' || IS_HIGHBIT_SET(c))
                                 saw_non_ascii = true;
                         }
                         break;
                     case 'x':
                         /* Handle \x3F */
                         if (cur_ptr < line_end_ptr)
                         {
                             char        hexchar = *cur_ptr;
 
                             if (isxdigit((unsigned char) hexchar))
                             {
                                 int         val = GetDecimalFromHex(hexchar);
 
                                 cur_ptr++;
                                 if (cur_ptr < line_end_ptr)
                                 {
                                     hexchar = *cur_ptr;
                                     if (isxdigit((unsigned char) hexchar))
                                     {
                                         cur_ptr++;
                                         val = (val << 4) + GetDecimalFromHex(hexchar);
                                     }
                                 }
                                 c = val & 0xff;
                                 if (c == '\0' || IS_HIGHBIT_SET(c))
                                     saw_non_ascii = true;
                             }
                         }
                         break;
                     case 'b':
                         c = '\b';
                         break;
                     case 'f':
                         c = '\f';
                         break;
                     case 'n':
                         c = '\n';
                         break;
                     case 'r':
                         c = '\r';
                         break;
                     case 't':
                         c = '\t';
                         break;
                     case 'v':
                         c = '\v';
                         break;
 
                         /*
                          * in all other cases, take the char after '\'
                          * literally
                          */
                 }
             }
 
             /* Add c to output string */
             *output_ptr++ = c;
         }
 
         /* Check whether raw input matched null marker */
         input_len = end_ptr - start_ptr;
         if (input_len == cstate->null_print_len &&
             strncmp(start_ptr, cstate->null_print, input_len) == 0)
             cstate->raw_fields[fieldno] = NULL;
         else
         {
             /*
              * At this point we know the field is supposed to contain data.
              *
              * If we de-escaped any non-7-bit-ASCII chars, make sure the
              * resulting string is valid data for the db encoding.
              */
             if (saw_non_ascii)
             {
                 char       *fld = cstate->raw_fields[fieldno];
 
                 pg_verifymbstr(fld, output_ptr - fld, false);
             }
         }
 
         /* Terminate attribute value in output area */
         *output_ptr++ = '\0';
 
         fieldno++;
         /* Done if we hit EOL instead of a delim */
         if (!found_delim)
             break;
     }
 
     /* Clean up state of attribute_buf */
     output_ptr--;
     Assert(*output_ptr == '\0');
     cstate->attribute_buf.len = (output_ptr - cstate->attribute_buf.data);
 
     return fieldno;
 }

◆ CopyReadBinaryAttribute()

static Datum CopyReadBinaryAttribute	(	CopyState	cstate,
		FmgrInfo *	flinfo,
		Oid	typioparam,
		int32	typmod,
		bool *	isnull
	)

static

Definition at line 4709 of file copy.c.

References CopyStateData::attribute_buf, CopyGetData(), CopyGetInt32(), StringInfoData::cursor, StringInfoData::data, enlargeStringInfo(), ereport, errcode(), errmsg(), ERROR, StringInfoData::len, ReceiveFunctionCall(), and resetStringInfo().

Referenced by NextCopyFrom().

 {
     int32       fld_size;
     Datum       result;
 
     if (!CopyGetInt32(cstate, &fld_size))
         ereport(ERROR,
                 (errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
                  errmsg("unexpected EOF in COPY data")));
     if (fld_size == -1)
     {
         *isnull = true;
         return ReceiveFunctionCall(flinfo, NULL, typioparam, typmod);
     }
     if (fld_size < 0)
         ereport(ERROR,
                 (errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
                  errmsg("invalid field size")));
 
     /* reset attribute_buf to empty, and load raw data in it */
     resetStringInfo(&cstate->attribute_buf);
 
     enlargeStringInfo(&cstate->attribute_buf, fld_size);
     if (CopyGetData(cstate, cstate->attribute_buf.data,
                     fld_size, fld_size) != fld_size)
         ereport(ERROR,
                 (errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
                  errmsg("unexpected EOF in COPY data")));
 
     cstate->attribute_buf.len = fld_size;
     cstate->attribute_buf.data[fld_size] = '\0';
 
     /* Call the column type's binary input converter */
     result = ReceiveFunctionCall(flinfo, &cstate->attribute_buf,
                                  typioparam, typmod);
 
     /* Trouble if it didn't eat the whole buffer */
     if (cstate->attribute_buf.cursor != cstate->attribute_buf.len)
         ereport(ERROR,
                 (errcode(ERRCODE_INVALID_BINARY_REPRESENTATION),
                  errmsg("incorrect binary data format")));
 
     *isnull = false;
     return result;
 }

◆ CopyReadLine()

static bool CopyReadLine ( CopyState cstate )

static

Definition at line 3831 of file copy.c.

References appendBinaryStringInfo(), Assert, CopyStateData::copy_dest, COPY_NEW_FE, CopyLoadRawBuf(), CopyReadLineText(), StringInfoData::data, EOL_CR, EOL_CRNL, EOL_NL, CopyStateData::eol_type, EOL_UNKNOWN, CopyStateData::file_encoding, StringInfoData::len, CopyStateData::line_buf, CopyStateData::line_buf_converted, CopyStateData::line_buf_valid, CopyStateData::need_transcoding, pfree(), pg_any_to_server(), CopyStateData::raw_buf_index, CopyStateData::raw_buf_len, and resetStringInfo().

Referenced by NextCopyFromRawFields().

 {
     bool        result;
 
     resetStringInfo(&cstate->line_buf);
     cstate->line_buf_valid = true;
 
     /* Mark that encoding conversion hasn't occurred yet */
     cstate->line_buf_converted = false;
 
     /* Parse data and transfer into line_buf */
     result = CopyReadLineText(cstate);
 
     if (result)
     {
         /*
          * Reached EOF.  In protocol version 3, we should ignore anything
          * after \. up to the protocol end of copy data.  (XXX maybe better
          * not to treat \. as special?)
          */
         if (cstate->copy_dest == COPY_NEW_FE)
         {
             do
             {
                 cstate->raw_buf_index = cstate->raw_buf_len;
             } while (CopyLoadRawBuf(cstate));
         }
     }
     else
     {
         /*
          * If we didn't hit EOF, then we must have transferred the EOL marker
          * to line_buf along with the data.  Get rid of it.
          */
         switch (cstate->eol_type)
         {
             case EOL_NL:
                 Assert(cstate->line_buf.len >= 1);
                 Assert(cstate->line_buf.data[cstate->line_buf.len - 1] == '\n');
                 cstate->line_buf.len--;
                 cstate->line_buf.data[cstate->line_buf.len] = '\0';
                 break;
             case EOL_CR:
                 Assert(cstate->line_buf.len >= 1);
                 Assert(cstate->line_buf.data[cstate->line_buf.len - 1] == '\r');
                 cstate->line_buf.len--;
                 cstate->line_buf.data[cstate->line_buf.len] = '\0';
                 break;
             case EOL_CRNL:
                 Assert(cstate->line_buf.len >= 2);
                 Assert(cstate->line_buf.data[cstate->line_buf.len - 2] == '\r');
                 Assert(cstate->line_buf.data[cstate->line_buf.len - 1] == '\n');
                 cstate->line_buf.len -= 2;
                 cstate->line_buf.data[cstate->line_buf.len] = '\0';
                 break;
             case EOL_UNKNOWN:
                 /* shouldn't get here */
                 Assert(false);
                 break;
         }
     }
 
     /* Done reading the line.  Convert it to server encoding. */
     if (cstate->need_transcoding)
     {
         char       *cvt;
 
         cvt = pg_any_to_server(cstate->line_buf.data,
                                cstate->line_buf.len,
                                cstate->file_encoding);
         if (cvt != cstate->line_buf.data)
         {
             /* transfer converted data back to line_buf */
             resetStringInfo(&cstate->line_buf);
             appendBinaryStringInfo(&cstate->line_buf, cvt, strlen(cvt));
             pfree(cvt);
         }
     }
 
     /* Now it's safe to use the buffer in error messages */
     cstate->line_buf_converted = true;
 
     return result;
 }

◆ CopyReadLineText()

static bool CopyReadLineText ( CopyState cstate )

static

Definition at line 3920 of file copy.c.

References appendBinaryStringInfo(), CopyLoadRawBuf(), CopyStateData::csv_mode, CopyStateData::cur_lineno, CopyStateData::encoding_embeds_ascii, EOL_CR, EOL_CRNL, EOL_NL, CopyStateData::eol_type, EOL_UNKNOWN, ereport, errcode(), errhint(), errmsg(), ERROR, CopyStateData::escape, CopyStateData::file_encoding, IF_NEED_REFILL_AND_EOF_BREAK, IF_NEED_REFILL_AND_NOT_EOF_CONTINUE, IS_HIGHBIT_SET, CopyStateData::line_buf, NO_END_OF_COPY_GOTO, pg_encoding_mblen(), CopyStateData::quote, CopyStateData::raw_buf, CopyStateData::raw_buf_index, CopyStateData::raw_buf_len, and REFILL_LINEBUF.

Referenced by CopyReadLine().

 {
     char       *copy_raw_buf;
     int         raw_buf_ptr;
     int         copy_buf_len;
     bool        need_data = false;
     bool        hit_eof = false;
     bool        result = false;
     char        mblen_str[2];
 
     /* CSV variables */
     bool        first_char_in_line = true;
     bool        in_quote = false,
                 last_was_esc = false;
     char        quotec = '\0';
     char        escapec = '\0';
 
     if (cstate->csv_mode)
     {
         quotec = cstate->quote[0];
         escapec = cstate->escape[0];
         /* ignore special escape processing if it's the same as quotec */
         if (quotec == escapec)
             escapec = '\0';
     }
 
     mblen_str[1] = '\0';
 
     /*
      * The objective of this loop is to transfer the entire next input line
      * into line_buf.  Hence, we only care for detecting newlines (\r and/or
      * \n) and the end-of-copy marker (\.).
      *
      * In CSV mode, \r and \n inside a quoted field are just part of the data
      * value and are put in line_buf.  We keep just enough state to know if we
      * are currently in a quoted field or not.
      *
      * These four characters, and the CSV escape and quote characters, are
      * assumed the same in frontend and backend encodings.
      *
      * For speed, we try to move data from raw_buf to line_buf in chunks
      * rather than one character at a time.  raw_buf_ptr points to the next
      * character to examine; any characters from raw_buf_index to raw_buf_ptr
      * have been determined to be part of the line, but not yet transferred to
      * line_buf.
      *
      * For a little extra speed within the loop, we copy raw_buf and
      * raw_buf_len into local variables.
      */
     copy_raw_buf = cstate->raw_buf;
     raw_buf_ptr = cstate->raw_buf_index;
     copy_buf_len = cstate->raw_buf_len;
 
     for (;;)
     {
         int         prev_raw_ptr;
         char        c;
 
         /*
          * Load more data if needed.  Ideally we would just force four bytes
          * of read-ahead and avoid the many calls to
          * IF_NEED_REFILL_AND_NOT_EOF_CONTINUE(), but the COPY_OLD_FE protocol
          * does not allow us to read too far ahead or we might read into the
          * next data, so we read-ahead only as far we know we can.  One
          * optimization would be to read-ahead four byte here if
          * cstate->copy_dest != COPY_OLD_FE, but it hardly seems worth it,
          * considering the size of the buffer.
          */
         if (raw_buf_ptr >= copy_buf_len || need_data)
         {
             REFILL_LINEBUF;
 
             /*
              * Try to read some more data.  This will certainly reset
              * raw_buf_index to zero, and raw_buf_ptr must go with it.
              */
             if (!CopyLoadRawBuf(cstate))
                 hit_eof = true;
             raw_buf_ptr = 0;
             copy_buf_len = cstate->raw_buf_len;
 
             /*
              * If we are completely out of data, break out of the loop,
              * reporting EOF.
              */
             if (copy_buf_len <= 0)
             {
                 result = true;
                 break;
             }
             need_data = false;
         }
 
         /* OK to fetch a character */
         prev_raw_ptr = raw_buf_ptr;
         c = copy_raw_buf[raw_buf_ptr++];
 
         if (cstate->csv_mode)
         {
             /*
              * If character is '\\' or '\r', we may need to look ahead below.
              * Force fetch of the next character if we don't already have it.
              * We need to do this before changing CSV state, in case one of
              * these characters is also the quote or escape character.
              *
              * Note: old-protocol does not like forced prefetch, but it's OK
              * here since we cannot validly be at EOF.
              */
             if (c == '\\' || c == '\r')
             {
                 IF_NEED_REFILL_AND_NOT_EOF_CONTINUE(0);
             }
 
             /*
              * Dealing with quotes and escapes here is mildly tricky. If the
              * quote char is also the escape char, there's no problem - we
              * just use the char as a toggle. If they are different, we need
              * to ensure that we only take account of an escape inside a
              * quoted field and immediately preceding a quote char, and not
              * the second in an escape-escape sequence.
              */
             if (in_quote && c == escapec)
                 last_was_esc = !last_was_esc;
             if (c == quotec && !last_was_esc)
                 in_quote = !in_quote;
             if (c != escapec)
                 last_was_esc = false;
 
             /*
              * Updating the line count for embedded CR and/or LF chars is
              * necessarily a little fragile - this test is probably about the
              * best we can do.  (XXX it's arguable whether we should do this
              * at all --- is cur_lineno a physical or logical count?)
              */
             if (in_quote && c == (cstate->eol_type == EOL_NL ? '\n' : '\r'))
                 cstate->cur_lineno++;
         }
 
         /* Process \r */
         if (c == '\r' && (!cstate->csv_mode || !in_quote))
         {
             /* Check for \r\n on first line, _and_ handle \r\n. */
             if (cstate->eol_type == EOL_UNKNOWN ||
                 cstate->eol_type == EOL_CRNL)
             {
                 /*
                  * If need more data, go back to loop top to load it.
                  *
                  * Note that if we are at EOF, c will wind up as '\0' because
                  * of the guaranteed pad of raw_buf.
                  */
                 IF_NEED_REFILL_AND_NOT_EOF_CONTINUE(0);
 
                 /* get next char */
                 c = copy_raw_buf[raw_buf_ptr];
 
                 if (c == '\n')
                 {
                     raw_buf_ptr++;  /* eat newline */
                     cstate->eol_type = EOL_CRNL;    /* in case not set yet */
                 }
                 else
                 {
                     /* found \r, but no \n */
                     if (cstate->eol_type == EOL_CRNL)
                         ereport(ERROR,
                                 (errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
                                  !cstate->csv_mode ?
                                  errmsg("literal carriage return found in data") :
                                  errmsg("unquoted carriage return found in data"),
                                  !cstate->csv_mode ?
                                  errhint("Use \"\\r\" to represent carriage return.") :
                                  errhint("Use quoted CSV field to represent carriage return.")));
 
                     /*
                      * if we got here, it is the first line and we didn't find
                      * \n, so don't consume the peeked character
                      */
                     cstate->eol_type = EOL_CR;
                 }
             }
             else if (cstate->eol_type == EOL_NL)
                 ereport(ERROR,
                         (errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
                          !cstate->csv_mode ?
                          errmsg("literal carriage return found in data") :
                          errmsg("unquoted carriage return found in data"),
                          !cstate->csv_mode ?
                          errhint("Use \"\\r\" to represent carriage return.") :
                          errhint("Use quoted CSV field to represent carriage return.")));
             /* If reach here, we have found the line terminator */
             break;
         }
 
         /* Process \n */
         if (c == '\n' && (!cstate->csv_mode || !in_quote))
         {
             if (cstate->eol_type == EOL_CR || cstate->eol_type == EOL_CRNL)
                 ereport(ERROR,
                         (errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
                          !cstate->csv_mode ?
                          errmsg("literal newline found in data") :
                          errmsg("unquoted newline found in data"),
                          !cstate->csv_mode ?
                          errhint("Use \"\\n\" to represent newline.") :
                          errhint("Use quoted CSV field to represent newline.")));
             cstate->eol_type = EOL_NL;  /* in case not set yet */
             /* If reach here, we have found the line terminator */
             break;
         }
 
         /*
          * In CSV mode, we only recognize \. alone on a line.  This is because
          * \. is a valid CSV data value.
          */
         if (c == '\\' && (!cstate->csv_mode || first_char_in_line))
         {
             char        c2;
 
             IF_NEED_REFILL_AND_NOT_EOF_CONTINUE(0);
             IF_NEED_REFILL_AND_EOF_BREAK(0);
 
             /* -----
              * get next character
              * Note: we do not change c so if it isn't \., we can fall
              * through and continue processing for file encoding.
              * -----
              */
             c2 = copy_raw_buf[raw_buf_ptr];
 
             if (c2 == '.')
             {
                 raw_buf_ptr++;  /* consume the '.' */
 
                 /*
                  * Note: if we loop back for more data here, it does not
                  * matter that the CSV state change checks are re-executed; we
                  * will come back here with no important state changed.
                  */
                 if (cstate->eol_type == EOL_CRNL)
                 {
                     /* Get the next character */
                     IF_NEED_REFILL_AND_NOT_EOF_CONTINUE(0);
                     /* if hit_eof, c2 will become '\0' */
                     c2 = copy_raw_buf[raw_buf_ptr++];
 
                     if (c2 == '\n')
                     {
                         if (!cstate->csv_mode)
                             ereport(ERROR,
                                     (errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
                                      errmsg("end-of-copy marker does not match previous newline style")));
                         else
                             NO_END_OF_COPY_GOTO;
                     }
                     else if (c2 != '\r')
                     {
                         if (!cstate->csv_mode)
                             ereport(ERROR,
                                     (errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
                                      errmsg("end-of-copy marker corrupt")));
                         else
                             NO_END_OF_COPY_GOTO;
                     }
                 }
 
                 /* Get the next character */
                 IF_NEED_REFILL_AND_NOT_EOF_CONTINUE(0);
                 /* if hit_eof, c2 will become '\0' */
                 c2 = copy_raw_buf[raw_buf_ptr++];
 
                 if (c2 != '\r' && c2 != '\n')
                 {
                     if (!cstate->csv_mode)
                         ereport(ERROR,
                                 (errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
                                  errmsg("end-of-copy marker corrupt")));
                     else
                         NO_END_OF_COPY_GOTO;
                 }
 
                 if ((cstate->eol_type == EOL_NL && c2 != '\n') ||
                     (cstate->eol_type == EOL_CRNL && c2 != '\n') ||
                     (cstate->eol_type == EOL_CR && c2 != '\r'))
                 {
                     ereport(ERROR,
                             (errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
                              errmsg("end-of-copy marker does not match previous newline style")));
                 }
 
                 /*
                  * Transfer only the data before the \. into line_buf, then
                  * discard the data and the \. sequence.
                  */
                 if (prev_raw_ptr > cstate->raw_buf_index)
                     appendBinaryStringInfo(&cstate->line_buf,
                                            cstate->raw_buf + cstate->raw_buf_index,
                                            prev_raw_ptr - cstate->raw_buf_index);
                 cstate->raw_buf_index = raw_buf_ptr;
                 result = true;  /* report EOF */
                 break;
             }
             else if (!cstate->csv_mode)
 
                 /*
                  * If we are here, it means we found a backslash followed by
                  * something other than a period.  In non-CSV mode, anything
                  * after a backslash is special, so we skip over that second
                  * character too.  If we didn't do that \\. would be
                  * considered an eof-of copy, while in non-CSV mode it is a
                  * literal backslash followed by a period.  In CSV mode,
                  * backslashes are not special, so we want to process the
                  * character after the backslash just like a normal character,
                  * so we don't increment in those cases.
                  */
                 raw_buf_ptr++;
         }
 
         /*
          * This label is for CSV cases where \. appears at the start of a
          * line, but there is more text after it, meaning it was a data value.
          * We are more strict for \. in CSV mode because \. could be a data
          * value, while in non-CSV mode, \. cannot be a data value.
          */
 not_end_of_copy:
 
         /*
          * Process all bytes of a multi-byte character as a group.
          *
          * We only support multi-byte sequences where the first byte has the
          * high-bit set, so as an optimization we can avoid this block
          * entirely if it is not set.
          */
         if (cstate->encoding_embeds_ascii && IS_HIGHBIT_SET(c))
         {
             int         mblen;
 
             /*
              * It is enough to look at the first byte in all our encodings, to
              * get the length.  (GB18030 is a bit special, but still works for
              * our purposes; see comment in pg_gb18030_mblen())
              */
             mblen_str[0] = c;
             mblen = pg_encoding_mblen(cstate->file_encoding, mblen_str);
 
             IF_NEED_REFILL_AND_NOT_EOF_CONTINUE(mblen - 1);
             IF_NEED_REFILL_AND_EOF_BREAK(mblen - 1);
             raw_buf_ptr += mblen - 1;
         }
         first_char_in_line = false;
     }                           /* end of outer loop */
 
     /*
      * Transfer any still-uncopied data to line_buf.
      */
     REFILL_LINEBUF;
 
     return result;
 }

◆ CopySendChar()

static void CopySendChar	(	CopyState	cstate,
		char	c
	)

static

Definition at line 511 of file copy.c.

References appendStringInfoCharMacro, and CopyStateData::fe_msgbuf.

Referenced by CopyAttributeOutCSV(), CopyAttributeOutText(), CopyOneRowTo(), CopySendEndOfRow(), and CopyTo().

 {
     appendStringInfoCharMacro(cstate->fe_msgbuf, c);
 }

◆ CopySendData()

static void CopySendData	(	CopyState	cstate,
		const void *	databuf,
		int	datasize
	)

static

Definition at line 499 of file copy.c.

References appendBinaryStringInfo(), and CopyStateData::fe_msgbuf.

Referenced by CopyOneRowTo(), CopySendInt16(), CopySendInt32(), CopyTo(), and SendCopyEnd().

 {
     appendBinaryStringInfo(cstate->fe_msgbuf, databuf, datasize);
 }

◆ CopySendEndOfRow()

static void CopySendEndOfRow ( CopyState cstate )

static

Definition at line 517 of file copy.c.

References Assert, CopyStateData::binary, ClosePipeToProgram(), COPY_CALLBACK, CopyStateData::copy_dest, COPY_FILE, CopyStateData::copy_file, COPY_NEW_FE, COPY_OLD_FE, CopySendChar(), CopySendString(), StringInfoData::data, ereport, errcode(), errcode_for_file_access(), errmsg(), ERROR, FATAL, CopyStateData::fe_msgbuf, CopyStateData::is_program, StringInfoData::len, pq_putbytes(), pq_putmessage, and resetStringInfo().

Referenced by CopyOneRowTo(), CopyTo(), and SendCopyEnd().

 {
     StringInfo  fe_msgbuf = cstate->fe_msgbuf;
 
     switch (cstate->copy_dest)
     {
         case COPY_FILE:
             if (!cstate->binary)
             {
                 /* Default line termination depends on platform */
 #ifndef WIN32
                 CopySendChar(cstate, '\n');
 #else
                 CopySendString(cstate, "\r\n");
 #endif
             }
 
             if (fwrite(fe_msgbuf->data, fe_msgbuf->len, 1,
                        cstate->copy_file) != 1 ||
                 ferror(cstate->copy_file))
             {
                 if (cstate->is_program)
                 {
                     if (errno == EPIPE)
                     {
                         /*
                          * The pipe will be closed automatically on error at
                          * the end of transaction, but we might get a better
                          * error message from the subprocess' exit code than
                          * just "Broken Pipe"
                          */
                         ClosePipeToProgram(cstate);
 
                         /*
                          * If ClosePipeToProgram() didn't throw an error, the
                          * program terminated normally, but closed the pipe
                          * first. Restore errno, and throw an error.
                          */
                         errno = EPIPE;
                     }
                     ereport(ERROR,
                             (errcode_for_file_access(),
                              errmsg("could not write to COPY program: %m")));
                 }
                 else
                     ereport(ERROR,
                             (errcode_for_file_access(),
                              errmsg("could not write to COPY file: %m")));
             }
             break;
         case COPY_OLD_FE:
             /* The FE/BE protocol uses \n as newline for all platforms */
             if (!cstate->binary)
                 CopySendChar(cstate, '\n');
 
             if (pq_putbytes(fe_msgbuf->data, fe_msgbuf->len))
             {
                 /* no hope of recovering connection sync, so FATAL */
                 ereport(FATAL,
                         (errcode(ERRCODE_CONNECTION_FAILURE),
                          errmsg("connection lost during COPY to stdout")));
             }
             break;
         case COPY_NEW_FE:
<

Data Structures

Macros

Typedefs

Enumerations

Functions

Variables

Macro Definition Documentation

◆ DUMPSOFAR

◆ IF_NEED_REFILL_AND_EOF_BREAK

◆ IF_NEED_REFILL_AND_NOT_EOF_CONTINUE

◆ ISOCTAL

◆ MAX_BUFFERED_BYTES

◆ MAX_BUFFERED_TUPLES

◆ MAX_COPY_DATA_DISPLAY

◆ MAX_PARTITION_BUFFERS

◆ NO_END_OF_COPY_GOTO

◆ OCTVALUE

◆ RAW_BUF_SIZE

◆ REFILL_LINEBUF

Typedef Documentation

◆ CopyDest

◆ CopyInsertMethod

◆ CopyMultiInsertBuffer

◆ CopyMultiInsertInfo

◆ CopyStateData

◆ EolType

Enumeration Type Documentation

◆ CopyDest

◆ CopyInsertMethod

◆ EolType

Function Documentation

◆ BeginCopy()

◆ BeginCopyFrom()

◆ BeginCopyTo()

◆ ClosePipeToProgram()

◆ copy_dest_destroy()

◆ copy_dest_receive()

◆ copy_dest_shutdown()

◆ copy_dest_startup()

◆ CopyAttributeOutCSV()

◆ CopyAttributeOutText()

◆ CopyFrom()

◆ CopyFromErrorCallback()

◆ CopyGetAttnums()

◆ CopyGetData()

◆ CopyGetInt16()

◆ CopyGetInt32()

◆ CopyLoadRawBuf()

◆ CopyMultiInsertBufferCleanup()

◆ CopyMultiInsertBufferFlush()

◆ CopyMultiInsertBufferInit()

◆ CopyMultiInsertInfoCleanup()

◆ CopyMultiInsertInfoFlush()

◆ CopyMultiInsertInfoInit()

◆ CopyMultiInsertInfoIsEmpty()

◆ CopyMultiInsertInfoIsFull()

◆ CopyMultiInsertInfoNextFreeSlot()

◆ CopyMultiInsertInfoSetupBuffer()

◆ CopyMultiInsertInfoStore()

◆ CopyOneRowTo()

◆ CopyReadAttributesCSV()

◆ CopyReadAttributesText()

◆ CopyReadBinaryAttribute()

◆ CopyReadLine()

◆ CopyReadLineText()

◆ CopySendChar()

◆ CopySendData()

◆ CopySendEndOfRow()