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