typedef void(* ProcessUtility_hook_type) (PlannedStmt *pstmt, const char *queryString, bool readOnlyTree, ProcessUtilityContext context, ParamListInfo params, QueryEnvironment *queryEnv, DestReceiver *dest, QueryCompletion *qc)

Definition at line 71 of file utility.h.

Enumeration Type Documentation

◆ ProcessUtilityContext

enum ProcessUtilityContext

Enumerator
PROCESS_UTILITY_TOPLEVEL
PROCESS_UTILITY_QUERY
PROCESS_UTILITY_QUERY_NONATOMIC
PROCESS_UTILITY_SUBCOMMAND

Definition at line 20 of file utility.h.

21{

22 PROCESS_UTILITY_TOPLEVEL, /* toplevel interactive command */

23 PROCESS_UTILITY_QUERY, /* a complete query, but not toplevel */

24 PROCESS_UTILITY_QUERY_NONATOMIC, /* a complete query, nonatomic

25 * execution context */

26 PROCESS_UTILITY_SUBCOMMAND, /* a portion of a query */

27} ProcessUtilityContext;

ProcessUtilityContext

Definition: utility.h:21

PROCESS_UTILITY_SUBCOMMAND

@ PROCESS_UTILITY_SUBCOMMAND

Definition: utility.h:26

PROCESS_UTILITY_TOPLEVEL

@ PROCESS_UTILITY_TOPLEVEL

Definition: utility.h:22

PROCESS_UTILITY_QUERY_NONATOMIC

@ PROCESS_UTILITY_QUERY_NONATOMIC

Definition: utility.h:24

PROCESS_UTILITY_QUERY

@ PROCESS_UTILITY_QUERY

Definition: utility.h:23

Function Documentation

◆ CommandIsReadOnly()

bool CommandIsReadOnly ( PlannedStmt * pstmt )

Definition at line 94 of file utility.c.

95{

96 Assert(IsA(pstmt, PlannedStmt));

97 switch (pstmt->commandType)

98 {

99 case CMD_SELECT:

100 if (pstmt->rowMarks != NIL)

101 return false; /* SELECT FOR [KEY] UPDATE/SHARE */

102 else if (pstmt->hasModifyingCTE)

103 return false; /* data-modifying CTE */

104 else

105 return true;

106 case CMD_UPDATE:

107 case CMD_INSERT:

108 case CMD_DELETE:

109 case CMD_MERGE:

110 return false;

111 case CMD_UTILITY:

112 /* For now, treat all utility commands as read/write */

113 return false;

114 default:

115 elog(WARNING, "unrecognized commandType: %d",

116 (int) pstmt->commandType);

117 break;

118 }

119 return false;

120}

WARNING

#define WARNING

Definition: elog.h:36

elog

#define elog(elevel,...)

Definition: elog.h:226

Assert

Assert(PointerIsAligned(start, uint64))

IsA

#define IsA(nodeptr, _type_)

Definition: nodes.h:164

CMD_MERGE

@ CMD_MERGE

Definition: nodes.h:279

CMD_UTILITY

@ CMD_UTILITY

Definition: nodes.h:280

CMD_INSERT

@ CMD_INSERT

Definition: nodes.h:277

CMD_DELETE

@ CMD_DELETE

Definition: nodes.h:278

CMD_UPDATE

@ CMD_UPDATE

Definition: nodes.h:276

CMD_SELECT

@ CMD_SELECT

Definition: nodes.h:275

NIL

#define NIL

Definition: pg_list.h:68

PlannedStmt

Definition: plannodes.h:62

PlannedStmt::hasModifyingCTE

bool hasModifyingCTE

Definition: plannodes.h:83

PlannedStmt::rowMarks

List * rowMarks

Definition: plannodes.h:138

PlannedStmt::commandType

CmdType commandType

Definition: plannodes.h:68

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().

◆ CreateCommandName()

static const char * CreateCommandName ( Node * parsetree )

inlinestatic

Definition at line 103 of file utility.h.

104{

105 return GetCommandTagName(CreateCommandTag(parsetree));

106}

GetCommandTagName

const char * GetCommandTagName(CommandTag commandTag)

Definition: cmdtag.c:47

CreateCommandTag

CommandTag CreateCommandTag(Node *parsetree)

Definition: utility.c:2354

References CreateCommandTag(), and GetCommandTagName().

Referenced by _SPI_execute_plan(), ExecCheckXactReadOnly(), get_command_tag(), init_execution_state(), pg_event_trigger_ddl_commands(), and SPI_cursor_open_internal().

◆ CreateCommandTag()

CommandTag CreateCommandTag ( Node * parsetree )

Definition at line 2354 of file utility.c.

