source: proto/CSV/postgres/copy.c @ 383

Last change on this file since 383 was 383, checked in by lindanl, 10 years ago

Initial prototype with bitstreams for copyreadlineText only.

File size: 106.3 KB
Line 
1/*-------------------------------------------------------------------------
2 *
3 * copy.c
4 *              Implements the COPY utility command
5 *
6 * Portions Copyright (c) 1996-2009, PostgreSQL Global Development Group
7 * Portions Copyright (c) 1994, Regents of the University of California
8 *
9 *
10 * IDENTIFICATION
11 *        $PostgreSQL: pgsql/src/backend/commands/copy.c,v 1.312 2009/06/11 14:48:55 momjian Exp $
12 *
13 *-------------------------------------------------------------------------
14 */
15 
16
17
18#include "postgres.h"
19#include <ctype.h>
20#include <unistd.h>
21#include <sys/stat.h>
22#include <netinet/in.h>
23#include <arpa/inet.h>
24
25#include "access/heapam.h"
26#include "access/xact.h"
27#include "catalog/namespace.h"
28#include "catalog/pg_type.h"
29#include "commands/copy.h"
30#include "commands/trigger.h"
31#include "executor/executor.h"
32#include "libpq/libpq.h"
33#include "libpq/pqformat.h"
34#include "mb/pg_wchar.h"
35#include "miscadmin.h"
36#include "optimizer/planner.h"
37#include "parser/parse_relation.h"
38#include "rewrite/rewriteHandler.h"
39#include "storage/fd.h"
40#include "tcop/tcopprot.h"
41#include "utils/acl.h"
42#include "utils/builtins.h"
43#include "utils/lsyscache.h"
44#include "utils/memutils.h"
45#include "utils/snapmgr.h"
46
47#include "simd_lib/lib_simd.h"
48
49#define ISOCTAL(c) (((c) >= '0') && ((c) <= '7'))
50#define OCTVALUE(c) ((c) - '0')
51
52/*
53 * Represents the different source/dest cases we need to worry about at
54 * the bottom level
55 */
56typedef enum CopyDest
57{
58        COPY_FILE,                                      /* to/from file */
59        COPY_OLD_FE,                            /* to/from frontend (2.0 protocol) */
60        COPY_NEW_FE                                     /* to/from frontend (3.0 protocol) */
61} CopyDest;
62
63/*
64 *      Represents the end-of-line terminator type of the input
65 */
66typedef enum EolType
67{
68        EOL_UNKNOWN,
69        EOL_NL,
70        EOL_CR,
71        EOL_CRNL
72} EolType;
73
74/*
75 * This struct contains all the state variables used throughout a COPY
76 * operation. For simplicity, we use the same struct for all variants of COPY,
77 * even though some fields are used in only some cases.
78 *
79 * Multi-byte encodings: all supported client-side encodings encode multi-byte
80 * characters by having the first byte's high bit set. Subsequent bytes of the
81 * character can have the high bit not set. When scanning data in such an
82 * encoding to look for a match to a single-byte (ie ASCII) character, we must
83 * use the full pg_encoding_mblen() machinery to skip over multibyte
84 * characters, else we might find a false match to a trailing byte. In
85 * supported server encodings, there is no possibility of a false match, and
86 * it's faster to make useless comparisons to trailing bytes than it is to
87 * invoke pg_encoding_mblen() to skip over them. encoding_embeds_ascii is TRUE
88 * when we have to do it the hard way.
89 */
90typedef struct CopyStateData
91{
92        /* low-level state data */
93        CopyDest        copy_dest;              /* type of copy source/destination */
94        FILE       *copy_file;          /* used if copy_dest == COPY_FILE */
95        StringInfo      fe_msgbuf;              /* used for all dests during COPY TO, only for
96                                                                 * dest == COPY_NEW_FE in COPY FROM */
97        bool            fe_copy;                /* true for all FE copy dests */
98        bool            fe_eof;                 /* true if detected end of copy data */
99        EolType         eol_type;               /* EOL type of input */
100        int                     client_encoding;        /* remote side's character encoding */
101        bool            need_transcoding;               /* client encoding diff from server? */
102        bool            encoding_embeds_ascii;  /* ASCII can be non-first byte? */
103        uint64          processed;              /* # of tuples processed */
104
105        /* parameters from the COPY command */
106        Relation        rel;                    /* relation to copy to or from */
107        QueryDesc  *queryDesc;          /* executable query to copy from */
108        List       *attnumlist;         /* integer list of attnums to copy */
109        char       *filename;           /* filename, or NULL for STDIN/STDOUT */
110        bool            binary;                 /* binary format? */
111        bool            oids;                   /* include OIDs? */
112        bool            csv_mode;               /* Comma Separated Value format? */
113        bool            header_line;    /* CSV header line? */
114        char       *null_print;         /* NULL marker string (server encoding!) */
115        int                     null_print_len; /* length of same */
116        char       *null_print_client;          /* same converted to client encoding */
117        char       *delim;                      /* column delimiter (must be 1 byte) */
118        char       *quote;                      /* CSV quote char (must be 1 byte) */
119        char       *escape;                     /* CSV escape char (must be 1 byte) */
120        bool       *force_quote_flags;          /* per-column CSV FQ flags */
121        bool       *force_notnull_flags;        /* per-column CSV FNN flags */
122       
123        /*Bit streams*/
124        SIMD_type * escape_stream;
125        SIMD_type * quote_stream;
126        SIMD_type * delim_stream;
127        SIMD_type * EOL_stream; 
128
129        /* these are just for error messages, see copy_in_error_callback */
130        const char *cur_relname;        /* table name for error messages */
131        int                     cur_lineno;             /* line number for error messages */
132        const char *cur_attname;        /* current att for error messages */
133        const char *cur_attval;         /* current att value for error messages */
134
135        /*
136         * Working state for COPY TO
137         */
138        FmgrInfo   *out_functions;      /* lookup info for output functions */
139        MemoryContext rowcontext;       /* per-row evaluation context */
140
141        /*
142         * These variables are used to reduce overhead in textual COPY FROM.
143         *
144         * attribute_buf holds the separated, de-escaped text for each field of
145         * the current line.  The CopyReadAttributes functions return arrays of
146         * pointers into this buffer.  We avoid palloc/pfree overhead by re-using
147         * the buffer on each cycle.
148         */
149        StringInfoData attribute_buf;
150
151        /*
152         * Similarly, line_buf holds the whole input line being processed. The
153         * input cycle is first to read the whole line into line_buf, convert it
154         * to server encoding there, and then extract the individual attribute
155         * fields into attribute_buf.  line_buf is preserved unmodified so that we
156         * can display it in error messages if appropriate.
157         */
158        StringInfoData line_buf;
159        bool            line_buf_converted;             /* converted to server encoding? */
160
161        /*
162         * Finally, raw_buf holds raw data read from the data source (file or
163         * client connection).  CopyReadLine parses this data sufficiently to
164         * locate line boundaries, then transfers the data to line_buf and
165         * converts it.  Note: we guarantee that there is a \0 at
166         * raw_buf[raw_buf_len].
167         */
168        #define RAW_BUF_SIZE 65536              /* we palloc RAW_BUF_SIZE+1 bytes */
169        char       *raw_buf;
170        int                     raw_buf_index;  /* next byte to process */
171        int                     raw_buf_len;    /* total # of bytes stored */
172} CopyStateData;
173
174typedef CopyStateData *CopyState;
175
176/* DestReceiver for COPY (SELECT) TO */
177typedef struct
178{
179        DestReceiver pub;                       /* publicly-known function pointers */
180        CopyState       cstate;                 /* CopyStateData for the command */
181} DR_copy;
182
183
184
185
186const int BLOCK_SIZE_BYTES = sizeof(SIMD_type);
187const int BLOCK_SIZE_BITS = sizeof(SIMD_type)*8;
188
189#include "copy_simd.c"
190
191
192/*
193 * These macros centralize code used to process line_buf and raw_buf buffers.
194 * They are macros because they often do continue/break control and to avoid
195 * function call overhead in tight COPY loops.
196 *
197 * We must use "if (1)" because the usual "do {...} while(0)" wrapper would
198 * prevent the continue/break processing from working.  We end the "if (1)"
199 * with "else ((void) 0)" to ensure the "if" does not unintentionally match
200 * any "else" in the calling code, and to avoid any compiler warnings about
201 * empty statements.  See http://www.cit.gu.edu.au/~anthony/info/C/C.macros.
202 */
203
204/*
205 * This keeps the character read at the top of the loop in the buffer
206 * even if there is more than one read-ahead.
207 */
208#define IF_NEED_REFILL_AND_NOT_EOF_CONTINUE(extralen) \
209if (1) \
210{ \
211        if (raw_buf_ptr + (extralen) >= copy_buf_len && !hit_eof) \
212        { \
213                raw_buf_ptr = prev_raw_ptr; /* undo fetch */ \
214                need_data = true; \
215                continue; \
216        } \
217} else ((void) 0)
218
219/* This consumes the remainder of the buffer and breaks */
220#define IF_NEED_REFILL_AND_EOF_BREAK(extralen) \
221if (1) \
222{ \
223        if (raw_buf_ptr + (extralen) >= copy_buf_len && hit_eof) \
224        { \
225                if (extralen) \
226                        raw_buf_ptr = copy_buf_len; /* consume the partial character */ \
227                /* backslash just before EOF, treat as data char */ \
228                result = true; \
229                break; \
230        } \
231} else ((void) 0)
232
233/*
234 * Transfer any approved data to line_buf; must do this to be sure
235 * there is some room in raw_buf.
236 */
237#define REFILL_LINEBUF \
238if (1) \
239{ \
240        if (raw_buf_ptr > cstate->raw_buf_index) \
241        { \
242                appendBinaryStringInfo(&cstate->line_buf, \
243                                                         cstate->raw_buf + cstate->raw_buf_index, \
244                                                           raw_buf_ptr - cstate->raw_buf_index); \
245                cstate->raw_buf_index = raw_buf_ptr; \
246        } \
247} else ((void) 0)
248
249/* Undo any read-ahead and jump out of the block. */
250#define NO_END_OF_COPY_GOTO \
251if (1) \
252{ \
253        raw_buf_ptr = prev_raw_ptr + 1; \
254        goto not_end_of_copy; \
255} else ((void) 0)
256
257static const char BinarySignature[11] = "PGCOPY\n\377\r\n\0";
258
259
260/* non-export function prototypes */
261static void DoCopyTo(CopyState cstate);
262static void CopyTo(CopyState cstate);
263static void CopyOneRowTo(CopyState cstate, Oid tupleOid,
264                         Datum *values, bool *nulls);
265static void CopyFrom(CopyState cstate);
266static bool CopyReadLine(CopyState cstate);
267static bool CopyReadLineText(CopyState cstate);
268static int CopyReadAttributesText(CopyState cstate, int maxfields,
269                                           char **fieldvals);
270static int CopyReadAttributesCSV(CopyState cstate, int maxfields,
271                                          char **fieldvals);
272static Datum CopyReadBinaryAttribute(CopyState cstate,
273                                                int column_no, FmgrInfo *flinfo,
274                                                Oid typioparam, int32 typmod,
275                                                bool *isnull);
276static void CopyAttributeOutText(CopyState cstate, char *string);
277static void CopyAttributeOutCSV(CopyState cstate, char *string,
278                                        bool use_quote, bool single_attr);
279static List *CopyGetAttnums(TupleDesc tupDesc, Relation rel,
280                           List *attnamelist);
281static char *limit_printout_length(const char *str);
282
283/* Low-level communications functions */
284static void SendCopyBegin(CopyState cstate);
285static void ReceiveCopyBegin(CopyState cstate);
286static void SendCopyEnd(CopyState cstate);
287static void CopySendData(CopyState cstate, void *databuf, int datasize);
288static void CopySendString(CopyState cstate, const char *str);
289static void CopySendChar(CopyState cstate, char c);
290static void CopySendEndOfRow(CopyState cstate);
291static int CopyGetData(CopyState cstate, void *databuf,
292                        int minread, int maxread);
293static void CopySendInt32(CopyState cstate, int32 val);
294static bool CopyGetInt32(CopyState cstate, int32 *val);
295static void CopySendInt16(CopyState cstate, int16 val);
296static bool CopyGetInt16(CopyState cstate, int16 *val);
297
298/*
299 * Send copy start/stop messages for frontend copies.  These have changed
300 * in past protocol redesigns.
301 */
302static void
303SendCopyBegin(CopyState cstate)
304{
305        if (PG_PROTOCOL_MAJOR(FrontendProtocol) >= 3)
306        {
307                /* new way */
308                StringInfoData buf;
309                int                     natts = list_length(cstate->attnumlist);
310                int16           format = (cstate->binary ? 1 : 0);
311                int                     i;
312
313                pq_beginmessage(&buf, 'H');
314                pq_sendbyte(&buf, format);              /* overall format */
315                pq_sendint(&buf, natts, 2);
316                for (i = 0; i < natts; i++)
317                        pq_sendint(&buf, format, 2);            /* per-column formats */
318                pq_endmessage(&buf);
319                cstate->copy_dest = COPY_NEW_FE;
320        }
321        else if (PG_PROTOCOL_MAJOR(FrontendProtocol) >= 2)
322        {
323                /* old way */
324                if (cstate->binary)
325                        ereport(ERROR,
326                                        (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
327                        errmsg("COPY BINARY is not supported to stdout or from stdin")));
328                pq_putemptymessage('H');
329                /* grottiness needed for old COPY OUT protocol */
330                pq_startcopyout();
331                cstate->copy_dest = COPY_OLD_FE;
332        }
333        else
334        {
335                /* very old way */
336                if (cstate->binary)
337                        ereport(ERROR,
338                                        (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
339                        errmsg("COPY BINARY is not supported to stdout or from stdin")));
340                pq_putemptymessage('B');
341                /* grottiness needed for old COPY OUT protocol */
342                pq_startcopyout();
343                cstate->copy_dest = COPY_OLD_FE;
344        }
345}
346
347static void
348ReceiveCopyBegin(CopyState cstate)
349{
350        if (PG_PROTOCOL_MAJOR(FrontendProtocol) >= 3)
351        {
352                /* new way */
353                StringInfoData buf;
354                int                     natts = list_length(cstate->attnumlist);
355                int16           format = (cstate->binary ? 1 : 0);
356                int                     i;
357
358                pq_beginmessage(&buf, 'G');
359                pq_sendbyte(&buf, format);              /* overall format */
360                pq_sendint(&buf, natts, 2);
361                for (i = 0; i < natts; i++)
362                        pq_sendint(&buf, format, 2);            /* per-column formats */
363                pq_endmessage(&buf);
364                cstate->copy_dest = COPY_NEW_FE;
365                cstate->fe_msgbuf = makeStringInfo();
366        }
367        else if (PG_PROTOCOL_MAJOR(FrontendProtocol) >= 2)
368        {
369                /* old way */
370                if (cstate->binary)
371                        ereport(ERROR,
372                                        (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
373                        errmsg("COPY BINARY is not supported to stdout or from stdin")));
374                pq_putemptymessage('G');
375                cstate->copy_dest = COPY_OLD_FE;
376        }
377        else
378        {
379                /* very old way */
380                if (cstate->binary)
381                        ereport(ERROR,
382                                        (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
383                        errmsg("COPY BINARY is not supported to stdout or from stdin")));
384                pq_putemptymessage('D');
385                cstate->copy_dest = COPY_OLD_FE;
386        }
387        /* We *must* flush here to ensure FE knows it can send. */
388        pq_flush();
389}
390
391static void
392SendCopyEnd(CopyState cstate)
393{
394        if (cstate->copy_dest == COPY_NEW_FE)
395        {
396                /* Shouldn't have any unsent data */
397                Assert(cstate->fe_msgbuf->len == 0);
398                /* Send Copy Done message */
399                pq_putemptymessage('c');
400        }
401        else
402        {
403                CopySendData(cstate, "\\.", 2);
404                /* Need to flush out the trailer (this also appends a newline) */
405                CopySendEndOfRow(cstate);
406                pq_endcopyout(false);
407        }
408}
409
410/*----------
411 * CopySendData sends output data to the destination (file or frontend)
412 * CopySendString does the same for null-terminated strings
413 * CopySendChar does the same for single characters
414 * CopySendEndOfRow does the appropriate thing at end of each data row
415 *      (data is not actually flushed except by CopySendEndOfRow)
416 *
417 * NB: no data conversion is applied by these functions
418 *----------
419 */
420static void
421CopySendData(CopyState cstate, void *databuf, int datasize)
422{
423        appendBinaryStringInfo(cstate->fe_msgbuf, (char *) databuf, datasize);
424}
425
426static void
427CopySendString(CopyState cstate, const char *str)
428{
429        appendBinaryStringInfo(cstate->fe_msgbuf, str, strlen(str));
430}
431
432static void
433CopySendChar(CopyState cstate, char c)
434{
435        appendStringInfoCharMacro(cstate->fe_msgbuf, c);
436}
437
438static void
439CopySendEndOfRow(CopyState cstate)
440{
441        StringInfo      fe_msgbuf = cstate->fe_msgbuf;
442
443        switch (cstate->copy_dest)
444        {
445                case COPY_FILE:
446                        if (!cstate->binary)
447                        {
448                                /* Default line termination depends on platform */
449#ifndef WIN32
450                                CopySendChar(cstate, '\n');
451#else
452                                CopySendString(cstate, "\r\n");
453#endif
454                        }
455
456                        (void) fwrite(fe_msgbuf->data, fe_msgbuf->len,
457                                                  1, cstate->copy_file);
458                        if (ferror(cstate->copy_file))
459                                ereport(ERROR,
460                                                (errcode_for_file_access(),
461                                                 errmsg("could not write to COPY file: %m")));
462                        break;
463                case COPY_OLD_FE:
464                        /* The FE/BE protocol uses \n as newline for all platforms */
465                        if (!cstate->binary)
466                                CopySendChar(cstate, '\n');
467
468                        if (pq_putbytes(fe_msgbuf->data, fe_msgbuf->len))
469                        {
470                                /* no hope of recovering connection sync, so FATAL */
471                                ereport(FATAL,
472                                                (errcode(ERRCODE_CONNECTION_FAILURE),
473                                                 errmsg("connection lost during COPY to stdout")));
474                        }
475                        break;
476                case COPY_NEW_FE:
477                        /* The FE/BE protocol uses \n as newline for all platforms */
478                        if (!cstate->binary)
479                                CopySendChar(cstate, '\n');
480
481                        /* Dump the accumulated row as one CopyData message */
482                        (void) pq_putmessage('d', fe_msgbuf->data, fe_msgbuf->len);
483                        break;
484        }
485
486        resetStringInfo(fe_msgbuf);
487}
488
489/*
490 * CopyGetData reads data from the source (file or frontend)
491 *
492 * We attempt to read at least minread, and at most maxread, bytes from
493 * the source.  The actual number of bytes read is returned; if this is
494 * less than minread, EOF was detected.
495 *
496 * Note: when copying from the frontend, we expect a proper EOF mark per
497 * protocol; if the frontend simply drops the connection, we raise error.
498 * It seems unwise to allow the COPY IN to complete normally in that case.
499 *
500 * NB: no data conversion is applied here.
501 */
502static int
503CopyGetData(CopyState cstate, void *databuf, int minread, int maxread)
504{
505        int                     bytesread = 0;
506
507        switch (cstate->copy_dest)
508        {
509                case COPY_FILE:
510                        bytesread = fread(databuf, 1, maxread, cstate->copy_file);
511                        if (ferror(cstate->copy_file))
512                                ereport(ERROR,
513                                                (errcode_for_file_access(),
514                                                 errmsg("could not read from COPY file: %m")));
515                        break;
516                case COPY_OLD_FE:
517
518                        /*
519                         * We cannot read more than minread bytes (which in practice is 1)
520                         * because old protocol doesn't have any clear way of separating
521                         * the COPY stream from following data.  This is slow, but not any
522                         * slower than the code path was originally, and we don't care
523                         * much anymore about the performance of old protocol.
524                         */
525                        if (pq_getbytes((char *) databuf, minread))
526                        {
527                                /* Only a \. terminator is legal EOF in old protocol */
528                                ereport(ERROR,
529                                                (errcode(ERRCODE_CONNECTION_FAILURE),
530                                                 errmsg("unexpected EOF on client connection")));
531                        }
532                        bytesread = minread;
533                        break;
534                case COPY_NEW_FE:
535                        while (maxread > 0 && bytesread < minread && !cstate->fe_eof)
536                        {
537                                int                     avail;
538
539                                while (cstate->fe_msgbuf->cursor >= cstate->fe_msgbuf->len)
540                                {
541                                        /* Try to receive another message */
542                                        int                     mtype;
543
544                        readmessage:
545                                        mtype = pq_getbyte();
546                                        if (mtype == EOF)
547                                                ereport(ERROR,
548                                                                (errcode(ERRCODE_CONNECTION_FAILURE),
549                                                         errmsg("unexpected EOF on client connection")));
550                                        if (pq_getmessage(cstate->fe_msgbuf, 0))
551                                                ereport(ERROR,
552                                                                (errcode(ERRCODE_CONNECTION_FAILURE),
553                                                         errmsg("unexpected EOF on client connection")));
554                                        switch (mtype)
555                                        {
556                                                case 'd':               /* CopyData */
557                                                        break;
558                                                case 'c':               /* CopyDone */
559                                                        /* COPY IN correctly terminated by frontend */
560                                                        cstate->fe_eof = true;
561                                                        return bytesread;
562                                                case 'f':               /* CopyFail */
563                                                        ereport(ERROR,
564                                                                        (errcode(ERRCODE_QUERY_CANCELED),
565                                                                         errmsg("COPY from stdin failed: %s",
566                                                                           pq_getmsgstring(cstate->fe_msgbuf))));
567                                                        break;
568                                                case 'H':               /* Flush */
569                                                case 'S':               /* Sync */
570
571                                                        /*
572                                                         * Ignore Flush/Sync for the convenience of client
573                                                         * libraries (such as libpq) that may send those
574                                                         * without noticing that the command they just
575                                                         * sent was COPY.
576                                                         */
577                                                        goto readmessage;
578                                                default:
579                                                        ereport(ERROR,
580                                                                        (errcode(ERRCODE_PROTOCOL_VIOLATION),
581                                                                         errmsg("unexpected message type 0x%02X during COPY from stdin",
582                                                                                        mtype)));
583                                                        break;
584                                        }
585                                }
586                                avail = cstate->fe_msgbuf->len - cstate->fe_msgbuf->cursor;
587                                if (avail > maxread)
588                                        avail = maxread;
589                                pq_copymsgbytes(cstate->fe_msgbuf, databuf, avail);
590                                databuf = (void *) ((char *) databuf + avail);
591                                maxread -= avail;
592                                bytesread += avail;
593                        }
594                        break;
595        }
596
597        return bytesread;
598}
599
600
601/*
602 * These functions do apply some data conversion
603 */
604
605/*
606 * CopySendInt32 sends an int32 in network byte order
607 */
608static void
609CopySendInt32(CopyState cstate, int32 val)
610{
611        uint32          buf;
612
613        buf = htonl((uint32) val);
614        CopySendData(cstate, &buf, sizeof(buf));
615}
616
617/*
618 * CopyGetInt32 reads an int32 that appears in network byte order
619 *
620 * Returns true if OK, false if EOF
621 */
622static bool
623CopyGetInt32(CopyState cstate, int32 *val)
624{
625        uint32          buf;
626
627        if (CopyGetData(cstate, &buf, sizeof(buf), sizeof(buf)) != sizeof(buf))
628        {
629                *val = 0;                               /* suppress compiler warning */
630                return false;
631        }
632        *val = (int32) ntohl(buf);
633        return true;
634}
635
636/*
637 * CopySendInt16 sends an int16 in network byte order
638 */
639static void
640CopySendInt16(CopyState cstate, int16 val)
641{
642        uint16          buf;
643
644        buf = htons((uint16) val);
645        CopySendData(cstate, &buf, sizeof(buf));
646}
647
648/*
649 * CopyGetInt16 reads an int16 that appears in network byte order
650 */
651static bool
652CopyGetInt16(CopyState cstate, int16 *val)
653{
654        uint16          buf;
655
656        if (CopyGetData(cstate, &buf, sizeof(buf), sizeof(buf)) != sizeof(buf))
657        {
658                *val = 0;                               /* suppress compiler warning */
659                return false;
660        }
661        *val = (int16) ntohs(buf);
662        return true;
663}
664
665
666/*
667 * CopyLoadRawBuf loads some more data into raw_buf
668 *
669 * Returns TRUE if able to obtain at least one more byte, else FALSE.
670 *
671 * If raw_buf_index < raw_buf_len, the unprocessed bytes are transferred
672 * down to the start of the buffer and then we load more data after that.
673 * This case is used only when a frontend multibyte character crosses a
674 * bufferload boundary.
675 */
676static bool
677CopyLoadRawBuf(CopyState cstate)
678{
679        int                     nbytes;
680        int                     inbytes;
681
682        if (cstate->raw_buf_index < cstate->raw_buf_len)
683        {
684                /* Copy down the unprocessed data */
685                nbytes = cstate->raw_buf_len - cstate->raw_buf_index;
686                memmove(cstate->raw_buf, cstate->raw_buf + cstate->raw_buf_index,
687                                nbytes);
688        }
689        else
690                nbytes = 0;                             /* no data need be saved */
691
692        inbytes = CopyGetData(cstate, cstate->raw_buf + nbytes,
693                                                  1, RAW_BUF_SIZE - nbytes);
694        nbytes += inbytes;
695        cstate->raw_buf[nbytes] = '\0';
696        cstate->raw_buf_index = 0;
697        cstate->raw_buf_len = nbytes;
698//      bitstream_gen(cstate);
699                       
700        return (inbytes > 0);
701}
702
703/*
704 *       DoCopy executes the SQL COPY statement
705 *
706 * Either unload or reload contents of table <relation>, depending on <from>.
707 * (<from> = TRUE means we are inserting into the table.)  In the "TO" case
708 * we also support copying the output of an arbitrary SELECT query.
709 *
710 * If <pipe> is false, transfer is between the table and the file named
711 * <filename>.  Otherwise, transfer is between the table and our regular
712 * input/output stream. The latter could be either stdin/stdout or a
713 * socket, depending on whether we're running under Postmaster control.
714 *
715 * Iff <binary>, unload or reload in the binary format, as opposed to the
716 * more wasteful but more robust and portable text format.
717 *
718 * Iff <oids>, unload or reload the format that includes OID information.
719 * On input, we accept OIDs whether or not the table has an OID column,
720 * but silently drop them if it does not.  On output, we report an error
721 * if the user asks for OIDs in a table that has none (not providing an
722 * OID column might seem friendlier, but could seriously confuse programs).
723 *
724 * If in the text format, delimit columns with delimiter <delim> and print
725 * NULL values as <null_print>.
726 *
727 * Do not allow a Postgres user without superuser privilege to read from
728 * or write to a file.
729 *
730 * Do not allow the copy if user doesn't have proper permission to access
731 * the table or the specifically requested columns.
732 */
733uint64
734DoCopy(const CopyStmt *stmt, const char *queryString)
735{
736        CopyState       cstate;
737        bool            is_from = stmt->is_from;
738        bool            pipe = (stmt->filename == NULL);
739        List       *attnamelist = stmt->attlist;
740        List       *force_quote = NIL;
741        List       *force_notnull = NIL;
742        AclMode         required_access = (is_from ? ACL_INSERT : ACL_SELECT);
743        AclMode         relPerms;
744        AclMode         remainingPerms;
745        ListCell   *option;
746        TupleDesc       tupDesc;
747        int                     num_phys_attrs;
748        uint64          processed;
749
750        /* Allocate workspace and zero all fields */
751        cstate = (CopyStateData *) palloc0(sizeof(CopyStateData));
752
753        /* Extract options from the statement node tree */
754        foreach(option, stmt->options)
755        {
756                DefElem    *defel = (DefElem *) lfirst(option);
757
758                if (strcmp(defel->defname, "binary") == 0)
759                {
760                        if (cstate->binary)
761                                ereport(ERROR,
762                                                (errcode(ERRCODE_SYNTAX_ERROR),
763                                                 errmsg("conflicting or redundant options")));
764                        cstate->binary = intVal(defel->arg);
765                }
766                else if (strcmp(defel->defname, "oids") == 0)
767                {
768                        if (cstate->oids)
769                                ereport(ERROR,
770                                                (errcode(ERRCODE_SYNTAX_ERROR),
771                                                 errmsg("conflicting or redundant options")));
772                        cstate->oids = intVal(defel->arg);
773                }
774                else if (strcmp(defel->defname, "delimiter") == 0)
775                {
776                        if (cstate->delim)
777                                ereport(ERROR,
778                                                (errcode(ERRCODE_SYNTAX_ERROR),
779                                                 errmsg("conflicting or redundant options")));
780                        cstate->delim = strVal(defel->arg);
781                }
782                else if (strcmp(defel->defname, "null") == 0)
783                {
784                        if (cstate->null_print)
785                                ereport(ERROR,
786                                                (errcode(ERRCODE_SYNTAX_ERROR),
787                                                 errmsg("conflicting or redundant options")));
788                        cstate->null_print = strVal(defel->arg);
789                }
790                else if (strcmp(defel->defname, "csv") == 0)
791                {
792                        if (cstate->csv_mode)
793                                ereport(ERROR,
794                                                (errcode(ERRCODE_SYNTAX_ERROR),
795                                                 errmsg("conflicting or redundant options")));
796                        cstate->csv_mode = intVal(defel->arg);
797                }
798                else if (strcmp(defel->defname, "header") == 0)
799                {
800                        if (cstate->header_line)
801                                ereport(ERROR,
802                                                (errcode(ERRCODE_SYNTAX_ERROR),
803                                                 errmsg("conflicting or redundant options")));
804                        cstate->header_line = intVal(defel->arg);
805                }
806                else if (strcmp(defel->defname, "quote") == 0)
807                {
808                        if (cstate->quote)
809                                ereport(ERROR,
810                                                (errcode(ERRCODE_SYNTAX_ERROR),
811                                                 errmsg("conflicting or redundant options")));
812                        cstate->quote = strVal(defel->arg);
813                }
814                else if (strcmp(defel->defname, "escape") == 0)
815                {
816                        if (cstate->escape)
817                                ereport(ERROR,
818                                                (errcode(ERRCODE_SYNTAX_ERROR),
819                                                 errmsg("conflicting or redundant options")));
820                        cstate->escape = strVal(defel->arg);
821                }
822                else if (strcmp(defel->defname, "force_quote") == 0)
823                {
824                        if (force_quote)
825                                ereport(ERROR,
826                                                (errcode(ERRCODE_SYNTAX_ERROR),
827                                                 errmsg("conflicting or redundant options")));
828                        force_quote = (List *) defel->arg;
829                }
830                else if (strcmp(defel->defname, "force_notnull") == 0)
831                {
832                        if (force_notnull)
833                                ereport(ERROR,
834                                                (errcode(ERRCODE_SYNTAX_ERROR),
835                                                 errmsg("conflicting or redundant options")));
836                        force_notnull = (List *) defel->arg;
837                }
838                else
839                        elog(ERROR, "option \"%s\" not recognized",
840                                 defel->defname);
841        }
842
843        /* Check for incompatible options */
844        if (cstate->binary && cstate->delim)
845                ereport(ERROR,
846                                (errcode(ERRCODE_SYNTAX_ERROR),
847                                 errmsg("cannot specify DELIMITER in BINARY mode")));
848
849        if (cstate->binary && cstate->csv_mode)
850                ereport(ERROR,
851                                (errcode(ERRCODE_SYNTAX_ERROR),
852                                 errmsg("cannot specify CSV in BINARY mode")));
853
854        if (cstate->binary && cstate->null_print)
855                ereport(ERROR,
856                                (errcode(ERRCODE_SYNTAX_ERROR),
857                                 errmsg("cannot specify NULL in BINARY mode")));
858
859        /* Set defaults for omitted options */
860        if (!cstate->delim)
861                cstate->delim = cstate->csv_mode ? "," : "\t";
862
863        if (!cstate->null_print)
864                cstate->null_print = cstate->csv_mode ? "" : "\\N";
865        cstate->null_print_len = strlen(cstate->null_print);
866
867        if (cstate->csv_mode)
868        {
869                if (!cstate->quote)
870                        cstate->quote = "\"";
871                if (!cstate->escape)
872                        cstate->escape = cstate->quote;
873        }
874
875        /* Only single-byte delimiter strings are supported. */
876        if (strlen(cstate->delim) != 1)
877                ereport(ERROR,
878                                (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
879                          errmsg("COPY delimiter must be a single one-byte character")));
880
881        /* Disallow end-of-line characters */
882        if (strchr(cstate->delim, '\r') != NULL ||
883                strchr(cstate->delim, '\n') != NULL)
884                ereport(ERROR,
885                                (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
886                         errmsg("COPY delimiter cannot be newline or carriage return")));
887
888        if (strchr(cstate->null_print, '\r') != NULL ||
889                strchr(cstate->null_print, '\n') != NULL)
890                ereport(ERROR,
891                                (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
892                                 errmsg("COPY null representation cannot use newline or carriage return")));
893
894        /*
895         * Disallow unsafe delimiter characters in non-CSV mode.  We can't allow
896         * backslash because it would be ambiguous.  We can't allow the other
897         * cases because data characters matching the delimiter must be
898         * backslashed, and certain backslash combinations are interpreted
899         * non-literally by COPY IN.  Disallowing all lower case ASCII letters is
900         * more than strictly necessary, but seems best for consistency and
901         * future-proofing.  Likewise we disallow all digits though only octal
902         * digits are actually dangerous.
903         */
904        if (!cstate->csv_mode &&
905                strchr("\\.abcdefghijklmnopqrstuvwxyz0123456789",
906                           cstate->delim[0]) != NULL)
907                ereport(ERROR,
908                                (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
909                                 errmsg("COPY delimiter cannot be \"%s\"", cstate->delim)));
910
911        /* Check header */
912        if (!cstate->csv_mode && cstate->header_line)
913                ereport(ERROR,
914                                (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
915                                 errmsg("COPY HEADER available only in CSV mode")));
916
917        /* Check quote */
918        if (!cstate->csv_mode && cstate->quote != NULL)
919                ereport(ERROR,
920                                (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
921                                 errmsg("COPY quote available only in CSV mode")));
922
923        if (cstate->csv_mode && strlen(cstate->quote) != 1)
924                ereport(ERROR,
925                                (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
926                                 errmsg("COPY quote must be a single one-byte character")));
927
928        if (cstate->csv_mode && cstate->delim[0] == cstate->quote[0])
929                ereport(ERROR,
930                                (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
931                                 errmsg("COPY delimiter and quote must be different")));
932
933        /* Check escape */
934        if (!cstate->csv_mode && cstate->escape != NULL)
935                ereport(ERROR,
936                                (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
937                                 errmsg("COPY escape available only in CSV mode")));
938
939        if (cstate->csv_mode && strlen(cstate->escape) != 1)
940                ereport(ERROR,
941                                (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
942                                 errmsg("COPY escape must be a single one-byte character")));
943
944        /* Check force_quote */
945        if (!cstate->csv_mode && force_quote != NIL)
946                ereport(ERROR,
947                                (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
948                                 errmsg("COPY force quote available only in CSV mode")));
949        if (force_quote != NIL && is_from)
950                ereport(ERROR,
951                                (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
952                                 errmsg("COPY force quote only available using COPY TO")));
953
954        /* Check force_notnull */
955        if (!cstate->csv_mode && force_notnull != NIL)
956                ereport(ERROR,
957                                (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
958                                 errmsg("COPY force not null available only in CSV mode")));
959        if (force_notnull != NIL && !is_from)
960                ereport(ERROR,
961                                (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
962                          errmsg("COPY force not null only available using COPY FROM")));
963
964        /* Don't allow the delimiter to appear in the null string. */
965        if (strchr(cstate->null_print, cstate->delim[0]) != NULL)
966                ereport(ERROR,
967                                (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
968                errmsg("COPY delimiter must not appear in the NULL specification")));
969
970        /* Don't allow the CSV quote char to appear in the null string. */
971        if (cstate->csv_mode &&
972                strchr(cstate->null_print, cstate->quote[0]) != NULL)
973                ereport(ERROR,
974                                (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
975                                 errmsg("CSV quote character must not appear in the NULL specification")));
976
977        /* Disallow file COPY except to superusers. */
978        if (!pipe && !superuser())
979                ereport(ERROR,
980                                (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
981                                 errmsg("must be superuser to COPY to or from a file"),
982                                 errhint("Anyone can COPY to stdout or from stdin. "
983                                                 "psql's \\copy command also works for anyone.")));
984
985        if (stmt->relation)
986        {
987                Assert(!stmt->query);
988                cstate->queryDesc = NULL;
989
990                /* Open and lock the relation, using the appropriate lock type. */
991                cstate->rel = heap_openrv(stmt->relation,
992                                                         (is_from ? RowExclusiveLock : AccessShareLock));
993
994                tupDesc = RelationGetDescr(cstate->rel);
995
996                /* Check relation permissions. */
997                relPerms = pg_class_aclmask(RelationGetRelid(cstate->rel), GetUserId(),
998                                                                        required_access, ACLMASK_ALL);
999                remainingPerms = required_access & ~relPerms;
1000                if (remainingPerms != 0)
1001                {
1002                        /* We don't have table permissions, check per-column permissions */
1003                        List       *attnums;
1004                        ListCell   *cur;
1005
1006                        attnums = CopyGetAttnums(tupDesc, cstate->rel, attnamelist);
1007                        foreach(cur, attnums)
1008                        {
1009                                int                     attnum = lfirst_int(cur);
1010
1011                                if (pg_attribute_aclcheck(RelationGetRelid(cstate->rel),
1012                                                                                  attnum,
1013                                                                                  GetUserId(),
1014                                                                                  remainingPerms) != ACLCHECK_OK)
1015                                        aclcheck_error(ACLCHECK_NO_PRIV, ACL_KIND_CLASS,
1016                                                                   RelationGetRelationName(cstate->rel));
1017                        }
1018                }
1019
1020                /* check read-only transaction */
1021                if (XactReadOnly && is_from && !cstate->rel->rd_islocaltemp)
1022                        ereport(ERROR,
1023                                        (errcode(ERRCODE_READ_ONLY_SQL_TRANSACTION),
1024                                         errmsg("transaction is read-only")));
1025
1026                /* Don't allow COPY w/ OIDs to or from a table without them */
1027                if (cstate->oids && !cstate->rel->rd_rel->relhasoids)
1028                        ereport(ERROR,
1029                                        (errcode(ERRCODE_UNDEFINED_COLUMN),
1030                                         errmsg("table \"%s\" does not have OIDs",
1031                                                        RelationGetRelationName(cstate->rel))));
1032        }
1033        else
1034        {
1035                List       *rewritten;
1036                Query      *query;
1037                PlannedStmt *plan;
1038                DestReceiver *dest;
1039
1040                Assert(!is_from);
1041                cstate->rel = NULL;
1042
1043                /* Don't allow COPY w/ OIDs from a select */
1044                if (cstate->oids)
1045                        ereport(ERROR,
1046                                        (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
1047                                         errmsg("COPY (SELECT) WITH OIDS is not supported")));
1048
1049                /*
1050                 * Run parse analysis and rewrite.      Note this also acquires sufficient
1051                 * locks on the source table(s).
1052                 *
1053                 * Because the parser and planner tend to scribble on their input, we
1054                 * make a preliminary copy of the source querytree.  This prevents
1055                 * problems in the case that the COPY is in a portal or plpgsql
1056                 * function and is executed repeatedly.  (See also the same hack in
1057                 * DECLARE CURSOR and PREPARE.)  XXX FIXME someday.
1058                 */
1059                rewritten = pg_analyze_and_rewrite((Node *) copyObject(stmt->query),
1060                                                                                   queryString, NULL, 0);
1061
1062                /* We don't expect more or less than one result query */
1063                if (list_length(rewritten) != 1)
1064                        elog(ERROR, "unexpected rewrite result");
1065
1066                query = (Query *) linitial(rewritten);
1067                Assert(query->commandType == CMD_SELECT);
1068                Assert(query->utilityStmt == NULL);
1069
1070                /* Query mustn't use INTO, either */
1071                if (query->intoClause)
1072                        ereport(ERROR,
1073                                        (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
1074                                         errmsg("COPY (SELECT INTO) is not supported")));
1075
1076                /* plan the query */
1077                plan = planner(query, 0, NULL);
1078
1079                /*
1080                 * Use a snapshot with an updated command ID to ensure this query sees
1081                 * results of any previously executed queries.
1082                 */
1083                PushUpdatedSnapshot(GetActiveSnapshot());
1084
1085                /* Create dest receiver for COPY OUT */
1086                dest = CreateDestReceiver(DestCopyOut);
1087                ((DR_copy *) dest)->cstate = cstate;
1088
1089                /* Create a QueryDesc requesting no output */
1090                cstate->queryDesc = CreateQueryDesc(plan, queryString,
1091                                                                                        GetActiveSnapshot(),
1092                                                                                        InvalidSnapshot,
1093                                                                                        dest, NULL, false);
1094
1095                /*
1096                 * Call ExecutorStart to prepare the plan for execution.
1097                 *
1098                 * ExecutorStart computes a result tupdesc for us
1099                 */
1100                ExecutorStart(cstate->queryDesc, 0);
1101
1102                tupDesc = cstate->queryDesc->tupDesc;
1103        }
1104
1105        /* Generate or convert list of attributes to process */
1106        cstate->attnumlist = CopyGetAttnums(tupDesc, cstate->rel, attnamelist);
1107
1108        num_phys_attrs = tupDesc->natts;
1109
1110        /* Convert FORCE QUOTE name list to per-column flags, check validity */
1111        cstate->force_quote_flags = (bool *) palloc0(num_phys_attrs * sizeof(bool));
1112        if (force_quote)
1113        {
1114                List       *attnums;
1115                ListCell   *cur;
1116
1117                attnums = CopyGetAttnums(tupDesc, cstate->rel, force_quote);
1118
1119                foreach(cur, attnums)
1120                {
1121                        int                     attnum = lfirst_int(cur);
1122
1123                        if (!list_member_int(cstate->attnumlist, attnum))
1124                                ereport(ERROR,
1125                                                (errcode(ERRCODE_INVALID_COLUMN_REFERENCE),
1126                                   errmsg("FORCE QUOTE column \"%s\" not referenced by COPY",
1127                                                  NameStr(tupDesc->attrs[attnum - 1]->attname))));
1128                        cstate->force_quote_flags[attnum - 1] = true;
1129                }
1130        }
1131
1132        /* Convert FORCE NOT NULL name list to per-column flags, check validity */
1133        cstate->force_notnull_flags = (bool *) palloc0(num_phys_attrs * sizeof(bool));
1134        if (force_notnull)
1135        {
1136                List       *attnums;
1137                ListCell   *cur;
1138
1139                attnums = CopyGetAttnums(tupDesc, cstate->rel, force_notnull);
1140
1141                foreach(cur, attnums)
1142                {
1143                        int                     attnum = lfirst_int(cur);
1144
1145                        if (!list_member_int(cstate->attnumlist, attnum))
1146                                ereport(ERROR,
1147                                                (errcode(ERRCODE_INVALID_COLUMN_REFERENCE),
1148                                errmsg("FORCE NOT NULL column \"%s\" not referenced by COPY",
1149                                           NameStr(tupDesc->attrs[attnum - 1]->attname))));
1150                        cstate->force_notnull_flags[attnum - 1] = true;
1151                }
1152        }
1153
1154        /* Set up variables to avoid per-attribute overhead. */
1155        initStringInfo(&cstate->attribute_buf);
1156        initStringInfo(&cstate->line_buf);
1157        cstate->line_buf_converted = false;
1158//      cstate->raw_buf = (char *) palloc(RAW_BUF_SIZE + 1);
1159        cstate->raw_buf = (char *) ((((int) palloc(RAW_BUF_SIZE + 16)) + 15) &~ 0xF);
1160        cstate->raw_buf_index = cstate->raw_buf_len = 0;
1161        cstate->processed = 0;
1162       
1163        /*Initialize bit stream buffers*/
1164        cstate->escape_stream = simd_new(RAW_BUF_SIZE/BLOCK_SIZE_BYTES+1);
1165        cstate->quote_stream = simd_new(RAW_BUF_SIZE/BLOCK_SIZE_BYTES+1);
1166        cstate->delim_stream = simd_new(RAW_BUF_SIZE/BLOCK_SIZE_BYTES+1);
1167        cstate->EOL_stream = simd_new(RAW_BUF_SIZE/BLOCK_SIZE_BYTES+1);
1168        /*
1169         * Set up encoding conversion info.  Even if the client and server
1170         * encodings are the same, we must apply pg_client_to_server() to validate
1171         * data in multibyte encodings.
1172         */
1173        cstate->client_encoding = pg_get_client_encoding();
1174        cstate->need_transcoding =
1175                (cstate->client_encoding != GetDatabaseEncoding() ||
1176                 pg_database_encoding_max_length() > 1);
1177        /* See Multibyte encoding comment above */
1178        cstate->encoding_embeds_ascii = PG_ENCODING_IS_CLIENT_ONLY(cstate->client_encoding);
1179
1180        cstate->copy_dest = COPY_FILE;          /* default */
1181        cstate->filename = stmt->filename;
1182
1183        if (is_from)
1184                CopyFrom(cstate);               /* copy from file to database */
1185        else
1186                DoCopyTo(cstate);               /* copy from database to file */
1187
1188        /*
1189         * Close the relation or query.  If reading, we can release the
1190         * AccessShareLock we got; if writing, we should hold the lock until end
1191         * of transaction to ensure that updates will be committed before lock is
1192         * released.
1193         */
1194        if (cstate->rel)
1195                heap_close(cstate->rel, (is_from ? NoLock : AccessShareLock));
1196        else
1197        {
1198                /* Close down the query and free resources. */
1199                ExecutorEnd(cstate->queryDesc);
1200                FreeQueryDesc(cstate->queryDesc);
1201                PopActiveSnapshot();
1202        }
1203
1204        /* Clean up storage (probably not really necessary) */
1205        processed = cstate->processed;
1206
1207        pfree(cstate->attribute_buf.data);
1208        pfree(cstate->line_buf.data);
1209        pfree(cstate->raw_buf);
1210        pfree(cstate);
1211
1212        return processed;
1213}
1214
1215
1216/*
1217 * This intermediate routine exists mainly to localize the effects of setjmp
1218 * so we don't need to plaster a lot of variables with "volatile".
1219 */
1220static void
1221DoCopyTo(CopyState cstate)
1222{
1223        bool            pipe = (cstate->filename == NULL);
1224
1225        if (cstate->rel)
1226        {
1227                if (cstate->rel->rd_rel->relkind != RELKIND_RELATION)
1228                {
1229                        if (cstate->rel->rd_rel->relkind == RELKIND_VIEW)
1230                                ereport(ERROR,
1231                                                (errcode(ERRCODE_WRONG_OBJECT_TYPE),
1232                                                 errmsg("cannot copy from view \"%s\"",
1233                                                                RelationGetRelationName(cstate->rel)),
1234                                                 errhint("Try the COPY (SELECT ...) TO variant.")));
1235                        else if (cstate->rel->rd_rel->relkind == RELKIND_SEQUENCE)
1236                                ereport(ERROR,
1237                                                (errcode(ERRCODE_WRONG_OBJECT_TYPE),
1238                                                 errmsg("cannot copy from sequence \"%s\"",
1239                                                                RelationGetRelationName(cstate->rel))));
1240                        else
1241                                ereport(ERROR,
1242                                                (errcode(ERRCODE_WRONG_OBJECT_TYPE),
1243                                                 errmsg("cannot copy from non-table relation \"%s\"",
1244                                                                RelationGetRelationName(cstate->rel))));
1245                }
1246        }
1247
1248        if (pipe)
1249        {
1250                if (whereToSendOutput == DestRemote)
1251                        cstate->fe_copy = true;
1252                else
1253                        cstate->copy_file = stdout;
1254        }
1255        else
1256        {
1257                mode_t          oumask;         /* Pre-existing umask value */
1258                struct stat st;
1259
1260                /*
1261                 * Prevent write to relative path ... too easy to shoot oneself in the
1262                 * foot by overwriting a database file ...
1263                 */
1264                if (!is_absolute_path(cstate->filename))
1265                        ereport(ERROR,
1266                                        (errcode(ERRCODE_INVALID_NAME),
1267                                         errmsg("relative path not allowed for COPY to file")));
1268
1269                oumask = umask((mode_t) 022);
1270                cstate->copy_file = AllocateFile(cstate->filename, PG_BINARY_W);
1271                umask(oumask);
1272
1273                if (cstate->copy_file == NULL)
1274                        ereport(ERROR,
1275                                        (errcode_for_file_access(),
1276                                         errmsg("could not open file \"%s\" for writing: %m",
1277                                                        cstate->filename)));
1278
1279                fstat(fileno(cstate->copy_file), &st);
1280                if (S_ISDIR(st.st_mode))
1281                        ereport(ERROR,
1282                                        (errcode(ERRCODE_WRONG_OBJECT_TYPE),
1283                                         errmsg("\"%s\" is a directory", cstate->filename)));
1284        }
1285
1286        PG_TRY();
1287        {
1288                if (cstate->fe_copy)
1289                        SendCopyBegin(cstate);
1290
1291                CopyTo(cstate);
1292
1293                if (cstate->fe_copy)
1294                        SendCopyEnd(cstate);
1295        }
1296        PG_CATCH();
1297        {
1298                /*
1299                 * Make sure we turn off old-style COPY OUT mode upon error. It is
1300                 * okay to do this in all cases, since it does nothing if the mode is
1301                 * not on.
1302                 */
1303                pq_endcopyout(true);
1304                PG_RE_THROW();
1305        }
1306        PG_END_TRY();
1307
1308        if (!pipe)
1309        {
1310                if (FreeFile(cstate->copy_file))
1311                        ereport(ERROR,
1312                                        (errcode_for_file_access(),
1313                                         errmsg("could not write to file \"%s\": %m",
1314                                                        cstate->filename)));
1315        }
1316}
1317
1318/*
1319 * Copy from relation or query TO file.
1320 */
1321static void
1322CopyTo(CopyState cstate)
1323{
1324        TupleDesc       tupDesc;
1325        int                     num_phys_attrs;
1326        Form_pg_attribute *attr;
1327        ListCell   *cur;
1328
1329        if (cstate->rel)
1330                tupDesc = RelationGetDescr(cstate->rel);
1331        else
1332                tupDesc = cstate->queryDesc->tupDesc;
1333        attr = tupDesc->attrs;
1334        num_phys_attrs = tupDesc->natts;
1335        cstate->null_print_client = cstate->null_print;         /* default */
1336
1337        /* We use fe_msgbuf as a per-row buffer regardless of copy_dest */
1338        cstate->fe_msgbuf = makeStringInfo();
1339
1340        /* Get info about the columns we need to process. */
1341        cstate->out_functions = (FmgrInfo *) palloc(num_phys_attrs * sizeof(FmgrInfo));
1342        foreach(cur, cstate->attnumlist)
1343        {
1344                int                     attnum = lfirst_int(cur);
1345                Oid                     out_func_oid;
1346                bool            isvarlena;
1347
1348                if (cstate->binary)
1349                        getTypeBinaryOutputInfo(attr[attnum - 1]->atttypid,
1350                                                                        &out_func_oid,
1351                                                                        &isvarlena);
1352                else
1353                        getTypeOutputInfo(attr[attnum - 1]->atttypid,
1354                                                          &out_func_oid,
1355                                                          &isvarlena);
1356                fmgr_info(out_func_oid, &cstate->out_functions[attnum - 1]);
1357        }
1358
1359        /*
1360         * Create a temporary memory context that we can reset once per row to
1361         * recover palloc'd memory.  This avoids any problems with leaks inside
1362         * datatype output routines, and should be faster than retail pfree's
1363         * anyway.      (We don't need a whole econtext as CopyFrom does.)
1364         */
1365        cstate->rowcontext = AllocSetContextCreate(CurrentMemoryContext,
1366                                                                                           "COPY TO",
1367                                                                                           ALLOCSET_DEFAULT_MINSIZE,
1368                                                                                           ALLOCSET_DEFAULT_INITSIZE,
1369                                                                                           ALLOCSET_DEFAULT_MAXSIZE);
1370
1371        if (cstate->binary)
1372        {
1373                /* Generate header for a binary copy */
1374                int32           tmp;
1375
1376                /* Signature */
1377                CopySendData(cstate, (char *) BinarySignature, 11);
1378                /* Flags field */
1379                tmp = 0;
1380                if (cstate->oids)
1381                        tmp |= (1 << 16);
1382                CopySendInt32(cstate, tmp);
1383                /* No header extension */
1384                tmp = 0;
1385                CopySendInt32(cstate, tmp);
1386        }
1387        else
1388        {
1389                /*
1390                 * For non-binary copy, we need to convert null_print to client
1391                 * encoding, because it will be sent directly with CopySendString.
1392                 */
1393                if (cstate->need_transcoding)
1394                        cstate->null_print_client = pg_server_to_client(cstate->null_print,
1395                                                                                                         cstate->null_print_len);
1396
1397                /* if a header has been requested send the line */
1398                if (cstate->header_line)
1399                {
1400                        bool            hdr_delim = false;
1401
1402                        foreach(cur, cstate->attnumlist)
1403                        {
1404                                int                     attnum = lfirst_int(cur);
1405                                char       *colname;
1406
1407                                if (hdr_delim)
1408                                        CopySendChar(cstate, cstate->delim[0]);
1409                                hdr_delim = true;
1410
1411                                colname = NameStr(attr[attnum - 1]->attname);
1412
1413                                CopyAttributeOutCSV(cstate, colname, false,
1414                                                                        list_length(cstate->attnumlist) == 1);
1415                        }
1416
1417                        CopySendEndOfRow(cstate);
1418                }
1419        }
1420
1421        if (cstate->rel)
1422        {
1423                Datum      *values;
1424                bool       *nulls;
1425                HeapScanDesc scandesc;
1426                HeapTuple       tuple;
1427
1428                values = (Datum *) palloc(num_phys_attrs * sizeof(Datum));
1429                nulls = (bool *) palloc(num_phys_attrs * sizeof(bool));
1430
1431                scandesc = heap_beginscan(cstate->rel, GetActiveSnapshot(), 0, NULL);
1432
1433                while ((tuple = heap_getnext(scandesc, ForwardScanDirection)) != NULL)
1434                {
1435                        CHECK_FOR_INTERRUPTS();
1436
1437                        /* Deconstruct the tuple ... faster than repeated heap_getattr */
1438                        heap_deform_tuple(tuple, tupDesc, values, nulls);
1439
1440                        /* Format and send the data */
1441                        CopyOneRowTo(cstate, HeapTupleGetOid(tuple), values, nulls);
1442                }
1443
1444                heap_endscan(scandesc);
1445        }
1446        else
1447        {
1448                /* run the plan --- the dest receiver will send tuples */
1449                ExecutorRun(cstate->queryDesc, ForwardScanDirection, 0L);
1450        }
1451
1452        if (cstate->binary)
1453        {
1454                /* Generate trailer for a binary copy */
1455                CopySendInt16(cstate, -1);
1456                /* Need to flush out the trailer */
1457                CopySendEndOfRow(cstate);
1458        }
1459
1460        MemoryContextDelete(cstate->rowcontext);
1461}
1462
1463/*
1464 * Emit one row during CopyTo().
1465 */
1466static void
1467CopyOneRowTo(CopyState cstate, Oid tupleOid, Datum *values, bool *nulls)
1468{
1469        bool            need_delim = false;
1470        FmgrInfo   *out_functions = cstate->out_functions;
1471        MemoryContext oldcontext;
1472        ListCell   *cur;
1473        char       *string;
1474
1475        MemoryContextReset(cstate->rowcontext);
1476        oldcontext = MemoryContextSwitchTo(cstate->rowcontext);
1477
1478        if (cstate->binary)
1479        {
1480                /* Binary per-tuple header */
1481                CopySendInt16(cstate, list_length(cstate->attnumlist));
1482                /* Send OID if wanted --- note attnumlist doesn't include it */
1483                if (cstate->oids)
1484                {
1485                        /* Hack --- assume Oid is same size as int32 */
1486                        CopySendInt32(cstate, sizeof(int32));
1487                        CopySendInt32(cstate, tupleOid);
1488                }
1489        }
1490        else
1491        {
1492                /* Text format has no per-tuple header, but send OID if wanted */
1493                /* Assume digits don't need any quoting or encoding conversion */
1494                if (cstate->oids)
1495                {
1496                        string = DatumGetCString(DirectFunctionCall1(oidout,
1497                                                                                                ObjectIdGetDatum(tupleOid)));
1498                        CopySendString(cstate, string);
1499                        need_delim = true;
1500                }
1501        }
1502
1503        foreach(cur, cstate->attnumlist)
1504        {
1505                int                     attnum = lfirst_int(cur);
1506                Datum           value = values[attnum - 1];
1507                bool            isnull = nulls[attnum - 1];
1508
1509                if (!cstate->binary)
1510                {
1511                        if (need_delim)
1512                                CopySendChar(cstate, cstate->delim[0]);
1513                        need_delim = true;
1514                }
1515
1516                if (isnull)
1517                {
1518                        if (!cstate->binary)
1519                                CopySendString(cstate, cstate->null_print_client);
1520                        else
1521                                CopySendInt32(cstate, -1);
1522                }
1523                else
1524                {
1525                        if (!cstate->binary)
1526                        {
1527                                string = OutputFunctionCall(&out_functions[attnum - 1],
1528                                                                                        value);
1529                                if (cstate->csv_mode)
1530                                        CopyAttributeOutCSV(cstate, string,
1531                                                                                cstate->force_quote_flags[attnum - 1],
1532                                                                                list_length(cstate->attnumlist) == 1);
1533                                else
1534                                        CopyAttributeOutText(cstate, string);
1535                        }
1536                        else
1537                        {
1538                                bytea      *outputbytes;
1539
1540                                outputbytes = SendFunctionCall(&out_functions[attnum - 1],
1541                                                                                           value);
1542                                CopySendInt32(cstate, VARSIZE(outputbytes) - VARHDRSZ);
1543                                CopySendData(cstate, VARDATA(outputbytes),
1544                                                         VARSIZE(outputbytes) - VARHDRSZ);
1545                        }
1546                }
1547        }
1548
1549        CopySendEndOfRow(cstate);
1550
1551        MemoryContextSwitchTo(oldcontext);
1552
1553        cstate->processed++;
1554}
1555
1556
1557/*
1558 * error context callback for COPY FROM
1559 */
1560static void
1561copy_in_error_callback(void *arg)
1562{
1563        CopyState       cstate = (CopyState) arg;
1564
1565        if (cstate->binary)
1566        {
1567                /* can't usefully display the data */
1568                if (cstate->cur_attname)
1569                        errcontext("COPY %s, line %d, column %s",
1570                                           cstate->cur_relname, cstate->cur_lineno,
1571                                           cstate->cur_attname);
1572                else
1573                        errcontext("COPY %s, line %d",
1574                                           cstate->cur_relname, cstate->cur_lineno);
1575        }
1576        else
1577        {
1578                if (cstate->cur_attname && cstate->cur_attval)
1579                {
1580                        /* error is relevant to a particular column */
1581                        char       *attval;
1582
1583                        attval = limit_printout_length(cstate->cur_attval);
1584                        errcontext("COPY %s, line %d, column %s: \"%s\"",
1585                                           cstate->cur_relname, cstate->cur_lineno,
1586                                           cstate->cur_attname, attval);
1587                        pfree(attval);
1588                }
1589                else if (cstate->cur_attname)
1590                {
1591                        /* error is relevant to a particular column, value is NULL */
1592                        errcontext("COPY %s, line %d, column %s: null input",
1593                                           cstate->cur_relname, cstate->cur_lineno,
1594                                           cstate->cur_attname);
1595                }
1596                else
1597                {
1598                        /* error is relevant to a particular line */
1599                        if (cstate->line_buf_converted || !cstate->need_transcoding)
1600                        {
1601                                char       *lineval;
1602
1603                                lineval = limit_printout_length(cstate->line_buf.data);
1604                                errcontext("COPY %s, line %d: \"%s\"",
1605                                                   cstate->cur_relname, cstate->cur_lineno, lineval);
1606                                pfree(lineval);
1607                        }
1608                        else
1609                        {
1610                                /*
1611                                 * Here, the line buffer is still in a foreign encoding, and
1612                                 * indeed it's quite likely that the error is precisely a
1613                                 * failure to do encoding conversion (ie, bad data).  We dare
1614                                 * not try to convert it, and at present there's no way to
1615                                 * regurgitate it without conversion.  So we have to punt and
1616                                 * just report the line number.
1617                                 */
1618                                errcontext("COPY %s, line %d",
1619                                                   cstate->cur_relname, cstate->cur_lineno);
1620                        }
1621                }
1622        }
1623}
1624
1625/*
1626 * Make sure we don't print an unreasonable amount of COPY data in a message.
1627 *
1628 * It would seem a lot easier to just use the sprintf "precision" limit to
1629 * truncate the string.  However, some versions of glibc have a bug/misfeature
1630 * that vsnprintf will always fail (return -1) if it is asked to truncate
1631 * a string that contains invalid byte sequences for the current encoding.
1632 * So, do our own truncation.  We return a pstrdup'd copy of the input.
1633 */
1634static char *
1635limit_printout_length(const char *str)
1636{
1637#define MAX_COPY_DATA_DISPLAY 100
1638
1639        int                     slen = strlen(str);
1640        int                     len;
1641        char       *res;
1642
1643        /* Fast path if definitely okay */
1644        if (slen <= MAX_COPY_DATA_DISPLAY)
1645                return pstrdup(str);
1646
1647        /* Apply encoding-dependent truncation */
1648        len = pg_mbcliplen(str, slen, MAX_COPY_DATA_DISPLAY);
1649
1650        /*
1651         * Truncate, and add "..." to show we truncated the input.
1652         */
1653        res = (char *) palloc(len + 4);
1654        memcpy(res, str, len);
1655        strcpy(res + len, "...");
1656
1657        return res;
1658}
1659
1660/*
1661 * Copy FROM file to relation.
1662 */
1663static void
1664CopyFrom(CopyState cstate)
1665{
1666        bool            pipe = (cstate->filename == NULL);
1667        HeapTuple       tuple;
1668        TupleDesc       tupDesc;
1669        Form_pg_attribute *attr;
1670        AttrNumber      num_phys_attrs,
1671                                attr_count,
1672                                num_defaults;
1673        FmgrInfo   *in_functions;
1674        FmgrInfo        oid_in_function;
1675        Oid                *typioparams;
1676        Oid                     oid_typioparam;
1677        int                     attnum;
1678        int                     i;
1679        Oid                     in_func_oid;
1680        Datum      *values;
1681        bool       *nulls;
1682        int                     nfields;
1683        char      **field_strings;
1684        bool            done = false;
1685        bool            isnull;
1686        ResultRelInfo *resultRelInfo;
1687        EState     *estate = CreateExecutorState(); /* for ExecConstraints() */
1688        TupleTableSlot *slot;
1689        bool            file_has_oids;
1690        int                *defmap;
1691        ExprState **defexprs;           /* array of default att expressions */
1692        ExprContext *econtext;          /* used for ExecEvalExpr for default atts */
1693        MemoryContext oldcontext = CurrentMemoryContext;
1694        ErrorContextCallback errcontext;
1695        CommandId       mycid = GetCurrentCommandId(true);
1696        int                     hi_options = 0; /* start with default heap_insert options */
1697        BulkInsertState bistate;
1698
1699        Assert(cstate->rel);
1700
1701        if (cstate->rel->rd_rel->relkind != RELKIND_RELATION)
1702        {
1703                if (cstate->rel->rd_rel->relkind == RELKIND_VIEW)
1704                        ereport(ERROR,
1705                                        (errcode(ERRCODE_WRONG_OBJECT_TYPE),
1706                                         errmsg("cannot copy to view \"%s\"",
1707                                                        RelationGetRelationName(cstate->rel))));
1708                else if (cstate->rel->rd_rel->relkind == RELKIND_SEQUENCE)
1709                        ereport(ERROR,
1710                                        (errcode(ERRCODE_WRONG_OBJECT_TYPE),
1711                                         errmsg("cannot copy to sequence \"%s\"",
1712                                                        RelationGetRelationName(cstate->rel))));
1713                else
1714                        ereport(ERROR,
1715                                        (errcode(ERRCODE_WRONG_OBJECT_TYPE),
1716                                         errmsg("cannot copy to non-table relation \"%s\"",
1717                                                        RelationGetRelationName(cstate->rel))));
1718        }
1719
1720        /*----------
1721         * Check to see if we can avoid writing WAL
1722         *
1723         * If archive logging is not enabled *and* either
1724         *      - table was created in same transaction as this COPY
1725         *      - data is being written to relfilenode created in this transaction
1726         * then we can skip writing WAL.  It's safe because if the transaction
1727         * doesn't commit, we'll discard the table (or the new relfilenode file).
1728         * If it does commit, we'll have done the heap_sync at the bottom of this
1729         * routine first.
1730         *
1731         * As mentioned in comments in utils/rel.h, the in-same-transaction test
1732         * is not completely reliable, since in rare cases rd_createSubid or
1733         * rd_newRelfilenodeSubid can be cleared before the end of the transaction.
1734         * However this is OK since at worst we will fail to make the optimization.
1735         *
1736         * Also, if the target file is new-in-transaction, we assume that checking
1737         * FSM for free space is a waste of time, even if we must use WAL because
1738         * of archiving.  This could possibly be wrong, but it's unlikely.
1739         *
1740         * The comments for heap_insert and RelationGetBufferForTuple specify that
1741         * skipping WAL logging is only safe if we ensure that our tuples do not
1742         * go into pages containing tuples from any other transactions --- but this
1743         * must be the case if we have a new table or new relfilenode, so we need
1744         * no additional work to enforce that.
1745         *----------
1746         */
1747        if (cstate->rel->rd_createSubid != InvalidSubTransactionId ||
1748                cstate->rel->rd_newRelfilenodeSubid != InvalidSubTransactionId)
1749        {
1750                hi_options |= HEAP_INSERT_SKIP_FSM;
1751                if (!XLogArchivingActive())
1752                        hi_options |= HEAP_INSERT_SKIP_WAL;
1753        }
1754
1755        if (pipe)
1756        {
1757                if (whereToSendOutput == DestRemote)
1758                        ReceiveCopyBegin(cstate);
1759                else
1760                        cstate->copy_file = stdin;
1761        }
1762        else
1763        {
1764                struct stat st;
1765
1766                cstate->copy_file = AllocateFile(cstate->filename, PG_BINARY_R);
1767
1768                if (cstate->copy_file == NULL)
1769                        ereport(ERROR,
1770                                        (errcode_for_file_access(),
1771                                         errmsg("could not open file \"%s\" for reading: %m",
1772                                                        cstate->filename)));
1773
1774                fstat(fileno(cstate->copy_file), &st);
1775                if (S_ISDIR(st.st_mode))
1776                        ereport(ERROR,
1777                                        (errcode(ERRCODE_WRONG_OBJECT_TYPE),
1778                                         errmsg("\"%s\" is a directory", cstate->filename)));
1779        }
1780
1781        tupDesc = RelationGetDescr(cstate->rel);
1782        attr = tupDesc->attrs;
1783        num_phys_attrs = tupDesc->natts;
1784        attr_count = list_length(cstate->attnumlist);
1785        num_defaults = 0;
1786
1787        /*
1788         * We need a ResultRelInfo so we can use the regular executor's
1789         * index-entry-making machinery.  (There used to be a huge amount of code
1790         * here that basically duplicated execUtils.c ...)
1791         */
1792        resultRelInfo = makeNode(ResultRelInfo);
1793        resultRelInfo->ri_RangeTableIndex = 1;          /* dummy */
1794        resultRelInfo->ri_RelationDesc = cstate->rel;
1795        resultRelInfo->ri_TrigDesc = CopyTriggerDesc(cstate->rel->trigdesc);
1796        if (resultRelInfo->ri_TrigDesc)
1797                resultRelInfo->ri_TrigFunctions = (FmgrInfo *)
1798                        palloc0(resultRelInfo->ri_TrigDesc->numtriggers * sizeof(FmgrInfo));
1799        resultRelInfo->ri_TrigInstrument = NULL;
1800
1801        ExecOpenIndices(resultRelInfo);
1802
1803        estate->es_result_relations = resultRelInfo;
1804        estate->es_num_result_relations = 1;
1805        estate->es_result_relation_info = resultRelInfo;
1806
1807        /* Set up a tuple slot too */
1808        slot = MakeSingleTupleTableSlot(tupDesc);
1809
1810        econtext = GetPerTupleExprContext(estate);
1811
1812        /*
1813         * Pick up the required catalog information for each attribute in the
1814         * relation, including the input function, the element type (to pass to
1815         * the input function), and info about defaults and constraints. (Which
1816         * input function we use depends on text/binary format choice.)
1817         */
1818        in_functions = (FmgrInfo *) palloc(num_phys_attrs * sizeof(FmgrInfo));
1819        typioparams = (Oid *) palloc(num_phys_attrs * sizeof(Oid));
1820        defmap = (int *) palloc(num_phys_attrs * sizeof(int));
1821        defexprs = (ExprState **) palloc(num_phys_attrs * sizeof(ExprState *));
1822
1823        for (attnum = 1; attnum <= num_phys_attrs; attnum++)
1824        {
1825                /* We don't need info for dropped attributes */
1826                if (attr[attnum - 1]->attisdropped)
1827                        continue;
1828
1829                /* Fetch the input function and typioparam info */
1830                if (cstate->binary)
1831                        getTypeBinaryInputInfo(attr[attnum - 1]->atttypid,
1832                                                                   &in_func_oid, &typioparams[attnum - 1]);
1833                else
1834                        getTypeInputInfo(attr[attnum - 1]->atttypid,
1835                                                         &in_func_oid, &typioparams[attnum - 1]);
1836                fmgr_info(in_func_oid, &in_functions[attnum - 1]);
1837
1838                /* Get default info if needed */
1839                if (!list_member_int(cstate->attnumlist, attnum))
1840                {
1841                        /* attribute is NOT to be copied from input */
1842                        /* use default value if one exists */
1843                        Node       *defexpr = build_column_default(cstate->rel, attnum);
1844
1845                        if (defexpr != NULL)
1846                        {
1847                                defexprs[num_defaults] = ExecPrepareExpr((Expr *) defexpr,
1848                                                                                                                 estate);
1849                                defmap[num_defaults] = attnum - 1;
1850                                num_defaults++;
1851                        }
1852                }
1853        }
1854
1855        /* Prepare to catch AFTER triggers. */
1856        AfterTriggerBeginQuery();
1857
1858        /*
1859         * Check BEFORE STATEMENT insertion triggers. It's debateable whether we
1860         * should do this for COPY, since it's not really an "INSERT" statement as
1861         * such. However, executing these triggers maintains consistency with the
1862         * EACH ROW triggers that we already fire on COPY.
1863         */
1864        ExecBSInsertTriggers(estate, resultRelInfo);
1865
1866        if (!cstate->binary)
1867                file_has_oids = cstate->oids;   /* must rely on user to tell us... */
1868        else
1869        {
1870                /* Read and verify binary header */
1871                char            readSig[11];
1872                int32           tmp;
1873
1874                /* Signature */
1875                if (CopyGetData(cstate, readSig, 11, 11) != 11 ||
1876                        memcmp(readSig, BinarySignature, 11) != 0)
1877                        ereport(ERROR,
1878                                        (errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
1879                                         errmsg("COPY file signature not recognized")));
1880                /* Flags field */
1881                if (!CopyGetInt32(cstate, &tmp))
1882                        ereport(ERROR,
1883                                        (errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
1884                                         errmsg("invalid COPY file header (missing flags)")));
1885                file_has_oids = (tmp & (1 << 16)) != 0;
1886                tmp &= ~(1 << 16);
1887                if ((tmp >> 16) != 0)
1888                        ereport(ERROR,
1889                                        (errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
1890                                 errmsg("unrecognized critical flags in COPY file header")));
1891                /* Header extension length */
1892                if (!CopyGetInt32(cstate, &tmp) ||
1893                        tmp < 0)
1894                        ereport(ERROR,
1895                                        (errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
1896                                         errmsg("invalid COPY file header (missing length)")));
1897                /* Skip extension header, if present */
1898                while (tmp-- > 0)
1899                {
1900                        if (CopyGetData(cstate, readSig, 1, 1) != 1)
1901                                ereport(ERROR,
1902                                                (errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
1903                                                 errmsg("invalid COPY file header (wrong length)")));
1904                }
1905        }
1906
1907        if (file_has_oids && cstate->binary)
1908        {
1909                getTypeBinaryInputInfo(OIDOID,
1910                                                           &in_func_oid, &oid_typioparam);
1911                fmgr_info(in_func_oid, &oid_in_function);
1912        }
1913
1914        values = (Datum *) palloc(num_phys_attrs * sizeof(Datum));
1915        nulls = (bool *) palloc(num_phys_attrs * sizeof(bool));
1916
1917        /* create workspace for CopyReadAttributes results */
1918        nfields = file_has_oids ? (attr_count + 1) : attr_count;
1919        field_strings = (char **) palloc(nfields * sizeof(char *));
1920
1921        /* Initialize state variables */
1922        cstate->fe_eof = false;
1923        cstate->eol_type = EOL_UNKNOWN;
1924        cstate->cur_relname = RelationGetRelationName(cstate->rel);
1925        cstate->cur_lineno = 0;
1926        cstate->cur_attname = NULL;
1927        cstate->cur_attval = NULL;
1928
1929        bistate = GetBulkInsertState();
1930
1931        /* Set up callback to identify error line number */
1932        errcontext.callback = copy_in_error_callback;
1933        errcontext.arg = (void *) cstate;
1934        errcontext.previous = error_context_stack;
1935        error_context_stack = &errcontext;
1936
1937        /* on input just throw the header line away */
1938        if (cstate->header_line)
1939        {
1940                cstate->cur_lineno++;
1941                done = CopyReadLine(cstate);
1942        }
1943
1944        while (!done)
1945        {
1946                bool            skip_tuple;
1947                Oid                     loaded_oid = InvalidOid;
1948
1949                CHECK_FOR_INTERRUPTS();
1950
1951                cstate->cur_lineno++;
1952
1953                /* Reset the per-tuple exprcontext */
1954                ResetPerTupleExprContext(estate);
1955
1956                /* Switch into its memory context */
1957                MemoryContextSwitchTo(GetPerTupleMemoryContext(estate));
1958
1959                /* Initialize all values for row to NULL */
1960                MemSet(values, 0, num_phys_attrs * sizeof(Datum));
1961                MemSet(nulls, true, num_phys_attrs * sizeof(bool));
1962
1963                if (!cstate->binary)
1964                {
1965                        ListCell   *cur;
1966                        int                     fldct;
1967                        int                     fieldno;
1968                        char       *string;
1969
1970                        /* Actually read the line into memory here */
1971                        done = CopyReadLine(cstate);
1972
1973                        /*
1974                         * EOF at start of line means we're done.  If we see EOF after
1975                         * some characters, we act as though it was newline followed by
1976                         * EOF, ie, process the line and then exit loop on next iteration.
1977                         */
1978                        if (done && cstate->line_buf.len == 0)
1979                                break;
1980
1981                        /* Parse the line into de-escaped field values */
1982                        if (cstate->csv_mode)
1983                                fldct = CopyReadAttributesCSV(cstate, nfields, field_strings);
1984                        else
1985                                fldct = CopyReadAttributesText(cstate, nfields, field_strings);
1986                        fieldno = 0;
1987
1988                        /* Read the OID field if present */
1989                        if (file_has_oids)
1990                        {
1991                                if (fieldno >= fldct)
1992                                        ereport(ERROR,
1993                                                        (errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
1994                                                         errmsg("missing data for OID column")));
1995                                string = field_strings[fieldno++];
1996
1997                                if (string == NULL)
1998                                        ereport(ERROR,
1999                                                        (errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
2000                                                         errmsg("null OID in COPY data")));
2001                                else
2002                                {
2003                                        cstate->cur_attname = "oid";
2004                                        cstate->cur_attval = string;
2005                                        loaded_oid = DatumGetObjectId(DirectFunctionCall1(oidin,
2006                                                                                                   CStringGetDatum(string)));
2007                                        if (loaded_oid == InvalidOid)
2008                                                ereport(ERROR,
2009                                                                (errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
2010                                                                 errmsg("invalid OID in COPY data")));
2011                                        cstate->cur_attname = NULL;
2012                                        cstate->cur_attval = NULL;
2013                                }
2014                        }
2015
2016                        /* Loop to read the user attributes on the line. */
2017                        foreach(cur, cstate->attnumlist)
2018                        {
2019                                int                     attnum = lfirst_int(cur);
2020                                int                     m = attnum - 1;
2021
2022                                if (fieldno >= fldct)
2023                                        ereport(ERROR,
2024                                                        (errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
2025                                                         errmsg("missing data for column \"%s\"",
2026                                                                        NameStr(attr[m]->attname))));
2027                                string = field_strings[fieldno++];
2028
2029                                if (cstate->csv_mode && string == NULL &&
2030                                        cstate->force_notnull_flags[m])
2031                                {
2032                                        /* Go ahead and read the NULL string */
2033                                        string = cstate->null_print;
2034                                }
2035
2036                                cstate->cur_attname = NameStr(attr[m]->attname);
2037                                cstate->cur_attval = string;
2038                                values[m] = InputFunctionCall(&in_functions[m],
2039                                                                                          string,
2040                                                                                          typioparams[m],
2041                                                                                          attr[m]->atttypmod);
2042                                if (string != NULL)
2043                                        nulls[m] = false;
2044                                cstate->cur_attname = NULL;
2045                                cstate->cur_attval = NULL;
2046                        }
2047
2048                        Assert(fieldno == nfields);
2049                }
2050                else
2051                {
2052                        /* binary */
2053                        int16           fld_count;
2054                        ListCell   *cur;
2055
2056                        if (!CopyGetInt16(cstate, &fld_count) ||
2057                                fld_count == -1)
2058                        {
2059                                done = true;
2060                                break;
2061                        }
2062
2063                        if (fld_count != attr_count)
2064                                ereport(ERROR,
2065                                                (errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
2066                                                 errmsg("row field count is %d, expected %d",
2067                                                                (int) fld_count, attr_count)));
2068
2069                        if (file_has_oids)
2070                        {
2071                                cstate->cur_attname = "oid";
2072                                loaded_oid =
2073                                        DatumGetObjectId(CopyReadBinaryAttribute(cstate,
2074                                                                                                                         0,
2075                                                                                                                         &oid_in_function,
2076                                                                                                                         oid_typioparam,
2077                                                                                                                         -1,
2078                                                                                                                         &isnull));
2079                                if (isnull || loaded_oid == InvalidOid)
2080                                        ereport(ERROR,
2081                                                        (errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
2082                                                         errmsg("invalid OID in COPY data")));
2083                                cstate->cur_attname = NULL;
2084                        }
2085
2086                        i = 0;
2087                        foreach(cur, cstate->attnumlist)
2088                        {
2089                                int                     attnum = lfirst_int(cur);
2090                                int                     m = attnum - 1;
2091
2092                                cstate->cur_attname = NameStr(attr[m]->attname);
2093                                i++;
2094                                values[m] = CopyReadBinaryAttribute(cstate,
2095                                                                                                        i,
2096                                                                                                        &in_functions[m],
2097                                                                                                        typioparams[m],
2098                                                                                                        attr[m]->atttypmod,
2099                                                                                                        &nulls[m]);
2100                                cstate->cur_attname = NULL;
2101                        }
2102                }
2103
2104                /*
2105                 * Now compute and insert any defaults available for the columns not
2106                 * provided by the input data.  Anything not processed here or above
2107                 * will remain NULL.
2108                 */
2109                for (i = 0; i < num_defaults; i++)
2110                {
2111                        values[defmap[i]] = ExecEvalExpr(defexprs[i], econtext,
2112                                                                                         &nulls[defmap[i]], NULL);
2113                }
2114
2115                /* And now we can form the input tuple. */
2116                tuple = heap_form_tuple(tupDesc, values, nulls);
2117
2118                if (cstate->oids && file_has_oids)
2119                        HeapTupleSetOid(tuple, loaded_oid);
2120
2121                /* Triggers and stuff need to be invoked in query context. */
2122                MemoryContextSwitchTo(oldcontext);
2123
2124                skip_tuple = false;
2125
2126                /* BEFORE ROW INSERT Triggers */
2127                if (resultRelInfo->ri_TrigDesc &&
2128                  resultRelInfo->ri_TrigDesc->n_before_row[TRIGGER_EVENT_INSERT] > 0)
2129                {
2130                        HeapTuple       newtuple;
2131
2132                        newtuple = ExecBRInsertTriggers(estate, resultRelInfo, tuple);
2133
2134                        if (newtuple == NULL)           /* "do nothing" */
2135                                skip_tuple = true;
2136                        else if (newtuple != tuple) /* modified by Trigger(s) */
2137                        {
2138                                heap_freetuple(tuple);
2139                                tuple = newtuple;
2140                        }
2141                }
2142
2143                if (!skip_tuple)
2144                {
2145                        /* Place tuple in tuple slot */
2146                        ExecStoreTuple(tuple, slot, InvalidBuffer, false);
2147
2148                        /* Check the constraints of the tuple */
2149                        if (cstate->rel->rd_att->constr)
2150                                ExecConstraints(resultRelInfo, slot, estate);
2151
2152                        /* OK, store the tuple and create index entries for it */
2153                        heap_insert(cstate->rel, tuple, mycid, hi_options, bistate);
2154
2155                        if (resultRelInfo->ri_NumIndices > 0)
2156                                ExecInsertIndexTuples(slot, &(tuple->t_self), estate, false);
2157
2158                        /* AFTER ROW INSERT Triggers */
2159                        ExecARInsertTriggers(estate, resultRelInfo, tuple);
2160
2161                        /*
2162                         * We count only tuples not suppressed by a BEFORE INSERT trigger;
2163                         * this is the same definition used by execMain.c for counting
2164                         * tuples inserted by an INSERT command.
2165                         */
2166                        cstate->processed++;
2167                }
2168        }
2169
2170        /* Done, clean up */
2171        error_context_stack = errcontext.previous;
2172
2173        FreeBulkInsertState(bistate);
2174
2175        MemoryContextSwitchTo(oldcontext);
2176
2177        /* Execute AFTER STATEMENT insertion triggers */
2178        ExecASInsertTriggers(estate, resultRelInfo);
2179
2180        /* Handle queued AFTER triggers */
2181        AfterTriggerEndQuery(estate);
2182
2183        pfree(values);
2184        pfree(nulls);
2185        pfree(field_strings);
2186
2187        pfree(in_functions);
2188        pfree(typioparams);
2189        pfree(defmap);
2190        pfree(defexprs);
2191
2192        ExecDropSingleTupleTableSlot(slot);
2193
2194        ExecCloseIndices(resultRelInfo);
2195
2196        FreeExecutorState(estate);
2197
2198        if (!pipe)
2199        {
2200                if (FreeFile(cstate->copy_file))
2201                        ereport(ERROR,
2202                                        (errcode_for_file_access(),
2203                                         errmsg("could not read from file \"%s\": %m",
2204                                                        cstate->filename)));
2205        }
2206
2207        /*
2208         * If we skipped writing WAL, then we need to sync the heap (but not
2209         * indexes since those use WAL anyway)
2210         */
2211        if (hi_options & HEAP_INSERT_SKIP_WAL)
2212                heap_sync(cstate->rel);
2213}
2214
2215
2216/*
2217 * Read the next input line and stash it in line_buf, with conversion to
2218 * server encoding.
2219 *
2220 * Result is true if read was terminated by EOF, false if terminated
2221 * by newline.  The terminating newline or EOF marker is not included
2222 * in the final value of line_buf.
2223 */
2224static bool
2225CopyReadLine(CopyState cstate)
2226{
2227        bool            result;
2228
2229        resetStringInfo(&cstate->line_buf);
2230
2231        /* Mark that encoding conversion hasn't occurred yet */
2232        cstate->line_buf_converted = false;
2233
2234        /* Parse data and transfer into line_buf */
2235        result = CopyReadLineText(cstate);
2236
2237        if (result)
2238        {
2239                /*
2240                 * Reached EOF.  In protocol version 3, we should ignore anything
2241                 * after \. up to the protocol end of copy data.  (XXX maybe better
2242                 * not to treat \. as special?)
2243                 */
2244                if (cstate->copy_dest == COPY_NEW_FE)
2245                {
2246                        do
2247                        {
2248                                cstate->raw_buf_index = cstate->raw_buf_len;
2249                        } while (CopyLoadRawBuf(cstate));
2250                }
2251        }
2252        else
2253        {
2254                /*
2255                 * If we didn't hit EOF, then we must have transferred the EOL marker
2256                 * to line_buf along with the data.  Get rid of it.
2257                 */
2258                switch (cstate->eol_type)
2259                {
2260                        case EOL_NL:
2261                                Assert(cstate->line_buf.len >= 1);
2262                                Assert(cstate->line_buf.data[cstate->line_buf.len - 1] == '\n');
2263                                cstate->line_buf.len--;
2264                                cstate->line_buf.data[cstate->line_buf.len] = '\0';
2265                                break;
2266                        case EOL_CR:
2267                                Assert(cstate->line_buf.len >= 1);
2268                                Assert(cstate->line_buf.data[cstate->line_buf.len - 1] == '\r');
2269                                cstate->line_buf.len--;
2270                                cstate->line_buf.data[cstate->line_buf.len] = '\0';
2271                                break;
2272                        case EOL_CRNL:
2273                                Assert(cstate->line_buf.len >= 2);
2274                                Assert(cstate->line_buf.data[cstate->line_buf.len - 2] == '\r');
2275                                Assert(cstate->line_buf.data[cstate->line_buf.len - 1] == '\n');
2276                                cstate->line_buf.len -= 2;
2277                                cstate->line_buf.data[cstate->line_buf.len] = '\0';
2278                                break;
2279                        case EOL_UNKNOWN:
2280                                /* shouldn't get here */
2281                                Assert(false);
2282                                break;
2283                }
2284        }
2285
2286        /* Done reading the line.  Convert it to server encoding. */
2287        if (cstate->need_transcoding)
2288        {
2289                char       *cvt;
2290
2291                cvt = pg_client_to_server(cstate->line_buf.data,
2292                                                                  cstate->line_buf.len);
2293                if (cvt != cstate->line_buf.data)
2294                {
2295                        /* transfer converted data back to line_buf */
2296                        resetStringInfo(&cstate->line_buf);
2297                        appendBinaryStringInfo(&cstate->line_buf, cvt, strlen(cvt));
2298                        pfree(cvt);
2299                }
2300        }
2301
2302        /* Now it's safe to use the buffer in error messages */
2303        cstate->line_buf_converted = true;
2304
2305        return result;
2306}
2307/*
2308 * CopyReadLineText - inner loop of CopyReadLine for text mode
2309 */
2310//static bool
2311//CopyReadLineText(CopyState cstate)
2312//{
2313//      char       *copy_raw_buf;
2314//      int                     raw_buf_ptr;
2315//      int                     copy_buf_len;
2316//      bool            need_data = false;
2317//      bool            hit_eof = false;
2318//      bool            result = false;
2319//      char            mblen_str[2];
2320//
2321//      /* CSV variables */
2322//      bool            first_char_in_line = true;
2323//      bool            in_quote = false,
2324//                              last_was_esc = false;
2325//      char            quotec = '\0';
2326//      char            escapec = '\0';
2327//
2328//      if (cstate->csv_mode)
2329//      {
2330//              quotec = cstate->quote[0];
2331//              escapec = cstate->escape[0];
2332//              /* ignore special escape processing if it's the same as quotec */
2333//              if (quotec == escapec)
2334//                      escapec = '\0';
2335//      }
2336//
2337//      mblen_str[1] = '\0';
2338//
2339//      /*
2340//       * The objective of this loop is to transfer the entire next input line
2341//       * into line_buf.  Hence, we only care for detecting newlines (\r and/or
2342//       * \n) and the end-of-copy marker (\.).
2343//       *
2344//       * In CSV mode, \r and \n inside a quoted field are just part of the data
2345//       * value and are put in line_buf.  We keep just enough state to know if we
2346//       * are currently in a quoted field or not.
2347//       *
2348//       * These four characters, and the CSV escape and quote characters, are
2349//       * assumed the same in frontend and backend encodings.
2350//       *
2351//       * For speed, we try to move data from raw_buf to line_buf in chunks
2352//       * rather than one character at a time.  raw_buf_ptr points to the next
2353//       * character to examine; any characters from raw_buf_index to raw_buf_ptr
2354//       * have been determined to be part of the line, but not yet transferred to
2355//       * line_buf.
2356//       *
2357//       * For a little extra speed within the loop, we copy raw_buf and
2358//       * raw_buf_len into local variables.
2359//       */
2360//      copy_raw_buf = cstate->raw_buf;
2361//      raw_buf_ptr = cstate->raw_buf_index;
2362//      copy_buf_len = cstate->raw_buf_len;
2363//
2364//      for (;;)
2365//      {
2366//              int                     prev_raw_ptr;
2367//              char            c;
2368//
2369//              /*
2370//               * Load more data if needed.  Ideally we would just force four bytes
2371//               * of read-ahead and avoid the many calls to
2372//               * IF_NEED_REFILL_AND_NOT_EOF_CONTINUE(), but the COPY_OLD_FE protocol
2373//               * does not allow us to read too far ahead or we might read into the
2374//               * next data, so we read-ahead only as far we know we can.      One
2375//               * optimization would be to read-ahead four byte here if
2376//               * cstate->copy_dest != COPY_OLD_FE, but it hardly seems worth it,
2377//               * considering the size of the buffer.
2378//               */
2379//              if (raw_buf_ptr >= copy_buf_len || need_data)
2380//              {
2381//                      REFILL_LINEBUF;
2382//
2383//                      /*
2384//                       * Try to read some more data.  This will certainly reset
2385//                       * raw_buf_index to zero, and raw_buf_ptr must go with it.
2386//                       */
2387//                      if (!CopyLoadRawBuf(cstate))
2388//                              hit_eof = true;
2389//                      raw_buf_ptr = 0;
2390//                      copy_buf_len = cstate->raw_buf_len;
2391//
2392//                      /*
2393//                       * If we are completely out of data, break out of the loop,
2394//                       * reporting EOF.
2395//                       */
2396//                      if (copy_buf_len <= 0)
2397//                      {
2398//                              result = true;
2399//                              break;
2400//                      }
2401//                      need_data = false;
2402//              }
2403//
2404//              /* OK to fetch a character */
2405//              prev_raw_ptr = raw_buf_ptr;
2406//              c = copy_raw_buf[raw_buf_ptr++];
2407//
2408//              if (cstate->csv_mode)
2409//              {
2410//                      /*
2411//                       * If character is '\\' or '\r', we may need to look ahead below.
2412//                       * Force fetch of the next character if we don't already have it.
2413//                       * We need to do this before changing CSV state, in case one of
2414//                       * these characters is also the quote or escape character.
2415//                       *
2416//                       * Note: old-protocol does not like forced prefetch, but it's OK
2417//                       * here since we cannot validly be at EOF.
2418//                       */
2419//                      if (c == '\\' || c == '\r')
2420//                      {
2421//                              IF_NEED_REFILL_AND_NOT_EOF_CONTINUE(0);
2422//                      }
2423//
2424//                      /*
2425//                       * Dealing with quotes and escapes here is mildly tricky. If the
2426//                       * quote char is also the escape char, there's no problem - we
2427//                       * just use the char as a toggle. If they are different, we need
2428//                       * to ensure that we only take account of an escape inside a
2429//                       * quoted field and immediately preceding a quote char, and not
2430//                       * the second in a escape-escape sequence.
2431//                       */
2432//                      if (in_quote && c == escapec)
2433//                              last_was_esc = !last_was_esc;
2434//                      if (c == quotec && !last_was_esc)
2435//                              in_quote = !in_quote;
2436//                      if (c != escapec)
2437//                              last_was_esc = false;
2438//
2439//                      /*
2440//                       * Updating the line count for embedded CR and/or LF chars is
2441//                       * necessarily a little fragile - this test is probably about the
2442//                       * best we can do.      (XXX it's arguable whether we should do this
2443//                       * at all --- is cur_lineno a physical or logical count?)
2444//                       */
2445//                      if (in_quote && c == (cstate->eol_type == EOL_NL ? '\n' : '\r'))
2446//                              cstate->cur_lineno++;
2447//              }
2448//
2449//              /* Process \r */
2450//              if (c == '\r' && (!cstate->csv_mode || !in_quote))
2451//              {
2452//                      /* Check for \r\n on first line, _and_ handle \r\n. */
2453//                      if (cstate->eol_type == EOL_UNKNOWN ||
2454//                              cstate->eol_type == EOL_CRNL)
2455//                      {
2456//                              /*
2457//                               * If need more data, go back to loop top to load it.
2458//                               *
2459//                               * Note that if we are at EOF, c will wind up as '\0' because
2460//                               * of the guaranteed pad of raw_buf.
2461//                               */
2462//                              IF_NEED_REFILL_AND_NOT_EOF_CONTINUE(0);
2463//
2464//                              /* get next char */
2465//                              c = copy_raw_buf[raw_buf_ptr];
2466//
2467//                              if (c == '\n')
2468//                              {
2469//                                      raw_buf_ptr++;          /* eat newline */
2470//                                      cstate->eol_type = EOL_CRNL;            /* in case not set yet */
2471//                              }
2472//                              else
2473//                              {
2474//                                      /* found \r, but no \n */
2475//                                      if (cstate->eol_type == EOL_CRNL)
2476//                                              ereport(ERROR,
2477//                                                              (errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
2478//                                                               !cstate->csv_mode ?
2479//                                                      errmsg("literal carriage return found in data") :
2480//                                                      errmsg("unquoted carriage return found in data"),
2481//                                                               !cstate->csv_mode ?
2482//                                              errhint("Use \"\\r\" to represent carriage return.") :
2483//                                                               errhint("Use quoted CSV field to represent carriage return.")));
2484//
2485//                                      /*
2486//                                       * if we got here, it is the first line and we didn't find
2487//                                       * \n, so don't consume the peeked character
2488//                                       */
2489//                                      cstate->eol_type = EOL_CR;
2490//                              }
2491//                      }
2492//                      else if (cstate->eol_type == EOL_NL)
2493//                              ereport(ERROR,
2494//                                              (errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
2495//                                               !cstate->csv_mode ?
2496//                                               errmsg("literal carriage return found in data") :
2497//                                               errmsg("unquoted carriage return found in data"),
2498//                                               !cstate->csv_mode ?
2499//                                         errhint("Use \"\\r\" to represent carriage return.") :
2500//                                               errhint("Use quoted CSV field to represent carriage return.")));
2501//                      /* If reach here, we have found the line terminator */
2502//                      break;
2503//              }
2504//
2505//              /* Process \n */
2506//              if (c == '\n' && (!cstate->csv_mode || !in_quote))
2507//              {
2508//                      if (cstate->eol_type == EOL_CR || cstate->eol_type == EOL_CRNL)
2509//                              ereport(ERROR,
2510//                                              (errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
2511//                                               !cstate->csv_mode ?
2512//                                               errmsg("literal newline found in data") :
2513//                                               errmsg("unquoted newline found in data"),
2514//                                               !cstate->csv_mode ?
2515//                                               errhint("Use \"\\n\" to represent newline.") :
2516//                                       errhint("Use quoted CSV field to represent newline.")));
2517//                      cstate->eol_type = EOL_NL;      /* in case not set yet */
2518//                      /* If reach here, we have found the line terminator */
2519//                      break;
2520//              }
2521//
2522//              /*
2523//               * In CSV mode, we only recognize \. alone on a line.  This is because
2524//               * \. is a valid CSV data value.
2525//               */
2526//              if (c == '\\' && (!cstate->csv_mode || first_char_in_line))
2527//              {
2528//                      char            c2;
2529//
2530//                      IF_NEED_REFILL_AND_NOT_EOF_CONTINUE(0);
2531//                      IF_NEED_REFILL_AND_EOF_BREAK(0);
2532//
2533//                      /* -----
2534//                       * get next character
2535//                       * Note: we do not change c so if it isn't \., we can fall
2536//                       * through and continue processing for client encoding.
2537//                       * -----
2538//                       */
2539//                      c2 = copy_raw_buf[raw_buf_ptr];
2540//
2541//                      if (c2 == '.')
2542//                      {
2543//                              raw_buf_ptr++;  /* consume the '.' */
2544//
2545//                              /*
2546//                               * Note: if we loop back for more data here, it does not
2547//                               * matter that the CSV state change checks are re-executed; we
2548//                               * will come back here with no important state changed.
2549//                               */
2550//                              if (cstate->eol_type == EOL_CRNL)
2551//                              {
2552//                                      /* Get the next character */
2553//                                      IF_NEED_REFILL_AND_NOT_EOF_CONTINUE(0);
2554//                                      /* if hit_eof, c2 will become '\0' */
2555//                                      c2 = copy_raw_buf[raw_buf_ptr++];
2556//
2557//                                      if (c2 == '\n')
2558//                                      {
2559//                                              if (!cstate->csv_mode)
2560//                                                      ereport(ERROR,
2561//                                                                      (errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
2562//                                                                       errmsg("end-of-copy marker does not match previous newline style")));
2563//                                              else
2564//                                                      NO_END_OF_COPY_GOTO;
2565//                                      }
2566//                                      else if (c2 != '\r')
2567//                                      {
2568//                                              if (!cstate->csv_mode)
2569//                                                      ereport(ERROR,
2570//                                                                      (errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
2571//                                                                       errmsg("end-of-copy marker corrupt")));
2572//                                              else
2573//                                                      NO_END_OF_COPY_GOTO;
2574//                                      }
2575//                              }
2576//
2577//                              /* Get the next character */
2578//                              IF_NEED_REFILL_AND_NOT_EOF_CONTINUE(0);
2579//                              /* if hit_eof, c2 will become '\0' */
2580//                              c2 = copy_raw_buf[raw_buf_ptr++];
2581//
2582//                              if (c2 != '\r' && c2 != '\n')
2583//                              {
2584//                                      if (!cstate->csv_mode)
2585//                                              ereport(ERROR,
2586//                                                              (errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
2587//                                                               errmsg("end-of-copy marker corrupt")));
2588//                                      else
2589//                                              NO_END_OF_COPY_GOTO;
2590//                              }
2591//
2592//                              if ((cstate->eol_type == EOL_NL && c2 != '\n') ||
2593//                                      (cstate->eol_type == EOL_CRNL && c2 != '\n') ||
2594//                                      (cstate->eol_type == EOL_CR && c2 != '\r'))
2595//                              {
2596//                                      ereport(ERROR,
2597//                                                      (errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
2598//                                                       errmsg("end-of-copy marker does not match previous newline style")));
2599//                              }
2600//
2601//                              /*
2602//                               * Transfer only the data before the \. into line_buf, then
2603//                               * discard the data and the \. sequence.
2604//                               */
2605//                              if (prev_raw_ptr > cstate->raw_buf_index)
2606//                                      appendBinaryStringInfo(&cstate->line_buf,
2607//                                                                       cstate->raw_buf + cstate->raw_buf_index,
2608//                                                                         prev_raw_ptr - cstate->raw_buf_index);
2609//                              cstate->raw_buf_index = raw_buf_ptr;
2610//                              result = true;  /* report EOF */
2611//                              break;
2612//                      }
2613//                      else if (!cstate->csv_mode)
2614//
2615//                              /*
2616//                               * If we are here, it means we found a backslash followed by
2617//                               * something other than a period.  In non-CSV mode, anything
2618//                               * after a backslash is special, so we skip over that second
2619//                               * character too.  If we didn't do that \\. would be
2620//                               * considered an eof-of copy, while in non-CVS mode it is a
2621//                               * literal backslash followed by a period.      In CSV mode,
2622//                               * backslashes are not special, so we want to process the
2623//                               * character after the backslash just like a normal character,
2624//                               * so we don't increment in those cases.
2625//                               */
2626//                              raw_buf_ptr++;
2627//              }
2628//
2629//              /*
2630//               * This label is for CSV cases where \. appears at the start of a
2631//               * line, but there is more text after it, meaning it was a data value.
2632//               * We are more strict for \. in CSV mode because \. could be a data
2633//               * value, while in non-CSV mode, \. cannot be a data value.
2634//               */
2635//not_end_of_copy:
2636//
2637//              /*
2638//               * Process all bytes of a multi-byte character as a group.
2639//               *
2640//               * We only support multi-byte sequences where the first byte has the
2641//               * high-bit set, so as an optimization we can avoid this block
2642//               * entirely if it is not set.
2643//               */
2644//              if (cstate->encoding_embeds_ascii && IS_HIGHBIT_SET(c))
2645//              {
2646//                      int                     mblen;
2647//
2648//                      mblen_str[0] = c;
2649//                      /* All our encodings only read the first byte to get the length */
2650//                      mblen = pg_encoding_mblen(cstate->client_encoding, mblen_str);
2651//                      IF_NEED_REFILL_AND_NOT_EOF_CONTINUE(mblen - 1);
2652//                      IF_NEED_REFILL_AND_EOF_BREAK(mblen - 1);
2653//                      raw_buf_ptr += mblen - 1;
2654//              }
2655//              first_char_in_line = false;
2656//      }                                                       /* end of outer loop */
2657//
2658//      /*
2659//       * Transfer any still-uncopied data to line_buf.
2660//       */
2661//      REFILL_LINEBUF;
2662//
2663//      return result;
2664//}
2665
2666
2667static bool
2668CopyReadLineText(CopyState cstate)
2669{
2670        char       *copy_raw_buf;
2671        int                     raw_buf_ptr;
2672        int                     copy_buf_len;
2673        bool            need_data = false;
2674        bool            hit_eof = false;
2675        bool            result = false;
2676        char            mblen_str[2];
2677
2678        /* CSV variables */
2679        bool            first_char_in_line = true;
2680        char            c,c2;
2681       
2682        mblen_str[1] = '\0';
2683       
2684        copy_raw_buf = cstate->raw_buf;
2685        raw_buf_ptr = cstate->raw_buf_index;
2686        copy_buf_len = cstate->raw_buf_len;
2687
2688        if (cstate->csv_mode){
2689               
2690                if (copy_raw_buf[raw_buf_ptr]=='\\' && copy_raw_buf[raw_buf_ptr+1]=='.'){
2691                        if( copy_raw_buf[raw_buf_ptr+2]=='\n'|| copy_raw_buf[raw_buf_ptr+2]=='\r')
2692                                return 1;
2693                }
2694                while(1){       
2695                        if (raw_buf_ptr >= copy_buf_len)
2696                        {
2697                                raw_buf_ptr = copy_buf_len;
2698                                c = copy_raw_buf[raw_buf_ptr-1];
2699                                if (!CopyLoadRawBuf(cstate))
2700                                        cstate->fe_eof = true;
2701                                       
2702                                bitstream_gen(cstate);
2703//                              if(cstate->quote[0]==cstate->escape[0])
2704//                                      bitstream_gen(cstate);
2705//                              else
2706//                                      bitstream_gen2(cstate);
2707                                raw_buf_ptr = 0;
2708                                copy_buf_len = cstate->raw_buf_len;
2709       
2710                        }
2711                        if(bitblock_has_bit(cstate->EOL_stream[raw_buf_ptr/BLOCK_SIZE_BITS])){
2712                                break;
2713                        }
2714                        else {
2715                                raw_buf_ptr = (raw_buf_ptr/BLOCK_SIZE_BITS+1)*BLOCK_SIZE_BITS;
2716                                if(cstate->fe_eof==1 && raw_buf_ptr > copy_buf_len)
2717                                        return true;
2718                        }
2719                }
2720               
2721                raw_buf_ptr = raw_buf_ptr/BLOCK_SIZE_BITS*BLOCK_SIZE_BITS + count_forward_zeroes(cstate->EOL_stream[raw_buf_ptr/BLOCK_SIZE_BITS]);
2722                cstate->EOL_stream[raw_buf_ptr/BLOCK_SIZE_BITS] = simd_and(cstate->EOL_stream[raw_buf_ptr/BLOCK_SIZE_BITS],simd_sll_128(simd_const_1(1),sisd_from_int(raw_buf_ptr%BLOCK_SIZE_BITS+1)));
2723               
2724                if(raw_buf_ptr!=0){
2725                        c = copy_raw_buf[raw_buf_ptr-1];
2726                        c2 = copy_raw_buf[raw_buf_ptr];
2727                }
2728                else{
2729                        c2 = copy_raw_buf[0];
2730                }
2731               
2732                if(c=='\r'){
2733                        if(c2=='\n')
2734                                if(cstate->eol_type == EOL_UNKNOWN ||cstate->eol_type == EOL_CRNL){
2735                                        cstate->eol_type = EOL_CRNL;   
2736                                        raw_buf_ptr++;
2737                                }
2738                                else
2739                                        ereport(ERROR,
2740                                                        (errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
2741                                                         errmsg("unquoted carriage return found in data"),
2742                                                         errhint("Use quoted CSV field to represent newline.")));
2743                        else if(cstate->eol_type == EOL_UNKNOWN ||cstate->eol_type == EOL_CR)
2744                                        cstate->eol_type = EOL_CR;
2745                                else
2746                                        ereport(ERROR,
2747                                                        (errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
2748                                                         errmsg("unquoted carriage return found in data"),
2749                                                         errhint("Use quoted CSV field to represent newline.")));
2750                }
2751                else if(c2=='\n')
2752                        if(cstate->eol_type == EOL_CR || cstate->eol_type == EOL_CRNL)
2753                                ereport(ERROR,
2754                                                (errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
2755                                                 errmsg("unquoted newline found in data"),
2756                                                 errhint("Use quoted CSV field to represent newline.")));
2757                        else{
2758                                cstate->eol_type = EOL_NL;     
2759                                raw_buf_ptr++;
2760                        }
2761               
2762        }
2763        else
2764        {
2765                for (;;)
2766                {
2767                        int                     prev_raw_ptr;
2768                        /*
2769                         * Load more data if needed.  Ideally we would just force four bytes
2770                         * of read-ahead and avoid the many calls to
2771                         * IF_NEED_REFILL_AND_NOT_EOF_CONTINUE(), but the COPY_OLD_FE protocol
2772                         * does not allow us to read too far ahead or we might read into the
2773                         * next data, so we read-ahead only as far we know we can.      One
2774                         * optimization would be to read-ahead four byte here if
2775                         * cstate->copy_dest != COPY_OLD_FE, but it hardly seems worth it,
2776                         * considering the size of the buffer.
2777                         */
2778                        if (raw_buf_ptr >= copy_buf_len || need_data)
2779                        {
2780                                REFILL_LINEBUF;
2781       
2782                                /*
2783                                 * Try to read some more data.  This will certainly reset
2784                                 * raw_buf_index to zero, and raw_buf_ptr must go with it.
2785                                 */
2786                                if (!CopyLoadRawBuf(cstate))
2787                                        hit_eof = true;
2788                                raw_buf_ptr = 0;
2789                                copy_buf_len = cstate->raw_buf_len;
2790       
2791                                /*
2792                                 * If we are completely out of data, break out of the loop,
2793                                 * reporting EOF.
2794                                 */
2795                                if (copy_buf_len <= 0)
2796                                {
2797                                        result = true;
2798                                        break;
2799                                }
2800                                need_data = false;
2801                        }
2802       
2803                        /* OK to fetch a character */
2804                        prev_raw_ptr = raw_buf_ptr;
2805                        c = copy_raw_buf[raw_buf_ptr++];
2806                       
2807                        /* Process \r */
2808                        if (c == '\r' )
2809                        {
2810                                /* Check for \r\n on first line, _and_ handle \r\n. */
2811                                if (cstate->eol_type == EOL_UNKNOWN ||
2812                                        cstate->eol_type == EOL_CRNL)
2813                                {
2814                                        /*
2815                                         * If need more data, go back to loop top to load it.
2816                                         *
2817                                         * Note that if we are at EOF, c will wind up as '\0' because
2818                                         * of the guaranteed pad of raw_buf.
2819                                         */
2820                                        IF_NEED_REFILL_AND_NOT_EOF_CONTINUE(0);
2821       
2822                                        /* get next char */
2823                                        c = copy_raw_buf[raw_buf_ptr];
2824       
2825                                        if (c == '\n')
2826                                        {
2827                                                raw_buf_ptr++;          /* eat newline */
2828                                                cstate->eol_type = EOL_CRNL;            /* in case not set yet */
2829                                        }
2830                                        else
2831                                        {
2832                                                /* found \r, but no \n */
2833                                                if (cstate->eol_type == EOL_CRNL)
2834                                                        ereport(ERROR,
2835                                                                        (errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
2836                                                                        errmsg("literal carriage return found in data") ,
2837                                                                        errhint("Use \"\\r\" to represent carriage return.") ));
2838       
2839                                                /*
2840                                                 * if we got here, it is the first line and we didn't find
2841                                                 * \n, so don't consume the peeked character
2842                                                 */
2843                                                cstate->eol_type = EOL_CR;
2844                                        }
2845                                }
2846                                else if (cstate->eol_type == EOL_NL)
2847                                        ereport(ERROR,
2848                                                        (errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
2849                                                         errmsg("literal carriage return found in data"),
2850                                                         errhint("Use \"\\r\" to represent carriage return.")));
2851                                /* If reach here, we have found the line terminator */
2852                                break;
2853                        }
2854       
2855                        /* Process \n */
2856                        if (c == '\n')
2857                        {
2858                                if (cstate->eol_type == EOL_CR || cstate->eol_type == EOL_CRNL)
2859                                        ereport(ERROR,
2860                                                        (errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
2861                                                         errmsg("literal newline found in data") ,
2862                                                         errhint("Use \"\\n\" to represent newline.")));
2863                                cstate->eol_type = EOL_NL;      /* in case not set yet */
2864                                /* If reach here, we have found the line terminator */
2865                                break;
2866                        }
2867       
2868                        /*
2869                         * In CSV mode, we only recognize \. alone on a line.  This is because
2870                         * \. is a valid CSV data value.
2871                         */
2872                        if (c == '\\')
2873                        {
2874                                char            c2;
2875       
2876                                IF_NEED_REFILL_AND_NOT_EOF_CONTINUE(0);
2877                                IF_NEED_REFILL_AND_EOF_BREAK(0);
2878       
2879                                /* -----
2880                                 * get next character
2881                                 * Note: we do not change c so if it isn't \., we can fall
2882                                 * through and continue processing for client encoding.
2883                                 * -----
2884                                 */
2885                                c2 = copy_raw_buf[raw_buf_ptr];
2886       
2887                                if (c2 == '.')
2888                                {
2889                                        raw_buf_ptr++;  /* consume the '.' */
2890       
2891                                        /*
2892                                         * Note: if we loop back for more data here, it does not
2893                                         * matter that the CSV state change checks are re-executed; we
2894                                         * will come back here with no important state changed.
2895                                         */
2896                                        if (cstate->eol_type == EOL_CRNL)
2897                                        {
2898                                                /* Get the next character */
2899                                                IF_NEED_REFILL_AND_NOT_EOF_CONTINUE(0);
2900                                                /* if hit_eof, c2 will become '\0' */
2901                                                c2 = copy_raw_buf[raw_buf_ptr++];
2902       
2903                                                if (c2 == '\n')
2904                                                {
2905                                                        ereport(ERROR,
2906                                                                                (errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
2907                                                                                 errmsg("end-of-copy marker does not match previous newline style")));
2908                                                }
2909                                                else if (c2 != '\r')
2910                                                {
2911                                                        ereport(ERROR,
2912                                                                                (errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
2913                                                                                 errmsg("end-of-copy marker corrupt")));
2914                                                }
2915                                        }
2916       
2917                                        /* Get the next character */
2918                                        IF_NEED_REFILL_AND_NOT_EOF_CONTINUE(0);
2919                                        /* if hit_eof, c2 will become '\0' */
2920                                        c2 = copy_raw_buf[raw_buf_ptr++];
2921       
2922                                        if (c2 != '\r' && c2 != '\n')
2923                                        {
2924                                                ereport(ERROR,
2925                                                                        (errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
2926                                                                         errmsg("end-of-copy marker corrupt")));
2927                                        }
2928       
2929                                        if ((cstate->eol_type == EOL_NL && c2 != '\n') ||
2930                                                (cstate->eol_type == EOL_CRNL && c2 != '\n') ||
2931                                                (cstate->eol_type == EOL_CR && c2 != '\r'))
2932                                        {
2933                                                ereport(ERROR,
2934                                                                (errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
2935                                                                 errmsg("end-of-copy marker does not match previous newline style")));
2936                                        }
2937       
2938                                        /*
2939                                         * Transfer only the data before the \. into line_buf, then
2940                                         * discard the data and the \. sequence.
2941                                         */
2942                                        if (prev_raw_ptr > cstate->raw_buf_index)
2943                                                appendBinaryStringInfo(&cstate->line_buf,
2944                                                                                 cstate->raw_buf + cstate->raw_buf_index,
2945                                                                                   prev_raw_ptr - cstate->raw_buf_index);
2946                                        cstate->raw_buf_index = raw_buf_ptr;
2947                                        result = true;  /* report EOF */
2948                                        break;
2949                                }
2950                                else 
2951       
2952                                        /*
2953                                         * If we are here, it means we found a backslash followed by
2954                                         * something other than a period.  In non-CSV mode, anything
2955                                         * after a backslash is special, so we skip over that second
2956                                         * character too.  If we didn't do that \\. would be
2957                                         * considered an eof-of copy, while in non-CVS mode it is a
2958                                         * literal backslash followed by a period.      In CSV mode,
2959                                         * backslashes are not special, so we want to process the
2960                                         * character after the backslash just like a normal character,
2961                                         * so we don't increment in those cases.
2962                                         */
2963                                        raw_buf_ptr++;
2964                        }
2965
2966                        /*
2967                         * This label is for CSV cases where \. appears at the start of a
2968                         * line, but there is more text after it, meaning it was a data value.
2969                         * We are more strict for \. in CSV mode because \. could be a data
2970                         * value, while in non-CSV mode, \. cannot be a data value.
2971                         */
2972        not_end_of_copy:
2973       
2974                        /*
2975                         * Process all bytes of a multi-byte character as a group.
2976                         *
2977                         * We only support multi-byte sequences where the first byte has the
2978                         * high-bit set, so as an optimization we can avoid this block
2979                         * entirely if it is not set.
2980                         */
2981                        if (cstate->encoding_embeds_ascii && IS_HIGHBIT_SET(c))
2982                        {
2983                                int                     mblen;
2984       
2985                                mblen_str[0] = c;
2986                                /* All our encodings only read the first byte to get the length */
2987                                mblen = pg_encoding_mblen(cstate->client_encoding, mblen_str);
2988                                IF_NEED_REFILL_AND_NOT_EOF_CONTINUE(mblen - 1);
2989                                IF_NEED_REFILL_AND_EOF_BREAK(mblen - 1);
2990                                raw_buf_ptr += mblen - 1;
2991                        }
2992                        first_char_in_line = false;
2993               
2994                }       /* end of outer loop */
2995        }                                               
2996
2997        /*
2998         * Transfer any still-uncopied data to line_buf.
2999         */
3000        REFILL_LINEBUF;
3001
3002        return result;
3003}
3004/*
3005 *      Return decimal value for a hexadecimal digit
3006 */
3007static int
3008GetDecimalFromHex(char hex)
3009{
3010        if (isdigit((unsigned char) hex))
3011                return hex - '0';
3012        else
3013                return tolower((unsigned char) hex) - 'a' + 10;
3014}
3015
3016/*
3017 * Parse the current line into separate attributes (fields),
3018 * performing de-escaping as needed.
3019 *
3020 * The input is in line_buf.  We use attribute_buf to hold the result
3021 * strings.  fieldvals[k] is set to point to the k'th attribute string,
3022 * or NULL when the input matches the null marker string.  (Note that the
3023 * caller cannot check for nulls since the returned string would be the
3024 * post-de-escaping equivalent, which may look the same as some valid data
3025 * string.)
3026 *
3027 * delim is the column delimiter string (must be just one byte for now).
3028 * null_print is the null marker string.  Note that this is compared to
3029 * the pre-de-escaped input string.
3030 *
3031 * The return value is the number of fields actually read.      (We error out
3032 * if this would exceed maxfields, which is the length of fieldvals[].)
3033 */
3034static int
3035CopyReadAttributesText(CopyState cstate, int maxfields, char **fieldvals)
3036{
3037        char            delimc = cstate->delim[0];
3038        int                     fieldno;
3039        char       *output_ptr;
3040        char       *cur_ptr;
3041        char       *line_end_ptr;
3042
3043        /*
3044         * We need a special case for zero-column tables: check that the input
3045         * line is empty, and return.
3046         */
3047        if (maxfields <= 0)
3048        {
3049                if (cstate->line_buf.len != 0)
3050                        ereport(ERROR,
3051                                        (errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
3052                                         errmsg("extra data after last expected column")));
3053                return 0;
3054        }
3055
3056        resetStringInfo(&cstate->attribute_buf);
3057
3058        /*
3059         * The de-escaped attributes will certainly not be longer than the input
3060         * data line, so we can just force attribute_buf to be large enough and
3061         * then transfer data without any checks for enough space.      We need to do
3062         * it this way because enlarging attribute_buf mid-stream would invalidate
3063         * pointers already stored into fieldvals[].
3064         */
3065        if (cstate->attribute_buf.maxlen <= cstate->line_buf.len)
3066                enlargeStringInfo(&cstate->attribute_buf, cstate->line_buf.len);
3067        output_ptr = cstate->attribute_buf.data;
3068
3069        /* set pointer variables for loop */
3070        cur_ptr = cstate->line_buf.data;
3071        line_end_ptr = cstate->line_buf.data + cstate->line_buf.len;
3072
3073        /* Outer loop iterates over fields */
3074        fieldno = 0;
3075        for (;;)
3076        {
3077                bool            found_delim = false;
3078                char       *start_ptr;
3079                char       *end_ptr;
3080                int                     input_len;
3081                bool            saw_non_ascii = false;
3082
3083                /* Make sure space remains in fieldvals[] */
3084                if (fieldno >= maxfields)
3085                        ereport(ERROR,
3086                                        (errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
3087                                         errmsg("extra data after last expected column")));
3088
3089                /* Remember start of field on both input and output sides */
3090                start_ptr = cur_ptr;
3091                fieldvals[fieldno] = output_ptr;
3092
3093                /* Scan data for field */
3094                for (;;)
3095                {
3096                        char            c;
3097
3098                        end_ptr = cur_ptr;
3099                        if (cur_ptr >= line_end_ptr)
3100                                break;
3101                        c = *cur_ptr++;
3102                        if (c == delimc)
3103                        {
3104                                found_delim = true;
3105                                break;
3106                        }
3107                        if (c == '\\')
3108                        {
3109                                if (cur_ptr >= line_end_ptr)
3110                                        break;
3111                                c = *cur_ptr++;
3112                                switch (c)
3113                                {
3114                                        case '0':
3115                                        case '1':
3116                                        case '2':
3117                                        case '3':
3118                                        case '4':
3119                                        case '5':
3120                                        case '6':
3121                                        case '7':
3122                                                {
3123                                                        /* handle \013 */
3124                                                        int                     val;
3125
3126                                                        val = OCTVALUE(c);
3127                                                        if (cur_ptr < line_end_ptr)
3128                                                        {
3129                                                                c = *cur_ptr;
3130                                                                if (ISOCTAL(c))
3131                                                                {
3132                                                                        cur_ptr++;
3133                                                                        val = (val << 3) + OCTVALUE(c);
3134                                                                        if (cur_ptr < line_end_ptr)
3135                                                                        {
3136                                                                                c = *cur_ptr;
3137                                                                                if (ISOCTAL(c))
3138                                                                                {
3139                                                                                        cur_ptr++;
3140                                                                                        val = (val << 3) + OCTVALUE(c);
3141                                                                                }
3142                                                                        }
3143                                                                }
3144                                                        }
3145                                                        c = val & 0377;
3146                                                        if (c == '\0' || IS_HIGHBIT_SET(c))
3147                                                                saw_non_ascii = true;
3148                                                }
3149                                                break;
3150                                        case 'x':
3151                                                /* Handle \x3F */
3152                                                if (cur_ptr < line_end_ptr)
3153                                                {
3154                                                        char            hexchar = *cur_ptr;
3155
3156                                                        if (isxdigit((unsigned char) hexchar))
3157                                                        {
3158                                                                int                     val = GetDecimalFromHex(hexchar);
3159
3160                                                                cur_ptr++;
3161                                                                if (cur_ptr < line_end_ptr)
3162                                                                {
3163                                                                        hexchar = *cur_ptr;
3164                                                                        if (isxdigit((unsigned char) hexchar))
3165                                                                        {
3166                                                                                cur_ptr++;
3167                                                                                val = (val << 4) + GetDecimalFromHex(hexchar);
3168                                                                        }
3169                                                                }
3170                                                                c = val & 0xff;
3171                                                                if (c == '\0' || IS_HIGHBIT_SET(c))
3172                                                                        saw_non_ascii = true;
3173                                                        }
3174                                                }
3175                                                break;
3176                                        case 'b':
3177                                                c = '\b';
3178                                                break;
3179                                        case 'f':
3180                                                c = '\f';
3181                                                break;
3182                                        case 'n':
3183                                                c = '\n';
3184                                                break;
3185                                        case 'r':
3186                                                c = '\r';
3187                                                break;
3188                                        case 't':
3189                                                c = '\t';
3190                                                break;
3191                                        case 'v':
3192                                                c = '\v';
3193                                                break;
3194
3195                                                /*
3196                                                 * in all other cases, take the char after '\'
3197                                                 * literally
3198                                                 */
3199                                }
3200                        }
3201
3202                        /* Add c to output string */
3203                        *output_ptr++ = c;
3204                }
3205
3206                /* Terminate attribute value in output area */
3207                *output_ptr++ = '\0';
3208
3209                /*
3210                 * If we de-escaped a non-7-bit-ASCII char, make sure we still have
3211                 * valid data for the db encoding. Avoid calling strlen here for the
3212                 * sake of efficiency.
3213                 */
3214                if (saw_non_ascii)
3215                {
3216                        char       *fld = fieldvals[fieldno];
3217
3218                        pg_verifymbstr(fld, output_ptr - (fld + 1), false);
3219                }
3220
3221                /* Check whether raw input matched null marker */
3222                input_len = end_ptr - start_ptr;
3223                if (input_len == cstate->null_print_len &&
3224                        strncmp(start_ptr, cstate->null_print, input_len) == 0)
3225                        fieldvals[fieldno] = NULL;
3226
3227                fieldno++;
3228                /* Done if we hit EOL instead of a delim */
3229                if (!found_delim)
3230                        break;
3231        }
3232
3233        /* Clean up state of attribute_buf */
3234        output_ptr--;
3235        Assert(*output_ptr == '\0');
3236        cstate->attribute_buf.len = (output_ptr - cstate->attribute_buf.data);
3237
3238        return fieldno;
3239}
3240
3241/*
3242 * Parse the current line into separate attributes (fields),
3243 * performing de-escaping as needed.  This has exactly the same API as
3244 * CopyReadAttributesText, except we parse the fields according to
3245 * "standard" (i.e. common) CSV usage.
3246 */
3247static int
3248CopyReadAttributesCSV(CopyState cstate, int maxfields, char **fieldvals)
3249{
3250        char            delimc = cstate->delim[0];
3251        char            quotec = cstate->quote[0];
3252        char            escapec = cstate->escape[0];
3253        int                     fieldno;
3254        char       *output_ptr;
3255        char       *cur_ptr;
3256        char       *line_end_ptr;
3257
3258        /*
3259         * We need a special case for zero-column tables: check that the input
3260         * line is empty, and return.
3261         */
3262        if (maxfields <= 0)
3263        {
3264                if (cstate->line_buf.len != 0)
3265                        ereport(ERROR,
3266                                        (errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
3267                                         errmsg("extra data after last expected column")));
3268                return 0;
3269        }
3270
3271        resetStringInfo(&cstate->attribute_buf);
3272
3273        /*
3274         * The de-escaped attributes will certainly not be longer than the input
3275         * data line, so we can just force attribute_buf to be large enough and
3276         * then transfer data without any checks for enough space.      We need to do
3277         * it this way because enlarging attribute_buf mid-stream would invalidate
3278         * pointers already stored into fieldvals[].
3279         */
3280        if (cstate->attribute_buf.maxlen <= cstate->line_buf.len)
3281                enlargeStringInfo(&cstate->attribute_buf, cstate->line_buf.len);
3282        output_ptr = cstate->attribute_buf.data;
3283
3284        /* set pointer variables for loop */
3285        cur_ptr = cstate->line_buf.data;
3286        line_end_ptr = cstate->line_buf.data + cstate->line_buf.len;
3287
3288        /* Outer loop iterates over fields */
3289        fieldno = 0;
3290        for (;;)
3291        {
3292                bool            found_delim = false;
3293                bool            saw_quote = false;
3294                char       *start_ptr;
3295                char       *end_ptr;
3296                int                     input_len;
3297
3298                /* Make sure space remains in fieldvals[] */
3299                if (fieldno >= maxfields)
3300                        ereport(ERROR,
3301                                        (errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
3302                                         errmsg("extra data after last expected column")));
3303
3304                /* Remember start of field on both input and output sides */
3305                start_ptr = cur_ptr;
3306                fieldvals[fieldno] = output_ptr;
3307
3308                /*
3309                 * Scan data for field,
3310                 *
3311                 * The loop starts in "not quote" mode and then toggles between that
3312                 * and "in quote" mode. The loop exits normally if it is in "not
3313                 * quote" mode and a delimiter or line end is seen.
3314                 */
3315                for (;;)
3316                {
3317                        char            c;
3318
3319                        /* Not in quote */
3320                        for (;;)
3321                        {
3322                                end_ptr = cur_ptr;
3323                                if (cur_ptr >= line_end_ptr)
3324                                        goto endfield;
3325                                c = *cur_ptr++;
3326                                /* unquoted field delimiter */
3327                                if (c == delimc)
3328                                {
3329                                        found_delim = true;
3330                                        goto endfield;
3331                                }
3332                                /* start of quoted field (or part of field) */
3333                                if (c == quotec)
3334                                {
3335                                        saw_quote = true;
3336                                        break;
3337                                }
3338                                /* Add c to output string */
3339                                *output_ptr++ = c;
3340                        }
3341
3342                        /* In quote */
3343                        for (;;)
3344                        {
3345                                end_ptr = cur_ptr;
3346                                if (cur_ptr >= line_end_ptr)
3347                                        ereport(ERROR,
3348                                                        (errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
3349                                                         errmsg("unterminated CSV quoted field")));
3350
3351                                c = *cur_ptr++;
3352
3353                                /* escape within a quoted field */
3354                                if (c == escapec)
3355                                {
3356                                        /*
3357                                         * peek at the next char if available, and escape it if it
3358                                         * is an escape char or a quote char
3359                                         */
3360                                        if (cur_ptr < line_end_ptr)
3361                                        {
3362                                                char            nextc = *cur_ptr;
3363
3364                                                if (nextc == escapec || nextc == quotec)
3365                                                {
3366                                                        *output_ptr++ = nextc;
3367                                                        cur_ptr++;
3368                                                        continue;
3369                                                }
3370                                        }
3371                                }
3372
3373                                /*
3374                                 * end of quoted field. Must do this test after testing for
3375                                 * escape in case quote char and escape char are the same
3376                                 * (which is the common case).
3377                                 */
3378                                if (c == quotec)
3379                                        break;
3380
3381                                /* Add c to output string */
3382                                *output_ptr++ = c;
3383                        }
3384                }
3385endfield:
3386
3387                /* Terminate attribute value in output area */
3388                *output_ptr++ = '\0';
3389
3390                /* Check whether raw input matched null marker */
3391                input_len = end_ptr - start_ptr;
3392                if (!saw_quote && input_len == cstate->null_print_len &&
3393                        strncmp(start_ptr, cstate->null_print, input_len) == 0)
3394                        fieldvals[fieldno] = NULL;
3395
3396                fieldno++;
3397                /* Done if we hit EOL instead of a delim */
3398                if (!found_delim)
3399                        break;
3400        }
3401
3402        /* Clean up state of attribute_buf */
3403        output_ptr--;
3404        Assert(*output_ptr == '\0');
3405        cstate->attribute_buf.len = (output_ptr - cstate->attribute_buf.data);
3406
3407        return fieldno;
3408}
3409
3410
3411/*
3412 * Read a binary attribute
3413 */
3414static Datum
3415CopyReadBinaryAttribute(CopyState cstate,
3416                                                int column_no, FmgrInfo *flinfo,
3417                                                Oid typioparam, int32 typmod,
3418                                                bool *isnull)
3419{
3420        int32           fld_size;
3421        Datum           result;
3422
3423        if (!CopyGetInt32(cstate, &fld_size))
3424                ereport(ERROR,
3425                                (errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
3426                                 errmsg("unexpected EOF in COPY data")));
3427        if (fld_size == -1)
3428        {
3429                *isnull = true;
3430                return ReceiveFunctionCall(flinfo, NULL, typioparam, typmod);
3431        }
3432        if (fld_size < 0)
3433                ereport(ERROR,
3434                                (errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
3435                                 errmsg("invalid field size")));
3436
3437        /* reset attribute_buf to empty, and load raw data in it */
3438        resetStringInfo(&cstate->attribute_buf);
3439
3440        enlargeStringInfo(&cstate->attribute_buf, fld_size);
3441        if (CopyGetData(cstate, cstate->attribute_buf.data,
3442                                        fld_size, fld_size) != fld_size)
3443                ereport(ERROR,
3444                                (errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
3445                                 errmsg("unexpected EOF in COPY data")));
3446
3447        cstate->attribute_buf.len = fld_size;
3448        cstate->attribute_buf.data[fld_size] = '\0';
3449
3450        /* Call the column type's binary input converter */
3451        result = ReceiveFunctionCall(flinfo, &cstate->attribute_buf,
3452                                                                 typioparam, typmod);
3453
3454        /* Trouble if it didn't eat the whole buffer */
3455        if (cstate->attribute_buf.cursor != cstate->attribute_buf.len)
3456                ereport(ERROR,
3457                                (errcode(ERRCODE_INVALID_BINARY_REPRESENTATION),
3458                                 errmsg("incorrect binary data format")));
3459
3460        *isnull = false;
3461        return result;
3462}
3463
3464/*
3465 * Send text representation of one attribute, with conversion and escaping
3466 */
3467#define DUMPSOFAR() \
3468        do { \
3469                if (ptr > start) \
3470                        CopySendData(cstate, start, ptr - start); \
3471        } while (0)
3472
3473static void
3474CopyAttributeOutText(CopyState cstate, char *string)
3475{
3476        char       *ptr;
3477        char       *start;
3478        char            c;
3479        char            delimc = cstate->delim[0];
3480
3481        if (cstate->need_transcoding)
3482                ptr = pg_server_to_client(string, strlen(string));
3483        else
3484                ptr = string;
3485
3486        /*
3487         * We have to grovel through the string searching for control characters
3488         * and instances of the delimiter character.  In most cases, though, these
3489         * are infrequent.      To avoid overhead from calling CopySendData once per
3490         * character, we dump out all characters between escaped characters in a
3491         * single call.  The loop invariant is that the data from "start" to "ptr"
3492         * can be sent literally, but hasn't yet been.
3493         *
3494         * We can skip pg_encoding_mblen() overhead when encoding is safe, because
3495         * in valid backend encodings, extra bytes of a multibyte character never
3496         * look like ASCII.  This loop is sufficiently performance-critical that
3497         * it's worth making two copies of it to get the IS_HIGHBIT_SET() test out
3498         * of the normal safe-encoding path.
3499         */
3500        if (cstate->encoding_embeds_ascii)
3501        {
3502                start = ptr;
3503                while ((c = *ptr) != '\0')
3504                {
3505                        if ((unsigned char) c < (unsigned char) 0x20)
3506                        {
3507                                /*
3508                                 * \r and \n must be escaped, the others are traditional. We
3509                                 * prefer to dump these using the C-like notation, rather than
3510                                 * a backslash and the literal character, because it makes the
3511                                 * dump file a bit more proof against Microsoftish data
3512                                 * mangling.
3513                                 */
3514                                switch (c)
3515                                {
3516                                        case '\b':
3517                                                c = 'b';
3518                                                break;
3519                                        case '\f':
3520                                                c = 'f';
3521                                                break;
3522                                        case '\n':
3523                                                c = 'n';
3524                                                break;
3525                                        case '\r':
3526                                                c = 'r';
3527                                                break;
3528                                        case '\t':
3529                                                c = 't';
3530                                                break;
3531                                        case '\v':
3532                                                c = 'v';
3533                                                break;
3534                                        default:
3535                                                /* If it's the delimiter, must backslash it */
3536                                                if (c == delimc)
3537                                                        break;
3538                                                /* All ASCII control chars are length 1 */
3539                                                ptr++;
3540                                                continue;               /* fall to end of loop */
3541                                }
3542                                /* if we get here, we need to convert the control char */
3543                                DUMPSOFAR();
3544                                CopySendChar(cstate, '\\');
3545                                CopySendChar(cstate, c);
3546                                start = ++ptr;  /* do not include char in next run */
3547                        }
3548                        else if (c == '\\' || c == delimc)
3549                        {
3550                                DUMPSOFAR();
3551                                CopySendChar(cstate, '\\');
3552                                start = ptr++;  /* we include char in next run */
3553                        }
3554                        else if (IS_HIGHBIT_SET(c))
3555                                ptr += pg_encoding_mblen(cstate->client_encoding, ptr);
3556                        else
3557                                ptr++;
3558                }
3559        }
3560        else
3561        {
3562                start = ptr;
3563                while ((c = *ptr) != '\0')
3564                {
3565                        if ((unsigned char) c < (unsigned char) 0x20)
3566                        {
3567                                /*
3568                                 * \r and \n must be escaped, the others are traditional. We
3569                                 * prefer to dump these using the C-like notation, rather than
3570                                 * a backslash and the literal character, because it makes the
3571                                 * dump file a bit more proof against Microsoftish data
3572                                 * mangling.
3573                                 */
3574                                switch (c)
3575                                {
3576                                        case '\b':
3577                                                c = 'b';
3578                                                break;
3579                                        case '\f':
3580                                                c = 'f';
3581                                                break;
3582                                        case '\n':
3583                                                c = 'n';
3584                                                break;
3585                                        case '\r':
3586                                                c = 'r';
3587                                                break;
3588                                        case '\t':
3589                                                c = 't';
3590                                                break;
3591                                        case '\v':
3592                                                c = 'v';
3593                                                break;
3594                                        default:
3595                                                /* If it's the delimiter, must backslash it */
3596                                                if (c == delimc)
3597                                                        break;
3598                                                /* All ASCII control chars are length 1 */
3599                                                ptr++;
3600                                                continue;               /* fall to end of loop */
3601                                }
3602                                /* if we get here, we need to convert the control char */
3603                                DUMPSOFAR();
3604                                CopySendChar(cstate, '\\');
3605                                CopySendChar(cstate, c);
3606                                start = ++ptr;  /* do not include char in next run */
3607                        }
3608                        else if (c == '\\' || c == delimc)
3609                        {
3610                                DUMPSOFAR();
3611                                CopySendChar(cstate, '\\');
3612                                start = ptr++;  /* we include char in next run */
3613                        }
3614                        else
3615                                ptr++;
3616                }
3617        }
3618
3619        DUMPSOFAR();
3620}
3621
3622/*
3623 * Send text representation of one attribute, with conversion and
3624 * CSV-style escaping
3625 */
3626static void
3627CopyAttributeOutCSV(CopyState cstate, char *string,
3628                                        bool use_quote, bool single_attr)
3629{
3630        char       *ptr;
3631        char       *start;
3632        char            c;
3633        char            delimc = cstate->delim[0];
3634        char            quotec = cstate->quote[0];
3635        char            escapec = cstate->escape[0];
3636
3637        /* force quoting if it matches null_print (before conversion!) */
3638        if (!use_quote && strcmp(string, cstate->null_print) == 0)
3639                use_quote = true;
3640
3641        if (cstate->need_transcoding)
3642                ptr = pg_server_to_client(string, strlen(string));
3643        else
3644                ptr = string;
3645
3646        /*
3647         * Make a preliminary pass to discover if it needs quoting
3648         */
3649        if (!use_quote)
3650        {
3651                /*
3652                 * Because '\.' can be a data value, quote it if it appears alone on a
3653                 * line so it is not interpreted as the end-of-data marker.
3654                 */
3655                if (single_attr && strcmp(ptr, "\\.") == 0)
3656                        use_quote = true;
3657                else
3658                {
3659                        char       *tptr = ptr;
3660
3661                        while ((c = *tptr) != '\0')
3662                        {
3663                                if (c == delimc || c == quotec || c == '\n' || c == '\r')
3664                                {
3665                                        use_quote = true;
3666                                        break;
3667                                }
3668                                if (IS_HIGHBIT_SET(c) && cstate->encoding_embeds_ascii)
3669                                        tptr += pg_encoding_mblen(cstate->client_encoding, tptr);
3670                                else
3671                                        tptr++;
3672                        }
3673                }
3674        }
3675
3676        if (use_quote)
3677        {
3678                CopySendChar(cstate, quotec);
3679
3680                /*
3681                 * We adopt the same optimization strategy as in CopyAttributeOutText
3682                 */
3683                start = ptr;
3684                while ((c = *ptr) != '\0')
3685                {
3686                        if (c == quotec || c == escapec)
3687                        {
3688                                DUMPSOFAR();
3689                                CopySendChar(cstate, escapec);
3690                                start = ptr;    /* we include char in next run */
3691                        }
3692                        if (IS_HIGHBIT_SET(c) && cstate->encoding_embeds_ascii)
3693                                ptr += pg_encoding_mblen(cstate->client_encoding, ptr);
3694                        else
3695                                ptr++;
3696                }
3697                DUMPSOFAR();
3698
3699                CopySendChar(cstate, quotec);
3700        }
3701        else
3702        {
3703                /* If it doesn't need quoting, we can just dump it as-is */
3704                CopySendString(cstate, ptr);
3705        }
3706}
3707
3708/*
3709 * CopyGetAttnums - build an integer list of attnums to be copied
3710 *
3711 * The input attnamelist is either the user-specified column list,
3712 * or NIL if there was none (in which case we want all the non-dropped
3713 * columns).
3714 *
3715 * rel can be NULL ... it's only used for error reports.
3716 */
3717static List *
3718CopyGetAttnums(TupleDesc tupDesc, Relation rel, List *attnamelist)
3719{
3720        List       *attnums = NIL;
3721
3722        if (attnamelist == NIL)
3723        {
3724                /* Generate default column list */
3725                Form_pg_attribute *attr = tupDesc->attrs;
3726                int                     attr_count = tupDesc->natts;
3727                int                     i;
3728
3729                for (i = 0; i < attr_count; i++)
3730                {
3731                        if (attr[i]->attisdropped)
3732                                continue;
3733                        attnums = lappend_int(attnums, i + 1);
3734                }
3735        }
3736        else
3737        {
3738                /* Validate the user-supplied list and extract attnums */
3739                ListCell   *l;
3740
3741                foreach(l, attnamelist)
3742                {
3743                        char       *name = strVal(lfirst(l));
3744                        int                     attnum;
3745                        int                     i;
3746
3747                        /* Lookup column name */
3748                        attnum = InvalidAttrNumber;
3749                        for (i = 0; i < tupDesc->natts; i++)
3750                        {
3751                                if (tupDesc->attrs[i]->attisdropped)
3752                                        continue;
3753                                if (namestrcmp(&(tupDesc->attrs[i]->attname), name) == 0)
3754                                {
3755                                        attnum = tupDesc->attrs[i]->attnum;
3756                                        break;
3757                                }
3758                        }
3759                        if (attnum == InvalidAttrNumber)
3760                        {
3761                                if (rel != NULL)
3762                                        ereport(ERROR,
3763                                                        (errcode(ERRCODE_UNDEFINED_COLUMN),
3764                                        errmsg("column \"%s\" of relation \"%s\" does not exist",
3765                                                   name, RelationGetRelationName(rel))));
3766                                else
3767                                        ereport(ERROR,
3768                                                        (errcode(ERRCODE_UNDEFINED_COLUMN),
3769                                                         errmsg("column \"%s\" does not exist",
3770                                                                        name)));
3771                        }
3772                        /* Check for duplicates */
3773                        if (list_member_int(attnums, attnum))
3774                                ereport(ERROR,
3775                                                (errcode(ERRCODE_DUPLICATE_COLUMN),
3776                                                 errmsg("column \"%s\" specified more than once",
3777                                                                name)));
3778                        attnums = lappend_int(attnums, attnum);
3779                }
3780        }
3781
3782        return attnums;
3783}
3784
3785
3786/*
3787 * copy_dest_startup --- executor startup
3788 */
3789static void
3790copy_dest_startup(DestReceiver *self, int operation, TupleDesc typeinfo)
3791{
3792        /* no-op */
3793}
3794
3795/*
3796 * copy_dest_receive --- receive one tuple
3797 */
3798static void
3799copy_dest_receive(TupleTableSlot *slot, DestReceiver *self)
3800{
3801        DR_copy    *myState = (DR_copy *) self;
3802        CopyState       cstate = myState->cstate;
3803
3804        /* Make sure the tuple is fully deconstructed */
3805        slot_getallattrs(slot);
3806
3807        /* And send the data */
3808        CopyOneRowTo(cstate, InvalidOid, slot->tts_values, slot->tts_isnull);
3809}
3810
3811/*
3812 * copy_dest_shutdown --- executor end
3813 */
3814static void
3815copy_dest_shutdown(DestReceiver *self)
3816{
3817        /* no-op */
3818}
3819
3820/*
3821 * copy_dest_destroy --- release DestReceiver object
3822 */
3823static void
3824copy_dest_destroy(DestReceiver *self)
3825{
3826        pfree(self);
3827}
3828
3829/*
3830 * CreateCopyDestReceiver -- create a suitable DestReceiver object
3831 */
3832DestReceiver *
3833CreateCopyDestReceiver(void)
3834{
3835        DR_copy    *self = (DR_copy *) palloc(sizeof(DR_copy));
3836
3837        self->pub.receiveSlot = copy_dest_receive;
3838        self->pub.rStartup = copy_dest_startup;
3839        self->pub.rShutdown = copy_dest_shutdown;
3840        self->pub.rDestroy = copy_dest_destroy;
3841        self->pub.mydest = DestCopyOut;
3842
3843        self->cstate = NULL;            /* will be set later */
3844
3845        return (DestReceiver *) self;
3846}
Note: See TracBrowser for help on using the repository browser.