mirror of
https://git.postgresql.org/git/postgresql.git
synced 2024-09-01 19:57:22 +02:00
If any error occurred while we were in the middle of reading a protocol message from the client, we could lose sync, and incorrectly try to interpret a part of another message as a new protocol message. That will usually lead to an "invalid frontend message" error that terminates the connection. However, this is a security issue because an attacker might be able to deliberately cause an error, inject a Query message in what's supposed to be just user data, and have the server execute it. We were quite careful to not have CHECK_FOR_INTERRUPTS() calls or other operations that could ereport(ERROR) in the middle of processing a message, but a query cancel interrupt or statement timeout could nevertheless cause it to happen. Also, the V2 fastpath and COPY handling were not so careful. It's very difficult to recover in the V2 COPY protocol, so we will just terminate the connection on error. In practice, that's what happened previously anyway, as we lost protocol sync. To fix, add a new variable in pqcomm.c, PqCommReadingMsg, that is set whenever we're in the middle of reading a message. When it's set, we cannot safely ERROR out and continue running, because we might've read only part of a message. PqCommReadingMsg acts somewhat similarly to critical sections in that if an error occurs while it's set, the error handler will force the connection to be terminated, as if the error was FATAL. It's not implemented by promoting ERROR to FATAL in elog.c, like ERROR is promoted to PANIC in critical sections, because we want to be able to use PG_TRY/CATCH to recover and regain protocol sync. pq_getmessage() takes advantage of that to prevent an OOM error from terminating the connection. To prevent unnecessary connection terminations, add a holdoff mechanism similar to HOLD/RESUME_INTERRUPTS() that can be used hold off query cancel interrupts, but still allow die interrupts. The rules on which interrupts are processed when are now a bit more complicated, so refactor ProcessInterrupts() and the calls to it in signal handlers so that the signal handlers always call it if ImmediateInterruptOK is set, and ProcessInterrupts() can decide to not do anything if the other conditions are not met. Reported by Emil Lenngren. Patch reviewed by Noah Misch and Andres Freund. Backpatch to all supported versions. Security: CVE-2015-0244
4446 lines
124 KiB
C
4446 lines
124 KiB
C
/*-------------------------------------------------------------------------
|
|
*
|
|
* copy.c
|
|
* Implements the COPY utility command
|
|
*
|
|
* Portions Copyright (c) 1996-2015, PostgreSQL Global Development Group
|
|
* Portions Copyright (c) 1994, Regents of the University of California
|
|
*
|
|
*
|
|
* IDENTIFICATION
|
|
* src/backend/commands/copy.c
|
|
*
|
|
*-------------------------------------------------------------------------
|
|
*/
|
|
#include "postgres.h"
|
|
|
|
#include <ctype.h>
|
|
#include <unistd.h>
|
|
#include <sys/stat.h>
|
|
#include <netinet/in.h>
|
|
#include <arpa/inet.h>
|
|
|
|
#include "access/heapam.h"
|
|
#include "access/htup_details.h"
|
|
#include "access/sysattr.h"
|
|
#include "access/xact.h"
|
|
#include "access/xlog.h"
|
|
#include "catalog/namespace.h"
|
|
#include "catalog/pg_type.h"
|
|
#include "commands/copy.h"
|
|
#include "commands/defrem.h"
|
|
#include "commands/trigger.h"
|
|
#include "executor/executor.h"
|
|
#include "libpq/libpq.h"
|
|
#include "libpq/pqformat.h"
|
|
#include "mb/pg_wchar.h"
|
|
#include "miscadmin.h"
|
|
#include "optimizer/clauses.h"
|
|
#include "optimizer/planner.h"
|
|
#include "parser/parse_relation.h"
|
|
#include "nodes/makefuncs.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/portal.h"
|
|
#include "utils/rel.h"
|
|
#include "utils/rls.h"
|
|
#include "utils/snapmgr.h"
|
|
|
|
|
|
#define ISOCTAL(c) (((c) >= '0') && ((c) <= '7'))
|
|
#define OCTVALUE(c) ((c) - '0')
|
|
|
|
/*
|
|
* Represents the different source/dest cases we need to worry about at
|
|
* the bottom level
|
|
*/
|
|
typedef enum CopyDest
|
|
{
|
|
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) */
|
|
} CopyDest;
|
|
|
|
/*
|
|
* Represents the end-of-line terminator type of the input
|
|
*/
|
|
typedef enum EolType
|
|
{
|
|
EOL_UNKNOWN,
|
|
EOL_NL,
|
|
EOL_CR,
|
|
EOL_CRNL
|
|
} EolType;
|
|
|
|
/*
|
|
* This struct contains all the state variables used throughout a COPY
|
|
* operation. For simplicity, we use the same struct for all variants of COPY,
|
|
* even though some fields are used in only some cases.
|
|
*
|
|
* Multi-byte encodings: all supported client-side encodings encode multi-byte
|
|
* characters by having the first byte's high bit set. Subsequent bytes of the
|
|
* character can have the high bit not set. When scanning data in such an
|
|
* encoding to look for a match to a single-byte (ie ASCII) character, we must
|
|
* use the full pg_encoding_mblen() machinery to skip over multibyte
|
|
* characters, else we might find a false match to a trailing byte. In
|
|
* supported server encodings, there is no possibility of a false match, and
|
|
* it's faster to make useless comparisons to trailing bytes than it is to
|
|
* invoke pg_encoding_mblen() to skip over them. encoding_embeds_ascii is TRUE
|
|
* when we have to do it the hard way.
|
|
*/
|
|
typedef struct CopyStateData
|
|
{
|
|
/* low-level state data */
|
|
CopyDest copy_dest; /* type of copy source/destination */
|
|
FILE *copy_file; /* used if copy_dest == COPY_FILE */
|
|
StringInfo fe_msgbuf; /* used for all dests during COPY TO, only for
|
|
* dest == COPY_NEW_FE in COPY FROM */
|
|
bool fe_eof; /* true if detected end of copy data */
|
|
EolType eol_type; /* EOL type of input */
|
|
int file_encoding; /* file or remote side's character encoding */
|
|
bool need_transcoding; /* file encoding diff from server? */
|
|
bool encoding_embeds_ascii; /* ASCII can be non-first byte? */
|
|
|
|
/* parameters from the COPY command */
|
|
Relation rel; /* relation to copy to or from */
|
|
QueryDesc *queryDesc; /* executable query to copy from */
|
|
List *attnumlist; /* integer list of attnums to copy */
|
|
char *filename; /* filename, or NULL for STDIN/STDOUT */
|
|
bool is_program; /* is 'filename' a program to popen? */
|
|
bool binary; /* binary format? */
|
|
bool oids; /* include OIDs? */
|
|
bool freeze; /* freeze rows on loading? */
|
|
bool csv_mode; /* Comma Separated Value format? */
|
|
bool header_line; /* CSV header line? */
|
|
char *null_print; /* NULL marker string (server encoding!) */
|
|
int null_print_len; /* length of same */
|
|
char *null_print_client; /* same converted to file encoding */
|
|
char *delim; /* column delimiter (must be 1 byte) */
|
|
char *quote; /* CSV quote char (must be 1 byte) */
|
|
char *escape; /* CSV escape char (must be 1 byte) */
|
|
List *force_quote; /* list of column names */
|
|
bool force_quote_all; /* FORCE QUOTE *? */
|
|
bool *force_quote_flags; /* per-column CSV FQ flags */
|
|
List *force_notnull; /* list of column names */
|
|
bool *force_notnull_flags; /* per-column CSV FNN flags */
|
|
List *force_null; /* list of column names */
|
|
bool *force_null_flags; /* per-column CSV FN flags */
|
|
bool convert_selectively; /* do selective binary conversion? */
|
|
List *convert_select; /* list of column names (can be NIL) */
|
|
bool *convert_select_flags; /* per-column CSV/TEXT CS flags */
|
|
|
|
/* these are just for error messages, see CopyFromErrorCallback */
|
|
const char *cur_relname; /* table name for error messages */
|
|
int cur_lineno; /* line number for error messages */
|
|
const char *cur_attname; /* current att for error messages */
|
|
const char *cur_attval; /* current att value for error messages */
|
|
|
|
/*
|
|
* Working state for COPY TO/FROM
|
|
*/
|
|
MemoryContext copycontext; /* per-copy execution context */
|
|
|
|
/*
|
|
* Working state for COPY TO
|
|
*/
|
|
FmgrInfo *out_functions; /* lookup info for output functions */
|
|
MemoryContext rowcontext; /* per-row evaluation context */
|
|
|
|
/*
|
|
* Working state for COPY FROM
|
|
*/
|
|
AttrNumber num_defaults;
|
|
bool file_has_oids;
|
|
FmgrInfo oid_in_function;
|
|
Oid oid_typioparam;
|
|
FmgrInfo *in_functions; /* array of input functions for each attrs */
|
|
Oid *typioparams; /* array of element types for in_functions */
|
|
int *defmap; /* array of default att numbers */
|
|
ExprState **defexprs; /* array of default att expressions */
|
|
bool volatile_defexprs; /* is any of defexprs volatile? */
|
|
List *range_table;
|
|
|
|
/*
|
|
* These variables are used to reduce overhead in textual COPY FROM.
|
|
*
|
|
* attribute_buf holds the separated, de-escaped text for each field of
|
|
* the current line. The CopyReadAttributes functions return arrays of
|
|
* pointers into this buffer. We avoid palloc/pfree overhead by re-using
|
|
* the buffer on each cycle.
|
|
*/
|
|
StringInfoData attribute_buf;
|
|
|
|
/* field raw data pointers found by COPY FROM */
|
|
|
|
int max_fields;
|
|
char **raw_fields;
|
|
|
|
/*
|
|
* Similarly, line_buf holds the whole input line being processed. The
|
|
* input cycle is first to read the whole line into line_buf, convert it
|
|
* to server encoding there, and then extract the individual attribute
|
|
* fields into attribute_buf. line_buf is preserved unmodified so that we
|
|
* can display it in error messages if appropriate.
|
|
*/
|
|
StringInfoData line_buf;
|
|
bool line_buf_converted; /* converted to server encoding? */
|
|
bool line_buf_valid; /* contains the row being processed? */
|
|
|
|
/*
|
|
* Finally, raw_buf holds raw data read from the data source (file or
|
|
* client connection). CopyReadLine parses this data sufficiently to
|
|
* locate line boundaries, then transfers the data to line_buf and
|
|
* converts it. Note: we guarantee that there is a \0 at
|
|
* raw_buf[raw_buf_len].
|
|
*/
|
|
#define RAW_BUF_SIZE 65536 /* we palloc RAW_BUF_SIZE+1 bytes */
|
|
char *raw_buf;
|
|
int raw_buf_index; /* next byte to process */
|
|
int raw_buf_len; /* total # of bytes stored */
|
|
} CopyStateData;
|
|
|
|
/* DestReceiver for COPY (SELECT) TO */
|
|
typedef struct
|
|
{
|
|
DestReceiver pub; /* publicly-known function pointers */
|
|
CopyState cstate; /* CopyStateData for the command */
|
|
uint64 processed; /* # of tuples processed */
|
|
} DR_copy;
|
|
|
|
|
|
/*
|
|
* These macros centralize code used to process line_buf and raw_buf buffers.
|
|
* They are macros because they often do continue/break control and to avoid
|
|
* function call overhead in tight COPY loops.
|
|
*
|
|
* We must use "if (1)" because the usual "do {...} while(0)" wrapper would
|
|
* prevent the continue/break processing from working. We end the "if (1)"
|
|
* with "else ((void) 0)" to ensure the "if" does not unintentionally match
|
|
* any "else" in the calling code, and to avoid any compiler warnings about
|
|
* empty statements. See http://www.cit.gu.edu.au/~anthony/info/C/C.macros.
|
|
*/
|
|
|
|
/*
|
|
* This keeps the character read at the top of the loop in the buffer
|
|
* even if there is more than one read-ahead.
|
|
*/
|
|
#define IF_NEED_REFILL_AND_NOT_EOF_CONTINUE(extralen) \
|
|
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)
|
|
|
|
/* This consumes the remainder of the buffer and breaks */
|
|
#define IF_NEED_REFILL_AND_EOF_BREAK(extralen) \
|
|
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)
|
|
|
|
/*
|
|
* Transfer any approved data to line_buf; must do this to be sure
|
|
* there is some room in raw_buf.
|
|
*/
|
|
#define REFILL_LINEBUF \
|
|
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)
|
|
|
|
/* Undo any read-ahead and jump out of the block. */
|
|
#define NO_END_OF_COPY_GOTO \
|
|
if (1) \
|
|
{ \
|
|
raw_buf_ptr = prev_raw_ptr + 1; \
|
|
goto not_end_of_copy; \
|
|
} else ((void) 0)
|
|
|
|
static const char BinarySignature[11] = "PGCOPY\n\377\r\n\0";
|
|
|
|
|
|
/* non-export function prototypes */
|
|
static CopyState BeginCopy(bool is_from, Relation rel, Node *raw_query,
|
|
const char *queryString, const Oid queryRelId, List *attnamelist,
|
|
List *options);
|
|
static void EndCopy(CopyState cstate);
|
|
static void ClosePipeToProgram(CopyState cstate);
|
|
static CopyState BeginCopyTo(Relation rel, Node *query, const char *queryString,
|
|
const 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, Oid tupleOid,
|
|
Datum *values, bool *nulls);
|
|
static uint64 CopyFrom(CopyState cstate);
|
|
static void CopyFromInsertBatch(CopyState cstate, EState *estate,
|
|
CommandId mycid, int hi_options,
|
|
ResultRelInfo *resultRelInfo, TupleTableSlot *myslot,
|
|
BulkInsertState bistate,
|
|
int nBufferedTuples, HeapTuple *bufferedTuples,
|
|
int firstBufferedLineNo);
|
|
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,
|
|
int column_no, 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);
|
|
|
|
/* Low-level communications functions */
|
|
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);
|
|
|
|
|
|
/*
|
|
* Send copy start/stop messages for frontend copies. These have changed
|
|
* in past protocol redesigns.
|
|
*/
|
|
static void
|
|
SendCopyBegin(CopyState cstate)
|
|
{
|
|
if (PG_PROTOCOL_MAJOR(FrontendProtocol) >= 3)
|
|
{
|
|
/* new way */
|
|
StringInfoData buf;
|
|
int natts = list_length(cstate->attnumlist);
|
|
int16 format = (cstate->binary ? 1 : 0);
|
|
int i;
|
|
|
|
pq_beginmessage(&buf, 'H');
|
|
pq_sendbyte(&buf, format); /* overall format */
|
|
pq_sendint(&buf, natts, 2);
|
|
for (i = 0; i < natts; i++)
|
|
pq_sendint(&buf, format, 2); /* per-column formats */
|
|
pq_endmessage(&buf);
|
|
cstate->copy_dest = COPY_NEW_FE;
|
|
}
|
|
else if (PG_PROTOCOL_MAJOR(FrontendProtocol) >= 2)
|
|
{
|
|
/* old way */
|
|
if (cstate->binary)
|
|
ereport(ERROR,
|
|
(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
|
|
errmsg("COPY BINARY is not supported to stdout or from stdin")));
|
|
pq_putemptymessage('H');
|
|
/* grottiness needed for old COPY OUT protocol */
|
|
pq_startcopyout();
|
|
cstate->copy_dest = COPY_OLD_FE;
|
|
}
|
|
else
|
|
{
|
|
/* very old way */
|
|
if (cstate->binary)
|
|
ereport(ERROR,
|
|
(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
|
|
errmsg("COPY BINARY is not supported to stdout or from stdin")));
|
|
pq_putemptymessage('B');
|
|
/* grottiness needed for old COPY OUT protocol */
|
|
pq_startcopyout();
|
|
cstate->copy_dest = COPY_OLD_FE;
|
|
}
|
|
}
|
|
|
|
static void
|
|
ReceiveCopyBegin(CopyState cstate)
|
|
{
|
|
if (PG_PROTOCOL_MAJOR(FrontendProtocol) >= 3)
|
|
{
|
|
/* new way */
|
|
StringInfoData buf;
|
|
int natts = list_length(cstate->attnumlist);
|
|
int16 format = (cstate->binary ? 1 : 0);
|
|
int i;
|
|
|
|
pq_beginmessage(&buf, 'G');
|
|
pq_sendbyte(&buf, format); /* overall format */
|
|
pq_sendint(&buf, natts, 2);
|
|
for (i = 0; i < natts; i++)
|
|
pq_sendint(&buf, format, 2); /* per-column formats */
|
|
pq_endmessage(&buf);
|
|
cstate->copy_dest = COPY_NEW_FE;
|
|
cstate->fe_msgbuf = makeStringInfo();
|
|
}
|
|
else if (PG_PROTOCOL_MAJOR(FrontendProtocol) >= 2)
|
|
{
|
|
/* old way */
|
|
if (cstate->binary)
|
|
ereport(ERROR,
|
|
(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
|
|
errmsg("COPY BINARY is not supported to stdout or from stdin")));
|
|
pq_putemptymessage('G');
|
|
/* any error in old protocol will make us lose sync */
|
|
pq_startmsgread();
|
|
cstate->copy_dest = COPY_OLD_FE;
|
|
}
|
|
else
|
|
{
|
|
/* very old way */
|
|
if (cstate->binary)
|
|
ereport(ERROR,
|
|
(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
|
|
errmsg("COPY BINARY is not supported to stdout or from stdin")));
|
|
pq_putemptymessage('D');
|
|
/* any error in old protocol will make us lose sync */
|
|
pq_startmsgread();
|
|
cstate->copy_dest = COPY_OLD_FE;
|
|
}
|
|
/* We *must* flush here to ensure FE knows it can send. */
|
|
pq_flush();
|
|
}
|
|
|
|
static void
|
|
SendCopyEnd(CopyState cstate)
|
|
{
|
|
if (cstate->copy_dest == COPY_NEW_FE)
|
|
{
|
|
/* Shouldn't have any unsent data */
|
|
Assert(cstate->fe_msgbuf->len == 0);
|
|
/* Send Copy Done message */
|
|
pq_putemptymessage('c');
|
|
}
|
|
else
|
|
{
|
|
CopySendData(cstate, "\\.", 2);
|
|
/* Need to flush out the trailer (this also appends a newline) */
|
|
CopySendEndOfRow(cstate);
|
|
pq_endcopyout(false);
|
|
}
|
|
}
|
|
|
|
/*----------
|
|
* CopySendData sends output data to the destination (file or frontend)
|
|
* CopySendString does the same for null-terminated strings
|
|
* CopySendChar does the same for single characters
|
|
* CopySendEndOfRow does the appropriate thing at end of each data row
|
|
* (data is not actually flushed except by CopySendEndOfRow)
|
|
*
|
|
* NB: no data conversion is applied by these functions
|
|
*----------
|
|
*/
|
|
static void
|
|
CopySendData(CopyState cstate, const void *databuf, int datasize)
|
|
{
|
|
appendBinaryStringInfo(cstate->fe_msgbuf, databuf, datasize);
|
|
}
|
|
|
|
static void
|
|
CopySendString(CopyState cstate, const char *str)
|
|
{
|
|
appendBinaryStringInfo(cstate->fe_msgbuf, str, strlen(str));
|
|
}
|
|
|
|
static void
|
|
CopySendChar(CopyState cstate, char c)
|
|
{
|
|
appendStringInfoCharMacro(cstate->fe_msgbuf, c);
|
|
}
|
|
|
|
static void
|
|
CopySendEndOfRow(CopyState cstate)
|
|
{
|
|
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:
|
|
/* The FE/BE protocol uses \n as newline for all platforms */
|
|
if (!cstate->binary)
|
|
CopySendChar(cstate, '\n');
|
|
|
|
/* Dump the accumulated row as one CopyData message */
|
|
(void) pq_putmessage('d', fe_msgbuf->data, fe_msgbuf->len);
|
|
break;
|
|
}
|
|
|
|
resetStringInfo(fe_msgbuf);
|
|
}
|
|
|
|
/*
|
|
* CopyGetData reads data from the source (file or frontend)
|
|
*
|
|
* We attempt to read at least minread, and at most maxread, bytes from
|
|
* the source. The actual number of bytes read is returned; if this is
|
|
* less than minread, EOF was detected.
|
|
*
|
|
* Note: when copying from the frontend, we expect a proper EOF mark per
|
|
* protocol; if the frontend simply drops the connection, we raise error.
|
|
* It seems unwise to allow the COPY IN to complete normally in that case.
|
|
*
|
|
* NB: no data conversion is applied here.
|
|
*/
|
|
static int
|
|
CopyGetData(CopyState cstate, void *databuf, int minread, int maxread)
|
|
{
|
|
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")));
|
|
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->fe_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->fe_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;
|
|
}
|
|
|
|
return bytesread;
|
|
}
|
|
|
|
|
|
/*
|
|
* These functions do apply some data conversion
|
|
*/
|
|
|
|
/*
|
|
* CopySendInt32 sends an int32 in network byte order
|
|
*/
|
|
static void
|
|
CopySendInt32(CopyState cstate, int32 val)
|
|
{
|
|
uint32 buf;
|
|
|
|
buf = htonl((uint32) val);
|
|
CopySendData(cstate, &buf, sizeof(buf));
|
|
}
|
|
|
|
/*
|
|
* CopyGetInt32 reads an int32 that appears in network byte order
|
|
*
|
|
* Returns true if OK, false if EOF
|
|
*/
|
|
static bool
|
|
CopyGetInt32(CopyState cstate, int32 *val)
|
|
{
|
|
uint32 buf;
|
|
|
|
if (CopyGetData(cstate, &buf, sizeof(buf), sizeof(buf)) != sizeof(buf))
|
|
{
|
|
*val = 0; /* suppress compiler warning */
|
|
return false;
|
|
}
|
|
*val = (int32) ntohl(buf);
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
* CopySendInt16 sends an int16 in network byte order
|
|
*/
|
|
static void
|
|
CopySendInt16(CopyState cstate, int16 val)
|
|
{
|
|
uint16 buf;
|
|
|
|
buf = htons((uint16) val);
|
|
CopySendData(cstate, &buf, sizeof(buf));
|
|
}
|
|
|
|
/*
|
|
* CopyGetInt16 reads an int16 that appears in network byte order
|
|
*/
|
|
static bool
|
|
CopyGetInt16(CopyState cstate, int16 *val)
|
|
{
|
|
uint16 buf;
|
|
|
|
if (CopyGetData(cstate, &buf, sizeof(buf), sizeof(buf)) != sizeof(buf))
|
|
{
|
|
*val = 0; /* suppress compiler warning */
|
|
return false;
|
|
}
|
|
*val = (int16) ntohs(buf);
|
|
return true;
|
|
}
|
|
|
|
|
|
/*
|
|
* CopyLoadRawBuf loads some more data into raw_buf
|
|
*
|
|
* Returns TRUE if able to obtain at least one more byte, else FALSE.
|
|
*
|
|
* If raw_buf_index < raw_buf_len, the unprocessed bytes are transferred
|
|
* down to the start of the buffer and then we load more data after that.
|
|
* This case is used only when a frontend multibyte character crosses a
|
|
* bufferload boundary.
|
|
*/
|
|
static bool
|
|
CopyLoadRawBuf(CopyState cstate)
|
|
{
|
|
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);
|
|
}
|
|
|
|
|
|
/*
|
|
* DoCopy executes the SQL COPY statement
|
|
*
|
|
* Either unload or reload contents of table <relation>, depending on <from>.
|
|
* (<from> = TRUE means we are inserting into the table.) In the "TO" case
|
|
* we also support copying the output of an arbitrary SELECT query.
|
|
*
|
|
* If <pipe> is false, transfer is between the table and the file named
|
|
* <filename>. Otherwise, transfer is between the table and our regular
|
|
* input/output stream. The latter could be either stdin/stdout or a
|
|
* socket, depending on whether we're running under Postmaster control.
|
|
*
|
|
* Do not allow a Postgres user without superuser privilege to read from
|
|
* or write to a file.
|
|
*
|
|
* Do not allow the copy if user doesn't have proper permission to access
|
|
* the table or the specifically requested columns.
|
|
*/
|
|
Oid
|
|
DoCopy(const CopyStmt *stmt, const char *queryString, uint64 *processed)
|
|
{
|
|
CopyState cstate;
|
|
bool is_from = stmt->is_from;
|
|
bool pipe = (stmt->filename == NULL);
|
|
Relation rel;
|
|
Oid relid;
|
|
Node *query = NULL;
|
|
List *range_table = NIL;
|
|
|
|
/* Disallow COPY to/from file or program except to superusers. */
|
|
if (!pipe && !superuser())
|
|
{
|
|
if (stmt->is_program)
|
|
ereport(ERROR,
|
|
(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
|
|
errmsg("must be superuser to COPY to or from an external program"),
|
|
errhint("Anyone can COPY to stdout or from stdin. "
|
|
"psql's \\copy command also works for anyone.")));
|
|
else
|
|
ereport(ERROR,
|
|
(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
|
|
errmsg("must be superuser to COPY to or from a file"),
|
|
errhint("Anyone can COPY to stdout or from stdin. "
|
|
"psql's \\copy command also works for anyone.")));
|
|
}
|
|
|
|
if (stmt->relation)
|
|
{
|
|
TupleDesc tupDesc;
|
|
AclMode required_access = (is_from ? ACL_INSERT : ACL_SELECT);
|
|
List *attnums;
|
|
ListCell *cur;
|
|
RangeTblEntry *rte;
|
|
|
|
Assert(!stmt->query);
|
|
|
|
/* Open and lock the relation, using the appropriate lock type. */
|
|
rel = heap_openrv(stmt->relation,
|
|
(is_from ? RowExclusiveLock : AccessShareLock));
|
|
|
|
relid = RelationGetRelid(rel);
|
|
|
|
rte = makeNode(RangeTblEntry);
|
|
rte->rtekind = RTE_RELATION;
|
|
rte->relid = RelationGetRelid(rel);
|
|
rte->relkind = rel->rd_rel->relkind;
|
|
rte->requiredPerms = required_access;
|
|
range_table = list_make1(rte);
|
|
|
|
tupDesc = RelationGetDescr(rel);
|
|
attnums = CopyGetAttnums(tupDesc, rel, stmt->attlist);
|
|
foreach(cur, attnums)
|
|
{
|
|
int attno = lfirst_int(cur) -
|
|
FirstLowInvalidHeapAttributeNumber;
|
|
|
|
if (is_from)
|
|
rte->modifiedCols = bms_add_member(rte->modifiedCols, attno);
|
|
else
|
|
rte->selectedCols = bms_add_member(rte->selectedCols, attno);
|
|
}
|
|
ExecCheckRTPerms(range_table, true);
|
|
|
|
/*
|
|
* Permission check for row security policies.
|
|
*
|
|
* check_enable_rls will ereport(ERROR) if the user has requested
|
|
* something invalid and will otherwise indicate if we should enable
|
|
* RLS (returns RLS_ENABLED) or not for this COPY statement.
|
|
*
|
|
* If the relation has a row security policy and we are to apply it
|
|
* then perform a "query" copy and allow the normal query processing to
|
|
* handle the policies.
|
|
*
|
|
* If RLS is not enabled for this, then just fall through to the
|
|
* normal non-filtering relation handling.
|
|
*/
|
|
if (check_enable_rls(rte->relid, InvalidOid, false) == RLS_ENABLED)
|
|
{
|
|
SelectStmt *select;
|
|
ColumnRef *cr;
|
|
ResTarget *target;
|
|
RangeVar *from;
|
|
|
|
if (is_from)
|
|
ereport(ERROR,
|
|
(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
|
|
errmsg("COPY FROM not supported with row level security."),
|
|
errhint("Use direct INSERT statements instead.")));
|
|
|
|
/* Build target list */
|
|
cr = makeNode(ColumnRef);
|
|
|
|
if (!stmt->attlist)
|
|
cr->fields = list_make1(makeNode(A_Star));
|
|
else
|
|
cr->fields = stmt->attlist;
|
|
|
|
cr->location = 1;
|
|
|
|
target = makeNode(ResTarget);
|
|
target->name = NULL;
|
|
target->indirection = NIL;
|
|
target->val = (Node *) cr;
|
|
target->location = 1;
|
|
|
|
/* Build FROM clause */
|
|
from = stmt->relation;
|
|
|
|
/* Build query */
|
|
select = makeNode(SelectStmt);
|
|
select->targetList = list_make1(target);
|
|
select->fromClause = list_make1(from);
|
|
|
|
query = (Node*) select;
|
|
|
|
/* Close the handle to the relation as it is no longer needed. */
|
|
heap_close(rel, (is_from ? RowExclusiveLock : AccessShareLock));
|
|
rel = NULL;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Assert(stmt->query);
|
|
|
|
query = stmt->query;
|
|
relid = InvalidOid;
|
|
rel = NULL;
|
|
}
|
|
|
|
if (is_from)
|
|
{
|
|
Assert(rel);
|
|
|
|
/* check read-only transaction */
|
|
if (XactReadOnly && !rel->rd_islocaltemp)
|
|
PreventCommandIfReadOnly("COPY FROM");
|
|
|
|
cstate = BeginCopyFrom(rel, stmt->filename, stmt->is_program,
|
|
stmt->attlist, stmt->options);
|
|
cstate->range_table = range_table;
|
|
*processed = CopyFrom(cstate); /* copy from file to database */
|
|
EndCopyFrom(cstate);
|
|
}
|
|
else
|
|
{
|
|
cstate = BeginCopyTo(rel, query, queryString, relid,
|
|
stmt->filename, stmt->is_program,
|
|
stmt->attlist, stmt->options);
|
|
*processed = DoCopyTo(cstate); /* copy from database to file */
|
|
EndCopyTo(cstate);
|
|
}
|
|
|
|
/*
|
|
* Close the relation. If reading, we can release the AccessShareLock we
|
|
* got; if writing, we should hold the lock until end of transaction to
|
|
* ensure that updates will be committed before lock is released.
|
|
*/
|
|
if (rel != NULL)
|
|
heap_close(rel, (is_from ? NoLock : AccessShareLock));
|
|
|
|
return relid;
|
|
}
|
|
|
|
/*
|
|
* Process the statement option list for COPY.
|
|
*
|
|
* Scan the options list (a list of DefElem) and transpose the information
|
|
* into cstate, applying appropriate error checking.
|
|
*
|
|
* cstate is assumed to be filled with zeroes initially.
|
|
*
|
|
* This is exported so that external users of the COPY API can sanity-check
|
|
* a list of options. In that usage, cstate should be passed as NULL
|
|
* (since external users don't know sizeof(CopyStateData)) and the collected
|
|
* data is just leaked until CurrentMemoryContext is reset.
|
|
*
|
|
* Note that additional checking, such as whether column names listed in FORCE
|
|
* QUOTE actually exist, has to be applied later. This just checks for
|
|
* self-consistency of the options list.
|
|
*/
|
|
void
|
|
ProcessCopyOptions(CopyState cstate,
|
|
bool is_from,
|
|
List *options)
|
|
{
|
|
bool format_specified = false;
|
|
ListCell *option;
|
|
|
|
/* Support external use for option sanity checking */
|
|
if (cstate == NULL)
|
|
cstate = (CopyStateData *) palloc0(sizeof(CopyStateData));
|
|
|
|
cstate->file_encoding = -1;
|
|
|
|
/* Extract options from the statement node tree */
|
|
foreach(option, options)
|
|
{
|
|
DefElem *defel = (DefElem *) lfirst(option);
|
|
|
|
if (strcmp(defel->defname, "format") == 0)
|
|
{
|
|
char *fmt = defGetString(defel);
|
|
|
|
if (format_specified)
|
|
ereport(ERROR,
|
|
(errcode(ERRCODE_SYNTAX_ERROR),
|
|
errmsg("conflicting or redundant options")));
|
|
format_specified = true;
|
|
if (strcmp(fmt, "text") == 0)
|
|
/* default format */ ;
|
|
else if (strcmp(fmt, "csv") == 0)
|
|
cstate->csv_mode = true;
|
|
else if (strcmp(fmt, "binary") == 0)
|
|
cstate->binary = true;
|
|
else
|
|
ereport(ERROR,
|
|
(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
|
|
errmsg("COPY format \"%s\" not recognized", fmt)));
|
|
}
|
|
else if (strcmp(defel->defname, "oids") == 0)
|
|
{
|
|
if (cstate->oids)
|
|
ereport(ERROR,
|
|
(errcode(ERRCODE_SYNTAX_ERROR),
|
|
errmsg("conflicting or redundant options")));
|
|
cstate->oids = defGetBoolean(defel);
|
|
}
|
|
else if (strcmp(defel->defname, "freeze") == 0)
|
|
{
|
|
if (cstate->freeze)
|
|
ereport(ERROR,
|
|
(errcode(ERRCODE_SYNTAX_ERROR),
|
|
errmsg("conflicting or redundant options")));
|
|
cstate->freeze = defGetBoolean(defel);
|
|
}
|
|
else if (strcmp(defel->defname, "delimiter") == 0)
|
|
{
|
|
if (cstate->delim)
|
|
ereport(ERROR,
|
|
(errcode(ERRCODE_SYNTAX_ERROR),
|
|
errmsg("conflicting or redundant options")));
|
|
cstate->delim = defGetString(defel);
|
|
}
|
|
else if (strcmp(defel->defname, "null") == 0)
|
|
{
|
|
if (cstate->null_print)
|
|
ereport(ERROR,
|
|
(errcode(ERRCODE_SYNTAX_ERROR),
|
|
errmsg("conflicting or redundant options")));
|
|
cstate->null_print = defGetString(defel);
|
|
}
|
|
else if (strcmp(defel->defname, "header") == 0)
|
|
{
|
|
if (cstate->header_line)
|
|
ereport(ERROR,
|
|
(errcode(ERRCODE_SYNTAX_ERROR),
|
|
errmsg("conflicting or redundant options")));
|
|
cstate->header_line = defGetBoolean(defel);
|
|
}
|
|
else if (strcmp(defel->defname, "quote") == 0)
|
|
{
|
|
if (cstate->quote)
|
|
ereport(ERROR,
|
|
(errcode(ERRCODE_SYNTAX_ERROR),
|
|
errmsg("conflicting or redundant options")));
|
|
cstate->quote = defGetString(defel);
|
|
}
|
|
else if (strcmp(defel->defname, "escape") == 0)
|
|
{
|
|
if (cstate->escape)
|
|
ereport(ERROR,
|
|
(errcode(ERRCODE_SYNTAX_ERROR),
|
|
errmsg("conflicting or redundant options")));
|
|
cstate->escape = defGetString(defel);
|
|
}
|
|
else if (strcmp(defel->defname, "force_quote") == 0)
|
|
{
|
|
if (cstate->force_quote || cstate->force_quote_all)
|
|
ereport(ERROR,
|
|
(errcode(ERRCODE_SYNTAX_ERROR),
|
|
errmsg("conflicting or redundant options")));
|
|
if (defel->arg && IsA(defel->arg, A_Star))
|
|
cstate->force_quote_all = true;
|
|
else if (defel->arg && IsA(defel->arg, List))
|
|
cstate->force_quote = (List *) defel->arg;
|
|
else
|
|
ereport(ERROR,
|
|
(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
|
|
errmsg("argument to option \"%s\" must be a list of column names",
|
|
defel->defname)));
|
|
}
|
|
else if (strcmp(defel->defname, "force_not_null") == 0)
|
|
{
|
|
if (cstate->force_notnull)
|
|
ereport(ERROR,
|
|
(errcode(ERRCODE_SYNTAX_ERROR),
|
|
errmsg("conflicting or redundant options")));
|
|
if (defel->arg && IsA(defel->arg, List))
|
|
cstate->force_notnull = (List *) defel->arg;
|
|
else
|
|
ereport(ERROR,
|
|
(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
|
|
errmsg("argument to option \"%s\" must be a list of column names",
|
|
defel->defname)));
|
|
}
|
|
else if (strcmp(defel->defname, "force_null") == 0)
|
|
{
|
|
if (cstate->force_null)
|
|
ereport(ERROR,
|
|
(errcode(ERRCODE_SYNTAX_ERROR),
|
|
errmsg("conflicting or redundant options")));
|
|
if (defel->arg && IsA(defel->arg, List))
|
|
cstate->force_null = (List *) defel->arg;
|
|
else
|
|
ereport(ERROR,
|
|
(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
|
|
errmsg("argument to option \"%s\" must be a list of column names",
|
|
defel->defname)));
|
|
}
|
|
else if (strcmp(defel->defname, "convert_selectively") == 0)
|
|
{
|
|
/*
|
|
* Undocumented, not-accessible-from-SQL option: convert only the
|
|
* named columns to binary form, storing the rest as NULLs. It's
|
|
* allowed for the column list to be NIL.
|
|
*/
|
|
if (cstate->convert_selectively)
|
|
ereport(ERROR,
|
|
(errcode(ERRCODE_SYNTAX_ERROR),
|
|
errmsg("conflicting or redundant options")));
|
|
cstate->convert_selectively = true;
|
|
if (defel->arg == NULL || IsA(defel->arg, List))
|
|
cstate->convert_select = (List *) defel->arg;
|
|
else
|
|
ereport(ERROR,
|
|
(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
|
|
errmsg("argument to option \"%s\" must be a list of column names",
|
|
defel->defname)));
|
|
}
|
|
else if (strcmp(defel->defname, "encoding") == 0)
|
|
{
|
|
if (cstate->file_encoding >= 0)
|
|
ereport(ERROR,
|
|
(errcode(ERRCODE_SYNTAX_ERROR),
|
|
errmsg("conflicting or redundant options")));
|
|
cstate->file_encoding = pg_char_to_encoding(defGetString(defel));
|
|
if (cstate->file_encoding < 0)
|
|
ereport(ERROR,
|
|
(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
|
|
errmsg("argument to option \"%s\" must be a valid encoding name",
|
|
defel->defname)));
|
|
}
|
|
else
|
|
ereport(ERROR,
|
|
(errcode(ERRCODE_SYNTAX_ERROR),
|
|
errmsg("option \"%s\" not recognized",
|
|
defel->defname)));
|
|
}
|
|
|
|
/*
|
|
* Check for incompatible options (must do these two before inserting
|
|
* defaults)
|
|
*/
|
|
if (cstate->binary && cstate->delim)
|
|
ereport(ERROR,
|
|
(errcode(ERRCODE_SYNTAX_ERROR),
|
|
errmsg("cannot specify DELIMITER in BINARY mode")));
|
|
|
|
if (cstate->binary && cstate->null_print)
|
|
ereport(ERROR,
|
|
(errcode(ERRCODE_SYNTAX_ERROR),
|
|
errmsg("cannot specify NULL in BINARY mode")));
|
|
|
|
/* Set defaults for omitted options */
|
|
if (!cstate->delim)
|
|
cstate->delim = cstate->csv_mode ? "," : "\t";
|
|
|
|
if (!cstate->null_print)
|
|
cstate->null_print = cstate->csv_mode ? "" : "\\N";
|
|
cstate->null_print_len = strlen(cstate->null_print);
|
|
|
|
if (cstate->csv_mode)
|
|
{
|
|
if (!cstate->quote)
|
|
cstate->quote = "\"";
|
|
if (!cstate->escape)
|
|
cstate->escape = cstate->quote;
|
|
}
|
|
|
|
/* Only single-byte delimiter strings are supported. */
|
|
if (strlen(cstate->delim) != 1)
|
|
ereport(ERROR,
|
|
(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
|
|
errmsg("COPY delimiter must be a single one-byte character")));
|
|
|
|
/* Disallow end-of-line characters */
|
|
if (strchr(cstate->delim, '\r') != NULL ||
|
|
strchr(cstate->delim, '\n') != NULL)
|
|
ereport(ERROR,
|
|
(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
|
|
errmsg("COPY delimiter cannot be newline or carriage return")));
|
|
|
|
if (strchr(cstate->null_print, '\r') != NULL ||
|
|
strchr(cstate->null_print, '\n') != NULL)
|
|
ereport(ERROR,
|
|
(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
|
|
errmsg("COPY null representation cannot use newline or carriage return")));
|
|
|
|
/*
|
|
* Disallow unsafe delimiter characters in non-CSV mode. We can't allow
|
|
* backslash because it would be ambiguous. We can't allow the other
|
|
* cases because data characters matching the delimiter must be
|
|
* backslashed, and certain backslash combinations are interpreted
|
|
* non-literally by COPY IN. Disallowing all lower case ASCII letters is
|
|
* more than strictly necessary, but seems best for consistency and
|
|
* future-proofing. Likewise we disallow all digits though only octal
|
|
* digits are actually dangerous.
|
|
*/
|
|
if (!cstate->csv_mode &&
|
|
strchr("\\.abcdefghijklmnopqrstuvwxyz0123456789",
|
|
cstate->delim[0]) != NULL)
|
|
ereport(ERROR,
|
|
(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
|
|
errmsg("COPY delimiter cannot be \"%s\"", cstate->delim)));
|
|
|
|
/* Check header */
|
|
if (!cstate->csv_mode && cstate->header_line)
|
|
ereport(ERROR,
|
|
(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
|
|
errmsg("COPY HEADER available only in CSV mode")));
|
|
|
|
/* Check quote */
|
|
if (!cstate->csv_mode && cstate->quote != NULL)
|
|
ereport(ERROR,
|
|
(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
|
|
errmsg("COPY quote available only in CSV mode")));
|
|
|
|
if (cstate->csv_mode && strlen(cstate->quote) != 1)
|
|
ereport(ERROR,
|
|
(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
|
|
errmsg("COPY quote must be a single one-byte character")));
|
|
|
|
if (cstate->csv_mode && cstate->delim[0] == cstate->quote[0])
|
|
ereport(ERROR,
|
|
(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
|
|
errmsg("COPY delimiter and quote must be different")));
|
|
|
|
/* Check escape */
|
|
if (!cstate->csv_mode && cstate->escape != NULL)
|
|
ereport(ERROR,
|
|
(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
|
|
errmsg("COPY escape available only in CSV mode")));
|
|
|
|
if (cstate->csv_mode && strlen(cstate->escape) != 1)
|
|
ereport(ERROR,
|
|
(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
|
|
errmsg("COPY escape must be a single one-byte character")));
|
|
|
|
/* Check force_quote */
|
|
if (!cstate->csv_mode && (cstate->force_quote || cstate->force_quote_all))
|
|
ereport(ERROR,
|
|
(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
|
|
errmsg("COPY force quote available only in CSV mode")));
|
|
if ((cstate->force_quote || cstate->force_quote_all) && is_from)
|
|
ereport(ERROR,
|
|
(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
|
|
errmsg("COPY force quote only available using COPY TO")));
|
|
|
|
/* Check force_notnull */
|
|
if (!cstate->csv_mode && cstate->force_notnull != NIL)
|
|
ereport(ERROR,
|
|
(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
|
|
errmsg("COPY force not null available only in CSV mode")));
|
|
if (cstate->force_notnull != NIL && !is_from)
|
|
ereport(ERROR,
|
|
(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
|
|
errmsg("COPY force not null only available using COPY FROM")));
|
|
|
|
/* Check force_null */
|
|
if (!cstate->csv_mode && cstate->force_null != NIL)
|
|
ereport(ERROR,
|
|
(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
|
|
errmsg("COPY force null available only in CSV mode")));
|
|
|
|
if (cstate->force_null != NIL && !is_from)
|
|
ereport(ERROR,
|
|
(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
|
|
errmsg("COPY force null only available using COPY FROM")));
|
|
|
|
/* Don't allow the delimiter to appear in the null string. */
|
|
if (strchr(cstate->null_print, cstate->delim[0]) != NULL)
|
|
ereport(ERROR,
|
|
(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
|
|
errmsg("COPY delimiter must not appear in the NULL specification")));
|
|
|
|
/* Don't allow the CSV quote char to appear in the null string. */
|
|
if (cstate->csv_mode &&
|
|
strchr(cstate->null_print, cstate->quote[0]) != NULL)
|
|
ereport(ERROR,
|
|
(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
|
|
errmsg("CSV quote character must not appear in the NULL specification")));
|
|
}
|
|
|
|
/*
|
|
* Common setup routines used by BeginCopyFrom and BeginCopyTo.
|
|
*
|
|
* Iff <binary>, unload or reload in the binary format, as opposed to the
|
|
* more wasteful but more robust and portable text format.
|
|
*
|
|
* Iff <oids>, unload or reload the format that includes OID information.
|
|
* On input, we accept OIDs whether or not the table has an OID column,
|
|
* but silently drop them if it does not. On output, we report an error
|
|
* if the user asks for OIDs in a table that has none (not providing an
|
|
* OID column might seem friendlier, but could seriously confuse programs).
|
|
*
|
|
* If in the text format, delimit columns with delimiter <delim> and print
|
|
* NULL values as <null_print>.
|
|
*/
|
|
static CopyState
|
|
BeginCopy(bool is_from,
|
|
Relation rel,
|
|
Node *raw_query,
|
|
const char *queryString,
|
|
const Oid queryRelId,
|
|
List *attnamelist,
|
|
List *options)
|
|
{
|
|
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_MINSIZE,
|
|
ALLOCSET_DEFAULT_INITSIZE,
|
|
ALLOCSET_DEFAULT_MAXSIZE);
|
|
|
|
oldcontext = MemoryContextSwitchTo(cstate->copycontext);
|
|
|
|
/* Extract options from the statement node tree */
|
|
ProcessCopyOptions(cstate, is_from, options);
|
|
|
|
/* Process the source/target relation or query */
|
|
if (rel)
|
|
{
|
|
Assert(!raw_query);
|
|
|
|
cstate->rel = rel;
|
|
|
|
tupDesc = RelationGetDescr(cstate->rel);
|
|
|
|
/* Don't allow COPY w/ OIDs to or from a table without them */
|
|
if (cstate->oids && !cstate->rel->rd_rel->relhasoids)
|
|
ereport(ERROR,
|
|
(errcode(ERRCODE_UNDEFINED_COLUMN),
|
|
errmsg("table \"%s\" does not have OIDs",
|
|
RelationGetRelationName(cstate->rel))));
|
|
}
|
|
else
|
|
{
|
|
List *rewritten;
|
|
Query *query;
|
|
PlannedStmt *plan;
|
|
DestReceiver *dest;
|
|
|
|
Assert(!is_from);
|
|
cstate->rel = NULL;
|
|
|
|
/* Don't allow COPY w/ OIDs from a select */
|
|
if (cstate->oids)
|
|
ereport(ERROR,
|
|
(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
|
|
errmsg("COPY (SELECT) WITH OIDS is not supported")));
|
|
|
|
/*
|
|
* 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((Node *) copyObject(raw_query),
|
|
queryString, NULL, 0);
|
|
|
|
/* We don't expect more or less than one result query */
|
|
if (list_length(rewritten) != 1)
|
|
elog(ERROR, "unexpected rewrite result");
|
|
|
|
query = (Query *) linitial(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->commandType == CMD_SELECT);
|
|
Assert(query->utilityStmt == NULL);
|
|
|
|
/* plan the query */
|
|
plan = planner(query, 0, NULL);
|
|
|
|
/*
|
|
* If we were passed in a relid, make sure we got the same one back
|
|
* after planning out the query. It's possible that it changed between
|
|
* when we checked the policies on the table and decided to use a query
|
|
* and now.
|
|
*/
|
|
if (queryRelId != InvalidOid)
|
|
{
|
|
Oid relid = linitial_oid(plan->relationOids);
|
|
|
|
/*
|
|
* There should only be one relationOid in this case, since we will
|
|
* only get here when we have changed the command for the user from
|
|
* a "COPY relation TO" to "COPY (SELECT * FROM relation) TO", to
|
|
* allow row level security policies to be applied.
|
|
*/
|
|
Assert(list_length(plan->relationOids) == 1);
|
|
|
|
if (relid != 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, queryString,
|
|
GetActiveSnapshot(),
|
|
InvalidSnapshot,
|
|
dest, 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);
|
|
|
|
if (!list_member_int(cstate->attnumlist, attnum))
|
|
ereport(ERROR,
|
|
(errcode(ERRCODE_INVALID_COLUMN_REFERENCE),
|
|
errmsg("FORCE QUOTE column \"%s\" not referenced by COPY",
|
|
NameStr(tupDesc->attrs[attnum - 1]->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);
|
|
|
|
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(tupDesc->attrs[attnum - 1]->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);
|
|
|
|
if (!list_member_int(cstate->attnumlist, attnum))
|
|
ereport(ERROR,
|
|
(errcode(ERRCODE_INVALID_COLUMN_REFERENCE),
|
|
errmsg("FORCE NULL column \"%s\" not referenced by COPY",
|
|
NameStr(tupDesc->attrs[attnum - 1]->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);
|
|
|
|
if (!list_member_int(cstate->attnumlist, attnum))
|
|
ereport(ERROR,
|
|
(errcode(ERRCODE_INVALID_COLUMN_REFERENCE),
|
|
errmsg_internal("selected column \"%s\" not referenced by COPY",
|
|
NameStr(tupDesc->attrs[attnum - 1]->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;
|
|
}
|
|
|
|
/*
|
|
* Closes the pipe to an external program, checking the pclose() return code.
|
|
*/
|
|
static void
|
|
ClosePipeToProgram(CopyState cstate)
|
|
{
|
|
int pclose_rc;
|
|
|
|
Assert(cstate->is_program);
|
|
|
|
pclose_rc = ClosePipeStream(cstate->copy_file);
|
|
if (pclose_rc == -1)
|
|
ereport(ERROR,
|
|
(errmsg("could not close pipe to external command: %m")));
|
|
else if (pclose_rc != 0)
|
|
ereport(ERROR,
|
|
(errmsg("program \"%s\" failed",
|
|
cstate->filename),
|
|
errdetail_internal("%s", wait_result_to_str(pclose_rc))));
|
|
}
|
|
|
|
/*
|
|
* Release resources allocated in a cstate for COPY TO/FROM.
|
|
*/
|
|
static void
|
|
EndCopy(CopyState cstate)
|
|
{
|
|
if (cstate->is_program)
|
|
{
|
|
ClosePipeToProgram(cstate);
|
|
}
|
|
else
|
|
{
|
|
if (cstate->filename != NULL && FreeFile(cstate->copy_file))
|
|
ereport(ERROR,
|
|
(errcode_for_file_access(),
|
|
errmsg("could not close file \"%s\": %m",
|
|
cstate->filename)));
|
|
}
|
|
|
|
MemoryContextDelete(cstate->copycontext);
|
|
pfree(cstate);
|
|
}
|
|
|
|
/*
|
|
* Setup CopyState to read tuples from a table or a query for COPY TO.
|
|
*/
|
|
static CopyState
|
|
BeginCopyTo(Relation rel,
|
|
Node *query,
|
|
const char *queryString,
|
|
const Oid queryRelId,
|
|
const char *filename,
|
|
bool is_program,
|
|
List *attnamelist,
|
|
List *options)
|
|
{
|
|
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
|
|
ereport(ERROR,
|
|
(errcode(ERRCODE_WRONG_OBJECT_TYPE),
|
|
errmsg("cannot copy from non-table relation \"%s\"",
|
|
RelationGetRelationName(rel))));
|
|
}
|
|
|
|
cstate = BeginCopy(false, rel, query, queryString, 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,
|
|
(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);
|
|
cstate->copy_file = AllocateFile(cstate->filename, PG_BINARY_W);
|
|
umask(oumask);
|
|
if (cstate->copy_file == NULL)
|
|
ereport(ERROR,
|
|
(errcode_for_file_access(),
|
|
errmsg("could not open file \"%s\" for writing: %m",
|
|
cstate->filename)));
|
|
|
|
if (fstat(fileno(cstate->copy_file), &st))
|
|
elog(ERROR, "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;
|
|
}
|
|
|
|
/*
|
|
* This intermediate routine exists mainly to localize the effects of setjmp
|
|
* so we don't need to plaster a lot of variables with "volatile".
|
|
*/
|
|
static uint64
|
|
DoCopyTo(CopyState cstate)
|
|
{
|
|
bool pipe = (cstate->filename == NULL);
|
|
bool fe_copy = (pipe && whereToSendOutput == DestRemote);
|
|
uint64 processed;
|
|
|
|
PG_TRY();
|
|
{
|
|
if (fe_copy)
|
|
SendCopyBegin(cstate);
|
|
|
|
processed = CopyTo(cstate);
|
|
|
|
if (fe_copy)
|
|
SendCopyEnd(cstate);
|
|
}
|
|
PG_CATCH();
|
|
{
|
|
/*
|
|
* Make sure we turn off old-style COPY OUT mode upon error. It is
|
|
* okay to do this in all cases, since it does nothing if the mode is
|
|
* not on.
|
|
*/
|
|
pq_endcopyout(true);
|
|
PG_RE_THROW();
|
|
}
|
|
PG_END_TRY();
|
|
|
|
return processed;
|
|
}
|
|
|
|
/*
|
|
* Clean up storage and release resources for COPY TO.
|
|
*/
|
|
static void
|
|
EndCopyTo(CopyState cstate)
|
|
{
|
|
if (cstate->queryDesc != NULL)
|
|
{
|
|
/* Close down the query and free resources. */
|
|
ExecutorFinish(cstate->queryDesc);
|
|
ExecutorEnd(cstate->queryDesc);
|
|
FreeQueryDesc(cstate->queryDesc);
|
|
PopActiveSnapshot();
|
|
}
|
|
|
|
/* Clean up storage */
|
|
EndCopy(cstate);
|
|
}
|
|
|
|
/*
|
|
* Copy from relation or query TO file.
|
|
*/
|
|
static uint64
|
|
CopyTo(CopyState cstate)
|
|
{
|
|
TupleDesc tupDesc;
|
|
int num_phys_attrs;
|
|
Form_pg_attribute *attr;
|
|
ListCell *cur;
|
|
uint64 processed;
|
|
|
|
if (cstate->rel)
|
|
tupDesc = RelationGetDescr(cstate->rel);
|
|
else
|
|
tupDesc = cstate->queryDesc->tupDesc;
|
|
attr = tupDesc->attrs;
|
|
num_phys_attrs = tupDesc->natts;
|
|
cstate->null_print_client = cstate->null_print; /* default */
|
|
|
|
/* We use fe_msgbuf as a per-row buffer regardless of copy_dest */
|
|
cstate->fe_msgbuf = makeStringInfo();
|
|
|
|
/* Get info about the columns we need to process. */
|
|
cstate->out_functions = (FmgrInfo *) palloc(num_phys_attrs * sizeof(FmgrInfo));
|
|
foreach(cur, cstate->attnumlist)
|
|
{
|
|
int attnum = lfirst_int(cur);
|
|
Oid out_func_oid;
|
|
bool isvarlena;
|
|
|
|
if (cstate->binary)
|
|
getTypeBinaryOutputInfo(attr[attnum - 1]->atttypid,
|
|
&out_func_oid,
|
|
&isvarlena);
|
|
else
|
|
getTypeOutputInfo(attr[attnum - 1]->atttypid,
|
|
&out_func_oid,
|
|
&isvarlena);
|
|
fmgr_info(out_func_oid, &cstate->out_functions[attnum - 1]);
|
|
}
|
|
|
|
/*
|
|
* Create a temporary memory context that we can reset once per row to
|
|
* recover palloc'd memory. This avoids any problems with leaks inside
|
|
* datatype output routines, and should be faster than retail pfree's
|
|
* anyway. (We don't need a whole econtext as CopyFrom does.)
|
|
*/
|
|
cstate->rowcontext = AllocSetContextCreate(CurrentMemoryContext,
|
|
"COPY TO",
|
|
ALLOCSET_DEFAULT_MINSIZE,
|
|
ALLOCSET_DEFAULT_INITSIZE,
|
|
ALLOCSET_DEFAULT_MAXSIZE);
|
|
|
|
if (cstate->binary)
|
|
{
|
|
/* Generate header for a binary copy */
|
|
int32 tmp;
|
|
|
|
/* Signature */
|
|
CopySendData(cstate, BinarySignature, 11);
|
|
/* Flags field */
|
|
tmp = 0;
|
|
if (cstate->oids)
|
|
tmp |= (1 << 16);
|
|
CopySendInt32(cstate, tmp);
|
|
/* No header extension */
|
|
tmp = 0;
|
|
CopySendInt32(cstate, tmp);
|
|
}
|
|
else
|
|
{
|
|
/*
|
|
* For non-binary copy, we need to convert null_print to file
|
|
* encoding, because it will be sent directly with CopySendString.
|
|
*/
|
|
if (cstate->need_transcoding)
|
|
cstate->null_print_client = pg_server_to_any(cstate->null_print,
|
|
cstate->null_print_len,
|
|
cstate->file_encoding);
|
|
|
|
/* if a header has been requested send the line */
|
|
if (cstate->header_line)
|
|
{
|
|
bool hdr_delim = false;
|
|
|
|
foreach(cur, cstate->attnumlist)
|
|
{
|
|
int attnum = lfirst_int(cur);
|
|
char *colname;
|
|
|
|
if (hdr_delim)
|
|
CopySendChar(cstate, cstate->delim[0]);
|
|
hdr_delim = true;
|
|
|
|
colname = NameStr(attr[attnum - 1]->attname);
|
|
|
|
CopyAttributeOutCSV(cstate, colname, false,
|
|
list_length(cstate->attnumlist) == 1);
|
|
}
|
|
|
|
CopySendEndOfRow(cstate);
|
|
}
|
|
}
|
|
|
|
if (cstate->rel)
|
|
{
|
|
Datum *values;
|
|
bool *nulls;
|
|
HeapScanDesc scandesc;
|
|
HeapTuple tuple;
|
|
|
|
values = (Datum *) palloc(num_phys_attrs * sizeof(Datum));
|
|
nulls = (bool *) palloc(num_phys_attrs * sizeof(bool));
|
|
|
|
scandesc = heap_beginscan(cstate->rel, GetActiveSnapshot(), 0, NULL);
|
|
|
|
processed = 0;
|
|
while ((tuple = heap_getnext(scandesc, ForwardScanDirection)) != NULL)
|
|
{
|
|
CHECK_FOR_INTERRUPTS();
|
|
|
|
/* Deconstruct the tuple ... faster than repeated heap_getattr */
|
|
heap_deform_tuple(tuple, tupDesc, values, nulls);
|
|
|
|
/* Format and send the data */
|
|
CopyOneRowTo(cstate, HeapTupleGetOid(tuple), values, nulls);
|
|
processed++;
|
|
}
|
|
|
|
heap_endscan(scandesc);
|
|
|
|
pfree(values);
|
|
pfree(nulls);
|
|
}
|
|
else
|
|
{
|
|
/* run the plan --- the dest receiver will send tuples */
|
|
ExecutorRun(cstate->queryDesc, ForwardScanDirection, 0L);
|
|
processed = ((DR_copy *) cstate->queryDesc->dest)->processed;
|
|
}
|
|
|
|
if (cstate->binary)
|
|
{
|
|
/* Generate trailer for a binary copy */
|
|
CopySendInt16(cstate, -1);
|
|
/* Need to flush out the trailer */
|
|
CopySendEndOfRow(cstate);
|
|
}
|
|
|
|
MemoryContextDelete(cstate->rowcontext);
|
|
|
|
return processed;
|
|
}
|
|
|
|
/*
|
|
* Emit one row during CopyTo().
|
|
*/
|
|
static void
|
|
CopyOneRowTo(CopyState cstate, Oid tupleOid, Datum *values, bool *nulls)
|
|
{
|
|
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));
|
|
/* Send OID if wanted --- note attnumlist doesn't include it */
|
|
if (cstate->oids)
|
|
{
|
|
/* Hack --- assume Oid is same size as int32 */
|
|
CopySendInt32(cstate, sizeof(int32));
|
|
CopySendInt32(cstate, tupleOid);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
/* Text format has no per-tuple header, but send OID if wanted */
|
|
/* Assume digits don't need any quoting or encoding conversion */
|
|
if (cstate->oids)
|
|
{
|
|
string = DatumGetCString(DirectFunctionCall1(oidout,
|
|
ObjectIdGetDatum(tupleOid)));
|
|
CopySendString(cstate, string);
|
|
need_delim = true;
|
|
}
|
|
}
|
|
|
|
foreach(cur, cstate->attnumlist)
|
|
{
|
|
int attnum = lfirst_int(cur);
|
|
Datum value = values[attnum - 1];
|
|
bool isnull = nulls[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);
|
|
}
|
|
|
|
|
|
/*
|
|
* error context callback for COPY FROM
|
|
*
|
|
* The argument for the error context must be CopyState.
|
|
*/
|
|
void
|
|
CopyFromErrorCallback(void *arg)
|
|
{
|
|
CopyState cstate = (CopyState) arg;
|
|
|
|
if (cstate->binary)
|
|
{
|
|
/* can't usefully display the data */
|
|
if (cstate->cur_attname)
|
|
errcontext("COPY %s, line %d, column %s",
|
|
cstate->cur_relname, cstate->cur_lineno,
|
|
cstate->cur_attname);
|
|
else
|
|
errcontext("COPY %s, line %d",
|
|
cstate->cur_relname, cstate->cur_lineno);
|
|
}
|
|
else
|
|
{
|
|
if (cstate->cur_attname && cstate->cur_attval)
|
|
{
|
|
/* error is relevant to a particular column */
|
|
char *attval;
|
|
|
|
attval = limit_printout_length(cstate->cur_attval);
|
|
errcontext("COPY %s, line %d, column %s: \"%s\"",
|
|
cstate->cur_relname, cstate->cur_lineno,
|
|
cstate->cur_attname, attval);
|
|
pfree(attval);
|
|
}
|
|
else if (cstate->cur_attname)
|
|
{
|
|
/* error is relevant to a particular column, value is NULL */
|
|
errcontext("COPY %s, line %d, column %s: null input",
|
|
cstate->cur_relname, cstate->cur_lineno,
|
|
cstate->cur_attname);
|
|
}
|
|
else
|
|
{
|
|
/*
|
|
* Error is relevant to a particular line.
|
|
*
|
|
* If line_buf still contains the correct line, and it's already
|
|
* transcoded, print it. If it's still in a foreign encoding, it's
|
|
* quite likely that the error is precisely a failure to do
|
|
* encoding conversion (ie, bad data). We dare not try to convert
|
|
* it, and at present there's no way to regurgitate it without
|
|
* conversion. So we have to punt and just report the line number.
|
|
*/
|
|
if (cstate->line_buf_valid &&
|
|
(cstate->line_buf_converted || !cstate->need_transcoding))
|
|
{
|
|
char *lineval;
|
|
|
|
lineval = limit_printout_length(cstate->line_buf.data);
|
|
errcontext("COPY %s, line %d: \"%s\"",
|
|
cstate->cur_relname, cstate->cur_lineno, lineval);
|
|
pfree(lineval);
|
|
}
|
|
else
|
|
{
|
|
errcontext("COPY %s, line %d",
|
|
cstate->cur_relname, cstate->cur_lineno);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Make sure we don't print an unreasonable amount of COPY data in a message.
|
|
*
|
|
* It would seem a lot easier to just use the sprintf "precision" limit to
|
|
* truncate the string. However, some versions of glibc have a bug/misfeature
|
|
* that vsnprintf will always fail (return -1) if it is asked to truncate
|
|
* a string that contains invalid byte sequences for the current encoding.
|
|
* So, do our own truncation. We return a pstrdup'd copy of the input.
|
|
*/
|
|
static char *
|
|
limit_printout_length(const char *str)
|
|
{
|
|
#define MAX_COPY_DATA_DISPLAY 100
|
|
|
|
int slen = strlen(str);
|
|
int len;
|
|
char *res;
|
|
|
|
/* Fast path if definitely okay */
|
|
if (slen <= MAX_COPY_DATA_DISPLAY)
|
|
return pstrdup(str);
|
|
|
|
/* Apply encoding-dependent truncation */
|
|
len = pg_mbcliplen(str, slen, MAX_COPY_DATA_DISPLAY);
|
|
|
|
/*
|
|
* Truncate, and add "..." to show we truncated the input.
|
|
*/
|
|
res = (char *) palloc(len + 4);
|
|
memcpy(res, str, len);
|
|
strcpy(res + len, "...");
|
|
|
|
return res;
|
|
}
|
|
|
|
/*
|
|
* Copy FROM file to relation.
|
|
*/
|
|
static uint64
|
|
CopyFrom(CopyState cstate)
|
|
{
|
|
HeapTuple tuple;
|
|
TupleDesc tupDesc;
|
|
Datum *values;
|
|
bool *nulls;
|
|
ResultRelInfo *resultRelInfo;
|
|
EState *estate = CreateExecutorState(); /* for ExecConstraints() */
|
|
ExprContext *econtext;
|
|
TupleTableSlot *myslot;
|
|
MemoryContext oldcontext = CurrentMemoryContext;
|
|
|
|
ErrorContextCallback errcallback;
|
|
CommandId mycid = GetCurrentCommandId(true);
|
|
int hi_options = 0; /* start with default heap_insert options */
|
|
BulkInsertState bistate;
|
|
uint64 processed = 0;
|
|
bool useHeapMultiInsert;
|
|
int nBufferedTuples = 0;
|
|
|
|
#define MAX_BUFFERED_TUPLES 1000
|
|
HeapTuple *bufferedTuples = NULL; /* initialize to silence warning */
|
|
Size bufferedTuplesSize = 0;
|
|
int firstBufferedLineNo = 0;
|
|
|
|
Assert(cstate->rel);
|
|
|
|
if (cstate->rel->rd_rel->relkind != RELKIND_RELATION)
|
|
{
|
|
if (cstate->rel->rd_rel->relkind == RELKIND_VIEW)
|
|
ereport(ERROR,
|
|
(errcode(ERRCODE_WRONG_OBJECT_TYPE),
|
|
errmsg("cannot copy to view \"%s\"",
|
|
RelationGetRelationName(cstate->rel))));
|
|
else if (cstate->rel->rd_rel->relkind == RELKIND_MATVIEW)
|
|
ereport(ERROR,
|
|
(errcode(ERRCODE_WRONG_OBJECT_TYPE),
|
|
errmsg("cannot copy to materialized view \"%s\"",
|
|
RelationGetRelationName(cstate->rel))));
|
|
else if (cstate->rel->rd_rel->relkind == RELKIND_FOREIGN_TABLE)
|
|
ereport(ERROR,
|
|
(errcode(ERRCODE_WRONG_OBJECT_TYPE),
|
|
errmsg("cannot copy to foreign table \"%s\"",
|
|
RelationGetRelationName(cstate->rel))));
|
|
else if (cstate->rel->rd_rel->relkind == RELKIND_SEQUENCE)
|
|
ereport(ERROR,
|
|
(errcode(ERRCODE_WRONG_OBJECT_TYPE),
|
|
errmsg("cannot copy to sequence \"%s\"",
|
|
RelationGetRelationName(cstate->rel))));
|
|
else
|
|
ereport(ERROR,
|
|
(errcode(ERRCODE_WRONG_OBJECT_TYPE),
|
|
errmsg("cannot copy to non-table relation \"%s\"",
|
|
RelationGetRelationName(cstate->rel))));
|
|
}
|
|
|
|
tupDesc = RelationGetDescr(cstate->rel);
|
|
|
|
/*----------
|
|
* Check to see if we can avoid writing WAL
|
|
*
|
|
* If archive logging/streaming is not enabled *and* either
|
|
* - table was created in same transaction as this COPY
|
|
* - data is being written to relfilenode created in this transaction
|
|
* then we can skip writing WAL. It's safe because if the transaction
|
|
* doesn't commit, we'll discard the table (or the new relfilenode file).
|
|
* If it does commit, we'll have done the heap_sync at the bottom of this
|
|
* routine first.
|
|
*
|
|
* As mentioned in comments in utils/rel.h, the in-same-transaction test
|
|
* is not always set correctly, since in rare cases rd_newRelfilenodeSubid
|
|
* can be cleared before the end of the transaction. The exact case is
|
|
* when a relation sets a new relfilenode twice in same transaction, yet
|
|
* the second one fails in an aborted subtransaction, e.g.
|
|
*
|
|
* BEGIN;
|
|
* TRUNCATE t;
|
|
* SAVEPOINT save;
|
|
* TRUNCATE t;
|
|
* ROLLBACK TO save;
|
|
* COPY ...
|
|
*
|
|
* Also, if the target file is new-in-transaction, we assume that checking
|
|
* FSM for free space is a waste of time, even if we must use WAL because
|
|
* of archiving. This could possibly be wrong, but it's unlikely.
|
|
*
|
|
* The comments for heap_insert and RelationGetBufferForTuple specify that
|
|
* skipping WAL logging is only safe if we ensure that our tuples do not
|
|
* go into pages containing tuples from any other transactions --- but this
|
|
* must be the case if we have a new table or new relfilenode, so we need
|
|
* no additional work to enforce that.
|
|
*----------
|
|
*/
|
|
/* createSubid is creation check, newRelfilenodeSubid is truncation check */
|
|
if (cstate->rel->rd_createSubid != InvalidSubTransactionId ||
|
|
cstate->rel->rd_newRelfilenodeSubid != InvalidSubTransactionId)
|
|
{
|
|
hi_options |= HEAP_INSERT_SKIP_FSM;
|
|
if (!XLogIsNeeded())
|
|
hi_options |= HEAP_INSERT_SKIP_WAL;
|
|
}
|
|
|
|
/*
|
|
* Optimize if new relfilenode was created in this subxact or one of its
|
|
* committed children and we won't see those rows later as part of an
|
|
* earlier scan or command. This ensures that if this subtransaction
|
|
* aborts then the frozen rows won't be visible after xact cleanup. Note
|
|
* that the stronger test of exactly which subtransaction created it is
|
|
* crucial for correctness of this optimisation.
|
|
*/
|
|
if (cstate->freeze)
|
|
{
|
|
if (!ThereAreNoPriorRegisteredSnapshots() || !ThereAreNoReadyPortals())
|
|
ereport(ERROR,
|
|
(ERRCODE_INVALID_TRANSACTION_STATE,
|
|
errmsg("cannot perform FREEZE because of prior transaction activity")));
|
|
|
|
if (cstate->rel->rd_createSubid != GetCurrentSubTransactionId() &&
|
|
cstate->rel->rd_newRelfilenodeSubid != GetCurrentSubTransactionId())
|
|
ereport(ERROR,
|
|
(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE,
|
|
errmsg("cannot perform FREEZE because the table was not created or truncated in the current subtransaction")));
|
|
|
|
hi_options |= HEAP_INSERT_FROZEN;
|
|
}
|
|
|
|
/*
|
|
* We need a ResultRelInfo so we can use the regular executor's
|
|
* index-entry-making machinery. (There used to be a huge amount of code
|
|
* here that basically duplicated execUtils.c ...)
|
|
*/
|
|
resultRelInfo = makeNode(ResultRelInfo);
|
|
InitResultRelInfo(resultRelInfo,
|
|
cstate->rel,
|
|
1, /* dummy rangetable index */
|
|
0);
|
|
|
|
ExecOpenIndices(resultRelInfo);
|
|
|
|
estate->es_result_relations = resultRelInfo;
|
|
estate->es_num_result_relations = 1;
|
|
estate->es_result_relation_info = resultRelInfo;
|
|
estate->es_range_table = cstate->range_table;
|
|
|
|
/* Set up a tuple slot too */
|
|
myslot = ExecInitExtraTupleSlot(estate);
|
|
ExecSetSlotDescriptor(myslot, tupDesc);
|
|
/* Triggers might need a slot as well */
|
|
estate->es_trig_tuple_slot = ExecInitExtraTupleSlot(estate);
|
|
|
|
/*
|
|
* It's more efficient to prepare a bunch of tuples for insertion, and
|
|
* insert them in one heap_multi_insert() call, than call heap_insert()
|
|
* separately for every tuple. However, we can't do that if there are
|
|
* BEFORE/INSTEAD OF triggers, or we need to evaluate volatile default
|
|
* expressions. Such triggers or expressions might query the table we're
|
|
* inserting to, and act differently if the tuples that have already been
|
|
* processed and prepared for insertion are not there.
|
|
*/
|
|
if ((resultRelInfo->ri_TrigDesc != NULL &&
|
|
(resultRelInfo->ri_TrigDesc->trig_insert_before_row ||
|
|
resultRelInfo->ri_TrigDesc->trig_insert_instead_row)) ||
|
|
cstate->volatile_defexprs)
|
|
{
|
|
useHeapMultiInsert = false;
|
|
}
|
|
else
|
|
{
|
|
useHeapMultiInsert = true;
|
|
bufferedTuples = palloc(MAX_BUFFERED_TUPLES * sizeof(HeapTuple));
|
|
}
|
|
|
|
/* Prepare to catch AFTER triggers. */
|
|
AfterTriggerBeginQuery();
|
|
|
|
/*
|
|
* Check BEFORE STATEMENT insertion triggers. It's debatable whether we
|
|
* should do this for COPY, since it's not really an "INSERT" statement as
|
|
* such. However, executing these triggers maintains consistency with the
|
|
* EACH ROW triggers that we already fire on COPY.
|
|
*/
|
|
ExecBSInsertTriggers(estate, resultRelInfo);
|
|
|
|
values = (Datum *) palloc(tupDesc->natts * sizeof(Datum));
|
|
nulls = (bool *) palloc(tupDesc->natts * sizeof(bool));
|
|
|
|
bistate = GetBulkInsertState();
|
|
econtext = GetPerTupleExprContext(estate);
|
|
|
|
/* Set up callback to identify error line number */
|
|
errcallback.callback = CopyFromErrorCallback;
|
|
errcallback.arg = (void *) cstate;
|
|
errcallback.previous = error_context_stack;
|
|
error_context_stack = &errcallback;
|
|
|
|
for (;;)
|
|
{
|
|
TupleTableSlot *slot;
|
|
bool skip_tuple;
|
|
Oid loaded_oid = InvalidOid;
|
|
|
|
CHECK_FOR_INTERRUPTS();
|
|
|
|
if (nBufferedTuples == 0)
|
|
{
|
|
/*
|
|
* Reset the per-tuple exprcontext. We can only do this if the
|
|
* tuple buffer is empty. (Calling the context the per-tuple
|
|
* memory context is a bit of a misnomer now.)
|
|
*/
|
|
ResetPerTupleExprContext(estate);
|
|
}
|
|
|
|
/* Switch into its memory context */
|
|
MemoryContextSwitchTo(GetPerTupleMemoryContext(estate));
|
|
|
|
if (!NextCopyFrom(cstate, econtext, values, nulls, &loaded_oid))
|
|
break;
|
|
|
|
/* And now we can form the input tuple. */
|
|
tuple = heap_form_tuple(tupDesc, values, nulls);
|
|
|
|
if (loaded_oid != InvalidOid)
|
|
HeapTupleSetOid(tuple, loaded_oid);
|
|
|
|
/*
|
|
* Constraints might reference the tableoid column, so initialize
|
|
* t_tableOid before evaluating them.
|
|
*/
|
|
tuple->t_tableOid = RelationGetRelid(resultRelInfo->ri_RelationDesc);
|
|
|
|
/* Triggers and stuff need to be invoked in query context. */
|
|
MemoryContextSwitchTo(oldcontext);
|
|
|
|
/* Place tuple in tuple slot --- but slot shouldn't free it */
|
|
slot = myslot;
|
|
ExecStoreTuple(tuple, slot, InvalidBuffer, false);
|
|
|
|
skip_tuple = false;
|
|
|
|
/* BEFORE ROW INSERT Triggers */
|
|
if (resultRelInfo->ri_TrigDesc &&
|
|
resultRelInfo->ri_TrigDesc->trig_insert_before_row)
|
|
{
|
|
slot = ExecBRInsertTriggers(estate, resultRelInfo, slot);
|
|
|
|
if (slot == NULL) /* "do nothing" */
|
|
skip_tuple = true;
|
|
else /* trigger might have changed tuple */
|
|
tuple = ExecMaterializeSlot(slot);
|
|
}
|
|
|
|
if (!skip_tuple)
|
|
{
|
|
/* Check the constraints of the tuple */
|
|
if (cstate->rel->rd_att->constr)
|
|
ExecConstraints(resultRelInfo, slot, estate);
|
|
|
|
if (useHeapMultiInsert)
|
|
{
|
|
/* Add this tuple to the tuple buffer */
|
|
if (nBufferedTuples == 0)
|
|
firstBufferedLineNo = cstate->cur_lineno;
|
|
bufferedTuples[nBufferedTuples++] = tuple;
|
|
bufferedTuplesSize += tuple->t_len;
|
|
|
|
/*
|
|
* If the buffer filled up, flush it. Also flush if the total
|
|
* size of all the tuples in the buffer becomes large, to
|
|
* avoid using large amounts of memory for the buffers when
|
|
* the tuples are exceptionally wide.
|
|
*/
|
|
if (nBufferedTuples == MAX_BUFFERED_TUPLES ||
|
|
bufferedTuplesSize > 65535)
|
|
{
|
|
CopyFromInsertBatch(cstate, estate, mycid, hi_options,
|
|
resultRelInfo, myslot, bistate,
|
|
nBufferedTuples, bufferedTuples,
|
|
firstBufferedLineNo);
|
|
nBufferedTuples = 0;
|
|
bufferedTuplesSize = 0;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
List *recheckIndexes = NIL;
|
|
|
|
/* OK, store the tuple and create index entries for it */
|
|
heap_insert(cstate->rel, tuple, mycid, hi_options, bistate);
|
|
|
|
if (resultRelInfo->ri_NumIndices > 0)
|
|
recheckIndexes = ExecInsertIndexTuples(slot, &(tuple->t_self),
|
|
estate);
|
|
|
|
/* AFTER ROW INSERT Triggers */
|
|
ExecARInsertTriggers(estate, resultRelInfo, tuple,
|
|
recheckIndexes);
|
|
|
|
list_free(recheckIndexes);
|
|
}
|
|
|
|
/*
|
|
* We count only tuples not suppressed by a BEFORE INSERT trigger;
|
|
* this is the same definition used by execMain.c for counting
|
|
* tuples inserted by an INSERT command.
|
|
*/
|
|
processed++;
|
|
}
|
|
}
|
|
|
|
/* Flush any remaining buffered tuples */
|
|
if (nBufferedTuples > 0)
|
|
CopyFromInsertBatch(cstate, estate, mycid, hi_options,
|
|
resultRelInfo, myslot, bistate,
|
|
nBufferedTuples, bufferedTuples,
|
|
firstBufferedLineNo);
|
|
|
|
/* Done, clean up */
|
|
error_context_stack = errcallback.previous;
|
|
|
|
FreeBulkInsertState(bistate);
|
|
|
|
MemoryContextSwitchTo(oldcontext);
|
|
|
|
/*
|
|
* In the old protocol, tell pqcomm that we can process normal protocol
|
|
* messages again.
|
|
*/
|
|
if (cstate->copy_dest == COPY_OLD_FE)
|
|
pq_endmsgread();
|
|
|
|
/* Execute AFTER STATEMENT insertion triggers */
|
|
ExecASInsertTriggers(estate, resultRelInfo);
|
|
|
|
/* Handle queued AFTER triggers */
|
|
AfterTriggerEndQuery(estate);
|
|
|
|
pfree(values);
|
|
pfree(nulls);
|
|
|
|
ExecResetTupleTable(estate->es_tupleTable, false);
|
|
|
|
ExecCloseIndices(resultRelInfo);
|
|
|
|
FreeExecutorState(estate);
|
|
|
|
/*
|
|
* If we skipped writing WAL, then we need to sync the heap (but not
|
|
* indexes since those use WAL anyway)
|
|
*/
|
|
if (hi_options & HEAP_INSERT_SKIP_WAL)
|
|
heap_sync(cstate->rel);
|
|
|
|
return processed;
|
|
}
|
|
|
|
/*
|
|
* A subroutine of CopyFrom, to write the current batch of buffered heap
|
|
* tuples to the heap. Also updates indexes and runs AFTER ROW INSERT
|
|
* triggers.
|
|
*/
|
|
static void
|
|
CopyFromInsertBatch(CopyState cstate, EState *estate, CommandId mycid,
|
|
int hi_options, ResultRelInfo *resultRelInfo,
|
|
TupleTableSlot *myslot, BulkInsertState bistate,
|
|
int nBufferedTuples, HeapTuple *bufferedTuples,
|
|
int firstBufferedLineNo)
|
|
{
|
|
MemoryContext oldcontext;
|
|
int i;
|
|
int save_cur_lineno;
|
|
|
|
/*
|
|
* Print error context information correctly, if one of the operations
|
|
* below fail.
|
|
*/
|
|
cstate->line_buf_valid = false;
|
|
save_cur_lineno = cstate->cur_lineno;
|
|
|
|
/*
|
|
* heap_multi_insert leaks memory, so switch to short-lived memory context
|
|
* before calling it.
|
|
*/
|
|
oldcontext = MemoryContextSwitchTo(GetPerTupleMemoryContext(estate));
|
|
heap_multi_insert(cstate->rel,
|
|
bufferedTuples,
|
|
nBufferedTuples,
|
|
mycid,
|
|
hi_options,
|
|
bistate);
|
|
MemoryContextSwitchTo(oldcontext);
|
|
|
|
/*
|
|
* If there are any indexes, update them for all the inserted tuples, and
|
|
* run AFTER ROW INSERT triggers.
|
|
*/
|
|
if (resultRelInfo->ri_NumIndices > 0)
|
|
{
|
|
for (i = 0; i < nBufferedTuples; i++)
|
|
{
|
|
List *recheckIndexes;
|
|
|
|
cstate->cur_lineno = firstBufferedLineNo + i;
|
|
ExecStoreTuple(bufferedTuples[i], myslot, InvalidBuffer, false);
|
|
recheckIndexes =
|
|
ExecInsertIndexTuples(myslot, &(bufferedTuples[i]->t_self),
|
|
estate);
|
|
ExecARInsertTriggers(estate, resultRelInfo,
|
|
bufferedTuples[i],
|
|
recheckIndexes);
|
|
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)
|
|
{
|
|
for (i = 0; i < nBufferedTuples; i++)
|
|
{
|
|
cstate->cur_lineno = firstBufferedLineNo + i;
|
|
ExecARInsertTriggers(estate, resultRelInfo,
|
|
bufferedTuples[i],
|
|
NIL);
|
|
}
|
|
}
|
|
|
|
/* reset cur_lineno to where we were */
|
|
cstate->cur_lineno = save_cur_lineno;
|
|
}
|
|
|
|
/*
|
|
* Setup to read tuples from a file for COPY FROM.
|
|
*
|
|
* 'rel': Used as a template for the tuples
|
|
* 'filename': Name of server-local file to read
|
|
* 'attnamelist': List of char *, columns to include. NIL selects all cols.
|
|
* 'options': List of DefElem. See copy_opt_item in gram.y for selections.
|
|
*
|
|
* Returns a CopyState, to be passed to NextCopyFrom and related functions.
|
|
*/
|
|
CopyState
|
|
BeginCopyFrom(Relation rel,
|
|
const char *filename,
|
|
bool is_program,
|
|
List *attnamelist,
|
|
List *options)
|
|
{
|
|
CopyState cstate;
|
|
bool pipe = (filename == NULL);
|
|
TupleDesc tupDesc;
|
|
Form_pg_attribute *attr;
|
|
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(true, rel, NULL, NULL, InvalidOid, attnamelist, options);
|
|
oldcontext = MemoryContextSwitchTo(cstate->copycontext);
|
|
|
|
/* Initialize state variables */
|
|
cstate->fe_eof = false;
|
|
cstate->eol_type = EOL_UNKNOWN;
|
|
cstate->cur_relname = RelationGetRelationName(cstate->rel);
|
|
cstate->cur_lineno = 0;
|
|
cstate->cur_attname = NULL;
|
|
cstate->cur_attval = NULL;
|
|
|
|
/* Set up variables to avoid per-attribute overhead. */
|
|
initStringInfo(&cstate->attribute_buf);
|
|
initStringInfo(&cstate->line_buf);
|
|
cstate->line_buf_converted = false;
|
|
cstate->raw_buf = (char *) palloc(RAW_BUF_SIZE + 1);
|
|
cstate->raw_buf_index = cstate->raw_buf_len = 0;
|
|
|
|
tupDesc = RelationGetDescr(cstate->rel);
|
|
attr = tupDesc->attrs;
|
|
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++)
|
|
{
|
|
/* We don't need info for dropped attributes */
|
|
if (attr[attnum - 1]->attisdropped)
|
|
continue;
|
|
|
|
/* Fetch the input function and typioparam info */
|
|
if (cstate->binary)
|
|
getTypeBinaryInputInfo(attr[attnum - 1]->atttypid,
|
|
&in_func_oid, &typioparams[attnum - 1]);
|
|
else
|
|
getTypeInputInfo(attr[attnum - 1]->atttypid,
|
|
&in_func_oid, &typioparams[attnum - 1]);
|
|
fmgr_info(in_func_oid, &in_functions[attnum - 1]);
|
|
|
|
/* Get default info if needed */
|
|
if (!list_member_int(cstate->attnumlist, attnum))
|
|
{
|
|
/* attribute is NOT to be copied from input */
|
|
/* use default value if one exists */
|
|
Expr *defexpr = (Expr *) build_column_default(cstate->rel,
|
|
attnum);
|
|
|
|
if (defexpr != NULL)
|
|
{
|
|
/* Run the expression through planner */
|
|
defexpr = expression_planner(defexpr);
|
|
|
|
/* Initialize executable expression in copycontext */
|
|
defexprs[num_defaults] = ExecInitExpr(defexpr, NULL);
|
|
defmap[num_defaults] = attnum - 1;
|
|
num_defaults++;
|
|
|
|
/*
|
|
* If a default expression looks at the table being loaded,
|
|
* then it could give the wrong answer when using
|
|
* multi-insert. Since database access can be dynamic this is
|
|
* hard to test for exactly, so we use the much wider test of
|
|
* whether the default expression is volatile. We allow for
|
|
* the special case of when the default expression is the
|
|
* nextval() of a sequence which in this specific case is
|
|
* known to be safe for use with the multi-insert
|
|
* optimisation. 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 (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,
|
|
(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)
|
|
ereport(ERROR,
|
|
(errcode_for_file_access(),
|
|
errmsg("could not open file \"%s\" for reading: %m",
|
|
cstate->filename)));
|
|
|
|
if (fstat(fileno(cstate->copy_file), &st))
|
|
elog(ERROR, "could not stat file \"%s\": %m", cstate->filename);
|
|
|
|
if (S_ISDIR(st.st_mode))
|
|
ereport(ERROR,
|
|
(errcode(ERRCODE_WRONG_OBJECT_TYPE),
|
|
errmsg("\"%s\" is a directory", cstate->filename)));
|
|
}
|
|
}
|
|
|
|
if (!cstate->binary)
|
|
{
|
|
/* must rely on user to tell us... */
|
|
cstate->file_has_oids = cstate->oids;
|
|
}
|
|
else
|
|
{
|
|
/* Read and verify binary header */
|
|
char readSig[11];
|
|
int32 tmp;
|
|
|
|
/* Signature */
|
|
if (CopyGetData(cstate, readSig, 11, 11) != 11 ||
|
|
memcmp(readSig, BinarySignature, 11) != 0)
|
|
ereport(ERROR,
|
|
(errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
|
|
errmsg("COPY file signature not recognized")));
|
|
/* Flags field */
|
|
if (!CopyGetInt32(cstate, &tmp))
|
|
ereport(ERROR,
|
|
(errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
|
|
errmsg("invalid COPY file header (missing flags)")));
|
|
cstate->file_has_oids = (tmp & (1 << 16)) != 0;
|
|
tmp &= ~(1 << 16);
|
|
if ((tmp >> 16) != 0)
|
|
ereport(ERROR,
|
|
(errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
|
|
errmsg("unrecognized critical flags in COPY file header")));
|
|
/* Header extension length */
|
|
if (!CopyGetInt32(cstate, &tmp) ||
|
|
tmp < 0)
|
|
ereport(ERROR,
|
|
(errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
|
|
errmsg("invalid COPY file header (missing length)")));
|
|
/* Skip extension header, if present */
|
|
while (tmp-- > 0)
|
|
{
|
|
if (CopyGetData(cstate, readSig, 1, 1) != 1)
|
|
ereport(ERROR,
|
|
(errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
|
|
errmsg("invalid COPY file header (wrong length)")));
|
|
}
|
|
}
|
|
|
|
if (cstate->file_has_oids && cstate->binary)
|
|
{
|
|
getTypeBinaryInputInfo(OIDOID,
|
|
&in_func_oid, &cstate->oid_typioparam);
|
|
fmgr_info(in_func_oid, &cstate->oid_in_function);
|
|
}
|
|
|
|
/* create workspace for CopyReadAttributes results */
|
|
if (!cstate->binary)
|
|
{
|
|
AttrNumber attr_count = list_length(cstate->attnumlist);
|
|
int nfields = cstate->file_has_oids ? (attr_count + 1) : attr_count;
|
|
|
|
cstate->max_fields = nfields;
|
|
cstate->raw_fields = (char **) palloc(nfields * sizeof(char *));
|
|
}
|
|
|
|
MemoryContextSwitchTo(oldcontext);
|
|
|
|
return cstate;
|
|
}
|
|
|
|
/*
|
|
* Read raw fields in the next line for COPY FROM in text or csv mode.
|
|
* Return false if no more lines.
|
|
*
|
|
* An internal temporary buffer is returned via 'fields'. It is valid until
|
|
* the next call of the function. Since the function returns all raw fields
|
|
* in the input file, 'nfields' could be different from the number of columns
|
|
* in the relation.
|
|
*
|
|
* NOTE: force_not_null option are not applied to the returned fields.
|
|
*/
|
|
bool
|
|
NextCopyFromRawFields(CopyState cstate, char ***fields, int *nfields)
|
|
{
|
|
int fldct;
|
|
bool done;
|
|
|
|
/* only available for text or csv input */
|
|
Assert(!cstate->binary);
|
|
|
|
/* on input just throw the header line away */
|
|
if (cstate->cur_lineno == 0 && cstate->header_line)
|
|
{
|
|
cstate->cur_lineno++;
|
|
if (CopyReadLine(cstate))
|
|
return false; /* done */
|
|
}
|
|
|
|
cstate->cur_lineno++;
|
|
|
|
/* Actually read the line into memory here */
|
|
done = CopyReadLine(cstate);
|
|
|
|
/*
|
|
* EOF at start of line means we're done. If we see EOF after some
|
|
* characters, we act as though it was newline followed by EOF, ie,
|
|
* process the line and then exit loop on next iteration.
|
|
*/
|
|
if (done && cstate->line_buf.len == 0)
|
|
return false;
|
|
|
|
/* Parse the line into de-escaped field values */
|
|
if (cstate->csv_mode)
|
|
fldct = CopyReadAttributesCSV(cstate);
|
|
else
|
|
fldct = CopyReadAttributesText(cstate);
|
|
|
|
*fields = cstate->raw_fields;
|
|
*nfields = fldct;
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
* Read next tuple from file for COPY FROM. Return false if no more tuples.
|
|
*
|
|
* 'econtext' is used to evaluate default expression for each columns not
|
|
* read from the file. It can be NULL when no default values are used, i.e.
|
|
* when all columns are read from the file.
|
|
*
|
|
* 'values' and 'nulls' arrays must be the same length as columns of the
|
|
* relation passed to BeginCopyFrom. This function fills the arrays.
|
|
* Oid of the tuple is returned with 'tupleOid' separately.
|
|
*/
|
|
bool
|
|
NextCopyFrom(CopyState cstate, ExprContext *econtext,
|
|
Datum *values, bool *nulls, Oid *tupleOid)
|
|
{
|
|
TupleDesc tupDesc;
|
|
Form_pg_attribute *attr;
|
|
AttrNumber num_phys_attrs,
|
|
attr_count,
|
|
num_defaults = cstate->num_defaults;
|
|
FmgrInfo *in_functions = cstate->in_functions;
|
|
Oid *typioparams = cstate->typioparams;
|
|
int i;
|
|
int nfields;
|
|
bool isnull;
|
|
bool file_has_oids = cstate->file_has_oids;
|
|
int *defmap = cstate->defmap;
|
|
ExprState **defexprs = cstate->defexprs;
|
|
|
|
tupDesc = RelationGetDescr(cstate->rel);
|
|
attr = tupDesc->attrs;
|
|
num_phys_attrs = tupDesc->natts;
|
|
attr_count = list_length(cstate->attnumlist);
|
|
nfields = file_has_oids ? (attr_count + 1) : attr_count;
|
|
|
|
/* Initialize all values for row to NULL */
|
|
MemSet(values, 0, num_phys_attrs * sizeof(Datum));
|
|
MemSet(nulls, true, num_phys_attrs * sizeof(bool));
|
|
|
|
if (!cstate->binary)
|
|
{
|
|
char **field_strings;
|
|
ListCell *cur;
|
|
int fldct;
|
|
int fieldno;
|
|
char *string;
|
|
|
|
/* read raw fields in the next line */
|
|
if (!NextCopyFromRawFields(cstate, &field_strings, &fldct))
|
|
return false;
|
|
|
|
/* check for overflowing fields */
|
|
if (nfields > 0 && fldct > nfields)
|
|
ereport(ERROR,
|
|
(errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
|
|
errmsg("extra data after last expected column")));
|
|
|
|
fieldno = 0;
|
|
|
|
/* Read the OID field if present */
|
|
if (file_has_oids)
|
|
{
|
|
if (fieldno >= fldct)
|
|
ereport(ERROR,
|
|
(errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
|
|
errmsg("missing data for OID column")));
|
|
string = field_strings[fieldno++];
|
|
|
|
if (string == NULL)
|
|
ereport(ERROR,
|
|
(errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
|
|
errmsg("null OID in COPY data")));
|
|
else if (cstate->oids && tupleOid != NULL)
|
|
{
|
|
cstate->cur_attname = "oid";
|
|
cstate->cur_attval = string;
|
|
*tupleOid = DatumGetObjectId(DirectFunctionCall1(oidin,
|
|
CStringGetDatum(string)));
|
|
if (*tupleOid == InvalidOid)
|
|
ereport(ERROR,
|
|
(errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
|
|
errmsg("invalid OID in COPY data")));
|
|
cstate->cur_attname = NULL;
|
|
cstate->cur_attval = NULL;
|
|
}
|
|
}
|
|
|
|
/* Loop to read the user attributes on the line. */
|
|
foreach(cur, cstate->attnumlist)
|
|
{
|
|
int attnum = lfirst_int(cur);
|
|
int m = attnum - 1;
|
|
|
|
if (fieldno >= fldct)
|
|
ereport(ERROR,
|
|
(errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
|
|
errmsg("missing data for column \"%s\"",
|
|
NameStr(attr[m]->attname))));
|
|
string = field_strings[fieldno++];
|
|
|
|
if (cstate->convert_select_flags &&
|
|
!cstate->convert_select_flags[m])
|
|
{
|
|
/* ignore input field, leaving column as NULL */
|
|
continue;
|
|
}
|
|
|
|
if (cstate->csv_mode)
|
|
{
|
|
if (string == NULL &&
|
|
cstate->force_notnull_flags[m])
|
|
{
|
|
/*
|
|
* FORCE_NOT_NULL option is set and column is NULL -
|
|
* convert it to the NULL string.
|
|
*/
|
|
string = cstate->null_print;
|
|
}
|
|
else if (string != NULL && cstate->force_null_flags[m]
|
|
&& strcmp(string, cstate->null_print) == 0)
|
|
{
|
|
/*
|
|
* FORCE_NULL option is set and column matches the NULL
|
|
* string. It must have been quoted, or otherwise the
|
|
* string would already have been set to NULL. Convert it
|
|
* to NULL as specified.
|
|
*/
|
|
string = NULL;
|
|
}
|
|
}
|
|
|
|
cstate->cur_attname = NameStr(attr[m]->attname);
|
|
cstate->cur_attval = string;
|
|
values[m] = InputFunctionCall(&in_functions[m],
|
|
string,
|
|
typioparams[m],
|
|
attr[m]->atttypmod);
|
|
if (string != NULL)
|
|
nulls[m] = false;
|
|
cstate->cur_attname = NULL;
|
|
cstate->cur_attval = NULL;
|
|
}
|
|
|
|
Assert(fieldno == nfields);
|
|
}
|
|
else
|
|
{
|
|
/* binary */
|
|
int16 fld_count;
|
|
ListCell *cur;
|
|
|
|
cstate->cur_lineno++;
|
|
|
|
if (!CopyGetInt16(cstate, &fld_count))
|
|
{
|
|
/* EOF detected (end of file, or protocol-level EOF) */
|
|
return false;
|
|
}
|
|
|
|
if (fld_count == -1)
|
|
{
|
|
/*
|
|
* Received EOF marker. In a V3-protocol copy, wait for the
|
|
* protocol-level EOF, and complain if it doesn't come
|
|
* immediately. This ensures that we correctly handle CopyFail,
|
|
* if client chooses to send that now.
|
|
*
|
|
* Note that we MUST NOT try to read more data in an old-protocol
|
|
* copy, since there is no protocol-level EOF marker then. We
|
|
* could go either way for copy from file, but choose to throw
|
|
* error if there's data after the EOF marker, for consistency
|
|
* with the new-protocol case.
|
|
*/
|
|
char dummy;
|
|
|
|
if (cstate->copy_dest != COPY_OLD_FE &&
|
|
CopyGetData(cstate, &dummy, 1, 1) > 0)
|
|
ereport(ERROR,
|
|
(errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
|
|
errmsg("received copy data after EOF marker")));
|
|
return false;
|
|
}
|
|
|
|
if (fld_count != attr_count)
|
|
ereport(ERROR,
|
|
(errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
|
|
errmsg("row field count is %d, expected %d",
|
|
(int) fld_count, attr_count)));
|
|
|
|
if (file_has_oids)
|
|
{
|
|
Oid loaded_oid;
|
|
|
|
cstate->cur_attname = "oid";
|
|
loaded_oid =
|
|
DatumGetObjectId(CopyReadBinaryAttribute(cstate,
|
|
0,
|
|
&cstate->oid_in_function,
|
|
cstate->oid_typioparam,
|
|
-1,
|
|
&isnull));
|
|
if (isnull || loaded_oid == InvalidOid)
|
|
ereport(ERROR,
|
|
(errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
|
|
errmsg("invalid OID in COPY data")));
|
|
cstate->cur_attname = NULL;
|
|
if (cstate->oids && tupleOid != NULL)
|
|
*tupleOid = loaded_oid;
|
|
}
|
|
|
|
i = 0;
|
|
foreach(cur, cstate->attnumlist)
|
|
{
|
|
int attnum = lfirst_int(cur);
|
|
int m = attnum - 1;
|
|
|
|
cstate->cur_attname = NameStr(attr[m]->attname);
|
|
i++;
|
|
values[m] = CopyReadBinaryAttribute(cstate,
|
|
i,
|
|
&in_functions[m],
|
|
typioparams[m],
|
|
attr[m]->atttypmod,
|
|
&nulls[m]);
|
|
cstate->cur_attname = NULL;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Now compute and insert any defaults available for the columns not
|
|
* provided by the input data. Anything not processed here or above will
|
|
* remain NULL.
|
|
*/
|
|
for (i = 0; i < num_defaults; i++)
|
|
{
|
|
/*
|
|
* The caller must supply econtext and have switched into the
|
|
* per-tuple memory context in it.
|
|
*/
|
|
Assert(econtext != NULL);
|
|
Assert(CurrentMemoryContext == econtext->ecxt_per_tuple_memory);
|
|
|
|
values[defmap[i]] = ExecEvalExpr(defexprs[i], econtext,
|
|
&nulls[defmap[i]], NULL);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
* Clean up storage and release resources for COPY FROM.
|
|
*/
|
|
void
|
|
EndCopyFrom(CopyState cstate)
|
|
{
|
|
/* No COPY FROM related resources except memory. */
|
|
|
|
EndCopy(cstate);
|
|
}
|
|
|
|
/*
|
|
* Read the next input line and stash it in line_buf, with conversion to
|
|
* server encoding.
|
|
*
|
|
* Result is true if read was terminated by EOF, false if terminated
|
|
* by newline. The terminating newline or EOF marker is not included
|
|
* in the final value of line_buf.
|
|
*/
|
|
static bool
|
|
CopyReadLine(CopyState cstate)
|
|
{
|
|
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 - inner loop of CopyReadLine for text mode
|
|
*/
|
|
static bool
|
|
CopyReadLineText(CopyState cstate)
|
|
{
|
|
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 a 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;
|
|
|
|
mblen_str[0] = c;
|
|
/* All our encodings only read the first byte to get the length */
|
|
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;
|
|
}
|
|
|
|
/*
|
|
* Return decimal value for a hexadecimal digit
|
|
*/
|
|
static int
|
|
GetDecimalFromHex(char hex)
|
|
{
|
|
if (isdigit((unsigned char) hex))
|
|
return hex - '0';
|
|
else
|
|
return tolower((unsigned char) hex) - 'a' + 10;
|
|
}
|
|
|
|
/*
|
|
* Parse the current line into separate attributes (fields),
|
|
* performing de-escaping as needed.
|
|
*
|
|
* The input is in line_buf. We use attribute_buf to hold the result
|
|
* strings. cstate->raw_fields[k] is set to point to the k'th attribute
|
|
* string, or NULL when the input matches the null marker string.
|
|
* This array is expanded as necessary.
|
|
*
|
|
* (Note that the caller cannot check for nulls since the returned
|
|
* string would be the post-de-escaping equivalent, which may look
|
|
* the same as some valid data string.)
|
|
*
|
|
* delim is the column delimiter string (must be just one byte for now).
|
|
* null_print is the null marker string. Note that this is compared to
|
|
* the pre-de-escaped input string.
|
|
*
|
|
* The return value is the number of fields actually read.
|
|
*/
|
|
static int
|
|
CopyReadAttributesText(CopyState cstate)
|
|
{
|
|
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;
|
|
}
|
|
|
|
/*
|
|
* Parse the current line into separate attributes (fields),
|
|
* performing de-escaping as needed. This has exactly the same API as
|
|
* CopyReadAttributesText, except we parse the fields according to
|
|
* "standard" (i.e. common) CSV usage.
|
|
*/
|
|
static int
|
|
CopyReadAttributesCSV(CopyState cstate)
|
|
{
|
|
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;
|
|
}
|
|
|
|
|
|
/*
|
|
* Read a binary attribute
|
|
*/
|
|
static Datum
|
|
CopyReadBinaryAttribute(CopyState cstate,
|
|
int column_no, FmgrInfo *flinfo,
|
|
Oid typioparam, int32 typmod,
|
|
bool *isnull)
|
|
{
|
|
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;
|
|
}
|
|
|
|
/*
|
|
* Send text representation of one attribute, with conversion and escaping
|
|
*/
|
|
#define DUMPSOFAR() \
|
|
do { \
|
|
if (ptr > start) \
|
|
CopySendData(cstate, start, ptr - start); \
|
|
} while (0)
|
|
|
|
static void
|
|
CopyAttributeOutText(CopyState cstate, char *string)
|
|
{
|
|
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();
|
|
}
|
|
|
|
/*
|
|
* Send text representation of one attribute, with conversion and
|
|
* CSV-style escaping
|
|
*/
|
|
static void
|
|
CopyAttributeOutCSV(CopyState cstate, char *string,
|
|
bool use_quote, bool single_attr)
|
|
{
|
|
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);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* CopyGetAttnums - build an integer list of attnums to be copied
|
|
*
|
|
* The input attnamelist is either the user-specified column list,
|
|
* or NIL if there was none (in which case we want all the non-dropped
|
|
* columns).
|
|
*
|
|
* rel can be NULL ... it's only used for error reports.
|
|
*/
|
|
static List *
|
|
CopyGetAttnums(TupleDesc tupDesc, Relation rel, List *attnamelist)
|
|
{
|
|
List *attnums = NIL;
|
|
|
|
if (attnamelist == NIL)
|
|
{
|
|
/* Generate default column list */
|
|
Form_pg_attribute *attr = tupDesc->attrs;
|
|
int attr_count = tupDesc->natts;
|
|
int i;
|
|
|
|
for (i = 0; i < attr_count; i++)
|
|
{
|
|
if (attr[i]->attisdropped)
|
|
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++)
|
|
{
|
|
if (tupDesc->attrs[i]->attisdropped)
|
|
continue;
|
|
if (namestrcmp(&(tupDesc->attrs[i]->attname), name) == 0)
|
|
{
|
|
attnum = tupDesc->attrs[i]->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;
|
|
}
|
|
|
|
|
|
/*
|
|
* copy_dest_startup --- executor startup
|
|
*/
|
|
static void
|
|
copy_dest_startup(DestReceiver *self, int operation, TupleDesc typeinfo)
|
|
{
|
|
/* no-op */
|
|
}
|
|
|
|
/*
|
|
* copy_dest_receive --- receive one tuple
|
|
*/
|
|
static void
|
|
copy_dest_receive(TupleTableSlot *slot, DestReceiver *self)
|
|
{
|
|
DR_copy *myState = (DR_copy *) self;
|
|
CopyState cstate = myState->cstate;
|
|
|
|
/* Make sure the tuple is fully deconstructed */
|
|
slot_getallattrs(slot);
|
|
|
|
/* And send the data */
|
|
CopyOneRowTo(cstate, InvalidOid, slot->tts_values, slot->tts_isnull);
|
|
myState->processed++;
|
|
}
|
|
|
|
/*
|
|
* copy_dest_shutdown --- executor end
|
|
*/
|
|
static void
|
|
copy_dest_shutdown(DestReceiver *self)
|
|
{
|
|
/* no-op */
|
|
}
|
|
|
|
/*
|
|
* copy_dest_destroy --- release DestReceiver object
|
|
*/
|
|
static void
|
|
copy_dest_destroy(DestReceiver *self)
|
|
{
|
|
pfree(self);
|
|
}
|
|
|
|
/*
|
|
* CreateCopyDestReceiver -- create a suitable DestReceiver object
|
|
*/
|
|
DestReceiver *
|
|
CreateCopyDestReceiver(void)
|
|
{
|
|
DR_copy *self = (DR_copy *) palloc(sizeof(DR_copy));
|
|
|
|
self->pub.receiveSlot = copy_dest_receive;
|
|
self->pub.rStartup = copy_dest_startup;
|
|
self->pub.rShutdown = copy_dest_shutdown;
|
|
self->pub.rDestroy = copy_dest_destroy;
|
|
self->pub.mydest = DestCopyOut;
|
|
|
|
self->cstate = NULL; /* will be set later */
|
|
self->processed = 0;
|
|
|
|
return (DestReceiver *) self;
|
|
}
|