2355{

2356 CommandTag tag;

2357

2358 switch (nodeTag(parsetree))

2359 {

2360 /* recurse if we're given a RawStmt */

2361 case T_RawStmt:

2362 tag = CreateCommandTag(((RawStmt *) parsetree)->stmt);

2363 break;

2364

2365 /* raw plannable queries */

2366 case T_InsertStmt:

2367 tag = CMDTAG_INSERT;

2368 break;

2369

2370 case T_DeleteStmt:

2371 tag = CMDTAG_DELETE;

2372 break;

2373

2374 case T_UpdateStmt:

2375 tag = CMDTAG_UPDATE;

2376 break;

2377

2378 case T_MergeStmt:

2379 tag = CMDTAG_MERGE;

2380 break;

2381

2382 case T_SelectStmt:

2383 tag = CMDTAG_SELECT;

2384 break;

2385

2386 case T_PLAssignStmt:

2387 tag = CMDTAG_SELECT;

2388 break;

2389

2390 /* utility statements --- same whether raw or cooked */

2391 case T_TransactionStmt:

2392 {

2393 TransactionStmt *stmt = (TransactionStmt *) parsetree;

2394

2395 switch (stmt->kind)

2396 {

2397 case TRANS_STMT_BEGIN:

2398 tag = CMDTAG_BEGIN;

2399 break;

2400

2401 case TRANS_STMT_START:

2402 tag = CMDTAG_START_TRANSACTION;

2403 break;

2404

2405 case TRANS_STMT_COMMIT:

2406 tag = CMDTAG_COMMIT;

2407 break;

2408

2409 case TRANS_STMT_ROLLBACK:

2410 case TRANS_STMT_ROLLBACK_TO:

2411 tag = CMDTAG_ROLLBACK;

2412 break;

2413

2414 case TRANS_STMT_SAVEPOINT:

2415 tag = CMDTAG_SAVEPOINT;

2416 break;

2417

2418 case TRANS_STMT_RELEASE:

2419 tag = CMDTAG_RELEASE;

2420 break;

2421

2422 case TRANS_STMT_PREPARE:

2423 tag = CMDTAG_PREPARE_TRANSACTION;

2424 break;

2425

2426 case TRANS_STMT_COMMIT_PREPARED:

2427 tag = CMDTAG_COMMIT_PREPARED;

2428 break;

2429

2430 case TRANS_STMT_ROLLBACK_PREPARED:

2431 tag = CMDTAG_ROLLBACK_PREPARED;

2432 break;

2433

2434 default:

2435 tag = CMDTAG_UNKNOWN;

2436 break;

2437 }

2438 }

2439 break;

2440

2441 case T_DeclareCursorStmt:

2442 tag = CMDTAG_DECLARE_CURSOR;

2443 break;

2444

2445 case T_ClosePortalStmt:

2446 {

2447 ClosePortalStmt *stmt = (ClosePortalStmt *) parsetree;

2448

2449 if (stmt->portalname == NULL)

2450 tag = CMDTAG_CLOSE_CURSOR_ALL;

2451 else

2452 tag = CMDTAG_CLOSE_CURSOR;

2453 }

2454 break;

2455

2456 case T_FetchStmt:

2457 {

2458 FetchStmt *stmt = (FetchStmt *) parsetree;

2459

2460 tag = (stmt->ismove) ? CMDTAG_MOVE : CMDTAG_FETCH;

2461 }

2462 break;

2463

2464 case T_CreateDomainStmt:

2465 tag = CMDTAG_CREATE_DOMAIN;

2466 break;

2467

2468 case T_CreateSchemaStmt:

2469 tag = CMDTAG_CREATE_SCHEMA;

2470 break;

2471

2472 case T_CreateStmt:

2473 tag = CMDTAG_CREATE_TABLE;

2474 break;

2475

2476 case T_CreateTableSpaceStmt:

2477 tag = CMDTAG_CREATE_TABLESPACE;

2478 break;

2479

2480 case T_DropTableSpaceStmt:

2481 tag = CMDTAG_DROP_TABLESPACE;

2482 break;

2483

2484 case T_AlterTableSpaceOptionsStmt:

2485 tag = CMDTAG_ALTER_TABLESPACE;

2486 break;

2487

2488 case T_CreateExtensionStmt:

2489 tag = CMDTAG_CREATE_EXTENSION;

2490 break;

2491

2492 case T_AlterExtensionStmt:

2493 tag = CMDTAG_ALTER_EXTENSION;

2494 break;

2495

2496 case T_AlterExtensionContentsStmt:

2497 tag = CMDTAG_ALTER_EXTENSION;

2498 break;

2499

2500 case T_CreateFdwStmt:

2501 tag = CMDTAG_CREATE_FOREIGN_DATA_WRAPPER;

2502 break;

2503

2504 case T_AlterFdwStmt:

2505 tag = CMDTAG_ALTER_FOREIGN_DATA_WRAPPER;

2506 break;

2507

2508 case T_CreateForeignServerStmt:

2509 tag = CMDTAG_CREATE_SERVER;

2510 break;

2511

2512 case T_AlterForeignServerStmt:

2513 tag = CMDTAG_ALTER_SERVER;

2514 break;

2515

2516 case T_CreateUserMappingStmt:

2517 tag = CMDTAG_CREATE_USER_MAPPING;

2518 break;

2519

2520 case T_AlterUserMappingStmt:

2521 tag = CMDTAG_ALTER_USER_MAPPING;

2522 break;

2523

2524 case T_DropUserMappingStmt:

2525 tag = CMDTAG_DROP_USER_MAPPING;

2526 break;

2527

2528 case T_CreateForeignTableStmt:

2529 tag = CMDTAG_CREATE_FOREIGN_TABLE;

2530 break;

2531

2532 case T_ImportForeignSchemaStmt:

2533 tag = CMDTAG_IMPORT_FOREIGN_SCHEMA;

2534 break;

2535

2536 case T_DropStmt:

2537 switch (((DropStmt *) parsetree)->removeType)

2538 {

2539 case OBJECT_TABLE:

2540 tag = CMDTAG_DROP_TABLE;

2541 break;

2542 case OBJECT_SEQUENCE:

2543 tag = CMDTAG_DROP_SEQUENCE;

2544 break;

2545 case OBJECT_VIEW:

2546 tag = CMDTAG_DROP_VIEW;

2547 break;

2548 case OBJECT_MATVIEW:

2549 tag = CMDTAG_DROP_MATERIALIZED_VIEW;

2550 break;

2551 case OBJECT_INDEX:

2552 tag = CMDTAG_DROP_INDEX;

2553 break;

2554 case OBJECT_TYPE:

2555 tag = CMDTAG_DROP_TYPE;

2556 break;

2557 case OBJECT_DOMAIN:

2558 tag = CMDTAG_DROP_DOMAIN;

2559 break;

2560 case OBJECT_COLLATION:

2561 tag = CMDTAG_DROP_COLLATION;

2562 break;

2563 case OBJECT_CONVERSION:

2564 tag = CMDTAG_DROP_CONVERSION;

2565 break;

2566 case OBJECT_SCHEMA:

2567 tag = CMDTAG_DROP_SCHEMA;

2568 break;

2569 case OBJECT_TSPARSER:

2570 tag = CMDTAG_DROP_TEXT_SEARCH_PARSER;

2571 break;

2572 case OBJECT_TSDICTIONARY:

2573 tag = CMDTAG_DROP_TEXT_SEARCH_DICTIONARY;

2574 break;

2575 case OBJECT_TSTEMPLATE:

2576 tag = CMDTAG_DROP_TEXT_SEARCH_TEMPLATE;

2577 break;

2578 case OBJECT_TSCONFIGURATION:

2579 tag = CMDTAG_DROP_TEXT_SEARCH_CONFIGURATION;

2580 break;

2581 case OBJECT_FOREIGN_TABLE:

2582 tag = CMDTAG_DROP_FOREIGN_TABLE;

2583 break;

2584 case OBJECT_EXTENSION:

2585 tag = CMDTAG_DROP_EXTENSION;

2586 break;

2587 case OBJECT_FUNCTION:

2588 tag = CMDTAG_DROP_FUNCTION;

2589 break;

2590 case OBJECT_PROCEDURE:

2591 tag = CMDTAG_DROP_PROCEDURE;

2592 break;

2593 case OBJECT_ROUTINE:

2594 tag = CMDTAG_DROP_ROUTINE;

2595 break;

2596 case OBJECT_AGGREGATE:

2597 tag = CMDTAG_DROP_AGGREGATE;

2598 break;

2599 case OBJECT_OPERATOR:

2600 tag = CMDTAG_DROP_OPERATOR;

2601 break;

2602 case OBJECT_LANGUAGE:

2603 tag = CMDTAG_DROP_LANGUAGE;

2604 break;

2605 case OBJECT_CAST:

2606 tag = CMDTAG_DROP_CAST;

2607 break;

2608 case OBJECT_TRIGGER:

2609 tag = CMDTAG_DROP_TRIGGER;

2610 break;

2611 case OBJECT_EVENT_TRIGGER:

2612 tag = CMDTAG_DROP_EVENT_TRIGGER;

2613 break;

2614 case OBJECT_RULE:

2615 tag = CMDTAG_DROP_RULE;

2616 break;

2617 case OBJECT_FDW:

2618 tag = CMDTAG_DROP_FOREIGN_DATA_WRAPPER;

2619 break;

2620 case OBJECT_FOREIGN_SERVER:

2621 tag = CMDTAG_DROP_SERVER;

2622 break;

2623 case OBJECT_OPCLASS:

2624 tag = CMDTAG_DROP_OPERATOR_CLASS;

2625 break;

2626 case OBJECT_OPFAMILY:

2627 tag = CMDTAG_DROP_OPERATOR_FAMILY;

2628 break;

2629 case OBJECT_POLICY:

2630 tag = CMDTAG_DROP_POLICY;

2631 break;

2632 case OBJECT_TRANSFORM:

2633 tag = CMDTAG_DROP_TRANSFORM;

2634 break;

2635 case OBJECT_ACCESS_METHOD:

2636 tag = CMDTAG_DROP_ACCESS_METHOD;

2637 break;

2638 case OBJECT_PUBLICATION:

2639 tag = CMDTAG_DROP_PUBLICATION;

2640 break;

2641 case OBJECT_STATISTIC_EXT:

2642 tag = CMDTAG_DROP_STATISTICS;

2643 break;

2644 default:

2645 tag = CMDTAG_UNKNOWN;

2646 }

2647 break;

2648

2649 case T_TruncateStmt:

2650 tag = CMDTAG_TRUNCATE_TABLE;

2651 break;

2652

2653 case T_CommentStmt:

2654 tag = CMDTAG_COMMENT;

2655 break;

2656

2657 case T_SecLabelStmt:

2658 tag = CMDTAG_SECURITY_LABEL;

2659 break;

2660

2661 case T_CopyStmt:

2662 tag = CMDTAG_COPY;

2663 break;

2664

2665 case T_RenameStmt:

2666

2667 /*

2668 * When the column is renamed, the command tag is created from its

2669 * relation type

2670 */

2671 tag = AlterObjectTypeCommandTag(((RenameStmt *) parsetree)->renameType == OBJECT_COLUMN ?

2672 ((RenameStmt *) parsetree)->relationType :

2673 ((RenameStmt *) parsetree)->renameType);

2674 break;

2675

2676 case T_AlterObjectDependsStmt:

2677 tag = AlterObjectTypeCommandTag(((AlterObjectDependsStmt *) parsetree)->objectType);

2678 break;

2679

2680 case T_AlterObjectSchemaStmt:

2681 tag = AlterObjectTypeCommandTag(((AlterObjectSchemaStmt *) parsetree)->objectType);

2682 break;

2683

2684 case T_AlterOwnerStmt:

2685 tag = AlterObjectTypeCommandTag(((AlterOwnerStmt *) parsetree)->objectType);

2686 break;

2687

2688 case T_AlterTableMoveAllStmt:

2689 tag = AlterObjectTypeCommandTag(((AlterTableMoveAllStmt *) parsetree)->objtype);

2690 break;

2691

2692 case T_AlterTableStmt:

2693 tag = AlterObjectTypeCommandTag(((AlterTableStmt *) parsetree)->objtype);

2694 break;

2695

2696 case T_AlterDomainStmt:

2697 tag = CMDTAG_ALTER_DOMAIN;

2698 break;

2699

2700 case T_AlterFunctionStmt:

2701 switch (((AlterFunctionStmt *) parsetree)->objtype)

2702 {

2703 case OBJECT_FUNCTION:

2704 tag = CMDTAG_ALTER_FUNCTION;

2705 break;

2706 case OBJECT_PROCEDURE:

2707 tag = CMDTAG_ALTER_PROCEDURE;

2708 break;

2709 case OBJECT_ROUTINE:

2710 tag = CMDTAG_ALTER_ROUTINE;

2711 break;

2712 default:

2713 tag = CMDTAG_UNKNOWN;

2714 }

2715 break;

2716

2717 case T_GrantStmt:

2718 {

2719 GrantStmt *stmt = (GrantStmt *) parsetree;

2720

2721 tag = (stmt->is_grant) ? CMDTAG_GRANT : CMDTAG_REVOKE;

2722 }

2723 break;

2724

2725 case T_GrantRoleStmt:

2726 {

2727 GrantRoleStmt *stmt = (GrantRoleStmt *) parsetree;

2728

2729 tag = (stmt->is_grant) ? CMDTAG_GRANT_ROLE : CMDTAG_REVOKE_ROLE;

2730 }

2731 break;

2732

2733 case T_AlterDefaultPrivilegesStmt:

2734 tag = CMDTAG_ALTER_DEFAULT_PRIVILEGES;

2735 break;

2736

2737 case T_DefineStmt:

2738 switch (((DefineStmt *) parsetree)->kind)

2739 {

2740 case OBJECT_AGGREGATE:

2741 tag = CMDTAG_CREATE_AGGREGATE;

2742 break;

2743 case OBJECT_OPERATOR:

2744 tag = CMDTAG_CREATE_OPERATOR;

2745 break;

2746 case OBJECT_TYPE:

2747 tag = CMDTAG_CREATE_TYPE;

2748 break;

2749 case OBJECT_TSPARSER:

2750 tag = CMDTAG_CREATE_TEXT_SEARCH_PARSER;

2751 break;

2752 case OBJECT_TSDICTIONARY:

2753 tag = CMDTAG_CREATE_TEXT_SEARCH_DICTIONARY;

2754 break;

2755 case OBJECT_TSTEMPLATE:

2756 tag = CMDTAG_CREATE_TEXT_SEARCH_TEMPLATE;

2757 break;

2758 case OBJECT_TSCONFIGURATION:

2759 tag = CMDTAG_CREATE_TEXT_SEARCH_CONFIGURATION;

2760 break;

2761 case OBJECT_COLLATION:

2762 tag = CMDTAG_CREATE_COLLATION;

2763 break;

2764 case OBJECT_ACCESS_METHOD:

2765 tag = CMDTAG_CREATE_ACCESS_METHOD;

2766 break;

2767 default:

2768 tag = CMDTAG_UNKNOWN;

2769 }

2770 break;

2771

2772 case T_CompositeTypeStmt:

2773 tag = CMDTAG_CREATE_TYPE;

2774 break;

2775

2776 case T_CreateEnumStmt:

2777 tag = CMDTAG_CREATE_TYPE;

2778 break;

2779

2780 case T_CreateRangeStmt:

2781 tag = CMDTAG_CREATE_TYPE;

2782 break;

2783

2784 case T_AlterEnumStmt:

2785 tag = CMDTAG_ALTER_TYPE;

2786 break;

2787

2788 case T_ViewStmt:

2789 tag = CMDTAG_CREATE_VIEW;

2790 break;

2791

2792 case T_CreateFunctionStmt:

2793 if (((CreateFunctionStmt *) parsetree)->is_procedure)

2794 tag = CMDTAG_CREATE_PROCEDURE;

2795 else

2796 tag = CMDTAG_CREATE_FUNCTION;

2797 break;

2798

2799 case T_IndexStmt:

2800 tag = CMDTAG_CREATE_INDEX;

2801 break;

2802

2803 case T_RuleStmt:

2804 tag = CMDTAG_CREATE_RULE;

2805 break;

2806

2807 case T_CreateSeqStmt:

2808 tag = CMDTAG_CREATE_SEQUENCE;

2809 break;

2810

2811 case T_AlterSeqStmt:

2812 tag = CMDTAG_ALTER_SEQUENCE;

2813 break;

2814

2815 case T_DoStmt:

2816 tag = CMDTAG_DO;

2817 break;

2818

2819 case T_CreatedbStmt:

2820 tag = CMDTAG_CREATE_DATABASE;

2821 break;

2822

2823 case T_AlterDatabaseStmt:

2824 case T_AlterDatabaseRefreshCollStmt:

2825 case T_AlterDatabaseSetStmt:

2826 tag = CMDTAG_ALTER_DATABASE;

2827 break;

2828

2829 case T_DropdbStmt:

2830 tag = CMDTAG_DROP_DATABASE;

2831 break;

2832

2833 case T_NotifyStmt:

2834 tag = CMDTAG_NOTIFY;

2835 break;

2836

2837 case T_ListenStmt:

2838 tag = CMDTAG_LISTEN;

2839 break;

2840

2841 case T_UnlistenStmt:

2842 tag = CMDTAG_UNLISTEN;

2843 break;

2844

2845 case T_LoadStmt:

2846 tag = CMDTAG_LOAD;

2847 break;

2848

2849 case T_CallStmt:

2850 tag = CMDTAG_CALL;

2851 break;

2852

2853 case T_ClusterStmt:

2854 tag = CMDTAG_CLUSTER;

2855 break;

2856

2857 case T_VacuumStmt:

2858 if (((VacuumStmt *) parsetree)->is_vacuumcmd)

2859 tag = CMDTAG_VACUUM;

2860 else

2861 tag = CMDTAG_ANALYZE;

2862 break;

2863

2864 case T_ExplainStmt:

2865 tag = CMDTAG_EXPLAIN;

2866 break;

2867

2868 case T_CreateTableAsStmt:

2869 switch (((CreateTableAsStmt *) parsetree)->objtype)

2870 {

2871 case OBJECT_TABLE:

2872 if (((CreateTableAsStmt *) parsetree)->is_select_into)

2873 tag = CMDTAG_SELECT_INTO;

2874 else

2875 tag = CMDTAG_CREATE_TABLE_AS;

2876 break;

2877 case OBJECT_MATVIEW:

2878 tag = CMDTAG_CREATE_MATERIALIZED_VIEW;

2879 break;

2880 default:

2881 tag = CMDTAG_UNKNOWN;

2882 }

2883 break;

2884

2885 case T_RefreshMatViewStmt:

2886 tag = CMDTAG_REFRESH_MATERIALIZED_VIEW;

2887 break;

2888

2889 case T_AlterSystemStmt:

2890 tag = CMDTAG_ALTER_SYSTEM;

2891 break;

2892

2893 case T_VariableSetStmt:

2894 switch (((VariableSetStmt *) parsetree)->kind)

2895 {

2896 case VAR_SET_VALUE:

2897 case VAR_SET_CURRENT:

2898 case VAR_SET_DEFAULT:

2899 case VAR_SET_MULTI:

2900 tag = CMDTAG_SET;

2901 break;

2902 case VAR_RESET:

2903 case VAR_RESET_ALL:

2904 tag = CMDTAG_RESET;

2905 break;

2906 default:

2907 tag = CMDTAG_UNKNOWN;

2908 }

2909 break;

2910

2911 case T_VariableShowStmt:

2912 tag = CMDTAG_SHOW;

2913 break;

2914

2915 case T_DiscardStmt:

2916 switch (((DiscardStmt *) parsetree)->target)

2917 {

2918 case DISCARD_ALL:

2919 tag = CMDTAG_DISCARD_ALL;

2920 break;

2921 case DISCARD_PLANS:

2922 tag = CMDTAG_DISCARD_PLANS;

2923 break;

2924 case DISCARD_TEMP:

2925 tag = CMDTAG_DISCARD_TEMP;

2926 break;

2927 case DISCARD_SEQUENCES:

2928 tag = CMDTAG_DISCARD_SEQUENCES;

2929 break;

2930 default:

2931 tag = CMDTAG_UNKNOWN;

2932 }

2933 break;

2934

2935 case T_CreateTransformStmt:

2936 tag = CMDTAG_CREATE_TRANSFORM;

2937 break;

2938

2939 case T_CreateTrigStmt:

2940 tag = CMDTAG_CREATE_TRIGGER;

2941 break;

2942

2943 case T_CreateEventTrigStmt:

2944 tag = CMDTAG_CREATE_EVENT_TRIGGER;

2945 break;

2946

2947 case T_AlterEventTrigStmt:

2948 tag = CMDTAG_ALTER_EVENT_TRIGGER;

2949 break;

2950

2951 case T_CreatePLangStmt:

2952 tag = CMDTAG_CREATE_LANGUAGE;

2953 break;

2954

2955 case T_CreateRoleStmt:

2956 tag = CMDTAG_CREATE_ROLE;

2957 break;

2958

2959 case T_AlterRoleStmt:

2960 tag = CMDTAG_ALTER_ROLE;

2961 break;

2962

2963 case T_AlterRoleSetStmt:

2964 tag = CMDTAG_ALTER_ROLE;

2965 break;

2966

2967 case T_DropRoleStmt:

2968 tag = CMDTAG_DROP_ROLE;

2969 break;

2970

2971 case T_DropOwnedStmt:

2972 tag = CMDTAG_DROP_OWNED;

2973 break;

2974

2975 case T_ReassignOwnedStmt:

2976 tag = CMDTAG_REASSIGN_OWNED;

2977 break;

2978

2979 case T_LockStmt:

2980 tag = CMDTAG_LOCK_TABLE;

2981 break;

2982

2983 case T_ConstraintsSetStmt:

2984 tag = CMDTAG_SET_CONSTRAINTS;

2985 break;

2986

2987 case T_CheckPointStmt:

2988 tag = CMDTAG_CHECKPOINT;

2989 break;

2990

2991 case T_ReindexStmt:

2992 tag = CMDTAG_REINDEX;

2993 break;

2994

2995 case T_CreateConversionStmt:

2996 tag = CMDTAG_CREATE_CONVERSION;

2997 break;

2998

2999 case T_CreateCastStmt:

3000 tag = CMDTAG_CREATE_CAST;

3001 break;

3002

3003 case T_CreateOpClassStmt:

3004 tag = CMDTAG_CREATE_OPERATOR_CLASS;

3005 break;

3006

3007 case T_CreateOpFamilyStmt:

3008 tag = CMDTAG_CREATE_OPERATOR_FAMILY;

3009 break;

3010

3011 case T_AlterOpFamilyStmt:

3012 tag = CMDTAG_ALTER_OPERATOR_FAMILY;

3013 break;

3014

3015 case T_AlterOperatorStmt:

3016 tag = CMDTAG_ALTER_OPERATOR;

3017 break;

3018

3019 case T_AlterTypeStmt:

3020 tag = CMDTAG_ALTER_TYPE;

3021 break;

3022

3023 case T_AlterTSDictionaryStmt:

3024 tag = CMDTAG_ALTER_TEXT_SEARCH_DICTIONARY;

3025 break;

3026

3027 case T_AlterTSConfigurationStmt:

3028 tag = CMDTAG_ALTER_TEXT_SEARCH_CONFIGURATION;

3029 break;

3030

3031 case T_CreatePolicyStmt:

3032 tag = CMDTAG_CREATE_POLICY;

3033 break;

3034

3035 case T_AlterPolicyStmt:

3036 tag = CMDTAG_ALTER_POLICY;

3037 break;

3038

3039 case T_CreateAmStmt:

3040 tag = CMDTAG_CREATE_ACCESS_METHOD;

3041 break;

3042

3043 case T_CreatePublicationStmt:

3044 tag = CMDTAG_CREATE_PUBLICATION;

3045 break;

3046

3047 case T_AlterPublicationStmt:

3048 tag = CMDTAG_ALTER_PUBLICATION;

3049 break;

3050

3051 case T_CreateSubscriptionStmt:

3052 tag = CMDTAG_CREATE_SUBSCRIPTION;

3053 break;

3054

3055 case T_AlterSubscriptionStmt:

3056 tag = CMDTAG_ALTER_SUBSCRIPTION;

3057 break;

3058

3059 case T_DropSubscriptionStmt:

3060 tag = CMDTAG_DROP_SUBSCRIPTION;

3061 break;

3062

3063 case T_AlterCollationStmt:

3064 tag = CMDTAG_ALTER_COLLATION;

3065 break;

3066

3067 case T_PrepareStmt:

3068 tag = CMDTAG_PREPARE;

3069 break;

3070

3071 case T_ExecuteStmt:

3072 tag = CMDTAG_EXECUTE;

3073 break;

3074

3075 case T_CreateStatsStmt:

3076 tag = CMDTAG_CREATE_STATISTICS;

3077 break;

3078

3079 case T_AlterStatsStmt:

3080 tag = CMDTAG_ALTER_STATISTICS;

3081 break;

3082

3083 case T_DeallocateStmt:

3084 {

3085 DeallocateStmt *stmt = (DeallocateStmt *) parsetree;

3086

3087 if (stmt->name == NULL)

3088 tag = CMDTAG_DEALLOCATE_ALL;

3089 else

3090 tag = CMDTAG_DEALLOCATE;

3091 }

3092 break;

3093

3094 /* already-planned queries */

3095 case T_PlannedStmt:

3096 {

3097 PlannedStmt *stmt = (PlannedStmt *) parsetree;

3098

3099 switch (stmt->commandType)

3100 {

3101 case CMD_SELECT:

3102

3103 /*

3104 * We take a little extra care here so that the result

3105 * will be useful for complaints about read-only

3106 * statements

3107 */

3108 if (stmt->rowMarks != NIL)

3109 {

3110 /* not 100% but probably close enough */

3111 switch (((PlanRowMark *) linitial(stmt->rowMarks))->strength)

3112 {

3113 case LCS_FORKEYSHARE:

3114 tag = CMDTAG_SELECT_FOR_KEY_SHARE;

3115 break;

3116 case LCS_FORSHARE:

3117 tag = CMDTAG_SELECT_FOR_SHARE;

3118 break;

3119 case LCS_FORNOKEYUPDATE:

3120 tag = CMDTAG_SELECT_FOR_NO_KEY_UPDATE;

3121 break;

3122 case LCS_FORUPDATE:

3123 tag = CMDTAG_SELECT_FOR_UPDATE;

3124 break;

3125 default:

3126 tag = CMDTAG_SELECT;

3127 break;

3128 }

3129 }

3130 else

3131 tag = CMDTAG_SELECT;

3132 break;

3133 case CMD_UPDATE:

3134 tag = CMDTAG_UPDATE;

3135 break;

3136 case CMD_INSERT:

3137 tag = CMDTAG_INSERT;

3138 break;

3139 case CMD_DELETE:

3140 tag = CMDTAG_DELETE;

3141 break;

3142 case CMD_MERGE:

3143 tag = CMDTAG_MERGE;

3144 break;

3145 case CMD_UTILITY:

3146 tag = CreateCommandTag(stmt->utilityStmt);

3147 break;

3148 default:

3149 elog(WARNING, "unrecognized commandType: %d",

3150 (int) stmt->commandType);

3151 tag = CMDTAG_UNKNOWN;

3152 break;

3153 }

3154 }

3155 break;

3156

3157 /* parsed-and-rewritten-but-not-planned queries */

3158 case T_Query:

3159 {

3160 Query *stmt = (Query *) parsetree;

3161

3162 switch (stmt->commandType)

3163 {

3164 case CMD_SELECT:

3165

3166 /*

3167 * We take a little extra care here so that the result

3168 * will be useful for complaints about read-only

3169 * statements

3170 */

3171 if (stmt->rowMarks != NIL)

3172 {

3173 /* not 100% but probably close enough */

3174 switch (((RowMarkClause *) linitial(stmt->rowMarks))->strength)

3175 {

3176 case LCS_FORKEYSHARE:

3177 tag = CMDTAG_SELECT_FOR_KEY_SHARE;

3178 break;

3179 case LCS_FORSHARE:

3180 tag = CMDTAG_SELECT_FOR_SHARE;

3181 break;

3182 case LCS_FORNOKEYUPDATE:

3183 tag = CMDTAG_SELECT_FOR_NO_KEY_UPDATE;

3184 break;

3185 case LCS_FORUPDATE:

3186 tag = CMDTAG_SELECT_FOR_UPDATE;

3187 break;

3188 default:

3189 tag = CMDTAG_UNKNOWN;

3190 break;

3191 }

3192 }

3193 else

3194 tag = CMDTAG_SELECT;

3195 break;

3196 case CMD_UPDATE:

3197 tag = CMDTAG_UPDATE;

3198 break;

3199 case CMD_INSERT:

3200 tag = CMDTAG_INSERT;

3201 break;

3202 case CMD_DELETE:

3203 tag = CMDTAG_DELETE;

3204 break;

3205 case CMD_MERGE:

3206 tag = CMDTAG_MERGE;

3207 break;

3208 case CMD_UTILITY:

3209 tag = CreateCommandTag(stmt->utilityStmt);

3210 break;

3211 default:

3212 elog(WARNING, "unrecognized commandType: %d",

3213 (int) stmt->commandType);

3214 tag = CMDTAG_UNKNOWN;

3215 break;

3216 }

3217 }

3218 break;

3219

3220 default:

3221 elog(WARNING, "unrecognized node type: %d",

3222 (int) nodeTag(parsetree));

3223 tag = CMDTAG_UNKNOWN;

3224 break;

3225 }

3226

3227 return tag;

3228}

