Loading...
Searching...
No Matches
#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/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/propgraphcmds.h"#include "commands/publicationcmds.h"#include "commands/repack.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 2236 of file utility.c.
2237{
2238 CommandTag tag;
2239
2240 switch (objtype)
2241 {
2243 tag = CMDTAG_ALTER_AGGREGATE;
2244 break;
2246 tag = CMDTAG_ALTER_TYPE;
2247 break;
2249 tag = CMDTAG_ALTER_CAST;
2250 break;
2252 tag = CMDTAG_ALTER_COLLATION;
2253 break;
2255 tag = CMDTAG_ALTER_TABLE;
2256 break;
2258 tag = CMDTAG_ALTER_CONVERSION;
2259 break;
2261 tag = CMDTAG_ALTER_DATABASE;
2262 break;
2265 tag = CMDTAG_ALTER_DOMAIN;
2266 break;
2268 tag = CMDTAG_ALTER_EXTENSION;
2269 break;
2271 tag = CMDTAG_ALTER_FOREIGN_DATA_WRAPPER;
2272 break;
2274 tag = CMDTAG_ALTER_SERVER;
2275 break;
2277 tag = CMDTAG_ALTER_FOREIGN_TABLE;
2278 break;
2280 tag = CMDTAG_ALTER_FUNCTION;
2281 break;
2283 tag = CMDTAG_ALTER_INDEX;
2284 break;
2286 tag = CMDTAG_ALTER_LANGUAGE;
2287 break;
2289 tag = CMDTAG_ALTER_LARGE_OBJECT;
2290 break;
2292 tag = CMDTAG_ALTER_OPERATOR_CLASS;
2293 break;
2295 tag = CMDTAG_ALTER_OPERATOR;
2296 break;
2298 tag = CMDTAG_ALTER_OPERATOR_FAMILY;
2299 break;
2301 tag = CMDTAG_ALTER_POLICY;
2302 break;
2304 tag = CMDTAG_ALTER_PROCEDURE;
2305 break;
2307 tag = CMDTAG_ALTER_PROPERTY_GRAPH;
2308 break;
2310 tag = CMDTAG_ALTER_ROLE;
2311 break;
2313 tag = CMDTAG_ALTER_ROUTINE;
2314 break;
2316 tag = CMDTAG_ALTER_RULE;
2317 break;
2319 tag = CMDTAG_ALTER_SCHEMA;
2320 break;
2322 tag = CMDTAG_ALTER_SEQUENCE;
2323 break;
2326 tag = CMDTAG_ALTER_TABLE;
2327 break;
2329 tag = CMDTAG_ALTER_TABLESPACE;
2330 break;
2332 tag = CMDTAG_ALTER_TRIGGER;
2333 break;
2335 tag = CMDTAG_ALTER_EVENT_TRIGGER;
2336 break;
2338 tag = CMDTAG_ALTER_TEXT_SEARCH_CONFIGURATION;
2339 break;
2341 tag = CMDTAG_ALTER_TEXT_SEARCH_DICTIONARY;
2342 break;
2344 tag = CMDTAG_ALTER_TEXT_SEARCH_PARSER;
2345 break;
2347 tag = CMDTAG_ALTER_TEXT_SEARCH_TEMPLATE;
2348 break;
2350 tag = CMDTAG_ALTER_TYPE;
2351 break;
2353 tag = CMDTAG_ALTER_VIEW;
2354 break;
2356 tag = CMDTAG_ALTER_MATERIALIZED_VIEW;
2357 break;
2359 tag = CMDTAG_ALTER_PUBLICATION;
2360 break;
2362 tag = CMDTAG_ALTER_SUBSCRIPTION;
2363 break;
2365 tag = CMDTAG_ALTER_STATISTICS;
2366 break;
2367 default:
2368 tag = CMDTAG_UNKNOWN;
2369 break;
2370 }
2371
2372 return tag;
2373}
References fb(), 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_PROPGRAPH, 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()
Definition at line 464 of file utility.c.
References ereport, errcode(), errmsg, ERROR, fb(), and InSecurityRestrictedOperation().
Referenced by standard_ProcessUtility().
◆ ClassifyUtilityCommandAsReadOnly()
Definition at line 130 of file utility.c.
131{
133 {
218 {
219 /* DDL is not read-only, and neither is TRUNCATE. */
221 }
222
224 {
225 /*
226 * Surprisingly, ALTER SYSTEM meets all our definitions of
227 * read-only: it changes nothing that affects the output of
228 * pg_dump, it doesn't write WAL or imperil the application of
229 * future WAL, and it doesn't depend on any state that needs
230 * to be synchronized with parallel workers.
231 *
232 * So, despite the fact that it writes to a file, it's read
233 * only!
234 */
236 }
237
240 {
241 /*
242 * Commands inside the DO block or the called procedure might
243 * not be read only, but they'll be checked separately when we
244 * try to execute them. Here we only need to worry about the
245 * DO or CALL command itself.
246 */
248 }
249
251 {
252 /*
253 * You might think that this should not be permitted in
254 * recovery, but we interpret a CHECKPOINT command during
255 * recovery as a request for a restartpoint instead. We allow
256 * this since it can be a useful way of reducing switchover
257 * time when using various forms of replication.
258 */
260 }
261
274 {
275 /*
276 * These modify only backend-local state, so they're OK to run
277 * in a read-only transaction or on a standby. However, they
278 * are disallowed in parallel mode, because they either rely
279 * upon or modify backend-local state that might not be
280 * synchronized among cooperating backends.
281 */
283 }
284
288 {
289 /*
290 * These commands write WAL, so they're not strictly
291 * read-only, and running them in parallel workers isn't
292 * supported.
293 *
294 * However, they don't change the database state in a way that
295 * would affect pg_dump output, so it's fine to run them in a
296 * read-only transaction. (REPACK/CLUSTER might change the
297 * order of rows on disk, which could affect the ordering of
298 * pg_dump output, but that's not semantically significant.)
299 */
301 }
302
304 {
306
307 /*
308 * You might think that COPY FROM is not at all read only, but
309 * it's OK to copy into a temporary table, because that
310 * wouldn't change the output of pg_dump. If the target table
311 * turns out to be non-temporary, DoCopy itself will call
312 * PreventCommandIfReadOnly.
313 */
316 else
318 }
319
322 {
323 /*
324 * These commands don't modify any data and are safe to run in
325 * a parallel worker.
326 */
328 }
329
332 {
333 /*
334 * NOTIFY requires an XID assignment, so it can't be permitted
335 * on a standby. Perhaps LISTEN could, since without NOTIFY it
336 * would be OK to just do nothing, at least until promotion,
337 * but we currently prohibit it lest the user get the wrong
338 * idea.
339 *
340 * (We do allow T_UnlistenStmt on a standby, though, because
341 * it's a no-op.)
342 */
344 }
345
347 {
349
350 /*
351 * Only weaker locker modes are allowed during recovery. The
352 * restrictions here must match those in
353 * LockAcquireExtended().
354 */
357 else
359 }
360
362 {
364
365 /*
366 * PREPARE, COMMIT PREPARED, and ROLLBACK PREPARED all write
367 * WAL, so they're not read-only in the strict sense; but the
368 * first and third do not change pg_dump output, so they're OK
369 * in a read-only transactions.
370 *
371 * We also consider COMMIT PREPARED to be OK in a read-only
372 * transaction environment, by way of exception.
373 */
375 {
384
389 }
392 return 0; /* silence stupider compilers */
393 }
394
395 default:
398 return 0; /* silence stupider compilers */
399 }
400}
Definition parsenodes.h:2780
Definition parsenodes.h:4198
Definition parsenodes.h:3913
References COMMAND_IS_NOT_READ_ONLY, COMMAND_IS_STRICTLY_READ_ONLY, COMMAND_OK_IN_READ_ONLY_TXN, COMMAND_OK_IN_RECOVERY, elog, ERROR, fb(), 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 96 of file utility.c.
97{
100 {
103 return false; /* SELECT FOR [KEY] UPDATE/SHARE */
105 return false; /* data-modifying CTE */
106 else
107 return true;
112 return false;
114 /* For now, treat all utility commands as read/write */
115 return false;
116 default:
119 break;
120 }
121 return false;
122}
Definition plannodes.h:60
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 2385 of file utility.c.
2386{
2387 CommandTag tag;
2388
2390 {
2391 /* recurse if we're given a RawStmt */
2394 break;
2395
2396 /* raw plannable queries */
2398 tag = CMDTAG_INSERT;
2399 break;
2400
2402 tag = CMDTAG_DELETE;
2403 break;
2404
2406 tag = CMDTAG_UPDATE;
2407 break;
2408
2410 tag = CMDTAG_MERGE;
2411 break;
2412
2414 tag = CMDTAG_SELECT;
2415 break;
2416
2418 tag = CMDTAG_SELECT;
2419 break;
2420
2421 /* utility statements --- same whether raw or cooked */
2423 {
2425
2427 {
2429 tag = CMDTAG_BEGIN;
2430 break;
2431
2433 tag = CMDTAG_START_TRANSACTION;
2434 break;
2435
2437 tag = CMDTAG_COMMIT;
2438 break;
2439
2442 tag = CMDTAG_ROLLBACK;
2443 break;
2444
2446 tag = CMDTAG_SAVEPOINT;
2447 break;
2448
2450 tag = CMDTAG_RELEASE;
2451 break;
2452
2454 tag = CMDTAG_PREPARE_TRANSACTION;
2455 break;
2456
2458 tag = CMDTAG_COMMIT_PREPARED;
2459 break;
2460
2462 tag = CMDTAG_ROLLBACK_PREPARED;
2463 break;
2464
2465 default:
2466 tag = CMDTAG_UNKNOWN;
2467 break;
2468 }
2469 }
2470 break;
2471
2473 tag = CMDTAG_DECLARE_CURSOR;
2474 break;
2475
2477 {
2479
2481 tag = CMDTAG_CLOSE_CURSOR_ALL;
2482 else
2483 tag = CMDTAG_CLOSE_CURSOR;
2484 }
2485 break;
2486
2488 {
2490
2492 }
2493 break;
2494
2496 tag = CMDTAG_CREATE_DOMAIN;
2497 break;
2498
2500 tag = CMDTAG_CREATE_SCHEMA;
2501 break;
2502
2504 tag = CMDTAG_CREATE_TABLE;
2505 break;
2506
2508 tag = CMDTAG_CREATE_TABLESPACE;
2509 break;
2510
2512 tag = CMDTAG_DROP_TABLESPACE;
2513 break;
2514
2516 tag = CMDTAG_ALTER_TABLESPACE;
2517 break;
2518
2520 tag = CMDTAG_CREATE_EXTENSION;
2521 break;
2522
2524 tag = CMDTAG_ALTER_EXTENSION;
2525 break;
2526
2528 tag = CMDTAG_ALTER_EXTENSION;
2529 break;
2530
2532 tag = CMDTAG_CREATE_FOREIGN_DATA_WRAPPER;
2533 break;
2534
2536 tag = CMDTAG_ALTER_FOREIGN_DATA_WRAPPER;
2537 break;
2538
2540 tag = CMDTAG_CREATE_SERVER;
2541 break;
2542
2544 tag = CMDTAG_ALTER_SERVER;
2545 break;
2546
2548 tag = CMDTAG_CREATE_USER_MAPPING;
2549 break;
2550
2552 tag = CMDTAG_ALTER_USER_MAPPING;
2553 break;
2554
2556 tag = CMDTAG_DROP_USER_MAPPING;
2557 break;
2558
2560 tag = CMDTAG_CREATE_FOREIGN_TABLE;
2561 break;
2562
2564 tag = CMDTAG_IMPORT_FOREIGN_SCHEMA;
2565 break;
2566
2569 {
2571 tag = CMDTAG_DROP_TABLE;
2572 break;
2574 tag = CMDTAG_DROP_SEQUENCE;
2575 break;
2577 tag = CMDTAG_DROP_VIEW;
2578 break;
2580 tag = CMDTAG_DROP_MATERIALIZED_VIEW;
2581 break;
2583 tag = CMDTAG_DROP_INDEX;
2584 break;
2586 tag = CMDTAG_DROP_PROPERTY_GRAPH;
2587 break;
2589 tag = CMDTAG_DROP_TYPE;
2590 break;
2592 tag = CMDTAG_DROP_DOMAIN;
2593 break;
2595 tag = CMDTAG_DROP_COLLATION;
2596 break;
2598 tag = CMDTAG_DROP_CONVERSION;
2599 break;
2601 tag = CMDTAG_DROP_SCHEMA;
2602 break;
2604 tag = CMDTAG_DROP_TEXT_SEARCH_PARSER;
2605 break;
2607 tag = CMDTAG_DROP_TEXT_SEARCH_DICTIONARY;
2608 break;
2610 tag = CMDTAG_DROP_TEXT_SEARCH_TEMPLATE;
2611 break;
2613 tag = CMDTAG_DROP_TEXT_SEARCH_CONFIGURATION;
2614 break;
2616 tag = CMDTAG_DROP_FOREIGN_TABLE;
2617 break;
2619 tag = CMDTAG_DROP_EXTENSION;
2620 break;
2622 tag = CMDTAG_DROP_FUNCTION;
2623 break;
2625 tag = CMDTAG_DROP_PROCEDURE;
2626 break;
2628 tag = CMDTAG_DROP_ROUTINE;
2629 break;
2631 tag = CMDTAG_DROP_AGGREGATE;
2632 break;
2634 tag = CMDTAG_DROP_OPERATOR;
2635 break;
2637 tag = CMDTAG_DROP_LANGUAGE;
2638 break;
2640 tag = CMDTAG_DROP_CAST;
2641 break;
2643 tag = CMDTAG_DROP_TRIGGER;
2644 break;
2646 tag = CMDTAG_DROP_EVENT_TRIGGER;
2647 break;
2649 tag = CMDTAG_DROP_RULE;
2650 break;
2652 tag = CMDTAG_DROP_FOREIGN_DATA_WRAPPER;
2653 break;
2655 tag = CMDTAG_DROP_SERVER;
2656 break;
2658 tag = CMDTAG_DROP_OPERATOR_CLASS;
2659 break;
2661 tag = CMDTAG_DROP_OPERATOR_FAMILY;
2662 break;
2664 tag = CMDTAG_DROP_POLICY;
2665 break;
2667 tag = CMDTAG_DROP_TRANSFORM;
2668 break;
2670 tag = CMDTAG_DROP_ACCESS_METHOD;
2671 break;
2673 tag = CMDTAG_DROP_PUBLICATION;
2674 break;
2676 tag = CMDTAG_DROP_STATISTICS;
2677 break;
2678 default:
2679 tag = CMDTAG_UNKNOWN;
2680 }
2681 break;
2682
2684 tag = CMDTAG_TRUNCATE_TABLE;
2685 break;
2686
2688 tag = CMDTAG_COMMENT;
2689 break;
2690
2692 tag = CMDTAG_SECURITY_LABEL;
2693 break;
2694
2696 tag = CMDTAG_COPY;
2697 break;
2698
2700
2701 /*
2702 * When the column is renamed, the command tag is created from its
2703 * relation type
2704 */
2706 ((RenameStmt *) parsetree)->relationType :
2707 ((RenameStmt *) parsetree)->renameType);
2708 break;
2709
2712 break;
2713
2716 break;
2717
2720 break;
2721
2724 break;
2725
2728 break;
2729
2731 tag = CMDTAG_ALTER_DOMAIN;
2732 break;
2733
2736 {
2738 tag = CMDTAG_ALTER_FUNCTION;
2739 break;
2741 tag = CMDTAG_ALTER_PROCEDURE;
2742 break;
2744 tag = CMDTAG_ALTER_ROUTINE;
2745 break;
2746 default:
2747 tag = CMDTAG_UNKNOWN;
2748 }
2749 break;
2750
2752 {
2754
2756 }
2757 break;
2758
2760 {
2762
2764 }
2765 break;
2766
2768 tag = CMDTAG_ALTER_DEFAULT_PRIVILEGES;
2769 break;
2770
2773 {
2775 tag = CMDTAG_CREATE_AGGREGATE;
2776 break;
2778 tag = CMDTAG_CREATE_OPERATOR;
2779 break;
2781 tag = CMDTAG_CREATE_TYPE;
2782 break;
2784 tag = CMDTAG_CREATE_TEXT_SEARCH_PARSER;
2785 break;
2787 tag = CMDTAG_CREATE_TEXT_SEARCH_DICTIONARY;
2788 break;
2790 tag = CMDTAG_CREATE_TEXT_SEARCH_TEMPLATE;
2791 break;
2793 tag = CMDTAG_CREATE_TEXT_SEARCH_CONFIGURATION;
2794 break;
2796 tag = CMDTAG_CREATE_COLLATION;
2797 break;
2799 tag = CMDTAG_CREATE_ACCESS_METHOD;
2800 break;
2801 default:
2802 tag = CMDTAG_UNKNOWN;
2803 }
2804 break;
2805
2807 tag = CMDTAG_CREATE_TYPE;
2808 break;
2809
2811 tag = CMDTAG_CREATE_TYPE;
2812 break;
2813
2815 tag = CMDTAG_CREATE_TYPE;
2816 break;
2817
2819 tag = CMDTAG_ALTER_TYPE;
2820 break;
2821
2823 tag = CMDTAG_CREATE_VIEW;
2824 break;
2825
2828 tag = CMDTAG_CREATE_PROCEDURE;
2829 else
2830 tag = CMDTAG_CREATE_FUNCTION;
2831 break;
2832
2834 tag = CMDTAG_CREATE_INDEX;
2835 break;
2836
2838 tag = CMDTAG_CREATE_RULE;
2839 break;
2840
2842 tag = CMDTAG_CREATE_SEQUENCE;
2843 break;
2844
2846 tag = CMDTAG_ALTER_SEQUENCE;
2847 break;
2848
2850 tag = CMDTAG_DO;
2851 break;
2852
2854 tag = CMDTAG_CREATE_DATABASE;
2855 break;
2856
2860 tag = CMDTAG_ALTER_DATABASE;
2861 break;
2862
2864 tag = CMDTAG_DROP_DATABASE;
2865 break;
2866
2868 tag = CMDTAG_NOTIFY;
2869 break;
2870
2872 tag = CMDTAG_LISTEN;
2873 break;
2874
2876 tag = CMDTAG_UNLISTEN;
2877 break;
2878
2880 tag = CMDTAG_LOAD;
2881 break;
2882
2884 tag = CMDTAG_CALL;
2885 break;
2886
2889 tag = CMDTAG_VACUUM;
2890 else
2891 tag = CMDTAG_ANALYZE;
2892 break;
2893
2896 tag = CMDTAG_CLUSTER;
2897 else
2898 tag = CMDTAG_REPACK;
2899 break;
2900
2902 tag = CMDTAG_EXPLAIN;
2903 break;
2904
2907 {
2910 tag = CMDTAG_SELECT_INTO;
2911 else
2912 tag = CMDTAG_CREATE_TABLE_AS;
2913 break;
2915 tag = CMDTAG_CREATE_MATERIALIZED_VIEW;
2916 break;
2917 default:
2918 tag = CMDTAG_UNKNOWN;
2919 }
2920 break;
2921
2923 tag = CMDTAG_REFRESH_MATERIALIZED_VIEW;
2924 break;
2925
2927 tag = CMDTAG_ALTER_SYSTEM;
2928 break;
2929
2932 {
2937 tag = CMDTAG_SET;
2938 break;
2941 tag = CMDTAG_RESET;
2942 break;
2943 default:
2944 tag = CMDTAG_UNKNOWN;
2945 }
2946 break;
2947
2949 tag = CMDTAG_SHOW;
2950 break;
2951
2954 {
2956 tag = CMDTAG_DISCARD_ALL;
2957 break;
2959 tag = CMDTAG_DISCARD_PLANS;
2960 break;
2962 tag = CMDTAG_DISCARD_TEMP;
2963 break;
2965 tag = CMDTAG_DISCARD_SEQUENCES;
2966 break;
2967 default:
2968 tag = CMDTAG_UNKNOWN;
2969 }
2970 break;
2971
2973 tag = CMDTAG_CREATE_PROPERTY_GRAPH;
2974 break;
2975
2977 tag = CMDTAG_ALTER_PROPERTY_GRAPH;
2978 break;
2979
2981 tag = CMDTAG_CREATE_TRANSFORM;
2982 break;
2983
2985 tag = CMDTAG_CREATE_TRIGGER;
2986 break;
2987
2989 tag = CMDTAG_CREATE_EVENT_TRIGGER;
2990 break;
2991
2993 tag = CMDTAG_ALTER_EVENT_TRIGGER;
2994 break;
2995
2997 tag = CMDTAG_CREATE_LANGUAGE;
2998 break;
2999
3001 tag = CMDTAG_CREATE_ROLE;
3002 break;
3003
3005 tag = CMDTAG_ALTER_ROLE;
3006 break;
3007
3009 tag = CMDTAG_ALTER_ROLE;
3010 break;
3011
3013 tag = CMDTAG_DROP_ROLE;
3014 break;
3015
3017 tag = CMDTAG_DROP_OWNED;
3018 break;
3019
3021 tag = CMDTAG_REASSIGN_OWNED;
3022 break;
3023
3025 tag = CMDTAG_LOCK_TABLE;
3026 break;
3027
3029 tag = CMDTAG_SET_CONSTRAINTS;
3030 break;
3031
3033 tag = CMDTAG_CHECKPOINT;
3034 break;
3035
3037 tag = CMDTAG_REINDEX;
3038 break;
3039
3041 tag = CMDTAG_CREATE_CONVERSION;
3042 break;
3043
3045 tag = CMDTAG_CREATE_CAST;
3046 break;
3047
3049 tag = CMDTAG_CREATE_OPERATOR_CLASS;
3050 break;
3051
3053 tag = CMDTAG_CREATE_OPERATOR_FAMILY;
3054 break;
3055
3057 tag = CMDTAG_ALTER_OPERATOR_FAMILY;
3058 break;
3059
3061 tag = CMDTAG_ALTER_OPERATOR;
3062 break;
3063
3065 tag = CMDTAG_ALTER_TYPE;
3066 break;
3067
3069 tag = CMDTAG_ALTER_TEXT_SEARCH_DICTIONARY;
3070 break;
3071
3073 tag = CMDTAG_ALTER_TEXT_SEARCH_CONFIGURATION;
3074 break;
3075
3077 tag = CMDTAG_CREATE_POLICY;
3078 break;
3079
3081 tag = CMDTAG_ALTER_POLICY;
3082 break;
3083
3085 tag = CMDTAG_CREATE_ACCESS_METHOD;
3086 break;
3087
3089 tag = CMDTAG_CREATE_PUBLICATION;
3090 break;
3091
3093 tag = CMDTAG_ALTER_PUBLICATION;
3094 break;
3095
3097 tag = CMDTAG_CREATE_SUBSCRIPTION;
3098 break;
3099
3101 tag = CMDTAG_ALTER_SUBSCRIPTION;
3102 break;
3103
3105 tag = CMDTAG_DROP_SUBSCRIPTION;
3106 break;
3107
3109 tag = CMDTAG_ALTER_COLLATION;
3110 break;
3111
3113 tag = CMDTAG_PREPARE;
3114 break;
3115
3117 tag = CMDTAG_EXECUTE;
3118 break;
3119
3121 tag = CMDTAG_CREATE_STATISTICS;
3122 break;
3123
3125 tag = CMDTAG_ALTER_STATISTICS;
3126 break;
3127
3129 {
3131
3133 tag = CMDTAG_DEALLOCATE_ALL;
3134 else
3135 tag = CMDTAG_DEALLOCATE;
3136 }
3137 break;
3138
3140 tag = CMDTAG_WAIT;
3141 break;
3142
3143 /* already-planned queries */
3145 {
3147
3149 {
3151
3152 /*
3153 * We take a little extra care here so that the result
3154 * will be useful for complaints about read-only
3155 * statements
3156 */
3158 {
3159 /* not 100% but probably close enough */
3161 {
3163 tag = CMDTAG_SELECT_FOR_KEY_SHARE;
3164 break;
3166 tag = CMDTAG_SELECT_FOR_SHARE;
3167 break;
3169 tag = CMDTAG_SELECT_FOR_NO_KEY_UPDATE;
3170 break;
3172 tag = CMDTAG_SELECT_FOR_UPDATE;
3173 break;
3174 default:
3175 tag = CMDTAG_SELECT;
3176 break;
3177 }
3178 }
3179 else
3180 tag = CMDTAG_SELECT;
3181 break;
3183 tag = CMDTAG_UPDATE;
3184 break;
3186 tag = CMDTAG_INSERT;
3187 break;
3189 tag = CMDTAG_DELETE;
3190 break;
3192 tag = CMDTAG_MERGE;
3193 break;
3196 break;
3197 default:
3200 tag = CMDTAG_UNKNOWN;
3201 break;
3202 }
3203 }
3204 break;
3205
3206 /* parsed-and-rewritten-but-not-planned queries */
3208 {
3210
3212 {
3214
3215 /*
3216 * We take a little extra care here so that the result
3217 * will be useful for complaints about read-only
3218 * statements
3219 */
3221 {
3222 /* not 100% but probably close enough */
3224 {
3226 tag = CMDTAG_SELECT_FOR_KEY_SHARE;
3227 break;
3229 tag = CMDTAG_SELECT_FOR_SHARE;
3230 break;
3232 tag = CMDTAG_SELECT_FOR_NO_KEY_UPDATE;
3233 break;
3235 tag = CMDTAG_SELECT_FOR_UPDATE;
3236 break;
3237 default:
3238 tag = CMDTAG_UNKNOWN;
3239 break;
3240 }
3241 }
3242 else
3243 tag = CMDTAG_SELECT;
3244 break;
3246 tag = CMDTAG_UPDATE;
3247 break;
3249 tag = CMDTAG_INSERT;
3250 break;
3252 tag = CMDTAG_DELETE;
3253 break;
3255 tag = CMDTAG_MERGE;
3256 break;
3259 break;
3260 default:
3263 tag = CMDTAG_UNKNOWN;
3264 break;
3265 }
3266 }
3267 break;
3268
3269 default:
3272 tag = CMDTAG_UNKNOWN;
3273 break;
3274 }
3275
3276 return tag;
3277}
Definition parsenodes.h:3706
Definition parsenodes.h:3789
Definition parsenodes.h:3803
Definition parsenodes.h:3817
Definition parsenodes.h:3019
Definition parsenodes.h:2514
Definition parsenodes.h:3520
Definition parsenodes.h:3672
Definition parsenodes.h:4143
Definition parsenodes.h:4394
Definition parsenodes.h:3355
Definition parsenodes.h:4188
Definition parsenodes.h:3441
Definition parsenodes.h:3559
Definition parsenodes.h:2750
Definition parsenodes.h:2685
Definition plannodes.h:1606
Definition parsenodes.h:118
Definition parsenodes.h:2188
Definition parsenodes.h:3771
Definition parsenodes.h:4105
Definition parsenodes.h:1695
Definition parsenodes.h:4071
Definition parsenodes.h:2812
static CommandTag AlterObjectTypeCommandTag(ObjectType objtype)
Definition utility.c:2236
References AlterObjectTypeCommandTag(), CMD_DELETE, CMD_INSERT, CMD_MERGE, CMD_SELECT, CMD_UPDATE, CMD_UTILITY, CreateCommandTag(), DISCARD_ALL, DISCARD_PLANS, DISCARD_SEQUENCES, DISCARD_TEMP, elog, fb(), 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_PROPGRAPH, 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, REPACK_COMMAND_CLUSTER, 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()
Definition at line 2008 of file utility.c.
2009{
2011 {
2015 "DROP INDEX CONCURRENTLY");
2016 pg_fallthrough;
2017
2025 break;
2026 default:
2028 break;
2029 }
2030}
void PreventInTransactionBlock(bool isTopLevel, const char *stmtType)
Definition xact.c:3698
References fb(), OBJECT_FOREIGN_TABLE, OBJECT_INDEX, OBJECT_MATVIEW, OBJECT_PROPGRAPH, OBJECT_SEQUENCE, OBJECT_TABLE, OBJECT_VIEW, pg_fallthrough, PreventInTransactionBlock(), RemoveObjects(), RemoveRelations(), and stmt.
Referenced by ProcessUtilitySlow(), and standard_ProcessUtility().
◆ GetCommandLogLevel()
| LogStmtLevel GetCommandLogLevel | ( | Node * | parsetree | ) |
Definition at line 3290 of file utility.c.
3291{
3293
3295 {
3296 /* recurse if we're given a RawStmt */
3299 break;
3300
3301 /* raw plannable queries */
3307 break;
3308
3312 else
3314 break;
3315
3318 break;
3319
3320 /* utility statements --- same whether raw or cooked */
3323 break;
3324
3327 break;
3328
3331 break;
3332
3335 break;
3336
3339 break;
3340
3344 break;
3345
3350 break;
3351
3356 break;
3357
3367 break;
3368
3371 break;
3372
3375 break;
3376
3379 break;
3380
3383 break;
3384
3388 else
3390 break;
3391
3393 {
3395
3396 /* Look through a PREPARE to the contained stmt */
3398 }
3399 break;
3400
3402 {
3405
3406 /* Look through an EXECUTE to the referenced stmt */
3410 else
3412 }
3413 break;
3414
3417 break;
3418
3421 break;
3422
3425 break;
3426
3429 break;
3430
3433 break;
3434
3437 break;
3438
3441 break;
3442
3446 break;
3447
3450 break;
3451
3454 break;
3455
3458 break;
3459
3462 break;
3463
3466 break;
3467
3470 break;
3471
3474 break;
3475
3478 break;
3479
3482 break;
3483
3486 break;
3487
3490 break;
3491
3494 break;
3495
3498 break;
3499
3502 break;
3503
3506 break;
3507
3510 break;
3511
3514 break;
3515
3518 break;
3519
3524 break;
3525
3528 break;
3529
3532 break;
3533
3536 break;
3537
3540 break;
3541
3544 break;
3545
3548 break;
3549
3552 break;
3553
3556 break;
3557
3559 {
3563
3564 /* Look through an EXPLAIN ANALYZE to the contained stmt */
3566 {
3568
3571 /* don't "break", as explain.c will use the last value */
3572 }
3575
3576 /* Plain EXPLAIN isn't so interesting */
3578 }
3579 break;
3580
3583 break;
3584
3587 break;
3588
3591 break;
3592
3595 break;
3596
3599 break;
3600
3603 break;
3604
3607 break;
3608
3611 break;
3612
3615 break;
3616
3619 break;
3620
3623 break;
3624
3627 break;
3628
3631 break;
3632
3635 break;
3636
3639 break;
3640
3643 break;
3644
3647 break;
3648
3651 break;
3652
3655 break;
3656
3659 break;
3660
3663 break;
3664
3667 break;
3668
3671 break;
3672
3675 break;
3676
3679 break;
3680
3683 break;
3684
3687 break;
3688
3691 break;
3692
3695 break;
3696
3699 break;
3700
3703 break;
3704
3707 break;
3708
3711 break;
3712
3715 break;
3716
3719 break;
3720
3723 break;
3724
3727 break;
3728
3731 break;
3732
3735 break;
3736
3739 break;
3740
3743 break;
3744
3747 break;
3748
3751 break;
3752
3753 /* already-planned queries */
3755 {
3757
3759 {
3762 break;
3763
3769 break;
3770
3773 break;
3774
3775 default:
3779 break;
3780 }
3781 }
3782 break;
3783
3784 /* parsed-and-rewritten-but-not-planned queries */
3786 {
3788
3790 {
3793 break;
3794
3800 break;
3801
3804 break;
3805
3806 default:
3810 break;
3811 }
3812 }
3813 break;
3814
3815 default:
3819 break;
3820 }
3821
3823}
PreparedStatement * FetchPreparedStatement(const char *stmt_name, bool throwError)
Definition prepare.c:436
struct parser_state ps
Definition parsenodes.h:857
Definition parsenodes.h:4382
Definition parsenodes.h:4123
Definition parsenodes.h:4368
Definition prepare.h:29
Definition parsenodes.h:2289
Definition pg_list.h:46
References analyze(), CMD_DELETE, CMD_INSERT, CMD_MERGE, CMD_SELECT, CMD_UPDATE, CMD_UTILITY, defGetBoolean(), DefElem::defname, elog, fb(), FetchPreparedStatement(), GetCommandLogLevel(), lfirst, LOGSTMT_ALL, LOGSTMT_DDL, LOGSTMT_MOD, nodeTag, ps, stmt, and WARNING.
Referenced by check_log_statement(), and GetCommandLogLevel().
◆ PreventCommandDuringRecovery()
Definition at line 446 of file utility.c.
References ereport, errcode(), errmsg, ERROR, fb(), and RecoveryInProgress().
Referenced by pg_current_xact_id(), pg_notify(), and standard_ProcessUtility().
◆ PreventCommandIfParallelMode()
Definition at line 427 of file utility.c.
References ereport, errcode(), errmsg, ERROR, fb(), and IsInParallelMode().
Referenced by ExecCheckXactReadOnly(), nextval_internal(), SetSequence(), and standard_ProcessUtility().
◆ PreventCommandIfReadOnly()
Definition at line 409 of file utility.c.
References ereport, errcode(), errmsg, ERROR, fb(), 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 504 of file utility.c.
512{
517
518 /*
519 * We provide a function hook variable that lets loadable plugins get
520 * control when ProcessUtility is called. Such a plugin would normally
521 * call standard_ProcessUtility().
522 */
524 (*ProcessUtility_hook) (pstmt, queryString, readOnlyTree,
525 context, params, queryEnv,
526 dest, qc);
527 else
529 context, params, queryEnv,
530 dest, qc);
531}
void standard_ProcessUtility(PlannedStmt *pstmt, const char *queryString, bool readOnlyTree, ProcessUtilityContext context, ParamListInfo params, QueryEnvironment *queryEnv, DestReceiver *dest, QueryCompletion *qc)
Definition utility.c:548
References Assert, CMD_UTILITY, QueryCompletion::commandTag, PlannedStmt::commandType, fb(), 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 1971 of file utility.c.
1972{
1973 PlannedStmt *wrapper;
1974
1975 /*
1976 * For event triggers, we must "close" the current complex-command set,
1977 * and start a new one afterwards; this is needed to ensure the ordering
1978 * of command events is consistent with the way they were executed.
1979 */
1980 EventTriggerAlterTableEnd();
1981
1982 /* Create a suitable wrapper */
1990
1991 ProcessUtility(wrapper,
1992 context->queryString,
1993 false,
1995 context->params,
1996 context->queryEnv,
1997 None_Receiver,
1998 NULL);
1999
2002}
void EventTriggerAlterTableRelid(Oid objectId)
Definition event_trigger.c:1789
void EventTriggerAlterTableStart(const Node *parsetree)
Definition event_trigger.c:1755
void ProcessUtility(PlannedStmt *pstmt, const char *queryString, bool readOnlyTree, ProcessUtilityContext context, ParamListInfo params, QueryEnvironment *queryEnv, DestReceiver *dest, QueryCompletion *qc)
Definition utility.c:504
References PlannedStmt::canSetTag, CMD_UTILITY, PlannedStmt::commandType, EventTriggerAlterTableEnd(), EventTriggerAlterTableRelid(), EventTriggerAlterTableStart(), fb(), 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 1094 of file utility.c.
1102{
1108 ObjectAddress address;
1110
1111 /* All event trigger calls are done only when isCompleteQuery is true */
1113
1114 /* PG_TRY block is to ensure we call EventTriggerEndCompleteQuery */
1115 PG_TRY();
1116 {
1118 EventTriggerDDLCommandStart(parsetree);
1119
1121 {
1122 /*
1123 * relation and attribute manipulation
1124 */
1126 CreateSchemaCommand(pstate,
1127 (CreateSchemaStmt *) parsetree,
1128 pstmt->stmt_location,
1129 pstmt->stmt_len);
1130
1131 /*
1132 * EventTriggerCollectSimpleCommand called by
1133 * CreateSchemaCommand
1134 */
1136 break;
1137
1140 {
1141 List *stmts;
1143
1144 /* Run parse analysis ... */
1146 queryString);
1147
1148 /*
1149 * ... and do it. We can't use foreach() because we may
1150 * modify the list midway through, so pick off the
1151 * elements one at a time, the hard way.
1152 */
1154 {
1156
1157 stmts = list_delete_first(stmts);
1158
1160 {
1164
1165 /* Remember transformed RangeVar for LIKE */
1167
1168 /* Create the table itself */
1170 RELKIND_RELATION,
1172 queryString);
1173 EventTriggerCollectSimpleCommand(address,
1174 secondaryObject,
1175 stmt);
1176
1177 /*
1178 * Let NewRelationCreateToastTable decide if this
1179 * one needs a secondary relation too.
1180 */
1181 CommandCounterIncrement();
1182
1183 /*
1184 * parse and validate reloptions for the toast
1185 * table
1186 */
1188 cstmt->options,
1189 "toast",
1190 validnsps,
1191 true,
1192 false);
1194 toast_options,
1195 true);
1196
1198 toast_options);
1199 }
1201 {
1203
1204 /* Remember transformed RangeVar for LIKE */
1206
1207 /* Create the table itself */
1209 RELKIND_FOREIGN_TABLE,
1211 queryString);
1213 address.objectId);
1214 EventTriggerCollectSimpleCommand(address,
1215 secondaryObject,
1216 stmt);
1217 }
1219 {
1220 /*
1221 * Do delayed processing of LIKE options. This
1222 * will result in additional sub-statements for us
1223 * to process. Those should get done before any
1224 * remaining actions, so prepend them to "stmts".
1225 */
1228
1230
1233 }
1234 else
1235 {
1236 /*
1237 * Recurse for anything else. Note the recursive
1238 * call will stash the objects so created into our
1239 * event trigger context.
1240 */
1241 PlannedStmt *wrapper;
1242
1250
1251 ProcessUtility(wrapper,
1252 queryString,
1253 false,
1255 params,
1256 NULL,
1257 None_Receiver,
1258 NULL);
1259 }
1260
1261 /* Need CCI between commands */
1263 CommandCounterIncrement();
1264 }
1265
1266 /*
1267 * The multiple commands generated here are stashed
1268 * individually, so disable collection below.
1269 */
1271 }
1272 break;
1273
1275 {
1277 Oid relid;
1278 LOCKMODE lockmode;
1279 ListCell *cell;
1280
1281 /*
1282 * Disallow ALTER TABLE .. DETACH CONCURRENTLY in a
1283 * transaction block or function. (Perhaps it could be
1284 * allowed in a procedure, but don't hold your breath.)
1285 */
1287 {
1289
1290 /* Disallow DETACH CONCURRENTLY in a transaction block */
1292 {
1295 "ALTER TABLE ... DETACH CONCURRENTLY");
1296 }
1297 }
1298
1299 /*
1300 * Figure out lock mode, and acquire lock. This also does
1301 * basic permissions checks, so that we won't wait for a
1302 * lock on (for example) a relation on which we have no
1303 * permissions.
1304 */
1307
1309 {
1311
1312 /* Set up info needed for recursive callbacks ... */
1314 atcontext.queryString = queryString;
1315 atcontext.relid = relid;
1316 atcontext.params = params;
1317 atcontext.queryEnv = queryEnv;
1318
1319 /* ... ensure we have an event trigger context ... */
1320 EventTriggerAlterTableStart(parsetree);
1321 EventTriggerAlterTableRelid(relid);
1322
1323 /* ... and do it */
1325
1326 /* done */
1327 EventTriggerAlterTableEnd();
1328 }
1329 else
1332 atstmt->relation->relname)));
1333 }
1334
1335 /* ALTER TABLE stashes commands internally */
1337 break;
1338
1340 {
1342
1343 /*
1344 * Some or all of these functions are recursive to cover
1345 * inherited things, so permission checks are done there.
1346 */
1348 {
1350
1351 /*
1352 * Recursively alter column default for table and,
1353 * if requested, for descendants
1354 */
1355 address =
1357 stmt->def);
1358 break;
1360 address =
1362 false);
1363 break;
1365 address =
1367 true);
1368 break;
1370 address =
1372 stmt->def,
1373 &secondaryObject);
1374 break;
1376 address =
1378 stmt->name,
1379 stmt->behavior,
1380 stmt->missing_ok);
1381 break;
1383 address =
1385 stmt->name);
1386 break;
1387 default: /* oops */
1390 break;
1391 }
1392 }
1393 break;
1394
1395 /*
1396 * ************* object creation / destruction **************
1397 */
1399 {
1401
1403 {
1405 address =
1407 stmt->oldstyle,
1408 stmt->definition,
1409 stmt->replace);
1410 break;
1414 stmt->definition);
1415 break;
1418 address = DefineType(pstate,
1419 stmt->defnames,
1420 stmt->definition);
1421 break;
1425 stmt->definition);
1426 break;
1430 stmt->definition);
1431 break;
1435 stmt->definition);
1436 break;
1440 stmt->definition,
1441 &secondaryObject);
1442 break;
1445 address = DefineCollation(pstate,
1446 stmt->defnames,
1447 stmt->definition,
1448 stmt->if_not_exists);
1449 break;
1450 default:
1453 break;
1454 }
1455 }
1456 break;
1457
1459 {
1461 Oid relid;
1462 LOCKMODE lockmode;
1463 int nparts = -1;
1465
1468 "CREATE INDEX CONCURRENTLY");
1469
1470 /*
1471 * Look up the relation OID just once, right here at the
1472 * beginning, so that we don't end up repeating the name
1473 * lookup later and latching onto a different relation
1474 * partway through. To avoid lock upgrade hazards, it's
1475 * important that we take the strongest lock that will
1476 * eventually be needed here, so the lockmode calculation
1477 * needs to match what DefineIndex() does.
1478 */
1480 : ShareLock;
1481 relid =
1483 0,
1485 NULL);
1486
1487 /*
1488 * CREATE INDEX on partitioned tables (but not regular
1489 * inherited tables) recurses to partitions, so we must
1490 * acquire locks early to avoid deadlocks.
1491 *
1492 * We also take the opportunity to verify that all
1493 * partitions are something we can put an index on, to
1494 * avoid building some indexes only to fail later. While
1495 * at it, also count the partitions, so that DefineIndex
1496 * needn't do a duplicative find_all_inheritors search.
1497 */
1500 {
1503
1506 {
1509
1511 relkind != RELKIND_MATVIEW &&
1512 relkind != RELKIND_PARTITIONED_TABLE &&
1513 relkind != RELKIND_FOREIGN_TABLE)
1515 relkind, stmt->relation->relname);
1516
1522 stmt->relation->relname),
1524 stmt->relation->relname)));
1525 }
1526 /* count direct and indirect children, but not rel */
1529 }
1530
1531 /*
1532 * If the IndexStmt is already transformed, it must have
1533 * come from generateClonedIndexStmt, which in current
1534 * usage means it came from expandTableLikeClause rather
1535 * than from original parse analysis. And that means we
1536 * must treat it like ALTER TABLE ADD INDEX, not CREATE.
1537 * (This is a bit grotty, but currently it doesn't seem
1538 * worth adding a separate bool field for the purpose.)
1539 */
1541
1542 /* Run parse analysis ... */
1544
1545 /* ... and do it */
1546 EventTriggerAlterTableStart(parsetree);
1547 address =
1548 DefineIndex(pstate,
1549 relid, /* OID of heap relation */
1550 stmt,
1554 nparts, /* # of partitions, or -1 */
1555 is_alter_table,
1556 true, /* check_rights */
1557 true, /* check_not_in_use */
1558 false, /* skip_build */
1559 false); /* quiet */
1560
1561 /*
1562 * Add the CREATE INDEX node itself to stash right away;
1563 * if there were any commands stashed in the ALTER TABLE
1564 * code, we need them to appear after this one.
1565 */
1566 EventTriggerCollectSimpleCommand(address, secondaryObject,
1567 parsetree);
1569 EventTriggerAlterTableEnd();
1570 }
1571 break;
1572
1575
1576 /* EventTriggerCollectSimpleCommand is called directly */
1578 break;
1579
1582 break;
1583
1586 break;
1587
1590 &secondaryObject);
1591 break;
1592
1595 break;
1596
1599 break;
1600
1603 break;
1604
1607 break;
1608
1611 break;
1612
1615 break;
1616
1619 /* no commands stashed for DROP */
1621 break;
1622
1625 /* commands are stashed inside ImportForeignSchema */
1627 break;
1628
1630 {
1632
1634 stmt->coldeflist);
1635 }
1636 break;
1637
1640 break;
1641
1644 break;
1645
1648 break;
1649
1651 EventTriggerAlterTableStart(parsetree);
1654 EventTriggerCollectSimpleCommand(address, secondaryObject,
1655 parsetree);
1656 /* stashed internally */
1658 EventTriggerAlterTableEnd();
1659 break;
1660
1663 break;
1664
1667 break;
1668
1671 break;
1672
1675 break;
1676
1679 break;
1680
1683 params, queryEnv, qc);
1684 break;
1685
1687
1688 /*
1689 * REFRESH CONCURRENTLY executes some DDL commands internally.
1690 * Inhibit DDL command collection here to avoid those commands
1691 * from showing up in the deparsed command queue. The refresh
1692 * command itself is queued, which is enough.
1693 */
1695 PG_TRY(2);
1696 {
1698 queryString, qc);
1699 }
1700 PG_FINALLY(2);
1701 {
1703 }
1704 PG_END_TRY(2);
1705 break;
1706
1712 break;
1713
1716 break;
1717
1720 break;
1721
1724 break;
1725
1728 break;
1729
1732 /* command is stashed in DefineOpClass */
1734 break;
1735
1738
1739 /*
1740 * DefineOpFamily calls EventTriggerCollectSimpleCommand
1741 * directly.
1742 */
1744 break;
1745
1748 break;
1749
1752 break;
1753
1756 break;
1757
1760 /* commands are stashed in AlterOpFamily */
1762 break;
1763
1766 break;
1767
1770
1771 /*
1772 * Commands are stashed in MakeConfigurationMapping and
1773 * DropConfigurationMapping, which are called from
1774 * AlterTSConfiguration
1775 */
1777 break;
1778
1781 /* commands are stashed in AlterTableMoveAll */
1783 break;
1784
1787 /* no commands stashed for DROP */
1789 break;
1790
1793 break;
1794
1796 address =
1798 &secondaryObject);
1799 break;
1800
1802 address =
1804 &secondaryObject);
1805 break;
1806
1809 break;
1810
1813 break;
1814
1817 break;
1818
1821 break;
1822
1825 /* commands are stashed in ExecGrantStmt_oids */
1827 break;
1828
1831 /* no commands stashed for DROP */
1833 break;
1834
1839 break;
1840
1843 break;
1844
1847 break;
1848
1851 break;
1852
1855 break;
1856
1859 break;
1860
1863
1864 /*
1865 * AlterPublication calls EventTriggerCollectSimpleCommand
1866 * directly
1867 */
1869 break;
1870
1872 address = CreateSubscription(pstate,
1873 (CreateSubscriptionStmt *) parsetree,
1874 isTopLevel);
1875 break;
1876
1878 address = AlterSubscription(pstate,
1879 (AlterSubscriptionStmt *) parsetree,
1880 isTopLevel);
1881 break;
1882
1885 /* no commands stashed for DROP */
1887 break;
1888
1890 {
1891 Oid relid;
1894
1899
1900 /*
1901 * CREATE STATISTICS will influence future execution plans
1902 * but does not interfere with currently executing plans.
1903 * So it should be enough to take ShareUpdateExclusiveLock
1904 * on relation, conflicting with ANALYZE and other DDL
1905 * that sets statistical information, but not with normal
1906 * queries.
1907 *
1908 * XXX RangeVarCallbackOwnsRelation not needed here, to
1909 * keep the same behavior as before.
1910 */
1912
1913 /* Run parse analysis ... */
1915
1917 }
1918 break;
1919
1922 break;
1923
1926 break;
1927
1928 default:
1931 break;
1932 }
1933
1934 /*
1935 * Remember the object so that ddl_command_end event triggers have
1936 * access to it.
1937 */
1939 EventTriggerCollectSimpleCommand(address, secondaryObject,
1940 parsetree);
1941
1943 {
1944 EventTriggerSQLDrop(parsetree);
1945 EventTriggerDDLCommandEnd(parsetree);
1946 }
1947 }
1948 PG_FINALLY();
1949 {
1951 EventTriggerEndCompleteQuery();
1952 }
1953 PG_END_TRY();
1954}
void ExecAlterDefaultPrivilegesStmt(ParseState *pstate, AlterDefaultPrivilegesStmt *stmt)
Definition aclchk.c:915
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:466
ObjectAddress ExecAlterObjectSchemaStmt(AlterObjectSchemaStmt *stmt, ObjectAddress *oldSchemaAddr)
Definition alter.c:529
ObjectAddress DefineCollation(ParseState *pstate, List *names, List *parameters, bool if_not_exists)
Definition collationcmds.c:58
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:33
ObjectAddress ExecCreateTableAs(ParseState *pstate, CreateTableAsStmt *stmt, ParamListInfo params, QueryEnvironment *queryEnv, QueryCompletion *qc)
Definition createas.c:223
int errdetail(const char *fmt,...) pg_attribute_printf(1
void EventTriggerUndoInhibitCommandCollection(void)
Definition event_trigger.c:1695
void EventTriggerDDLCommandStart(Node *parsetree)
Definition event_trigger.c:727
void EventTriggerInhibitCommandCollection(void)
Definition event_trigger.c:1683
bool EventTriggerBeginCompleteQuery(void)
Definition event_trigger.c:1185
void EventTriggerCollectAlterDefPrivs(const AlterDefaultPrivilegesStmt *stmt)
Definition event_trigger.c:2029
void EventTriggerDDLCommandEnd(Node *parsetree)
Definition event_trigger.c:778
void EventTriggerCollectSimpleCommand(ObjectAddress address, ObjectAddress secondaryObject, const Node *parsetree)
Definition event_trigger.c:1717
ObjectAddress CreateExtension(ParseState *pstate, CreateExtensionStmt *stmt)
Definition extension.c:2147
ObjectAddress ExecAlterExtensionStmt(ParseState *pstate, AlterExtensionStmt *stmt)
Definition extension.c:3471
ObjectAddress ExecAlterExtensionContentsStmt(AlterExtensionContentsStmt *stmt, ObjectAddress *objAddr)
Definition extension.c:3776
void ImportForeignSchema(ImportForeignSchemaStmt *stmt)
Definition foreigncmds.c:1590
ObjectAddress AlterForeignServer(AlterForeignServerStmt *stmt)
Definition foreigncmds.c:1080
ObjectAddress AlterForeignDataWrapper(ParseState *pstate, AlterFdwStmt *stmt)
Definition foreigncmds.c:736
ObjectAddress CreateForeignServer(CreateForeignServerStmt *stmt)
Definition foreigncmds.c:944
ObjectAddress CreateForeignDataWrapper(ParseState *pstate, CreateFdwStmt *stmt)
Definition foreigncmds.c:608
ObjectAddress AlterUserMapping(AlterUserMappingStmt *stmt)
Definition foreigncmds.c:1332
void CreateForeignTable(CreateForeignTableStmt *stmt, Oid relid)
Definition foreigncmds.c:1510
ObjectAddress CreateUserMapping(CreateUserMappingStmt *stmt)
Definition foreigncmds.c:1206
ObjectAddress CreateFunction(ParseState *pstate, CreateFunctionStmt *stmt)
Definition functioncmds.c:1029
ObjectAddress AlterFunction(ParseState *pstate, AlterFunctionStmt *stmt)
Definition functioncmds.c:1364
ObjectAddress CreateTransform(CreateTransformStmt *stmt)
Definition functioncmds.c:1835
void ExecReindex(ParseState *pstate, const ReindexStmt *stmt, bool isTopLevel)
Definition indexcmds.c:2852
ObjectAddress DefineIndex(ParseState *pstate, Oid tableId, const IndexStmt *stmt, Oid indexRelationId, Oid parentIndexId, Oid parentConstraintId, int total_parts, bool is_alter_table, bool check_rights, bool check_not_in_use, bool skip_build, bool quiet)
Definition indexcmds.c:545
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:442
ObjectAddress DefineOperator(List *names, List *parameters)
Definition operatorcmds.c:67
List * transformCreateStmt(CreateStmt *stmt, const char *queryString)
Definition parse_utilcmd.c:162
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:1342
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:256
ObjectAddress CreateProceduralLanguage(CreatePLangStmt *stmt)
Definition proclang.c:38
ObjectAddress AlterPropGraph(ParseState *pstate, const AlterPropGraphStmt *stmt)
Definition propgraphcmds.c:1291
ObjectAddress CreatePropGraph(ParseState *pstate, const CreatePropGraphStmt *stmt)
Definition propgraphcmds.c:104
ObjectAddress CreatePublication(ParseState *pstate, CreatePublicationStmt *stmt)
Definition publicationcmds.c:836
void AlterPublication(ParseState *pstate, AlterPublicationStmt *stmt)
Definition publicationcmds.c:1657
Datum transformRelOptions(Datum oldOptions, List *defList, const char *nameSpace, const char *const validnsps[], bool acceptOidsOff, bool isReset)
Definition reloptions.c:1266
bytea * heap_reloptions(char relkind, Datum reloptions, bool validate)
Definition reloptions.c:2164
ObjectAddress DefineRule(RuleStmt *stmt, const char *queryString)
Definition rewriteDefine.c:190
Oid CreateSchemaCommand(ParseState *pstate, CreateSchemaStmt *stmt, int stmt_location, int stmt_len)
Definition schemacmds.c:52
ObjectAddress CreateStatistics(CreateStatsStmt *stmt, bool check_rights)
Definition statscmds.c:64
Definition parsenodes.h:2638
Definition parsenodes.h:2765
Definition parsenodes.h:2662
Definition parsenodes.h:3964
Definition parsenodes.h:3050
Definition parsenodes.h:3043
Definition parsenodes.h:3072
Definition parsenodes.h:3096
Definition parsenodes.h:3427
Definition parsenodes.h:3830
Definition parsenodes.h:3190
Definition parsenodes.h:4331
Definition parsenodes.h:4535
Definition parsenodes.h:3342
Definition parsenodes.h:3660
Definition parsenodes.h:4578
Definition parsenodes.h:4452
Definition parsenodes.h:4433
Definition parsenodes.h:2595
Definition utility.h:31
Definition parsenodes.h:3841
Definition parsenodes.h:3131
Definition parsenodes.h:3467
Definition parsenodes.h:3931
Definition parsenodes.h:3204
Definition parsenodes.h:4258
Definition parsenodes.h:4244
Definition parsenodes.h:3371
Definition parsenodes.h:3942
Definition parsenodes.h:3034
Definition parsenodes.h:3064
Definition parsenodes.h:3085
Definition parsenodes.h:3110
Definition parsenodes.h:3384
Definition parsenodes.h:3416
Definition parsenodes.h:3269
Definition parsenodes.h:3174
Definition parsenodes.h:4272
Definition parsenodes.h:4517
Definition parsenodes.h:3953
Definition parsenodes.h:2495
Definition parsenodes.h:3332
Definition parsenodes.h:3629
Definition parsenodes.h:2857
Definition parsenodes.h:4554
Definition parsenodes.h:4354
Definition parsenodes.h:3216
Definition parsenodes.h:3122
Definition parsenodes.h:4413
Definition parsenodes.h:4589
Definition parsenodes.h:3139
Definition parsenodes.h:3159
Definition parsenodes.h:3592
Definition pg_list.h:54
Definition nodes.h:135
Definition objectaddress.h:26
Definition parsenodes.h:1002
Definition primnodes.h:74
Definition parsenodes.h:4157
Definition parsenodes.h:4230
Definition parsenodes.h:3852
Definition parsenodes.h:3479
Definition parsenodes.h:796
Definition parsenodes.h:3986
void DropSubscription(DropSubscriptionStmt *stmt, bool isTopLevel)
Definition subscriptioncmds.c:2176
ObjectAddress CreateSubscription(ParseState *pstate, CreateSubscriptionStmt *stmt, bool isTopLevel)
Definition subscriptioncmds.c:615
ObjectAddress AlterSubscription(ParseState *pstate, AlterSubscriptionStmt *stmt, bool isTopLevel)
Definition subscriptioncmds.c:1413
void AlterTable(AlterTableStmt *stmt, LOCKMODE lockmode, AlterTableUtilityContext *context)
Definition tablecmds.c:4565
Oid AlterTableLookupRelation(AlterTableStmt *stmt, LOCKMODE lockmode)
Definition tablecmds.c:4506
ObjectAddress DefineRelation(CreateStmt *stmt, char relkind, Oid ownerId, ObjectAddress *typaddress, const char *queryString)
Definition tablecmds.c:784
void RangeVarCallbackOwnsRelation(const RangeVar *relation, Oid relId, Oid oldRelId, void *arg)
Definition tablecmds.c:19792
void NewRelationCreateToastTable(Oid relOid, Datum reloptions)
Definition toasting.c:72
ObjectAddress CreateTrigger(const CreateTrigStmt *stmt, const char *queryString, Oid relOid, Oid refRelOid, Oid constraintOid, Oid indexOid, Oid funcoid, Oid parentTriggerOid, Node *whenClause, bool isInternal, bool in_partition)
Definition trigger.c:162
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:2768
ObjectAddress DefineType(ParseState *pstate, List *names, List *parameters)
Definition typecmds.c:154
ObjectAddress AlterDomainDropConstraint(List *names, const char *constrName, DropBehavior behavior, bool missing_ok)
Definition typecmds.c:2854
ObjectAddress AlterDomainAddConstraint(List *names, Node *newConstraint, ObjectAddress *constrAddr)
Definition typecmds.c:2960
ObjectAddress DefineDomain(ParseState *pstate, CreateDomainStmt *stmt)
Definition typecmds.c:699
ObjectAddress AlterDomainValidateConstraint(List *names, const char *constrName)
Definition typecmds.c:3060
ObjectAddress AlterDomainDefault(List *names, Node *defaultRaw)
Definition typecmds.c:2639
ObjectAddress DefineCompositeType(RangeVar *typevar, List *coldeflist)
Definition typecmds.c:2581
ObjectAddress DefineRange(ParseState *pstate, CreateRangeStmt *stmt)
Definition typecmds.c:1382
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(), AlterPropGraph(), AlterPublication(), AlterSequence(), AlterStatistics(), AlterSubscription(), AlterTable(), AlterTableGetLockLevel(), AlterTableLookupRelation(), AlterTableMoveAll(), AlterTSConfiguration(), AlterTSDictionary(), AlterType(), AlterUserMapping(), Assert, AT_DetachPartition, CreateForeignTableStmt::base, PlannedStmt::canSetTag, CMD_UTILITY, CommandCounterIncrement(), PlannedStmt::commandType, CommentObject(), CreateAccessMethod(), CreateCast(), CreateConversionCommand(), CreateExtension(), CreateForeignDataWrapper(), CreateForeignServer(), CreateForeignTable(), CreateFunction(), CreatePolicy(), CreateProceduralLanguage(), CreatePropGraph(), 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(), fb(), 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, PG_END_TRY, PG_FINALLY, PG_TRY, PLAN_STMT_INTERNAL, PlannedStmt::planOrigin, PreventInTransactionBlock(), PROCESS_UTILITY_SUBCOMMAND, PROCESS_UTILITY_TOPLEVEL, ProcessUtility(), AlterTableUtilityContext::pstmt, RangeVarCallbackOwnsRelation(), RangeVarGetRelid, RangeVarGetRelidExtended(), CreateStmt::relation, 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 548 of file utility.c.
556{
557 Node *parsetree;
559 bool isAtomicContext = (!(context == PROCESS_UTILITY_TOPLEVEL || context == PROCESS_UTILITY_QUERY_NONATOMIC) || IsTransactionBlock());
560 ParseState *pstate;
562
563 /* This can recurse, so check for excessive recursion */
564 check_stack_depth();
565
566 /*
567 * If the given node tree is read-only, make a copy to ensure that parse
568 * transformations don't damage the original tree. This could be
569 * refactored to avoid making unnecessary copies in more cases, but it's
570 * not clear that it's worth a great deal of trouble over. Statements
571 * that are complex enough to be expensive to copy are exactly the ones
572 * we'd need to copy, so that only marginal savings seem possible.
573 */
575 pstmt = copyObject(pstmt);
576 parsetree = pstmt->utilityStmt;
577
578 /* Prohibit read/write commands in read-only states. */
582 {
584
591 }
592
594 pstate->p_sourcetext = queryString;
595 pstate->p_queryEnv = queryEnv;
596
598 {
599 /*
600 * ******************** transactions ********************
601 */
603 {
605
607 {
608 /*
609 * START TRANSACTION, as defined by SQL99: Identical
610 * to BEGIN. Same code for both.
611 */
614 {
616
617 BeginTransactionBlock();
619 {
621
625 true);
629 true);
633 true);
634 }
635 }
636 break;
637
640 {
641 /* report unsuccessful commit in qc */
642 if (qc)
644 }
645 break;
646
649 {
650 /* report unsuccessful commit in qc */
651 if (qc)
653 }
654 break;
655
659 break;
660
664 break;
665
668 break;
669
673 break;
674
678 break;
679
683
684 /*
685 * CommitTransactionCommand is in charge of
686 * re-defining the savepoint again
687 */
688 break;
689 }
690 }
691 break;
692
693 /*
694 * Portal (cursor) manipulation
695 */
698 isTopLevel);
699 break;
700
702 {
704
707 }
708 break;
709
712 break;
713
716 break;
717
719 /* no event triggers for global objects */
722 break;
723
725 /* no event triggers for global objects */
728 break;
729
731 /* no event triggers for global objects */
733 break;
734
737 break;
738
740 {
741 uint64 processed;
742
745 &processed);
746 if (qc)
748 }
749 break;
750
755 break;
756
758 ExecuteQuery(pstate,
760 params,
761 dest, qc);
762 break;
763
767 break;
768
770 /* no event triggers for global objects */
772 break;
773
775 /* no event triggers for global objects */
778 break;
779
781 /* no event triggers for global objects */
783 break;
784
786 /* no event triggers for global objects */
788 break;
789
791 /* no event triggers for global objects */
793 break;
794
796 /* no event triggers for global objects */
799 break;
800
801 /* Query-level asynchronous notification */
803 {
805
807 }
808 break;
809
811 {
813
815
816 /*
817 * We don't allow LISTEN in background processes, as there is
818 * no mechanism for them to collect NOTIFY messages, so they'd
819 * just block cleanout of the async SLRU indefinitely.
820 * (Authors of custom background workers could bypass this
821 * restriction by calling Async_Listen directly, but then it's
822 * on them to provide some mechanism to process the message
823 * queue.) Note there seems no reason to forbid UNLISTEN.
824 */
828 /* translator: %s is name of a SQL command, eg LISTEN */
830 "LISTEN")));
831
833 }
834 break;
835
837 {
839
843 else
844 Async_UnlistenAll();
845 }
846 break;
847
849 {
851
853 /* Allowed names are restricted if you're not superuser */
855 }
856 break;
857
860 break;
861
864 break;
865
868 break;
869
872 break;
873
877 break;
878
881 break;
882
884 {
886
888 }
889 break;
890
892 /* should we allow DISCARD PLANS? */
895 break;
896
898 /* no event triggers on event triggers */
900 break;
901
903 /* no event triggers on event triggers */
905 break;
906
907 /*
908 * ******************************** ROLE statements ****
909 */
911 /* no event triggers for global objects */
913 break;
914
916 /* no event triggers for global objects */
918 break;
919
921 /* no event triggers for global objects */
923 break;
924
926 /* no event triggers for global objects */
928 break;
929
931 /* no event triggers for global objects */
933 break;
934
936
937 /*
938 * Since the lock would just get dropped immediately, LOCK TABLE
939 * outside a transaction block is presumed to be user error.
940 */
943 break;
944
948 break;
949
952 break;
953
954 /*
955 * The following statements are supported by Event Triggers only
956 * in some cases, so we "fast path" them in the other cases.
957 */
958
960 {
962
964 ProcessUtilitySlow(pstate, pstmt, queryString,
965 context, params, queryEnv,
966 dest, qc);
967 else
969 }
970 break;
971
973 {
975
977 ProcessUtilitySlow(pstate, pstmt, queryString,
978 context, params, queryEnv,
979 dest, qc);
980 else
982 }
983 break;
984
986 {
988
990 ProcessUtilitySlow(pstate, pstmt, queryString,
991 context, params, queryEnv,
992 dest, qc);
993 else
995 }
996 break;
997
999 {
1001
1003 ProcessUtilitySlow(pstate, pstmt, queryString,
1004 context, params, queryEnv,
1005 dest, qc);
1006 else
1008 }
1009 break;
1010
1012 {
1014
1016 ProcessUtilitySlow(pstate, pstmt, queryString,
1017 context, params, queryEnv,
1018 dest, qc);
1019 else
1021 }
1022 break;
1023
1025 {
1027
1029 ProcessUtilitySlow(pstate, pstmt, queryString,
1030 context, params, queryEnv,
1031 dest, qc);
1032 else
1034 }
1035 break;
1036
1038 {
1040
1042 ProcessUtilitySlow(pstate, pstmt, queryString,
1043 context, params, queryEnv,
1044 dest, qc);
1045 else
1047 break;
1048 }
1049
1051 {
1053
1055 ProcessUtilitySlow(pstate, pstmt, queryString,
1056 context, params, queryEnv,
1057 dest, qc);
1058 else
1060 break;
1061 }
1062
1064 {
1066 dest);
1067 }
1068 break;
1069
1070 default:
1071 /* All other statement types have event trigger support */
1072 ProcessUtilitySlow(pstate, pstmt, queryString,
1073 context, params, queryEnv,
1074 dest, qc);
1075 break;
1076 }
1077
1078 free_parsestate(pstate);
1079
1080 /*
1081 * Make effects of commands visible, for instance so that
1082 * PreCommit_on_commit_actions() can see them (see for example bug
1083 * #15631).
1084 */
1085 CommandCounterIncrement();
1086}
void DoCopy(ParseState *pstate, const CopyStmt *stmt, int stmt_location, int stmt_len, uint64 *processed)
Definition copy.c:63
void PrepareQuery(ParseState *pstate, PrepareStmt *stmt, int stmt_location, int stmt_len)
Definition prepare.c:61
void ExecuteQuery(ParseState *pstate, ExecuteStmt *stmt, IntoClause *intoClause, ParamListInfo params, DestReceiver *dest, QueryCompletion *qc)
Definition prepare.c:152
Oid AlterTableSpaceOptions(AlterTableSpaceOptionsStmt *stmt)
Definition tablespace.c:1029
void ExecCheckpoint(ParseState *pstate, CheckPointStmt *stmt)
Definition checkpointer.c:1006
static void SetQueryCompletion(QueryCompletion *qc, CommandTag commandTag, uint64 nprocessed)
Definition cmdtag.h:37
ObjectAddress AlterDatabaseRefreshColl(AlterDatabaseRefreshCollStmt *stmt)
Definition dbcommands.c:2563
Oid AlterDatabase(ParseState *pstate, AlterDatabaseStmt *stmt, bool isTopLevel)
Definition dbcommands.c:2390
bool EventTriggerSupportsObjectType(ObjectType obtype)
Definition event_trigger.c:1135
void ExplainQuery(ParseState *pstate, ExplainStmt *stmt, ParamListInfo params, DestReceiver *dest)
Definition explain.c:181
void ExecuteCallStmt(CallStmt *stmt, ParamListInfo params, bool atomic, DestReceiver *dest)
Definition functioncmds.c:2209
void ExecuteDoStmt(ParseState *pstate, DoStmt *stmt, bool atomic)
Definition functioncmds.c:2087
void AlterSystemSetConfigFile(AlterSystemStmt *altersysstmt)
Definition guc.c:4508
void SetPGVariable(const char *name, List *args, bool is_local)
Definition guc_funcs.c:343
void ExecSetVariableStmt(VariableSetStmt *stmt, bool isTopLevel)
Definition guc_funcs.c:45
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
void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel)
Definition repack.c:237
Definition parsenodes.h:4035
Definition parsenodes.h:4022
Definition parsenodes.h:3257
Definition parsenodes.h:3312
Definition parsenodes.h:3304
Definition parsenodes.h:4058
Definition parsenodes.h:3011
Definition parsenodes.h:3748
Definition parsenodes.h:4169
Definition parsenodes.h:4210
Definition parsenodes.h:3244
Definition parsenodes.h:3296
Definition parsenodes.h:2995
Definition parsenodes.h:4011
Definition parsenodes.h:3508
Definition parsenodes.h:3720
Definition parsenodes.h:3320
Definition parsenodes.h:3004
Definition parsenodes.h:4046
Definition parsenodes.h:3879
Definition parsenodes.h:4001
Definition parsenodes.h:3868
Definition parse_node.h:212
Definition parsenodes.h:4423
Definition parsenodes.h:3455
Definition parsenodes.h:3889
Definition parsenodes.h:2840
Definition parsenodes.h:4597
void FinishPreparedTransaction(const char *gid, bool isCommit)
Definition twophase.c:1503
static int ClassifyUtilityCommandAsReadOnly(Node *parsetree)
Definition utility.c:130
void PreventCommandIfParallelMode(const char *cmdname)
Definition utility.c:427
static void CheckRestrictedOperation(const char *cmdname)
Definition utility.c:464
void PreventCommandDuringRecovery(const char *cmdname)
Definition utility.c:446
static void ProcessUtilitySlow(ParseState *pstate, PlannedStmt *pstmt, const char *queryString, ProcessUtilityContext context, ParamListInfo params, QueryEnvironment *queryEnv, DestReceiver *dest, QueryCompletion *qc)
Definition utility.c:1094
void ExecVacuum(ParseState *pstate, VacuumStmt *vacstmt, bool isTopLevel)
Definition vacuum.c:163
void ExecWaitStmt(ParseState *pstate, WaitStmt *stmt, bool isTopLevel, DestReceiver *dest)
Definition wait.c:34
void WarnNoTransactionBlock(bool isTopLevel, const char *stmtType)
Definition xact.c:3761
void RequireTransactionBlock(bool isTopLevel, const char *stmtType)
Definition xact.c:3767
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(), 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, DiscardCommand(), DoCopy(), DropDatabase(), DropRole(), DropTableSpace(), EndTransactionBlock(), ereport, errcode(), errmsg, ERROR, EventTriggerSupportsObjectType(), ExecAlterObjectDependsStmt(), ExecAlterObjectSchemaStmt(), ExecAlterOwnerStmt(), ExecCheckpoint(), ExecDropStmt(), ExecRenameStmt(), ExecRepack(), ExecSecLabelStmt(), ExecSetVariableStmt(), ExecuteCallStmt(), ExecuteDoStmt(), ExecuteGrantStmt(), ExecuteQuery(), ExecuteTruncate(), ExecVacuum(), ExecWaitStmt(), ExplainQuery(), fb(), 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 2199 of file utility.c.
2200{
2201 Query *qry;
2202
2204 {
2209 return qry;
2210
2215 return qry;
2216
2221 return qry;
2222
2223 default:
2225 }
2226}
References castNode, CMD_UTILITY, Query::commandType, fb(), nodeTag, UtilityContainsQuery(), and Query::utilityStmt.
Referenced by AcquireExecutorLocks(), AcquirePlannerLocks(), extract_query_dependencies_walker(), and UtilityContainsQuery().
◆ UtilityReturnsTuples()
Definition at line 2042 of file utility.c.
2043{
2045 {
2047 {
2049
2051 }
2053 {
2055 Portal portal;
2056
2058 return false;
2061 return false; /* not our business to raise error */
2063 }
2064
2066 {
2068 PreparedStatement *entry;
2069
2071 if (!entry)
2072 return false; /* not our business to raise error */
2074 return true;
2075 return false;
2076 }
2077
2079 return true;
2080
2082 return true;
2083
2085 return true;
2086
2087 default:
2088 return false;
2089 }
2090}
Definition portal.h:116
References fb(), FetchPreparedStatement(), GetPortalByName(), nodeTag, PreparedStatement::plansource, PortalIsValid, CachedPlanSource::resultDesc, stmt, true, and PortalData::tupDesc.
Referenced by ChoosePortalStrategy().
◆ UtilityTupleDescriptor()
Definition at line 2101 of file utility.c.
2102{
2104 {
2107
2109 {
2111 Portal portal;
2112
2119 }
2120
2122 {
2124 PreparedStatement *entry;
2125
2127 if (!entry)
2130 }
2131
2134
2136 {
2138
2140 }
2141
2144
2145 default:
2147 }
2148}
TupleDesc FetchPreparedStatementResultDesc(PreparedStatement *stmt)
Definition prepare.c:468
TupleDesc GetPGVariableResultDesc(const char *name)
Definition guc_funcs.c:422
References CallStmtResultDesc(), CreateTupleDescCopy(), ExplainResultDesc(), fb(), 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 72 of file utility.c.
Referenced by _PG_init(), and ProcessUtility().
