#include "postgres.h"#include "access/reloptions.h"#include "access/twophase.h"#include "access/xact.h"#include "access/xlog.h"#include "catalog/namespace.h"#include "catalog/pg_authid.h"#include "catalog/pg_inherits.h"#include "catalog/toasting.h"#include "commands/alter.h"#include "commands/async.h"#include "commands/cluster.h"#include "commands/collationcmds.h"#include "commands/comment.h"#include "commands/conversioncmds.h"#include "commands/copy.h"#include "commands/createas.h"#include "commands/dbcommands.h"#include "commands/defrem.h"#include "commands/discard.h"#include "commands/event_trigger.h"#include "commands/explain.h"#include "commands/extension.h"#include "commands/lockcmds.h"#include "commands/matview.h"#include "commands/policy.h"#include "commands/portalcmds.h"#include "commands/prepare.h"#include "commands/proclang.h"#include "commands/publicationcmds.h"#include "commands/schemacmds.h"#include "commands/seclabel.h"#include "commands/sequence.h"#include "commands/subscriptioncmds.h"#include "commands/tablecmds.h"#include "commands/tablespace.h"#include "commands/trigger.h"#include "commands/typecmds.h"#include "commands/user.h"#include "commands/vacuum.h"#include "commands/view.h"#include "commands/wait.h"#include "miscadmin.h"#include "parser/parse_utilcmd.h"#include "postmaster/bgwriter.h"#include "rewrite/rewriteDefine.h"#include "storage/fd.h"#include "tcop/utility.h"#include "utils/acl.h"#include "utils/guc.h"#include "utils/lsyscache.h"
Include dependency graph for utility.c:
Go to the source code of this file.
Variables | |
| ProcessUtility_hook_type | ProcessUtility_hook = NULL |
Function Documentation
◆ AlterObjectTypeCommandTag()
|
static |
Definition at line 2223 of file utility.c.
2224{
2225 CommandTag tag;
2226
2227 switch (objtype)
2228 {
2230 tag = CMDTAG_ALTER_AGGREGATE;
2231 break;
2233 tag = CMDTAG_ALTER_TYPE;
2234 break;
2236 tag = CMDTAG_ALTER_CAST;
2237 break;
2239 tag = CMDTAG_ALTER_COLLATION;
2240 break;
2242 tag = CMDTAG_ALTER_TABLE;
2243 break;
2245 tag = CMDTAG_ALTER_CONVERSION;
2246 break;
2248 tag = CMDTAG_ALTER_DATABASE;
2249 break;
2252 tag = CMDTAG_ALTER_DOMAIN;
2253 break;
2255 tag = CMDTAG_ALTER_EXTENSION;
2256 break;
2258 tag = CMDTAG_ALTER_FOREIGN_DATA_WRAPPER;
2259 break;
2261 tag = CMDTAG_ALTER_SERVER;
2262 break;
2264 tag = CMDTAG_ALTER_FOREIGN_TABLE;
2265 break;
2267 tag = CMDTAG_ALTER_FUNCTION;
2268 break;
2270 tag = CMDTAG_ALTER_INDEX;
2271 break;
2273 tag = CMDTAG_ALTER_LANGUAGE;
2274 break;
2276 tag = CMDTAG_ALTER_LARGE_OBJECT;
2277 break;
2279 tag = CMDTAG_ALTER_OPERATOR_CLASS;
2280 break;
2282 tag = CMDTAG_ALTER_OPERATOR;
2283 break;
2285 tag = CMDTAG_ALTER_OPERATOR_FAMILY;
2286 break;
2288 tag = CMDTAG_ALTER_POLICY;
2289 break;
2291 tag = CMDTAG_ALTER_PROCEDURE;
2292 break;
2294 tag = CMDTAG_ALTER_ROLE;
2295 break;
2297 tag = CMDTAG_ALTER_ROUTINE;
2298 break;
2300 tag = CMDTAG_ALTER_RULE;
2301 break;
2303 tag = CMDTAG_ALTER_SCHEMA;
2304 break;
2306 tag = CMDTAG_ALTER_SEQUENCE;
2307 break;
2310 tag = CMDTAG_ALTER_TABLE;
2311 break;
2313 tag = CMDTAG_ALTER_TABLESPACE;
2314 break;
2316 tag = CMDTAG_ALTER_TRIGGER;
2317 break;
2319 tag = CMDTAG_ALTER_EVENT_TRIGGER;
2320 break;
2322 tag = CMDTAG_ALTER_TEXT_SEARCH_CONFIGURATION;
2323 break;
2325 tag = CMDTAG_ALTER_TEXT_SEARCH_DICTIONARY;
2326 break;
2328 tag = CMDTAG_ALTER_TEXT_SEARCH_PARSER;
2329 break;
2331 tag = CMDTAG_ALTER_TEXT_SEARCH_TEMPLATE;
2332 break;
2334 tag = CMDTAG_ALTER_TYPE;
2335 break;
2337 tag = CMDTAG_ALTER_VIEW;
2338 break;
2340 tag = CMDTAG_ALTER_MATERIALIZED_VIEW;
2341 break;
2343 tag = CMDTAG_ALTER_PUBLICATION;
2344 break;
2346 tag = CMDTAG_ALTER_SUBSCRIPTION;
2347 break;
2349 tag = CMDTAG_ALTER_STATISTICS;
2350 break;
2351 default:
2352 tag = CMDTAG_UNKNOWN;
2353 break;
2354 }
2355
2356 return tag;
2357}
References OBJECT_AGGREGATE, OBJECT_ATTRIBUTE, OBJECT_CAST, OBJECT_COLLATION, OBJECT_COLUMN, OBJECT_CONVERSION, OBJECT_DATABASE, OBJECT_DOMAIN, OBJECT_DOMCONSTRAINT, OBJECT_EVENT_TRIGGER, OBJECT_EXTENSION, OBJECT_FDW, OBJECT_FOREIGN_SERVER, OBJECT_FOREIGN_TABLE, OBJECT_FUNCTION, OBJECT_INDEX, OBJECT_LANGUAGE, OBJECT_LARGEOBJECT, OBJECT_MATVIEW, OBJECT_OPCLASS, OBJECT_OPERATOR, OBJECT_OPFAMILY, OBJECT_POLICY, OBJECT_PROCEDURE, OBJECT_PUBLICATION, OBJECT_ROLE, OBJECT_ROUTINE, OBJECT_RULE, OBJECT_SCHEMA, OBJECT_SEQUENCE, OBJECT_STATISTIC_EXT, OBJECT_SUBSCRIPTION, OBJECT_TABCONSTRAINT, OBJECT_TABLE, OBJECT_TABLESPACE, OBJECT_TRIGGER, OBJECT_TSCONFIGURATION, OBJECT_TSDICTIONARY, OBJECT_TSPARSER, OBJECT_TSTEMPLATE, OBJECT_TYPE, and OBJECT_VIEW.
Referenced by CreateCommandTag().
◆ CheckRestrictedOperation()
|
static |
Definition at line 461 of file utility.c.
462{
465 (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
466 /* translator: %s is name of a SQL command, eg PREPARE */
468 cmdname)));
469}
References ereport, errcode(), errmsg(), ERROR, and InSecurityRestrictedOperation().
Referenced by standard_ProcessUtility().
◆ ClassifyUtilityCommandAsReadOnly()
|
static |
Definition at line 129 of file utility.c.
130{
132 {
133 case T_AlterCollationStmt:
134 case T_AlterDatabaseRefreshCollStmt:
135 case T_AlterDatabaseSetStmt:
136 case T_AlterDatabaseStmt:
137 case T_AlterDefaultPrivilegesStmt:
138 case T_AlterDomainStmt:
139 case T_AlterEnumStmt:
140 case T_AlterEventTrigStmt:
141 case T_AlterExtensionContentsStmt:
142 case T_AlterExtensionStmt:
143 case T_AlterFdwStmt:
144 case T_AlterForeignServerStmt:
145 case T_AlterFunctionStmt:
146 case T_AlterObjectDependsStmt:
147 case T_AlterObjectSchemaStmt:
148 case T_AlterOpFamilyStmt:
149 case T_AlterOperatorStmt:
150 case T_AlterOwnerStmt:
151 case T_AlterPolicyStmt:
152 case T_AlterPublicationStmt:
153 case T_AlterRoleSetStmt:
154 case T_AlterRoleStmt:
155 case T_AlterSeqStmt:
156 case T_AlterStatsStmt:
157 case T_AlterSubscriptionStmt:
158 case T_AlterTSConfigurationStmt:
159 case T_AlterTSDictionaryStmt:
160 case T_AlterTableMoveAllStmt:
161 case T_AlterTableSpaceOptionsStmt:
162 case T_AlterTableStmt:
163 case T_AlterTypeStmt:
164 case T_AlterUserMappingStmt:
165 case T_CommentStmt:
166 case T_CompositeTypeStmt:
167 case T_CreateAmStmt:
168 case T_CreateCastStmt:
169 case T_CreateConversionStmt:
170 case T_CreateDomainStmt:
171 case T_CreateEnumStmt:
172 case T_CreateEventTrigStmt:
173 case T_CreateExtensionStmt:
174 case T_CreateFdwStmt:
175 case T_CreateForeignServerStmt:
176 case T_CreateForeignTableStmt:
177 case T_CreateFunctionStmt:
178 case T_CreateOpClassStmt:
179 case T_CreateOpFamilyStmt:
180 case T_CreatePLangStmt:
181 case T_CreatePolicyStmt:
182 case T_CreatePublicationStmt:
183 case T_CreateRangeStmt:
184 case T_CreateRoleStmt:
185 case T_CreateSchemaStmt:
186 case T_CreateSeqStmt:
187 case T_CreateStatsStmt:
188 case T_CreateStmt:
189 case T_CreateSubscriptionStmt:
190 case T_CreateTableAsStmt:
191 case T_CreateTableSpaceStmt:
192 case T_CreateTransformStmt:
193 case T_CreateTrigStmt:
194 case T_CreateUserMappingStmt:
195 case T_CreatedbStmt:
196 case T_DefineStmt:
197 case T_DropOwnedStmt:
198 case T_DropRoleStmt:
199 case T_DropStmt:
200 case T_DropSubscriptionStmt:
201 case T_DropTableSpaceStmt:
202 case T_DropUserMappingStmt:
203 case T_DropdbStmt:
204 case T_GrantRoleStmt:
205 case T_GrantStmt:
206 case T_ImportForeignSchemaStmt:
207 case T_IndexStmt:
208 case T_ReassignOwnedStmt:
209 case T_RefreshMatViewStmt:
210 case T_RenameStmt:
211 case T_RuleStmt:
212 case T_SecLabelStmt:
213 case T_TruncateStmt:
214 case T_ViewStmt:
215 {
216 /* DDL is not read-only, and neither is TRUNCATE. */
218 }
219
220 case T_AlterSystemStmt:
221 {
222 /*
223 * Surprisingly, ALTER SYSTEM meets all our definitions of
224 * read-only: it changes nothing that affects the output of
225 * pg_dump, it doesn't write WAL or imperil the application of
226 * future WAL, and it doesn't depend on any state that needs
227 * to be synchronized with parallel workers.
228 *
229 * So, despite the fact that it writes to a file, it's read
230 * only!
231 */
233 }
234
235 case T_CallStmt:
236 case T_DoStmt:
237 {
238 /*
239 * Commands inside the DO block or the called procedure might
240 * not be read only, but they'll be checked separately when we
241 * try to execute them. Here we only need to worry about the
242 * DO or CALL command itself.
243 */
245 }
246
247 case T_CheckPointStmt:
248 {
249 /*
250 * You might think that this should not be permitted in
251 * recovery, but we interpret a CHECKPOINT command during
252 * recovery as a request for a restartpoint instead. We allow
253 * this since it can be a useful way of reducing switchover
254 * time when using various forms of replication.
255 */
257 }
258
259 case T_ClosePortalStmt:
260 case T_ConstraintsSetStmt:
261 case T_DeallocateStmt:
262 case T_DeclareCursorStmt:
263 case T_DiscardStmt:
264 case T_ExecuteStmt:
265 case T_FetchStmt:
266 case T_LoadStmt:
267 case T_PrepareStmt:
268 case T_UnlistenStmt:
269 case T_VariableSetStmt:
270 case T_WaitStmt:
271 {
272 /*
273 * These modify only backend-local state, so they're OK to run
274 * in a read-only transaction or on a standby. However, they
275 * are disallowed in parallel mode, because they either rely
276 * upon or modify backend-local state that might not be
277 * synchronized among cooperating backends.
278 */
280 }
281
282 case T_ClusterStmt:
283 case T_ReindexStmt:
284 case T_VacuumStmt:
285 {
286 /*
287 * These commands write WAL, so they're not strictly
288 * read-only, and running them in parallel workers isn't
289 * supported.
290 *
291 * However, they don't change the database state in a way that
292 * would affect pg_dump output, so it's fine to run them in a
293 * read-only transaction. (CLUSTER might change the order of
294 * rows on disk, which could affect the ordering of pg_dump
295 * output, but that's not semantically significant.)
296 */
298 }
299
300 case T_CopyStmt:
301 {
303
304 /*
305 * You might think that COPY FROM is not at all read only, but
306 * it's OK to copy into a temporary table, because that
307 * wouldn't change the output of pg_dump. If the target table
308 * turns out to be non-temporary, DoCopy itself will call
309 * PreventCommandIfReadOnly.
310 */
313 else
315 }
316
317 case T_ExplainStmt:
318 case T_VariableShowStmt:
319 {
320 /*
321 * These commands don't modify any data and are safe to run in
322 * a parallel worker.
323 */
325 }
326
327 case T_ListenStmt:
328 case T_NotifyStmt:
329 {
330 /*
331 * NOTIFY requires an XID assignment, so it can't be permitted
332 * on a standby. Perhaps LISTEN could, since without NOTIFY it
333 * would be OK to just do nothing, at least until promotion,
334 * but we currently prohibit it lest the user get the wrong
335 * idea.
336 *
337 * (We do allow T_UnlistenStmt on a standby, though, because
338 * it's a no-op.)
339 */
341 }
342
343 case T_LockStmt:
344 {
346
347 /*
348 * Only weaker locker modes are allowed during recovery. The
349 * restrictions here must match those in
350 * LockAcquireExtended().
351 */
354 else
356 }
357
358 case T_TransactionStmt:
359 {
361
362 /*
363 * PREPARE, COMMIT PREPARED, and ROLLBACK PREPARED all write
364 * WAL, so they're not read-only in the strict sense; but the
365 * first and third do not change pg_dump output, so they're OK
366 * in a read-only transactions.
367 *
368 * We also consider COMMIT PREPARED to be OK in a read-only
369 * transaction environment, by way of exception.
370 */
372 {
381
386 }
389 return 0; /* silence stupider compilers */
390 }
391
392 default:
395 return 0; /* silence stupider compilers */
396 }
397}
Definition: parsenodes.h:2700
Definition: parsenodes.h:4109
Definition: parsenodes.h:3833
References COMMAND_IS_NOT_READ_ONLY, COMMAND_IS_STRICTLY_READ_ONLY, COMMAND_OK_IN_READ_ONLY_TXN, COMMAND_OK_IN_RECOVERY, elog, ERROR, nodeTag, RowExclusiveLock, stmt, TRANS_STMT_BEGIN, TRANS_STMT_COMMIT, TRANS_STMT_COMMIT_PREPARED, TRANS_STMT_PREPARE, TRANS_STMT_RELEASE, TRANS_STMT_ROLLBACK, TRANS_STMT_ROLLBACK_PREPARED, TRANS_STMT_ROLLBACK_TO, TRANS_STMT_SAVEPOINT, and TRANS_STMT_START.
Referenced by standard_ProcessUtility().
◆ CommandIsReadOnly()
| bool CommandIsReadOnly | ( | PlannedStmt * | pstmt | ) |
Definition at line 95 of file utility.c.
96{
99 {
102 return false; /* SELECT FOR [KEY] UPDATE/SHARE */
104 return false; /* data-modifying CTE */
105 else
106 return true;
111 return false;
113 /* For now, treat all utility commands as read/write */
114 return false;
115 default:
118 break;
119 }
120 return false;
121}
Assert(PointerIsAligned(start, uint64))
Definition: plannodes.h:62
References Assert(), CMD_DELETE, CMD_INSERT, CMD_MERGE, CMD_SELECT, CMD_UPDATE, CMD_UTILITY, PlannedStmt::commandType, elog, PlannedStmt::hasModifyingCTE, IsA, NIL, PlannedStmt::rowMarks, and WARNING.
Referenced by _SPI_execute_plan(), init_execution_state(), and SPI_cursor_open_internal().
◆ CreateCommandTag()
| CommandTag CreateCommandTag | ( | Node * | parsetree | ) |
Definition at line 2369 of file utility.c.
2370{
2371 CommandTag tag;
2372
2374 {
2375 /* recurse if we're given a RawStmt */
2376 case T_RawStmt:
2378 break;
2379
2380 /* raw plannable queries */
2381 case T_InsertStmt:
2382 tag = CMDTAG_INSERT;
2383 break;
2384
2385 case T_DeleteStmt:
2386 tag = CMDTAG_DELETE;
2387 break;
2388
2389 case T_UpdateStmt:
2390 tag = CMDTAG_UPDATE;
2391 break;
2392
2393 case T_MergeStmt:
2394 tag = CMDTAG_MERGE;
2395 break;
2396
2397 case T_SelectStmt:
2398 tag = CMDTAG_SELECT;
2399 break;
2400
2401 case T_PLAssignStmt:
2402 tag = CMDTAG_SELECT;
2403 break;
2404
2405 /* utility statements --- same whether raw or cooked */
2406 case T_TransactionStmt:
2407 {
2409
2411 {
2413 tag = CMDTAG_BEGIN;
2414 break;
2415
2417 tag = CMDTAG_START_TRANSACTION;
2418 break;
2419
2421 tag = CMDTAG_COMMIT;
2422 break;
2423
2426 tag = CMDTAG_ROLLBACK;
2427 break;
2428
2430 tag = CMDTAG_SAVEPOINT;
2431 break;
2432
2434 tag = CMDTAG_RELEASE;
2435 break;
2436
2438 tag = CMDTAG_PREPARE_TRANSACTION;
2439 break;
2440
2442 tag = CMDTAG_COMMIT_PREPARED;
2443 break;
2444
2446 tag = CMDTAG_ROLLBACK_PREPARED;
2447 break;
2448
2449 default:
2450 tag = CMDTAG_UNKNOWN;
2451 break;
2452 }
2453 }
2454 break;
2455
2456 case T_DeclareCursorStmt:
2457 tag = CMDTAG_DECLARE_CURSOR;
2458 break;
2459
2460 case T_ClosePortalStmt:
2461 {
2463
2465 tag = CMDTAG_CLOSE_CURSOR_ALL;
2466 else
2467 tag = CMDTAG_CLOSE_CURSOR;
2468 }
2469 break;
2470
2471 case T_FetchStmt:
2472 {
2474
2475 tag = (stmt->ismove) ? CMDTAG_MOVE : CMDTAG_FETCH;
2476 }
2477 break;
2478
2479 case T_CreateDomainStmt:
2480 tag = CMDTAG_CREATE_DOMAIN;
2481 break;
2482
2483 case T_CreateSchemaStmt:
2484 tag = CMDTAG_CREATE_SCHEMA;
2485 break;
2486
2487 case T_CreateStmt:
2488 tag = CMDTAG_CREATE_TABLE;
2489 break;
2490
2491 case T_CreateTableSpaceStmt:
2492 tag = CMDTAG_CREATE_TABLESPACE;
2493 break;
2494
2495 case T_DropTableSpaceStmt:
2496 tag = CMDTAG_DROP_TABLESPACE;
2497 break;
2498
2499 case T_AlterTableSpaceOptionsStmt:
2500 tag = CMDTAG_ALTER_TABLESPACE;
2501 break;
2502
2503 case T_CreateExtensionStmt:
2504 tag = CMDTAG_CREATE_EXTENSION;
2505 break;
2506
2507 case T_AlterExtensionStmt:
2508 tag = CMDTAG_ALTER_EXTENSION;
2509 break;
2510
2511 case T_AlterExtensionContentsStmt:
2512 tag = CMDTAG_ALTER_EXTENSION;
2513 break;
2514
2515 case T_CreateFdwStmt:
2516 tag = CMDTAG_CREATE_FOREIGN_DATA_WRAPPER;
2517 break;
2518
2519 case T_AlterFdwStmt:
2520 tag = CMDTAG_ALTER_FOREIGN_DATA_WRAPPER;
2521 break;
2522
2523 case T_CreateForeignServerStmt:
2524 tag = CMDTAG_CREATE_SERVER;
2525 break;
2526
2527 case T_AlterForeignServerStmt:
2528 tag = CMDTAG_ALTER_SERVER;
2529 break;
2530
2531 case T_CreateUserMappingStmt:
2532 tag = CMDTAG_CREATE_USER_MAPPING;
2533 break;
2534
2535 case T_AlterUserMappingStmt:
2536 tag = CMDTAG_ALTER_USER_MAPPING;
2537 break;
2538
2539 case T_DropUserMappingStmt:
2540 tag = CMDTAG_DROP_USER_MAPPING;
2541 break;
2542
2543 case T_CreateForeignTableStmt:
2544 tag = CMDTAG_CREATE_FOREIGN_TABLE;
2545 break;
2546
2547 case T_ImportForeignSchemaStmt:
2548 tag = CMDTAG_IMPORT_FOREIGN_SCHEMA;
2549 break;
2550
2551 case T_DropStmt:
2553 {
2555 tag = CMDTAG_DROP_TABLE;
2556 break;
2558 tag = CMDTAG_DROP_SEQUENCE;
2559 break;
2561 tag = CMDTAG_DROP_VIEW;
2562 break;
2564 tag = CMDTAG_DROP_MATERIALIZED_VIEW;
2565 break;
2567 tag = CMDTAG_DROP_INDEX;
2568 break;
2570 tag = CMDTAG_DROP_TYPE;
2571 break;
2573 tag = CMDTAG_DROP_DOMAIN;
2574 break;
2576 tag = CMDTAG_DROP_COLLATION;
2577 break;
2579 tag = CMDTAG_DROP_CONVERSION;
2580 break;
2582 tag = CMDTAG_DROP_SCHEMA;
2583 break;
2585 tag = CMDTAG_DROP_TEXT_SEARCH_PARSER;
2586 break;
2588 tag = CMDTAG_DROP_TEXT_SEARCH_DICTIONARY;
2589 break;
2591 tag = CMDTAG_DROP_TEXT_SEARCH_TEMPLATE;
2592 break;
2594 tag = CMDTAG_DROP_TEXT_SEARCH_CONFIGURATION;
2595 break;
2597 tag = CMDTAG_DROP_FOREIGN_TABLE;
2598 break;
2600 tag = CMDTAG_DROP_EXTENSION;
2601 break;
2603 tag = CMDTAG_DROP_FUNCTION;
2604 break;
2606 tag = CMDTAG_DROP_PROCEDURE;
2607 break;
2609 tag = CMDTAG_DROP_ROUTINE;
2610 break;
2612 tag = CMDTAG_DROP_AGGREGATE;
2613 break;
2615 tag = CMDTAG_DROP_OPERATOR;
2616 break;
2618 tag = CMDTAG_DROP_LANGUAGE;
2619 break;
2621 tag = CMDTAG_DROP_CAST;
2622 break;
2624 tag = CMDTAG_DROP_TRIGGER;
2625 break;
2627 tag = CMDTAG_DROP_EVENT_TRIGGER;
2628 break;
2630 tag = CMDTAG_DROP_RULE;
2631 break;
2633 tag = CMDTAG_DROP_FOREIGN_DATA_WRAPPER;
2634 break;
2636 tag = CMDTAG_DROP_SERVER;
2637 break;
2639 tag = CMDTAG_DROP_OPERATOR_CLASS;
2640 break;
2642 tag = CMDTAG_DROP_OPERATOR_FAMILY;
2643 break;
2645 tag = CMDTAG_DROP_POLICY;
2646 break;
2648 tag = CMDTAG_DROP_TRANSFORM;
2649 break;
2651 tag = CMDTAG_DROP_ACCESS_METHOD;
2652 break;
2654 tag = CMDTAG_DROP_PUBLICATION;
2655 break;
2657 tag = CMDTAG_DROP_STATISTICS;
2658 break;
2659 default:
2660 tag = CMDTAG_UNKNOWN;
2661 }
2662 break;
2663
2664 case T_TruncateStmt:
2665 tag = CMDTAG_TRUNCATE_TABLE;
2666 break;
2667
2668 case T_CommentStmt:
2669 tag = CMDTAG_COMMENT;
2670 break;
2671
2672 case T_SecLabelStmt:
2673 tag = CMDTAG_SECURITY_LABEL;
2674 break;
2675
2676 case T_CopyStmt:
2677 tag = CMDTAG_COPY;
2678 break;
2679
2680 case T_RenameStmt:
2681
2682 /*
2683 * When the column is renamed, the command tag is created from its
2684 * relation type
2685 */
2687 ((RenameStmt *) parsetree)->relationType :
2688 ((RenameStmt *) parsetree)->renameType);
2689 break;
2690
2691 case T_AlterObjectDependsStmt:
2693 break;
2694
2695 case T_AlterObjectSchemaStmt:
2697 break;
2698
2699 case T_AlterOwnerStmt:
2701 break;
2702
2703 case T_AlterTableMoveAllStmt:
2705 break;
2706
2707 case T_AlterTableStmt:
2709 break;
2710
2711 case T_AlterDomainStmt:
2712 tag = CMDTAG_ALTER_DOMAIN;
2713 break;
2714
2715 case T_AlterFunctionStmt:
2717 {
2719 tag = CMDTAG_ALTER_FUNCTION;
2720 break;
2722 tag = CMDTAG_ALTER_PROCEDURE;
2723 break;
2725 tag = CMDTAG_ALTER_ROUTINE;
2726 break;
2727 default:
2728 tag = CMDTAG_UNKNOWN;
2729 }
2730 break;
2731
2732 case T_GrantStmt:
2733 {
2735
2736 tag = (stmt->is_grant) ? CMDTAG_GRANT : CMDTAG_REVOKE;
2737 }
2738 break;
2739
2740 case T_GrantRoleStmt:
2741 {
2743
2744 tag = (stmt->is_grant) ? CMDTAG_GRANT_ROLE : CMDTAG_REVOKE_ROLE;
2745 }
2746 break;
2747
2748 case T_AlterDefaultPrivilegesStmt:
2749 tag = CMDTAG_ALTER_DEFAULT_PRIVILEGES;
2750 break;
2751
2752 case T_DefineStmt:
2754 {
2756 tag = CMDTAG_CREATE_AGGREGATE;
2757 break;
2759 tag = CMDTAG_CREATE_OPERATOR;
2760 break;
2762 tag = CMDTAG_CREATE_TYPE;
2763 break;
2765 tag = CMDTAG_CREATE_TEXT_SEARCH_PARSER;
2766 break;
2768 tag = CMDTAG_CREATE_TEXT_SEARCH_DICTIONARY;
2769 break;
2771 tag = CMDTAG_CREATE_TEXT_SEARCH_TEMPLATE;
2772 break;
2774 tag = CMDTAG_CREATE_TEXT_SEARCH_CONFIGURATION;
2775 break;
2777 tag = CMDTAG_CREATE_COLLATION;
2778 break;
2780 tag = CMDTAG_CREATE_ACCESS_METHOD;
2781 break;
2782 default:
2783 tag = CMDTAG_UNKNOWN;
2784 }
2785 break;
2786
2787 case T_CompositeTypeStmt:
2788 tag = CMDTAG_CREATE_TYPE;
2789 break;
2790
2791 case T_CreateEnumStmt:
2792 tag = CMDTAG_CREATE_TYPE;
2793 break;
2794
2795 case T_CreateRangeStmt:
2796 tag = CMDTAG_CREATE_TYPE;
2797 break;
2798
2799 case T_AlterEnumStmt:
2800 tag = CMDTAG_ALTER_TYPE;
2801 break;
2802
2803 case T_ViewStmt:
2804 tag = CMDTAG_CREATE_VIEW;
2805 break;
2806
2807 case T_CreateFunctionStmt:
2809 tag = CMDTAG_CREATE_PROCEDURE;
2810 else
2811 tag = CMDTAG_CREATE_FUNCTION;
2812 break;
2813
2814 case T_IndexStmt:
2815 tag = CMDTAG_CREATE_INDEX;
2816 break;
2817
2818 case T_RuleStmt:
2819 tag = CMDTAG_CREATE_RULE;
2820 break;
2821
2822 case T_CreateSeqStmt:
2823 tag = CMDTAG_CREATE_SEQUENCE;
2824 break;
2825
2826 case T_AlterSeqStmt:
2827 tag = CMDTAG_ALTER_SEQUENCE;
2828 break;
2829
2830 case T_DoStmt:
2831 tag = CMDTAG_DO;
2832 break;
2833
2834 case T_CreatedbStmt:
2835 tag = CMDTAG_CREATE_DATABASE;
2836 break;
2837
2838 case T_AlterDatabaseStmt:
2839 case T_AlterDatabaseRefreshCollStmt:
2840 case T_AlterDatabaseSetStmt:
2841 tag = CMDTAG_ALTER_DATABASE;
2842 break;
2843
2844 case T_DropdbStmt:
2845 tag = CMDTAG_DROP_DATABASE;
2846 break;
2847
2848 case T_NotifyStmt:
2849 tag = CMDTAG_NOTIFY;
2850 break;
2851
2852 case T_ListenStmt:
2853 tag = CMDTAG_LISTEN;
2854 break;
2855
2856 case T_UnlistenStmt:
2857 tag = CMDTAG_UNLISTEN;
2858 break;
2859
2860 case T_LoadStmt:
2861 tag = CMDTAG_LOAD;
2862 break;
2863
2864 case T_CallStmt:
2865 tag = CMDTAG_CALL;
2866 break;
2867
2868 case T_ClusterStmt:
2869 tag = CMDTAG_CLUSTER;
2870 break;
2871
2872 case T_VacuumStmt:
2874 tag = CMDTAG_VACUUM;
2875 else
2876 tag = CMDTAG_ANALYZE;
2877 break;
2878
2879 case T_ExplainStmt:
2880 tag = CMDTAG_EXPLAIN;
2881 break;
2882
2883 case T_CreateTableAsStmt:
2885 {
2888 tag = CMDTAG_SELECT_INTO;
2889 else
2890 tag = CMDTAG_CREATE_TABLE_AS;
2891 break;
2893 tag = CMDTAG_CREATE_MATERIALIZED_VIEW;
2894 break;
2895 default:
2896 tag = CMDTAG_UNKNOWN;
2897 }
2898 break;
2899
2900 case T_RefreshMatViewStmt:
2901 tag = CMDTAG_REFRESH_MATERIALIZED_VIEW;
2902 break;
2903
2904 case T_AlterSystemStmt:
2905 tag = CMDTAG_ALTER_SYSTEM;
2906 break;
2907
2908 case T_VariableSetStmt:
2910 {
2915 tag = CMDTAG_SET;
2916 break;
2919 tag = CMDTAG_RESET;
2920 break;
2921 default:
2922 tag = CMDTAG_UNKNOWN;
2923 }
2924 break;
2925
2926 case T_VariableShowStmt:
2927 tag = CMDTAG_SHOW;
2928 break;
2929
2930 case T_DiscardStmt:
2932 {
2934 tag = CMDTAG_DISCARD_ALL;
2935 break;
2937 tag = CMDTAG_DISCARD_PLANS;
2938 break;
2940 tag = CMDTAG_DISCARD_TEMP;
2941 break;
2943 tag = CMDTAG_DISCARD_SEQUENCES;
2944 break;
2945 default:
2946 tag = CMDTAG_UNKNOWN;
2947 }
2948 break;
2949
2950 case T_CreateTransformStmt:
2951 tag = CMDTAG_CREATE_TRANSFORM;
2952 break;
2953
2954 case T_CreateTrigStmt:
2955 tag = CMDTAG_CREATE_TRIGGER;
2956 break;
2957
2958 case T_CreateEventTrigStmt:
2959 tag = CMDTAG_CREATE_EVENT_TRIGGER;
2960 break;
2961
2962 case T_AlterEventTrigStmt:
2963 tag = CMDTAG_ALTER_EVENT_TRIGGER;
2964 break;
2965
2966 case T_CreatePLangStmt:
2967 tag = CMDTAG_CREATE_LANGUAGE;
2968 break;
2969
2970 case T_CreateRoleStmt:
2971 tag = CMDTAG_CREATE_ROLE;
2972 break;
2973
2974 case T_AlterRoleStmt:
2975 tag = CMDTAG_ALTER_ROLE;
2976 break;
2977
2978 case T_AlterRoleSetStmt:
2979 tag = CMDTAG_ALTER_ROLE;
2980 break;
2981
2982 case T_DropRoleStmt:
2983 tag = CMDTAG_DROP_ROLE;
2984 break;
2985
2986 case T_DropOwnedStmt:
2987 tag = CMDTAG_DROP_OWNED;
2988 break;
2989
2990 case T_ReassignOwnedStmt:
2991 tag = CMDTAG_REASSIGN_OWNED;
2992 break;
2993
2994 case T_LockStmt:
2995 tag = CMDTAG_LOCK_TABLE;
2996 break;
2997
2998 case T_ConstraintsSetStmt:
2999 tag = CMDTAG_SET_CONSTRAINTS;
3000 break;
3001
3002 case T_CheckPointStmt:
3003 tag = CMDTAG_CHECKPOINT;
3004 break;
3005
3006 case T_ReindexStmt:
3007 tag = CMDTAG_REINDEX;
3008 break;
3009
3010 case T_CreateConversionStmt:
3011 tag = CMDTAG_CREATE_CONVERSION;
3012 break;
3013
3014 case T_CreateCastStmt:
3015 tag = CMDTAG_CREATE_CAST;
3016 break;
3017
3018 case T_CreateOpClassStmt:
3019 tag = CMDTAG_CREATE_OPERATOR_CLASS;
3020 break;
3021
3022 case T_CreateOpFamilyStmt:
3023 tag = CMDTAG_CREATE_OPERATOR_FAMILY;
3024 break;
3025
3026 case T_AlterOpFamilyStmt:
3027 tag = CMDTAG_ALTER_OPERATOR_FAMILY;
3028 break;
3029
3030 case T_AlterOperatorStmt:
3031 tag = CMDTAG_ALTER_OPERATOR;
3032 break;
3033
3034 case T_AlterTypeStmt:
3035 tag = CMDTAG_ALTER_TYPE;
3036 break;
3037
3038 case T_AlterTSDictionaryStmt:
3039 tag = CMDTAG_ALTER_TEXT_SEARCH_DICTIONARY;
3040 break;
3041
3042 case T_AlterTSConfigurationStmt:
3043 tag = CMDTAG_ALTER_TEXT_SEARCH_CONFIGURATION;
3044 break;
3045
3046 case T_CreatePolicyStmt:
3047 tag = CMDTAG_CREATE_POLICY;
3048 break;
3049
3050 case T_AlterPolicyStmt:
3051 tag = CMDTAG_ALTER_POLICY;
3052 break;
3053
3054 case T_CreateAmStmt:
3055 tag = CMDTAG_CREATE_ACCESS_METHOD;
3056 break;
3057
3058 case T_CreatePublicationStmt:
3059 tag = CMDTAG_CREATE_PUBLICATION;
3060 break;
3061
3062 case T_AlterPublicationStmt:
3063 tag = CMDTAG_ALTER_PUBLICATION;
3064 break;
3065
3066 case T_CreateSubscriptionStmt:
3067 tag = CMDTAG_CREATE_SUBSCRIPTION;
3068 break;
3069
3070 case T_AlterSubscriptionStmt:
3071 tag = CMDTAG_ALTER_SUBSCRIPTION;
3072 break;
3073
3074 case T_DropSubscriptionStmt:
3075 tag = CMDTAG_DROP_SUBSCRIPTION;
3076 break;
3077
3078 case T_AlterCollationStmt:
3079 tag = CMDTAG_ALTER_COLLATION;
3080 break;
3081
3082 case T_PrepareStmt:
3083 tag = CMDTAG_PREPARE;
3084 break;
3085
3086 case T_ExecuteStmt:
3087 tag = CMDTAG_EXECUTE;
3088 break;
3089
3090 case T_CreateStatsStmt:
3091 tag = CMDTAG_CREATE_STATISTICS;
3092 break;
3093
3094 case T_AlterStatsStmt:
3095 tag = CMDTAG_ALTER_STATISTICS;
3096 break;
3097
3098 case T_DeallocateStmt:
3099 {
3101
3103 tag = CMDTAG_DEALLOCATE_ALL;
3104 else
3105 tag = CMDTAG_DEALLOCATE;
3106 }
3107 break;
3108
3109 case T_WaitStmt:
3110 tag = CMDTAG_WAIT;
3111 break;
3112
3113 /* already-planned queries */
3114 case T_PlannedStmt:
3115 {
3117
3119 {
3121
3122 /*
3123 * We take a little extra care here so that the result
3124 * will be useful for complaints about read-only
3125 * statements
3126 */
3128 {
3129 /* not 100% but probably close enough */
3131 {
3133 tag = CMDTAG_SELECT_FOR_KEY_SHARE;
3134 break;
3136 tag = CMDTAG_SELECT_FOR_SHARE;
3137 break;
3139 tag = CMDTAG_SELECT_FOR_NO_KEY_UPDATE;
3140 break;
3142 tag = CMDTAG_SELECT_FOR_UPDATE;
3143 break;
3144 default:
3145 tag = CMDTAG_SELECT;
3146 break;
3147 }
3148 }
3149 else
3150 tag = CMDTAG_SELECT;
3151 break;
3153 tag = CMDTAG_UPDATE;
3154 break;
3156 tag = CMDTAG_INSERT;
3157 break;
3159 tag = CMDTAG_DELETE;
3160 break;
3162 tag = CMDTAG_MERGE;
3163 break;
3166 break;
3167 default:
3170 tag = CMDTAG_UNKNOWN;
3171 break;
3172 }
3173 }
3174 break;
3175
3176 /* parsed-and-rewritten-but-not-planned queries */
3177 case T_Query:
3178 {
3180
3182 {
3184
3185 /*
3186 * We take a little extra care here so that the result
3187 * will be useful for complaints about read-only
3188 * statements
3189 */
3191 {
3192 /* not 100% but probably close enough */
3194 {
3196 tag = CMDTAG_SELECT_FOR_KEY_SHARE;
3197 break;
3199 tag = CMDTAG_SELECT_FOR_SHARE;
3200 break;
3202 tag = CMDTAG_SELECT_FOR_NO_KEY_UPDATE;
3203 break;
3205 tag = CMDTAG_SELECT_FOR_UPDATE;
3206 break;
3207 default:
3208 tag = CMDTAG_UNKNOWN;
3209 break;
3210 }
3211 }
3212 else
3213 tag = CMDTAG_SELECT;
3214 break;
3216 tag = CMDTAG_UPDATE;
3217 break;
3219 tag = CMDTAG_INSERT;
3220 break;
3222 tag = CMDTAG_DELETE;
3223 break;
3225 tag = CMDTAG_MERGE;
3226 break;
3229 break;
3230 default:
3233 tag = CMDTAG_UNKNOWN;
3234 break;
3235 }
3236 }
3237 break;
3238
3239 default:
3242 tag = CMDTAG_UNKNOWN;
3243 break;
3244 }
3245
3246 return tag;
3247}
Definition: parsenodes.h:3626
Definition: parsenodes.h:3709
Definition: parsenodes.h:3723
Definition: parsenodes.h:3737
Definition: parsenodes.h:2939
Definition: parsenodes.h:2434
Definition: parsenodes.h:3440
Definition: parsenodes.h:3592
Definition: parsenodes.h:4054
Definition: parsenodes.h:4223
Definition: parsenodes.h:3275
Definition: parsenodes.h:4099
Definition: parsenodes.h:3361
Definition: parsenodes.h:3479
Definition: parsenodes.h:2670
Definition: parsenodes.h:2605
Definition: plannodes.h:1585
Definition: parsenodes.h:118
Definition: parsenodes.h:2111
Definition: parsenodes.h:3691
Definition: parsenodes.h:1635
Definition: parsenodes.h:4003
Definition: parsenodes.h:2732
static CommandTag AlterObjectTypeCommandTag(ObjectType objtype)
Definition: utility.c:2223
References AlterObjectTypeCommandTag(), CMD_DELETE, CMD_INSERT, CMD_MERGE, CMD_SELECT, CMD_UPDATE, CMD_UTILITY, CreateCommandTag(), DISCARD_ALL, DISCARD_PLANS, DISCARD_SEQUENCES, DISCARD_TEMP, elog, LCS_FORKEYSHARE, LCS_FORNOKEYUPDATE, LCS_FORSHARE, LCS_FORUPDATE, linitial, NIL, nodeTag, OBJECT_ACCESS_METHOD, OBJECT_AGGREGATE, OBJECT_CAST, OBJECT_COLLATION, OBJECT_COLUMN, OBJECT_CONVERSION, OBJECT_DOMAIN, OBJECT_EVENT_TRIGGER, OBJECT_EXTENSION, OBJECT_FDW, OBJECT_FOREIGN_SERVER, OBJECT_FOREIGN_TABLE, OBJECT_FUNCTION, OBJECT_INDEX, OBJECT_LANGUAGE, OBJECT_MATVIEW, OBJECT_OPCLASS, OBJECT_OPERATOR, OBJECT_OPFAMILY, OBJECT_POLICY, OBJECT_PROCEDURE, OBJECT_PUBLICATION, OBJECT_ROUTINE, OBJECT_RULE, OBJECT_SCHEMA, OBJECT_SEQUENCE, OBJECT_STATISTIC_EXT, OBJECT_TABLE, OBJECT_TRANSFORM, OBJECT_TRIGGER, OBJECT_TSCONFIGURATION, OBJECT_TSDICTIONARY, OBJECT_TSPARSER, OBJECT_TSTEMPLATE, OBJECT_TYPE, OBJECT_VIEW, stmt, TRANS_STMT_BEGIN, TRANS_STMT_COMMIT, TRANS_STMT_COMMIT_PREPARED, TRANS_STMT_PREPARE, TRANS_STMT_RELEASE, TRANS_STMT_ROLLBACK, TRANS_STMT_ROLLBACK_PREPARED, TRANS_STMT_ROLLBACK_TO, TRANS_STMT_SAVEPOINT, TRANS_STMT_START, VAR_RESET, VAR_RESET_ALL, VAR_SET_CURRENT, VAR_SET_DEFAULT, VAR_SET_MULTI, VAR_SET_VALUE, and WARNING.
Referenced by _SPI_prepare_oneshot_plan(), _SPI_prepare_plan(), CreateCommandName(), CreateCommandTag(), EventTriggerGetTag(), exec_parse_message(), exec_simple_query(), interpret_AS_clause(), prepare_next_query(), PrepareQuery(), REGRESS_utility_command(), and standard_ProcessUtility().
◆ ExecDropStmt()
|
static |
Definition at line 1996 of file utility.c.
1997{
1999 {
2002 PreventInTransactionBlock(isTopLevel,
2003 "DROP INDEX CONCURRENTLY");
2004 /* fall through */
2005
2012 break;
2013 default:
2015 break;
2016 }
2017}
void PreventInTransactionBlock(bool isTopLevel, const char *stmtType)
Definition: xact.c:3669
References OBJECT_FOREIGN_TABLE, OBJECT_INDEX, OBJECT_MATVIEW, OBJECT_SEQUENCE, OBJECT_TABLE, OBJECT_VIEW, PreventInTransactionBlock(), RemoveObjects(), RemoveRelations(), and stmt.
Referenced by ProcessUtilitySlow(), and standard_ProcessUtility().
◆ GetCommandLogLevel()
| LogStmtLevel GetCommandLogLevel | ( | Node * | parsetree | ) |
Definition at line 3260 of file utility.c.
3261{
3262 LogStmtLevel lev;
3263
3265 {
3266 /* recurse if we're given a RawStmt */
3267 case T_RawStmt:
3269 break;
3270
3271 /* raw plannable queries */
3272 case T_InsertStmt:
3273 case T_DeleteStmt:
3274 case T_UpdateStmt:
3275 case T_MergeStmt:
3276 lev = LOGSTMT_MOD;
3277 break;
3278
3279 case T_SelectStmt:
3282 else
3283 lev = LOGSTMT_ALL;
3284 break;
3285
3286 case T_PLAssignStmt:
3287 lev = LOGSTMT_ALL;
3288 break;
3289
3290 /* utility statements --- same whether raw or cooked */
3291 case T_TransactionStmt:
3292 lev = LOGSTMT_ALL;
3293 break;
3294
3295 case T_DeclareCursorStmt:
3296 lev = LOGSTMT_ALL;
3297 break;
3298
3299 case T_ClosePortalStmt:
3300 lev = LOGSTMT_ALL;
3301 break;
3302
3303 case T_FetchStmt:
3304 lev = LOGSTMT_ALL;
3305 break;
3306
3307 case T_CreateSchemaStmt:
3308 lev = LOGSTMT_DDL;
3309 break;
3310
3311 case T_CreateStmt:
3312 case T_CreateForeignTableStmt:
3313 lev = LOGSTMT_DDL;
3314 break;
3315
3316 case T_CreateTableSpaceStmt:
3317 case T_DropTableSpaceStmt:
3318 case T_AlterTableSpaceOptionsStmt:
3319 lev = LOGSTMT_DDL;
3320 break;
3321
3322 case T_CreateExtensionStmt:
3323 case T_AlterExtensionStmt:
3324 case T_AlterExtensionContentsStmt:
3325 lev = LOGSTMT_DDL;
3326 break;
3327
3328 case T_CreateFdwStmt:
3329 case T_AlterFdwStmt:
3330 case T_CreateForeignServerStmt:
3331 case T_AlterForeignServerStmt:
3332 case T_CreateUserMappingStmt:
3333 case T_AlterUserMappingStmt:
3334 case T_DropUserMappingStmt:
3335 case T_ImportForeignSchemaStmt:
3336 lev = LOGSTMT_DDL;
3337 break;
3338
3339 case T_DropStmt:
3340 lev = LOGSTMT_DDL;
3341 break;
3342
3343 case T_TruncateStmt:
3344 lev = LOGSTMT_MOD;
3345 break;
3346
3347 case T_CommentStmt:
3348 lev = LOGSTMT_DDL;
3349 break;
3350
3351 case T_SecLabelStmt:
3352 lev = LOGSTMT_DDL;
3353 break;
3354
3355 case T_CopyStmt:
3357 lev = LOGSTMT_MOD;
3358 else
3359 lev = LOGSTMT_ALL;
3360 break;
3361
3362 case T_PrepareStmt:
3363 {
3365
3366 /* Look through a PREPARE to the contained stmt */
3368 }
3369 break;
3370
3371 case T_ExecuteStmt:
3372 {
3375
3376 /* Look through an EXECUTE to the referenced stmt */
3380 else
3381 lev = LOGSTMT_ALL;
3382 }
3383 break;
3384
3385 case T_DeallocateStmt:
3386 lev = LOGSTMT_ALL;
3387 break;
3388
3389 case T_RenameStmt:
3390 lev = LOGSTMT_DDL;
3391 break;
3392
3393 case T_AlterObjectDependsStmt:
3394 lev = LOGSTMT_DDL;
3395 break;
3396
3397 case T_AlterObjectSchemaStmt:
3398 lev = LOGSTMT_DDL;
3399 break;
3400
3401 case T_AlterOwnerStmt:
3402 lev = LOGSTMT_DDL;
3403 break;
3404
3405 case T_AlterOperatorStmt:
3406 lev = LOGSTMT_DDL;
3407 break;
3408
3409 case T_AlterTypeStmt:
3410 lev = LOGSTMT_DDL;
3411 break;
3412
3413 case T_AlterTableMoveAllStmt:
3414 case T_AlterTableStmt:
3415 lev = LOGSTMT_DDL;
3416 break;
3417
3418 case T_AlterDomainStmt:
3419 lev = LOGSTMT_DDL;
3420 break;
3421
3422 case T_GrantStmt:
3423 lev = LOGSTMT_DDL;
3424 break;
3425
3426 case T_GrantRoleStmt:
3427 lev = LOGSTMT_DDL;
3428 break;
3429
3430 case T_AlterDefaultPrivilegesStmt:
3431 lev = LOGSTMT_DDL;
3432 break;
3433
3434 case T_DefineStmt:
3435 lev = LOGSTMT_DDL;
3436 break;
3437
3438 case T_CompositeTypeStmt:
3439 lev = LOGSTMT_DDL;
3440 break;
3441
3442 case T_CreateEnumStmt:
3443 lev = LOGSTMT_DDL;
3444 break;
3445
3446 case T_CreateRangeStmt:
3447 lev = LOGSTMT_DDL;
3448 break;
3449
3450 case T_AlterEnumStmt:
3451 lev = LOGSTMT_DDL;
3452 break;
3453
3454 case T_ViewStmt:
3455 lev = LOGSTMT_DDL;
3456 break;
3457
3458 case T_CreateFunctionStmt:
3459 lev = LOGSTMT_DDL;
3460 break;
3461
3462 case T_AlterFunctionStmt:
3463 lev = LOGSTMT_DDL;
3464 break;
3465
3466 case T_IndexStmt:
3467 lev = LOGSTMT_DDL;
3468 break;
3469
3470 case T_RuleStmt:
3471 lev = LOGSTMT_DDL;
3472 break;
3473
3474 case T_CreateSeqStmt:
3475 lev = LOGSTMT_DDL;
3476 break;
3477
3478 case T_AlterSeqStmt:
3479 lev = LOGSTMT_DDL;
3480 break;
3481
3482 case T_DoStmt:
3483 lev = LOGSTMT_ALL;
3484 break;
3485
3486 case T_CreatedbStmt:
3487 lev = LOGSTMT_DDL;
3488 break;
3489
3490 case T_AlterDatabaseStmt:
3491 case T_AlterDatabaseRefreshCollStmt:
3492 case T_AlterDatabaseSetStmt:
3493 lev = LOGSTMT_DDL;
3494 break;
3495
3496 case T_DropdbStmt:
3497 lev = LOGSTMT_DDL;
3498 break;
3499
3500 case T_NotifyStmt:
3501 lev = LOGSTMT_ALL;
3502 break;
3503
3504 case T_ListenStmt:
3505 lev = LOGSTMT_ALL;
3506 break;
3507
3508 case T_UnlistenStmt:
3509 lev = LOGSTMT_ALL;
3510 break;
3511
3512 case T_LoadStmt:
3513 lev = LOGSTMT_ALL;
3514 break;
3515
3516 case T_CallStmt:
3517 lev = LOGSTMT_ALL;
3518 break;
3519
3520 case T_ClusterStmt:
3521 lev = LOGSTMT_DDL;
3522 break;
3523
3524 case T_VacuumStmt:
3525 lev = LOGSTMT_ALL;
3526 break;
3527
3528 case T_ExplainStmt:
3529 {
3532 ListCell *lc;
3533
3534 /* Look through an EXPLAIN ANALYZE to the contained stmt */
3536 {
3538
3541 /* don't "break", as explain.c will use the last value */
3542 }
3545
3546 /* Plain EXPLAIN isn't so interesting */
3547 lev = LOGSTMT_ALL;
3548 }
3549 break;
3550
3551 case T_CreateTableAsStmt:
3552 lev = LOGSTMT_DDL;
3553 break;
3554
3555 case T_RefreshMatViewStmt:
3556 lev = LOGSTMT_DDL;
3557 break;
3558
3559 case T_AlterSystemStmt:
3560 lev = LOGSTMT_DDL;
3561 break;
3562
3563 case T_VariableSetStmt:
3564 lev = LOGSTMT_ALL;
3565 break;
3566
3567 case T_VariableShowStmt:
3568 lev = LOGSTMT_ALL;
3569 break;
3570
3571 case T_DiscardStmt:
3572 lev = LOGSTMT_ALL;
3573 break;
3574
3575 case T_CreateTrigStmt:
3576 lev = LOGSTMT_DDL;
3577 break;
3578
3579 case T_CreateEventTrigStmt:
3580 lev = LOGSTMT_DDL;
3581 break;
3582
3583 case T_AlterEventTrigStmt:
3584 lev = LOGSTMT_DDL;
3585 break;
3586
3587 case T_CreatePLangStmt:
3588 lev = LOGSTMT_DDL;
3589 break;
3590
3591 case T_CreateDomainStmt:
3592 lev = LOGSTMT_DDL;
3593 break;
3594
3595 case T_CreateRoleStmt:
3596 lev = LOGSTMT_DDL;
3597 break;
3598
3599 case T_AlterRoleStmt:
3600 lev = LOGSTMT_DDL;
3601 break;
3602
3603 case T_AlterRoleSetStmt:
3604 lev = LOGSTMT_DDL;
3605 break;
3606
3607 case T_DropRoleStmt:
3608 lev = LOGSTMT_DDL;
3609 break;
3610
3611 case T_DropOwnedStmt:
3612 lev = LOGSTMT_DDL;
3613 break;
3614
3615 case T_ReassignOwnedStmt:
3616 lev = LOGSTMT_DDL;
3617 break;
3618
3619 case T_LockStmt:
3620 lev = LOGSTMT_ALL;
3621 break;
3622
3623 case T_ConstraintsSetStmt:
3624 lev = LOGSTMT_ALL;
3625 break;
3626
3627 case T_CheckPointStmt:
3628 lev = LOGSTMT_ALL;
3629 break;
3630
3631 case T_ReindexStmt:
3633 break;
3634
3635 case T_CreateConversionStmt:
3636 lev = LOGSTMT_DDL;
3637 break;
3638
3639 case T_CreateCastStmt:
3640 lev = LOGSTMT_DDL;
3641 break;
3642
3643 case T_CreateOpClassStmt:
3644 lev = LOGSTMT_DDL;
3645 break;
3646
3647 case T_CreateOpFamilyStmt:
3648 lev = LOGSTMT_DDL;
3649 break;
3650
3651 case T_CreateTransformStmt:
3652 lev = LOGSTMT_DDL;
3653 break;
3654
3655 case T_AlterOpFamilyStmt:
3656 lev = LOGSTMT_DDL;
3657 break;
3658
3659 case T_CreatePolicyStmt:
3660 lev = LOGSTMT_DDL;
3661 break;
3662
3663 case T_AlterPolicyStmt:
3664 lev = LOGSTMT_DDL;
3665 break;
3666
3667 case T_AlterTSDictionaryStmt:
3668 lev = LOGSTMT_DDL;
3669 break;
3670
3671 case T_AlterTSConfigurationStmt:
3672 lev = LOGSTMT_DDL;
3673 break;
3674
3675 case T_CreateAmStmt:
3676 lev = LOGSTMT_DDL;
3677 break;
3678
3679 case T_CreatePublicationStmt:
3680 lev = LOGSTMT_DDL;
3681 break;
3682
3683 case T_AlterPublicationStmt:
3684 lev = LOGSTMT_DDL;
3685 break;
3686
3687 case T_CreateSubscriptionStmt:
3688 lev = LOGSTMT_DDL;
3689 break;
3690
3691 case T_AlterSubscriptionStmt:
3692 lev = LOGSTMT_DDL;
3693 break;
3694
3695 case T_DropSubscriptionStmt:
3696 lev = LOGSTMT_DDL;
3697 break;
3698
3699 case T_CreateStatsStmt:
3700 lev = LOGSTMT_DDL;
3701 break;
3702
3703 case T_AlterStatsStmt:
3704 lev = LOGSTMT_DDL;
3705 break;
3706
3707 case T_AlterCollationStmt:
3708 lev = LOGSTMT_DDL;
3709 break;
3710
3711 case T_WaitStmt:
3712 lev = LOGSTMT_ALL;
3713 break;
3714
3715 /* already-planned queries */
3716 case T_PlannedStmt:
3717 {
3719
3721 {
3723 lev = LOGSTMT_ALL;
3724 break;
3725
3730 lev = LOGSTMT_MOD;
3731 break;
3732
3735 break;
3736
3737 default:
3740 lev = LOGSTMT_ALL;
3741 break;
3742 }
3743 }
3744 break;
3745
3746 /* parsed-and-rewritten-but-not-planned queries */
3747 case T_Query:
3748 {
3750
3752 {
3754 lev = LOGSTMT_ALL;
3755 break;
3756
3761 lev = LOGSTMT_MOD;
3762 break;
3763
3766 break;
3767
3768 default:
3771 lev = LOGSTMT_ALL;
3772 break;
3773 }
3774 }
3775 break;
3776
3777 default:
3780 lev = LOGSTMT_ALL;
3781 break;
3782 }
3783
3784 return lev;
3785}
PreparedStatement * FetchPreparedStatement(const char *stmt_name, bool throwError)
Definition: prepare.c:434
struct parser_state ps
Definition: parsenodes.h:841
Definition: parsenodes.h:4211
Definition: parsenodes.h:4034
Definition: parsenodes.h:4197
Definition: prepare.h:29
Definition: parsenodes.h:2210
Definition: pg_list.h:46
References analyze(), CMD_DELETE, CMD_INSERT, CMD_MERGE, CMD_SELECT, CMD_UPDATE, CMD_UTILITY, defGetBoolean(), DefElem::defname, elog, FetchPreparedStatement(), GetCommandLogLevel(), lfirst, LOGSTMT_ALL, LOGSTMT_DDL, LOGSTMT_MOD, nodeTag, ps, stmt, and WARNING.
Referenced by check_log_statement(), and GetCommandLogLevel().
◆ PreventCommandDuringRecovery()
| void PreventCommandDuringRecovery | ( | const char * | cmdname | ) |
Definition at line 443 of file utility.c.
444{
447 (errcode(ERRCODE_READ_ONLY_SQL_TRANSACTION),
448 /* translator: %s is name of a SQL command, eg CREATE */
450 cmdname)));
451}
References ereport, errcode(), errmsg(), ERROR, and RecoveryInProgress().
Referenced by pg_current_xact_id(), pg_notify(), and standard_ProcessUtility().
◆ PreventCommandIfParallelMode()
| void PreventCommandIfParallelMode | ( | const char * | cmdname | ) |
Definition at line 424 of file utility.c.
425{
428 (errcode(ERRCODE_INVALID_TRANSACTION_STATE),
429 /* translator: %s is name of a SQL command, eg CREATE */
431 cmdname)));
432}
References ereport, errcode(), errmsg(), ERROR, and IsInParallelMode().
Referenced by ExecCheckXactReadOnly(), nextval_internal(), SetSequence(), and standard_ProcessUtility().
◆ PreventCommandIfReadOnly()
| void PreventCommandIfReadOnly | ( | const char * | cmdname | ) |
Definition at line 406 of file utility.c.
407{
410 (errcode(ERRCODE_READ_ONLY_SQL_TRANSACTION),
411 /* translator: %s is name of a SQL command, eg CREATE */
413 cmdname)));
414}
References ereport, errcode(), errmsg(), ERROR, and XactReadOnly.
Referenced by be_lo_creat(), be_lo_create(), be_lo_from_bytea(), be_lo_open(), be_lo_put(), be_lo_truncate(), be_lo_truncate64(), be_lo_unlink(), be_lowrite(), DoCopy(), ExecCheckXactReadOnly(), lo_import_internal(), nextval_internal(), SetSequence(), and standard_ProcessUtility().
◆ ProcessUtility()
| void ProcessUtility | ( | PlannedStmt * | pstmt, |
| const char * | queryString, | ||
| bool | readOnlyTree, | ||
| ProcessUtilityContext | context, | ||
| ParamListInfo | params, | ||
| QueryEnvironment * | queryEnv, | ||
| DestReceiver * | dest, | ||
| QueryCompletion * | qc | ||
| ) |
Definition at line 501 of file utility.c.
509{
514
515 /*
516 * We provide a function hook variable that lets loadable plugins get
517 * control when ProcessUtility is called. Such a plugin would normally
518 * call standard_ProcessUtility().
519 */
521 (*ProcessUtility_hook) (pstmt, queryString, readOnlyTree,
522 context, params, queryEnv,
523 dest, qc);
524 else
525 standard_ProcessUtility(pstmt, queryString, readOnlyTree,
526 context, params, queryEnv,
527 dest, qc);
528}
void standard_ProcessUtility(PlannedStmt *pstmt, const char *queryString, bool readOnlyTree, ProcessUtilityContext context, ParamListInfo params, QueryEnvironment *queryEnv, DestReceiver *dest, QueryCompletion *qc)
Definition: utility.c:545
References Assert(), CMD_UTILITY, QueryCompletion::commandTag, PlannedStmt::commandType, generate_unaccent_rules::dest, IsA, ProcessUtility_hook, and standard_ProcessUtility().
Referenced by _SPI_execute_plan(), CreateSchemaCommand(), execute_sql_string(), ImportForeignSchema(), PortalRunUtility(), postquel_getnext(), ProcessUtilityForAlterTable(), and ProcessUtilitySlow().
◆ ProcessUtilityForAlterTable()
| void ProcessUtilityForAlterTable | ( | Node * | stmt, |
| AlterTableUtilityContext * | context | ||
| ) |
Definition at line 1959 of file utility.c.
1960{
1961 PlannedStmt *wrapper;
1962
1963 /*
1964 * For event triggers, we must "close" the current complex-command set,
1965 * and start a new one afterwards; this is needed to ensure the ordering
1966 * of command events is consistent with the way they were executed.
1967 */
1968 EventTriggerAlterTableEnd();
1969
1970 /* Create a suitable wrapper */
1978
1979 ProcessUtility(wrapper,
1980 context->queryString,
1981 false,
1983 context->params,
1984 context->queryEnv,
1985 None_Receiver,
1986 NULL);
1987
1990}
void EventTriggerAlterTableStart(Node *parsetree)
Definition: event_trigger.c:1753
void EventTriggerAlterTableRelid(Oid objectId)
Definition: event_trigger.c:1787
void ProcessUtility(PlannedStmt *pstmt, const char *queryString, bool readOnlyTree, ProcessUtilityContext context, ParamListInfo params, QueryEnvironment *queryEnv, DestReceiver *dest, QueryCompletion *qc)
Definition: utility.c:501
References PlannedStmt::canSetTag, CMD_UTILITY, PlannedStmt::commandType, EventTriggerAlterTableEnd(), EventTriggerAlterTableRelid(), EventTriggerAlterTableStart(), makeNode, None_Receiver, AlterTableUtilityContext::params, PLAN_STMT_INTERNAL, PlannedStmt::planOrigin, PROCESS_UTILITY_SUBCOMMAND, ProcessUtility(), AlterTableUtilityContext::pstmt, AlterTableUtilityContext::queryEnv, AlterTableUtilityContext::queryString, AlterTableUtilityContext::relid, stmt, PlannedStmt::stmt_len, PlannedStmt::stmt_location, and PlannedStmt::utilityStmt.
Referenced by ATParseTransformCmd(), and ATRewriteTables().
◆ ProcessUtilitySlow()
|
static |
Definition at line 1090 of file utility.c.
1098{
1102 bool needCleanup;
1103 bool commandCollected = false;
1104 ObjectAddress address;
1106
1107 /* All event trigger calls are done only when isCompleteQuery is true */
1108 needCleanup = isCompleteQuery && EventTriggerBeginCompleteQuery();
1109
1110 /* PG_TRY block is to ensure we call EventTriggerEndCompleteQuery */
1111 PG_TRY();
1112 {
1113 if (isCompleteQuery)
1114 EventTriggerDDLCommandStart(parsetree);
1115
1117 {
1118 /*
1119 * relation and attribute manipulation
1120 */
1121 case T_CreateSchemaStmt:
1123 queryString,
1124 pstmt->stmt_location,
1125 pstmt->stmt_len);
1126
1127 /*
1128 * EventTriggerCollectSimpleCommand called by
1129 * CreateSchemaCommand
1130 */
1131 commandCollected = true;
1132 break;
1133
1134 case T_CreateStmt:
1135 case T_CreateForeignTableStmt:
1136 {
1137 List *stmts;
1138 RangeVar *table_rv = NULL;
1139
1140 /* Run parse analysis ... */
1142 queryString);
1143
1144 /*
1145 * ... and do it. We can't use foreach() because we may
1146 * modify the list midway through, so pick off the
1147 * elements one at a time, the hard way.
1148 */
1150 {
1152
1153 stmts = list_delete_first(stmts);
1154
1156 {
1158 Datum toast_options;
1160
1161 /* Remember transformed RangeVar for LIKE */
1162 table_rv = cstmt->relation;
1163
1164 /* Create the table itself */
1165 address = DefineRelation(cstmt,
1166 RELKIND_RELATION,
1167 InvalidOid, NULL,
1168 queryString);
1169 EventTriggerCollectSimpleCommand(address,
1170 secondaryObject,
1171 stmt);
1172
1173 /*
1174 * Let NewRelationCreateToastTable decide if this
1175 * one needs a secondary relation too.
1176 */
1177 CommandCounterIncrement();
1178
1179 /*
1180 * parse and validate reloptions for the toast
1181 * table
1182 */
1184 cstmt->options,
1185 "toast",
1186 validnsps,
1187 true,
1188 false);
1189 (void) heap_reloptions(RELKIND_TOASTVALUE,
1190 toast_options,
1191 true);
1192
1194 toast_options);
1195 }
1197 {
1199
1200 /* Remember transformed RangeVar for LIKE */
1202
1203 /* Create the table itself */
1205 RELKIND_FOREIGN_TABLE,
1206 InvalidOid, NULL,
1207 queryString);
1208 CreateForeignTable(cstmt,
1209 address.objectId);
1210 EventTriggerCollectSimpleCommand(address,
1211 secondaryObject,
1212 stmt);
1213 }
1215 {
1216 /*
1217 * Do delayed processing of LIKE options. This
1218 * will result in additional sub-statements for us
1219 * to process. Those should get done before any
1220 * remaining actions, so prepend them to "stmts".
1221 */
1223 List *morestmts;
1224
1225 Assert(table_rv != NULL);
1226
1227 morestmts = expandTableLikeClause(table_rv, like);
1228 stmts = list_concat(morestmts, stmts);
1229 }
1230 else
1231 {
1232 /*
1233 * Recurse for anything else. Note the recursive
1234 * call will stash the objects so created into our
1235 * event trigger context.
1236 */
1237 PlannedStmt *wrapper;
1238
1246
1247 ProcessUtility(wrapper,
1248 queryString,
1249 false,
1251 params,
1252 NULL,
1253 None_Receiver,
1254 NULL);
1255 }
1256
1257 /* Need CCI between commands */
1259 CommandCounterIncrement();
1260 }
1261
1262 /*
1263 * The multiple commands generated here are stashed
1264 * individually, so disable collection below.
1265 */
1266 commandCollected = true;
1267 }
1268 break;
1269
1270 case T_AlterTableStmt:
1271 {
1273 Oid relid;
1274 LOCKMODE lockmode;
1275 ListCell *cell;
1276
1277 /*
1278 * Disallow ALTER TABLE .. DETACH CONCURRENTLY in a
1279 * transaction block or function. (Perhaps it could be
1280 * allowed in a procedure, but don't hold your breath.)
1281 */
1283 {
1285
1286 /* Disallow DETACH CONCURRENTLY in a transaction block */
1288 {
1290 PreventInTransactionBlock(isTopLevel,
1291 "ALTER TABLE ... DETACH CONCURRENTLY");
1292 }
1293 }
1294
1295 /*
1296 * Figure out lock mode, and acquire lock. This also does
1297 * basic permissions checks, so that we won't wait for a
1298 * lock on (for example) a relation on which we have no
1299 * permissions.
1300 */
1302 relid = AlterTableLookupRelation(atstmt, lockmode);
1303
1305 {
1306 AlterTableUtilityContext atcontext;
1307
1308 /* Set up info needed for recursive callbacks ... */
1309 atcontext.pstmt = pstmt;
1310 atcontext.queryString = queryString;
1311 atcontext.relid = relid;
1312 atcontext.params = params;
1313 atcontext.queryEnv = queryEnv;
1314
1315 /* ... ensure we have an event trigger context ... */
1316 EventTriggerAlterTableStart(parsetree);
1317 EventTriggerAlterTableRelid(relid);
1318
1319 /* ... and do it */
1320 AlterTable(atstmt, lockmode, &atcontext);
1321
1322 /* done */
1323 EventTriggerAlterTableEnd();
1324 }
1325 else
1329 }
1330
1331 /* ALTER TABLE stashes commands internally */
1332 commandCollected = true;
1333 break;
1334
1335 case T_AlterDomainStmt:
1336 {
1338
1339 /*
1340 * Some or all of these functions are recursive to cover
1341 * inherited things, so permission checks are done there.
1342 */
1344 {
1346
1347 /*
1348 * Recursively alter column default for table and,
1349 * if requested, for descendants
1350 */
1351 address =
1353 stmt->def);
1354 break;
1356 address =
1358 false);
1359 break;
1361 address =
1363 true);
1364 break;
1366 address =
1368 stmt->def,
1369 &secondaryObject);
1370 break;
1372 address =
1374 stmt->name,
1375 stmt->behavior,
1376 stmt->missing_ok);
1377 break;
1379 address =
1381 stmt->name);
1382 break;
1383 default: /* oops */
1386 break;
1387 }
1388 }
1389 break;
1390
1391 /*
1392 * ************* object creation / destruction **************
1393 */
1394 case T_DefineStmt:
1395 {
1397
1399 {
1401 address =
1403 stmt->oldstyle,
1404 stmt->definition,
1405 stmt->replace);
1406 break;
1410 stmt->definition);
1411 break;
1414 address = DefineType(pstate,
1415 stmt->defnames,
1416 stmt->definition);
1417 break;
1421 stmt->definition);
1422 break;
1426 stmt->definition);
1427 break;
1431 stmt->definition);
1432 break;
1436 stmt->definition,
1437 &secondaryObject);
1438 break;
1441 address = DefineCollation(pstate,
1442 stmt->defnames,
1443 stmt->definition,
1444 stmt->if_not_exists);
1445 break;
1446 default:
1449 break;
1450 }
1451 }
1452 break;
1453
1454 case T_IndexStmt: /* CREATE INDEX */
1455 {
1457 Oid relid;
1458 LOCKMODE lockmode;
1459 int nparts = -1;
1460 bool is_alter_table;
1461
1463 PreventInTransactionBlock(isTopLevel,
1464 "CREATE INDEX CONCURRENTLY");
1465
1466 /*
1467 * Look up the relation OID just once, right here at the
1468 * beginning, so that we don't end up repeating the name
1469 * lookup later and latching onto a different relation
1470 * partway through. To avoid lock upgrade hazards, it's
1471 * important that we take the strongest lock that will
1472 * eventually be needed here, so the lockmode calculation
1473 * needs to match what DefineIndex() does.
1474 */
1476 : ShareLock;
1477 relid =
1479 0,
1481 NULL);
1482
1483 /*
1484 * CREATE INDEX on partitioned tables (but not regular
1485 * inherited tables) recurses to partitions, so we must
1486 * acquire locks early to avoid deadlocks.
1487 *
1488 * We also take the opportunity to verify that all
1489 * partitions are something we can put an index on, to
1490 * avoid building some indexes only to fail later. While
1491 * at it, also count the partitions, so that DefineIndex
1492 * needn't do a duplicative find_all_inheritors search.
1493 */
1495 get_rel_relkind(relid) == RELKIND_PARTITIONED_TABLE)
1496 {
1497 ListCell *lc;
1499
1500 inheritors = find_all_inheritors(relid, lockmode, NULL);
1501 foreach(lc, inheritors)
1502 {
1505
1506 if (relkind != RELKIND_RELATION &&
1507 relkind != RELKIND_MATVIEW &&
1508 relkind != RELKIND_PARTITIONED_TABLE &&
1509 relkind != RELKIND_FOREIGN_TABLE)
1511 relkind, stmt->relation->relname);
1512
1513 if (relkind == RELKIND_FOREIGN_TABLE &&
1516 (errcode(ERRCODE_WRONG_OBJECT_TYPE),
1518 stmt->relation->relname),
1520 stmt->relation->relname)));
1521 }
1522 /* count direct and indirect children, but not rel */
1523 nparts = list_length(inheritors) - 1;
1524 list_free(inheritors);
1525 }
1526
1527 /*
1528 * If the IndexStmt is already transformed, it must have
1529 * come from generateClonedIndexStmt, which in current
1530 * usage means it came from expandTableLikeClause rather
1531 * than from original parse analysis. And that means we
1532 * must treat it like ALTER TABLE ADD INDEX, not CREATE.
1533 * (This is a bit grotty, but currently it doesn't seem
1534 * worth adding a separate bool field for the purpose.)
1535 */
1536 is_alter_table = stmt->transformed;
1537
1538 /* Run parse analysis ... */
1540
1541 /* ... and do it */
1542 EventTriggerAlterTableStart(parsetree);
1543 address =
1544 DefineIndex(pstate,
1545 relid, /* OID of heap relation */
1546 stmt,
1550 nparts, /* # of partitions, or -1 */
1551 is_alter_table,
1552 true, /* check_rights */
1553 true, /* check_not_in_use */
1554 false, /* skip_build */
1555 false); /* quiet */
1556
1557 /*
1558 * Add the CREATE INDEX node itself to stash right away;
1559 * if there were any commands stashed in the ALTER TABLE
1560 * code, we need them to appear after this one.
1561 */
1562 EventTriggerCollectSimpleCommand(address, secondaryObject,
1563 parsetree);
1564 commandCollected = true;
1565 EventTriggerAlterTableEnd();
1566 }
1567 break;
1568
1569 case T_ReindexStmt:
1571
1572 /* EventTriggerCollectSimpleCommand is called directly */
1573 commandCollected = true;
1574 break;
1575
1576 case T_CreateExtensionStmt:
1578 break;
1579
1580 case T_AlterExtensionStmt:
1582 break;
1583
1584 case T_AlterExtensionContentsStmt:
1586 &secondaryObject);
1587 break;
1588
1589 case T_CreateFdwStmt:
1591 break;
1592
1593 case T_AlterFdwStmt:
1595 break;
1596
1597 case T_CreateForeignServerStmt:
1599 break;
1600
1601 case T_AlterForeignServerStmt:
1603 break;
1604
1605 case T_CreateUserMappingStmt:
1607 break;
1608
1609 case T_AlterUserMappingStmt:
1611 break;
1612
1613 case T_DropUserMappingStmt:
1615 /* no commands stashed for DROP */
1616 commandCollected = true;
1617 break;
1618
1619 case T_ImportForeignSchemaStmt:
1621 /* commands are stashed inside ImportForeignSchema */
1622 commandCollected = true;
1623 break;
1624
1625 case T_CompositeTypeStmt: /* CREATE TYPE (composite) */
1626 {
1628
1630 stmt->coldeflist);
1631 }
1632 break;
1633
1634 case T_CreateEnumStmt: /* CREATE TYPE AS ENUM */
1636 break;
1637
1638 case T_CreateRangeStmt: /* CREATE TYPE AS RANGE */
1640 break;
1641
1642 case T_AlterEnumStmt: /* ALTER TYPE (enum) */
1644 break;
1645
1646 case T_ViewStmt: /* CREATE VIEW */
1647 EventTriggerAlterTableStart(parsetree);
1650 EventTriggerCollectSimpleCommand(address, secondaryObject,
1651 parsetree);
1652 /* stashed internally */
1653 commandCollected = true;
1654 EventTriggerAlterTableEnd();
1655 break;
1656
1657 case T_CreateFunctionStmt: /* CREATE FUNCTION */
1659 break;
1660
1661 case T_AlterFunctionStmt: /* ALTER FUNCTION */
1663 break;
1664
1665 case T_RuleStmt: /* CREATE RULE */
1667 break;
1668
1669 case T_CreateSeqStmt:
1671 break;
1672
1673 case T_AlterSeqStmt:
1675 break;
1676
1677 case T_CreateTableAsStmt:
1679 params, queryEnv, qc);
1680 break;
1681
1682 case T_RefreshMatViewStmt:
1683
1684 /*
1685 * REFRESH CONCURRENTLY executes some DDL commands internally.
1686 * Inhibit DDL command collection here to avoid those commands
1687 * from showing up in the deparsed command queue. The refresh
1688 * command itself is queued, which is enough.
1689 */
1691 PG_TRY(2);
1692 {
1694 queryString, qc);
1695 }
1696 PG_FINALLY(2);
1697 {
1699 }
1700 PG_END_TRY(2);
1701 break;
1702
1703 case T_CreateTrigStmt:
1708 break;
1709
1710 case T_CreatePLangStmt:
1712 break;
1713
1714 case T_CreateDomainStmt:
1716 break;
1717
1718 case T_CreateConversionStmt:
1720 break;
1721
1722 case T_CreateCastStmt:
1724 break;
1725
1726 case T_CreateOpClassStmt:
1728 /* command is stashed in DefineOpClass */
1729 commandCollected = true;
1730 break;
1731
1732 case T_CreateOpFamilyStmt:
1734
1735 /*
1736 * DefineOpFamily calls EventTriggerCollectSimpleCommand
1737 * directly.
1738 */
1739 commandCollected = true;
1740 break;
1741
1742 case T_CreateTransformStmt:
1744 break;
1745
1746 case T_AlterOpFamilyStmt:
1748 /* commands are stashed in AlterOpFamily */
1749 commandCollected = true;
1750 break;
1751
1752 case T_AlterTSDictionaryStmt:
1754 break;
1755
1756 case T_AlterTSConfigurationStmt:
1758
1759 /*
1760 * Commands are stashed in MakeConfigurationMapping and
1761 * DropConfigurationMapping, which are called from
1762 * AlterTSConfiguration
1763 */
1764 commandCollected = true;
1765 break;
1766
1767 case T_AlterTableMoveAllStmt:
1769 /* commands are stashed in AlterTableMoveAll */
1770 commandCollected = true;
1771 break;
1772
1773 case T_DropStmt:
1775 /* no commands stashed for DROP */
1776 commandCollected = true;
1777 break;
1778
1779 case T_RenameStmt:
1781 break;
1782
1783 case T_AlterObjectDependsStmt:
1784 address =
1786 &secondaryObject);
1787 break;
1788
1789 case T_AlterObjectSchemaStmt:
1790 address =
1792 &secondaryObject);
1793 break;
1794
1795 case T_AlterOwnerStmt:
1797 break;
1798
1799 case T_AlterOperatorStmt:
1801 break;
1802
1803 case T_AlterTypeStmt:
1805 break;
1806
1807 case T_CommentStmt:
1809 break;
1810
1811 case T_GrantStmt:
1813 /* commands are stashed in ExecGrantStmt_oids */
1814 commandCollected = true;
1815 break;
1816
1817 case T_DropOwnedStmt:
1819 /* no commands stashed for DROP */
1820 commandCollected = true;
1821 break;
1822
1823 case T_AlterDefaultPrivilegesStmt:
1826 commandCollected = true;
1827 break;
1828
1829 case T_CreatePolicyStmt: /* CREATE POLICY */
1831 break;
1832
1833 case T_AlterPolicyStmt: /* ALTER POLICY */
1835 break;
1836
1837 case T_SecLabelStmt:
1839 break;
1840
1841 case T_CreateAmStmt:
1843 break;
1844
1845 case T_CreatePublicationStmt:
1847 break;
1848
1849 case T_AlterPublicationStmt:
1851
1852 /*
1853 * AlterPublication calls EventTriggerCollectSimpleCommand
1854 * directly
1855 */
1856 commandCollected = true;
1857 break;
1858
1859 case T_CreateSubscriptionStmt:
1860 address = CreateSubscription(pstate,
1861 (CreateSubscriptionStmt *) parsetree,
1862 isTopLevel);
1863 break;
1864
1865 case T_AlterSubscriptionStmt:
1866 address = AlterSubscription(pstate,
1867 (AlterSubscriptionStmt *) parsetree,
1868 isTopLevel);
1869 break;
1870
1871 case T_DropSubscriptionStmt:
1873 /* no commands stashed for DROP */
1874 commandCollected = true;
1875 break;
1876
1877 case T_CreateStatsStmt:
1878 {
1879 Oid relid;
1882
1885 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
1887
1888 /*
1889 * CREATE STATISTICS will influence future execution plans
1890 * but does not interfere with currently executing plans.
1891 * So it should be enough to take ShareUpdateExclusiveLock
1892 * on relation, conflicting with ANALYZE and other DDL
1893 * that sets statistical information, but not with normal
1894 * queries.
1895 *
1896 * XXX RangeVarCallbackOwnsRelation not needed here, to
1897 * keep the same behavior as before.
1898 */
1900
1901 /* Run parse analysis ... */
1903
1905 }
1906 break;
1907
1908 case T_AlterStatsStmt:
1910 break;
1911
1912 case T_AlterCollationStmt:
1914 break;
1915
1916 default:
1919 break;
1920 }
1921
1922 /*
1923 * Remember the object so that ddl_command_end event triggers have
1924 * access to it.
1925 */
1926 if (!commandCollected)
1927 EventTriggerCollectSimpleCommand(address, secondaryObject,
1928 parsetree);
1929
1930 if (isCompleteQuery)
1931 {
1932 EventTriggerSQLDrop(parsetree);
1933 EventTriggerDDLCommandEnd(parsetree);
1934 }
1935 }
1936 PG_FINALLY();
1937 {
1938 if (needCleanup)
1939 EventTriggerEndCompleteQuery();
1940 }
1941 PG_END_TRY();
1942}
void ExecAlterDefaultPrivilegesStmt(ParseState *pstate, AlterDefaultPrivilegesStmt *stmt)
Definition: aclchk.c:916
ObjectAddress DefineAggregate(ParseState *pstate, List *name, List *args, bool oldstyle, List *parameters, bool replace)
Definition: aggregatecmds.c:53
ObjectAddress ExecAlterObjectDependsStmt(AlterObjectDependsStmt *stmt, ObjectAddress *refAddress)
Definition: alter.c:471
ObjectAddress ExecAlterObjectSchemaStmt(AlterObjectSchemaStmt *stmt, ObjectAddress *oldSchemaAddr)
Definition: alter.c:534
ObjectAddress DefineCollation(ParseState *pstate, List *names, List *parameters, bool if_not_exists)
Definition: collationcmds.c:57
ObjectAddress DefineSequence(ParseState *pstate, CreateSeqStmt *seq)
Definition: sequence.c:112
ObjectAddress AlterSequence(ParseState *pstate, AlterSeqStmt *stmt)
Definition: sequence.c:429
ObjectAddress CreateConversionCommand(CreateConversionStmt *stmt)
Definition: conversioncmds.c:32
ObjectAddress ExecCreateTableAs(ParseState *pstate, CreateTableAsStmt *stmt, ParamListInfo params, QueryEnvironment *queryEnv, QueryCompletion *qc)
Definition: createas.c:223
void EventTriggerUndoInhibitCommandCollection(void)
Definition: event_trigger.c:1693
void EventTriggerCollectAlterDefPrivs(AlterDefaultPrivilegesStmt *stmt)
Definition: event_trigger.c:2024
void EventTriggerDDLCommandStart(Node *parsetree)
Definition: event_trigger.c:725
void EventTriggerInhibitCommandCollection(void)
Definition: event_trigger.c:1681
bool EventTriggerBeginCompleteQuery(void)
Definition: event_trigger.c:1183
void EventTriggerCollectSimpleCommand(ObjectAddress address, ObjectAddress secondaryObject, Node *parsetree)
Definition: event_trigger.c:1715
void EventTriggerDDLCommandEnd(Node *parsetree)
Definition: event_trigger.c:776
ObjectAddress CreateExtension(ParseState *pstate, CreateExtensionStmt *stmt)
Definition: extension.c:2015
ObjectAddress ExecAlterExtensionStmt(ParseState *pstate, AlterExtensionStmt *stmt)
Definition: extension.c:3339
ObjectAddress ExecAlterExtensionContentsStmt(AlterExtensionContentsStmt *stmt, ObjectAddress *objAddr)
Definition: extension.c:3644
void ImportForeignSchema(ImportForeignSchemaStmt *stmt)
Definition: foreigncmds.c:1495
ObjectAddress AlterForeignServer(AlterForeignServerStmt *stmt)
Definition: foreigncmds.c:985
ObjectAddress AlterForeignDataWrapper(ParseState *pstate, AlterFdwStmt *stmt)
Definition: foreigncmds.c:685
ObjectAddress CreateForeignServer(CreateForeignServerStmt *stmt)
Definition: foreigncmds.c:849
ObjectAddress CreateForeignDataWrapper(ParseState *pstate, CreateFdwStmt *stmt)
Definition: foreigncmds.c:569
ObjectAddress AlterUserMapping(AlterUserMappingStmt *stmt)
Definition: foreigncmds.c:1237
void CreateForeignTable(CreateForeignTableStmt *stmt, Oid relid)
Definition: foreigncmds.c:1415
ObjectAddress CreateUserMapping(CreateUserMappingStmt *stmt)
Definition: foreigncmds.c:1111
ObjectAddress CreateFunction(ParseState *pstate, CreateFunctionStmt *stmt)
Definition: functioncmds.c:1028
ObjectAddress AlterFunction(ParseState *pstate, AlterFunctionStmt *stmt)
Definition: functioncmds.c:1363
ObjectAddress CreateTransform(CreateTransformStmt *stmt)
Definition: functioncmds.c:1834
void ExecReindex(ParseState *pstate, const ReindexStmt *stmt, bool isTopLevel)
Definition: indexcmds.c:2846
ObjectAddress DefineIndex(ParseState *pstate, Oid tableId, IndexStmt *stmt, Oid indexRelationId, Oid parentIndexId, Oid parentConstraintId, int total_parts, bool is_alter_table, bool check_rights, bool check_not_in_use, bool skip_build, bool quiet)
Definition: indexcmds.c:544
ObjectAddress ExecRefreshMatView(RefreshMatViewStmt *stmt, const char *queryString, QueryCompletion *qc)
Definition: matview.c:120
Oid RangeVarGetRelidExtended(const RangeVar *relation, LOCKMODE lockmode, uint32 flags, RangeVarGetRelidCallback callback, void *callback_arg)
Definition: namespace.c:440
ObjectAddress DefineOperator(List *names, List *parameters)
Definition: operatorcmds.c:67
List * transformCreateStmt(CreateStmt *stmt, const char *queryString)
Definition: parse_utilcmd.c:167
IndexStmt * transformIndexStmt(Oid relid, IndexStmt *stmt, const char *queryString)
Definition: parse_utilcmd.c:3058
List * expandTableLikeClause(RangeVar *heapRel, TableLikeClause *table_like_clause)
Definition: parse_utilcmd.c:1347
CreateStatsStmt * transformStatsStmt(Oid relid, CreateStatsStmt *stmt, const char *queryString)
Definition: parse_utilcmd.c:3153
List * find_all_inheritors(Oid parentrelId, LOCKMODE lockmode, List **numparents)
Definition: pg_inherits.c:255
ObjectAddress CreateProceduralLanguage(CreatePLangStmt *stmt)
Definition: proclang.c:38
ObjectAddress CreatePublication(ParseState *pstate, CreatePublicationStmt *stmt)
Definition: publicationcmds.c:831
void AlterPublication(ParseState *pstate, AlterPublicationStmt *stmt)
Definition: publicationcmds.c:1540
Datum transformRelOptions(Datum oldOptions, List *defList, const char *nameSpace, const char *const validnsps[], bool acceptOidsOff, bool isReset)
Definition: reloptions.c:1176
bytea * heap_reloptions(char relkind, Datum reloptions, bool validate)
Definition: reloptions.c:2066
ObjectAddress DefineRule(RuleStmt *stmt, const char *queryString)
Definition: rewriteDefine.c:190
Oid CreateSchemaCommand(CreateSchemaStmt *stmt, const char *queryString, int stmt_location, int stmt_len)
Definition: schemacmds.c:52
ObjectAddress CreateStatistics(CreateStatsStmt *stmt, bool check_rights)
Definition: statscmds.c:63
Definition: parsenodes.h:2558
Definition: parsenodes.h:2685
Definition: parsenodes.h:2582
Definition: parsenodes.h:3884
Definition: parsenodes.h:2970
Definition: parsenodes.h:2963
Definition: parsenodes.h:2992
Definition: parsenodes.h:3016
Definition: parsenodes.h:3347
Definition: parsenodes.h:3750
Definition: parsenodes.h:3110
Definition: parsenodes.h:4361
Definition: parsenodes.h:3262
Definition: parsenodes.h:3580
Definition: parsenodes.h:4400
Definition: parsenodes.h:4281
Definition: parsenodes.h:4262
Definition: parsenodes.h:2515
Definition: utility.h:31
Definition: parsenodes.h:3761
Definition: parsenodes.h:3051
Definition: parsenodes.h:3387
Definition: parsenodes.h:3851
Definition: parsenodes.h:3124
Definition: parsenodes.h:4169
Definition: parsenodes.h:4155
Definition: parsenodes.h:3291
Definition: parsenodes.h:3862
Definition: parsenodes.h:2954
Definition: parsenodes.h:2984
Definition: parsenodes.h:3005
Definition: parsenodes.h:3030
Definition: parsenodes.h:3304
Definition: parsenodes.h:3336
Definition: parsenodes.h:3189
Definition: parsenodes.h:3094
Definition: parsenodes.h:4343
Definition: parsenodes.h:3873
Definition: parsenodes.h:2415
Definition: parsenodes.h:3252
Definition: parsenodes.h:3549
Definition: parsenodes.h:2777
Definition: parsenodes.h:4378
Definition: parsenodes.h:4183
Definition: parsenodes.h:3136
Definition: parsenodes.h:3042
Definition: parsenodes.h:4242
Definition: parsenodes.h:4410
Definition: parsenodes.h:3059
Definition: parsenodes.h:3079
Definition: parsenodes.h:3512
Definition: pg_list.h:54
Definition: nodes.h:135
Definition: objectaddress.h:25
Definition: parsenodes.h:986
Definition: primnodes.h:73
Definition: parsenodes.h:4068
Definition: parsenodes.h:4141
Definition: parsenodes.h:3772
Definition: parsenodes.h:3399
Definition: parsenodes.h:780
Definition: parsenodes.h:3906
void DropSubscription(DropSubscriptionStmt *stmt, bool isTopLevel)
Definition: subscriptioncmds.c:2010
ObjectAddress CreateSubscription(ParseState *pstate, CreateSubscriptionStmt *stmt, bool isTopLevel)
Definition: subscriptioncmds.c:586
ObjectAddress AlterSubscription(ParseState *pstate, AlterSubscriptionStmt *stmt, bool isTopLevel)
Definition: subscriptioncmds.c:1333
void AlterTable(AlterTableStmt *stmt, LOCKMODE lockmode, AlterTableUtilityContext *context)
Definition: tablecmds.c:4532
Oid AlterTableLookupRelation(AlterTableStmt *stmt, LOCKMODE lockmode)
Definition: tablecmds.c:4473
ObjectAddress DefineRelation(CreateStmt *stmt, char relkind, Oid ownerId, ObjectAddress *typaddress, const char *queryString)
Definition: tablecmds.c:769
void RangeVarCallbackOwnsRelation(const RangeVar *relation, Oid relId, Oid oldRelId, void *arg)
Definition: tablecmds.c:19582
void NewRelationCreateToastTable(Oid relOid, Datum reloptions)
Definition: toasting.c:71
ObjectAddress CreateTrigger(CreateTrigStmt *stmt, const char *queryString, Oid relOid, Oid refRelOid, Oid constraintOid, Oid indexOid, Oid funcoid, Oid parentTriggerOid, Node *whenClause, bool isInternal, bool in_partition)
Definition: trigger.c:160
ObjectAddress AlterTSConfiguration(AlterTSConfigurationStmt *stmt)
Definition: tsearchcmds.c:1156
ObjectAddress DefineTSTemplate(List *names, List *parameters)
Definition: tsearchcmds.c:690
ObjectAddress DefineTSDictionary(List *names, List *parameters)
Definition: tsearchcmds.c:397
ObjectAddress DefineTSConfiguration(List *names, List *parameters, ObjectAddress *copied)
Definition: tsearchcmds.c:899
ObjectAddress AlterTSDictionary(AlterTSDictionaryStmt *stmt)
Definition: tsearchcmds.c:493
ObjectAddress DefineTSParser(List *names, List *parameters)
Definition: tsearchcmds.c:184
ObjectAddress AlterDomainNotNull(List *names, bool notNull)
Definition: typecmds.c:2746
ObjectAddress DefineType(ParseState *pstate, List *names, List *parameters)
Definition: typecmds.c:152
ObjectAddress AlterDomainDropConstraint(List *names, const char *constrName, DropBehavior behavior, bool missing_ok)
Definition: typecmds.c:2832
ObjectAddress AlterDomainAddConstraint(List *names, Node *newConstraint, ObjectAddress *constrAddr)
Definition: typecmds.c:2938
ObjectAddress DefineDomain(ParseState *pstate, CreateDomainStmt *stmt)
Definition: typecmds.c:697
ObjectAddress AlterDomainValidateConstraint(List *names, const char *constrName)
Definition: typecmds.c:3035
ObjectAddress AlterDomainDefault(List *names, Node *defaultRaw)
Definition: typecmds.c:2617
ObjectAddress DefineCompositeType(RangeVar *typevar, List *coldeflist)
Definition: typecmds.c:2559
ObjectAddress DefineRange(ParseState *pstate, CreateRangeStmt *stmt)
Definition: typecmds.c:1380
ObjectAddress DefineView(ViewStmt *stmt, const char *queryString, int stmt_location, int stmt_len)
Definition: view.c:355
References AD_AddConstraint, AD_AlterDefault, AD_DropConstraint, AD_DropNotNull, AD_SetNotNull, AD_ValidateConstraint, AlterCollation(), AlterDomainAddConstraint(), AlterDomainDefault(), AlterDomainDropConstraint(), AlterDomainNotNull(), AlterDomainValidateConstraint(), AlterEnum(), AlterForeignDataWrapper(), AlterForeignServer(), AlterFunction(), AlterOperator(), AlterOpFamily(), AlterPolicy(), AlterPublication(), AlterSequence(), AlterStatistics(), AlterSubscription(), AlterTable(), AlterTableGetLockLevel(), AlterTableLookupRelation(), AlterTableMoveAll(), AlterTSConfiguration(), AlterTSDictionary(), AlterType(), AlterUserMapping(), Assert(), AT_DetachPartition, CreateForeignTableStmt::base, PlannedStmt::canSetTag, CMD_UTILITY, AlterTableStmt::cmds, CommandCounterIncrement(), PlannedStmt::commandType, CommentObject(), CreateAccessMethod(), CreateCast(), CreateConversionCommand(), CreateExtension(), CreateForeignDataWrapper(), CreateForeignServer(), CreateForeignTable(), CreateFunction(), CreatePolicy(), CreateProceduralLanguage(), CreatePublication(), CreateSchemaCommand(), CreateStatistics(), CreateSubscription(), CreateTransform(), CreateTrigger(), CreateUserMapping(), AlterTableCmd::def, DefineAggregate(), DefineCollation(), DefineCompositeType(), DefineDomain(), DefineEnum(), DefineIndex(), DefineOpClass(), DefineOperator(), DefineOpFamily(), DefineRange(), DefineRelation(), DefineRule(), DefineSequence(), DefineTSConfiguration(), DefineTSDictionary(), DefineTSParser(), DefineTSTemplate(), DefineType(), DefineView(), DropOwnedObjects(), DropSubscription(), elog, ereport, errcode(), errdetail(), errmsg(), ERROR, EventTriggerAlterTableEnd(), EventTriggerAlterTableRelid(), EventTriggerAlterTableStart(), EventTriggerBeginCompleteQuery(), EventTriggerCollectAlterDefPrivs(), EventTriggerCollectSimpleCommand(), EventTriggerDDLCommandEnd(), EventTriggerDDLCommandStart(), EventTriggerEndCompleteQuery(), EventTriggerInhibitCommandCollection(), EventTriggerSQLDrop(), EventTriggerUndoInhibitCommandCollection(), ExecAlterDefaultPrivilegesStmt(), ExecAlterExtensionContentsStmt(), ExecAlterExtensionStmt(), ExecAlterObjectDependsStmt(), ExecAlterObjectSchemaStmt(), ExecAlterOwnerStmt(), ExecCreateTableAs(), ExecDropStmt(), ExecRefreshMatView(), ExecReindex(), ExecRenameStmt(), ExecSecLabelStmt(), ExecuteGrantStmt(), expandTableLikeClause(), find_all_inheritors(), get_rel_relkind(), HEAP_RELOPT_NAMESPACES, heap_reloptions(), ImportForeignSchema(), InvalidObjectAddress, InvalidOid, IsA, lfirst, lfirst_oid, linitial, list_concat(), list_delete_first(), list_free(), list_length(), makeNode, NewRelationCreateToastTable(), NIL, nodeTag, None_Receiver, NOTICE, OBJECT_AGGREGATE, OBJECT_COLLATION, OBJECT_OPERATOR, OBJECT_TSCONFIGURATION, OBJECT_TSDICTIONARY, OBJECT_TSPARSER, OBJECT_TSTEMPLATE, OBJECT_TYPE, ObjectAddress::objectId, OidIsValid, CreateStmt::options, AlterTableUtilityContext::params, PG_END_TRY, PG_FINALLY, PG_TRY, PLAN_STMT_INTERNAL, PlannedStmt::planOrigin, PreventInTransactionBlock(), PROCESS_UTILITY_SUBCOMMAND, PROCESS_UTILITY_TOPLEVEL, ProcessUtility(), AlterTableUtilityContext::pstmt, AlterTableUtilityContext::queryEnv, AlterTableUtilityContext::queryString, RangeVarCallbackOwnsRelation(), RangeVarGetRelid, RangeVarGetRelidExtended(), AlterTableStmt::relation, CreateStmt::relation, AlterTableUtilityContext::relid, RangeVar::relname, RemoveUserMapping(), ShareLock, ShareUpdateExclusiveLock, stmt, PlannedStmt::stmt_len, PlannedStmt::stmt_location, AlterTableCmd::subtype, transformCreateStmt(), transformIndexStmt(), transformRelOptions(), transformStatsStmt(), and PlannedStmt::utilityStmt.
Referenced by standard_ProcessUtility().
◆ standard_ProcessUtility()
| void standard_ProcessUtility | ( | PlannedStmt * | pstmt, |
| const char * | queryString, | ||
| bool | readOnlyTree, | ||
| ProcessUtilityContext | context, | ||
| ParamListInfo | params, | ||
| QueryEnvironment * | queryEnv, | ||
| DestReceiver * | dest, | ||
| QueryCompletion * | qc | ||
| ) |
Definition at line 545 of file utility.c.
553{
554 Node *parsetree;
556 bool isAtomicContext = (!(context == PROCESS_UTILITY_TOPLEVEL || context == PROCESS_UTILITY_QUERY_NONATOMIC) || IsTransactionBlock());
557 ParseState *pstate;
558 int readonly_flags;
559
560 /* This can recurse, so check for excessive recursion */
561 check_stack_depth();
562
563 /*
564 * If the given node tree is read-only, make a copy to ensure that parse
565 * transformations don't damage the original tree. This could be
566 * refactored to avoid making unnecessary copies in more cases, but it's
567 * not clear that it's worth a great deal of trouble over. Statements
568 * that are complex enough to be expensive to copy are exactly the ones
569 * we'd need to copy, so that only marginal savings seem possible.
570 */
571 if (readOnlyTree)
572 pstmt = copyObject(pstmt);
573 parsetree = pstmt->utilityStmt;
574
575 /* Prohibit read/write commands in read-only states. */
576 readonly_flags = ClassifyUtilityCommandAsReadOnly(parsetree);
579 {
581
588 }
589
590 pstate = make_parsestate(NULL);
591 pstate->p_sourcetext = queryString;
592 pstate->p_queryEnv = queryEnv;
593
595 {
596 /*
597 * ******************** transactions ********************
598 */
599 case T_TransactionStmt:
600 {
602
604 {
605 /*
606 * START TRANSACTION, as defined by SQL99: Identical
607 * to BEGIN. Same code for both.
608 */
611 {
612 ListCell *lc;
613
614 BeginTransactionBlock();
616 {
618
622 true);
626 true);
630 true);
631 }
632 }
633 break;
634
637 {
638 /* report unsuccessful commit in qc */
639 if (qc)
640 SetQueryCompletion(qc, CMDTAG_ROLLBACK, 0);
641 }
642 break;
643
646 {
647 /* report unsuccessful commit in qc */
648 if (qc)
649 SetQueryCompletion(qc, CMDTAG_ROLLBACK, 0);
650 }
651 break;
652
656 break;
657
661 break;
662
665 break;
666
670 break;
671
675 break;
676
680
681 /*
682 * CommitTransactionCommand is in charge of
683 * re-defining the savepoint again
684 */
685 break;
686 }
687 }
688 break;
689
690 /*
691 * Portal (cursor) manipulation
692 */
693 case T_DeclareCursorStmt:
695 isTopLevel);
696 break;
697
698 case T_ClosePortalStmt:
699 {
701
704 }
705 break;
706
707 case T_FetchStmt:
709 break;
710
711 case T_DoStmt:
713 break;
714
715 case T_CreateTableSpaceStmt:
716 /* no event triggers for global objects */
719 break;
720
721 case T_DropTableSpaceStmt:
722 /* no event triggers for global objects */
725 break;
726
727 case T_AlterTableSpaceOptionsStmt:
728 /* no event triggers for global objects */
730 break;
731
732 case T_TruncateStmt:
734 break;
735
736 case T_CopyStmt:
737 {
738 uint64 processed;
739
742 &processed);
743 if (qc)
744 SetQueryCompletion(qc, CMDTAG_COPY, processed);
745 }
746 break;
747
748 case T_PrepareStmt:
752 break;
753
754 case T_ExecuteStmt:
755 ExecuteQuery(pstate,
756 (ExecuteStmt *) parsetree, NULL,
757 params,
758 dest, qc);
759 break;
760
761 case T_DeallocateStmt:
764 break;
765
766 case T_GrantRoleStmt:
767 /* no event triggers for global objects */
769 break;
770
771 case T_CreatedbStmt:
772 /* no event triggers for global objects */
775 break;
776
777 case T_AlterDatabaseStmt:
778 /* no event triggers for global objects */
780 break;
781
782 case T_AlterDatabaseRefreshCollStmt:
783 /* no event triggers for global objects */
785 break;
786
787 case T_AlterDatabaseSetStmt:
788 /* no event triggers for global objects */
790 break;
791
792 case T_DropdbStmt:
793 /* no event triggers for global objects */
796 break;
797
798 /* Query-level asynchronous notification */
799 case T_NotifyStmt:
800 {
802
804 }
805 break;
806
807 case T_ListenStmt:
808 {
810
812
813 /*
814 * We don't allow LISTEN in background processes, as there is
815 * no mechanism for them to collect NOTIFY messages, so they'd
816 * just block cleanout of the async SLRU indefinitely.
817 * (Authors of custom background workers could bypass this
818 * restriction by calling Async_Listen directly, but then it's
819 * on them to provide some mechanism to process the message
820 * queue.) Note there seems no reason to forbid UNLISTEN.
821 */
824 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
825 /* translator: %s is name of a SQL command, eg LISTEN */
827 "LISTEN")));
828
830 }
831 break;
832
833 case T_UnlistenStmt:
834 {
836
840 else
841 Async_UnlistenAll();
842 }
843 break;
844
845 case T_LoadStmt:
846 {
848
850 /* Allowed names are restricted if you're not superuser */
852 }
853 break;
854
855 case T_CallStmt:
857 break;
858
859 case T_ClusterStmt:
861 break;
862
863 case T_VacuumStmt:
865 break;
866
867 case T_ExplainStmt:
869 break;
870
871 case T_AlterSystemStmt:
874 break;
875
876 case T_VariableSetStmt:
878 break;
879
880 case T_VariableShowStmt:
881 {
883
885 }
886 break;
887
888 case T_DiscardStmt:
889 /* should we allow DISCARD PLANS? */
892 break;
893
894 case T_CreateEventTrigStmt:
895 /* no event triggers on event triggers */
897 break;
898
899 case T_AlterEventTrigStmt:
900 /* no event triggers on event triggers */
902 break;
903
904 /*
905 * ******************************** ROLE statements ****
906 */
907 case T_CreateRoleStmt:
908 /* no event triggers for global objects */
910 break;
911
912 case T_AlterRoleStmt:
913 /* no event triggers for global objects */
915 break;
916
917 case T_AlterRoleSetStmt:
918 /* no event triggers for global objects */
920 break;
921
922 case T_DropRoleStmt:
923 /* no event triggers for global objects */
925 break;
926
927 case T_ReassignOwnedStmt:
928 /* no event triggers for global objects */
930 break;
931
932 case T_LockStmt:
933
934 /*
935 * Since the lock would just get dropped immediately, LOCK TABLE
936 * outside a transaction block is presumed to be user error.
937 */
940 break;
941
942 case T_ConstraintsSetStmt:
945 break;
946
947 case T_CheckPointStmt:
949 break;
950
951 /*
952 * The following statements are supported by Event Triggers only
953 * in some cases, so we "fast path" them in the other cases.
954 */
955
956 case T_GrantStmt:
957 {
959
961 ProcessUtilitySlow(pstate, pstmt, queryString,
962 context, params, queryEnv,
963 dest, qc);
964 else
966 }
967 break;
968
969 case T_DropStmt:
970 {
972
974 ProcessUtilitySlow(pstate, pstmt, queryString,
975 context, params, queryEnv,
976 dest, qc);
977 else
979 }
980 break;
981
982 case T_RenameStmt:
983 {
985
987 ProcessUtilitySlow(pstate, pstmt, queryString,
988 context, params, queryEnv,
989 dest, qc);
990 else
992 }
993 break;
994
995 case T_AlterObjectDependsStmt:
996 {
998
1000 ProcessUtilitySlow(pstate, pstmt, queryString,
1001 context, params, queryEnv,
1002 dest, qc);
1003 else
1005 }
1006 break;
1007
1008 case T_AlterObjectSchemaStmt:
1009 {
1011
1013 ProcessUtilitySlow(pstate, pstmt, queryString,
1014 context, params, queryEnv,
1015 dest, qc);
1016 else
1018 }
1019 break;
1020
1021 case T_AlterOwnerStmt:
1022 {
1024
1026 ProcessUtilitySlow(pstate, pstmt, queryString,
1027 context, params, queryEnv,
1028 dest, qc);
1029 else
1031 }
1032 break;
1033
1034 case T_CommentStmt:
1035 {
1037
1039 ProcessUtilitySlow(pstate, pstmt, queryString,
1040 context, params, queryEnv,
1041 dest, qc);
1042 else
1044 break;
1045 }
1046
1047 case T_SecLabelStmt:
1048 {
1050
1052 ProcessUtilitySlow(pstate, pstmt, queryString,
1053 context, params, queryEnv,
1054 dest, qc);
1055 else
1057 break;
1058 }
1059
1060 case T_WaitStmt:
1061 {
1063 }
1064 break;
1065
1066 default:
1067 /* All other statement types have event trigger support */
1068 ProcessUtilitySlow(pstate, pstmt, queryString,
1069 context, params, queryEnv,
1070 dest, qc);
1071 break;
1072 }
1073
1074 free_parsestate(pstate);
1075
1076 /*
1077 * Make effects of commands visible, for instance so that
1078 * PreCommit_on_commit_actions() can see them (see for example bug
1079 * #15631).
1080 */
1081 CommandCounterIncrement();
1082}
void DoCopy(ParseState *pstate, const CopyStmt *stmt, int stmt_location, int stmt_len, uint64 *processed)
Definition: copy.c:62
void PrepareQuery(ParseState *pstate, PrepareStmt *stmt, int stmt_location, int stmt_len)
Definition: prepare.c:59
void ExecuteQuery(ParseState *pstate, ExecuteStmt *stmt, IntoClause *intoClause, ParamListInfo params, DestReceiver *dest, QueryCompletion *qc)
Definition: prepare.c:150
Oid AlterTableSpaceOptions(AlterTableSpaceOptionsStmt *stmt)
Definition: tablespace.c:1015
void ExecCheckpoint(ParseState *pstate, CheckPointStmt *stmt)
Definition: checkpointer.c:1012
void cluster(ParseState *pstate, ClusterStmt *stmt, bool isTopLevel)
Definition: cluster.c:107
static void SetQueryCompletion(QueryCompletion *qc, CommandTag commandTag, uint64 nprocessed)
Definition: cmdtag.h:37
ObjectAddress AlterDatabaseRefreshColl(AlterDatabaseRefreshCollStmt *stmt)
Definition: dbcommands.c:2542
Oid AlterDatabase(ParseState *pstate, AlterDatabaseStmt *stmt, bool isTopLevel)
Definition: dbcommands.c:2369
bool EventTriggerSupportsObjectType(ObjectType obtype)
Definition: event_trigger.c:1133
void ExplainQuery(ParseState *pstate, ExplainStmt *stmt, ParamListInfo params, DestReceiver *dest)
Definition: explain.c:177
void ExecuteCallStmt(CallStmt *stmt, ParamListInfo params, bool atomic, DestReceiver *dest)
Definition: functioncmds.c:2208
void ExecuteDoStmt(ParseState *pstate, DoStmt *stmt, bool atomic)
Definition: functioncmds.c:2086
void AlterSystemSetConfigFile(AlterSystemStmt *altersysstmt)
Definition: guc.c:4470
void SetPGVariable(const char *name, List *args, bool is_local)
Definition: guc_funcs.c:341
void ExecSetVariableStmt(VariableSetStmt *stmt, bool isTopLevel)
Definition: guc_funcs.c:43
ParseState * make_parsestate(ParseState *parentParseState)
Definition: parse_node.c:39
void PerformCursorOpen(ParseState *pstate, DeclareCursorStmt *cstmt, ParamListInfo params, bool isTopLevel)
Definition: portalcmds.c:45
void PerformPortalFetch(FetchStmt *stmt, DestReceiver *dest, QueryCompletion *qc)
Definition: portalcmds.c:178
Definition: parsenodes.h:3949
Definition: parsenodes.h:3955
Definition: parsenodes.h:3942
Definition: parsenodes.h:3177
Definition: parsenodes.h:3232
Definition: parsenodes.h:3224
Definition: parsenodes.h:3978
Definition: parsenodes.h:2931
Definition: parsenodes.h:3668
Definition: parsenodes.h:4080
Definition: parsenodes.h:3988
Definition: parsenodes.h:4121
Definition: parsenodes.h:3164
Definition: parsenodes.h:3216
Definition: parsenodes.h:2915
Definition: parsenodes.h:3931
Definition: parsenodes.h:3428
Definition: parsenodes.h:3640
Definition: parsenodes.h:3240
Definition: parsenodes.h:2924
Definition: parsenodes.h:3966
Definition: parsenodes.h:3799
Definition: parsenodes.h:3921
Definition: parsenodes.h:3788
Definition: parse_node.h:193
Definition: parsenodes.h:4252
Definition: parsenodes.h:3375
Definition: parsenodes.h:3809
Definition: parsenodes.h:2760
Definition: parsenodes.h:4418
void FinishPreparedTransaction(const char *gid, bool isCommit)
Definition: twophase.c:1497
static int ClassifyUtilityCommandAsReadOnly(Node *parsetree)
Definition: utility.c:129
void PreventCommandIfParallelMode(const char *cmdname)
Definition: utility.c:424
static void CheckRestrictedOperation(const char *cmdname)
Definition: utility.c:461
void PreventCommandDuringRecovery(const char *cmdname)
Definition: utility.c:443
static void ProcessUtilitySlow(ParseState *pstate, PlannedStmt *pstmt, const char *queryString, ProcessUtilityContext context, ParamListInfo params, QueryEnvironment *queryEnv, DestReceiver *dest, QueryCompletion *qc)
Definition: utility.c:1090
void ExecVacuum(ParseState *pstate, VacuumStmt *vacstmt, bool isTopLevel)
Definition: vacuum.c:162
void ExecWaitStmt(ParseState *pstate, WaitStmt *stmt, DestReceiver *dest)
Definition: wait.c:33
void WarnNoTransactionBlock(bool isTopLevel, const char *stmtType)
Definition: xact.c:3732
void RequireTransactionBlock(bool isTopLevel, const char *stmtType)
Definition: xact.c:3738
References AfterTriggerSetState(), AlterDatabase(), AlterDatabaseRefreshColl(), AlterDatabaseSet(), AlterEventTrigger(), AlterRole(), AlterRoleSet(), AlterSystemSetConfigFile(), AlterTableSpaceOptions(), DefElem::arg, Async_Listen(), Async_Notify(), Async_Unlisten(), Async_UnlistenAll(), B_BACKEND, BeginTransactionBlock(), castNode, check_stack_depth(), CheckRestrictedOperation(), ClassifyUtilityCommandAsReadOnly(), closeAllVfds(), cluster(), COMMAND_IS_STRICTLY_READ_ONLY, COMMAND_OK_IN_PARALLEL_MODE, COMMAND_OK_IN_READ_ONLY_TXN, COMMAND_OK_IN_RECOVERY, CommandCounterIncrement(), CommentObject(), copyObject, CreateCommandTag(), createdb(), CreateEventTrigger(), CreateRole(), CreateTableSpace(), DeallocateQuery(), DefineSavepoint(), DefElem::defname, generate_unaccent_rules::dest, DiscardCommand(), DoCopy(), DropDatabase(), DropRole(), DropTableSpace(), EndTransactionBlock(), ereport, errcode(), errmsg(), ERROR, EventTriggerSupportsObjectType(), ExecAlterObjectDependsStmt(), ExecAlterObjectSchemaStmt(), ExecAlterOwnerStmt(), ExecCheckpoint(), ExecDropStmt(), ExecRenameStmt(), ExecSecLabelStmt(), ExecSetVariableStmt(), ExecuteCallStmt(), ExecuteDoStmt(), ExecuteGrantStmt(), ExecuteQuery(), ExecuteTruncate(), ExecVacuum(), ExecWaitStmt(), ExplainQuery(), FinishPreparedTransaction(), free_parsestate(), GetCommandTagName(), GetPGVariable(), GrantRole(), IsInParallelMode(), IsTransactionBlock(), lfirst, list_make1, load_file(), LockTableCommand(), make_parsestate(), MyBackendType, VariableShowStmt::name, nodeTag, ParseState::p_queryEnv, ParseState::p_sourcetext, PerformCursorOpen(), PerformPortalClose(), PerformPortalFetch(), PrepareQuery(), PrepareTransactionBlock(), PreventCommandDuringRecovery(), PreventCommandIfParallelMode(), PreventCommandIfReadOnly(), PreventInTransactionBlock(), PROCESS_UTILITY_QUERY_NONATOMIC, PROCESS_UTILITY_TOPLEVEL, ProcessUtilitySlow(), ReassignOwnedObjects(), ReleaseSavepoint(), RequireTransactionBlock(), RollbackToSavepoint(), SetPGVariable(), SetQueryCompletion(), stmt, PlannedStmt::stmt_len, PlannedStmt::stmt_location, superuser(), TRANS_STMT_BEGIN, TRANS_STMT_COMMIT, TRANS_STMT_COMMIT_PREPARED, TRANS_STMT_PREPARE, TRANS_STMT_RELEASE, TRANS_STMT_ROLLBACK, TRANS_STMT_ROLLBACK_PREPARED, TRANS_STMT_ROLLBACK_TO, TRANS_STMT_SAVEPOINT, TRANS_STMT_START, UserAbortTransactionBlock(), PlannedStmt::utilityStmt, WarnNoTransactionBlock(), and XactReadOnly.
Referenced by pgss_ProcessUtility(), ProcessUtility(), REGRESS_utility_command(), and sepgsql_utility_command().
◆ UtilityContainsQuery()
Definition at line 2186 of file utility.c.
2187{
2188 Query *qry;
2189
2191 {
2192 case T_DeclareCursorStmt:
2196 return qry;
2197
2198 case T_ExplainStmt:
2202 return qry;
2203
2204 case T_CreateTableAsStmt:
2208 return qry;
2209
2210 default:
2211 return NULL;
2212 }
2213}
References castNode, CMD_UTILITY, Query::commandType, nodeTag, UtilityContainsQuery(), and Query::utilityStmt.
Referenced by AcquireExecutorLocks(), AcquirePlannerLocks(), extract_query_dependencies_walker(), and UtilityContainsQuery().
◆ UtilityReturnsTuples()
| bool UtilityReturnsTuples | ( | Node * | parsetree | ) |
Definition at line 2029 of file utility.c.
2030{
2032 {
2033 case T_CallStmt:
2034 {
2036
2038 }
2039 case T_FetchStmt:
2040 {
2042 Portal portal;
2043
2045 return false;
2048 return false; /* not our business to raise error */
2050 }
2051
2052 case T_ExecuteStmt:
2053 {
2055 PreparedStatement *entry;
2056
2058 if (!entry)
2059 return false; /* not our business to raise error */
2061 return true;
2062 return false;
2063 }
2064
2065 case T_ExplainStmt:
2066 return true;
2067
2068 case T_VariableShowStmt:
2069 return true;
2070
2071 case T_WaitStmt:
2072 return true;
2073
2074 default:
2075 return false;
2076 }
2077}
Definition: portal.h:116
References FetchPreparedStatement(), GetPortalByName(), nodeTag, PreparedStatement::plansource, PortalIsValid, CachedPlanSource::resultDesc, stmt, true, and PortalData::tupDesc.
Referenced by ChoosePortalStrategy().
◆ UtilityTupleDescriptor()
Definition at line 2088 of file utility.c.
2089{
2091 {
2092 case T_CallStmt:
2094
2095 case T_FetchStmt:
2096 {
2098 Portal portal;
2099
2101 return NULL;
2104 return NULL; /* not our business to raise error */
2106 }
2107
2108 case T_ExecuteStmt:
2109 {
2111 PreparedStatement *entry;
2112
2114 if (!entry)
2115 return NULL; /* not our business to raise error */
2117 }
2118
2119 case T_ExplainStmt:
2121
2122 case T_VariableShowStmt:
2123 {
2125
2127 }
2128
2129 case T_WaitStmt:
2131
2132 default:
2133 return NULL;
2134 }
2135}
TupleDesc FetchPreparedStatementResultDesc(PreparedStatement *stmt)
Definition: prepare.c:466
TupleDesc GetPGVariableResultDesc(const char *name)
Definition: guc_funcs.c:420
References CallStmtResultDesc(), CreateTupleDescCopy(), ExplainResultDesc(), FetchPreparedStatement(), FetchPreparedStatementResultDesc(), GetPGVariableResultDesc(), GetPortalByName(), VariableShowStmt::name, nodeTag, PortalIsValid, stmt, PortalData::tupDesc, and WaitStmtResultDesc().
Referenced by PlanCacheComputeResultDesc(), and PortalStart().
Variable Documentation
◆ ProcessUtility_hook
| ProcessUtility_hook_type ProcessUtility_hook = NULL |
Definition at line 71 of file utility.c.
Referenced by _PG_init(), and ProcessUtility().