CommandTag

Definition: cmdtag.h:23

stmt

#define stmt

Definition: indent_codes.h:59

LCS_FORUPDATE

@ LCS_FORUPDATE

Definition: lockoptions.h:27

LCS_FORSHARE

@ LCS_FORSHARE

Definition: lockoptions.h:25

LCS_FORKEYSHARE

@ LCS_FORKEYSHARE

Definition: lockoptions.h:24

LCS_FORNOKEYUPDATE

@ LCS_FORNOKEYUPDATE

Definition: lockoptions.h:26

nodeTag

#define nodeTag(nodeptr)

Definition: nodes.h:139

TRANS_STMT_ROLLBACK_TO

@ TRANS_STMT_ROLLBACK_TO

Definition: parsenodes.h:3797

TRANS_STMT_START

@ TRANS_STMT_START

Definition: parsenodes.h:3792

TRANS_STMT_SAVEPOINT

@ TRANS_STMT_SAVEPOINT

Definition: parsenodes.h:3795

TRANS_STMT_BEGIN

@ TRANS_STMT_BEGIN

Definition: parsenodes.h:3791

TRANS_STMT_ROLLBACK

@ TRANS_STMT_ROLLBACK

Definition: parsenodes.h:3794

TRANS_STMT_COMMIT_PREPARED

@ TRANS_STMT_COMMIT_PREPARED

Definition: parsenodes.h:3799

TRANS_STMT_COMMIT

@ TRANS_STMT_COMMIT

Definition: parsenodes.h:3793

TRANS_STMT_ROLLBACK_PREPARED

@ TRANS_STMT_ROLLBACK_PREPARED

Definition: parsenodes.h:3800

TRANS_STMT_PREPARE

@ TRANS_STMT_PREPARE

Definition: parsenodes.h:3798

TRANS_STMT_RELEASE

@ TRANS_STMT_RELEASE

Definition: parsenodes.h:3796

VAR_SET_DEFAULT

@ VAR_SET_DEFAULT

Definition: parsenodes.h:2695

VAR_RESET

@ VAR_RESET

Definition: parsenodes.h:2698

VAR_SET_MULTI

@ VAR_SET_MULTI

Definition: parsenodes.h:2697

VAR_SET_VALUE

@ VAR_SET_VALUE

Definition: parsenodes.h:2694

VAR_SET_CURRENT

@ VAR_SET_CURRENT

Definition: parsenodes.h:2696

VAR_RESET_ALL

@ VAR_RESET_ALL

Definition: parsenodes.h:2699

OBJECT_EVENT_TRIGGER

@ OBJECT_EVENT_TRIGGER

Definition: parsenodes.h:2339

OBJECT_FDW

@ OBJECT_FDW

Definition: parsenodes.h:2341

OBJECT_TSPARSER

@ OBJECT_TSPARSER

Definition: parsenodes.h:2372

OBJECT_COLLATION

@ OBJECT_COLLATION

Definition: parsenodes.h:2332

OBJECT_ACCESS_METHOD

@ OBJECT_ACCESS_METHOD

Definition: parsenodes.h:2325

OBJECT_OPCLASS

@ OBJECT_OPCLASS

Definition: parsenodes.h:2349

OBJECT_AGGREGATE

@ OBJECT_AGGREGATE

Definition: parsenodes.h:2326

OBJECT_MATVIEW

@ OBJECT_MATVIEW

Definition: parsenodes.h:2348

OBJECT_SCHEMA

@ OBJECT_SCHEMA

Definition: parsenodes.h:2361

OBJECT_POLICY

@ OBJECT_POLICY

Definition: parsenodes.h:2353

OBJECT_OPERATOR

@ OBJECT_OPERATOR

Definition: parsenodes.h:2350

OBJECT_FOREIGN_TABLE

@ OBJECT_FOREIGN_TABLE

Definition: parsenodes.h:2343

OBJECT_TSCONFIGURATION

@ OBJECT_TSCONFIGURATION

Definition: parsenodes.h:2370

