PostgreSQL Source Code  git master
copy.c File Reference
#include "postgres.h"
#include <ctype.h>
#include <unistd.h>
#include <sys/stat.h>
#include "access/sysattr.h"
#include "access/table.h"
#include "access/xact.h"
#include "catalog/pg_authid.h"
#include "commands/copy.h"
#include "commands/defrem.h"
#include "executor/executor.h"
#include "mb/pg_wchar.h"
#include "miscadmin.h"
#include "nodes/makefuncs.h"
#include "optimizer/optimizer.h"
#include "parser/parse_coerce.h"
#include "parser/parse_collate.h"
#include "parser/parse_expr.h"
#include "parser/parse_relation.h"
#include "utils/acl.h"
#include "utils/builtins.h"
#include "utils/lsyscache.h"
#include "utils/rel.h"
#include "utils/rls.h"
Include dependency graph for copy.c:

Go to the source code of this file.

Functions

void DoCopy (ParseState *pstate, const CopyStmt *stmt, int stmt_location, int stmt_len, uint64 *processed)
 
static CopyHeaderChoice defGetCopyHeaderChoice (DefElem *def, bool is_from)
 
static CopyOnErrorChoice defGetCopyOnErrorChoice (DefElem *def, ParseState *pstate, bool is_from)
 
static CopyLogVerbosityChoice defGetCopyLogVerbosityChoice (DefElem *def, ParseState *pstate)
 
void ProcessCopyOptions (ParseState *pstate, CopyFormatOptions *opts_out, bool is_from, List *options)
 
ListCopyGetAttnums (TupleDesc tupDesc, Relation rel, List *attnamelist)
 

Function Documentation

◆ CopyGetAttnums()

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

Definition at line 858 of file copy.c.

859 {
860  List *attnums = NIL;
861 
862  if (attnamelist == NIL)
863  {
864  /* Generate default column list */
865  int attr_count = tupDesc->natts;
866  int i;
867 
868  for (i = 0; i < attr_count; i++)
869  {
870  if (TupleDescAttr(tupDesc, i)->attisdropped)
871  continue;
872  if (TupleDescAttr(tupDesc, i)->attgenerated)
873  continue;
874  attnums = lappend_int(attnums, i + 1);
875  }
876  }
877  else
878  {
879  /* Validate the user-supplied list and extract attnums */
880  ListCell *l;
881 
882  foreach(l, attnamelist)
883  {
884  char *name = strVal(lfirst(l));
885  int attnum;
886  int i;
887 
888  /* Lookup column name */
890  for (i = 0; i < tupDesc->natts; i++)
891  {
892  Form_pg_attribute att = TupleDescAttr(tupDesc, i);
893 
894  if (att->attisdropped)
895  continue;
896  if (namestrcmp(&(att->attname), name) == 0)
897  {
898  if (att->attgenerated)
899  ereport(ERROR,
900  (errcode(ERRCODE_INVALID_COLUMN_REFERENCE),
901  errmsg("column \"%s\" is a generated column",
902  name),
903  errdetail("Generated columns cannot be used in COPY.")));
904  attnum = att->attnum;
905  break;
906  }
907  }
908  if (attnum == InvalidAttrNumber)
909  {
910  if (rel != NULL)
911  ereport(ERROR,
912  (errcode(ERRCODE_UNDEFINED_COLUMN),
913  errmsg("column \"%s\" of relation \"%s\" does not exist",
914  name, RelationGetRelationName(rel))));
915  else
916  ereport(ERROR,
917  (errcode(ERRCODE_UNDEFINED_COLUMN),
918  errmsg("column \"%s\" does not exist",
919  name)));
920  }
921  /* Check for duplicates */
922  if (list_member_int(attnums, attnum))
923  ereport(ERROR,
924  (errcode(ERRCODE_DUPLICATE_COLUMN),
925  errmsg("column \"%s\" specified more than once",
926  name)));
927  attnums = lappend_int(attnums, attnum);
928  }
929  }
930 
931  return attnums;
932 }
#define InvalidAttrNumber
Definition: attnum.h:23
int errdetail(const char *fmt,...)
Definition: elog.c:1205
int errcode(int sqlerrcode)
Definition: elog.c:855
int errmsg(const char *fmt,...)
Definition: elog.c:1072
#define ERROR
Definition: elog.h:39
#define ereport(elevel,...)
Definition: elog.h:149
int i
Definition: isn.c:73
List * lappend_int(List *list, int datum)
Definition: list.c:357
bool list_member_int(const List *list, int datum)
Definition: list.c:702
int namestrcmp(Name name, const char *str)
Definition: name.c:247
int16 attnum
Definition: pg_attribute.h:74
FormData_pg_attribute * Form_pg_attribute
Definition: pg_attribute.h:209
#define lfirst(lc)
Definition: pg_list.h:172
#define NIL
Definition: pg_list.h:68
#define RelationGetRelationName(relation)
Definition: rel.h:539
Definition: pg_list.h:54
#define TupleDescAttr(tupdesc, i)
Definition: tupdesc.h:92
#define strVal(v)
Definition: value.h:82
const char * name

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

Referenced by BeginCopyFrom(), BeginCopyTo(), and DoCopy().

◆ defGetCopyHeaderChoice()

static CopyHeaderChoice defGetCopyHeaderChoice ( DefElem def,
bool  is_from 
)
static

Definition at line 329 of file copy.c.

