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