OBJECT_OPFAMILY

@ OBJECT_OPFAMILY

Definition: parsenodes.h:2351

OBJECT_DOMAIN

@ OBJECT_DOMAIN

Definition: parsenodes.h:2337

OBJECT_COLUMN

@ OBJECT_COLUMN

Definition: parsenodes.h:2331

OBJECT_ROUTINE

@ OBJECT_ROUTINE

Definition: parsenodes.h:2359

OBJECT_PROCEDURE

@ OBJECT_PROCEDURE

Definition: parsenodes.h:2354

OBJECT_EXTENSION

@ OBJECT_EXTENSION

Definition: parsenodes.h:2340

OBJECT_INDEX

@ OBJECT_INDEX

Definition: parsenodes.h:2345

OBJECT_SEQUENCE

@ OBJECT_SEQUENCE

Definition: parsenodes.h:2362

OBJECT_TSTEMPLATE

@ OBJECT_TSTEMPLATE

Definition: parsenodes.h:2373

OBJECT_LANGUAGE

@ OBJECT_LANGUAGE

Definition: parsenodes.h:2346

OBJECT_FOREIGN_SERVER

@ OBJECT_FOREIGN_SERVER

Definition: parsenodes.h:2342

OBJECT_TSDICTIONARY

@ OBJECT_TSDICTIONARY

Definition: parsenodes.h:2371

OBJECT_PUBLICATION

@ OBJECT_PUBLICATION

Definition: parsenodes.h:2355

OBJECT_RULE

@ OBJECT_RULE

Definition: parsenodes.h:2360

OBJECT_CONVERSION

@ OBJECT_CONVERSION

Definition: parsenodes.h:2333

OBJECT_TABLE

@ OBJECT_TABLE

Definition: parsenodes.h:2366

OBJECT_VIEW

@ OBJECT_VIEW

Definition: parsenodes.h:2376

OBJECT_TYPE

@ OBJECT_TYPE

Definition: parsenodes.h:2374

OBJECT_FUNCTION

@ OBJECT_FUNCTION

Definition: parsenodes.h:2344

OBJECT_STATISTIC_EXT

@ OBJECT_STATISTIC_EXT

Definition: parsenodes.h:2364

OBJECT_CAST

@ OBJECT_CAST

Definition: parsenodes.h:2330

OBJECT_TRIGGER

@ OBJECT_TRIGGER

Definition: parsenodes.h:2369

OBJECT_TRANSFORM

@ OBJECT_TRANSFORM

Definition: parsenodes.h:2368

DISCARD_ALL

@ DISCARD_ALL

Definition: parsenodes.h:4063

DISCARD_PLANS

@ DISCARD_PLANS

Definition: parsenodes.h:4064

DISCARD_SEQUENCES

@ DISCARD_SEQUENCES

Definition: parsenodes.h:4065

DISCARD_TEMP

@ DISCARD_TEMP

Definition: parsenodes.h:4066

linitial

#define linitial(l)

Definition: pg_list.h:178

AlterFunctionStmt

Definition: parsenodes.h:3597

AlterObjectDependsStmt

Definition: parsenodes.h:3680

AlterObjectSchemaStmt

Definition: parsenodes.h:3694

AlterOwnerStmt

Definition: parsenodes.h:3708

AlterTableMoveAllStmt

Definition: parsenodes.h:2910

AlterTableStmt

Definition: parsenodes.h:2407

ClosePortalStmt

Definition: parsenodes.h:3411

CreateFunctionStmt

Definition: parsenodes.h:3563

CreateTableAsStmt

Definition: parsenodes.h:4025

DeallocateStmt

Definition: parsenodes.h:4194

DefineStmt

Definition: parsenodes.h:3246

DiscardStmt

Definition: parsenodes.h:4070

DropStmt

Definition: parsenodes.h:3332

FetchStmt

Definition: parsenodes.h:3450

GrantRoleStmt

Definition: parsenodes.h:2641

GrantStmt

Definition: parsenodes.h:2576

PlanRowMark

Definition: plannodes.h:1578

Query

Definition: parsenodes.h:118

RawStmt

Definition: parsenodes.h:2084

RenameStmt

Definition: parsenodes.h:3662

RowMarkClause

Definition: parsenodes.h:1608

TransactionStmt

Definition: parsenodes.h:3804

VacuumStmt

Definition: parsenodes.h:3974

VariableSetStmt

Definition: parsenodes.h:2703

CreateCommandTag

CommandTag CreateCommandTag(Node *parsetree)

Definition: utility.c:2354

AlterObjectTypeCommandTag

static CommandTag AlterObjectTypeCommandTag(ObjectType objtype)

Definition: utility.c:2208

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().

◆ GetCommandLogLevel()

LogStmtLevel GetCommandLogLevel ( Node * parsetree )

Definition at line 3241 of file utility.c.

3242{

3243 LogStmtLevel lev;

3244

3245 switch (nodeTag(parsetree))

3246 {

3247 /* recurse if we're given a RawStmt */

3248 case T_RawStmt:

3249 lev = GetCommandLogLevel(((RawStmt *) parsetree)->stmt);

3250 break;

3251

3252 /* raw plannable queries */

3253 case T_InsertStmt:

3254 case T_DeleteStmt:

3255 case T_UpdateStmt:

3256 case T_MergeStmt:

3257 lev = LOGSTMT_MOD;

3258 break;

3259

3260 case T_SelectStmt:

3261 if (((SelectStmt *) parsetree)->intoClause)

3262 lev = LOGSTMT_DDL; /* SELECT INTO */

3263 else

3264 lev = LOGSTMT_ALL;

3265 break;

3266

3267 case T_PLAssignStmt:

3268 lev = LOGSTMT_ALL;

3269 break;

3270

3271 /* utility statements --- same whether raw or cooked */

3272 case T_TransactionStmt:

3273 lev = LOGSTMT_ALL;

3274 break;

3275

3276 case T_DeclareCursorStmt:

3277 lev = LOGSTMT_ALL;

3278 break;

3279

3280 case T_ClosePortalStmt:

3281 lev = LOGSTMT_ALL;

3282 break;

3283

3284 case T_FetchStmt:

3285 lev = LOGSTMT_ALL;

3286 break;

3287

3288 case T_CreateSchemaStmt:

3289 lev = LOGSTMT_DDL;

3290 break;

3291

3292 case T_CreateStmt:

3293 case T_CreateForeignTableStmt:

3294 lev = LOGSTMT_DDL;

3295 break;

3296

3297 case T_CreateTableSpaceStmt:

3298 case T_DropTableSpaceStmt:

3299 case T_AlterTableSpaceOptionsStmt:

3300 lev = LOGSTMT_DDL;

3301 break;

3302

3303 case T_CreateExtensionStmt:

3304 case T_AlterExtensionStmt:

3305 case T_AlterExtensionContentsStmt:

3306 lev = LOGSTMT_DDL;

3307 break;

3308

3309 case T_CreateFdwStmt:

3310 case T_AlterFdwStmt:

3311 case T_CreateForeignServerStmt:

3312 case T_AlterForeignServerStmt:

3313 case T_CreateUserMappingStmt:

3314 case T_AlterUserMappingStmt:

3315 case T_DropUserMappingStmt:

3316 case T_ImportForeignSchemaStmt:

3317 lev = LOGSTMT_DDL;

3318 break;

3319

3320 case T_DropStmt:

3321 lev = LOGSTMT_DDL;

3322 break;

3323

3324 case T_TruncateStmt:

3325 lev = LOGSTMT_MOD;

3326 break;

3327

3328 case T_CommentStmt:

3329 lev = LOGSTMT_DDL;

3330 break;

3331

3332 case T_SecLabelStmt:

3333 lev = LOGSTMT_DDL;

3334 break;

3335

3336 case T_CopyStmt:

3337 if (((CopyStmt *) parsetree)->is_from)

3338 lev = LOGSTMT_MOD;

3339 else

3340 lev = LOGSTMT_ALL;

3341 break;

3342

3343 case T_PrepareStmt:

3344 {

3345 PrepareStmt *stmt = (PrepareStmt *) parsetree;

3346

3347 /* Look through a PREPARE to the contained stmt */

3348 lev = GetCommandLogLevel(stmt->query);

3349 }

3350 break;

3351

3352 case T_ExecuteStmt:

3353 {

3354 ExecuteStmt *stmt = (ExecuteStmt *) parsetree;

3355 PreparedStatement *ps;

3356

3357 /* Look through an EXECUTE to the referenced stmt */

3358 ps = FetchPreparedStatement(stmt->name, false);

3359 if (ps && ps->plansource->raw_parse_tree)

3360 lev = GetCommandLogLevel(ps->plansource->raw_parse_tree->stmt);

3361 else

3362 lev = LOGSTMT_ALL;

3363 }

3364 break;

3365

3366 case T_DeallocateStmt:

3367 lev = LOGSTMT_ALL;

3368 break;

3369

3370 case T_RenameStmt:

3371 lev = LOGSTMT_DDL;

3372 break;

3373

3374 case T_AlterObjectDependsStmt:

3375 lev = LOGSTMT_DDL;

3376 break;

3377

3378 case T_AlterObjectSchemaStmt:

3379 lev = LOGSTMT_DDL;

3380 break;

3381

3382 case T_AlterOwnerStmt:

3383 lev = LOGSTMT_DDL;

3384 break;

3385

3386 case T_AlterOperatorStmt:

3387 lev = LOGSTMT_DDL;

3388 break;

3389

3390 case T_AlterTypeStmt:

3391 lev = LOGSTMT_DDL;

3392 break;

3393

3394 case T_AlterTableMoveAllStmt:

3395 case T_AlterTableStmt:

3396 lev = LOGSTMT_DDL;

3397 break;

3398

3399 case T_AlterDomainStmt:

3400 lev = LOGSTMT_DDL;

3401 break;

3402

3403 case T_GrantStmt:

3404 lev = LOGSTMT_DDL;

3405 break;

3406

3407 case T_GrantRoleStmt:

3408 lev = LOGSTMT_DDL;

3409 break;

3410

3411 case T_AlterDefaultPrivilegesStmt:

3412 lev = LOGSTMT_DDL;

3413 break;

3414

3415 case T_DefineStmt:

3416 lev = LOGSTMT_DDL;

3417 break;

3418

3419 case T_CompositeTypeStmt:

3420 lev = LOGSTMT_DDL;

3421 break;

3422

3423 case T_CreateEnumStmt:

3424 lev = LOGSTMT_DDL;

3425 break;

3426

3427 case T_CreateRangeStmt:

3428 lev = LOGSTMT_DDL;

3429 break;

3430

3431 case T_AlterEnumStmt:

3432 lev = LOGSTMT_DDL;

3433 break;

3434

3435 case T_ViewStmt:

3436 lev = LOGSTMT_DDL;

3437 break;

3438

3439 case T_CreateFunctionStmt:

3440 lev = LOGSTMT_DDL;

3441 break;

3442

3443 case T_AlterFunctionStmt:

3444 lev = LOGSTMT_DDL;

3445 break;

3446

3447 case T_IndexStmt:

3448 lev = LOGSTMT_DDL;

3449 break;

3450

3451 case T_RuleStmt:

3452 lev = LOGSTMT_DDL;

3453 break;

3454

3455 case T_CreateSeqStmt:

3456 lev = LOGSTMT_DDL;

3457 break;

3458

3459 case T_AlterSeqStmt:

3460 lev = LOGSTMT_DDL;

3461 break;

3462

3463 case T_DoStmt:

3464 lev = LOGSTMT_ALL;

3465 break;

3466

3467 case T_CreatedbStmt:

3468 lev = LOGSTMT_DDL;

3469 break;

3470

3471 case T_AlterDatabaseStmt:

3472 case T_AlterDatabaseRefreshCollStmt:

3473 case T_AlterDatabaseSetStmt:

3474 lev = LOGSTMT_DDL;

3475 break;

3476

3477 case T_DropdbStmt:

3478 lev = LOGSTMT_DDL;

3479 break;

3480

3481 case T_NotifyStmt:

3482 lev = LOGSTMT_ALL;

3483 break;

3484

3485 case T_ListenStmt:

3486 lev = LOGSTMT_ALL;

3487 break;

3488

3489 case T_UnlistenStmt:

3490 lev = LOGSTMT_ALL;

3491 break;

3492

3493 case T_LoadStmt:

3494 lev = LOGSTMT_ALL;

3495 break;

3496

3497 case T_CallStmt:

3498 lev = LOGSTMT_ALL;

3499 break;

3500

3501 case T_ClusterStmt:

3502 lev = LOGSTMT_DDL;

3503 break;

3504

3505 case T_VacuumStmt:

3506 lev = LOGSTMT_ALL;

3507 break;

3508

3509 case T_ExplainStmt:

3510 {

3511 ExplainStmt *stmt = (ExplainStmt *) parsetree;

3512 bool analyze = false;

3513 ListCell *lc;

3514

3515 /* Look through an EXPLAIN ANALYZE to the contained stmt */

3516 foreach(lc, stmt->options)

3517 {

3518 DefElem *opt = (DefElem *) lfirst(lc);

3519

3520 if (strcmp(opt->defname, "analyze") == 0)

3521 analyze = defGetBoolean(opt);

3522 /* don't "break", as explain.c will use the last value */

3523 }

3524 if (analyze)

3525 return GetCommandLogLevel(stmt->query);

3526

3527 /* Plain EXPLAIN isn't so interesting */

3528 lev = LOGSTMT_ALL;

3529 }

3530 break;

3531

3532 case T_CreateTableAsStmt:

3533 lev = LOGSTMT_DDL;

3534 break;

3535

3536 case T_RefreshMatViewStmt:

3537 lev = LOGSTMT_DDL;

3538 break;

3539

3540 case T_AlterSystemStmt:

3541 lev = LOGSTMT_DDL;

3542 break;

3543

3544 case T_VariableSetStmt:

3545 lev = LOGSTMT_ALL;

3546 break;

3547

3548 case T_VariableShowStmt:

3549 lev = LOGSTMT_ALL;

3550 break;

3551

3552 case T_DiscardStmt:

3553 lev = LOGSTMT_ALL;

3554 break;

3555

3556 case T_CreateTrigStmt:

3557 lev = LOGSTMT_DDL;

3558 break;

3559

3560 case T_CreateEventTrigStmt:

3561 lev = LOGSTMT_DDL;

3562 break;

3563

3564 case T_AlterEventTrigStmt:

3565 lev = LOGSTMT_DDL;

3566 break;

3567

3568 case T_CreatePLangStmt:

3569 lev = LOGSTMT_DDL;

3570 break;

3571

3572 case T_CreateDomainStmt:

3573 lev = LOGSTMT_DDL;

3574 break;

3575

3576 case T_CreateRoleStmt:

3577 lev = LOGSTMT_DDL;

3578 break;

3579

3580 case T_AlterRoleStmt:

3581 lev = LOGSTMT_DDL;

3582 break;

3583

3584 case T_AlterRoleSetStmt:

3585 lev = LOGSTMT_DDL;

3586 break;

3587

3588 case T_DropRoleStmt:

3589 lev = LOGSTMT_DDL;

3590 break;

3591

3592 case T_DropOwnedStmt:

3593 lev = LOGSTMT_DDL;

3594 break;

3595

3596 case T_ReassignOwnedStmt:

3597 lev = LOGSTMT_DDL;

3598 break;

3599

3600 case T_LockStmt:

3601 lev = LOGSTMT_ALL;

3602 break;

3603

3604 case T_ConstraintsSetStmt:

3605 lev = LOGSTMT_ALL;

3606 break;

3607

3608 case T_CheckPointStmt:

3609 lev = LOGSTMT_ALL;

3610 break;

3611

3612 case T_ReindexStmt:

3613 lev = LOGSTMT_ALL; /* should this be DDL? */

3614 break;

3615

3616 case T_CreateConversionStmt:

3617 lev = LOGSTMT_DDL;

3618 break;

3619

3620 case T_CreateCastStmt:

3621 lev = LOGSTMT_DDL;

3622 break;

3623

3624 case T_CreateOpClassStmt:

3625 lev = LOGSTMT_DDL;

3626 break;

3627

3628 case T_CreateOpFamilyStmt:

3629 lev = LOGSTMT_DDL;

3630 break;

3631

3632 case T_CreateTransformStmt:

3633 lev = LOGSTMT_DDL;

3634 break;

3635

3636 case T_AlterOpFamilyStmt:

3637 lev = LOGSTMT_DDL;

3638 break;

3639

3640 case T_CreatePolicyStmt:

3641 lev = LOGSTMT_DDL;

3642 break;

3643

3644 case T_AlterPolicyStmt:

3645 lev = LOGSTMT_DDL;

3646 break;

3647

3648 case T_AlterTSDictionaryStmt:

3649 lev = LOGSTMT_DDL;

3650 break;

3651

3652 case T_AlterTSConfigurationStmt:

3653 lev = LOGSTMT_DDL;

3654 break;

3655

3656 case T_CreateAmStmt:

3657 lev = LOGSTMT_DDL;

3658 break;

3659

3660 case T_CreatePublicationStmt:

3661 lev = LOGSTMT_DDL;

3662 break;

3663

3664 case T_AlterPublicationStmt:

3665 lev = LOGSTMT_DDL;

3666 break;

3667

3668 case T_CreateSubscriptionStmt:

3669 lev = LOGSTMT_DDL;

3670 break;

3671

3672 case T_AlterSubscriptionStmt:

3673 lev = LOGSTMT_DDL;

3674 break;

3675

3676 case T_DropSubscriptionStmt:

3677 lev = LOGSTMT_DDL;

3678 break;

3679

3680 case T_CreateStatsStmt:

3681 lev = LOGSTMT_DDL;

3682 break;

3683

3684 case T_AlterStatsStmt:

3685 lev = LOGSTMT_DDL;

3686 break;

3687

3688 case T_AlterCollationStmt:

3689 lev = LOGSTMT_DDL;

3690 break;

3691

3692 /* already-planned queries */

3693 case T_PlannedStmt:

3694 {

3695 PlannedStmt *stmt = (PlannedStmt *) parsetree;

3696

3697 switch (stmt->commandType)

3698 {

3699 case CMD_SELECT:

3700 lev = LOGSTMT_ALL;

3701 break;

3702

3703 case CMD_UPDATE:

3704 case CMD_INSERT:

3705 case CMD_DELETE:

3706 case CMD_MERGE:

3707 lev = LOGSTMT_MOD;

3708 break;

3709

3710 case CMD_UTILITY:

3711 lev = GetCommandLogLevel(stmt->utilityStmt);

3712 break;

3713

3714 default:

3715 elog(WARNING, "unrecognized commandType: %d",

3716 (int) stmt->commandType);

3717 lev = LOGSTMT_ALL;

3718 break;

3719 }

3720 }

3721 break;

3722

3723 /* parsed-and-rewritten-but-not-planned queries */

3724 case T_Query:

3725 {

3726 Query *stmt = (Query *) parsetree;

3727

3728 switch (stmt->commandType)

3729 {

3730 case CMD_SELECT:

3731 lev = LOGSTMT_ALL;

3732 break;

3733

3734 case CMD_UPDATE:

3735 case CMD_INSERT:

3736 case CMD_DELETE:

3737 case CMD_MERGE:

3738 lev = LOGSTMT_MOD;

3739 break;

3740

3741 case CMD_UTILITY:

3742 lev = GetCommandLogLevel(stmt->utilityStmt);

3743 break;

3744

3745 default:

3746 elog(WARNING, "unrecognized commandType: %d",

3747 (int) stmt->commandType);

3748 lev = LOGSTMT_ALL;

3749 break;

3750 }

3751 }

3752 break;

3753

3754 default:

3755 elog(WARNING, "unrecognized node type: %d",

3756 (int) nodeTag(parsetree));

3757 lev = LOGSTMT_ALL;

3758 break;

3759 }

3760

3761 return lev;

3762}