330 {
331  /*
332  * If no parameter value given, assume "true" is meant.
333  */
334  if (def->arg == NULL)
335  return COPY_HEADER_TRUE;
336 
337  /*
338  * Allow 0, 1, "true", "false", "on", "off", or "match".
339  */
340  switch (nodeTag(def->arg))
341  {
342  case T_Integer:
343  switch (intVal(def->arg))
344  {
345  case 0:
346  return COPY_HEADER_FALSE;
347  case 1:
348  return COPY_HEADER_TRUE;
349  default:
350  /* otherwise, error out below */
351  break;
352  }
353  break;
354  default:
355  {
356  char *sval = defGetString(def);
357 
358  /*
359  * The set of strings accepted here should match up with the
360  * grammar's opt_boolean_or_string production.
361  */
362  if (pg_strcasecmp(sval, "true") == 0)
363  return COPY_HEADER_TRUE;
364  if (pg_strcasecmp(sval, "false") == 0)
365  return COPY_HEADER_FALSE;
366  if (pg_strcasecmp(sval, "on") == 0)
367  return COPY_HEADER_TRUE;
368  if (pg_strcasecmp(sval, "off") == 0)
369  return COPY_HEADER_FALSE;
370  if (pg_strcasecmp(sval, "match") == 0)
371  {
372  if (!is_from)
373  ereport(ERROR,
374  (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
375  errmsg("cannot use \"%s\" with HEADER in COPY TO",
376  sval)));
377  return COPY_HEADER_MATCH;
378  }
379  }
380  break;
381  }
382  ereport(ERROR,
383  (errcode(ERRCODE_SYNTAX_ERROR),
384  errmsg("%s requires a Boolean value or \"match\"",
385  def->defname)));
386  return COPY_HEADER_FALSE; /* keep compiler quiet */
387 }
char * defGetString(DefElem *def)
Definition: define.c:48
@ COPY_HEADER_TRUE
Definition: copy.h:29
@ COPY_HEADER_FALSE
Definition: copy.h:28
@ COPY_HEADER_MATCH
Definition: copy.h:30
#define nodeTag(nodeptr)
Definition: nodes.h:133
int pg_strcasecmp(const char *s1, const char *s2)
Definition: pgstrcasecmp.c:36
char * defname
Definition: parsenodes.h:815
Node * arg
Definition: parsenodes.h:816
#define intVal(v)
Definition: value.h:79

References DefElem::arg, COPY_HEADER_FALSE, COPY_HEADER_MATCH, COPY_HEADER_TRUE, defGetString(), DefElem::defname, ereport, errcode(), errmsg(), ERROR, intVal, nodeTag, and pg_strcasecmp().

Referenced by ProcessCopyOptions().

◆ defGetCopyLogVerbosityChoice()

static CopyLogVerbosityChoice defGetCopyLogVerbosityChoice ( DefElem def,
ParseState pstate 
)
static

Definition at line 422 of file copy.c.

423 {
424  char *sval;
425 
426  /*
427  * Allow "default", or "verbose" values.
428  */
429  sval = defGetString(def);
430  if (pg_strcasecmp(sval, "default") == 0)
432  if (pg_strcasecmp(sval, "verbose") == 0)
434 
435  ereport(ERROR,
436  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
437  errmsg("COPY LOG_VERBOSITY \"%s\" not recognized", sval),
438  parser_errposition(pstate, def->location)));
439  return COPY_LOG_VERBOSITY_DEFAULT; /* keep compiler quiet */
440 }
@ COPY_LOG_VERBOSITY_VERBOSE
Definition: copy.h:49
@ COPY_LOG_VERBOSITY_DEFAULT
Definition: copy.h:48
int parser_errposition(ParseState *pstate, int location)
Definition: parse_node.c:106
ParseLoc location
Definition: parsenodes.h:819

References COPY_LOG_VERBOSITY_DEFAULT, COPY_LOG_VERBOSITY_VERBOSE, defGetString(), ereport, errcode(), errmsg(), ERROR, DefElem::location, parser_errposition(), and pg_strcasecmp().

Referenced by ProcessCopyOptions().

◆ defGetCopyOnErrorChoice()

static CopyOnErrorChoice defGetCopyOnErrorChoice ( DefElem def,
ParseState pstate,
bool  is_from 
)
static

Definition at line 393 of file copy.c.

394 {
395  char *sval = defGetString(def);
396 
397  if (!is_from)
398  ereport(ERROR,
399  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
400  errmsg("COPY ON_ERROR cannot be used with COPY TO"),
401  parser_errposition(pstate, def->location)));
402 
403  /*
404  * Allow "stop", or "ignore" values.
405  */
406  if (pg_strcasecmp(sval, "stop") == 0)
407  return COPY_ON_ERROR_STOP;
408  if (pg_strcasecmp(sval, "ignore") == 0)
409  return COPY_ON_ERROR_IGNORE;
410 
411  ereport(ERROR,
412  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
413  errmsg("COPY ON_ERROR \"%s\" not recognized", sval),
414  parser_errposition(pstate, def->location)));
415  return COPY_ON_ERROR_STOP; /* keep compiler quiet */
416 }
@ COPY_ON_ERROR_IGNORE
Definition: copy.h:40
@ COPY_ON_ERROR_STOP
Definition: copy.h:39

References COPY_ON_ERROR_IGNORE, COPY_ON_ERROR_STOP, defGetString(), ereport, errcode(), errmsg(), ERROR, DefElem::location, parser_errposition(), and pg_strcasecmp().

Referenced by ProcessCopyOptions().

◆ DoCopy()

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

Definition at line 62 of file copy.c.

