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