FetchPreparedStatement

PreparedStatement * FetchPreparedStatement(const char *stmt_name, bool throwError)

Definition: prepare.c:434

defGetBoolean

bool defGetBoolean(DefElem *def)

Definition: define.c:94

ps

struct parser_state ps

lfirst

#define lfirst(lc)

Definition: pg_list.h:172

analyze

static long analyze(struct nfa *nfa)

Definition: regc_nfa.c:3051

CopyStmt

Definition: parsenodes.h:2671

DefElem

Definition: parsenodes.h:840

DefElem::defname

char * defname

Definition: parsenodes.h:843

ExecuteStmt

Definition: parsenodes.h:4182

ExplainStmt

Definition: parsenodes.h:4005

PrepareStmt

Definition: parsenodes.h:4168

PreparedStatement

Definition: prepare.h:29

SelectStmt

Definition: parsenodes.h:2183

LogStmtLevel

Definition: tcopprot.h:32

LOGSTMT_MOD

@ LOGSTMT_MOD

Definition: tcopprot.h:35

LOGSTMT_DDL

@ LOGSTMT_DDL

Definition: tcopprot.h:34

LOGSTMT_ALL

@ LOGSTMT_ALL

Definition: tcopprot.h:36

ListCell

Definition: pg_list.h:46

GetCommandLogLevel

LogStmtLevel GetCommandLogLevel(Node *parsetree)

Definition: utility.c:3241

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().

◆ ProcessUtility()

void ProcessUtility ( PlannedStmt * pstmt,

const char * queryString,

bool readOnlyTree,

ProcessUtilityContext context,

ParamListInfo params,

QueryEnvironment * queryEnv,

DestReceiver * dest,

QueryCompletion * qc

)

Definition at line 499 of file utility.c.

507{

508 Assert(IsA(pstmt, PlannedStmt));

509 Assert(pstmt->commandType == CMD_UTILITY);

510 Assert(queryString != NULL); /* required as of 8.4 */

511 Assert(qc == NULL || qc->commandTag == CMDTAG_UNKNOWN);

512

513 /*

514 * We provide a function hook variable that lets loadable plugins get

515 * control when ProcessUtility is called. Such a plugin would normally

516 * call standard_ProcessUtility().

517 */

518 if (ProcessUtility_hook)

519 (*ProcessUtility_hook) (pstmt, queryString, readOnlyTree,

520 context, params, queryEnv,

521 dest, qc);

522 else

523 standard_ProcessUtility(pstmt, queryString, readOnlyTree,

524 context, params, queryEnv,

525 dest, qc);

526}

generate_unaccent_rules.dest

dest

Definition: generate_unaccent_rules.py:285

QueryCompletion::commandTag

CommandTag commandTag

Definition: cmdtag.h:31

standard_ProcessUtility

void standard_ProcessUtility(PlannedStmt *pstmt, const char *queryString, bool readOnlyTree, ProcessUtilityContext context, ParamListInfo params, QueryEnvironment *queryEnv, DestReceiver *dest, QueryCompletion *qc)

Definition: utility.c:543

ProcessUtility_hook

ProcessUtility_hook_type ProcessUtility_hook

Definition: utility.c:70

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 1950 of file utility.c.

1951{

1952 PlannedStmt *wrapper;

1953

1954 /*

1955 * For event triggers, we must "close" the current complex-command set,

1956 * and start a new one afterwards; this is needed to ensure the ordering

1957 * of command events is consistent with the way they were executed.

1958 */

1959 EventTriggerAlterTableEnd();

1960

1961 /* Create a suitable wrapper */

1962 wrapper = makeNode(PlannedStmt);

1963 wrapper->commandType = CMD_UTILITY;

1964 wrapper->canSetTag = false;

1965 wrapper->utilityStmt = stmt;

1966 wrapper->stmt_location = context->pstmt->stmt_location;

1967 wrapper->stmt_len = context->pstmt->stmt_len;

1968 wrapper->planOrigin = PLAN_STMT_INTERNAL;

1969

1970 ProcessUtility(wrapper,

1971 context->queryString,

1972 false,

1973 PROCESS_UTILITY_SUBCOMMAND,

1974 context->params,

1975 context->queryEnv,

1976 None_Receiver,

1977 NULL);

1978

1979 EventTriggerAlterTableStart(context->pstmt->utilityStmt);

1980 EventTriggerAlterTableRelid(context->relid);

1981}

None_Receiver

DestReceiver * None_Receiver

Definition: dest.c:96

EventTriggerAlterTableStart

void EventTriggerAlterTableStart(Node *parsetree)

Definition: event_trigger.c:1753

EventTriggerAlterTableRelid

void EventTriggerAlterTableRelid(Oid objectId)

Definition: event_trigger.c:1787

EventTriggerAlterTableEnd

void EventTriggerAlterTableEnd(void)

Definition: event_trigger.c:1840

makeNode

#define makeNode(_type_)

Definition: nodes.h:161

PLAN_STMT_INTERNAL

@ PLAN_STMT_INTERNAL

Definition: plannodes.h:40

AlterTableUtilityContext::params

ParamListInfo params

Definition: utility.h:35

AlterTableUtilityContext::relid

Oid relid

Definition: utility.h:34

AlterTableUtilityContext::queryEnv

QueryEnvironment * queryEnv

Definition: utility.h:36

AlterTableUtilityContext::pstmt

PlannedStmt * pstmt

Definition: utility.h:32

AlterTableUtilityContext::queryString

const char * queryString

Definition: utility.h:33

PlannedStmt::canSetTag

bool canSetTag

Definition: plannodes.h:86

PlannedStmt::stmt_len

ParseLoc stmt_len

Definition: plannodes.h:156

PlannedStmt::planOrigin

PlannedStmtOrigin planOrigin