65 {
66  bool is_from = stmt->is_from;
67  bool pipe = (stmt->filename == NULL);
68  Relation rel;
69  Oid relid;
70  RawStmt *query = NULL;
71  Node *whereClause = NULL;
72 
73  /*
74  * Disallow COPY to/from file or program except to users with the
75  * appropriate role.
76  */
77  if (!pipe)
78  {
79  if (stmt->is_program)
80  {
81  if (!has_privs_of_role(GetUserId(), ROLE_PG_EXECUTE_SERVER_PROGRAM))
82  ereport(ERROR,
83  (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
84  errmsg("permission denied to COPY to or from an external program"),
85  errdetail("Only roles with privileges of the \"%s\" role may COPY to or from an external program.",
86  "pg_execute_server_program"),
87  errhint("Anyone can COPY to stdout or from stdin. "
88  "psql's \\copy command also works for anyone.")));
89  }
90  else
91  {
92  if (is_from && !has_privs_of_role(GetUserId(), ROLE_PG_READ_SERVER_FILES))
93  ereport(ERROR,
94  (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
95  errmsg("permission denied to COPY from a file"),
96  errdetail("Only roles with privileges of the \"%s\" role may COPY from a file.",
97  "pg_read_server_files"),
98  errhint("Anyone can COPY to stdout or from stdin. "
99  "psql's \\copy command also works for anyone.")));
100 
101  if (!is_from && !has_privs_of_role(GetUserId(), ROLE_PG_WRITE_SERVER_FILES))
102  ereport(ERROR,
103  (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
104  errmsg("permission denied to COPY to a file"),
105  errdetail("Only roles with privileges of the \"%s\" role may COPY to a file.",
106  "pg_write_server_files"),
107  errhint("Anyone can COPY to stdout or from stdin. "
108  "psql's \\copy command also works for anyone.")));
109  }
110  }
111 
112  if (stmt->relation)
113  {
114  LOCKMODE lockmode = is_from ? RowExclusiveLock : AccessShareLock;
115  ParseNamespaceItem *nsitem;
116  RTEPermissionInfo *perminfo;
117  TupleDesc tupDesc;
118  List *attnums;
119  ListCell *cur;
120 
121  Assert(!stmt->query);
122 
123  /* Open and lock the relation, using the appropriate lock type. */
124  rel = table_openrv(stmt->relation, lockmode);
125 
126  relid = RelationGetRelid(rel);
127 
128  nsitem = addRangeTableEntryForRelation(pstate, rel, lockmode,
129  NULL, false, false);
130 
131  perminfo = nsitem->p_perminfo;
132  perminfo->requiredPerms = (is_from ? ACL_INSERT : ACL_SELECT);
133 
134  if (stmt->whereClause)
135  {
136  /* add nsitem to query namespace */
137  addNSItemToQuery(pstate, nsitem, false, true, true);
138 
139  /* Transform the raw expression tree */
140  whereClause = transformExpr(pstate, stmt->whereClause, EXPR_KIND_COPY_WHERE);
141 
142  /* Make sure it yields a boolean result. */
143  whereClause = coerce_to_boolean(pstate, whereClause, "WHERE");
144 
145  /* we have to fix its collations too */
146  assign_expr_collations(pstate, whereClause);
147 
148  whereClause = eval_const_expressions(NULL, whereClause);
149 
150  whereClause = (Node *) canonicalize_qual((Expr *) whereClause, false);
151  whereClause = (Node *) make_ands_implicit((Expr *) whereClause);
152  }
153 
154  tupDesc = RelationGetDescr(rel);
155  attnums = CopyGetAttnums(tupDesc, rel, stmt->attlist);
156  foreach(cur, attnums)
157  {
158  int attno;
159  Bitmapset **bms;
160 
162  bms = is_from ? &perminfo->insertedCols : &perminfo->selectedCols;
163 
164  *bms = bms_add_member(*bms, attno);
165  }
166  ExecCheckPermissions(pstate->p_rtable, list_make1(perminfo), true);
167 
168  /*
169  * Permission check for row security policies.
170  *
171  * check_enable_rls will ereport(ERROR) if the user has requested
172  * something invalid and will otherwise indicate if we should enable
173  * RLS (returns RLS_ENABLED) or not for this COPY statement.
174  *
175  * If the relation has a row security policy and we are to apply it
176  * then perform a "query" copy and allow the normal query processing
177  * to handle the policies.
178  *
179  * If RLS is not enabled for this, then just fall through to the
180  * normal non-filtering relation handling.
181  */
182  if (check_enable_rls(relid, InvalidOid, false) == RLS_ENABLED)
183  {
185  ColumnRef *cr;
186  ResTarget *target;
187  RangeVar *from;
188  List *targetList = NIL;
189 
190  if (is_from)
191  ereport(ERROR,
192  (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
193  errmsg("COPY FROM not supported with row-level security"),
194  errhint("Use INSERT statements instead.")));
195 
196  /*
197  * Build target list
198  *
199  * If no columns are specified in the attribute list of the COPY
200  * command, then the target list is 'all' columns. Therefore, '*'
201  * should be used as the target list for the resulting SELECT
202  * statement.
203  *
204  * In the case that columns are specified in the attribute list,
205  * create a ColumnRef and ResTarget for each column and add them
206  * to the target list for the resulting SELECT statement.
207  */
208  if (!stmt->attlist)
209  {
210  cr = makeNode(ColumnRef);
212  cr->location = -1;
213 
214  target = makeNode(ResTarget);
215  target->name = NULL;
216  target->indirection = NIL;
217  target->val = (Node *) cr;
218  target->location = -1;
219 
220  targetList = list_make1(target);
221  }
222  else
223  {
224  ListCell *lc;
225 
226  foreach(lc, stmt->attlist)
227  {
228  /*
229  * Build the ColumnRef for each column. The ColumnRef
230  * 'fields' property is a String node that corresponds to
231  * the column name respectively.
232  */
233  cr = makeNode(ColumnRef);
234  cr->fields = list_make1(lfirst(lc));
235  cr->location = -1;
236 
237  /* Build the ResTarget and add the ColumnRef to it. */
238  target = makeNode(ResTarget);
239  target->name = NULL;
240  target->indirection = NIL;
241  target->val = (Node *) cr;
242  target->location = -1;
243 
244  /* Add each column to the SELECT statement's target list */
245  targetList = lappend(targetList, target);
246  }
247  }
248 
249  /*
250  * Build RangeVar for from clause, fully qualified based on the
251  * relation which we have opened and locked. Use "ONLY" so that
252  * COPY retrieves rows from only the target table not any
253  * inheritance children, the same as when RLS doesn't apply.
254  */
257  -1);
258  from->inh = false; /* apply ONLY */
259 
260  /* Build query */
262  select->targetList = targetList;
263  select->fromClause = list_make1(from);
264 
265  query = makeNode(RawStmt);
266  query->stmt = (Node *) select;
267  query->stmt_location = stmt_location;
268  query->stmt_len = stmt_len;
269 
270  /*
271  * Close the relation for now, but keep the lock on it to prevent
272  * changes between now and when we start the query-based COPY.
273  *
274  * We'll reopen it later as part of the query-based COPY.
275  */
276  table_close(rel, NoLock);
277  rel = NULL;
278  }
279  }
280  else
281  {
282  Assert(stmt->query);
283 
284  query = makeNode(RawStmt);
285  query->stmt = stmt->query;
286  query->stmt_location = stmt_location;
287  query->stmt_len = stmt_len;
288 
289  relid = InvalidOid;
290  rel = NULL;
291  }
292 
293  if (is_from)
294  {
295  CopyFromState cstate;
296 
297  Assert(rel);
298 
299  /* check read-only transaction and parallel mode */
300  if (XactReadOnly && !rel->rd_islocaltemp)
301  PreventCommandIfReadOnly("COPY FROM");
302 
303  cstate = BeginCopyFrom(pstate, rel, whereClause,
304  stmt->filename, stmt->is_program,
305  NULL, stmt->attlist, stmt->options);
306  *processed = CopyFrom(cstate); /* copy from file to database */
307  EndCopyFrom(cstate);
308  }
309  else
310  {
311  CopyToState cstate;
312 
313  cstate = BeginCopyTo(pstate, rel, query, relid,
314  stmt->filename, stmt->is_program,
315  NULL, stmt->attlist, stmt->options);
316  *processed = DoCopyTo(cstate); /* copy from database to file */
317  EndCopyTo(cstate);
318  }
319 
320  if (rel != NULL)
321  table_close(rel, NoLock);
322 }
bool has_privs_of_role(Oid member, Oid role)
Definition: acl.c:5134
List * CopyGetAttnums(TupleDesc tupDesc, Relation rel, List *attnamelist)
Definition: copy.c:858
Bitmapset * bms_add_member(Bitmapset *a, int x)
Definition: bitmapset.c:815
#define Assert(condition)
Definition: c.h:858
Node * eval_const_expressions(PlannerInfo *root, Node *node)
Definition: clauses.c:2254
CopyFromState BeginCopyFrom(ParseState *pstate, Relation rel, Node *whereClause, const char *filename, bool is_program, copy_data_source_cb data_source_cb, List *attnamelist, List *options)
Definition: copyfrom.c:1368
uint64 CopyFrom(CopyFromState cstate)
Definition: copyfrom.c:628
void EndCopyFrom(CopyFromState cstate)
Definition: copyfrom.c:1785
uint64 DoCopyTo(CopyToState cstate)
Definition: copyto.c:742
CopyToState BeginCopyTo(ParseState *pstate, Relation rel, RawStmt *raw_query, Oid queryRelId, const char *filename, bool is_program, copy_data_dest_cb data_dest_cb, List *attnamelist, List *options)
Definition: copyto.c:350
void EndCopyTo(CopyToState cstate)
Definition: copyto.c:721
struct cursor * cur
Definition: ecpg.c:28
int errhint(const char *fmt,...)
Definition: elog.c:1319
bool ExecCheckPermissions(List *rangeTable, List *rteperminfos, bool ereport_on_violation)
Definition: execMain.c:579
#define stmt
Definition: indent_codes.h:59
List * lappend(List *list, void *datum)
Definition: list.c:339
int LOCKMODE
Definition: lockdefs.h:26
#define NoLock
Definition: lockdefs.h:34
#define AccessShareLock
Definition: lockdefs.h:36
#define RowExclusiveLock
Definition: lockdefs.h:38
char * get_namespace_name(Oid nspid)
Definition: lsyscache.c:3366
List * make_ands_implicit(Expr *clause)
Definition: makefuncs.c:737
RangeVar * makeRangeVar(char *schemaname, char *relname, int location)
Definition: makefuncs.c:424
char * pstrdup(const char *in)
Definition: mcxt.c:1696
Oid GetUserId(void)
Definition: miscinit.c:514
#define makeNode(_type_)
Definition: nodes.h:155
Node * coerce_to_boolean(ParseState *pstate, Node *node, const char *constructName)
void assign_expr_collations(ParseState *pstate, Node *expr)
Node * transformExpr(ParseState *pstate, Node *expr, ParseExprKind exprKind)
Definition: parse_expr.c:120
@ EXPR_KIND_COPY_WHERE
Definition: parse_node.h:82
ParseNamespaceItem * addRangeTableEntryForRelation(ParseState *pstate, Relation rel, int lockmode, Alias *alias, bool inh, bool inFromCl)
void addNSItemToQuery(ParseState *pstate, ParseNamespaceItem *nsitem, bool addToJoinList, bool addToRelNameSpace, bool addToVarNameSpace)
#define ACL_INSERT
Definition: parsenodes.h:76
#define ACL_SELECT
Definition: parsenodes.h:77
#define lfirst_int(lc)
Definition: pg_list.h:173
#define list_make1(x1)
Definition: pg_list.h:212
#define InvalidOid
Definition: postgres_ext.h:36
unsigned int Oid
Definition: postgres_ext.h:31
Expr * canonicalize_qual(Expr *qual, bool is_check)
Definition: prepqual.c:293
#define RelationGetRelid(relation)
Definition: rel.h:505
#define RelationGetDescr(relation)
Definition: rel.h:531
#define RelationGetNamespace(relation)
Definition: rel.h:546
int check_enable_rls(Oid relid, Oid checkAsUser, bool noError)
Definition: rls.c:52
@ RLS_ENABLED
Definition: rls.h:45
ParseLoc location
Definition: parsenodes.h:295
List * fields
Definition: parsenodes.h:294
Definition: nodes.h:129
RTEPermissionInfo * p_perminfo
Definition: parse_node.h:289
List * p_rtable
Definition: parse_node.h:194
Bitmapset * selectedCols
Definition: parsenodes.h:1297
AclMode requiredPerms
Definition: parsenodes.h:1295
Bitmapset * insertedCols
Definition: parsenodes.h:1298
bool inh
Definition: primnodes.h:85
ParseLoc stmt_location
Definition: parsenodes.h:2026
ParseLoc stmt_len
Definition: parsenodes.h:2027
Node * stmt
Definition: parsenodes.h:2025
bool rd_islocaltemp
Definition: rel.h:61
Node * val
Definition: parsenodes.h:519
ParseLoc location
Definition: parsenodes.h:520
List * indirection
Definition: parsenodes.h:518
char * name
Definition: parsenodes.h:517
#define FirstLowInvalidHeapAttributeNumber
Definition: sysattr.h:27
void table_close(Relation relation, LOCKMODE lockmode)
Definition: table.c:126
Relation table_openrv(const RangeVar *relation, LOCKMODE lockmode)
Definition: table.c:83
void PreventCommandIfReadOnly(const char *cmdname)
Definition: utility.c:404
#define select(n, r, w, e, timeout)
Definition: win32_port.h:500
bool XactReadOnly
Definition: xact.c:80

