PostgreSQL Source Code  git master
utility.c
Go to the documentation of this file.
1 /*-------------------------------------------------------------------------
2  *
3  * utility.c
4  * Contains functions which control the execution of the POSTGRES utility
5  * commands. At one time acted as an interface between the Lisp and C
6  * systems.
7  *
8  * Portions Copyright (c) 1996-2023, PostgreSQL Global Development Group
9  * Portions Copyright (c) 1994, Regents of the University of California
10  *
11  *
12  * IDENTIFICATION
13  * src/backend/tcop/utility.c
14  *
15  *-------------------------------------------------------------------------
16  */
17 #include "postgres.h"
18 
19 #include "access/htup_details.h"
20 #include "access/reloptions.h"
21 #include "access/twophase.h"
22 #include "access/xact.h"
23 #include "access/xlog.h"
24 #include "catalog/catalog.h"
25 #include "catalog/index.h"
26 #include "catalog/namespace.h"
27 #include "catalog/pg_authid.h"
28 #include "catalog/pg_inherits.h"
29 #include "catalog/toasting.h"
30 #include "commands/alter.h"
31 #include "commands/async.h"
32 #include "commands/cluster.h"
33 #include "commands/collationcmds.h"
34 #include "commands/comment.h"
35 #include "commands/conversioncmds.h"
36 #include "commands/copy.h"
37 #include "commands/createas.h"
38 #include "commands/dbcommands.h"
39 #include "commands/defrem.h"
40 #include "commands/discard.h"
41 #include "commands/event_trigger.h"
42 #include "commands/explain.h"
43 #include "commands/extension.h"
44 #include "commands/lockcmds.h"
45 #include "commands/matview.h"
46 #include "commands/policy.h"
47 #include "commands/portalcmds.h"
48 #include "commands/prepare.h"
49 #include "commands/proclang.h"
50 #include "commands/publicationcmds.h"
51 #include "commands/schemacmds.h"
52 #include "commands/seclabel.h"
53 #include "commands/sequence.h"
54 #include "commands/subscriptioncmds.h"
55 #include "commands/tablecmds.h"
56 #include "commands/tablespace.h"
57 #include "commands/trigger.h"
58 #include "commands/typecmds.h"
59 #include "commands/user.h"
60 #include "commands/vacuum.h"
61 #include "commands/view.h"
62 #include "miscadmin.h"
63 #include "parser/parse_utilcmd.h"
64 #include "postmaster/bgwriter.h"
65 #include "rewrite/rewriteDefine.h"
66 #include "rewrite/rewriteRemove.h"
67 #include "storage/fd.h"
68 #include "tcop/pquery.h"
69 #include "tcop/utility.h"
70 #include "utils/acl.h"
71 #include "utils/guc.h"
72 #include "utils/lsyscache.h"
73 #include "utils/rel.h"
74 #include "utils/syscache.h"
75 
76 /* Hook for plugins to get control in ProcessUtility() */
77 ProcessUtility_hook_type ProcessUtility_hook = NULL;
78 
79 /* local function declarations */
80 static int ClassifyUtilityCommandAsReadOnly(Node *parsetree);
81 static void ProcessUtilitySlow(ParseState *pstate,
82  PlannedStmt *pstmt,
83  const char *queryString,
84  ProcessUtilityContext context,
85  ParamListInfo params,
86  QueryEnvironment *queryEnv,
87  DestReceiver *dest,
88  QueryCompletion *qc);
89 static void ExecDropStmt(DropStmt *stmt, bool isTopLevel);
90 
91 /*
92  * CommandIsReadOnly: is an executable query read-only?
93  *
94  * This is a much stricter test than we apply for XactReadOnly mode;
95  * the query must be *in truth* read-only, because the caller wishes
96  * not to do CommandCounterIncrement for it.
97  *
98  * Note: currently no need to support raw or analyzed queries here
99  */
100 bool
101 CommandIsReadOnly(PlannedStmt *pstmt)
102 {
103  Assert(IsA(pstmt, PlannedStmt));
104  switch (pstmt->commandType)
105  {
106  case CMD_SELECT:
107  if (pstmt->rowMarks != NIL)
108  return false; /* SELECT FOR [KEY] UPDATE/SHARE */
109  else if (pstmt->hasModifyingCTE)
110  return false; /* data-modifying CTE */
111  else
112  return true;
113  case CMD_UPDATE:
114  case CMD_INSERT:
115  case CMD_DELETE:
116  case CMD_MERGE:
117  return false;
118  case CMD_UTILITY:
119  /* For now, treat all utility commands as read/write */
120  return false;
121  default:
122  elog(WARNING, "unrecognized commandType: %d",
123  (int) pstmt->commandType);
124  break;
125  }
126  return false;
127 }
128 
129 /*
130  * Determine the degree to which a utility command is read only.
131  *
132  * Note the definitions of the relevant flags in src/include/utility/tcop.h.
133  */
134 static int
135 ClassifyUtilityCommandAsReadOnly(Node *parsetree)
136 {
137  switch (nodeTag(parsetree))
138  {
139  case T_AlterCollationStmt:
140  case T_AlterDatabaseRefreshCollStmt:
141  case T_AlterDatabaseSetStmt:
142  case T_AlterDatabaseStmt:
143  case T_AlterDefaultPrivilegesStmt:
144  case T_AlterDomainStmt:
145  case T_AlterEnumStmt:
146  case T_AlterEventTrigStmt:
147  case T_AlterExtensionContentsStmt:
148  case T_AlterExtensionStmt:
149  case T_AlterFdwStmt:
150  case T_AlterForeignServerStmt:
151  case T_AlterFunctionStmt:
152  case T_AlterObjectDependsStmt:
153  case T_AlterObjectSchemaStmt:
154  case T_AlterOpFamilyStmt:
155  case T_AlterOperatorStmt:
156  case T_AlterOwnerStmt:
157  case T_AlterPolicyStmt:
158  case T_AlterPublicationStmt:
159  case T_AlterRoleSetStmt:
160  case T_AlterRoleStmt:
161  case T_AlterSeqStmt:
162  case T_AlterStatsStmt:
163  case T_AlterSubscriptionStmt:
164  case T_AlterTSConfigurationStmt:
165  case T_AlterTSDictionaryStmt:
166  case T_AlterTableMoveAllStmt:
167  case T_AlterTableSpaceOptionsStmt:
168  case T_AlterTableStmt:
169  case T_AlterTypeStmt:
170  case T_AlterUserMappingStmt:
171  case T_CommentStmt:
172  case T_CompositeTypeStmt:
173  case T_CreateAmStmt:
174  case T_CreateCastStmt:
175  case T_CreateConversionStmt:
176  case T_CreateDomainStmt:
177  case T_CreateEnumStmt:
178  case T_CreateEventTrigStmt:
179  case T_CreateExtensionStmt:
180  case T_CreateFdwStmt:
181  case T_CreateForeignServerStmt:
182  case T_CreateForeignTableStmt:
183  case T_CreateFunctionStmt:
184  case T_CreateOpClassStmt:
185  case T_CreateOpFamilyStmt:
186  case T_CreatePLangStmt:
187  case T_CreatePolicyStmt:
188  case T_CreatePublicationStmt:
189  case T_CreateRangeStmt:
190  case T_CreateRoleStmt:
191  case T_CreateSchemaStmt:
192  case T_CreateSeqStmt:
193  case T_CreateStatsStmt:
194  case T_CreateStmt:
195  case T_CreateSubscriptionStmt:
196  case T_CreateTableAsStmt:
197  case T_CreateTableSpaceStmt:
198  case T_CreateTransformStmt:
199  case T_CreateTrigStmt:
200  case T_CreateUserMappingStmt:
201  case T_CreatedbStmt:
202  case T_DefineStmt:
203  case T_DropOwnedStmt:
204  case T_DropRoleStmt:
205  case T_DropStmt:
206  case T_DropSubscriptionStmt:
207  case T_DropTableSpaceStmt:
208  case T_DropUserMappingStmt:
209  case T_DropdbStmt:
210  case T_GrantRoleStmt:
211  case T_GrantStmt:
212  case T_ImportForeignSchemaStmt:
213  case T_IndexStmt:
214  case T_ReassignOwnedStmt:
215  case T_RefreshMatViewStmt:
216  case T_RenameStmt:
217  case T_RuleStmt:
218  case T_SecLabelStmt:
219  case T_TruncateStmt:
220  case T_ViewStmt:
221  {
222  /* DDL is not read-only, and neither is TRUNCATE. */
223  return COMMAND_IS_NOT_READ_ONLY;
224  }
225 
226  case T_AlterSystemStmt:
227  {
228  /*
229  * Surprisingly, ALTER SYSTEM meets all our definitions of
230  * read-only: it changes nothing that affects the output of
231  * pg_dump, it doesn't write WAL or imperil the application of
232  * future WAL, and it doesn't depend on any state that needs
233  * to be synchronized with parallel workers.
234  *
235  * So, despite the fact that it writes to a file, it's read
236  * only!
237  */
238  return COMMAND_IS_STRICTLY_READ_ONLY;
239  }
240 
241  case T_CallStmt:
242  case T_DoStmt:
243  {
244  /*
245  * Commands inside the DO block or the called procedure might
246  * not be read only, but they'll be checked separately when we
247  * try to execute them. Here we only need to worry about the
248  * DO or CALL command itself.
249  */
250  return COMMAND_IS_STRICTLY_READ_ONLY;
251  }
252 
253  case T_CheckPointStmt:
254  {
255  /*
256  * You might think that this should not be permitted in
257  * recovery, but we interpret a CHECKPOINT command during
258  * recovery as a request for a restartpoint instead. We allow
259  * this since it can be a useful way of reducing switchover
260  * time when using various forms of replication.
261  */
262  return COMMAND_IS_STRICTLY_READ_ONLY;
263  }
264 
265  case T_ClosePortalStmt:
266  case T_ConstraintsSetStmt:
267  case T_DeallocateStmt:
268  case T_DeclareCursorStmt:
269  case T_DiscardStmt:
270  case T_ExecuteStmt:
271  case T_FetchStmt:
272  case T_LoadStmt:
273  case T_PrepareStmt:
274  case T_UnlistenStmt:
275  case T_VariableSetStmt:
276  {
277  /*
278  * These modify only backend-local state, so they're OK to run
279  * in a read-only transaction or on a standby. However, they
280  * are disallowed in parallel mode, because they either rely
281  * upon or modify backend-local state that might not be
282  * synchronized among cooperating backends.
283  */
284  return COMMAND_OK_IN_RECOVERY | COMMAND_OK_IN_READ_ONLY_TXN;
285  }
286 
287  case T_ClusterStmt:
288  case T_ReindexStmt:
289  case T_VacuumStmt:
290  {
291  /*
292  * These commands write WAL, so they're not strictly
293  * read-only, and running them in parallel workers isn't
294  * supported.
295  *
296  * However, they don't change the database state in a way that
297  * would affect pg_dump output, so it's fine to run them in a
298  * read-only transaction. (CLUSTER might change the order of
299  * rows on disk, which could affect the ordering of pg_dump
300  * output, but that's not semantically significant.)
301  */
302  return COMMAND_OK_IN_READ_ONLY_TXN;
303  }
304 
305  case T_CopyStmt:
306  {
307  CopyStmt *stmt = (CopyStmt *) parsetree;
308 
309  /*
310  * You might think that COPY FROM is not at all read only, but
311  * it's OK to copy into a temporary table, because that
312  * wouldn't change the output of pg_dump. If the target table
313  * turns out to be non-temporary, DoCopy itself will call
314  * PreventCommandIfReadOnly.
315  */
316  if (stmt->is_from)
317  return COMMAND_OK_IN_READ_ONLY_TXN;
318  else
319  return COMMAND_IS_STRICTLY_READ_ONLY;
320  }
321 
322  case T_ExplainStmt:
323  case T_VariableShowStmt:
324  {
325  /*
326  * These commands don't modify any data and are safe to run in
327  * a parallel worker.
328  */
329  return COMMAND_IS_STRICTLY_READ_ONLY;
330  }
331 
332  case T_ListenStmt:
333  case T_NotifyStmt:
334  {
335  /*
336  * NOTIFY requires an XID assignment, so it can't be permitted
337  * on a standby. Perhaps LISTEN could, since without NOTIFY it
338  * would be OK to just do nothing, at least until promotion,
339  * but we currently prohibit it lest the user get the wrong
340  * idea.
341  *
342  * (We do allow T_UnlistenStmt on a standby, though, because
343  * it's a no-op.)
344  */
345  return COMMAND_OK_IN_READ_ONLY_TXN;
346  }
347 
348  case T_LockStmt:
349  {
350  LockStmt *stmt = (LockStmt *) parsetree;
351 
352  /*
353  * Only weaker locker modes are allowed during recovery. The
354  * restrictions here must match those in
355  * LockAcquireExtended().
356  */
357  if (stmt->mode > RowExclusiveLock)
358  return COMMAND_OK_IN_READ_ONLY_TXN;
359  else
360  return COMMAND_IS_STRICTLY_READ_ONLY;
361  }
362 
363  case T_TransactionStmt:
364  {
365  TransactionStmt *stmt = (TransactionStmt *) parsetree;
366 
367  /*
368  * PREPARE, COMMIT PREPARED, and ROLLBACK PREPARED all write
369  * WAL, so they're not read-only in the strict sense; but the
370  * first and third do not change pg_dump output, so they're OK
371  * in a read-only transactions.
372  *
373  * We also consider COMMIT PREPARED to be OK in a read-only
374  * transaction environment, by way of exception.
375  */
376  switch (stmt->kind)
377  {
378  case TRANS_STMT_BEGIN:
379  case TRANS_STMT_START:
380  case TRANS_STMT_COMMIT:
381  case TRANS_STMT_ROLLBACK:
382  case TRANS_STMT_SAVEPOINT:
383  case TRANS_STMT_RELEASE:
384  case TRANS_STMT_ROLLBACK_TO:
385  return COMMAND_IS_STRICTLY_READ_ONLY;
386 
387  case TRANS_STMT_PREPARE:
388  case TRANS_STMT_COMMIT_PREPARED:
389  case TRANS_STMT_ROLLBACK_PREPARED:
390  return COMMAND_OK_IN_READ_ONLY_TXN;
391  }
392  elog(ERROR, "unrecognized TransactionStmtKind: %d",
393  (int) stmt->kind);
394  return 0; /* silence stupider compilers */
395  }
396 
397  default:
398  elog(ERROR, "unrecognized node type: %d",
399  (int) nodeTag(parsetree));
400  return 0; /* silence stupider compilers */
401  }
402 }
403 
404 /*
405  * PreventCommandIfReadOnly: throw error if XactReadOnly
406  *
407  * This is useful partly to ensure consistency of the error message wording;
408  * some callers have checked XactReadOnly for themselves.
409  */
410 void
411 PreventCommandIfReadOnly(const char *cmdname)
412 {
413  if (XactReadOnly)
414  ereport(ERROR,
415  (errcode(ERRCODE_READ_ONLY_SQL_TRANSACTION),
416  /* translator: %s is name of a SQL command, eg CREATE */
417  errmsg("cannot execute %s in a read-only transaction",
418  cmdname)));
419 }
420 
421 /*
422  * PreventCommandIfParallelMode: throw error if current (sub)transaction is
423  * in parallel mode.
424  *
425  * This is useful partly to ensure consistency of the error message wording;
426  * some callers have checked IsInParallelMode() for themselves.
427  */
428 void
429 PreventCommandIfParallelMode(const char *cmdname)
430 {
431  if (IsInParallelMode())
432  ereport(ERROR,
433  (errcode(ERRCODE_INVALID_TRANSACTION_STATE),
434  /* translator: %s is name of a SQL command, eg CREATE */
435  errmsg("cannot execute %s during a parallel operation",
436  cmdname)));
437 }
438 
439 /*
440  * PreventCommandDuringRecovery: throw error if RecoveryInProgress
441  *
442  * The majority of operations that are unsafe in a Hot Standby
443  * will be rejected by XactReadOnly tests. However there are a few
444  * commands that are allowed in "read-only" xacts but cannot be allowed
445  * in Hot Standby mode. Those commands should call this function.
446  */
447 void
448 PreventCommandDuringRecovery(const char *cmdname)
449 {
450  if (RecoveryInProgress())
451  ereport(ERROR,
452  (errcode(ERRCODE_READ_ONLY_SQL_TRANSACTION),
453  /* translator: %s is name of a SQL command, eg CREATE */
454  errmsg("cannot execute %s during recovery",
455  cmdname)));
456 }
457 
458 /*
459  * CheckRestrictedOperation: throw error for hazardous command if we're
460  * inside a security restriction context.
461  *
462  * This is needed to protect session-local state for which there is not any
463  * better-defined protection mechanism, such as ownership.
464  */
465 static void
466 CheckRestrictedOperation(const char *cmdname)
467 {
468  if (InSecurityRestrictedOperation())
469  ereport(ERROR,
470  (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
471  /* translator: %s is name of a SQL command, eg PREPARE */
472  errmsg("cannot execute %s within security-restricted operation",
473  cmdname)));
474 }
475 
476 /*
477  * ProcessUtility
478  * general utility function invoker
479  *
480  * pstmt: PlannedStmt wrapper for the utility statement
481  * queryString: original source text of command
482  * readOnlyTree: if true, pstmt's node tree must not be modified
483  * context: identifies source of statement (toplevel client command,
484  * non-toplevel client command, subcommand of a larger utility command)
485  * params: parameters to use during execution
486  * queryEnv: environment for parse through execution (e.g., ephemeral named
487  * tables like trigger transition tables). May be NULL.
488  * dest: where to send results
489  * qc: where to store command completion status data. May be NULL,
490  * but if not, then caller must have initialized it.
491  *
492  * Caller MUST supply a queryString; it is not allowed (anymore) to pass NULL.
493  * If you really don't have source text, you can pass a constant string,
494  * perhaps "(query not available)".
495  *
496  * Note for users of ProcessUtility_hook: the same queryString may be passed
497  * to multiple invocations of ProcessUtility when processing a query string
498  * containing multiple semicolon-separated statements. One should use
499  * pstmt->stmt_location and pstmt->stmt_len to identify the substring
500  * containing the current statement. Keep in mind also that some utility
501  * statements (e.g., CREATE SCHEMA) will recurse to ProcessUtility to process
502  * sub-statements, often passing down the same queryString, stmt_location,
503  * and stmt_len that were given for the whole statement.
504  */
505 void
506 ProcessUtility(PlannedStmt *pstmt,
507  const char *queryString,
508  bool readOnlyTree,
509  ProcessUtilityContext context,
510  ParamListInfo params,
511  QueryEnvironment *queryEnv,
512  DestReceiver *dest,
513  QueryCompletion *qc)
514 {
515  Assert(IsA(pstmt, PlannedStmt));
516  Assert(pstmt->commandType == CMD_UTILITY);
517  Assert(queryString != NULL); /* required as of 8.4 */
518  Assert(qc == NULL || qc->commandTag == CMDTAG_UNKNOWN);
519 
520  /*
521  * We provide a function hook variable that lets loadable plugins get
522  * control when ProcessUtility is called. Such a plugin would normally
523  * call standard_ProcessUtility().
524  */
525  if (ProcessUtility_hook)
526  (*ProcessUtility_hook) (pstmt, queryString, readOnlyTree,
527  context, params, queryEnv,
528  dest, qc);
529  else
530  standard_ProcessUtility(pstmt, queryString, readOnlyTree,
531  context, params, queryEnv,
532  dest, qc);
533 }
534 
535 /*
536  * standard_ProcessUtility itself deals only with utility commands for
537  * which we do not provide event trigger support. Commands that do have
538  * such support are passed down to ProcessUtilitySlow, which contains the
539  * necessary infrastructure for such triggers.
540  *
541  * This division is not just for performance: it's critical that the
542  * event trigger code not be invoked when doing START TRANSACTION for
543  * example, because we might need to refresh the event trigger cache,
544  * which requires being in a valid transaction.
545  */
546 void
547 standard_ProcessUtility(PlannedStmt *pstmt,
548  const char *queryString,
549  bool readOnlyTree,
550  ProcessUtilityContext context,
551  ParamListInfo params,
552  QueryEnvironment *queryEnv,
553  DestReceiver *dest,
554  QueryCompletion *qc)
555 {
556  Node *parsetree;
557  bool isTopLevel = (context == PROCESS_UTILITY_TOPLEVEL);
558  bool isAtomicContext = (!(context == PROCESS_UTILITY_TOPLEVEL || context == PROCESS_UTILITY_QUERY_NONATOMIC) || IsTransactionBlock());
559  ParseState *pstate;
560  int readonly_flags;
561 
562  /* This can recurse, so check for excessive recursion */
563  check_stack_depth();
564 
565  /*
566  * If the given node tree is read-only, make a copy to ensure that parse
567  * transformations don't damage the original tree. This could be
568  * refactored to avoid making unnecessary copies in more cases, but it's
569  * not clear that it's worth a great deal of trouble over. Statements
570  * that are complex enough to be expensive to copy are exactly the ones
571  * we'd need to copy, so that only marginal savings seem possible.
572  */
573  if (readOnlyTree)
574  pstmt = copyObject(pstmt);
575  parsetree = pstmt->utilityStmt;
576 
577  /* Prohibit read/write commands in read-only states. */
578  readonly_flags = ClassifyUtilityCommandAsReadOnly(parsetree);
579  if (readonly_flags != COMMAND_IS_STRICTLY_READ_ONLY &&
580  (XactReadOnly || IsInParallelMode()))
581  {
582  CommandTag commandtag = CreateCommandTag(parsetree);
583 
584  if ((readonly_flags & COMMAND_OK_IN_READ_ONLY_TXN) == 0)
585  PreventCommandIfReadOnly(GetCommandTagName(commandtag));
586  if ((readonly_flags & COMMAND_OK_IN_PARALLEL_MODE) == 0)
587  PreventCommandIfParallelMode(GetCommandTagName(commandtag));
588  if ((readonly_flags & COMMAND_OK_IN_RECOVERY) == 0)
589  PreventCommandDuringRecovery(GetCommandTagName(commandtag));
590  }
591 
592  pstate = make_parsestate(NULL);
593  pstate->p_sourcetext = queryString;
594  pstate->p_queryEnv = queryEnv;
595 
596  switch (nodeTag(parsetree))
597  {
598  /*
599  * ******************** transactions ********************
600  */
601  case T_TransactionStmt:
602  {
603  TransactionStmt *stmt = (TransactionStmt *) parsetree;
604 
605  switch (stmt->kind)
606  {
607  /*
608  * START TRANSACTION, as defined by SQL99: Identical
609  * to BEGIN. Same code for both.
610  */
611  case TRANS_STMT_BEGIN:
612  case TRANS_STMT_START:
613  {
614  ListCell *lc;
615 
616  BeginTransactionBlock();
617  foreach(lc, stmt->options)
618  {
619  DefElem *item = (DefElem *) lfirst(lc);
620 
621  if (strcmp(item->defname, "transaction_isolation") == 0)
622  SetPGVariable("transaction_isolation",
623  list_make1(item->arg),
624  true);
625  else if (strcmp(item->defname, "transaction_read_only") == 0)
626  SetPGVariable("transaction_read_only",
627  list_make1(item->arg),
628  true);
629  else if (strcmp(item->defname, "transaction_deferrable") == 0)
630  SetPGVariable("transaction_deferrable",
631  list_make1(item->arg),
632  true);
633  }
634  }
635  break;
636 
637  case TRANS_STMT_COMMIT:
638  if (!EndTransactionBlock(stmt->chain))
639  {
640  /* report unsuccessful commit in qc */
641  if (qc)
642  SetQueryCompletion(qc, CMDTAG_ROLLBACK, 0);
643  }
644  break;
645 
646  case TRANS_STMT_PREPARE:
647  if (!PrepareTransactionBlock(stmt->gid))
648  {
649  /* report unsuccessful commit in qc */
650  if (qc)
651  SetQueryCompletion(qc, CMDTAG_ROLLBACK, 0);
652  }
653  break;
654 
655  case TRANS_STMT_COMMIT_PREPARED:
656  PreventInTransactionBlock(isTopLevel, "COMMIT PREPARED");
657  FinishPreparedTransaction(stmt->gid, true);
658  break;
659 
660  case TRANS_STMT_ROLLBACK_PREPARED:
661  PreventInTransactionBlock(isTopLevel, "ROLLBACK PREPARED");
662  FinishPreparedTransaction(stmt->gid, false);
663  break;
664 
665  case TRANS_STMT_ROLLBACK:
666  UserAbortTransactionBlock(stmt->chain);
667  break;
668 
669  case TRANS_STMT_SAVEPOINT:
670  RequireTransactionBlock(isTopLevel, "SAVEPOINT");
671  DefineSavepoint(stmt->savepoint_name);
672  break;
673 
674  case TRANS_STMT_RELEASE:
675  RequireTransactionBlock(isTopLevel, "RELEASE SAVEPOINT");
676  ReleaseSavepoint(stmt->savepoint_name);
677  break;
678 
679  case TRANS_STMT_ROLLBACK_TO:
680  RequireTransactionBlock(isTopLevel, "ROLLBACK TO SAVEPOINT");
681  RollbackToSavepoint(stmt->savepoint_name);
682 
683  /*
684  * CommitTransactionCommand is in charge of
685  * re-defining the savepoint again
686  */
687  break;
688  }
689  }
690  break;
691 
692  /*
693  * Portal (cursor) manipulation
694  */
695  case T_DeclareCursorStmt:
696  PerformCursorOpen(pstate, (DeclareCursorStmt *) parsetree, params,
697  isTopLevel);
698  break;
699 
700  case T_ClosePortalStmt:
701  {
702  ClosePortalStmt *stmt = (ClosePortalStmt *) parsetree;
703 
704  CheckRestrictedOperation("CLOSE");
705  PerformPortalClose(stmt->portalname);
706  }
707  break;
708 
709  case T_FetchStmt:
710  PerformPortalFetch((FetchStmt *) parsetree, dest, qc);
711  break;
712 
713  case T_DoStmt:
714  ExecuteDoStmt(pstate, (DoStmt *) parsetree, isAtomicContext);
715  break;
716 
717  case T_CreateTableSpaceStmt:
718  /* no event triggers for global objects */
719  PreventInTransactionBlock(isTopLevel, "CREATE TABLESPACE");
720  CreateTableSpace((CreateTableSpaceStmt *) parsetree);
721  break;
722 
723  case T_DropTableSpaceStmt:
724  /* no event triggers for global objects */
725  PreventInTransactionBlock(isTopLevel, "DROP TABLESPACE");
726  DropTableSpace((DropTableSpaceStmt *) parsetree);
727  break;
728 
729  case T_AlterTableSpaceOptionsStmt:
730  /* no event triggers for global objects */
731  AlterTableSpaceOptions((AlterTableSpaceOptionsStmt *) parsetree);
732  break;
733 
734  case T_TruncateStmt:
735  ExecuteTruncate((TruncateStmt *) parsetree);
736  break;
737 
738  case T_CopyStmt:
739  {
740  uint64 processed;
741 
742  DoCopy(pstate, (CopyStmt *) parsetree,
743  pstmt->stmt_location, pstmt->stmt_len,
744  &processed);
745  if (qc)
746  SetQueryCompletion(qc, CMDTAG_COPY, processed);
747  }
748  break;
749 
750  case T_PrepareStmt:
751  CheckRestrictedOperation("PREPARE");
752  PrepareQuery(pstate, (PrepareStmt *) parsetree,
753  pstmt->stmt_location, pstmt->stmt_len);
754  break;
755 
756  case T_ExecuteStmt:
757  ExecuteQuery(pstate,
758  (ExecuteStmt *) parsetree, NULL,
759  params,
760  dest, qc);
761  break;
762 
763  case T_DeallocateStmt:
764  CheckRestrictedOperation("DEALLOCATE");
765  DeallocateQuery((DeallocateStmt *) parsetree);
766  break;
767 
768  case T_GrantRoleStmt:
769  /* no event triggers for global objects */
770  GrantRole(pstate, (GrantRoleStmt *) parsetree);
771  break;
772 
773  case T_CreatedbStmt:
774  /* no event triggers for global objects */
775  PreventInTransactionBlock(isTopLevel, "CREATE DATABASE");
776  createdb(pstate, (CreatedbStmt *) parsetree);
777  break;
778 
779  case T_AlterDatabaseStmt:
780  /* no event triggers for global objects */
781  AlterDatabase(pstate, (AlterDatabaseStmt *) parsetree, isTopLevel);
782  break;
783 
784  case T_AlterDatabaseRefreshCollStmt:
785  /* no event triggers for global objects */
786  AlterDatabaseRefreshColl((AlterDatabaseRefreshCollStmt *) parsetree);
787  break;
788 
789  case T_AlterDatabaseSetStmt:
790  /* no event triggers for global objects */
791  AlterDatabaseSet((AlterDatabaseSetStmt *) parsetree);
792  break;
793 
794  case T_DropdbStmt:
795  /* no event triggers for global objects */
796  PreventInTransactionBlock(isTopLevel, "DROP DATABASE");
797  DropDatabase(pstate, (DropdbStmt *) parsetree);
798  break;
799 
800  /* Query-level asynchronous notification */
801  case T_NotifyStmt:
802  {
803  NotifyStmt *stmt = (NotifyStmt *) parsetree;
804 
805  Async_Notify(stmt->conditionname, stmt->payload);
806  }
807  break;
808 
809  case T_ListenStmt:
810  {
811  ListenStmt *stmt = (ListenStmt *) parsetree;
812 
813  CheckRestrictedOperation("LISTEN");
814 
815  /*
816  * We don't allow LISTEN in background processes, as there is
817  * no mechanism for them to collect NOTIFY messages, so they'd
818  * just block cleanout of the async SLRU indefinitely.
819  * (Authors of custom background workers could bypass this
820  * restriction by calling Async_Listen directly, but then it's
821  * on them to provide some mechanism to process the message
822  * queue.) Note there seems no reason to forbid UNLISTEN.
823  */
824  if (MyBackendType != B_BACKEND)
825  ereport(ERROR,
826  (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
827  /* translator: %s is name of a SQL command, eg LISTEN */
828  errmsg("cannot execute %s within a background process",
829  "LISTEN")));
830 
831  Async_Listen(stmt->conditionname);
832  }
833  break;
834 
835  case T_UnlistenStmt:
836  {
837  UnlistenStmt *stmt = (UnlistenStmt *) parsetree;
838 
839  CheckRestrictedOperation("UNLISTEN");
840  if (stmt->conditionname)
841  Async_Unlisten(stmt->conditionname);
842  else
843  Async_UnlistenAll();
844  }
845  break;
846 
847  case T_LoadStmt:
848  {
849  LoadStmt *stmt = (LoadStmt *) parsetree;
850 
851  closeAllVfds(); /* probably not necessary... */
852  /* Allowed names are restricted if you're not superuser */
853  load_file(stmt->filename, !superuser());
854  }
855  break;
856 
857  case T_CallStmt:
858  ExecuteCallStmt(castNode(CallStmt, parsetree), params, isAtomicContext, dest);
859  break;
860 
861  case T_ClusterStmt:
862  cluster(pstate, (ClusterStmt *) parsetree, isTopLevel);
863  break;
864 
865  case T_VacuumStmt:
866  ExecVacuum(pstate, (VacuumStmt *) parsetree, isTopLevel);
867  break;
868 
869  case T_ExplainStmt:
870  ExplainQuery(pstate, (ExplainStmt *) parsetree, params, dest);
871  break;
872 
873  case T_AlterSystemStmt:
874  PreventInTransactionBlock(isTopLevel, "ALTER SYSTEM");
875  AlterSystemSetConfigFile((AlterSystemStmt *) parsetree);
876  break;
877 
878  case T_VariableSetStmt:
879  ExecSetVariableStmt((VariableSetStmt *) parsetree, isTopLevel);
880  break;
881 
882  case T_VariableShowStmt:
883  {
884  VariableShowStmt *n = (VariableShowStmt *) parsetree;
885 
886  GetPGVariable(n->name, dest);
887  }
888  break;
889 
890  case T_DiscardStmt:
891  /* should we allow DISCARD PLANS? */
892  CheckRestrictedOperation("DISCARD");
893  DiscardCommand((DiscardStmt *) parsetree, isTopLevel);
894  break;
895 
896  case T_CreateEventTrigStmt:
897  /* no event triggers on event triggers */
898  CreateEventTrigger((CreateEventTrigStmt *) parsetree);
899  break;
900 
901  case T_AlterEventTrigStmt:
902  /* no event triggers on event triggers */
903  AlterEventTrigger((AlterEventTrigStmt *) parsetree);
904  break;
905 
906  /*
907  * ******************************** ROLE statements ****
908  */
909  case T_CreateRoleStmt:
910  /* no event triggers for global objects */
911  CreateRole(pstate, (CreateRoleStmt *) parsetree);
912  break;
913 
914  case T_AlterRoleStmt:
915  /* no event triggers for global objects */
916  AlterRole(pstate, (AlterRoleStmt *) parsetree);
917  break;
918 
919  case T_AlterRoleSetStmt:
920  /* no event triggers for global objects */
921  AlterRoleSet((AlterRoleSetStmt *) parsetree);
922  break;
923 
924  case T_DropRoleStmt:
925  /* no event triggers for global objects */
926  DropRole((DropRoleStmt *) parsetree);
927  break;
928 
929  case T_ReassignOwnedStmt:
930  /* no event triggers for global objects */
931  ReassignOwnedObjects((ReassignOwnedStmt *) parsetree);
932  break;
933 
934  case T_LockStmt:
935 
936  /*
937  * Since the lock would just get dropped immediately, LOCK TABLE
938  * outside a transaction block is presumed to be user error.
939  */
940  RequireTransactionBlock(isTopLevel, "LOCK TABLE");
941  LockTableCommand((LockStmt *) parsetree);
942  break;
943 
944  case T_ConstraintsSetStmt:
945  WarnNoTransactionBlock(isTopLevel, "SET CONSTRAINTS");
946  AfterTriggerSetState((ConstraintsSetStmt *) parsetree);
947  break;
948 
949  case T_CheckPointStmt:
950  if (!has_privs_of_role(GetUserId(), ROLE_PG_CHECKPOINT))
951  ereport(ERROR,
952  (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
953  errmsg("permission denied to execute %s command",
954  "CHECKPOINT"),
955  errdetail("Only roles with privileges of the \"%s\" role may execute this command.",
956  "pg_checkpoint")));
957 
958  RequestCheckpoint(CHECKPOINT_IMMEDIATE | CHECKPOINT_WAIT |
959  (RecoveryInProgress() ? 0 : CHECKPOINT_FORCE));
960  break;
961 
962  case T_ReindexStmt:
963  ExecReindex(pstate, (ReindexStmt *) parsetree, isTopLevel);
964  break;
965 
966  /*
967  * The following statements are supported by Event Triggers only
968  * in some cases, so we "fast path" them in the other cases.
969  */
970 
971  case T_GrantStmt:
972  {
973  GrantStmt *stmt = (GrantStmt *) parsetree;
974 
975  if (EventTriggerSupportsObjectType(stmt->objtype))
976  ProcessUtilitySlow(pstate, pstmt, queryString,
977  context, params, queryEnv,
978  dest, qc);
979  else
980  ExecuteGrantStmt(stmt);
981  }
982  break;
983 
984  case T_DropStmt:
985  {
986  DropStmt *stmt = (DropStmt *) parsetree;
987 
988  if (EventTriggerSupportsObjectType(stmt->removeType))
989  ProcessUtilitySlow(pstate, pstmt, queryString,
990  context, params, queryEnv,
991  dest, qc);
992  else
993  ExecDropStmt(stmt, isTopLevel);
994  }
995  break;
996 
997  case T_RenameStmt:
998  {
999  RenameStmt *stmt = (RenameStmt *) parsetree;
1000 
1001  if (EventTriggerSupportsObjectType(stmt->renameType))
1002  ProcessUtilitySlow(pstate, pstmt, queryString,
1003  context, params, queryEnv,
1004  dest, qc);
1005  else
1006  ExecRenameStmt(stmt);
1007  }
1008  break;
1009 
1010  case T_AlterObjectDependsStmt:
1011  {
1012  AlterObjectDependsStmt *stmt = (AlterObjectDependsStmt *) parsetree;
1013 
1014  if (EventTriggerSupportsObjectType(stmt->objectType))
1015  ProcessUtilitySlow(pstate, pstmt, queryString,
1016  context, params, queryEnv,
1017  dest, qc);
1018  else
1019  ExecAlterObjectDependsStmt(stmt, NULL);
1020  }
1021  break;
1022 
1023  case T_AlterObjectSchemaStmt:
1024  {
1025  AlterObjectSchemaStmt *stmt = (AlterObjectSchemaStmt *) parsetree;
1026 
1027  if (EventTriggerSupportsObjectType(stmt->objectType))
1028  ProcessUtilitySlow(pstate, pstmt, queryString,
1029  context, params, queryEnv,
1030  dest, qc);
1031  else
1032  ExecAlterObjectSchemaStmt(stmt, NULL);
1033  }
1034  break;
1035 
1036  case T_AlterOwnerStmt:
1037  {
1038  AlterOwnerStmt *stmt = (AlterOwnerStmt *) parsetree;
1039 
1040  if (EventTriggerSupportsObjectType(stmt->objectType))
1041  ProcessUtilitySlow(pstate, pstmt, queryString,
1042  context, params, queryEnv,
1043  dest, qc);
1044  else
1045  ExecAlterOwnerStmt(stmt);
1046  }
1047  break;
1048 
1049  case T_CommentStmt:
1050  {
1051  CommentStmt *stmt = (CommentStmt *) parsetree;
1052 
1053  if (EventTriggerSupportsObjectType(stmt->objtype))
1054  ProcessUtilitySlow(pstate, pstmt, queryString,
1055  context, params, queryEnv,
1056  dest, qc);
1057  else
1058  CommentObject(stmt);
1059  break;
1060  }
1061 
1062  case T_SecLabelStmt:
1063  {
1064  SecLabelStmt *stmt = (SecLabelStmt *) parsetree;
1065 
1066  if (EventTriggerSupportsObjectType(stmt->objtype))
1067  ProcessUtilitySlow(pstate, pstmt, queryString,
1068  context, params, queryEnv,
1069  dest, qc);
1070  else
1071  ExecSecLabelStmt(stmt);
1072  break;
1073  }
1074 
1075  default:
1076  /* All other statement types have event trigger support */
1077  ProcessUtilitySlow(pstate, pstmt, queryString,
1078  context, params, queryEnv,
1079  dest, qc);
1080  break;
1081  }
1082 
1083  free_parsestate(pstate);
1084 
1085  /*
1086  * Make effects of commands visible, for instance so that
1087  * PreCommit_on_commit_actions() can see them (see for example bug
1088  * #15631).
1089  */
1090  CommandCounterIncrement();
1091 }
1092 
1093 /*
1094  * The "Slow" variant of ProcessUtility should only receive statements
1095  * supported by the event triggers facility. Therefore, we always
1096  * perform the trigger support calls if the context allows it.
1097  */
1098 static void
1099 ProcessUtilitySlow(ParseState *pstate,
1100  PlannedStmt *pstmt,
1101  const char *queryString,
1102  ProcessUtilityContext context,
1103  ParamListInfo params,
1104  QueryEnvironment *queryEnv,
1105  DestReceiver *dest,
1106  QueryCompletion *qc)
1107 {
1108  Node *parsetree = pstmt->utilityStmt;
1109  bool isTopLevel = (context == PROCESS_UTILITY_TOPLEVEL);
1110  bool isCompleteQuery = (context != PROCESS_UTILITY_SUBCOMMAND);
1111  bool needCleanup;
1112  bool commandCollected = false;
1113  ObjectAddress address;
1114  ObjectAddress secondaryObject = InvalidObjectAddress;
1115 
1116  /* All event trigger calls are done only when isCompleteQuery is true */
1117  needCleanup = isCompleteQuery && EventTriggerBeginCompleteQuery();
1118 
1119  /* PG_TRY block is to ensure we call EventTriggerEndCompleteQuery */
1120  PG_TRY();
1121  {
1122  if (isCompleteQuery)
1123  EventTriggerDDLCommandStart(parsetree);
1124 
1125  switch (nodeTag(parsetree))
1126  {
1127  /*
1128  * relation and attribute manipulation
1129  */
1130  case T_CreateSchemaStmt:
1131  CreateSchemaCommand((CreateSchemaStmt *) parsetree,
1132  queryString,
1133  pstmt->stmt_location,
1134  pstmt->stmt_len);
1135 
1136  /*
1137  * EventTriggerCollectSimpleCommand called by
1138  * CreateSchemaCommand
1139  */
1140  commandCollected = true;
1141  break;
1142 
1143  case T_CreateStmt:
1144  case T_CreateForeignTableStmt:
1145  {
1146  List *stmts;
1147  RangeVar *table_rv = NULL;
1148 
1149  /* Run parse analysis ... */
1150  stmts = transformCreateStmt((CreateStmt *) parsetree,
1151  queryString);
1152 
1153  /*
1154  * ... and do it. We can't use foreach() because we may
1155  * modify the list midway through, so pick off the
1156  * elements one at a time, the hard way.
1157  */
1158  while (stmts != NIL)
1159  {
1160  Node *stmt = (Node *) linitial(stmts);
1161 
1162  stmts = list_delete_first(stmts);
1163 
1164  if (IsA(stmt, CreateStmt))
1165  {
1166  CreateStmt *cstmt = (CreateStmt *) stmt;
1167  Datum toast_options;
1168  static char *validnsps[] = HEAP_RELOPT_NAMESPACES;
1169 
1170  /* Remember transformed RangeVar for LIKE */
1171  table_rv = cstmt->relation;
1172 
1173  /* Create the table itself */
1174  address = DefineRelation(cstmt,
1175  RELKIND_RELATION,
1176  InvalidOid, NULL,
1177  queryString);
1178  EventTriggerCollectSimpleCommand(address,
1179  secondaryObject,
1180  stmt);
1181 
1182  /*
1183  * Let NewRelationCreateToastTable decide if this
1184  * one needs a secondary relation too.
1185  */
1186  CommandCounterIncrement();
1187 
1188  /*
1189  * parse and validate reloptions for the toast
1190  * table
1191  */
1192  toast_options = transformRelOptions((Datum) 0,
1193  cstmt->options,
1194  "toast",
1195  validnsps,
1196  true,
1197  false);
1198  (void) heap_reloptions(RELKIND_TOASTVALUE,
1199  toast_options,
1200  true);
1201 
1202  NewRelationCreateToastTable(address.objectId,
1203  toast_options);
1204  }
1205  else if (IsA(stmt, CreateForeignTableStmt))
1206  {
1207  CreateForeignTableStmt *cstmt = (CreateForeignTableStmt *) stmt;
1208 
1209  /* Remember transformed RangeVar for LIKE */
1210  table_rv = cstmt->base.relation;
1211 
1212  /* Create the table itself */
1213  address = DefineRelation(&cstmt->base,
1214  RELKIND_FOREIGN_TABLE,
1215  InvalidOid, NULL,
1216  queryString);
1217  CreateForeignTable(cstmt,
1218  address.objectId);
1219  EventTriggerCollectSimpleCommand(address,
1220  secondaryObject,
1221  stmt);
1222  }
1223  else if (IsA(stmt, TableLikeClause))
1224  {
1225  /*
1226  * Do delayed processing of LIKE options. This
1227  * will result in additional sub-statements for us
1228  * to process. Those should get done before any
1229  * remaining actions, so prepend them to "stmts".
1230  */
1231  TableLikeClause *like = (TableLikeClause *) stmt;
1232  List *morestmts;
1233 
1234  Assert(table_rv != NULL);
1235 
1236  morestmts = expandTableLikeClause(table_rv, like);
1237  stmts = list_concat(morestmts, stmts);
1238  }
1239  else
1240  {
1241  /*
1242  * Recurse for anything else. Note the recursive
1243  * call will stash the objects so created into our
1244  * event trigger context.
1245  */
1246  PlannedStmt *wrapper;
1247 
1248  wrapper = makeNode(PlannedStmt);
1249  wrapper->commandType = CMD_UTILITY;
1250  wrapper->canSetTag = false;
1251  wrapper->utilityStmt = stmt;
1252  wrapper->stmt_location = pstmt->stmt_location;
1253  wrapper->stmt_len = pstmt->stmt_len;
1254 
1255  ProcessUtility(wrapper,
1256  queryString,
1257  false,
1258  PROCESS_UTILITY_SUBCOMMAND,
1259  params,
1260  NULL,
1261  None_Receiver,
1262  NULL);
1263  }
1264 
1265  /* Need CCI between commands */
1266  if (stmts != NIL)
1267  CommandCounterIncrement();
1268  }
1269 
1270  /*
1271  * The multiple commands generated here are stashed
1272  * individually, so disable collection below.
1273  */
1274  commandCollected = true;
1275  }
1276  break;
1277 
1278  case T_AlterTableStmt:
1279  {
1280  AlterTableStmt *atstmt = (AlterTableStmt *) parsetree;
1281  Oid relid;
1282  LOCKMODE lockmode;
1283  ListCell *cell;
1284 
1285  /*
1286  * Disallow ALTER TABLE .. DETACH CONCURRENTLY in a
1287  * transaction block or function. (Perhaps it could be
1288  * allowed in a procedure, but don't hold your breath.)
1289  */
1290  foreach(cell, atstmt->cmds)
1291  {
1292  AlterTableCmd *cmd = (AlterTableCmd *) lfirst(cell);
1293 
1294  /* Disallow DETACH CONCURRENTLY in a transaction block */
1295  if (cmd->subtype == AT_DetachPartition)
1296  {
1297  if (((PartitionCmd *) cmd->def)->concurrent)
1298  PreventInTransactionBlock(isTopLevel,
1299  "ALTER TABLE ... DETACH CONCURRENTLY");
1300  }
1301  }
1302 
1303  /*
1304  * Figure out lock mode, and acquire lock. This also does
1305  * basic permissions checks, so that we won't wait for a
1306  * lock on (for example) a relation on which we have no
1307  * permissions.
1308  */
1309  lockmode = AlterTableGetLockLevel(atstmt->cmds);
1310  relid = AlterTableLookupRelation(atstmt, lockmode);
1311 
1312  if (OidIsValid(relid))
1313  {
1314  AlterTableUtilityContext atcontext;
1315 
1316  /* Set up info needed for recursive callbacks ... */
1317  atcontext.pstmt = pstmt;
1318  atcontext.queryString = queryString;
1319  atcontext.relid = relid;
1320  atcontext.params = params;
1321  atcontext.queryEnv = queryEnv;
1322 
1323  /* ... ensure we have an event trigger context ... */
1324  EventTriggerAlterTableStart(parsetree);
1325  EventTriggerAlterTableRelid(relid);
1326 
1327  /* ... and do it */
1328  AlterTable(atstmt, lockmode, &atcontext);
1329 
1330  /* done */
1331  EventTriggerAlterTableEnd();
1332  }
1333  else
1334  ereport(NOTICE,
1335  (errmsg("relation \"%s\" does not exist, skipping",
1336  atstmt->relation->relname)));
1337  }
1338 
1339  /* ALTER TABLE stashes commands internally */
1340  commandCollected = true;
1341  break;
1342 
1343  case T_AlterDomainStmt:
1344  {
1345  AlterDomainStmt *stmt = (AlterDomainStmt *) parsetree;
1346 
1347  /*
1348  * Some or all of these functions are recursive to cover
1349  * inherited things, so permission checks are done there.
1350  */
1351  switch (stmt->subtype)
1352  {
1353  case 'T': /* ALTER DOMAIN DEFAULT */
1354 
1355  /*
1356  * Recursively alter column default for table and,
1357  * if requested, for descendants
1358  */
1359  address =
1360  AlterDomainDefault(stmt->typeName,
1361  stmt->def);
1362  break;
1363  case 'N': /* ALTER DOMAIN DROP NOT NULL */
1364  address =
1365  AlterDomainNotNull(stmt->typeName,
1366  false);
1367  break;
1368  case 'O': /* ALTER DOMAIN SET NOT NULL */
1369  address =
1370  AlterDomainNotNull(stmt->typeName,
1371  true);
1372  break;
1373  case 'C': /* ADD CONSTRAINT */
1374  address =
1375  AlterDomainAddConstraint(stmt->typeName,
1376  stmt->def,
1377  &secondaryObject);
1378  break;
1379  case 'X': /* DROP CONSTRAINT */
1380  address =
1381  AlterDomainDropConstraint(stmt->typeName,
1382  stmt->name,
1383  stmt->behavior,
1384  stmt->missing_ok);
1385  break;
1386  case 'V': /* VALIDATE CONSTRAINT */
1387  address =
1388  AlterDomainValidateConstraint(stmt->typeName,
1389  stmt->name);
1390  break;
1391  default: /* oops */
1392  elog(ERROR, "unrecognized alter domain type: %d",
1393  (int) stmt->subtype);
1394  break;
1395  }
1396  }
1397  break;
1398 
1399  /*
1400  * ************* object creation / destruction **************
1401  */
1402  case T_DefineStmt:
1403  {
1404  DefineStmt *stmt = (DefineStmt *) parsetree;
1405 
1406  switch (stmt->kind)
1407  {
1408  case OBJECT_AGGREGATE:
1409  address =
1410  DefineAggregate(pstate, stmt->defnames, stmt->args,
1411  stmt->oldstyle,
1412  stmt->definition,
1413  stmt->replace);
1414  break;
1415  case OBJECT_OPERATOR:
1416  Assert(stmt->args == NIL);
1417  address = DefineOperator(stmt->defnames,
1418  stmt->definition);
1419  break;
1420  case OBJECT_TYPE:
1421  Assert(stmt->args == NIL);
1422  address = DefineType(pstate,
1423  stmt->defnames,
1424  stmt->definition);
1425  break;
1426  case OBJECT_TSPARSER:
1427  Assert(stmt->args == NIL);
1428  address = DefineTSParser(stmt->defnames,
1429  stmt->definition);
1430  break;
1431  case OBJECT_TSDICTIONARY:
1432  Assert(stmt->args == NIL);
1433  address = DefineTSDictionary(stmt->defnames,
1434  stmt->definition);
1435  break;
1436  case OBJECT_TSTEMPLATE:
1437  Assert(stmt->args == NIL);
1438  address = DefineTSTemplate(stmt->defnames,
1439  stmt->definition);
1440  break;
1441  case OBJECT_TSCONFIGURATION:
1442  Assert(stmt->args == NIL);
1443  address = DefineTSConfiguration(stmt->defnames,
1444  stmt->definition,
1445  &secondaryObject);
1446  break;
1447  case OBJECT_COLLATION:
1448  Assert(stmt->args == NIL);
1449  address = DefineCollation(pstate,
1450  stmt->defnames,
1451  stmt->definition,
1452  stmt->if_not_exists);
1453  break;
1454  default:
1455  elog(ERROR, "unrecognized define stmt type: %d",
1456  (int) stmt->kind);
1457  break;
1458  }
1459  }
1460  break;
1461 
1462  case T_IndexStmt: /* CREATE INDEX */
1463  {
1464  IndexStmt *stmt = (IndexStmt *) parsetree;
1465  Oid relid;
1466  LOCKMODE lockmode;
1467  int nparts = -1;
1468  bool is_alter_table;
1469 
1470  if (stmt->concurrent)
1471  PreventInTransactionBlock(isTopLevel,
1472  "CREATE INDEX CONCURRENTLY");
1473 
1474  /*
1475  * Look up the relation OID just once, right here at the
1476  * beginning, so that we don't end up repeating the name
1477  * lookup later and latching onto a different relation
1478  * partway through. To avoid lock upgrade hazards, it's
1479  * important that we take the strongest lock that will
1480  * eventually be needed here, so the lockmode calculation
1481  * needs to match what DefineIndex() does.
1482  */
1483  lockmode = stmt->concurrent ? ShareUpdateExclusiveLock
1484  : ShareLock;
1485  relid =
1486  RangeVarGetRelidExtended(stmt->relation, lockmode,
1487  0,
1488  RangeVarCallbackOwnsRelation,
1489  NULL);
1490 
1491  /*
1492  * CREATE INDEX on partitioned tables (but not regular
1493  * inherited tables) recurses to partitions, so we must
1494  * acquire locks early to avoid deadlocks.
1495  *
1496  * We also take the opportunity to verify that all
1497  * partitions are something we can put an index on, to
1498  * avoid building some indexes only to fail later. While
1499  * at it, also count the partitions, so that DefineIndex
1500  * needn't do a duplicative find_all_inheritors search.
1501  */
1502  if (stmt->relation->inh &&
1503  get_rel_relkind(relid) == RELKIND_PARTITIONED_TABLE)
1504  {
1505  ListCell *lc;
1506  List *inheritors = NIL;
1507 
1508  inheritors = find_all_inheritors(relid, lockmode, NULL);
1509  foreach(lc, inheritors)
1510  {
1511  Oid partrelid = lfirst_oid(lc);
1512  char relkind = get_rel_relkind(partrelid);
1513 
1514  if (relkind != RELKIND_RELATION &&
1515  relkind != RELKIND_MATVIEW &&
1516  relkind != RELKIND_PARTITIONED_TABLE &&
1517  relkind != RELKIND_FOREIGN_TABLE)
1518  elog(ERROR, "unexpected relkind \"%c\" on partition \"%s\"",
1519  relkind, stmt->relation->relname);
1520 
1521  if (relkind == RELKIND_FOREIGN_TABLE &&
1522  (stmt->unique || stmt->primary))
1523  ereport(ERROR,
1524  (errcode(ERRCODE_WRONG_OBJECT_TYPE),
1525  errmsg("cannot create unique index on partitioned table \"%s\"",
1526  stmt->relation->relname),
1527  errdetail("Table \"%s\" contains partitions that are foreign tables.",
1528  stmt->relation->relname)));
1529  }
1530  /* count direct and indirect children, but not rel */
1531  nparts = list_length(inheritors) - 1;
1532  list_free(inheritors);
1533  }
1534 
1535  /*
1536  * If the IndexStmt is already transformed, it must have
1537  * come from generateClonedIndexStmt, which in current
1538  * usage means it came from expandTableLikeClause rather
1539  * than from original parse analysis. And that means we
1540  * must treat it like ALTER TABLE ADD INDEX, not CREATE.
1541  * (This is a bit grotty, but currently it doesn't seem
1542  * worth adding a separate bool field for the purpose.)
1543  */
1544  is_alter_table = stmt->transformed;
1545 
1546  /* Run parse analysis ... */
1547  stmt = transformIndexStmt(relid, stmt, queryString);
1548 
1549  /* ... and do it */
1550  EventTriggerAlterTableStart(parsetree);
1551  address =
1552  DefineIndex(relid, /* OID of heap relation */
1553  stmt,
1554  InvalidOid, /* no predefined OID */
1555  InvalidOid, /* no parent index */
1556  InvalidOid, /* no parent constraint */
1557  nparts, /* # of partitions, or -1 */
1558  is_alter_table,
1559  true, /* check_rights */
1560  true, /* check_not_in_use */
1561  false, /* skip_build */
1562  false); /* quiet */
1563 
1564  /*
1565  * Add the CREATE INDEX node itself to stash right away;
1566  * if there were any commands stashed in the ALTER TABLE
1567  * code, we need them to appear after this one.
1568  */
1569  EventTriggerCollectSimpleCommand(address, secondaryObject,
1570  parsetree);
1571  commandCollected = true;
1572  EventTriggerAlterTableEnd();
1573  }
1574  break;
1575 
1576  case T_CreateExtensionStmt:
1577  address = CreateExtension(pstate, (CreateExtensionStmt *) parsetree);
1578  break;
1579 
1580  case T_AlterExtensionStmt:
1581  address = ExecAlterExtensionStmt(pstate, (AlterExtensionStmt *) parsetree);
1582  break;
1583 
1584  case T_AlterExtensionContentsStmt:
1585  address = ExecAlterExtensionContentsStmt((AlterExtensionContentsStmt *) parsetree,
1586  &secondaryObject);
1587  break;
1588 
1589  case T_CreateFdwStmt:
1590  address = CreateForeignDataWrapper(pstate, (CreateFdwStmt *) parsetree);
1591  break;
1592 
1593  case T_AlterFdwStmt:
1594  address = AlterForeignDataWrapper(pstate, (AlterFdwStmt *) parsetree);
1595  break;
1596 
1597  case T_CreateForeignServerStmt:
1598  address = CreateForeignServer((CreateForeignServerStmt *) parsetree);
1599  break;
1600 
1601  case T_AlterForeignServerStmt:
1602  address = AlterForeignServer((AlterForeignServerStmt *) parsetree);
1603  break;
1604 
1605  case T_CreateUserMappingStmt:
1606  address = CreateUserMapping((CreateUserMappingStmt *) parsetree);
1607  break;
1608 
1609  case T_AlterUserMappingStmt:
1610  address = AlterUserMapping((AlterUserMappingStmt *) parsetree);
1611  break;
1612 
1613  case T_DropUserMappingStmt:
1614  RemoveUserMapping((DropUserMappingStmt *) parsetree);
1615  /* no commands stashed for DROP */
1616  commandCollected = true;
1617  break;
1618 
1619  case T_ImportForeignSchemaStmt:
1620  ImportForeignSchema((ImportForeignSchemaStmt *) parsetree);
1621  /* commands are stashed inside ImportForeignSchema */
1622  commandCollected = true;
1623  break;
1624 
1625  case T_CompositeTypeStmt: /* CREATE TYPE (composite) */
1626  {
1627  CompositeTypeStmt *stmt = (CompositeTypeStmt *) parsetree;
1628 
1629  address = DefineCompositeType(stmt->typevar,
1630  stmt->coldeflist);
1631  }
1632  break;
1633 
1634  case T_CreateEnumStmt: /* CREATE TYPE AS ENUM */
1635  address = DefineEnum((CreateEnumStmt *) parsetree);
1636  break;
1637 
1638  case T_CreateRangeStmt: /* CREATE TYPE AS RANGE */
1639  address = DefineRange(pstate, (CreateRangeStmt *) parsetree);
1640  break;
1641 
1642  case T_AlterEnumStmt: /* ALTER TYPE (enum) */
1643  address = AlterEnum((AlterEnumStmt *) parsetree);
1644  break;
1645 
1646  case T_ViewStmt: /* CREATE VIEW */
1647  EventTriggerAlterTableStart(parsetree);
1648  address = DefineView((ViewStmt *) parsetree, queryString,
1649  pstmt->stmt_location, pstmt->stmt_len);
1650  EventTriggerCollectSimpleCommand(address, secondaryObject,
1651  parsetree);
1652  /* stashed internally */
1653  commandCollected = true;
1654  EventTriggerAlterTableEnd();
1655  break;
1656 
1657  case T_CreateFunctionStmt: /* CREATE FUNCTION */
1658  address = CreateFunction(pstate, (CreateFunctionStmt *) parsetree);
1659  break;
1660 
1661  case T_AlterFunctionStmt: /* ALTER FUNCTION */
1662  address = AlterFunction(pstate, (AlterFunctionStmt *) parsetree);
1663  break;
1664 
1665  case T_RuleStmt: /* CREATE RULE */
1666  address = DefineRule((RuleStmt *) parsetree, queryString);
1667  break;
1668 
1669  case T_CreateSeqStmt:
1670  address = DefineSequence(pstate, (CreateSeqStmt *) parsetree);
1671  break;
1672 
1673  case T_AlterSeqStmt:
1674  address = AlterSequence(pstate, (AlterSeqStmt *) parsetree);
1675  break;
1676 
1677  case T_CreateTableAsStmt:
1678  address = ExecCreateTableAs(pstate, (CreateTableAsStmt *) parsetree,
1679  params, queryEnv, qc);
1680  break;
1681 
1682  case T_RefreshMatViewStmt:
1683 
1684  /*
1685  * REFRESH CONCURRENTLY executes some DDL commands internally.
1686  * Inhibit DDL command collection here to avoid those commands
1687  * from showing up in the deparsed command queue. The refresh
1688  * command itself is queued, which is enough.
1689  */
1690  EventTriggerInhibitCommandCollection();
1691  PG_TRY(2);
1692  {
1693  address = ExecRefreshMatView((RefreshMatViewStmt *) parsetree,
1694  queryString, params, qc);
1695  }
1696  PG_FINALLY(2);
1697  {
1698  EventTriggerUndoInhibitCommandCollection();
1699  }
1700  PG_END_TRY(2);
1701  break;
1702 
1703  case T_CreateTrigStmt:
1704  address = CreateTrigger((CreateTrigStmt *) parsetree,
1705  queryString, InvalidOid, InvalidOid,
1706  InvalidOid, InvalidOid, InvalidOid,
1707  InvalidOid, NULL, false, false);
1708  break;
1709 
1710  case T_CreatePLangStmt:
1711  address = CreateProceduralLanguage((CreatePLangStmt *) parsetree);
1712  break;
1713 
1714  case T_CreateDomainStmt:
1715  address = DefineDomain((CreateDomainStmt *) parsetree);
1716  break;
1717 
1718  case T_CreateConversionStmt:
1719  address = CreateConversionCommand((CreateConversionStmt *) parsetree);
1720  break;
1721 
1722  case T_CreateCastStmt:
1723  address = CreateCast((CreateCastStmt *) parsetree);
1724  break;
1725 
1726  case T_CreateOpClassStmt:
1727  DefineOpClass((CreateOpClassStmt *) parsetree);
1728  /* command is stashed in DefineOpClass */
1729  commandCollected = true;
1730  break;
1731 
1732  case T_CreateOpFamilyStmt:
1733  address = DefineOpFamily((CreateOpFamilyStmt *) parsetree);
1734 
1735  /*
1736  * DefineOpFamily calls EventTriggerCollectSimpleCommand
1737  * directly.
1738  */
1739  commandCollected = true;
1740  break;
1741 
1742  case T_CreateTransformStmt:
1743  address = CreateTransform((CreateTransformStmt *) parsetree);
1744  break;
1745 
1746  case T_AlterOpFamilyStmt:
1747  AlterOpFamily((AlterOpFamilyStmt *) parsetree);
1748  /* commands are stashed in AlterOpFamily */
1749  commandCollected = true;
1750  break;
1751 
1752  case T_AlterTSDictionaryStmt:
1753  address = AlterTSDictionary((AlterTSDictionaryStmt *) parsetree);
1754  break;
1755 
1756  case T_AlterTSConfigurationStmt:
1757  AlterTSConfiguration((AlterTSConfigurationStmt *) parsetree);
1758 
1759  /*
1760  * Commands are stashed in MakeConfigurationMapping and
1761  * DropConfigurationMapping, which are called from
1762  * AlterTSConfiguration
1763  */
1764  commandCollected = true;
1765  break;
1766 
1767  case T_AlterTableMoveAllStmt:
1768  AlterTableMoveAll((AlterTableMoveAllStmt *) parsetree);
1769  /* commands are stashed in AlterTableMoveAll */
1770  commandCollected = true;
1771  break;
1772 
1773  case T_DropStmt:
1774  ExecDropStmt((DropStmt *) parsetree, isTopLevel);
1775  /* no commands stashed for DROP */
1776  commandCollected = true;
1777  break;
1778 
1779  case T_RenameStmt:
1780  address = ExecRenameStmt((RenameStmt *) parsetree);
1781  break;
1782 
1783  case T_AlterObjectDependsStmt:
1784  address =
1785  ExecAlterObjectDependsStmt((AlterObjectDependsStmt *) parsetree,
1786  &secondaryObject);
1787  break;
1788 
1789  case T_AlterObjectSchemaStmt:
1790  address =
1791  ExecAlterObjectSchemaStmt((AlterObjectSchemaStmt *) parsetree,
1792  &secondaryObject);
1793  break;
1794 
1795  case T_AlterOwnerStmt:
1796  address = ExecAlterOwnerStmt((AlterOwnerStmt *) parsetree);
1797  break;
1798 
1799  case T_AlterOperatorStmt:
1800  address = AlterOperator((AlterOperatorStmt *) parsetree);
1801  break;
1802 
1803  case T_AlterTypeStmt:
1804  address = AlterType((AlterTypeStmt *) parsetree);
1805  break;
1806 
1807  case T_CommentStmt:
1808  address = CommentObject((CommentStmt *) parsetree);
1809  break;
1810 
1811  case T_GrantStmt:
1812  ExecuteGrantStmt((GrantStmt *) parsetree);
1813  /* commands are stashed in ExecGrantStmt_oids */
1814  commandCollected = true;
1815  break;
1816 
1817  case T_DropOwnedStmt:
1818  DropOwnedObjects((DropOwnedStmt *) parsetree);
1819  /* no commands stashed for DROP */
1820  commandCollected = true;
1821  break;
1822 
1823  case T_AlterDefaultPrivilegesStmt:
1824  ExecAlterDefaultPrivilegesStmt(pstate, (AlterDefaultPrivilegesStmt *) parsetree);
1825  EventTriggerCollectAlterDefPrivs((AlterDefaultPrivilegesStmt *) parsetree);
1826  commandCollected = true;
1827  break;
1828 
1829  case T_CreatePolicyStmt: /* CREATE POLICY */
1830  address = CreatePolicy((CreatePolicyStmt *) parsetree);
1831  break;
1832 
1833  case T_AlterPolicyStmt: /* ALTER POLICY */
1834  address = AlterPolicy((AlterPolicyStmt *) parsetree);
1835  break;
1836 
1837  case T_SecLabelStmt:
1838  address = ExecSecLabelStmt((SecLabelStmt *) parsetree);
1839  break;
1840 
1841  case T_CreateAmStmt:
1842  address = CreateAccessMethod((CreateAmStmt *) parsetree);
1843  break;
1844 
1845  case T_CreatePublicationStmt:
1846  address = CreatePublication(pstate, (CreatePublicationStmt *) parsetree);
1847  break;
1848 
1849  case T_AlterPublicationStmt:
1850  AlterPublication(pstate, (AlterPublicationStmt *) parsetree);
1851 
1852  /*
1853  * AlterPublication calls EventTriggerCollectSimpleCommand
1854  * directly
1855  */
1856  commandCollected = true;
1857  break;
1858 
1859  case T_CreateSubscriptionStmt:
1860  address = CreateSubscription(pstate,
1861  (CreateSubscriptionStmt *) parsetree,
1862  isTopLevel);
1863  break;
1864 
1865  case T_AlterSubscriptionStmt:
1866  address = AlterSubscription(pstate,
1867  (AlterSubscriptionStmt *) parsetree,
1868  isTopLevel);
1869  break;
1870 
1871  case T_DropSubscriptionStmt:
1872  DropSubscription((DropSubscriptionStmt *) parsetree, isTopLevel);
1873  /* no commands stashed for DROP */
1874  commandCollected = true;
1875  break;
1876 
1877  case T_CreateStatsStmt:
1878  {
1879  Oid relid;
1880  CreateStatsStmt *stmt = (CreateStatsStmt *) parsetree;
1881  RangeVar *rel = (RangeVar *) linitial(stmt->relations);
1882 
1883  if (!IsA(rel, RangeVar))
1884  ereport(ERROR,
1885  (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
1886  errmsg("only a single relation is allowed in CREATE STATISTICS")));
1887 
1888  /*
1889  * CREATE STATISTICS will influence future execution plans
1890  * but does not interfere with currently executing plans.
1891  * So it should be enough to take ShareUpdateExclusiveLock
1892  * on relation, conflicting with ANALYZE and other DDL
1893  * that sets statistical information, but not with normal
1894  * queries.
1895  *
1896  * XXX RangeVarCallbackOwnsRelation not needed here, to
1897  * keep the same behavior as before.
1898  */
1899  relid = RangeVarGetRelid(rel, ShareUpdateExclusiveLock, false);
1900 
1901  /* Run parse analysis ... */
1902  stmt = transformStatsStmt(relid, stmt, queryString);
1903 
1904  address = CreateStatistics(stmt);
1905  }
1906  break;
1907 
1908  case T_AlterStatsStmt:
1909  address = AlterStatistics((AlterStatsStmt *) parsetree);
1910  break;
1911 
1912  case T_AlterCollationStmt:
1913  address = AlterCollation((AlterCollationStmt *) parsetree);
1914  break;
1915 
1916  default:
1917  elog(ERROR, "unrecognized node type: %d",
1918  (int) nodeTag(parsetree));
1919  break;
1920  }
1921 
1922  /*
1923  * Remember the object so that ddl_command_end event triggers have
1924  * access to it.
1925  */
1926  if (!commandCollected)
1927  EventTriggerCollectSimpleCommand(address, secondaryObject,
1928  parsetree);
1929 
1930  if (isCompleteQuery)
1931  {
1932  EventTriggerSQLDrop(parsetree);
1933  EventTriggerDDLCommandEnd(parsetree);
1934  }
1935  }
1936  PG_FINALLY();
1937  {
1938  if (needCleanup)
1939  EventTriggerEndCompleteQuery();
1940  }
1941  PG_END_TRY();
1942 }
1943 
1944 /*
1945  * ProcessUtilityForAlterTable
1946  * Recursive entry from ALTER TABLE
1947  *
1948  * ALTER TABLE sometimes generates subcommands such as CREATE INDEX.
1949  * It calls this, not the main entry point ProcessUtility, to execute
1950  * such subcommands.
1951  *
1952  * stmt: the utility command to execute
1953  * context: opaque passthrough struct with the info we need
1954  *
1955  * It's caller's responsibility to do CommandCounterIncrement after
1956  * calling this, if needed.
1957  */
1958 void
1959 ProcessUtilityForAlterTable(Node *stmt, AlterTableUtilityContext *context)
1960 {
1961  PlannedStmt *wrapper;
1962 
1963  /*
1964  * For event triggers, we must "close" the current complex-command set,
1965  * and start a new one afterwards; this is needed to ensure the ordering
1966  * of command events is consistent with the way they were executed.
1967  */
1968  EventTriggerAlterTableEnd();
1969 
1970  /* Create a suitable wrapper */
1971  wrapper = makeNode(PlannedStmt);
1972  wrapper->commandType = CMD_UTILITY;
1973  wrapper->canSetTag = false;
1974  wrapper->utilityStmt = stmt;
1975  wrapper->stmt_location = context->pstmt->stmt_location;
1976  wrapper->stmt_len = context->pstmt->stmt_len;
1977 
1978  ProcessUtility(wrapper,
1979  context->queryString,
1980  false,
1981  PROCESS_UTILITY_SUBCOMMAND,
1982  context->params,
1983  context->queryEnv,
1984  None_Receiver,
1985  NULL);
1986 
1987  EventTriggerAlterTableStart(context->pstmt->utilityStmt);
1988  EventTriggerAlterTableRelid(context->relid);
1989 }
1990 
1991 /*
1992  * Dispatch function for DropStmt
1993  */
1994 static void
1995 ExecDropStmt(DropStmt *stmt, bool isTopLevel)
1996 {
1997  switch (stmt->removeType)
1998  {
1999  case OBJECT_INDEX:
2000  if (stmt->concurrent)
2001  PreventInTransactionBlock(isTopLevel,
2002  "DROP INDEX CONCURRENTLY");
2003  /* fall through */
2004 
2005  case OBJECT_TABLE:
2006  case OBJECT_SEQUENCE:
2007  case OBJECT_VIEW:
2008  case OBJECT_MATVIEW:
2009  case OBJECT_FOREIGN_TABLE:
2010  RemoveRelations(stmt);
2011  break;
2012  default:
2013  RemoveObjects(stmt);
2014  break;
2015  }
2016 }
2017 
2018 
2019 /*
2020  * UtilityReturnsTuples
2021  * Return "true" if this utility statement will send output to the
2022  * destination.
2023  *
2024  * Generally, there should be a case here for each case in ProcessUtility
2025  * where "dest" is passed on.
2026  */
2027 bool
2028 UtilityReturnsTuples(Node *parsetree)
2029 {
2030  switch (nodeTag(parsetree))
2031  {
2032  case T_CallStmt:
2033  {
2034  CallStmt *stmt = (CallStmt *) parsetree;
2035 
2036  return (stmt->funcexpr->funcresulttype == RECORDOID);
2037  }
2038  case T_FetchStmt:
2039  {
2040  FetchStmt *stmt = (FetchStmt *) parsetree;
2041  Portal portal;
2042 
2043  if (stmt->ismove)
2044  return false;
2045  portal = GetPortalByName(stmt->portalname);
2046  if (!PortalIsValid(portal))
2047  return false; /* not our business to raise error */
2048  return portal->tupDesc ? true : false;
2049  }
2050 
2051  case T_ExecuteStmt:
2052  {
2053  ExecuteStmt *stmt = (ExecuteStmt *) parsetree;
2054  PreparedStatement *entry;
2055 
2056  entry = FetchPreparedStatement(stmt->name, false);
2057  if (!entry)
2058  return false; /* not our business to raise error */
2059  if (entry->plansource->resultDesc)
2060  return true;
2061  return false;
2062  }
2063 
2064  case T_ExplainStmt:
2065  return true;
2066 
2067  case T_VariableShowStmt:
2068  return true;
2069 
2070  default:
2071  return false;
2072  }
2073 }
2074 
2075 /*
2076  * UtilityTupleDescriptor
2077  * Fetch the actual output tuple descriptor for a utility statement
2078  * for which UtilityReturnsTuples() previously returned "true".
2079  *
2080  * The returned descriptor is created in (or copied into) the current memory
2081  * context.
2082  */
2083 TupleDesc
2084 UtilityTupleDescriptor(Node *parsetree)
2085 {
2086  switch (nodeTag(parsetree))
2087  {
2088  case T_CallStmt:
2089  return CallStmtResultDesc((CallStmt *) parsetree);
2090 
2091  case T_FetchStmt:
2092  {
2093  FetchStmt *stmt = (FetchStmt *) parsetree;
2094  Portal portal;
2095 
2096  if (stmt->ismove)
2097  return NULL;
2098  portal = GetPortalByName(stmt->portalname);
2099  if (!PortalIsValid(portal))
2100  return NULL; /* not our business to raise error */
2101  return CreateTupleDescCopy(portal->tupDesc);
2102  }
2103 
2104  case T_ExecuteStmt:
2105  {
2106  ExecuteStmt *stmt = (ExecuteStmt *) parsetree;
2107  PreparedStatement *entry;
2108 
2109  entry = FetchPreparedStatement(stmt->name, false);
2110  if (!entry)
2111  return NULL; /* not our business to raise error */
2112  return FetchPreparedStatementResultDesc(entry);
2113  }
2114 
2115  case T_ExplainStmt:
2116  return ExplainResultDesc((ExplainStmt *) parsetree);
2117 
2118  case T_VariableShowStmt:
2119  {
2120  VariableShowStmt *n = (VariableShowStmt *) parsetree;
2121 
2122  return GetPGVariableResultDesc(n->name);
2123  }
2124 
2125  default:
2126  return NULL;
2127  }
2128 }
2129 
2130 
2131 /*
2132  * QueryReturnsTuples
2133  * Return "true" if this Query will send output to the destination.
2134  */
2135 #ifdef NOT_USED
2136 bool
2137 QueryReturnsTuples(Query *parsetree)
2138 {
2139  switch (parsetree->commandType)
2140  {
2141  case CMD_SELECT:
2142  /* returns tuples */
2143  return true;
2144  case CMD_MERGE:
2145  return false;
2146  case CMD_INSERT:
2147  case CMD_UPDATE:
2148  case CMD_DELETE:
2149  /* the forms with RETURNING return tuples */
2150  if (parsetree->returningList)
2151  return true;
2152  break;
2153  case CMD_UTILITY:
2154  return UtilityReturnsTuples(parsetree->utilityStmt);
2155  case CMD_UNKNOWN:
2156  case CMD_NOTHING:
2157  /* probably shouldn't get here */
2158  break;
2159  }
2160  return false; /* default */
2161 }
2162 #endif
2163 
2164 
2165 /*
2166  * UtilityContainsQuery
2167  * Return the contained Query, or NULL if there is none
2168  *
2169  * Certain utility statements, such as EXPLAIN, contain a plannable Query.
2170  * This function encapsulates knowledge of exactly which ones do.
2171  * We assume it is invoked only on already-parse-analyzed statements
2172  * (else the contained parsetree isn't a Query yet).
2173  *
2174  * In some cases (currently, only EXPLAIN of CREATE TABLE AS/SELECT INTO and
2175  * CREATE MATERIALIZED VIEW), potentially Query-containing utility statements
2176  * can be nested. This function will drill down to a non-utility Query, or
2177  * return NULL if none.
2178  */
2179 Query *
2180 UtilityContainsQuery(Node *parsetree)
2181 {
2182  Query *qry;
2183 
2184  switch (nodeTag(parsetree))
2185  {
2186  case T_DeclareCursorStmt:
2187  qry = castNode(Query, ((DeclareCursorStmt *) parsetree)->query);
2188  if (qry->commandType == CMD_UTILITY)
2189  return UtilityContainsQuery(qry->utilityStmt);
2190  return qry;
2191 
2192  case T_ExplainStmt:
2193  qry = castNode(Query, ((ExplainStmt *) parsetree)->query);
2194  if (qry->commandType == CMD_UTILITY)
2195  return UtilityContainsQuery(qry->utilityStmt);
2196  return qry;
2197 
2198  case T_CreateTableAsStmt:
2199  qry = castNode(Query, ((CreateTableAsStmt *) parsetree)->query);
2200  if (qry->commandType == CMD_UTILITY)
2201  return UtilityContainsQuery(qry->utilityStmt);
2202  return qry;
2203 
2204  default:
2205  return NULL;
2206  }
2207 }
2208 
2209 
2210 /*
2211  * AlterObjectTypeCommandTag
2212  * helper function for CreateCommandTag
2213  *
2214  * This covers most cases where ALTER is used with an ObjectType enum.
2215  */
2216 static CommandTag
2217 AlterObjectTypeCommandTag(ObjectType objtype)
2218 {
2219  CommandTag tag;
2220 
2221  switch (objtype)
2222  {
2223  case OBJECT_AGGREGATE:
2224  tag = CMDTAG_ALTER_AGGREGATE;
2225  break;
2226  case OBJECT_ATTRIBUTE:
2227  tag = CMDTAG_ALTER_TYPE;
2228  break;
2229  case OBJECT_CAST:
2230  tag = CMDTAG_ALTER_CAST;
2231  break;
2232  case OBJECT_COLLATION:
2233  tag = CMDTAG_ALTER_COLLATION;
2234  break;
2235  case OBJECT_COLUMN:
2236  tag = CMDTAG_ALTER_TABLE;
2237  break;
2238  case OBJECT_CONVERSION:
2239  tag = CMDTAG_ALTER_CONVERSION;
2240  break;
2241  case OBJECT_DATABASE:
2242  tag = CMDTAG_ALTER_DATABASE;
2243  break;
2244  case OBJECT_DOMAIN:
2245  case OBJECT_DOMCONSTRAINT:
2246  tag = CMDTAG_ALTER_DOMAIN;
2247  break;
2248  case OBJECT_EXTENSION:
2249  tag = CMDTAG_ALTER_EXTENSION;
2250  break;
2251  case OBJECT_FDW:
2252  tag = CMDTAG_ALTER_FOREIGN_DATA_WRAPPER;
2253  break;
2254  case OBJECT_FOREIGN_SERVER:
2255  tag = CMDTAG_ALTER_SERVER;
2256  break;
2257  case OBJECT_FOREIGN_TABLE:
2258  tag = CMDTAG_ALTER_FOREIGN_TABLE;
2259  break;
2260  case OBJECT_FUNCTION:
2261  tag = CMDTAG_ALTER_FUNCTION;
2262  break;
2263  case OBJECT_INDEX:
2264  tag = CMDTAG_ALTER_INDEX;
2265  break;
2266  case OBJECT_LANGUAGE:
2267  tag = CMDTAG_ALTER_LANGUAGE;
2268  break;
2269  case OBJECT_LARGEOBJECT:
2270  tag = CMDTAG_ALTER_LARGE_OBJECT;
2271  break;
2272  case OBJECT_OPCLASS:
2273  tag = CMDTAG_ALTER_OPERATOR_CLASS;
2274  break;
2275  case OBJECT_OPERATOR:
2276  tag = CMDTAG_ALTER_OPERATOR;
2277  break;
2278  case OBJECT_OPFAMILY:
2279  tag = CMDTAG_ALTER_OPERATOR_FAMILY;
2280  break;
2281  case OBJECT_POLICY:
2282  tag = CMDTAG_ALTER_POLICY;
2283  break;
2284  case OBJECT_PROCEDURE:
2285  tag = CMDTAG_ALTER_PROCEDURE;
2286  break;
2287  case OBJECT_ROLE:
2288  tag = CMDTAG_ALTER_ROLE;
2289  break;
2290  case OBJECT_ROUTINE:
2291  tag = CMDTAG_ALTER_ROUTINE;
2292  break;
2293  case OBJECT_RULE:
2294  tag = CMDTAG_ALTER_RULE;
2295  break;
2296  case OBJECT_SCHEMA:
2297  tag = CMDTAG_ALTER_SCHEMA;
2298  break;
2299  case OBJECT_SEQUENCE:
2300  tag = CMDTAG_ALTER_SEQUENCE;
2301  break;
2302  case OBJECT_TABLE:
2303  case OBJECT_TABCONSTRAINT:
2304  tag = CMDTAG_ALTER_TABLE;
2305  break;
2306  case OBJECT_TABLESPACE:
2307  tag = CMDTAG_ALTER_TABLESPACE;
2308  break;
2309  case OBJECT_TRIGGER:
2310  tag = CMDTAG_ALTER_TRIGGER;
2311  break;
2312  case OBJECT_EVENT_TRIGGER:
2313  tag = CMDTAG_ALTER_EVENT_TRIGGER;
2314  break;
2315  case OBJECT_TSCONFIGURATION:
2316  tag = CMDTAG_ALTER_TEXT_SEARCH_CONFIGURATION;
2317  break;
2318  case OBJECT_TSDICTIONARY:
2319  tag = CMDTAG_ALTER_TEXT_SEARCH_DICTIONARY;
2320  break;
2321  case OBJECT_TSPARSER:
2322  tag = CMDTAG_ALTER_TEXT_SEARCH_PARSER;
2323  break;
2324  case OBJECT_TSTEMPLATE:
2325  tag = CMDTAG_ALTER_TEXT_SEARCH_TEMPLATE;
2326  break;
2327  case OBJECT_TYPE:
2328  tag = CMDTAG_ALTER_TYPE;
2329  break;
2330  case OBJECT_VIEW:
2331  tag = CMDTAG_ALTER_VIEW;
2332  break;
2333  case OBJECT_MATVIEW:
2334  tag = CMDTAG_ALTER_MATERIALIZED_VIEW;
2335  break;
2336  case OBJECT_PUBLICATION:
2337  tag = CMDTAG_ALTER_PUBLICATION;
2338  break;
2339  case OBJECT_SUBSCRIPTION:
2340  tag = CMDTAG_ALTER_SUBSCRIPTION;
2341  break;
2342  case OBJECT_STATISTIC_EXT:
2343  tag = CMDTAG_ALTER_STATISTICS;
2344  break;
2345  default:
2346  tag = CMDTAG_UNKNOWN;
2347  break;
2348  }
2349 
2350  return tag;
2351 }
2352 
2353 /*
2354  * CreateCommandTag
2355  * utility to get a CommandTag for the command operation,
2356  * given either a raw (un-analyzed) parsetree, an analyzed Query,
2357  * or a PlannedStmt.
2358  *
2359  * This must handle all command types, but since the vast majority
2360  * of 'em are utility commands, it seems sensible to keep it here.
2361  */
2362 CommandTag
2363 CreateCommandTag(Node *parsetree)
2364 {
2365  CommandTag tag;
2366 
2367  switch (nodeTag(parsetree))
2368  {
2369  /* recurse if we're given a RawStmt */
2370  case T_RawStmt:
2371  tag = CreateCommandTag(((RawStmt *) parsetree)->stmt);
2372  break;
2373 
2374  /* raw plannable queries */
2375  case T_InsertStmt:
2376  tag = CMDTAG_INSERT;
2377  break;
2378 
2379  case T_DeleteStmt:
2380  tag = CMDTAG_DELETE;
2381  break;
2382 
2383  case T_UpdateStmt:
2384  tag = CMDTAG_UPDATE;
2385  break;
2386 
2387  case T_MergeStmt:
2388  tag = CMDTAG_MERGE;
2389  break;
2390 
2391  case T_SelectStmt:
2392  tag = CMDTAG_SELECT;
2393  break;
2394 
2395  case T_PLAssignStmt:
2396  tag = CMDTAG_SELECT;
2397  break;
2398 
2399  /* utility statements --- same whether raw or cooked */
2400  case T_TransactionStmt:
2401  {
2402  TransactionStmt *stmt = (TransactionStmt *) parsetree;
2403 
2404  switch (stmt->kind)
2405  {
2406  case TRANS_STMT_BEGIN:
2407  tag = CMDTAG_BEGIN;
2408  break;
2409 
2410  case TRANS_STMT_START:
2411  tag = CMDTAG_START_TRANSACTION;
2412  break;
2413 
2414  case TRANS_STMT_COMMIT:
2415  tag = CMDTAG_COMMIT;
2416  break;
2417 
2418  case TRANS_STMT_ROLLBACK:
2419  case TRANS_STMT_ROLLBACK_TO:
2420  tag = CMDTAG_ROLLBACK;
2421  break;
2422 
2423  case TRANS_STMT_SAVEPOINT:
2424  tag = CMDTAG_SAVEPOINT;
2425  break;
2426 
2427  case TRANS_STMT_RELEASE:
2428  tag = CMDTAG_RELEASE;
2429  break;
2430 
2431  case TRANS_STMT_PREPARE:
2432  tag = CMDTAG_PREPARE_TRANSACTION;
2433  break;
2434 
2435  case TRANS_STMT_COMMIT_PREPARED:
2436  tag = CMDTAG_COMMIT_PREPARED;
2437  break;
2438 
2439  case TRANS_STMT_ROLLBACK_PREPARED:
2440  tag = CMDTAG_ROLLBACK_PREPARED;
2441  break;
2442 
2443  default:
2444  tag = CMDTAG_UNKNOWN;
2445  break;
2446  }
2447  }
2448  break;
2449 
2450  case T_DeclareCursorStmt:
2451  tag = CMDTAG_DECLARE_CURSOR;
2452  break;
2453 
2454  case T_ClosePortalStmt:
2455  {
2456  ClosePortalStmt *stmt = (ClosePortalStmt *) parsetree;
2457 
2458  if (stmt->portalname == NULL)
2459  tag = CMDTAG_CLOSE_CURSOR_ALL;
2460  else
2461  tag = CMDTAG_CLOSE_CURSOR;
2462  }
2463  break;
2464 
2465  case T_FetchStmt:
2466  {
2467  FetchStmt *stmt = (FetchStmt *) parsetree;
2468 
2469  tag = (stmt->ismove) ? CMDTAG_MOVE : CMDTAG_FETCH;
2470  }
2471  break;
2472 
2473  case T_CreateDomainStmt:
2474  tag = CMDTAG_CREATE_DOMAIN;
2475  break;
2476 
2477  case T_CreateSchemaStmt:
2478  tag = CMDTAG_CREATE_SCHEMA;
2479  break;
2480 
2481  case T_CreateStmt:
2482  tag = CMDTAG_CREATE_TABLE;
2483  break;
2484 
2485  case T_CreateTableSpaceStmt:
2486  tag = CMDTAG_CREATE_TABLESPACE;
2487  break;
2488 
2489  case T_DropTableSpaceStmt:
2490  tag = CMDTAG_DROP_TABLESPACE;
2491  break;
2492 
2493  case T_AlterTableSpaceOptionsStmt:
2494  tag = CMDTAG_ALTER_TABLESPACE;
2495  break;
2496 
2497  case T_CreateExtensionStmt:
2498  tag = CMDTAG_CREATE_EXTENSION;
2499  break;
2500 
2501  case T_AlterExtensionStmt:
2502  tag = CMDTAG_ALTER_EXTENSION;
2503  break;
2504 
2505  case T_AlterExtensionContentsStmt:
2506  tag = CMDTAG_ALTER_EXTENSION;
2507  break;
2508 
2509  case T_CreateFdwStmt:
2510  tag = CMDTAG_CREATE_FOREIGN_DATA_WRAPPER;
2511  break;
2512 
2513  case T_AlterFdwStmt:
2514  tag = CMDTAG_ALTER_FOREIGN_DATA_WRAPPER;
2515  break;
2516 
2517  case T_CreateForeignServerStmt:
2518  tag = CMDTAG_CREATE_SERVER;
2519  break;
2520 
2521  case T_AlterForeignServerStmt:
2522  tag = CMDTAG_ALTER_SERVER;
2523  break;
2524 
2525  case T_CreateUserMappingStmt:
2526  tag = CMDTAG_CREATE_USER_MAPPING;
2527  break;
2528 
2529  case T_AlterUserMappingStmt:
2530  tag = CMDTAG_ALTER_USER_MAPPING;
2531  break;
2532 
2533  case T_DropUserMappingStmt:
2534  tag = CMDTAG_DROP_USER_MAPPING;
2535  break;
2536 
2537  case T_CreateForeignTableStmt:
2538  tag = CMDTAG_CREATE_FOREIGN_TABLE;
2539  break;
2540 
2541  case T_ImportForeignSchemaStmt:
2542  tag = CMDTAG_IMPORT_FOREIGN_SCHEMA;
2543  break;
2544 
2545  case T_DropStmt:
2546  switch (((DropStmt *) parsetree)->removeType)
2547  {
2548  case OBJECT_TABLE:
2549  tag = CMDTAG_DROP_TABLE;
2550  break;
2551  case OBJECT_SEQUENCE:
2552  tag = CMDTAG_DROP_SEQUENCE;
2553  break;
2554  case OBJECT_VIEW:
2555  tag = CMDTAG_DROP_VIEW;
2556  break;
2557  case OBJECT_MATVIEW:
2558  tag = CMDTAG_DROP_MATERIALIZED_VIEW;
2559  break;
2560  case OBJECT_INDEX:
2561  tag = CMDTAG_DROP_INDEX;
2562  break;
2563  case OBJECT_TYPE:
2564  tag = CMDTAG_DROP_TYPE;
2565  break;
2566  case OBJECT_DOMAIN:
2567  tag = CMDTAG_DROP_DOMAIN;
2568  break;
2569  case OBJECT_COLLATION:
2570  tag = CMDTAG_DROP_COLLATION;
2571  break;
2572  case OBJECT_CONVERSION:
2573  tag = CMDTAG_DROP_CONVERSION;
2574  break;
2575  case OBJECT_SCHEMA:
2576  tag = CMDTAG_DROP_SCHEMA;
2577  break;
2578  case OBJECT_TSPARSER:
2579  tag = CMDTAG_DROP_TEXT_SEARCH_PARSER;
2580  break;
2581  case OBJECT_TSDICTIONARY:
2582  tag = CMDTAG_DROP_TEXT_SEARCH_DICTIONARY;
2583  break;
2584  case OBJECT_TSTEMPLATE:
2585  tag = CMDTAG_DROP_TEXT_SEARCH_TEMPLATE;
2586  break;
2587  case OBJECT_TSCONFIGURATION:
2588  tag = CMDTAG_DROP_TEXT_SEARCH_CONFIGURATION;
2589  break;
2590  case OBJECT_FOREIGN_TABLE:
2591  tag = CMDTAG_DROP_FOREIGN_TABLE;
2592  break;
2593  case OBJECT_EXTENSION:
2594  tag = CMDTAG_DROP_EXTENSION;
2595  break;
2596  case OBJECT_FUNCTION:
2597  tag = CMDTAG_DROP_FUNCTION;
2598  break;
2599  case OBJECT_PROCEDURE:
2600  tag = CMDTAG_DROP_PROCEDURE;
2601  break;
2602  case OBJECT_ROUTINE:
2603  tag = CMDTAG_DROP_ROUTINE;
2604  break;
2605  case OBJECT_AGGREGATE:
2606  tag = CMDTAG_DROP_AGGREGATE;
2607  break;
2608  case OBJECT_OPERATOR:
2609  tag = CMDTAG_DROP_OPERATOR;
2610  break;
2611  case OBJECT_LANGUAGE:
2612  tag = CMDTAG_DROP_LANGUAGE;
2613  break;
2614  case OBJECT_CAST:
2615  tag = CMDTAG_DROP_CAST;
2616  break;
2617  case OBJECT_TRIGGER:
2618  tag = CMDTAG_DROP_TRIGGER;
2619  break;
2620  case OBJECT_EVENT_TRIGGER:
2621  tag = CMDTAG_DROP_EVENT_TRIGGER;
2622  break;
2623  case OBJECT_RULE:
2624  tag = CMDTAG_DROP_RULE;
2625  break;
2626  case OBJECT_FDW:
2627  tag = CMDTAG_DROP_FOREIGN_DATA_WRAPPER;
2628  break;
2629  case OBJECT_FOREIGN_SERVER:
2630  tag = CMDTAG_DROP_SERVER;
2631  break;
2632  case OBJECT_OPCLASS:
2633  tag = CMDTAG_DROP_OPERATOR_CLASS;
2634  break;
2635  case OBJECT_OPFAMILY:
2636  tag = CMDTAG_DROP_OPERATOR_FAMILY;
2637  break;
2638  case OBJECT_POLICY:
2639  tag = CMDTAG_DROP_POLICY;
2640  break;
2641  case OBJECT_TRANSFORM:
2642  tag = CMDTAG_DROP_TRANSFORM;
2643  break;
2644  case OBJECT_ACCESS_METHOD:
2645  tag = CMDTAG_DROP_ACCESS_METHOD;
2646  break;
2647  case OBJECT_PUBLICATION:
2648  tag = CMDTAG_DROP_PUBLICATION;
2649  break;
2650  case OBJECT_STATISTIC_EXT:
2651  tag = CMDTAG_DROP_STATISTICS;
2652  break;
2653  default:
2654  tag = CMDTAG_UNKNOWN;
2655  }
2656  break;
2657 
2658  case T_TruncateStmt:
2659  tag = CMDTAG_TRUNCATE_TABLE;
2660  break;
2661 
2662  case T_CommentStmt:
2663  tag = CMDTAG_COMMENT;
2664  break;
2665 
2666  case T_SecLabelStmt:
2667  tag = CMDTAG_SECURITY_LABEL;
2668  break;
2669 
2670  case T_CopyStmt:
2671  tag = CMDTAG_COPY;
2672  break;
2673 
2674  case T_RenameStmt:
2675 
2676  /*
2677  * When the column is renamed, the command tag is created from its
2678  * relation type
2679  */
2680  tag = AlterObjectTypeCommandTag(((RenameStmt *) parsetree)->renameType == OBJECT_COLUMN ?
2681  ((RenameStmt *) parsetree)->relationType :
2682  ((RenameStmt *) parsetree)->renameType);
2683  break;
2684 
2685  case T_AlterObjectDependsStmt:
2686  tag = AlterObjectTypeCommandTag(((AlterObjectDependsStmt *) parsetree)->objectType);
2687  break;
2688 
2689  case T_AlterObjectSchemaStmt:
2690  tag = AlterObjectTypeCommandTag(((AlterObjectSchemaStmt *) parsetree)->objectType);
2691  break;
2692 
2693  case T_AlterOwnerStmt:
2694  tag = AlterObjectTypeCommandTag(((AlterOwnerStmt *) parsetree)->objectType);
2695  break;
2696 
2697  case T_AlterTableMoveAllStmt:
2698  tag = AlterObjectTypeCommandTag(((AlterTableMoveAllStmt *) parsetree)->objtype);
2699  break;
2700 
2701  case T_AlterTableStmt:
2702  tag = AlterObjectTypeCommandTag(((AlterTableStmt *) parsetree)->objtype);
2703  break;
2704 
2705  case T_AlterDomainStmt:
2706  tag = CMDTAG_ALTER_DOMAIN;
2707  break;
2708 
2709  case T_AlterFunctionStmt:
2710  switch (((AlterFunctionStmt *) parsetree)->objtype)
2711  {
2712  case OBJECT_FUNCTION:
2713  tag = CMDTAG_ALTER_FUNCTION;
2714  break;
2715  case OBJECT_PROCEDURE:
2716  tag = CMDTAG_ALTER_PROCEDURE;
2717  break;
2718  case OBJECT_ROUTINE:
2719  tag = CMDTAG_ALTER_ROUTINE;
2720  break;
2721  default:
2722  tag = CMDTAG_UNKNOWN;
2723  }
2724  break;
2725 
2726  case T_GrantStmt:
2727  {
2728  GrantStmt *stmt = (GrantStmt *) parsetree;
2729 
2730  tag = (stmt->is_grant) ? CMDTAG_GRANT : CMDTAG_REVOKE;
2731  }
2732  break;
2733 
2734  case T_GrantRoleStmt:
2735  {
2736  GrantRoleStmt *stmt = (GrantRoleStmt *) parsetree;
2737 
2738  tag = (stmt->is_grant) ? CMDTAG_GRANT_ROLE : CMDTAG_REVOKE_ROLE;
2739  }
2740  break;
2741 
2742  case T_AlterDefaultPrivilegesStmt:
2743  tag = CMDTAG_ALTER_DEFAULT_PRIVILEGES;
2744  break;
2745 
2746  case T_DefineStmt:
2747  switch (((DefineStmt *) parsetree)->kind)
2748  {
2749  case OBJECT_AGGREGATE:
2750  tag = CMDTAG_CREATE_AGGREGATE;
2751  break;
2752  case OBJECT_OPERATOR:
2753  tag = CMDTAG_CREATE_OPERATOR;
2754  break;
2755  case OBJECT_TYPE:
2756  tag = CMDTAG_CREATE_TYPE;
2757  break;
2758  case OBJECT_TSPARSER:
2759  tag = CMDTAG_CREATE_TEXT_SEARCH_PARSER;
2760  break;
2761  case OBJECT_TSDICTIONARY:
2762  tag = CMDTAG_CREATE_TEXT_SEARCH_DICTIONARY;
2763  break;
2764  case OBJECT_TSTEMPLATE:
2765  tag = CMDTAG_CREATE_TEXT_SEARCH_TEMPLATE;
2766  break;
2767  case OBJECT_TSCONFIGURATION:
2768  tag = CMDTAG_CREATE_TEXT_SEARCH_CONFIGURATION;
2769  break;
2770  case OBJECT_COLLATION:
2771  tag = CMDTAG_CREATE_COLLATION;
2772  break;
2773  case OBJECT_ACCESS_METHOD:
2774  tag = CMDTAG_CREATE_ACCESS_METHOD;
2775  break;
2776  default:
2777  tag = CMDTAG_UNKNOWN;
2778  }
2779  break;
2780 
2781  case T_CompositeTypeStmt:
2782  tag = CMDTAG_CREATE_TYPE;
2783  break;
2784 
2785  case T_CreateEnumStmt:
2786  tag = CMDTAG_CREATE_TYPE;
2787  break;
2788 
2789  case T_CreateRangeStmt:
2790  tag = CMDTAG_CREATE_TYPE;
2791  break;
2792 
2793  case T_AlterEnumStmt:
2794  tag = CMDTAG_ALTER_TYPE;
2795  break;
2796 
2797  case T_ViewStmt:
2798  tag = CMDTAG_CREATE_VIEW;
2799  break;
2800 
2801  case T_CreateFunctionStmt:
2802  if (((CreateFunctionStmt *) parsetree)->is_procedure)
2803  tag = CMDTAG_CREATE_PROCEDURE;
2804  else
2805  tag = CMDTAG_CREATE_FUNCTION;
2806  break;
2807 
2808  case T_IndexStmt:
2809  tag = CMDTAG_CREATE_INDEX;
2810  break;
2811 
2812  case T_RuleStmt:
2813  tag = CMDTAG_CREATE_RULE;
2814  break;
2815 
2816  case T_CreateSeqStmt:
2817  tag = CMDTAG_CREATE_SEQUENCE;
2818  break;
2819 
2820  case T_AlterSeqStmt:
2821  tag = CMDTAG_ALTER_SEQUENCE;
2822  break;
2823 
2824  case T_DoStmt:
2825  tag = CMDTAG_DO;
2826  break;
2827 
2828  case T_CreatedbStmt:
2829  tag = CMDTAG_CREATE_DATABASE;
2830  break;
2831 
2832  case T_AlterDatabaseStmt:
2833  case T_AlterDatabaseRefreshCollStmt:
2834  case T_AlterDatabaseSetStmt:
2835  tag = CMDTAG_ALTER_DATABASE;
2836  break;
2837 
2838  case T_DropdbStmt:
2839  tag = CMDTAG_DROP_DATABASE;
2840  break;
2841 
2842  case T_NotifyStmt:
2843  tag = CMDTAG_NOTIFY;
2844  break;
2845 
2846  case T_ListenStmt:
2847  tag = CMDTAG_LISTEN;
2848  break;
2849 
2850  case T_UnlistenStmt:
2851  tag = CMDTAG_UNLISTEN;
2852  break;
2853 
2854  case T_LoadStmt:
2855  tag = CMDTAG_LOAD;
2856  break;
2857 
2858  case T_CallStmt:
2859  tag = CMDTAG_CALL;
2860  break;
2861 
2862  case T_ClusterStmt:
2863  tag = CMDTAG_CLUSTER;
2864  break;
2865 
2866  case T_VacuumStmt:
2867  if (((VacuumStmt *) parsetree)->is_vacuumcmd)
2868  tag = CMDTAG_VACUUM;
2869  else
2870  tag = CMDTAG_ANALYZE;
2871  break;
2872 
2873  case T_ExplainStmt:
2874  tag = CMDTAG_EXPLAIN;
2875  break;
2876 
2877  case T_CreateTableAsStmt:
2878  switch (((CreateTableAsStmt *) parsetree)->objtype)
2879  {
2880  case OBJECT_TABLE:
2881  if (((CreateTableAsStmt *) parsetree)->is_select_into)
2882  tag = CMDTAG_SELECT_INTO;
2883  else
2884  tag = CMDTAG_CREATE_TABLE_AS;
2885  break;
2886  case OBJECT_MATVIEW:
2887  tag = CMDTAG_CREATE_MATERIALIZED_VIEW;
2888  break;
2889  default:
2890  tag = CMDTAG_UNKNOWN;
2891  }
2892  break;
2893 
2894  case T_RefreshMatViewStmt:
2895  tag = CMDTAG_REFRESH_MATERIALIZED_VIEW;
2896  break;
2897 
2898  case T_AlterSystemStmt:
2899  tag = CMDTAG_ALTER_SYSTEM;
2900  break;
2901 
2902  case T_VariableSetStmt:
2903  switch (((VariableSetStmt *) parsetree)->kind)
2904  {
2905  case VAR_SET_VALUE:
2906  case VAR_SET_CURRENT:
2907  case VAR_SET_DEFAULT:
2908  case VAR_SET_MULTI:
2909  tag = CMDTAG_SET;
2910  break;
2911  case VAR_RESET:
2912  case VAR_RESET_ALL:
2913  tag = CMDTAG_RESET;
2914  break;
2915  default:
2916  tag = CMDTAG_UNKNOWN;
2917  }
2918  break;
2919 
2920  case T_VariableShowStmt:
2921  tag = CMDTAG_SHOW;
2922  break;
2923 
2924  case T_DiscardStmt:
2925  switch (((DiscardStmt *) parsetree)->target)
2926  {
2927  case DISCARD_ALL:
2928  tag = CMDTAG_DISCARD_ALL;
2929  break;
2930  case DISCARD_PLANS:
2931  tag = CMDTAG_DISCARD_PLANS;
2932  break;
2933  case DISCARD_TEMP:
2934  tag = CMDTAG_DISCARD_TEMP;
2935  break;
2936  case DISCARD_SEQUENCES:
2937  tag = CMDTAG_DISCARD_SEQUENCES;
2938  break;
2939  default:
2940  tag = CMDTAG_UNKNOWN;
2941  }
2942  break;
2943 
2944  case T_CreateTransformStmt:
2945  tag = CMDTAG_CREATE_TRANSFORM;
2946  break;
2947 
2948  case T_CreateTrigStmt:
2949  tag = CMDTAG_CREATE_TRIGGER;
2950  break;
2951 
2952  case T_CreateEventTrigStmt:
2953  tag = CMDTAG_CREATE_EVENT_TRIGGER;
2954  break;
2955 
2956  case T_AlterEventTrigStmt:
2957  tag = CMDTAG_ALTER_EVENT_TRIGGER;
2958  break;
2959 
2960  case T_CreatePLangStmt:
2961  tag = CMDTAG_CREATE_LANGUAGE;
2962  break;
2963 
2964  case T_CreateRoleStmt:
2965  tag = CMDTAG_CREATE_ROLE;
2966  break;
2967 
2968  case T_AlterRoleStmt:
2969  tag = CMDTAG_ALTER_ROLE;
2970  break;
2971 
2972  case T_AlterRoleSetStmt:
2973  tag = CMDTAG_ALTER_ROLE;
2974  break;
2975 
2976  case T_DropRoleStmt:
2977  tag = CMDTAG_DROP_ROLE;
2978  break;
2979 
2980  case T_DropOwnedStmt:
2981  tag = CMDTAG_DROP_OWNED;
2982  break;
2983 
2984  case T_ReassignOwnedStmt:
2985  tag = CMDTAG_REASSIGN_OWNED;
2986  break;
2987 
2988  case T_LockStmt:
2989  tag = CMDTAG_LOCK_TABLE;
2990  break;
2991 
2992  case T_ConstraintsSetStmt:
2993  tag = CMDTAG_SET_CONSTRAINTS;
2994  break;
2995 
2996  case T_CheckPointStmt:
2997  tag = CMDTAG_CHECKPOINT;
2998  break;
2999 
3000  case T_ReindexStmt:
3001  tag = CMDTAG_REINDEX;
3002  break;
3003 
3004  case T_CreateConversionStmt:
3005  tag = CMDTAG_CREATE_CONVERSION;
3006  break;
3007 
3008  case T_CreateCastStmt:
3009  tag = CMDTAG_CREATE_CAST;
3010  break;
3011 
3012  case T_CreateOpClassStmt:
3013  tag = CMDTAG_CREATE_OPERATOR_CLASS;
3014  break;
3015 
3016  case T_CreateOpFamilyStmt:
3017  tag = CMDTAG_CREATE_OPERATOR_FAMILY;
3018  break;
3019 
3020  case T_AlterOpFamilyStmt:
3021  tag = CMDTAG_ALTER_OPERATOR_FAMILY;
3022  break;
3023 
3024  case T_AlterOperatorStmt:
3025  tag = CMDTAG_ALTER_OPERATOR;
3026  break;
3027 
3028  case T_AlterTypeStmt:
3029  tag = CMDTAG_ALTER_TYPE;
3030  break;
3031 
3032  case T_AlterTSDictionaryStmt:
3033  tag = CMDTAG_ALTER_TEXT_SEARCH_DICTIONARY;
3034  break;
3035 
3036  case T_AlterTSConfigurationStmt:
3037  tag = CMDTAG_ALTER_TEXT_SEARCH_CONFIGURATION;
3038  break;
3039 
3040  case T_CreatePolicyStmt:
3041  tag = CMDTAG_CREATE_POLICY;
3042  break;
3043 
3044  case T_AlterPolicyStmt:
3045  tag = CMDTAG_ALTER_POLICY;
3046  break;
3047 
3048  case T_CreateAmStmt:
3049  tag = CMDTAG_CREATE_ACCESS_METHOD;
3050  break;
3051 
3052  case T_CreatePublicationStmt:
3053  tag = CMDTAG_CREATE_PUBLICATION;
3054  break;
3055 
3056  case T_AlterPublicationStmt:
3057  tag = CMDTAG_ALTER_PUBLICATION;
3058  break;
3059 
3060  case T_CreateSubscriptionStmt:
3061  tag = CMDTAG_CREATE_SUBSCRIPTION;
3062  break;
3063 
3064  case T_AlterSubscriptionStmt:
3065  tag = CMDTAG_ALTER_SUBSCRIPTION;
3066  break;
3067 
3068  case T_DropSubscriptionStmt:
3069  tag = CMDTAG_DROP_SUBSCRIPTION;
3070  break;
3071 
3072  case T_AlterCollationStmt:
3073  tag = CMDTAG_ALTER_COLLATION;
3074  break;
3075 
3076  case T_PrepareStmt:
3077  tag = CMDTAG_PREPARE;
3078  break;
3079 
3080  case T_ExecuteStmt:
3081  tag = CMDTAG_EXECUTE;
3082  break;
3083 
3084  case T_CreateStatsStmt:
3085  tag = CMDTAG_CREATE_STATISTICS;
3086  break;
3087 
3088  case T_AlterStatsStmt:
3089  tag = CMDTAG_ALTER_STATISTICS;
3090  break;
3091 
3092  case T_DeallocateStmt:
3093  {
3094  DeallocateStmt *stmt = (DeallocateStmt *) parsetree;
3095 
3096  if (stmt->name == NULL)
3097  tag = CMDTAG_DEALLOCATE_ALL;
3098  else
3099  tag = CMDTAG_DEALLOCATE;
3100  }
3101  break;
3102 
3103  /* already-planned queries */
3104  case T_PlannedStmt:
3105  {
3106  PlannedStmt *stmt = (PlannedStmt *) parsetree;
3107 
3108  switch (stmt->commandType)
3109  {
3110  case CMD_SELECT:
3111 
3112  /*
3113  * We take a little extra care here so that the result
3114  * will be useful for complaints about read-only
3115  * statements
3116  */
3117  if (stmt->rowMarks != NIL)
3118  {
3119  /* not 100% but probably close enough */
3120  switch (((PlanRowMark *) linitial(stmt->rowMarks))->strength)
3121  {
3122  case LCS_FORKEYSHARE:
3123  tag = CMDTAG_SELECT_FOR_KEY_SHARE;
3124  break;
3125  case LCS_FORSHARE:
3126  tag = CMDTAG_SELECT_FOR_SHARE;
3127  break;
3128  case LCS_FORNOKEYUPDATE:
3129  tag = CMDTAG_SELECT_FOR_NO_KEY_UPDATE;
3130  break;
3131  case LCS_FORUPDATE:
3132  tag = CMDTAG_SELECT_FOR_UPDATE;
3133  break;
3134  default:
3135  tag = CMDTAG_SELECT;
3136  break;
3137  }
3138  }
3139  else
3140  tag = CMDTAG_SELECT;
3141  break;
3142  case CMD_UPDATE:
3143  tag = CMDTAG_UPDATE;
3144  break;
3145  case CMD_INSERT:
3146  tag = CMDTAG_INSERT;
3147  break;
3148  case CMD_DELETE:
3149  tag = CMDTAG_DELETE;
3150  break;
3151  case CMD_MERGE:
3152  tag = CMDTAG_MERGE;
3153  break;
3154  case CMD_UTILITY:
3155  tag = CreateCommandTag(stmt->utilityStmt);
3156  break;
3157  default:
3158  elog(WARNING, "unrecognized commandType: %d",
3159  (int) stmt->commandType);
3160  tag = CMDTAG_UNKNOWN;
3161  break;
3162  }
3163  }
3164  break;
3165 
3166  /* parsed-and-rewritten-but-not-planned queries */
3167  case T_Query:
3168  {
3169  Query *stmt = (Query *) parsetree;
3170 
3171  switch (stmt->commandType)
3172  {
3173  case CMD_SELECT:
3174 
3175  /*
3176  * We take a little extra care here so that the result
3177  * will be useful for complaints about read-only
3178  * statements
3179  */
3180  if (stmt->rowMarks != NIL)
3181  {
3182  /* not 100% but probably close enough */
3183  switch (((RowMarkClause *) linitial(stmt->rowMarks))->strength)
3184  {
3185  case LCS_FORKEYSHARE:
3186  tag = CMDTAG_SELECT_FOR_KEY_SHARE;
3187  break;
3188  case LCS_FORSHARE:
3189  tag = CMDTAG_SELECT_FOR_SHARE;
3190  break;
3191  case LCS_FORNOKEYUPDATE:
3192  tag = CMDTAG_SELECT_FOR_NO_KEY_UPDATE;
3193  break;
3194  case LCS_FORUPDATE:
3195  tag = CMDTAG_SELECT_FOR_UPDATE;
3196  break;
3197  default:
3198  tag = CMDTAG_UNKNOWN;
3199  break;
3200  }
3201  }
3202  else
3203  tag = CMDTAG_SELECT;
3204  break;
3205  case CMD_UPDATE:
3206  tag = CMDTAG_UPDATE;
3207  break;
3208  case CMD_INSERT:
3209  tag = CMDTAG_INSERT;
3210  break;
3211  case CMD_DELETE:
3212  tag = CMDTAG_DELETE;
3213  break;
3214  case CMD_MERGE:
3215  tag = CMDTAG_MERGE;
3216  break;
3217  case CMD_UTILITY:
3218  tag = CreateCommandTag(stmt->utilityStmt);
3219  break;
3220  default:
3221  elog(WARNING, "unrecognized commandType: %d",
3222  (int) stmt->commandType);
3223  tag = CMDTAG_UNKNOWN;
3224  break;
3225  }
3226  }
3227  break;
3228 
3229  default:
3230  elog(WARNING, "unrecognized node type: %d",
3231  (int) nodeTag(parsetree));
3232  tag = CMDTAG_UNKNOWN;
3233  break;
3234  }
3235 
3236  return tag;
3237 }
3238 
3239 
3240 /*
3241  * GetCommandLogLevel
3242  * utility to get the minimum log_statement level for a command,
3243  * given either a raw (un-analyzed) parsetree, an analyzed Query,
3244  * or a PlannedStmt.
3245  *
3246  * This must handle all command types, but since the vast majority
3247  * of 'em are utility commands, it seems sensible to keep it here.
3248  */
3249 LogStmtLevel
3250 GetCommandLogLevel(Node *parsetree)
3251 {
3252  LogStmtLevel lev;
3253 
3254  switch (nodeTag(parsetree))
3255  {
3256  /* recurse if we're given a RawStmt */
3257  case T_RawStmt:
3258  lev = GetCommandLogLevel(((RawStmt *) parsetree)->stmt);
3259  break;
3260 
3261  /* raw plannable queries */
3262  case T_InsertStmt:
3263  case T_DeleteStmt:
3264  case T_UpdateStmt:
3265  case T_MergeStmt:
3266  lev = LOGSTMT_MOD;
3267  break;
3268 
3269  case T_SelectStmt:
3270  if (((SelectStmt *) parsetree)->intoClause)
3271  lev = LOGSTMT_DDL; /* SELECT INTO */
3272  else
3273  lev = LOGSTMT_ALL;
3274  break;
3275 
3276  case T_PLAssignStmt:
3277  lev = LOGSTMT_ALL;
3278  break;
3279 
3280  /* utility statements --- same whether raw or cooked */
3281  case T_TransactionStmt:
3282  lev = LOGSTMT_ALL;
3283  break;
3284 
3285  case T_DeclareCursorStmt:
3286  lev = LOGSTMT_ALL;
3287  break;
3288 
3289  case T_ClosePortalStmt:
3290  lev = LOGSTMT_ALL;
3291  break;
3292 
3293  case T_FetchStmt:
3294  lev = LOGSTMT_ALL;
3295  break;
3296 
3297  case T_CreateSchemaStmt:
3298  lev = LOGSTMT_DDL;
3299  break;
3300 
3301  case T_CreateStmt:
3302  case T_CreateForeignTableStmt:
3303  lev = LOGSTMT_DDL;
3304  break;
3305 
3306  case T_CreateTableSpaceStmt:
3307  case T_DropTableSpaceStmt:
3308  case T_AlterTableSpaceOptionsStmt:
3309  lev = LOGSTMT_DDL;
3310  break;
3311 
3312  case T_CreateExtensionStmt:
3313  case T_AlterExtensionStmt:
3314  case T_AlterExtensionContentsStmt:
3315  lev = LOGSTMT_DDL;
3316  break;
3317 
3318  case T_CreateFdwStmt:
3319  case T_AlterFdwStmt:
3320  case T_CreateForeignServerStmt:
3321  case T_AlterForeignServerStmt:
3322  case T_CreateUserMappingStmt:
3323  case T_AlterUserMappingStmt:
3324  case T_DropUserMappingStmt:
3325  case T_ImportForeignSchemaStmt:
3326  lev = LOGSTMT_DDL;
3327  break;
3328 
3329  case T_DropStmt:
3330  lev = LOGSTMT_DDL;
3331  break;
3332 
3333  case T_TruncateStmt:
3334  lev = LOGSTMT_MOD;
3335  break;
3336 
3337  case T_CommentStmt:
3338  lev = LOGSTMT_DDL;
3339  break;
3340 
3341  case T_SecLabelStmt:
3342  lev = LOGSTMT_DDL;
3343  break;
3344 
3345  case T_CopyStmt:
3346  if (((CopyStmt *) parsetree)->is_from)
3347  lev = LOGSTMT_MOD;
3348  else
3349  lev = LOGSTMT_ALL;
3350  break;
3351 
3352  case T_PrepareStmt:
3353  {
3354  PrepareStmt *stmt = (PrepareStmt *) parsetree;
3355 
3356  /* Look through a PREPARE to the contained stmt */
3357  lev = GetCommandLogLevel(stmt->query);
3358  }
3359  break;
3360 
3361  case T_ExecuteStmt:
3362  {
3363  ExecuteStmt *stmt = (ExecuteStmt *) parsetree;
3364  PreparedStatement *ps;
3365 
3366  /* Look through an EXECUTE to the referenced stmt */
3367  ps = FetchPreparedStatement(stmt->name, false);
3368  if (ps && ps->plansource->raw_parse_tree)
3369  lev = GetCommandLogLevel(ps->plansource->raw_parse_tree->stmt);
3370  else
3371  lev = LOGSTMT_ALL;
3372  }
3373  break;
3374 
3375  case T_DeallocateStmt:
3376  lev = LOGSTMT_ALL;
3377  break;
3378 
3379  case T_RenameStmt:
3380  lev = LOGSTMT_DDL;
3381  break;
3382 
3383  case T_AlterObjectDependsStmt:
3384  lev = LOGSTMT_DDL;
3385  break;
3386 
3387  case T_AlterObjectSchemaStmt:
3388  lev = LOGSTMT_DDL;
3389  break;
3390 
3391  case T_AlterOwnerStmt:
3392  lev = LOGSTMT_DDL;
3393  break;
3394 
3395  case T_AlterOperatorStmt:
3396  lev = LOGSTMT_DDL;
3397  break;
3398 
3399  case T_AlterTypeStmt:
3400  lev = LOGSTMT_DDL;
3401  break;
3402 
3403  case T_AlterTableMoveAllStmt:
3404  case T_AlterTableStmt:
3405  lev = LOGSTMT_DDL;
3406  break;
3407 
3408  case T_AlterDomainStmt:
3409  lev = LOGSTMT_DDL;
3410  break;
3411 
3412  case T_GrantStmt:
3413  lev = LOGSTMT_DDL;
3414  break;
3415 
3416  case T_GrantRoleStmt:
3417  lev = LOGSTMT_DDL;
3418  break;
3419 
3420  case T_AlterDefaultPrivilegesStmt:
3421  lev = LOGSTMT_DDL;
3422  break;
3423 
3424  case T_DefineStmt:
3425  lev = LOGSTMT_DDL;
3426  break;
3427 
3428  case T_CompositeTypeStmt:
3429  lev = LOGSTMT_DDL;
3430  break;
3431 
3432  case T_CreateEnumStmt:
3433  lev = LOGSTMT_DDL;
3434  break;
3435 
3436  case T_CreateRangeStmt:
3437  lev = LOGSTMT_DDL;
3438  break;
3439 
3440  case T_AlterEnumStmt:
3441  lev = LOGSTMT_DDL;
3442  break;
3443 
3444  case T_ViewStmt:
3445  lev = LOGSTMT_DDL;
3446  break;
3447 
3448  case T_CreateFunctionStmt:
3449  lev = LOGSTMT_DDL;
3450  break;
3451 
3452  case T_AlterFunctionStmt:
3453  lev = LOGSTMT_DDL;
3454  break;
3455 
3456  case T_IndexStmt:
3457  lev = LOGSTMT_DDL;
3458  break;
3459 
3460  case T_RuleStmt:
3461  lev = LOGSTMT_DDL;
3462  break;
3463 
3464  case T_CreateSeqStmt:
3465  lev = LOGSTMT_DDL;
3466  break;
3467 
3468  case T_AlterSeqStmt:
3469  lev = LOGSTMT_DDL;
3470  break;
3471 
3472  case T_DoStmt:
3473  lev = LOGSTMT_ALL;
3474  break;
3475 
3476  case T_CreatedbStmt:
3477  lev = LOGSTMT_DDL;
3478  break;
3479 
3480  case T_AlterDatabaseStmt:
3481  case T_AlterDatabaseRefreshCollStmt:
3482  case T_AlterDatabaseSetStmt:
3483  lev = LOGSTMT_DDL;
3484  break;
3485 
3486  case T_DropdbStmt:
3487  lev = LOGSTMT_DDL;
3488  break;
3489 
3490  case T_NotifyStmt:
3491  lev = LOGSTMT_ALL;
3492  break;
3493 
3494  case T_ListenStmt:
3495  lev = LOGSTMT_ALL;
3496  break;
3497 
3498  case T_UnlistenStmt:
3499  lev = LOGSTMT_ALL;
3500  break;
3501 
3502  case T_LoadStmt:
3503  lev = LOGSTMT_ALL;
3504  break;
3505 
3506  case T_CallStmt:
3507  lev = LOGSTMT_ALL;
3508  break;
3509 
3510  case T_ClusterStmt:
3511  lev = LOGSTMT_DDL;
3512  break;
3513 
3514  case T_VacuumStmt:
3515  lev = LOGSTMT_ALL;
3516  break;
3517 
3518  case T_ExplainStmt:
3519  {
3520  ExplainStmt *stmt = (ExplainStmt *) parsetree;
3521  bool analyze = false;
3522  ListCell *lc;
3523 
3524  /* Look through an EXPLAIN ANALYZE to the contained stmt */
3525  foreach(lc, stmt->options)
3526  {
3527  DefElem *opt = (DefElem *) lfirst(lc);
3528 
3529  if (strcmp(opt->defname, "analyze") == 0)
3530  analyze = defGetBoolean(opt);
3531  /* don't "break", as explain.c will use the last value */
3532  }
3533  if (analyze)
3534  return GetCommandLogLevel(stmt->query);
3535 
3536  /* Plain EXPLAIN isn't so interesting */
3537  lev = LOGSTMT_ALL;
3538  }
3539  break;
3540 
3541  case T_CreateTableAsStmt:
3542  lev = LOGSTMT_DDL;
3543  break;
3544 
3545  case T_RefreshMatViewStmt:
3546  lev = LOGSTMT_DDL;
3547  break;
3548 
3549  case T_AlterSystemStmt:
3550  lev = LOGSTMT_DDL;
3551  break;
3552 
3553  case T_VariableSetStmt:
3554  lev = LOGSTMT_ALL;
3555  break;
3556 
3557  case T_VariableShowStmt:
3558  lev = LOGSTMT_ALL;
3559  break;
3560 
3561  case T_DiscardStmt:
3562  lev = LOGSTMT_ALL;
3563  break;
3564 
3565  case T_CreateTrigStmt:
3566  lev = LOGSTMT_DDL;
3567  break;
3568 
3569  case T_CreateEventTrigStmt:
3570  lev = LOGSTMT_DDL;
3571  break;
3572 
3573  case T_AlterEventTrigStmt:
3574  lev = LOGSTMT_DDL;
3575  break;
3576 
3577  case T_CreatePLangStmt:
3578  lev = LOGSTMT_DDL;
3579  break;
3580 
3581  case T_CreateDomainStmt:
3582  lev = LOGSTMT_DDL;
3583  break;
3584 
3585  case T_CreateRoleStmt:
3586  lev = LOGSTMT_DDL;
3587  break;
3588 
3589  case T_AlterRoleStmt:
3590  lev = LOGSTMT_DDL;
3591  break;
3592 
3593  case T_AlterRoleSetStmt:
3594  lev = LOGSTMT_DDL;
3595  break;
3596 
3597  case T_DropRoleStmt:
3598  lev = LOGSTMT_DDL;
3599  break;
3600 
3601  case T_DropOwnedStmt:
3602  lev = LOGSTMT_DDL;
3603  break;
3604 
3605  case T_ReassignOwnedStmt:
3606  lev = LOGSTMT_DDL;
3607  break;
3608 
3609  case T_LockStmt:
3610  lev = LOGSTMT_ALL;
3611  break;
3612 
3613  case T_ConstraintsSetStmt:
3614  lev = LOGSTMT_ALL;
3615  break;
3616 
3617  case T_CheckPointStmt:
3618  lev = LOGSTMT_ALL;
3619  break;
3620 
3621  case T_ReindexStmt:
3622  lev = LOGSTMT_ALL; /* should this be DDL? */
3623  break;
3624 
3625  case T_CreateConversionStmt:
3626  lev = LOGSTMT_DDL;
3627  break;
3628 
3629  case T_CreateCastStmt:
3630  lev = LOGSTMT_DDL;
3631  break;
3632 
3633  case T_CreateOpClassStmt:
3634  lev = LOGSTMT_DDL;
3635  break;
3636 
3637  case T_CreateOpFamilyStmt:
3638  lev = LOGSTMT_DDL;
3639  break;
3640 
3641  case T_CreateTransformStmt:
3642  lev = LOGSTMT_DDL;
3643  break;
3644 
3645  case T_AlterOpFamilyStmt:
3646  lev = LOGSTMT_DDL;
3647  break;
3648 
3649  case T_CreatePolicyStmt:
3650  lev = LOGSTMT_DDL;
3651  break;
3652 
3653  case T_AlterPolicyStmt:
3654  lev = LOGSTMT_DDL;
3655  break;
3656 
3657  case T_AlterTSDictionaryStmt:
3658  lev = LOGSTMT_DDL;
3659  break;
3660 
3661  case T_AlterTSConfigurationStmt:
3662  lev = LOGSTMT_DDL;
3663  break;
3664 
3665  case T_CreateAmStmt:
3666  lev = LOGSTMT_DDL;
3667  break;
3668 
3669  case T_CreatePublicationStmt:
3670  lev = LOGSTMT_DDL;
3671  break;
3672 
3673  case T_AlterPublicationStmt:
3674  lev = LOGSTMT_DDL;
3675  break;
3676 
3677  case T_CreateSubscriptionStmt:
3678  lev = LOGSTMT_DDL;
3679  break;
3680 
3681  case T_AlterSubscriptionStmt:
3682  lev = LOGSTMT_DDL;
3683  break;
3684 
3685  case T_DropSubscriptionStmt:
3686  lev = LOGSTMT_DDL;
3687  break;
3688 
3689  case T_CreateStatsStmt:
3690  lev = LOGSTMT_DDL;
3691  break;
3692 
3693  case T_AlterStatsStmt:
3694  lev = LOGSTMT_DDL;
3695  break;
3696 
3697  case T_AlterCollationStmt:
3698  lev = LOGSTMT_DDL;
3699  break;
3700 
3701  /* already-planned queries */
3702  case T_PlannedStmt:
3703  {
3704  PlannedStmt *stmt = (PlannedStmt *) parsetree;
3705 
3706  switch (stmt->commandType)
3707  {
3708  case CMD_SELECT:
3709  lev = LOGSTMT_ALL;
3710  break;
3711 
3712  case CMD_UPDATE:
3713  case CMD_INSERT:
3714  case CMD_DELETE:
3715  case CMD_MERGE:
3716  lev = LOGSTMT_MOD;
3717  break;
3718 
3719  case CMD_UTILITY:
3720  lev = GetCommandLogLevel(stmt->utilityStmt);
3721  break;
3722 
3723  default:
3724  elog(WARNING, "unrecognized commandType: %d",
3725  (int) stmt->commandType);
3726  lev = LOGSTMT_ALL;
3727  break;
3728  }
3729  }
3730  break;
3731 
3732  /* parsed-and-rewritten-but-not-planned queries */
3733  case T_Query:
3734  {
3735  Query *stmt = (Query *) parsetree;
3736 
3737  switch (stmt->commandType)
3738  {
3739  case CMD_SELECT:
3740  lev = LOGSTMT_ALL;
3741  break;
3742 
3743  case CMD_UPDATE:
3744  case CMD_INSERT:
3745  case CMD_DELETE:
3746  case CMD_MERGE:
3747  lev = LOGSTMT_MOD;
3748  break;
3749 
3750  case CMD_UTILITY:
3751  lev = GetCommandLogLevel(stmt->utilityStmt);
3752  break;
3753 
3754  default:
3755  elog(WARNING, "unrecognized commandType: %d",
3756  (int) stmt->commandType);
3757  lev = LOGSTMT_ALL;
3758  break;
3759  }
3760  }
3761  break;
3762 
3763  default:
3764  elog(WARNING, "unrecognized node type: %d",
3765  (int) nodeTag(parsetree));
3766  lev = LOGSTMT_ALL;
3767  break;
3768  }
3769 
3770  return lev;
3771 }
has_privs_of_role
bool has_privs_of_role(Oid member, Oid role)
Definition: acl.c:4969
ExecuteGrantStmt
void ExecuteGrantStmt(GrantStmt *stmt)
Definition: aclchk.c:382
ExecAlterDefaultPrivilegesStmt
void ExecAlterDefaultPrivilegesStmt(ParseState *pstate, AlterDefaultPrivilegesStmt *stmt)
Definition: aclchk.c:966
DefineAggregate
ObjectAddress DefineAggregate(ParseState *pstate, List *name, List *args, bool oldstyle, List *parameters, bool replace)
Definition: aggregatecmds.c:57
ExecAlterOwnerStmt
ObjectAddress ExecAlterOwnerStmt(AlterOwnerStmt *stmt)
Definition: alter.c:864
ExecAlterObjectDependsStmt
ObjectAddress ExecAlterObjectDependsStmt(AlterObjectDependsStmt *stmt, ObjectAddress *refAddress)
Definition: alter.c:459
ExecRenameStmt
ObjectAddress ExecRenameStmt(RenameStmt *stmt)
Definition: alter.c:359
ExecAlterObjectSchemaStmt
ObjectAddress ExecAlterObjectSchemaStmt(AlterObjectSchemaStmt *stmt, ObjectAddress *oldSchemaAddr)
Definition: alter.c:523
CreateAccessMethod
ObjectAddress CreateAccessMethod(CreateAmStmt *stmt)
Definition: amcmds.c:43
Async_UnlistenAll
void Async_UnlistenAll(void)
Definition: async.c:804
Async_Unlisten
void Async_Unlisten(const char *channel)
Definition: async.c:786
Async_Listen
void Async_Listen(const char *channel)
Definition: async.c:772
Async_Notify
void Async_Notify(const char *channel, const char *payload)
Definition: async.c:625
DoCopy
void DoCopy(ParseState *pstate, const CopyStmt *stmt, int stmt_location, int stmt_len, uint64 *processed)
Definition: copy.c:64
PrepareQuery
void PrepareQuery(ParseState *pstate, PrepareStmt *stmt, int stmt_location, int stmt_len)
Definition: prepare.c:59
FetchPreparedStatement
PreparedStatement * FetchPreparedStatement(const char *stmt_name, bool throwError)
Definition: prepare.c:434
FetchPreparedStatementResultDesc
TupleDesc FetchPreparedStatementResultDesc(PreparedStatement *stmt)
Definition: prepare.c:466
ExecuteQuery
void ExecuteQuery(ParseState *pstate, ExecuteStmt *stmt, IntoClause *intoClause, ParamListInfo params, DestReceiver *dest, QueryCompletion *qc)
Definition: prepare.c:150
DeallocateQuery
void DeallocateQuery(DeallocateStmt *stmt)
Definition: prepare.c:505
AlterTableSpaceOptions
Oid AlterTableSpaceOptions(AlterTableSpaceOptionsStmt *stmt)
Definition: tablespace.c:1021
DropTableSpace
void DropTableSpace(DropTableSpaceStmt *stmt)
Definition: tablespace.c:401
CreateTableSpace
Oid CreateTableSpace(CreateTableSpaceStmt *stmt)
Definition: tablespace.c:214
OidIsValid
#define OidIsValid(objectId)
Definition: c.h:759
RequestCheckpoint
void RequestCheckpoint(int flags)
Definition: checkpointer.c:931
cluster
void cluster(ParseState *pstate, ClusterStmt *stmt, bool isTopLevel)
Definition: cluster.c:111
GetCommandTagName
const char * GetCommandTagName(CommandTag commandTag)
Definition: cmdtag.c:48
SetQueryCompletion
static void SetQueryCompletion(QueryCompletion *qc, CommandTag commandTag, uint64 nprocessed)
Definition: cmdtag.h:38
CommandTag
CommandTag
Definition: cmdtag.h:23
AlterCollation
ObjectAddress AlterCollation(AlterCollationStmt *stmt)
Definition: collationcmds.c:377
DefineCollation
ObjectAddress DefineCollation(ParseState *pstate, List *names, List *parameters, bool if_not_exists)
Definition: collationcmds.c:55
CommentObject
ObjectAddress CommentObject(CommentStmt *stmt)
Definition: comment.c:40
CreateConversionCommand
ObjectAddress CreateConversionCommand(CreateConversionStmt *stmt)
Definition: conversioncmds.c:39
ExecCreateTableAs
ObjectAddress ExecCreateTableAs(ParseState *pstate, CreateTableAsStmt *stmt, ParamListInfo params, QueryEnvironment *queryEnv, QueryCompletion *qc)
Definition: createas.c:226
AlterDatabaseRefreshColl
ObjectAddress AlterDatabaseRefreshColl(AlterDatabaseRefreshCollStmt *stmt)
Definition: dbcommands.c:2375
createdb
Oid createdb(ParseState *pstate, const CreatedbStmt *stmt)
Definition: dbcommands.c:671
AlterDatabase
Oid AlterDatabase(ParseState *pstate, AlterDatabaseStmt *stmt, bool isTopLevel)
Definition: dbcommands.c:2212
DropDatabase
void DropDatabase(ParseState *pstate, DropdbStmt *stmt)
Definition: dbcommands.c:2187
AlterDatabaseSet
Oid AlterDatabaseSet(AlterDatabaseSetStmt *stmt)
Definition: dbcommands.c:2458
defGetBoolean
bool defGetBoolean(DefElem *def)
Definition: define.c:108
None_Receiver
DestReceiver * None_Receiver
Definition: dest.c:96
load_file
void load_file(const char *filename, bool restricted)
Definition: dfmgr.c:144
DiscardCommand
void DiscardCommand(DiscardStmt *stmt, bool isTopLevel)
Definition: discard.c:31
RemoveObjects
void RemoveObjects(DropStmt *stmt)
Definition: dropcmds.c:58
errdetail
int errdetail(const char *fmt,...)
Definition: elog.c:1202
errcode
int errcode(int sqlerrcode)
Definition: elog.c:858
errmsg
int errmsg(const char *fmt,...)
Definition: elog.c:1069
PG_TRY
#define PG_TRY(...)
Definition: elog.h:370
WARNING
#define WARNING
Definition: elog.h:36
PG_END_TRY
#define PG_END_TRY(...)
Definition: elog.h:395
ERROR
#define ERROR
Definition: elog.h:39
NOTICE
#define NOTICE
Definition: elog.h:35
PG_FINALLY
#define PG_FINALLY(...)
Definition: elog.h:387
ereport
#define ereport(elevel,...)
Definition: elog.h:149
EventTriggerUndoInhibitCommandCollection
void EventTriggerUndoInhibitCommandCollection(void)
Definition: event_trigger.c:1461
EventTriggerAlterTableStart
void EventTriggerAlterTableStart(Node *parsetree)
Definition: event_trigger.c:1521
EventTriggerCollectAlterDefPrivs
void EventTriggerCollectAlterDefPrivs(AlterDefaultPrivilegesStmt *stmt)
Definition: event_trigger.c:1792
EventTriggerDDLCommandStart
void EventTriggerDDLCommandStart(Node *parsetree)
Definition: event_trigger.c:640
EventTriggerInhibitCommandCollection
void EventTriggerInhibitCommandCollection(void)
Definition: event_trigger.c:1449
EventTriggerBeginCompleteQuery
bool EventTriggerBeginCompleteQuery(void)
Definition: event_trigger.c:1079
EventTriggerSupportsObjectType
bool EventTriggerSupportsObjectType(ObjectType obtype)
Definition: event_trigger.c:935
CreateEventTrigger
Oid CreateEventTrigger(CreateEventTrigStmt *stmt)
Definition: event_trigger.c:108
AlterEventTrigger
Oid AlterEventTrigger(AlterEventTrigStmt *stmt)
Definition: event_trigger.c:361
EventTriggerSQLDrop
void EventTriggerSQLDrop(Node *parsetree)
Definition: event_trigger.c:736
EventTriggerEndCompleteQuery
void EventTriggerEndCompleteQuery(void)
Definition: event_trigger.c:1123
EventTriggerAlterTableRelid
void EventTriggerAlterTableRelid(Oid objectId)
Definition: event_trigger.c:1555
EventTriggerAlterTableEnd
void EventTriggerAlterTableEnd(void)
Definition: event_trigger.c:1608
EventTriggerCollectSimpleCommand
void EventTriggerCollectSimpleCommand(ObjectAddress address, ObjectAddress secondaryObject, Node *parsetree)
Definition: event_trigger.c:1483
EventTriggerDDLCommandEnd
void EventTriggerDDLCommandEnd(Node *parsetree)
Definition: event_trigger.c:688
event_trigger.h
ExplainQuery
void ExplainQuery(ParseState *pstate, ExplainStmt *stmt, ParamListInfo params, DestReceiver *dest)
Definition: explain.c:164
ExplainResultDesc
TupleDesc ExplainResultDesc(ExplainStmt *stmt)
Definition: explain.c:337
CreateExtension
ObjectAddress CreateExtension(ParseState *pstate, CreateExtensionStmt *stmt)
Definition: extension.c:1745
ExecAlterExtensionStmt
ObjectAddress ExecAlterExtensionStmt(ParseState *pstate, AlterExtensionStmt *stmt)
Definition: extension.c:2965
ExecAlterExtensionContentsStmt
ObjectAddress ExecAlterExtensionContentsStmt(AlterExtensionContentsStmt *stmt, ObjectAddress *objAddr)
Definition: extension.c:3270
closeAllVfds
void closeAllVfds(void)
Definition: fd.c:2821
ImportForeignSchema
void ImportForeignSchema(ImportForeignSchemaStmt *stmt)
Definition: foreigncmds.c:1484
AlterForeignServer
ObjectAddress AlterForeignServer(AlterForeignServerStmt *stmt)
Definition: foreigncmds.c:974
AlterForeignDataWrapper
ObjectAddress AlterForeignDataWrapper(ParseState *pstate, AlterFdwStmt *stmt)
Definition: foreigncmds.c:674
CreateForeignServer
ObjectAddress CreateForeignServer(CreateForeignServerStmt *stmt)
Definition: foreigncmds.c:838
RemoveUserMapping
Oid RemoveUserMapping(DropUserMappingStmt *stmt)
Definition: foreigncmds.c:1324
CreateForeignDataWrapper
ObjectAddress CreateForeignDataWrapper(ParseState *pstate, CreateFdwStmt *stmt)
Definition: foreigncmds.c:558
AlterUserMapping
ObjectAddress AlterUserMapping(AlterUserMappingStmt *stmt)
Definition: foreigncmds.c:1226
CreateForeignTable
void CreateForeignTable(CreateForeignTableStmt *stmt, Oid relid)
Definition: foreigncmds.c:1404
CreateUserMapping
ObjectAddress CreateUserMapping(CreateUserMappingStmt *stmt)
Definition: foreigncmds.c:1100
ExecuteCallStmt
void ExecuteCallStmt(CallStmt *stmt, ParamListInfo params, bool atomic, DestReceiver *dest)
Definition: functioncmds.c:2176
CreateCast
ObjectAddress CreateCast(CreateCastStmt *stmt)
Definition: functioncmds.c:1522
CreateFunction
ObjectAddress CreateFunction(ParseState *pstate, CreateFunctionStmt *stmt)
Definition: functioncmds.c:1016
AlterFunction
ObjectAddress AlterFunction(ParseState *pstate, AlterFunctionStmt *stmt)
Definition: functioncmds.c:1348
CallStmtResultDesc
TupleDesc CallStmtResultDesc(CallStmt *stmt)
Definition: functioncmds.c:2353
ExecuteDoStmt
void ExecuteDoStmt(ParseState *pstate, DoStmt *stmt, bool atomic)
Definition: functioncmds.c:2054
CreateTransform
ObjectAddress CreateTransform(CreateTransformStmt *stmt)
Definition: functioncmds.c:1802
AlterSystemSetConfigFile
void AlterSystemSetConfigFile(AlterSystemStmt *altersysstmt)
Definition: guc.c:4450
GetPGVariable
void GetPGVariable(const char *name, DestReceiver *dest)
Definition: guc_funcs.c:392
GetPGVariableResultDesc
TupleDesc GetPGVariableResultDesc(const char *name)
Definition: guc_funcs.c:404
SetPGVariable
void SetPGVariable(const char *name, List *args, bool is_local)
Definition: guc_funcs.c:325
ExecSetVariableStmt
void ExecSetVariableStmt(VariableSetStmt *stmt, bool isTopLevel)
Definition: guc_funcs.c:43
htup_details.h
stmt
#define stmt
Definition: indent_codes.h:59
ps
struct parser_state ps
ExecReindex
void ExecReindex(ParseState *pstate, ReindexStmt *stmt, bool isTopLevel)
Definition: indexcmds.c:2661
DefineIndex
ObjectAddress DefineIndex(Oid relationId, IndexStmt *stmt, Oid indexRelationId, Oid parentIndexId, Oid parentConstraintId, int total_parts, bool is_alter_table, bool check_rights, bool check_not_in_use, bool skip_build, bool quiet)
Definition: indexcmds.c:527
true
return true
Definition: isn.c:126
Assert
Assert(fmt[strlen(fmt) - 1] !='\n')
list_delete_first
List * list_delete_first(List *list)
Definition: list.c:942
list_free
void list_free(List *list)
Definition: list.c:1545
list_concat
List * list_concat(List *list1, const List *list2)
Definition: list.c:560
LockTableCommand
void LockTableCommand(LockStmt *lockstmt)
Definition: lockcmds.c:43
LOCKMODE
int LOCKMODE
Definition: lockdefs.h:26
ShareUpdateExclusiveLock
#define ShareUpdateExclusiveLock
Definition: lockdefs.h:39
ShareLock
#define ShareLock
Definition: lockdefs.h:40
RowExclusiveLock
#define RowExclusiveLock
Definition: lockdefs.h:38
LCS_FORUPDATE
@ LCS_FORUPDATE
Definition: lockoptions.h:27
LCS_FORSHARE
@ LCS_FORSHARE
Definition: lockoptions.h:25
LCS_FORKEYSHARE
@ LCS_FORKEYSHARE
Definition: lockoptions.h:24
LCS_FORNOKEYUPDATE
@ LCS_FORNOKEYUPDATE
Definition: lockoptions.h:26
get_rel_relkind
char get_rel_relkind(Oid relid)
Definition: lsyscache.c:1985
ExecRefreshMatView
ObjectAddress ExecRefreshMatView(RefreshMatViewStmt *stmt, const char *queryString, ParamListInfo params, QueryCompletion *qc)
Definition: matview.c:138
B_BACKEND
@ B_BACKEND
Definition: miscadmin.h:323
InSecurityRestrictedOperation
bool InSecurityRestrictedOperation(void)
Definition: miscinit.c:658
GetUserId
Oid GetUserId(void)
Definition: miscinit.c:510
MyBackendType
BackendType MyBackendType
Definition: miscinit.c:63
RangeVarGetRelidExtended
Oid RangeVarGetRelidExtended(const RangeVar *relation, LOCKMODE lockmode, uint32 flags, RangeVarGetRelidCallback callback, void *callback_arg)
Definition: namespace.c:239
RangeVarGetRelid
#define RangeVarGetRelid(relation, lockmode, missing_ok)
Definition: namespace.h:79
generate_unaccent_rules.dest
dest
Definition: generate_unaccent_rules.py:276
IsA
#define IsA(nodeptr, _type_)
Definition: nodes.h:179
copyObject
#define copyObject(obj)
Definition: nodes.h:244
nodeTag
#define nodeTag(nodeptr)
Definition: nodes.h:133
CMD_MERGE
@ CMD_MERGE
Definition: nodes.h:280
CMD_UTILITY
@ CMD_UTILITY
Definition: nodes.h:281
CMD_INSERT
@ CMD_INSERT
Definition: nodes.h:278
CMD_DELETE
@ CMD_DELETE
Definition: nodes.h:279
CMD_UNKNOWN
@ CMD_UNKNOWN
Definition: nodes.h:275
CMD_UPDATE
@ CMD_UPDATE
Definition: nodes.h:277
CMD_SELECT
@ CMD_SELECT
Definition: nodes.h:276
CMD_NOTHING
@ CMD_NOTHING
Definition: nodes.h:283
makeNode
#define makeNode(_type_)
Definition: nodes.h:176
castNode
#define castNode(_type_, nodeptr)
Definition: nodes.h:197
InvalidObjectAddress
const ObjectAddress InvalidObjectAddress
Definition: objectaddress.c:875
DefineOpClass
ObjectAddress DefineOpClass(CreateOpClassStmt *stmt)
Definition: opclasscmds.c:333
DefineOpFamily
ObjectAddress DefineOpFamily(CreateOpFamilyStmt *stmt)
Definition: opclasscmds.c:772
AlterOpFamily
Oid AlterOpFamily(AlterOpFamilyStmt *stmt)
Definition: opclasscmds.c:817
AlterOperator
ObjectAddress AlterOperator(AlterOperatorStmt *stmt)
Definition: operatorcmds.c:411
DefineOperator
ObjectAddress DefineOperator(List *names, List *parameters)
Definition: operatorcmds.c:67
free_parsestate
void free_parsestate(ParseState *pstate)
Definition: parse_node.c:77
make_parsestate
ParseState * make_parsestate(ParseState *parentParseState)
Definition: parse_node.c:44
transformCreateStmt
List * transformCreateStmt(CreateStmt *stmt, const char *queryString)
Definition: parse_utilcmd.c:165
transformStatsStmt
CreateStatsStmt * transformStatsStmt(Oid relid, CreateStatsStmt *stmt, const char *queryString)
Definition: parse_utilcmd.c:2901
expandTableLikeClause
List * expandTableLikeClause(RangeVar *heapRel, TableLikeClause *table_like_clause)
Definition: parse_utilcmd.c:1195
transformIndexStmt
IndexStmt * transformIndexStmt(Oid relid, IndexStmt *stmt, const char *queryString)
Definition: parse_utilcmd.c:2806
parse_utilcmd.h
TRANS_STMT_ROLLBACK_TO
@ TRANS_STMT_ROLLBACK_TO
Definition: parsenodes.h:3493
TRANS_STMT_START
@ TRANS_STMT_START
Definition: parsenodes.h:3488
TRANS_STMT_SAVEPOINT
@ TRANS_STMT_SAVEPOINT
Definition: parsenodes.h:3491
TRANS_STMT_BEGIN
@ TRANS_STMT_BEGIN
Definition: parsenodes.h:3487
TRANS_STMT_ROLLBACK
@ TRANS_STMT_ROLLBACK
Definition: parsenodes.h:3490
TRANS_STMT_COMMIT_PREPARED
@ TRANS_STMT_COMMIT_PREPARED
Definition: parsenodes.h:3495
TRANS_STMT_COMMIT
@ TRANS_STMT_COMMIT
Definition: parsenodes.h:3489
TRANS_STMT_ROLLBACK_PREPARED
@ TRANS_STMT_ROLLBACK_PREPARED
Definition: parsenodes.h:3496
TRANS_STMT_PREPARE
@ TRANS_STMT_PREPARE
Definition: parsenodes.h:3494
TRANS_STMT_RELEASE
@ TRANS_STMT_RELEASE
Definition: parsenodes.h:3492
VAR_SET_DEFAULT
@ VAR_SET_DEFAULT
Definition: parsenodes.h:2434
VAR_RESET
@ VAR_RESET
Definition: parsenodes.h:2437
VAR_SET_MULTI
@ VAR_SET_MULTI
Definition: parsenodes.h:2436
VAR_SET_VALUE
@ VAR_SET_VALUE
Definition: parsenodes.h:2433
VAR_SET_CURRENT
@ VAR_SET_CURRENT
Definition: parsenodes.h:2435
VAR_RESET_ALL
@ VAR_RESET_ALL
Definition: parsenodes.h:2438
ObjectType
ObjectType
Definition: parsenodes.h:2081
OBJECT_EVENT_TRIGGER
@ OBJECT_EVENT_TRIGGER
Definition: parsenodes.h:2096
OBJECT_FDW
@ OBJECT_FDW
Definition: parsenodes.h:2098
OBJECT_TSPARSER
@ OBJECT_TSPARSER
Definition: parsenodes.h:2129
OBJECT_COLLATION
@ OBJECT_COLLATION
Definition: parsenodes.h:2089
OBJECT_ACCESS_METHOD
@ OBJECT_ACCESS_METHOD
Definition: parsenodes.h:2082
OBJECT_OPCLASS
@ OBJECT_OPCLASS
Definition: parsenodes.h:2106
OBJECT_AGGREGATE
@ OBJECT_AGGREGATE
Definition: parsenodes.h:2083
OBJECT_MATVIEW
@ OBJECT_MATVIEW
Definition: parsenodes.h:2105
OBJECT_SCHEMA
@ OBJECT_SCHEMA
Definition: parsenodes.h:2118
OBJECT_POLICY
@ OBJECT_POLICY
Definition: parsenodes.h:2110
OBJECT_OPERATOR
@ OBJECT_OPERATOR
Definition: parsenodes.h:2107
OBJECT_FOREIGN_TABLE
@ OBJECT_FOREIGN_TABLE
Definition: parsenodes.h:2100
OBJECT_TSCONFIGURATION
@ OBJECT_TSCONFIGURATION
Definition: parsenodes.h:2127
OBJECT_OPFAMILY
@ OBJECT_OPFAMILY
Definition: parsenodes.h:2108
OBJECT_DOMAIN
@ OBJECT_DOMAIN
Definition: parsenodes.h:2094
OBJECT_COLUMN
@ OBJECT_COLUMN
Definition: parsenodes.h:2088
OBJECT_TABLESPACE
@ OBJECT_TABLESPACE
Definition: parsenodes.h:2124
OBJECT_ROLE
@ OBJECT_ROLE
Definition: parsenodes.h:2115
OBJECT_ROUTINE
@ OBJECT_ROUTINE
Definition: parsenodes.h:2116
OBJECT_LARGEOBJECT
@ OBJECT_LARGEOBJECT
Definition: parsenodes.h:2104
OBJECT_PROCEDURE
@ OBJECT_PROCEDURE
Definition: parsenodes.h:2111
OBJECT_EXTENSION
@ OBJECT_EXTENSION
Definition: parsenodes.h:2097
OBJECT_INDEX
@ OBJECT_INDEX
Definition: parsenodes.h:2102
OBJECT_DATABASE
@ OBJECT_DATABASE
Definition: parsenodes.h:2091
OBJECT_SEQUENCE
@ OBJECT_SEQUENCE
Definition: parsenodes.h:2119
OBJECT_TSTEMPLATE
@ OBJECT_TSTEMPLATE
Definition: parsenodes.h:2130
OBJECT_LANGUAGE
@ OBJECT_LANGUAGE
Definition: parsenodes.h:2103
OBJECT_FOREIGN_SERVER
@ OBJECT_FOREIGN_SERVER
Definition: parsenodes.h:2099
OBJECT_TSDICTIONARY
@ OBJECT_TSDICTIONARY
Definition: parsenodes.h:2128
OBJECT_ATTRIBUTE
@ OBJECT_ATTRIBUTE
Definition: parsenodes.h:2086
OBJECT_PUBLICATION
@ OBJECT_PUBLICATION
Definition: parsenodes.h:2112
OBJECT_RULE
@ OBJECT_RULE
Definition: parsenodes.h:2117
OBJECT_CONVERSION
@ OBJECT_CONVERSION
Definition: parsenodes.h:2090
OBJECT_TABLE
@ OBJECT_TABLE
Definition: parsenodes.h:2123
OBJECT_VIEW
@ OBJECT_VIEW
Definition: parsenodes.h:2133
OBJECT_TYPE
@ OBJECT_TYPE
Definition: parsenodes.h:2131
OBJECT_FUNCTION
@ OBJECT_FUNCTION
Definition: parsenodes.h:2101
OBJECT_TABCONSTRAINT
@ OBJECT_TABCONSTRAINT
Definition: parsenodes.h:2122
OBJECT_DOMCONSTRAINT
@ OBJECT_DOMCONSTRAINT
Definition: parsenodes.h:2095
OBJECT_SUBSCRIPTION
@ OBJECT_SUBSCRIPTION
Definition: parsenodes.h:2120
OBJECT_STATISTIC_EXT
@ OBJECT_STATISTIC_EXT
Definition: parsenodes.h:2121
OBJECT_CAST
@ OBJECT_CAST
Definition: parsenodes.h:2087
OBJECT_TRIGGER
@ OBJECT_TRIGGER
Definition: parsenodes.h:2126
OBJECT_TRANSFORM
@ OBJECT_TRANSFORM
Definition: parsenodes.h:2125
AT_DetachPartition
@ AT_DetachPartition
Definition: parsenodes.h:2234
DISCARD_ALL
@ DISCARD_ALL
Definition: parsenodes.h:3754
DISCARD_PLANS
@ DISCARD_PLANS
Definition: parsenodes.h:3755
DISCARD_SEQUENCES
@ DISCARD_SEQUENCES
Definition: parsenodes.h:3756
DISCARD_TEMP
@ DISCARD_TEMP
Definition: parsenodes.h:3757
pg_authid.h
find_all_inheritors
List * find_all_inheritors(Oid parentrelId, LOCKMODE lockmode, List **numparents)
Definition: pg_inherits.c:256
pg_inherits.h
lfirst
#define lfirst(lc)
Definition: pg_list.h:172
list_length
static int list_length(const List *l)
Definition: pg_list.h:152
NIL
#define NIL
Definition: pg_list.h:68
list_make1
#define list_make1(x1)
Definition: pg_list.h:212
linitial
#define linitial(l)
Definition: pg_list.h:178
lfirst_oid
#define lfirst_oid(lc)
Definition: pg_list.h:174
CreatePolicy
ObjectAddress CreatePolicy(CreatePolicyStmt *stmt)
Definition: policy.c:572
AlterPolicy
ObjectAddress AlterPolicy(AlterPolicyStmt *stmt)
Definition: policy.c:771
PortalIsValid
#define PortalIsValid(p)
Definition: portal.h:212
PerformCursorOpen
void PerformCursorOpen(ParseState *pstate, DeclareCursorStmt *cstmt, ParamListInfo params, bool isTopLevel)
Definition: portalcmds.c:43
PerformPortalClose
void PerformPortalClose(const char *name)
Definition: portalcmds.c:214
PerformPortalFetch
void PerformPortalFetch(FetchStmt *stmt, DestReceiver *dest, QueryCompletion *qc)
Definition: portalcmds.c:167
GetPortalByName
Portal GetPortalByName(const char *name)
Definition: portalmem.c:131
check_stack_depth
void check_stack_depth(void)
Definition: postgres.c:3461
Datum
uintptr_t Datum
Definition: postgres.h:64
InvalidOid
#define InvalidOid
Definition: postgres_ext.h:36
Oid
unsigned int Oid
Definition: postgres_ext.h:31
CreateProceduralLanguage
ObjectAddress CreateProceduralLanguage(CreatePLangStmt *stmt)
Definition: proclang.c:39
CreatePublication
ObjectAddress CreatePublication(ParseState *pstate, CreatePublicationStmt *stmt)
Definition: publicationcmds.c:735
AlterPublication
void AlterPublication(ParseState *pstate, AlterPublicationStmt *stmt)
Definition: publicationcmds.c:1378
analyze
static long analyze(struct nfa *nfa)
Definition: regc_nfa.c:3044
transformRelOptions
Datum transformRelOptions(Datum oldOptions, List *defList, const char *namspace, char *validnsps[], bool acceptOidsOff, bool isReset)
Definition: reloptions.c:1158
heap_reloptions
bytea * heap_reloptions(char relkind, Datum reloptions, bool validate)
Definition: reloptions.c:2020
HEAP_RELOPT_NAMESPACES
#define HEAP_RELOPT_NAMESPACES
Definition: reloptions.h:61
DefineRule
ObjectAddress DefineRule(RuleStmt *stmt, const char *queryString)
Definition: rewriteDefine.c:197
CreateSchemaCommand
Oid CreateSchemaCommand(CreateSchemaStmt *stmt, const char *queryString, int stmt_location, int stmt_len)
Definition: schemacmds.c:51
ExecSecLabelStmt
ObjectAddress ExecSecLabelStmt(SecLabelStmt *stmt)
Definition: seclabel.c:115
DefineSequence
ObjectAddress DefineSequence(ParseState *pstate, CreateSeqStmt *seq)
Definition: sequence.c:120
AlterSequence
ObjectAddress AlterSequence(ParseState *pstate, AlterSeqStmt *stmt)
Definition: sequence.c:450
AlterStatistics
ObjectAddress AlterStatistics(AlterStatsStmt *stmt)
Definition: statscmds.c:602
CreateStatistics
ObjectAddress CreateStatistics(CreateStatsStmt *stmt)
Definition: statscmds.c:65
AlterTableCmd::subtype
AlterTableType subtype
Definition: parsenodes.h:2252
AlterTableStmt::relation
RangeVar * relation
Definition: parsenodes.h:2166
AlterTableUtilityContext::params
ParamListInfo params
Definition: utility.h:35
AlterTableUtilityContext::queryEnv
QueryEnvironment * queryEnv
Definition: utility.h:36
AlterTableUtilityContext::pstmt
PlannedStmt * pstmt
Definition: utility.h:32
AlterTableUtilityContext::queryString
const char * queryString
Definition: utility.h:33
CachedPlanSource::resultDesc
TupleDesc resultDesc
Definition: plancache.h:108
CreateStmt::options
List * options
Definition: parsenodes.h:2483
CreateStmt::relation
RangeVar * relation
Definition: parsenodes.h:2475
DefElem::defname
char * defname
Definition: parsenodes.h:810
DefElem::arg
Node * arg
Definition: parsenodes.h:811
List
Definition: pg_list.h:54
Node
Definition: nodes.h:129
ParseState::p_queryEnv
QueryEnvironment * p_queryEnv
Definition: parse_node.h:219
ParseState::p_sourcetext
const char * p_sourcetext
Definition: parse_node.h:192
PlannedStmt::hasModifyingCTE
bool hasModifyingCTE
Definition: plannodes.h:59
PlannedStmt::canSetTag
bool canSetTag
Definition: plannodes.h:61
PlannedStmt::rowMarks
List * rowMarks
Definition: plannodes.h:91
PlannedStmt::stmt_location
int stmt_location
Definition: plannodes.h:102
PlannedStmt::stmt_len
int stmt_len
Definition: plannodes.h:103
PlannedStmt::commandType
CmdType commandType
Definition: plannodes.h:53
PlannedStmt::utilityStmt
Node * utilityStmt
Definition: plannodes.h:99
PortalData::tupDesc
TupleDesc tupDesc
Definition: portal.h:160
PreparedStatement::plansource
CachedPlanSource * plansource
Definition: prepare.h:31
QueryCompletion::commandTag
CommandTag commandTag
Definition: cmdtag.h:32
Query::returningList
List * returningList
Definition: parsenodes.h:196
Query::commandType
CmdType commandType
Definition: parsenodes.h:128
Query::utilityStmt
Node * utilityStmt
Definition: parsenodes.h:143
RangeVar::relname
char * relname
Definition: primnodes.h:74
_DestReceiver
Definition: dest.h:115
DropSubscription
void DropSubscription(DropSubscriptionStmt *stmt, bool isTopLevel)
Definition: subscriptioncmds.c:1448
CreateSubscription
ObjectAddress CreateSubscription(ParseState *pstate, CreateSubscriptionStmt *stmt, bool isTopLevel)
Definition: subscriptioncmds.c:554
AlterSubscription
ObjectAddress AlterSubscription(ParseState *pstate, AlterSubscriptionStmt *stmt, bool isTopLevel)
Definition: subscriptioncmds.c:1055
superuser
bool superuser(void)
Definition: superuser.c:46
AlterTable
void AlterTable(AlterTableStmt *stmt, LOCKMODE lockmode, AlterTableUtilityContext *context)
Definition: tablecmds.c:4167
RemoveRelations
void RemoveRelations(DropStmt *drop)
Definition: tablecmds.c:1343
AlterTableGetLockLevel
LOCKMODE AlterTableGetLockLevel(List *cmds)
Definition: tablecmds.c:4241
ExecuteTruncate
void ExecuteTruncate(TruncateStmt *stmt)
Definition: tablecmds.c:1666
AlterTableLookupRelation
Oid AlterTableLookupRelation(AlterTableStmt *stmt, LOCKMODE lockmode)
Definition: tablecmds.c:4108
DefineRelation
ObjectAddress DefineRelation(CreateStmt *stmt, char relkind, Oid ownerId, ObjectAddress *typaddress, const char *queryString)
Definition: tablecmds.c:662
AlterTableMoveAll
Oid AlterTableMoveAll(AlterTableMoveAllStmt *stmt)
Definition: tablecmds.c:14602
RangeVarCallbackOwnsRelation
void RangeVarCallbackOwnsRelation(const RangeVar *relation, Oid relId, Oid oldRelId, void *arg)
Definition: tablecmds.c:17053
LogStmtLevel
LogStmtLevel
Definition: tcopprot.h:37
LOGSTMT_MOD
@ LOGSTMT_MOD
Definition: tcopprot.h:40
LOGSTMT_DDL
@ LOGSTMT_DDL
Definition: tcopprot.h:39
LOGSTMT_ALL
@ LOGSTMT_ALL
Definition: tcopprot.h:41
NewRelationCreateToastTable
void NewRelationCreateToastTable(Oid relOid, Datum reloptions)
Definition: toasting.c:73
AfterTriggerSetState
void AfterTriggerSetState(ConstraintsSetStmt *stmt)
Definition: trigger.c:5621
CreateTrigger
ObjectAddress CreateTrigger(CreateTrigStmt *stmt, const char *queryString, Oid relOid, Oid refRelOid, Oid constraintOid, Oid indexOid, Oid funcoid, Oid parentTriggerOid, Node *whenClause, bool isInternal, bool in_partition)
Definition: trigger.c:165
AlterTSConfiguration
ObjectAddress AlterTSConfiguration(AlterTSConfigurationStmt *stmt)
Definition: tsearchcmds.c:1150
DefineTSTemplate
ObjectAddress DefineTSTemplate(List *names, List *parameters)
Definition: tsearchcmds.c:684
DefineTSDictionary
ObjectAddress DefineTSDictionary(List *names, List *parameters)
Definition: tsearchcmds.c:391
DefineTSConfiguration
ObjectAddress DefineTSConfiguration(List *names, List *parameters, ObjectAddress *copied)
Definition: tsearchcmds.c:893
AlterTSDictionary
ObjectAddress AlterTSDictionary(AlterTSDictionaryStmt *stmt)
Definition: tsearchcmds.c:487
DefineTSParser
ObjectAddress DefineTSParser(List *names, List *parameters)
Definition: tsearchcmds.c:178
CreateTupleDescCopy
TupleDesc CreateTupleDescCopy(TupleDesc tupdesc)
Definition: tupdesc.c:111
FinishPreparedTransaction
void FinishPreparedTransaction(const char *gid, bool isCommit)
Definition: twophase.c:1480
AlterDomainNotNull
ObjectAddress AlterDomainNotNull(List *names, bool notNull)
Definition: typecmds.c:2695
DefineDomain
ObjectAddress DefineDomain(CreateDomainStmt *stmt)
Definition: typecmds.c:693
DefineType
ObjectAddress DefineType(ParseState *pstate, List *names, List *parameters)
Definition: typecmds.c:148
DefineEnum
ObjectAddress DefineEnum(CreateEnumStmt *stmt)
Definition: typecmds.c:1137
AlterDomainDropConstraint
ObjectAddress AlterDomainDropConstraint(List *names, const char *constrName, DropBehavior behavior, bool missing_ok)
Definition: typecmds.c:2815
AlterEnum
ObjectAddress AlterEnum(AlterEnumStmt *stmt)
Definition: typecmds.c:1261
AlterDomainAddConstraint
ObjectAddress AlterDomainAddConstraint(List *names, Node *newConstraint, ObjectAddress *constrAddr)
Definition: typecmds.c:2914
AlterDomainValidateConstraint
ObjectAddress AlterDomainValidateConstraint(List *names, const char *constrName)
Definition: typecmds.c:3030
AlterDomainDefault
ObjectAddress AlterDomainDefault(List *names, Node *defaultRaw)
Definition: typecmds.c:2566
DefineCompositeType
ObjectAddress DefineCompositeType(RangeVar *typevar, List *coldeflist)
Definition: typecmds.c:2508
AlterType
ObjectAddress AlterType(AlterTypeStmt *stmt)
Definition: typecmds.c:4089
DefineRange
ObjectAddress DefineRange(ParseState *pstate, CreateRangeStmt *stmt)
Definition: typecmds.c:1336
ReassignOwnedObjects
void ReassignOwnedObjects(ReassignOwnedStmt *stmt)
Definition: user.c:1618
AlterRole
Oid AlterRole(ParseState *pstate, AlterRoleStmt *stmt)
Definition: user.c:620
AlterRoleSet
Oid AlterRoleSet(AlterRoleSetStmt *stmt)
Definition: user.c:1001
DropRole
void DropRole(DropRoleStmt *stmt)
Definition: user.c:1091
CreateRole
Oid CreateRole(ParseState *pstate, CreateRoleStmt *stmt)
Definition: user.c:133
GrantRole
void GrantRole(ParseState *pstate, GrantRoleStmt *stmt)
Definition: user.c:1487
DropOwnedObjects
void DropOwnedObjects(DropOwnedStmt *stmt)
Definition: user.c:1590
ClassifyUtilityCommandAsReadOnly
static int ClassifyUtilityCommandAsReadOnly(Node *parsetree)
Definition: utility.c:135
standard_ProcessUtility
void standard_ProcessUtility(PlannedStmt *pstmt, const char *queryString, bool readOnlyTree, ProcessUtilityContext context, ParamListInfo params, QueryEnvironment *queryEnv, DestReceiver *dest, QueryCompletion *qc)
Definition: utility.c:547
PreventCommandIfReadOnly
void PreventCommandIfReadOnly(const char *cmdname)
Definition: utility.c:411
ProcessUtility
void ProcessUtility(PlannedStmt *pstmt, const char *queryString, bool readOnlyTree, ProcessUtilityContext context, ParamListInfo params, QueryEnvironment *queryEnv, DestReceiver *dest, QueryCompletion *qc)
Definition: utility.c:506
PreventCommandIfParallelMode
void PreventCommandIfParallelMode(const char *cmdname)
Definition: utility.c:429
UtilityReturnsTuples
bool UtilityReturnsTuples(Node *parsetree)
Definition: utility.c:2028
ExecDropStmt
static void ExecDropStmt(DropStmt *stmt, bool isTopLevel)
Definition: utility.c:1995
CommandIsReadOnly
bool CommandIsReadOnly(PlannedStmt *pstmt)
Definition: utility.c:101
CheckRestrictedOperation
static void CheckRestrictedOperation(const char *cmdname)
Definition: utility.c:466
CreateCommandTag
CommandTag CreateCommandTag(Node *parsetree)
Definition: utility.c:2363
AlterObjectTypeCommandTag
static CommandTag AlterObjectTypeCommandTag(ObjectType objtype)
Definition: utility.c:2217
ProcessUtilityForAlterTable
void ProcessUtilityForAlterTable(Node *stmt, AlterTableUtilityContext *context)
Definition: utility.c:1959
UtilityContainsQuery
Query * UtilityContainsQuery(Node *parsetree)
Definition: utility.c:2180
ProcessUtility_hook
ProcessUtility_hook_type ProcessUtility_hook
Definition: utility.c:77
PreventCommandDuringRecovery
void PreventCommandDuringRecovery(const char *cmdname)
Definition: utility.c:448
UtilityTupleDescriptor
TupleDesc UtilityTupleDescriptor(Node *parsetree)
Definition: utility.c:2084
GetCommandLogLevel
LogStmtLevel GetCommandLogLevel(Node *parsetree)
Definition: utility.c:3250
ProcessUtilitySlow
static void ProcessUtilitySlow(ParseState *pstate, PlannedStmt *pstmt, const char *queryString, ProcessUtilityContext context, ParamListInfo params, QueryEnvironment *queryEnv, DestReceiver *dest, QueryCompletion *qc)
Definition: utility.c:1099
COMMAND_OK_IN_PARALLEL_MODE
#define COMMAND_OK_IN_PARALLEL_MODE
Definition: utility.h:57
COMMAND_OK_IN_RECOVERY
#define COMMAND_OK_IN_RECOVERY
Definition: utility.h:58
COMMAND_IS_STRICTLY_READ_ONLY
#define COMMAND_IS_STRICTLY_READ_ONLY
Definition: utility.h:65
ProcessUtility_hook_type
void(* ProcessUtility_hook_type)(PlannedStmt *pstmt, const char *queryString, bool readOnlyTree, ProcessUtilityContext context, ParamListInfo params, QueryEnvironment *queryEnv, DestReceiver *dest, QueryCompletion *qc)
Definition: utility.h:71
COMMAND_IS_NOT_READ_ONLY
#define COMMAND_IS_NOT_READ_ONLY
Definition: utility.h:68
ProcessUtilityContext
ProcessUtilityContext
Definition: utility.h:21
PROCESS_UTILITY_SUBCOMMAND
@ PROCESS_UTILITY_SUBCOMMAND
Definition: utility.h:26
PROCESS_UTILITY_TOPLEVEL
@ PROCESS_UTILITY_TOPLEVEL
Definition: utility.h:22
PROCESS_UTILITY_QUERY_NONATOMIC
@ PROCESS_UTILITY_QUERY_NONATOMIC
Definition: utility.h:24
COMMAND_OK_IN_READ_ONLY_TXN
#define COMMAND_OK_IN_READ_ONLY_TXN
Definition: utility.h:56
ExecVacuum
void ExecVacuum(ParseState *pstate, VacuumStmt *vacstmt, bool isTopLevel)
Definition: vacuum.c:110
DefineView
ObjectAddress DefineView(ViewStmt *stmt, const char *queryString, int stmt_location, int stmt_len)
Definition: view.c:361
WarnNoTransactionBlock
void WarnNoTransactionBlock(bool isTopLevel, const char *stmtType)
Definition: xact.c:3554
UserAbortTransactionBlock
void UserAbortTransactionBlock(bool chain)
Definition: xact.c:4051
PrepareTransactionBlock
bool PrepareTransactionBlock(const char *gid)
Definition: xact.c:3839
RequireTransactionBlock
void RequireTransactionBlock(bool isTopLevel, const char *stmtType)
Definition: xact.c:3560
DefineSavepoint
void DefineSavepoint(const char *name)
Definition: xact.c:4220
XactReadOnly
bool XactReadOnly
Definition: xact.c:82
CommandCounterIncrement
void CommandCounterIncrement(void)
Definition: xact.c:1078
PreventInTransactionBlock
void PreventInTransactionBlock(bool isTopLevel, const char *stmtType)
Definition: xact.c:3482
ReleaseSavepoint
void ReleaseSavepoint(const char *name)
Definition: xact.c:4305
IsTransactionBlock
bool IsTransactionBlock(void)
Definition: xact.c:4817
IsInParallelMode
bool IsInParallelMode(void)
Definition: xact.c:1069
BeginTransactionBlock
void BeginTransactionBlock(void)
Definition: xact.c:3771
RollbackToSavepoint
void RollbackToSavepoint(const char *name)
Definition: xact.c:4414
EndTransactionBlock
bool EndTransactionBlock(bool chain)
Definition: xact.c:3891
RecoveryInProgress
bool RecoveryInProgress(void)
Definition: xlog.c:5907
CHECKPOINT_FORCE
#define CHECKPOINT_FORCE
Definition: xlog.h:137
CHECKPOINT_WAIT
#define CHECKPOINT_WAIT
Definition: xlog.h:140
CHECKPOINT_IMMEDIATE
#define CHECKPOINT_IMMEDIATE
Definition: xlog.h:136