Definition: plannodes.h:77

PlannedStmt::stmt_location

ParseLoc stmt_location

Definition: plannodes.h:154

PlannedStmt::utilityStmt

Node * utilityStmt

Definition: plannodes.h:150

ProcessUtility

void ProcessUtility(PlannedStmt *pstmt, const char *queryString, bool readOnlyTree, ProcessUtilityContext context, ParamListInfo params, QueryEnvironment *queryEnv, DestReceiver *dest, QueryCompletion *qc)

Definition: utility.c:499

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().

◆ 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 543 of file utility.c.

551{

552 Node *parsetree;

553 bool isTopLevel = (context == PROCESS_UTILITY_TOPLEVEL);

554 bool isAtomicContext = (!(context == PROCESS_UTILITY_TOPLEVEL || context == PROCESS_UTILITY_QUERY_NONATOMIC) || IsTransactionBlock());

555 ParseState *pstate;

556 int readonly_flags;

557

558 /* This can recurse, so check for excessive recursion */

559 check_stack_depth();

560

561 /*

562 * If the given node tree is read-only, make a copy to ensure that parse

563 * transformations don't damage the original tree. This could be

564 * refactored to avoid making unnecessary copies in more cases, but it's

565 * not clear that it's worth a great deal of trouble over. Statements

566 * that are complex enough to be expensive to copy are exactly the ones

567 * we'd need to copy, so that only marginal savings seem possible.

568 */

569 if (readOnlyTree)

570 pstmt = copyObject(pstmt);

571 parsetree = pstmt->utilityStmt;

572

573 /* Prohibit read/write commands in read-only states. */

574 readonly_flags = ClassifyUtilityCommandAsReadOnly(parsetree);

575 if (readonly_flags != COMMAND_IS_STRICTLY_READ_ONLY &&

576 (XactReadOnly || IsInParallelMode()))

577 {

578 CommandTag commandtag = CreateCommandTag(parsetree);

579

580 if ((readonly_flags & COMMAND_OK_IN_READ_ONLY_TXN) == 0)

581 PreventCommandIfReadOnly(GetCommandTagName(commandtag));

582 if ((readonly_flags & COMMAND_OK_IN_PARALLEL_MODE) == 0)

583 PreventCommandIfParallelMode(GetCommandTagName(commandtag));

584 if ((readonly_flags & COMMAND_OK_IN_RECOVERY) == 0)

585 PreventCommandDuringRecovery(GetCommandTagName(commandtag));

586 }

587

588 pstate = make_parsestate(NULL);

589 pstate->p_sourcetext = queryString;

590 pstate->p_queryEnv = queryEnv;

591

592 switch (nodeTag(parsetree))

593 {

594 /*

595 * ******************** transactions ********************

596 */

597 case T_TransactionStmt:

598 {

599 TransactionStmt *stmt = (TransactionStmt *) parsetree;

600

601 switch (stmt->kind)

602 {

603 /*

604 * START TRANSACTION, as defined by SQL99: Identical

605 * to BEGIN. Same code for both.

606 */

607 case TRANS_STMT_BEGIN:

608 case TRANS_STMT_START:

609 {

610 ListCell *lc;

611

612 BeginTransactionBlock();

613 foreach(lc, stmt->options)

614 {

615 DefElem *item = (DefElem *) lfirst(lc);

616

617 if (strcmp(item->defname, "transaction_isolation") == 0)

618 SetPGVariable("transaction_isolation",

619 list_make1(item->arg),

620 true);

621 else if (strcmp(item->defname, "transaction_read_only") == 0)

622 SetPGVariable("transaction_read_only",

623 list_make1(item->arg),

624 true);

625 else if (strcmp(item->defname, "transaction_deferrable") == 0)

626 SetPGVariable("transaction_deferrable",

627 list_make1(item->arg),

628 true);

629 }

630 }

631 break;

632

633 case TRANS_STMT_COMMIT:

634 if (!EndTransactionBlock(stmt->chain))

635 {

636 /* report unsuccessful commit in qc */

637 if (qc)

638 SetQueryCompletion(qc, CMDTAG_ROLLBACK, 0);

639 }

640 break;

641

642 case TRANS_STMT_PREPARE:

643 if (!PrepareTransactionBlock(stmt->gid))

644 {

645 /* report unsuccessful commit in qc */

646 if (qc)

647 SetQueryCompletion(qc, CMDTAG_ROLLBACK, 0);

648 }

649 break;

650

651 case TRANS_STMT_COMMIT_PREPARED:

652 PreventInTransactionBlock(isTopLevel, "COMMIT PREPARED");

653 FinishPreparedTransaction(stmt->gid, true);

654 break;

655

656 case TRANS_STMT_ROLLBACK_PREPARED:

657 PreventInTransactionBlock(isTopLevel, "ROLLBACK PREPARED");

658 FinishPreparedTransaction(stmt->gid, false);

659 break;

660

661 case TRANS_STMT_ROLLBACK:

662 UserAbortTransactionBlock(stmt->chain);

663 break;

664

665 case TRANS_STMT_SAVEPOINT:

666 RequireTransactionBlock(isTopLevel, "SAVEPOINT");

667 DefineSavepoint(stmt->savepoint_name);

668 break;

669

670 case TRANS_STMT_RELEASE:

671 RequireTransactionBlock(isTopLevel, "RELEASE SAVEPOINT");

672 ReleaseSavepoint(stmt->savepoint_name);

673 break;

674

675 case TRANS_STMT_ROLLBACK_TO:

676 RequireTransactionBlock(isTopLevel, "ROLLBACK TO SAVEPOINT");

677 RollbackToSavepoint(stmt->savepoint_name);

678

679 /*

680 * CommitTransactionCommand is in charge of

681 * re-defining the savepoint again

682 */

683 break;

684 }

685 }

686 break;

687

688 /*

689 * Portal (cursor) manipulation

690 */

691 case T_DeclareCursorStmt:

692 PerformCursorOpen(pstate, (DeclareCursorStmt *) parsetree, params,

693 isTopLevel);

694 break;

695

696 case T_ClosePortalStmt:

697 {

698 ClosePortalStmt *stmt = (ClosePortalStmt *) parsetree;

699

700 CheckRestrictedOperation("CLOSE");

701 PerformPortalClose(stmt->portalname);

702 }

703 break;

704

705 case T_FetchStmt:

706 PerformPortalFetch((FetchStmt *) parsetree, dest, qc);

707 break;

708

709 case T_DoStmt:

710 ExecuteDoStmt(pstate, (DoStmt *) parsetree, isAtomicContext);

711 break;

712

713 case T_CreateTableSpaceStmt:

714 /* no event triggers for global objects */

715 PreventInTransactionBlock(isTopLevel, "CREATE TABLESPACE");

716 CreateTableSpace((CreateTableSpaceStmt *) parsetree);

717 break;

718

719 case T_DropTableSpaceStmt:

720 /* no event triggers for global objects */

721 PreventInTransactionBlock(isTopLevel, "DROP TABLESPACE");

722 DropTableSpace((DropTableSpaceStmt *) parsetree);

723 break;

724

725 case T_AlterTableSpaceOptionsStmt:

726 /* no event triggers for global objects */

727 AlterTableSpaceOptions((AlterTableSpaceOptionsStmt *) parsetree);

728 break;

729

730 case T_TruncateStmt:

731 ExecuteTruncate((TruncateStmt *) parsetree);

732 break;

733

734 case T_CopyStmt:

735 {

736 uint64 processed;

737

738 DoCopy(pstate, (CopyStmt *) parsetree,

739 pstmt->stmt_location, pstmt->stmt_len,

740 &processed);

741 if (qc)

742 SetQueryCompletion(qc, CMDTAG_COPY, processed);

743 }

744 break;

745

746 case T_PrepareStmt:

747 CheckRestrictedOperation("PREPARE");

748 PrepareQuery(pstate, (PrepareStmt *) parsetree,

749 pstmt->stmt_location, pstmt->stmt_len);

750 break;

751

752 case T_ExecuteStmt:

753 ExecuteQuery(pstate,

754 (ExecuteStmt *) parsetree, NULL,

755 params,

756 dest, qc);

757 break;

758

759 case T_DeallocateStmt:

760 CheckRestrictedOperation("DEALLOCATE");

761 DeallocateQuery((DeallocateStmt *) parsetree);

762 break;

763

764 case T_GrantRoleStmt:

765 /* no event triggers for global objects */

766 GrantRole(pstate, (GrantRoleStmt *) parsetree);

767 break;

768

769 case T_CreatedbStmt:

770 /* no event triggers for global objects */

771 PreventInTransactionBlock(isTopLevel, "CREATE DATABASE");

772 createdb(pstate, (CreatedbStmt *) parsetree);

773 break;

774

775 case T_AlterDatabaseStmt:

776 /* no event triggers for global objects */

777 AlterDatabase(pstate, (AlterDatabaseStmt *) parsetree, isTopLevel);

778 break;

779

780 case T_AlterDatabaseRefreshCollStmt:

781 /* no event triggers for global objects */

782 AlterDatabaseRefreshColl((AlterDatabaseRefreshCollStmt *) parsetree);

783 break;

784

785 case T_AlterDatabaseSetStmt:

786 /* no event triggers for global objects */

787 AlterDatabaseSet((AlterDatabaseSetStmt *) parsetree);

788 break;

789

790 case T_DropdbStmt:

791 /* no event triggers for global objects */

792 PreventInTransactionBlock(isTopLevel, "DROP DATABASE");

793 DropDatabase(pstate, (DropdbStmt *) parsetree);

794 break;

795

796 /* Query-level asynchronous notification */

797 case T_NotifyStmt:

798 {

799 NotifyStmt *stmt = (NotifyStmt *) parsetree;

800

801 Async_Notify(stmt->conditionname, stmt->payload);

802 }

803 break;

804

805 case T_ListenStmt:

806 {

807 ListenStmt *stmt = (ListenStmt *) parsetree;

808

809 CheckRestrictedOperation("LISTEN");

810

811 /*

812 * We don't allow LISTEN in background processes, as there is

813 * no mechanism for them to collect NOTIFY messages, so they'd

814 * just block cleanout of the async SLRU indefinitely.

815 * (Authors of custom background workers could bypass this

816 * restriction by calling Async_Listen directly, but then it's

817 * on them to provide some mechanism to process the message

818 * queue.) Note there seems no reason to forbid UNLISTEN.

819 */

820 if (MyBackendType != B_BACKEND)

821 ereport(ERROR,

822 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),

823 /* translator: %s is name of a SQL command, eg LISTEN */

824 errmsg("cannot execute %s within a background process",

825 "LISTEN")));

826

827 Async_Listen(stmt->conditionname);

828 }

829 break;

830

831 case T_UnlistenStmt:

832 {

833 UnlistenStmt *stmt = (UnlistenStmt *) parsetree;

834

835 CheckRestrictedOperation("UNLISTEN");

836 if (stmt->conditionname)

837 Async_Unlisten(stmt->conditionname);

838 else

839 Async_UnlistenAll();

840 }

841 break;

842

843 case T_LoadStmt:

844 {

845 LoadStmt *stmt = (LoadStmt *) parsetree;

846

847 closeAllVfds(); /* probably not necessary... */

848 /* Allowed names are restricted if you're not superuser */

849 load_file(stmt->filename, !superuser());

850 }

851 break;

852

853 case T_CallStmt:

854 ExecuteCallStmt(castNode(CallStmt, parsetree), params, isAtomicContext, dest);

855 break;

856

857 case T_ClusterStmt:

858 cluster(pstate, (ClusterStmt *) parsetree, isTopLevel);

859 break;

860

861 case T_VacuumStmt:

862 ExecVacuum(pstate, (VacuumStmt *) parsetree, isTopLevel);

863 break;

864

865 case T_ExplainStmt:

866 ExplainQuery(pstate, (ExplainStmt *) parsetree, params, dest);

867 break;

868

869 case T_AlterSystemStmt:

870 PreventInTransactionBlock(isTopLevel, "ALTER SYSTEM");

871 AlterSystemSetConfigFile((AlterSystemStmt *) parsetree);

872 break;

873

874 case T_VariableSetStmt:

875 ExecSetVariableStmt((VariableSetStmt *) parsetree, isTopLevel);

876 break;

877

878 case T_VariableShowStmt:

879 {

880 VariableShowStmt *n = (VariableShowStmt *) parsetree;

881

882 GetPGVariable(n->name, dest);

883 }

884 break;

885

886 case T_DiscardStmt:

887 /* should we allow DISCARD PLANS? */

888 CheckRestrictedOperation("DISCARD");

889 DiscardCommand((DiscardStmt *) parsetree, isTopLevel);

890 break;

891

892 case T_CreateEventTrigStmt:

893 /* no event triggers on event triggers */

894 CreateEventTrigger((CreateEventTrigStmt *) parsetree);