References AccessShareLock, ACL_INSERT, ACL_SELECT, addNSItemToQuery(), addRangeTableEntryForRelation(), Assert, assign_expr_collations(), BeginCopyFrom(), BeginCopyTo(), bms_add_member(), canonicalize_qual(), check_enable_rls(), coerce_to_boolean(), CopyFrom(), CopyGetAttnums(), cur, DoCopyTo(), EndCopyFrom(), EndCopyTo(), ereport, errcode(), errdetail(), errhint(), errmsg(), ERROR, eval_const_expressions(), ExecCheckPermissions(), EXPR_KIND_COPY_WHERE, ColumnRef::fields, FirstLowInvalidHeapAttributeNumber, get_namespace_name(), GetUserId(), has_privs_of_role(), ResTarget::indirection, RangeVar::inh, RTEPermissionInfo::insertedCols, InvalidOid, lappend(), lfirst, lfirst_int, list_make1, ColumnRef::location, ResTarget::location, make_ands_implicit(), makeNode, makeRangeVar(), ResTarget::name, NIL, NoLock, ParseNamespaceItem::p_perminfo, ParseState::p_rtable, PreventCommandIfReadOnly(), pstrdup(), RelationData::rd_islocaltemp, RelationGetDescr, RelationGetNamespace, RelationGetRelationName, RelationGetRelid, RTEPermissionInfo::requiredPerms, RLS_ENABLED, RowExclusiveLock, select, RTEPermissionInfo::selectedCols, RawStmt::stmt, stmt, RawStmt::stmt_len, RawStmt::stmt_location, table_close(), table_openrv(), transformExpr(), ResTarget::val, and XactReadOnly.