895 break;

896

897 case T_AlterEventTrigStmt:

898 /* no event triggers on event triggers */

899 AlterEventTrigger((AlterEventTrigStmt *) parsetree);

900 break;

901

902 /*

903 * ******************************** ROLE statements ****

904 */

905 case T_CreateRoleStmt:

906 /* no event triggers for global objects */

907 CreateRole(pstate, (CreateRoleStmt *) parsetree);

908 break;

909

910 case T_AlterRoleStmt:

911 /* no event triggers for global objects */

912 AlterRole(pstate, (AlterRoleStmt *) parsetree);

913 break;

914

915 case T_AlterRoleSetStmt:

916 /* no event triggers for global objects */

917 AlterRoleSet((AlterRoleSetStmt *) parsetree);

918 break;

919

920 case T_DropRoleStmt:

921 /* no event triggers for global objects */

922 DropRole((DropRoleStmt *) parsetree);

923 break;

924

925 case T_ReassignOwnedStmt:

926 /* no event triggers for global objects */

927 ReassignOwnedObjects((ReassignOwnedStmt *) parsetree);

928 break;

929

930 case T_LockStmt:

931

932 /*

933 * Since the lock would just get dropped immediately, LOCK TABLE

934 * outside a transaction block is presumed to be user error.

935 */

936 RequireTransactionBlock(isTopLevel, "LOCK TABLE");

937 LockTableCommand((LockStmt *) parsetree);

938 break;

939

940 case T_ConstraintsSetStmt:

941 WarnNoTransactionBlock(isTopLevel, "SET CONSTRAINTS");

942 AfterTriggerSetState((ConstraintsSetStmt *) parsetree);

943 break;

944

945 case T_CheckPointStmt:

946 ExecCheckpoint(pstate, (CheckPointStmt *) parsetree);

947 break;

948

949 /*

950 * The following statements are supported by Event Triggers only

951 * in some cases, so we "fast path" them in the other cases.

952 */

953

954 case T_GrantStmt:

955 {

956 GrantStmt *stmt = (GrantStmt *) parsetree;

957

958 if (EventTriggerSupportsObjectType(stmt->objtype))

959 ProcessUtilitySlow(pstate, pstmt, queryString,

960 context, params, queryEnv,

961 dest, qc);

962 else

963 ExecuteGrantStmt(stmt);

964 }

965 break;

966

967 case T_DropStmt:

968 {

969 DropStmt *stmt = (DropStmt *) parsetree;

970

971 if (EventTriggerSupportsObjectType(stmt->removeType))

972 ProcessUtilitySlow(pstate, pstmt, queryString,

973 context, params, queryEnv,

974 dest, qc);

975 else

976 ExecDropStmt(stmt, isTopLevel);

977 }

978 break;

979

980 case T_RenameStmt:

981 {

982 RenameStmt *stmt = (RenameStmt *) parsetree;

983

984 if (EventTriggerSupportsObjectType(stmt->renameType))

985 ProcessUtilitySlow(pstate, pstmt, queryString,

986 context, params, queryEnv,

987 dest, qc);

988 else

989 ExecRenameStmt(stmt);

990 }

991 break;

992

993 case T_AlterObjectDependsStmt:

994 {

995 AlterObjectDependsStmt *stmt = (AlterObjectDependsStmt *) parsetree;

996

997 if (EventTriggerSupportsObjectType(stmt->objectType))

998 ProcessUtilitySlow(pstate, pstmt, queryString,

999 context, params, queryEnv,

1000 dest, qc);

1001 else

1002 ExecAlterObjectDependsStmt(stmt, NULL);

1003 }

1004 break;

1005

1006 case T_AlterObjectSchemaStmt:

1007 {

1008 AlterObjectSchemaStmt *stmt = (AlterObjectSchemaStmt *) parsetree;

1009

1010 if (EventTriggerSupportsObjectType(stmt->objectType))

1011 ProcessUtilitySlow(pstate, pstmt, queryString,

1012 context, params, queryEnv,

1013 dest, qc);

1014 else

1015 ExecAlterObjectSchemaStmt(stmt, NULL);

1016 }

1017 break;

1018

1019 case T_AlterOwnerStmt:

1020 {

1021 AlterOwnerStmt *stmt = (AlterOwnerStmt *) parsetree;

1022

1023 if (EventTriggerSupportsObjectType(stmt->objectType))

1024 ProcessUtilitySlow(pstate, pstmt, queryString,

1025 context, params, queryEnv,

1026 dest, qc);

1027 else

1028 ExecAlterOwnerStmt(stmt);

1029 }

1030 break;

1031

1032 case T_CommentStmt:

1033 {

1034 CommentStmt *stmt = (CommentStmt *) parsetree;

1035

1036 if (EventTriggerSupportsObjectType(stmt->objtype))

1037 ProcessUtilitySlow(pstate, pstmt, queryString,

1038 context, params, queryEnv,

1039 dest, qc);

1040 else

1041 CommentObject(stmt);

1042 break;

1043 }

1044

1045 case T_SecLabelStmt:

1046 {

1047 SecLabelStmt *stmt = (SecLabelStmt *) parsetree;

1048

1049 if (EventTriggerSupportsObjectType(stmt->objtype))

1050 ProcessUtilitySlow(pstate, pstmt, queryString,

1051 context, params, queryEnv,

1052 dest, qc);

1053 else

1054 ExecSecLabelStmt(stmt);

1055 break;

1056 }

1057

1058 default:

1059 /* All other statement types have event trigger support */

1060 ProcessUtilitySlow(pstate, pstmt, queryString,

1061 context, params, queryEnv,

1062 dest, qc);

1063 break;

1064 }

1065

1066 free_parsestate(pstate);

1067

1068 /*

1069 * Make effects of commands visible, for instance so that

1070 * PreCommit_on_commit_actions() can see them (see for example bug

1071 * #15631).

1072 */

1073 CommandCounterIncrement();

1074}

ExecuteGrantStmt

void ExecuteGrantStmt(GrantStmt *stmt)

Definition: aclchk.c:391

ExecAlterOwnerStmt

ObjectAddress ExecAlterOwnerStmt(AlterOwnerStmt *stmt)

Definition: alter.c:837

ExecAlterObjectDependsStmt

ObjectAddress ExecAlterObjectDependsStmt(AlterObjectDependsStmt *stmt, ObjectAddress *refAddress)

Definition: alter.c:471

ExecRenameStmt

ObjectAddress ExecRenameStmt(RenameStmt *stmt)

Definition: alter.c:373

ExecAlterObjectSchemaStmt

ObjectAddress ExecAlterObjectSchemaStmt(AlterObjectSchemaStmt *stmt, ObjectAddress *oldSchemaAddr)

Definition: alter.c:534

Async_UnlistenAll

void Async_UnlistenAll(void)

Definition: async.c:770

Async_Unlisten

void Async_Unlisten(const char *channel)

Definition: async.c:752

Async_Listen

void Async_Listen(const char *channel)

Definition: async.c:738

Async_Notify

void Async_Notify(const char *channel, const char *payload)

Definition: async.c:591

DoCopy

void DoCopy(ParseState *pstate, const CopyStmt *stmt, int stmt_location, int stmt_len, uint64 *processed)

Definition: copy.c:62

PrepareQuery

void PrepareQuery(ParseState *pstate, PrepareStmt *stmt, int stmt_location, int stmt_len)

Definition: prepare.c:59

ExecuteQuery

void ExecuteQuery(ParseState *pstate, ExecuteStmt *stmt, IntoClause *intoClause, ParamListInfo params, DestReceiver *dest, QueryCompletion *qc)

Definition: prepare.c:150

DeallocateQuery

void DeallocateQuery(DeallocateStmt *stmt)

Definition: prepare.c:505

AlterTableSpaceOptions

Oid AlterTableSpaceOptions(AlterTableSpaceOptionsStmt *stmt)

Definition: tablespace.c:1015

DropTableSpace

void DropTableSpace(DropTableSpaceStmt *stmt)

Definition: tablespace.c:395

CreateTableSpace

Oid CreateTableSpace(CreateTableSpaceStmt *stmt)

Definition: tablespace.c:208

uint64

uint64_t uint64

Definition: c.h:539

ExecCheckpoint

void ExecCheckpoint(ParseState *pstate, CheckPointStmt *stmt)

Definition: checkpointer.c:1006

cluster

void cluster(ParseState *pstate, ClusterStmt *stmt, bool isTopLevel)

Definition: cluster.c:107

SetQueryCompletion

static void SetQueryCompletion(QueryCompletion *qc, CommandTag commandTag, uint64 nprocessed)

Definition: cmdtag.h:37

CommentObject

ObjectAddress CommentObject(CommentStmt *stmt)

Definition: comment.c:40

AlterDatabaseRefreshColl

ObjectAddress AlterDatabaseRefreshColl(AlterDatabaseRefreshCollStmt *stmt)

Definition: dbcommands.c:2541

createdb

Oid createdb(ParseState *pstate, const CreatedbStmt *stmt)

Definition: dbcommands.c:685

AlterDatabase

Oid AlterDatabase(ParseState *pstate, AlterDatabaseStmt *stmt, bool isTopLevel)

Definition: dbcommands.c:2368

DropDatabase

void DropDatabase(ParseState *pstate, DropdbStmt *stmt)

Definition: dbcommands.c:2343

AlterDatabaseSet

Oid AlterDatabaseSet(AlterDatabaseSetStmt *stmt)

Definition: dbcommands.c:2638

load_file

void load_file(const char *filename, bool restricted)

Definition: dfmgr.c:149

DiscardCommand

void DiscardCommand(DiscardStmt *stmt, bool isTopLevel)

Definition: discard.c:31

errcode

int errcode(int sqlerrcode)

Definition: elog.c:854

errmsg

int errmsg(const char *fmt,...)

Definition: elog.c:1071

ERROR

#define ERROR

Definition: elog.h:39

ereport

#define ereport(elevel,...)

Definition: elog.h:150

EventTriggerSupportsObjectType

bool EventTriggerSupportsObjectType(ObjectType obtype)

Definition: event_trigger.c:1133

CreateEventTrigger

Oid CreateEventTrigger(CreateEventTrigStmt *stmt)

Definition: event_trigger.c:124

AlterEventTrigger

Oid AlterEventTrigger(AlterEventTrigStmt *stmt)

Definition: event_trigger.c:427

ExplainQuery

void ExplainQuery(ParseState *pstate, ExplainStmt *stmt, ParamListInfo params, DestReceiver *dest)

Definition: explain.c:177

closeAllVfds

void closeAllVfds(void)

Definition: fd.c:3081

ExecuteCallStmt

void ExecuteCallStmt(CallStmt *stmt, ParamListInfo params, bool atomic, DestReceiver *dest)

Definition: functioncmds.c:2206

ExecuteDoStmt

void ExecuteDoStmt(ParseState *pstate, DoStmt *stmt, bool atomic)

Definition: functioncmds.c:2084

AlterSystemSetConfigFile

void AlterSystemSetConfigFile(AlterSystemStmt *altersysstmt)

Definition: guc.c:4613

GetPGVariable

void GetPGVariable(const char *name, DestReceiver *dest)

Definition: guc_funcs.c:382

SetPGVariable

void SetPGVariable(const char *name, List *args, bool is_local)

Definition: guc_funcs.c:315

ExecSetVariableStmt

void ExecSetVariableStmt(VariableSetStmt *stmt, bool isTopLevel)

Definition: guc_funcs.c:43

LockTableCommand

void LockTableCommand(LockStmt *lockstmt)

Definition: lockcmds.c:41

B_BACKEND

@ B_BACKEND

Definition: miscadmin.h:341

MyBackendType

BackendType MyBackendType

Definition: miscinit.c:64

copyObject

#define copyObject(obj)

Definition: nodes.h:232

castNode

#define castNode(_type_, nodeptr)

Definition: nodes.h:182

free_parsestate

void free_parsestate(ParseState *pstate)

Definition: parse_node.c:72

make_parsestate

ParseState * make_parsestate(ParseState *parentParseState)

Definition: parse_node.c:39

list_make1

#define list_make1(x1)

Definition: pg_list.h:212

PerformCursorOpen

void PerformCursorOpen(ParseState *pstate, DeclareCursorStmt *cstmt, ParamListInfo params, bool isTopLevel)

Definition: portalcmds.c:45

PerformPortalClose

void PerformPortalClose(const char *name)

Definition: portalcmds.c:224

PerformPortalFetch

void PerformPortalFetch(FetchStmt *stmt, DestReceiver *dest, QueryCompletion *qc)

Definition: portalcmds.c:177

ExecSecLabelStmt

ObjectAddress ExecSecLabelStmt(SecLabelStmt *stmt)

Definition: seclabel.c:115

check_stack_depth

void check_stack_depth(void)

Definition: stack_depth.c:95

AlterDatabaseRefreshCollStmt