Referenced by standard_ProcessUtility().

◆ ProcessCopyOptions()

void ProcessCopyOptions ( ParseState pstate,
CopyFormatOptions opts_out,
bool  is_from,
List options 
)

Definition at line 459 of file copy.c.

463 {
464  bool format_specified = false;
465  bool freeze_specified = false;
466  bool header_specified = false;
467  bool on_error_specified = false;
468  bool log_verbosity_specified = false;
469  ListCell *option;
470 
471  /* Support external use for option sanity checking */
472  if (opts_out == NULL)
473  opts_out = (CopyFormatOptions *) palloc0(sizeof(CopyFormatOptions));
474 
475  opts_out->file_encoding = -1;
476 
477  /* Extract options from the statement node tree */
478  foreach(option, options)
479  {
480  DefElem *defel = lfirst_node(DefElem, option);
481 
482  if (strcmp(defel->defname, "format") == 0)
483  {
484  char *fmt = defGetString(defel);
485 
486  if (format_specified)
487  errorConflictingDefElem(defel, pstate);
488  format_specified = true;
489  if (strcmp(fmt, "text") == 0)
490  /* default format */ ;
491  else if (strcmp(fmt, "csv") == 0)
492  opts_out->csv_mode = true;
493  else if (strcmp(fmt, "binary") == 0)
494  opts_out->binary = true;
495  else
496  ereport(ERROR,
497  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
498  errmsg("COPY format \"%s\" not recognized", fmt),
499  parser_errposition(pstate, defel->location)));
500  }
501  else if (strcmp(defel->defname, "freeze") == 0)
502  {
503  if (freeze_specified)
504  errorConflictingDefElem(defel, pstate);
505  freeze_specified = true;
506  opts_out->freeze = defGetBoolean(defel);
507  }
508  else if (strcmp(defel->defname, "delimiter") == 0)
509  {
510  if (opts_out->delim)
511  errorConflictingDefElem(defel, pstate);
512  opts_out->delim = defGetString(defel);
513  }
514  else if (strcmp(defel->defname, "null") == 0)
515  {
516  if (opts_out->null_print)
517  errorConflictingDefElem(defel, pstate);
518  opts_out->null_print = defGetString(defel);
519  }
520  else if (strcmp(defel->defname, "default") == 0)
521  {
522  if (opts_out->default_print)
523  errorConflictingDefElem(defel, pstate);
524  opts_out->default_print = defGetString(defel);
525  }
526  else if (strcmp(defel->defname, "header") == 0)
527  {
528  if (header_specified)
529  errorConflictingDefElem(defel, pstate);
530  header_specified = true;
531  opts_out->header_line = defGetCopyHeaderChoice(defel, is_from);
532  }
533  else if (strcmp(defel->defname, "quote") == 0)
534  {
535  if (opts_out->quote)
536  errorConflictingDefElem(defel, pstate);
537  opts_out->quote = defGetString(defel);
538  }
539  else if (strcmp(defel->defname, "escape") == 0)
540  {
541  if (opts_out->escape)
542  errorConflictingDefElem(defel, pstate);
543  opts_out->escape = defGetString(defel);
544  }
545  else if (strcmp(defel->defname, "force_quote") == 0)
546  {
547  if (opts_out->force_quote || opts_out->force_quote_all)
548  errorConflictingDefElem(defel, pstate);
549  if (defel->arg && IsA(defel->arg, A_Star))
550  opts_out->force_quote_all = true;
551  else if (defel->arg && IsA(defel->arg, List))
552  opts_out->force_quote = castNode(List, defel->arg);
553  else
554  ereport(ERROR,
555  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
556  errmsg("argument to option \"%s\" must be a list of column names",
557  defel->defname),
558  parser_errposition(pstate, defel->location)));
559  }
560  else if (strcmp(defel->defname, "force_not_null") == 0)
561  {
562  if (opts_out->force_notnull || opts_out->force_notnull_all)
563  errorConflictingDefElem(defel, pstate);
564  if (defel->arg && IsA(defel->arg, A_Star))
565  opts_out->force_notnull_all = true;
566  else if (defel->arg && IsA(defel->arg, List))
567  opts_out->force_notnull = castNode(List, defel->arg);
568  else
569  ereport(ERROR,
570  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
571  errmsg("argument to option \"%s\" must be a list of column names",
572  defel->defname),
573  parser_errposition(pstate, defel->location)));
574  }
575  else if (strcmp(defel->defname, "force_null") == 0)
576  {
577  if (opts_out->force_null || opts_out->force_null_all)
578  errorConflictingDefElem(defel, pstate);
579  if (defel->arg && IsA(defel->arg, A_Star))
580  opts_out->force_null_all = true;
581  else if (defel->arg && IsA(defel->arg, List))
582  opts_out->force_null = castNode(List, defel->arg);
583  else
584  ereport(ERROR,
585  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
586  errmsg("argument to option \"%s\" must be a list of column names",
587  defel->defname),
588  parser_errposition(pstate, defel->location)));
589  }
590  else if (strcmp(defel->defname, "convert_selectively") == 0)
591  {
592  /*
593  * Undocumented, not-accessible-from-SQL option: convert only the
594  * named columns to binary form, storing the rest as NULLs. It's
595  * allowed for the column list to be NIL.
596  */
597  if (opts_out->convert_selectively)
598  errorConflictingDefElem(defel, pstate);
599  opts_out->convert_selectively = true;
600  if (defel->arg == NULL || IsA(defel->arg, List))
601  opts_out->convert_select = castNode(List, defel->arg);
602  else
603  ereport(ERROR,
604  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
605  errmsg("argument to option \"%s\" must be a list of column names",
606  defel->defname),
607  parser_errposition(pstate, defel->location)));
608  }
609  else if (strcmp(defel->defname, "encoding") == 0)
610  {
611  if (opts_out->file_encoding >= 0)
612  errorConflictingDefElem(defel, pstate);
613  opts_out->file_encoding = pg_char_to_encoding(defGetString(defel));
614  if (opts_out->file_encoding < 0)
615  ereport(ERROR,
616  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
617  errmsg("argument to option \"%s\" must be a valid encoding name",
618  defel->defname),
619  parser_errposition(pstate, defel->location)));
620  }
621  else if (strcmp(defel->defname, "on_error") == 0)
622  {
623  if (on_error_specified)
624  errorConflictingDefElem(defel, pstate);
625  on_error_specified = true;
626  opts_out->on_error = defGetCopyOnErrorChoice(defel, pstate, is_from);
627  }
628  else if (strcmp(defel->defname, "log_verbosity") == 0)
629  {
630  if (log_verbosity_specified)
631  errorConflictingDefElem(defel, pstate);
632  log_verbosity_specified = true;
633  opts_out->log_verbosity = defGetCopyLogVerbosityChoice(defel, pstate);
634  }
635  else
636  ereport(ERROR,
637  (errcode(ERRCODE_SYNTAX_ERROR),
638  errmsg("option \"%s\" not recognized",
639  defel->defname),
640  parser_errposition(pstate, defel->location)));
641  }
642 
643  /*
644  * Check for incompatible options (must do these two before inserting
645  * defaults)
646  */
647  if (opts_out->binary && opts_out->delim)
648  ereport(ERROR,
649  (errcode(ERRCODE_SYNTAX_ERROR),
650  errmsg("cannot specify DELIMITER in BINARY mode")));
651 
652  if (opts_out->binary && opts_out->null_print)
653  ereport(ERROR,
654  (errcode(ERRCODE_SYNTAX_ERROR),
655  errmsg("cannot specify NULL in BINARY mode")));
656 
657  if (opts_out->binary && opts_out->default_print)
658  ereport(ERROR,
659  (errcode(ERRCODE_SYNTAX_ERROR),
660  errmsg("cannot specify DEFAULT in BINARY mode")));
661 
662  if (opts_out->binary && opts_out->on_error != COPY_ON_ERROR_STOP)
663  ereport(ERROR,
664  (errcode(ERRCODE_SYNTAX_ERROR),
665  errmsg("only ON_ERROR STOP is allowed in BINARY mode")));
666 
667  /* Set defaults for omitted options */
668  if (!opts_out->delim)
669  opts_out->delim = opts_out->csv_mode ? "," : "\t";
670 
671  if (!opts_out->null_print)
672  opts_out->null_print = opts_out->csv_mode ? "" : "\\N";
673  opts_out->null_print_len = strlen(opts_out->null_print);
674 
675  if (opts_out->csv_mode)
676  {
677  if (!opts_out->quote)
678  opts_out->quote = "\"";
679  if (!opts_out->escape)
680  opts_out->escape = opts_out->quote;
681  }
682 
683  /* Only single-byte delimiter strings are supported. */
684  if (strlen(opts_out->delim) != 1)
685  ereport(ERROR,
686  (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
687  errmsg("COPY delimiter must be a single one-byte character")));
688 
689  /* Disallow end-of-line characters */
690  if (strchr(opts_out->delim, '\r') != NULL ||
691  strchr(opts_out->delim, '\n') != NULL)
692  ereport(ERROR,
693  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
694  errmsg("COPY delimiter cannot be newline or carriage return")));
695 
696  if (strchr(opts_out->null_print, '\r') != NULL ||
697  strchr(opts_out->null_print, '\n') != NULL)
698  ereport(ERROR,
699  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
700  errmsg("COPY null representation cannot use newline or carriage return")));
701 
702  if (opts_out->default_print)
703  {
704  opts_out->default_print_len = strlen(opts_out->default_print);
705 
706  if (strchr(opts_out->default_print, '\r') != NULL ||
707  strchr(opts_out->default_print, '\n') != NULL)
708  ereport(ERROR,
709  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
710  errmsg("COPY default representation cannot use newline or carriage return")));
711  }
712 
713  /*
714  * Disallow unsafe delimiter characters in non-CSV mode. We can't allow
715  * backslash because it would be ambiguous. We can't allow the other
716  * cases because data characters matching the delimiter must be
717  * backslashed, and certain backslash combinations are interpreted
718  * non-literally by COPY IN. Disallowing all lower case ASCII letters is
719  * more than strictly necessary, but seems best for consistency and
720  * future-proofing. Likewise we disallow all digits though only octal
721  * digits are actually dangerous.
722  */
723  if (!opts_out->csv_mode &&
724  strchr("\\.abcdefghijklmnopqrstuvwxyz0123456789",
725  opts_out->delim[0]) != NULL)
726  ereport(ERROR,
727  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
728  errmsg("COPY delimiter cannot be \"%s\"", opts_out->delim)));
729 
730  /* Check header */
731  if (opts_out->binary && opts_out->header_line)
732  ereport(ERROR,
733  (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
734  errmsg("cannot specify HEADER in BINARY mode")));
735 
736  /* Check quote */
737  if (!opts_out->csv_mode && opts_out->quote != NULL)
738  ereport(ERROR,
739  (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
740  errmsg("COPY QUOTE requires CSV mode")));
741 
742  if (opts_out->csv_mode && strlen(opts_out->quote) != 1)
743  ereport(ERROR,
744  (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
745  errmsg("COPY quote must be a single one-byte character")));
746 
747  if (opts_out->csv_mode && opts_out->delim[0] == opts_out->quote[0])
748  ereport(ERROR,
749  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
750  errmsg("COPY delimiter and quote must be different")));
751 
752  /* Check escape */
753  if (!opts_out->csv_mode && opts_out->escape != NULL)
754  ereport(ERROR,
755  (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
756  errmsg("COPY ESCAPE requires CSV mode")));
757 
758  if (opts_out->csv_mode && strlen(opts_out->escape) != 1)
759  ereport(ERROR,
760  (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
761  errmsg("COPY escape must be a single one-byte character")));
762 
763  /* Check force_quote */
764  if (!opts_out->csv_mode && (opts_out->force_quote || opts_out->force_quote_all))
765  ereport(ERROR,
766  (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
767  errmsg("COPY FORCE_QUOTE requires CSV mode")));
768  if ((opts_out->force_quote || opts_out->force_quote_all) && is_from)
769  ereport(ERROR,
770  (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
771  errmsg("COPY FORCE_QUOTE cannot be used with COPY FROM")));
772 
773  /* Check force_notnull */
774  if (!opts_out->csv_mode && opts_out->force_notnull != NIL)
775  ereport(ERROR,
776  (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
777  errmsg("COPY FORCE_NOT_NULL requires CSV mode")));
778  if (opts_out->force_notnull != NIL && !is_from)
779  ereport(ERROR,
780  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
781  errmsg("COPY FORCE_NOT_NULL cannot be used with COPY TO")));
782 
783  /* Check force_null */
784  if (!opts_out->csv_mode && opts_out->force_null != NIL)
785  ereport(ERROR,
786  (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
787  errmsg("COPY FORCE_NULL requires CSV mode")));
788 
789  if (opts_out->force_null != NIL && !is_from)
790  ereport(ERROR,
791  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
792  errmsg("COPY FORCE_NULL cannot be used with COPY TO")));
793 
794  /* Don't allow the delimiter to appear in the null string. */
795  if (strchr(opts_out->null_print, opts_out->delim[0]) != NULL)
796  ereport(ERROR,
797  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
798  errmsg("COPY delimiter character must not appear in the NULL specification")));
799 
800  /* Don't allow the CSV quote char to appear in the null string. */
801  if (opts_out->csv_mode &&
802  strchr(opts_out->null_print, opts_out->quote[0]) != NULL)
803  ereport(ERROR,
804  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
805  errmsg("CSV quote character must not appear in the NULL specification")));
806 
807  /* Check freeze */
808  if (opts_out->freeze && !is_from)
809  ereport(ERROR,
810  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
811  errmsg("COPY FREEZE cannot be used with COPY TO")));
812 
813  if (opts_out->default_print)
814  {
815  if (!is_from)
816  ereport(ERROR,
817  (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
818  errmsg("COPY DEFAULT only available using COPY FROM")));
819 
820  /* Don't allow the delimiter to appear in the default string. */
821  if (strchr(opts_out->default_print, opts_out->delim[0]) != NULL)
822  ereport(ERROR,
823  (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
824  errmsg("COPY delimiter must not appear in the DEFAULT specification")));
825 
826  /* Don't allow the CSV quote char to appear in the default string. */
827  if (opts_out->csv_mode &&
828  strchr(opts_out->default_print, opts_out->quote[0]) != NULL)
829  ereport(ERROR,
830  (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
831  errmsg("CSV quote character must not appear in the DEFAULT specification")));
832 
833  /* Don't allow the NULL and DEFAULT string to be the same */
834  if (opts_out->null_print_len == opts_out->default_print_len &&
835  strncmp(opts_out->null_print, opts_out->default_print,
836  opts_out->null_print_len) == 0)
837  ereport(ERROR,
838  (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
839  errmsg("NULL specification and DEFAULT specification cannot be the same")));
840  }
841 }
static CopyHeaderChoice defGetCopyHeaderChoice(DefElem *def, bool is_from)
Definition: copy.c:329
static CopyOnErrorChoice defGetCopyOnErrorChoice(DefElem *def, ParseState *pstate, bool is_from)
Definition: copy.c:393
static CopyLogVerbosityChoice defGetCopyLogVerbosityChoice(DefElem *def, ParseState *pstate)
Definition: copy.c:422
bool defGetBoolean(DefElem *def)
Definition: define.c:107
void errorConflictingDefElem(DefElem *defel, ParseState *pstate)
Definition: define.c:384
static void const char * fmt
void * palloc0(Size size)
Definition: mcxt.c:1347
#define IsA(nodeptr, _type_)
Definition: nodes.h:158
#define castNode(_type_, nodeptr)
Definition: nodes.h:176
#define lfirst_node(type, lc)
Definition: pg_list.h:176
#define pg_char_to_encoding
Definition: pg_wchar.h:629
int default_print_len
Definition: copy.h:70
bool force_notnull_all
Definition: copy.h:78
bool force_quote_all
Definition: copy.h:75
bool freeze
Definition: copy.h:63
bool binary
Definition: copy.h:62
int null_print_len
Definition: copy.h:67
bool convert_selectively
Definition: copy.h:83
CopyLogVerbosityChoice log_verbosity
Definition: copy.h:85
char * quote
Definition: copy.h:72
CopyOnErrorChoice on_error
Definition: copy.h:84
CopyHeaderChoice header_line
Definition: copy.h:65
List * force_quote
Definition: copy.h:74
char * escape
Definition: copy.h:73
char * null_print
Definition: copy.h:66
List * force_null
Definition: copy.h:80
char * delim
Definition: copy.h:71
List * convert_select
Definition: copy.h:86
bool force_null_all
Definition: copy.h:81
bool csv_mode
Definition: copy.h:64
int file_encoding
Definition: copy.h:60
char * default_print
Definition: copy.h:69
List * force_notnull
Definition: copy.h:77

References DefElem::arg, CopyFormatOptions::binary, castNode, CopyFormatOptions::convert_select, CopyFormatOptions::convert_selectively, COPY_ON_ERROR_STOP, CopyFormatOptions::csv_mode, CopyFormatOptions::default_print, CopyFormatOptions::default_print_len, defGetBoolean(), defGetCopyHeaderChoice(), defGetCopyLogVerbosityChoice(), defGetCopyOnErrorChoice(), defGetString(), DefElem::defname, CopyFormatOptions::delim, ereport, errcode(), errmsg(), ERROR, errorConflictingDefElem(), CopyFormatOptions::escape, CopyFormatOptions::file_encoding, fmt, CopyFormatOptions::force_notnull, CopyFormatOptions::force_notnull_all, CopyFormatOptions::force_null, CopyFormatOptions::force_null_all, CopyFormatOptions::force_quote, CopyFormatOptions::force_quote_all, CopyFormatOptions::freeze, CopyFormatOptions::header_line, IsA, lfirst_node, DefElem::location, CopyFormatOptions::log_verbosity, NIL, CopyFormatOptions::null_print, CopyFormatOptions::null_print_len, CopyFormatOptions::on_error, palloc0(), parser_errposition(), pg_char_to_encoding, and CopyFormatOptions::quote.

Referenced by BeginCopyFrom(), BeginCopyTo(), and file_fdw_validator().