Definition: parsenodes.h:3920

AlterDatabaseSetStmt

Definition: parsenodes.h:3926

AlterDatabaseStmt

Definition: parsenodes.h:3913

AlterEventTrigStmt

Definition: parsenodes.h:3148

AlterRoleSetStmt

Definition: parsenodes.h:3203

AlterRoleStmt

Definition: parsenodes.h:3195

AlterSystemStmt

Definition: parsenodes.h:3949

AlterTableSpaceOptionsStmt

Definition: parsenodes.h:2902

CallStmt

Definition: parsenodes.h:3639

CheckPointStmt

Definition: parsenodes.h:4051

ClusterStmt

Definition: parsenodes.h:3959

CommentStmt

Definition: parsenodes.h:3358

ConstraintsSetStmt

Definition: parsenodes.h:4092

CreateEventTrigStmt

Definition: parsenodes.h:3135

CreateRoleStmt

Definition: parsenodes.h:3187

CreateTableSpaceStmt

Definition: parsenodes.h:2886

CreatedbStmt

Definition: parsenodes.h:3902

DeclareCursorStmt

Definition: parsenodes.h:3399

DefElem::arg

Node * arg

Definition: parsenodes.h:844

DoStmt

Definition: parsenodes.h:3611

DropRoleStmt

Definition: parsenodes.h:3211

DropTableSpaceStmt

Definition: parsenodes.h:2895

DropdbStmt

Definition: parsenodes.h:3937

ListenStmt

Definition: parsenodes.h:3770

LoadStmt

Definition: parsenodes.h:3892

LockStmt

Definition: parsenodes.h:4080

Node

Definition: nodes.h:135

NotifyStmt

Definition: parsenodes.h:3759

ParseState

Definition: parse_node.h:193

ParseState::p_queryEnv

QueryEnvironment * p_queryEnv

Definition: parse_node.h:223

ParseState::p_sourcetext

const char * p_sourcetext

Definition: parse_node.h:195

ReassignOwnedStmt

Definition: parsenodes.h:4223

SecLabelStmt

Definition: parsenodes.h:3370

TruncateStmt

Definition: parsenodes.h:3346

UnlistenStmt

Definition: parsenodes.h:3780

VariableShowStmt

Definition: parsenodes.h:2731

VariableShowStmt::name

char * name

Definition: parsenodes.h:2733

superuser

bool superuser(void)

Definition: superuser.c:46

ExecuteTruncate

void ExecuteTruncate(TruncateStmt *stmt)

Definition: tablecmds.c:1852

AfterTriggerSetState

void AfterTriggerSetState(ConstraintsSetStmt *stmt)

Definition: trigger.c:5745

FinishPreparedTransaction

void FinishPreparedTransaction(const char *gid, bool isCommit)

Definition: twophase.c:1497

ReassignOwnedObjects

void ReassignOwnedObjects(ReassignOwnedStmt *stmt)

Definition: user.c:1611

AlterRole

Oid AlterRole(ParseState *pstate, AlterRoleStmt *stmt)

Definition: user.c:619

AlterRoleSet

Oid AlterRoleSet(AlterRoleSetStmt *stmt)

Definition: user.c:1000

DropRole

void DropRole(DropRoleStmt *stmt)

Definition: user.c:1090

CreateRole

Oid CreateRole(ParseState *pstate, CreateRoleStmt *stmt)

Definition: user.c:132

GrantRole

void GrantRole(ParseState *pstate, GrantRoleStmt *stmt)

Definition: user.c:1480

ClassifyUtilityCommandAsReadOnly

static int ClassifyUtilityCommandAsReadOnly(Node *parsetree)

Definition: utility.c:128

PreventCommandIfReadOnly

void PreventCommandIfReadOnly(const char *cmdname)

Definition: utility.c:404

PreventCommandIfParallelMode

void PreventCommandIfParallelMode(const char *cmdname)

Definition: utility.c:422

ExecDropStmt

static void ExecDropStmt(DropStmt *stmt, bool isTopLevel)

Definition: utility.c:1987

CheckRestrictedOperation

static void CheckRestrictedOperation(const char *cmdname)

Definition: utility.c:459

PreventCommandDuringRecovery

void PreventCommandDuringRecovery(const char *cmdname)

Definition: utility.c:441

ProcessUtilitySlow

static void ProcessUtilitySlow(ParseState *pstate, PlannedStmt *pstmt, const char *queryString, ProcessUtilityContext context, ParamListInfo params, QueryEnvironment *queryEnv, DestReceiver *dest, QueryCompletion *qc)

Definition: utility.c:1082

COMMAND_OK_IN_PARALLEL_MODE

#define COMMAND_OK_IN_PARALLEL_MODE

Definition: utility.h:57

COMMAND_IS_STRICTLY_READ_ONLY

#define COMMAND_IS_STRICTLY_READ_ONLY

Definition: utility.h:65

ExecVacuum

void ExecVacuum(ParseState *pstate, VacuumStmt *vacstmt, bool isTopLevel)

Definition: vacuum.c:161

WarnNoTransactionBlock

void WarnNoTransactionBlock(bool isTopLevel, const char *stmtType)

Definition: xact.c:3722

UserAbortTransactionBlock

void UserAbortTransactionBlock(bool chain)

Definition: xact.c:4216

PrepareTransactionBlock

bool PrepareTransactionBlock(const char *gid)

Definition: xact.c:4004

RequireTransactionBlock

void RequireTransactionBlock(bool isTopLevel, const char *stmtType)

Definition: xact.c:3728

DefineSavepoint

void DefineSavepoint(const char *name)

Definition: xact.c:4385

XactReadOnly

bool XactReadOnly

Definition: xact.c:82

CommandCounterIncrement

void CommandCounterIncrement(void)

Definition: xact.c:1100

PreventInTransactionBlock

void PreventInTransactionBlock(bool isTopLevel, const char *stmtType)

Definition: xact.c:3660

ReleaseSavepoint

void ReleaseSavepoint(const char *name)

Definition: xact.c:4470

IsTransactionBlock

bool IsTransactionBlock(void)

Definition: xact.c:4983

IsInParallelMode

bool IsInParallelMode(void)

Definition: xact.c:1089

BeginTransactionBlock

void BeginTransactionBlock(void)

Definition: xact.c:3936

RollbackToSavepoint

void RollbackToSavepoint(const char *name)

Definition: xact.c:4579

EndTransactionBlock

bool EndTransactionBlock(bool chain)

Definition: xact.c:4056

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(), 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()

Query * UtilityContainsQuery ( Node * parsetree )

Definition at line 2171 of file utility.c.

2172{

2173 Query *qry;

2174

2175 switch (nodeTag(parsetree))

2176 {

2177 case T_DeclareCursorStmt:

2178 qry = castNode(Query, ((DeclareCursorStmt *) parsetree)->query);

2179 if (qry->commandType == CMD_UTILITY)

2180 return UtilityContainsQuery(qry->utilityStmt);

2181 return qry;

2182

2183 case T_ExplainStmt:

2184 qry = castNode(Query, ((ExplainStmt *) parsetree)->query);

2185 if (qry->commandType == CMD_UTILITY)

2186 return UtilityContainsQuery(qry->utilityStmt);

2187 return qry;

2188

2189 case T_CreateTableAsStmt:

2190 qry = castNode(Query, ((CreateTableAsStmt *) parsetree)->query);

2191 if (qry->commandType == CMD_UTILITY)

2192 return UtilityContainsQuery(qry->utilityStmt);

2193 return qry;

2194

2195 default:

2196 return NULL;

2197 }

2198}

Query::commandType

CmdType commandType

Definition: parsenodes.h:121

Query::utilityStmt

Node * utilityStmt

Definition: parsenodes.h:141

UtilityContainsQuery

Query * UtilityContainsQuery(Node *parsetree)

Definition: utility.c:2171

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 2020 of file utility.c.

2021{

2022 switch (nodeTag(parsetree))

2023 {

2024 case T_CallStmt:

2025 {

2026 CallStmt *stmt = (CallStmt *) parsetree;

2027

2028 return (stmt->funcexpr->funcresulttype == RECORDOID);

2029 }

2030 case T_FetchStmt:

2031 {

2032 FetchStmt *stmt = (FetchStmt *) parsetree;

2033 Portal portal;

2034

2035 if (stmt->ismove)

2036 return false;

2037 portal = GetPortalByName(stmt->portalname);

2038 if (!PortalIsValid(portal))

2039 return false; /* not our business to raise error */

2040 return portal->tupDesc ? true : false;

2041 }

2042

2043 case T_ExecuteStmt:

2044 {

2045 ExecuteStmt *stmt = (ExecuteStmt *) parsetree;

2046 PreparedStatement *entry;

2047

2048 entry = FetchPreparedStatement(stmt->name, false);

2049 if (!entry)

2050 return false; /* not our business to raise error */

2051 if (entry->plansource->resultDesc)

2052 return true;

2053 return false;

2054 }

2055

2056 case T_ExplainStmt:

2057 return true;

2058

2059 case T_VariableShowStmt:

2060 return true;

2061

2062 default:

2063 return false;

2064 }

2065}

true

return true

Definition: isn.c:130

PortalIsValid

#define PortalIsValid(p)

Definition: portal.h:211

GetPortalByName

Portal GetPortalByName(const char *name)

Definition: portalmem.c:130

CachedPlanSource::resultDesc

TupleDesc resultDesc

Definition: plancache.h:120

PortalData

Definition: portal.h:116

PortalData::tupDesc

TupleDesc tupDesc

Definition: portal.h:159

PreparedStatement::plansource

CachedPlanSource * plansource

Definition: prepare.h:32

References FetchPreparedStatement(), GetPortalByName(), nodeTag, PreparedStatement::plansource, PortalIsValid, CachedPlanSource::resultDesc, stmt, true, and PortalData::tupDesc.

Referenced by ChoosePortalStrategy().

◆ UtilityTupleDescriptor()

TupleDesc UtilityTupleDescriptor ( Node * parsetree )

Definition at line 2076 of file utility.c.

2077{

2078 switch (nodeTag(parsetree))

2079 {

2080 case T_CallStmt:

2081 return CallStmtResultDesc((CallStmt *) parsetree);

2082

2083 case T_FetchStmt:

2084 {

2085 FetchStmt *stmt = (FetchStmt *) parsetree;

2086 Portal portal;

2087

2088 if (stmt->ismove)

2089 return NULL;

2090 portal = GetPortalByName(stmt->portalname);

2091 if (!PortalIsValid(portal))

2092 return NULL; /* not our business to raise error */

2093 return CreateTupleDescCopy(portal->tupDesc);

2094 }

2095

2096 case T_ExecuteStmt:

2097 {

2098 ExecuteStmt *stmt = (ExecuteStmt *) parsetree;

2099 PreparedStatement *entry;

2100

2101 entry = FetchPreparedStatement(stmt->name, false);

2102 if (!entry)

2103 return NULL; /* not our business to raise error */

2104 return FetchPreparedStatementResultDesc(entry);

2105 }

2106

2107 case T_ExplainStmt:

2108 return ExplainResultDesc((ExplainStmt *) parsetree);

2109

2110 case T_VariableShowStmt:

2111 {

2112 VariableShowStmt *n = (VariableShowStmt *) parsetree;

2113

2114 return GetPGVariableResultDesc(n->name);

2115 }

2116

2117 default:

2118 return NULL;

2119 }

2120}

FetchPreparedStatementResultDesc

TupleDesc FetchPreparedStatementResultDesc(PreparedStatement *stmt)

Definition: prepare.c:466

ExplainResultDesc

TupleDesc ExplainResultDesc(ExplainStmt *stmt)

Definition: explain.c:255

CallStmtResultDesc

TupleDesc CallStmtResultDesc(CallStmt *stmt)

Definition: functioncmds.c:2383

GetPGVariableResultDesc

TupleDesc GetPGVariableResultDesc(const char *name)

Definition: guc_funcs.c:394

CreateTupleDescCopy

TupleDesc CreateTupleDescCopy(TupleDesc tupdesc)

Definition: tupdesc.c:252

References CallStmtResultDesc(), CreateTupleDescCopy(), ExplainResultDesc(), FetchPreparedStatement(), FetchPreparedStatementResultDesc(), GetPGVariableResultDesc(), GetPortalByName(), VariableShowStmt::name, nodeTag, PortalIsValid, stmt, and PortalData::tupDesc.

Referenced by PlanCacheComputeResultDesc(), and PortalStart().

Variable Documentation

◆ ProcessUtility_hook

PGDLLIMPORT ProcessUtility_hook_type ProcessUtility_hook

extern

Definition at line 70 of file utility.c.

Referenced by _PG_init(), and ProcessUtility().

src
include
tcop
utility.h
Generated on Mon Oct 6 2025 00:13:27 for PostgreSQL Source Code by doxygen 1.9.4