PostgreSQL Source Code git master
Loading...
Searching...
No Matches
Data Structures | Macros | Typedefs | Enumerations | Functions | Variables
utility.h File Reference
#include "tcop/cmdtag.h"
#include "tcop/tcopprot.h"
Include dependency graph for utility.h:
This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures

struct  AlterTableUtilityContext
 

Macros

#define COMMAND_OK_IN_READ_ONLY_TXN   0x0001
 
#define COMMAND_OK_IN_PARALLEL_MODE   0x0002
 
#define COMMAND_OK_IN_RECOVERY   0x0004
 
#define COMMAND_IS_STRICTLY_READ_ONLY
 
#define COMMAND_IS_NOT_READ_ONLY   0
 

Typedefs

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

Enumerations

enum  ProcessUtilityContext { PROCESS_UTILITY_TOPLEVEL , PROCESS_UTILITY_QUERY , PROCESS_UTILITY_QUERY_NONATOMIC , PROCESS_UTILITY_SUBCOMMAND }
 

Functions

void ProcessUtility (PlannedStmt *pstmt, const char *queryString, bool readOnlyTree, ProcessUtilityContext context, ParamListInfo params, QueryEnvironment *queryEnv, DestReceiver *dest, QueryCompletion *qc)
 
void standard_ProcessUtility (PlannedStmt *pstmt, const char *queryString, bool readOnlyTree, ProcessUtilityContext context, ParamListInfo params, QueryEnvironment *queryEnv, DestReceiver *dest, QueryCompletion *qc)
 
void ProcessUtilityForAlterTable (Node *stmt, AlterTableUtilityContext *context)
 
bool UtilityReturnsTuples (Node *parsetree)
 
TupleDesc UtilityTupleDescriptor (Node *parsetree)
 
Query * UtilityContainsQuery (Node *parsetree)
 
CommandTag CreateCommandTag (Node *parsetree)
 
static const char * CreateCommandName (Node *parsetree)
 
LogStmtLevel GetCommandLogLevel (Node *parsetree)
 
bool CommandIsReadOnly (PlannedStmt *pstmt)
 

Variables

PGDLLIMPORT ProcessUtility_hook_type ProcessUtility_hook
 

Macro Definition Documentation

◆ COMMAND_IS_NOT_READ_ONLY

#define COMMAND_IS_NOT_READ_ONLY   0

Definition at line 68 of file utility.h.

◆ COMMAND_IS_STRICTLY_READ_ONLY

#define COMMAND_IS_STRICTLY_READ_ONLY
Value:
(COMMAND_OK_IN_READ_ONLY_TXN | COMMAND_OK_IN_RECOVERY | \
COMMAND_OK_IN_PARALLEL_MODE)
COMMAND_OK_IN_PARALLEL_MODE
#define COMMAND_OK_IN_PARALLEL_MODE
Definition utility.h:57
COMMAND_OK_IN_RECOVERY
#define COMMAND_OK_IN_RECOVERY
Definition utility.h:58
COMMAND_OK_IN_READ_ONLY_TXN
#define COMMAND_OK_IN_READ_ONLY_TXN
Definition utility.h:56

Definition at line 65 of file utility.h.

104{
105 return GetCommandTagName(CreateCommandTag(parsetree));
106}
107
108extern LogStmtLevel GetCommandLogLevel(Node *parsetree);
109
110extern bool CommandIsReadOnly(PlannedStmt *pstmt);
111
112#endif /* UTILITY_H */
GetCommandTagName
const char * GetCommandTagName(CommandTag commandTag)
Definition cmdtag.c:47
Node
Definition nodes.h:135
LogStmtLevel
LogStmtLevel
Definition tcopprot.h:33
CommandIsReadOnly
bool CommandIsReadOnly(PlannedStmt *pstmt)
Definition utility.c:96
CreateCommandTag
CommandTag CreateCommandTag(Node *parsetree)
Definition utility.c:2385
GetCommandLogLevel
LogStmtLevel GetCommandLogLevel(Node *parsetree)
Definition utility.c:3290

◆ COMMAND_OK_IN_PARALLEL_MODE

#define COMMAND_OK_IN_PARALLEL_MODE   0x0002

Definition at line 57 of file utility.h.

◆ COMMAND_OK_IN_READ_ONLY_TXN

#define COMMAND_OK_IN_READ_ONLY_TXN   0x0001

Definition at line 56 of file utility.h.

◆ COMMAND_OK_IN_RECOVERY

#define COMMAND_OK_IN_RECOVERY   0x0004

Definition at line 58 of file utility.h.

Typedef Documentation

◆ AlterTableUtilityContext

typedef struct AlterTableUtilityContext AlterTableUtilityContext

◆ ProcessUtility_hook_type

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
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)
extern

Definition at line 96 of file utility.c.

97{
98 Assert(IsA(pstmt, PlannedStmt));
99 switch (pstmt->commandType)
100 {
101 case CMD_SELECT:
102 if (pstmt->rowMarks != NIL)
103 return false; /* SELECT FOR [KEY] UPDATE/SHARE */
104 else if (pstmt->hasModifyingCTE)
105 return false; /* data-modifying CTE */
106 else
107 return true;
108 case CMD_UPDATE:
109 case CMD_INSERT:
110 case CMD_DELETE:
111 case CMD_MERGE:
112 return false;
113 case CMD_UTILITY:
114 /* For now, treat all utility commands as read/write */
115 return false;
116 default:
117 elog(WARNING, "unrecognized commandType: %d",
118 (int) pstmt->commandType);
119 break;
120 }
121 return false;
122}
Assert
#define Assert(condition)
Definition c.h:943
WARNING
#define WARNING
Definition elog.h:37
elog
#define elog(elevel,...)
Definition elog.h:228
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::hasModifyingCTE
bool hasModifyingCTE
Definition plannodes.h:81
PlannedStmt::rowMarks
List * rowMarks
Definition plannodes.h:138
PlannedStmt::commandType
CmdType commandType
Definition plannodes.h:66

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}

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)
extern

Definition at line 2385 of file utility.c.

2386{
2387 CommandTag tag;
2388
2389 switch (nodeTag(parsetree))
2390 {
2391 /* recurse if we're given a RawStmt */
2392 case T_RawStmt:
2393 tag = CreateCommandTag(((RawStmt *) parsetree)->stmt);
2394 break;
2395
2396 /* raw plannable queries */
2397 case T_InsertStmt:
2398 tag = CMDTAG_INSERT;
2399 break;
2400
2401 case T_DeleteStmt:
2402 tag = CMDTAG_DELETE;
2403 break;
2404
2405 case T_UpdateStmt:
2406 tag = CMDTAG_UPDATE;
2407 break;
2408
2409 case T_MergeStmt:
2410 tag = CMDTAG_MERGE;
2411 break;
2412
2413 case T_SelectStmt:
2414 tag = CMDTAG_SELECT;
2415 break;
2416
2417 case T_PLAssignStmt:
2418 tag = CMDTAG_SELECT;
2419 break;
2420
2421 /* utility statements --- same whether raw or cooked */
2422 case T_TransactionStmt:
2423 {
2424 TransactionStmt *stmt = (TransactionStmt *) parsetree;
2425
2426 switch (stmt->kind)
2427 {
2428 case TRANS_STMT_BEGIN:
2429 tag = CMDTAG_BEGIN;
2430 break;
2431
2432 case TRANS_STMT_START:
2433 tag = CMDTAG_START_TRANSACTION;
2434 break;
2435
2436 case TRANS_STMT_COMMIT:
2437 tag = CMDTAG_COMMIT;
2438 break;
2439
2440 case TRANS_STMT_ROLLBACK:
2441 case TRANS_STMT_ROLLBACK_TO:
2442 tag = CMDTAG_ROLLBACK;
2443 break;
2444
2445 case TRANS_STMT_SAVEPOINT:
2446 tag = CMDTAG_SAVEPOINT;
2447 break;
2448
2449 case TRANS_STMT_RELEASE:
2450 tag = CMDTAG_RELEASE;
2451 break;
2452
2453 case TRANS_STMT_PREPARE:
2454 tag = CMDTAG_PREPARE_TRANSACTION;
2455 break;
2456
2457 case TRANS_STMT_COMMIT_PREPARED:
2458 tag = CMDTAG_COMMIT_PREPARED;
2459 break;
2460
2461 case TRANS_STMT_ROLLBACK_PREPARED:
2462 tag = CMDTAG_ROLLBACK_PREPARED;
2463 break;
2464
2465 default:
2466 tag = CMDTAG_UNKNOWN;
2467 break;
2468 }
2469 }
2470 break;
2471
2472 case T_DeclareCursorStmt:
2473 tag = CMDTAG_DECLARE_CURSOR;
2474 break;
2475
2476 case T_ClosePortalStmt:
2477 {
2478 ClosePortalStmt *stmt = (ClosePortalStmt *) parsetree;
2479
2480 if (stmt->portalname == NULL)
2481 tag = CMDTAG_CLOSE_CURSOR_ALL;
2482 else
2483 tag = CMDTAG_CLOSE_CURSOR;
2484 }
2485 break;
2486
2487 case T_FetchStmt:
2488 {
2489 FetchStmt *stmt = (FetchStmt *) parsetree;
2490
2491 tag = (stmt->ismove) ? CMDTAG_MOVE : CMDTAG_FETCH;
2492 }
2493 break;
2494
2495 case T_CreateDomainStmt:
2496 tag = CMDTAG_CREATE_DOMAIN;
2497 break;
2498
2499 case T_CreateSchemaStmt:
2500 tag = CMDTAG_CREATE_SCHEMA;
2501 break;
2502
2503 case T_CreateStmt:
2504 tag = CMDTAG_CREATE_TABLE;
2505 break;
2506
2507 case T_CreateTableSpaceStmt:
2508 tag = CMDTAG_CREATE_TABLESPACE;
2509 break;
2510
2511 case T_DropTableSpaceStmt:
2512 tag = CMDTAG_DROP_TABLESPACE;
2513 break;
2514
2515 case T_AlterTableSpaceOptionsStmt:
2516 tag = CMDTAG_ALTER_TABLESPACE;
2517 break;
2518
2519 case T_CreateExtensionStmt:
2520 tag = CMDTAG_CREATE_EXTENSION;
2521 break;
2522
2523 case T_AlterExtensionStmt:
2524 tag = CMDTAG_ALTER_EXTENSION;
2525 break;
2526
2527 case T_AlterExtensionContentsStmt:
2528 tag = CMDTAG_ALTER_EXTENSION;
2529 break;
2530
2531 case T_CreateFdwStmt:
2532 tag = CMDTAG_CREATE_FOREIGN_DATA_WRAPPER;
2533 break;
2534
2535 case T_AlterFdwStmt:
2536 tag = CMDTAG_ALTER_FOREIGN_DATA_WRAPPER;
2537 break;
2538
2539 case T_CreateForeignServerStmt:
2540 tag = CMDTAG_CREATE_SERVER;
2541 break;
2542
2543 case T_AlterForeignServerStmt:
2544 tag = CMDTAG_ALTER_SERVER;
2545 break;
2546
2547 case T_CreateUserMappingStmt:
2548 tag = CMDTAG_CREATE_USER_MAPPING;
2549 break;
2550
2551 case T_AlterUserMappingStmt:
2552 tag = CMDTAG_ALTER_USER_MAPPING;
2553 break;
2554
2555 case T_DropUserMappingStmt:
2556 tag = CMDTAG_DROP_USER_MAPPING;
2557 break;
2558
2559 case T_CreateForeignTableStmt:
2560 tag = CMDTAG_CREATE_FOREIGN_TABLE;
2561 break;
2562
2563 case T_ImportForeignSchemaStmt:
2564 tag = CMDTAG_IMPORT_FOREIGN_SCHEMA;
2565 break;
2566
2567 case T_DropStmt:
2568 switch (((DropStmt *) parsetree)->removeType)
2569 {
2570 case OBJECT_TABLE:
2571 tag = CMDTAG_DROP_TABLE;
2572 break;
2573 case OBJECT_SEQUENCE:
2574 tag = CMDTAG_DROP_SEQUENCE;
2575 break;
2576 case OBJECT_VIEW:
2577 tag = CMDTAG_DROP_VIEW;
2578 break;
2579 case OBJECT_MATVIEW:
2580 tag = CMDTAG_DROP_MATERIALIZED_VIEW;
2581 break;
2582 case OBJECT_INDEX:
2583 tag = CMDTAG_DROP_INDEX;
2584 break;
2585 case OBJECT_PROPGRAPH:
2586 tag = CMDTAG_DROP_PROPERTY_GRAPH;
2587 break;
2588 case OBJECT_TYPE:
2589 tag = CMDTAG_DROP_TYPE;
2590 break;
2591 case OBJECT_DOMAIN:
2592 tag = CMDTAG_DROP_DOMAIN;
2593 break;
2594 case OBJECT_COLLATION:
2595 tag = CMDTAG_DROP_COLLATION;
2596 break;
2597 case OBJECT_CONVERSION:
2598 tag = CMDTAG_DROP_CONVERSION;
2599 break;
2600 case OBJECT_SCHEMA:
2601 tag = CMDTAG_DROP_SCHEMA;
2602 break;
2603 case OBJECT_TSPARSER:
2604 tag = CMDTAG_DROP_TEXT_SEARCH_PARSER;
2605 break;
2606 case OBJECT_TSDICTIONARY:
2607 tag = CMDTAG_DROP_TEXT_SEARCH_DICTIONARY;
2608 break;
2609 case OBJECT_TSTEMPLATE:
2610 tag = CMDTAG_DROP_TEXT_SEARCH_TEMPLATE;
2611 break;
2612 case OBJECT_TSCONFIGURATION:
2613 tag = CMDTAG_DROP_TEXT_SEARCH_CONFIGURATION;
2614 break;
2615 case OBJECT_FOREIGN_TABLE:
2616 tag = CMDTAG_DROP_FOREIGN_TABLE;
2617 break;
2618 case OBJECT_EXTENSION:
2619 tag = CMDTAG_DROP_EXTENSION;
2620 break;
2621 case OBJECT_FUNCTION:
2622 tag = CMDTAG_DROP_FUNCTION;
2623 break;
2624 case OBJECT_PROCEDURE:
2625 tag = CMDTAG_DROP_PROCEDURE;
2626 break;
2627 case OBJECT_ROUTINE:
2628 tag = CMDTAG_DROP_ROUTINE;
2629 break;
2630 case OBJECT_AGGREGATE:
2631 tag = CMDTAG_DROP_AGGREGATE;
2632 break;
2633 case OBJECT_OPERATOR:
2634 tag = CMDTAG_DROP_OPERATOR;
2635 break;
2636 case OBJECT_LANGUAGE:
2637 tag = CMDTAG_DROP_LANGUAGE;
2638 break;
2639 case OBJECT_CAST:
2640 tag = CMDTAG_DROP_CAST;
2641 break;
2642 case OBJECT_TRIGGER:
2643 tag = CMDTAG_DROP_TRIGGER;
2644 break;
2645 case OBJECT_EVENT_TRIGGER:
2646 tag = CMDTAG_DROP_EVENT_TRIGGER;
2647 break;
2648 case OBJECT_RULE:
2649 tag = CMDTAG_DROP_RULE;
2650 break;
2651 case OBJECT_FDW:
2652 tag = CMDTAG_DROP_FOREIGN_DATA_WRAPPER;
2653 break;
2654 case OBJECT_FOREIGN_SERVER:
2655 tag = CMDTAG_DROP_SERVER;
2656 break;
2657 case OBJECT_OPCLASS:
2658 tag = CMDTAG_DROP_OPERATOR_CLASS;
2659 break;
2660 case OBJECT_OPFAMILY:
2661 tag = CMDTAG_DROP_OPERATOR_FAMILY;
2662 break;
2663 case OBJECT_POLICY:
2664 tag = CMDTAG_DROP_POLICY;
2665 break;
2666 case OBJECT_TRANSFORM:
2667 tag = CMDTAG_DROP_TRANSFORM;
2668 break;
2669 case OBJECT_ACCESS_METHOD:
2670 tag = CMDTAG_DROP_ACCESS_METHOD;
2671 break;
2672 case OBJECT_PUBLICATION:
2673 tag = CMDTAG_DROP_PUBLICATION;
2674 break;
2675 case OBJECT_STATISTIC_EXT:
2676 tag = CMDTAG_DROP_STATISTICS;
2677 break;
2678 default:
2679 tag = CMDTAG_UNKNOWN;
2680 }
2681 break;
2682
2683 case T_TruncateStmt:
2684 tag = CMDTAG_TRUNCATE_TABLE;
2685 break;
2686
2687 case T_CommentStmt:
2688 tag = CMDTAG_COMMENT;
2689 break;
2690
2691 case T_SecLabelStmt:
2692 tag = CMDTAG_SECURITY_LABEL;
2693 break;
2694
2695 case T_CopyStmt:
2696 tag = CMDTAG_COPY;
2697 break;
2698
2699 case T_RenameStmt:
2700
2701 /*
2702 * When the column is renamed, the command tag is created from its
2703 * relation type
2704 */
2705 tag = AlterObjectTypeCommandTag(((RenameStmt *) parsetree)->renameType == OBJECT_COLUMN ?
2706 ((RenameStmt *) parsetree)->relationType :
2707 ((RenameStmt *) parsetree)->renameType);
2708 break;
2709
2710 case T_AlterObjectDependsStmt:
2711 tag = AlterObjectTypeCommandTag(((AlterObjectDependsStmt *) parsetree)->objectType);
2712 break;
2713
2714 case T_AlterObjectSchemaStmt:
2715 tag = AlterObjectTypeCommandTag(((AlterObjectSchemaStmt *) parsetree)->objectType);
2716 break;
2717
2718 case T_AlterOwnerStmt:
2719 tag = AlterObjectTypeCommandTag(((AlterOwnerStmt *) parsetree)->objectType);
2720 break;
2721
2722 case T_AlterTableMoveAllStmt:
2723 tag = AlterObjectTypeCommandTag(((AlterTableMoveAllStmt *) parsetree)->objtype);
2724 break;
2725
2726 case T_AlterTableStmt:
2727 tag = AlterObjectTypeCommandTag(((AlterTableStmt *) parsetree)->objtype);
2728 break;
2729
2730 case T_AlterDomainStmt:
2731 tag = CMDTAG_ALTER_DOMAIN;
2732 break;
2733
2734 case T_AlterFunctionStmt:
2735 switch (((AlterFunctionStmt *) parsetree)->objtype)
2736 {
2737 case OBJECT_FUNCTION:
2738 tag = CMDTAG_ALTER_FUNCTION;
2739 break;
2740 case OBJECT_PROCEDURE:
2741 tag = CMDTAG_ALTER_PROCEDURE;
2742 break;
2743 case OBJECT_ROUTINE:
2744 tag = CMDTAG_ALTER_ROUTINE;
2745 break;
2746 default:
2747 tag = CMDTAG_UNKNOWN;
2748 }
2749 break;
2750
2751 case T_GrantStmt:
2752 {
2753 GrantStmt *stmt = (GrantStmt *) parsetree;
2754
2755 tag = (stmt->is_grant) ? CMDTAG_GRANT : CMDTAG_REVOKE;
2756 }
2757 break;
2758
2759 case T_GrantRoleStmt:
2760 {
2761 GrantRoleStmt *stmt = (GrantRoleStmt *) parsetree;
2762
2763 tag = (stmt->is_grant) ? CMDTAG_GRANT_ROLE : CMDTAG_REVOKE_ROLE;
2764 }
2765 break;
2766
2767 case T_AlterDefaultPrivilegesStmt:
2768 tag = CMDTAG_ALTER_DEFAULT_PRIVILEGES;
2769 break;
2770
2771 case T_DefineStmt:
2772 switch (((DefineStmt *) parsetree)->kind)
2773 {
2774 case OBJECT_AGGREGATE:
2775 tag = CMDTAG_CREATE_AGGREGATE;
2776 break;
2777 case OBJECT_OPERATOR:
2778 tag = CMDTAG_CREATE_OPERATOR;
2779 break;
2780 case OBJECT_TYPE:
2781 tag = CMDTAG_CREATE_TYPE;
2782 break;
2783 case OBJECT_TSPARSER:
2784 tag = CMDTAG_CREATE_TEXT_SEARCH_PARSER;
2785 break;
2786 case OBJECT_TSDICTIONARY:
2787 tag = CMDTAG_CREATE_TEXT_SEARCH_DICTIONARY;
2788 break;
2789 case OBJECT_TSTEMPLATE:
2790 tag = CMDTAG_CREATE_TEXT_SEARCH_TEMPLATE;
2791 break;
2792 case OBJECT_TSCONFIGURATION:
2793 tag = CMDTAG_CREATE_TEXT_SEARCH_CONFIGURATION;
2794 break;
2795 case OBJECT_COLLATION:
2796 tag = CMDTAG_CREATE_COLLATION;
2797 break;
2798 case OBJECT_ACCESS_METHOD:
2799 tag = CMDTAG_CREATE_ACCESS_METHOD;
2800 break;
2801 default:
2802 tag = CMDTAG_UNKNOWN;
2803 }
2804 break;
2805
2806 case T_CompositeTypeStmt:
2807 tag = CMDTAG_CREATE_TYPE;
2808 break;
2809
2810 case T_CreateEnumStmt:
2811 tag = CMDTAG_CREATE_TYPE;
2812 break;
2813
2814 case T_CreateRangeStmt:
2815 tag = CMDTAG_CREATE_TYPE;
2816 break;
2817
2818 case T_AlterEnumStmt:
2819 tag = CMDTAG_ALTER_TYPE;
2820 break;
2821
2822 case T_ViewStmt:
2823 tag = CMDTAG_CREATE_VIEW;
2824 break;
2825
2826 case T_CreateFunctionStmt:
2827 if (((CreateFunctionStmt *) parsetree)->is_procedure)
2828 tag = CMDTAG_CREATE_PROCEDURE;
2829 else
2830 tag = CMDTAG_CREATE_FUNCTION;
2831 break;
2832
2833 case T_IndexStmt:
2834 tag = CMDTAG_CREATE_INDEX;
2835 break;
2836
2837 case T_RuleStmt:
2838 tag = CMDTAG_CREATE_RULE;
2839 break;
2840
2841 case T_CreateSeqStmt:
2842 tag = CMDTAG_CREATE_SEQUENCE;
2843 break;
2844
2845 case T_AlterSeqStmt:
2846 tag = CMDTAG_ALTER_SEQUENCE;
2847 break;
2848
2849 case T_DoStmt:
2850 tag = CMDTAG_DO;
2851 break;
2852
2853 case T_CreatedbStmt:
2854 tag = CMDTAG_CREATE_DATABASE;
2855 break;
2856
2857 case T_AlterDatabaseStmt:
2858 case T_AlterDatabaseRefreshCollStmt:
2859 case T_AlterDatabaseSetStmt:
2860 tag = CMDTAG_ALTER_DATABASE;
2861 break;
2862
2863 case T_DropdbStmt:
2864 tag = CMDTAG_DROP_DATABASE;
2865 break;
2866
2867 case T_NotifyStmt:
2868 tag = CMDTAG_NOTIFY;
2869 break;
2870
2871 case T_ListenStmt:
2872 tag = CMDTAG_LISTEN;
2873 break;
2874
2875 case T_UnlistenStmt:
2876 tag = CMDTAG_UNLISTEN;
2877 break;
2878
2879 case T_LoadStmt:
2880 tag = CMDTAG_LOAD;
2881 break;
2882
2883 case T_CallStmt:
2884 tag = CMDTAG_CALL;
2885 break;
2886
2887 case T_VacuumStmt:
2888 if (((VacuumStmt *) parsetree)->is_vacuumcmd)
2889 tag = CMDTAG_VACUUM;
2890 else
2891 tag = CMDTAG_ANALYZE;
2892 break;
2893
2894 case T_RepackStmt:
2895 if (((RepackStmt *) parsetree)->command == REPACK_COMMAND_CLUSTER)
2896 tag = CMDTAG_CLUSTER;
2897 else
2898 tag = CMDTAG_REPACK;
2899 break;
2900
2901 case T_ExplainStmt:
2902 tag = CMDTAG_EXPLAIN;
2903 break;
2904
2905 case T_CreateTableAsStmt:
2906 switch (((CreateTableAsStmt *) parsetree)->objtype)
2907 {
2908 case OBJECT_TABLE:
2909 if (((CreateTableAsStmt *) parsetree)->is_select_into)
2910 tag = CMDTAG_SELECT_INTO;
2911 else
2912 tag = CMDTAG_CREATE_TABLE_AS;
2913 break;
2914 case OBJECT_MATVIEW:
2915 tag = CMDTAG_CREATE_MATERIALIZED_VIEW;
2916 break;
2917 default:
2918 tag = CMDTAG_UNKNOWN;
2919 }
2920 break;
2921
2922 case T_RefreshMatViewStmt:
2923 tag = CMDTAG_REFRESH_MATERIALIZED_VIEW;
2924 break;
2925
2926 case T_AlterSystemStmt:
2927 tag = CMDTAG_ALTER_SYSTEM;
2928 break;
2929
2930 case T_VariableSetStmt:
2931 switch (((VariableSetStmt *) parsetree)->kind)
2932 {
2933 case VAR_SET_VALUE:
2934 case VAR_SET_CURRENT:
2935 case VAR_SET_DEFAULT:
2936 case VAR_SET_MULTI:
2937 tag = CMDTAG_SET;
2938 break;
2939 case VAR_RESET:
2940 case VAR_RESET_ALL:
2941 tag = CMDTAG_RESET;
2942 break;
2943 default:
2944 tag = CMDTAG_UNKNOWN;
2945 }
2946 break;
2947
2948 case T_VariableShowStmt:
2949 tag = CMDTAG_SHOW;
2950 break;
2951
2952 case T_DiscardStmt:
2953 switch (((DiscardStmt *) parsetree)->target)
2954 {
2955 case DISCARD_ALL:
2956 tag = CMDTAG_DISCARD_ALL;
2957 break;
2958 case DISCARD_PLANS:
2959 tag = CMDTAG_DISCARD_PLANS;
2960 break;
2961 case DISCARD_TEMP:
2962 tag = CMDTAG_DISCARD_TEMP;
2963 break;
2964 case DISCARD_SEQUENCES:
2965 tag = CMDTAG_DISCARD_SEQUENCES;
2966 break;
2967 default:
2968 tag = CMDTAG_UNKNOWN;
2969 }
2970 break;
2971
2972 case T_CreatePropGraphStmt:
2973 tag = CMDTAG_CREATE_PROPERTY_GRAPH;
2974 break;
2975
2976 case T_AlterPropGraphStmt:
2977 tag = CMDTAG_ALTER_PROPERTY_GRAPH;
2978 break;
2979
2980 case T_CreateTransformStmt:
2981 tag = CMDTAG_CREATE_TRANSFORM;
2982 break;
2983
2984 case T_CreateTrigStmt:
2985 tag = CMDTAG_CREATE_TRIGGER;
2986 break;
2987
2988 case T_CreateEventTrigStmt:
2989 tag = CMDTAG_CREATE_EVENT_TRIGGER;
2990 break;
2991
2992 case T_AlterEventTrigStmt:
2993 tag = CMDTAG_ALTER_EVENT_TRIGGER;
2994 break;
2995
2996 case T_CreatePLangStmt:
2997 tag = CMDTAG_CREATE_LANGUAGE;
2998 break;
2999
3000 case T_CreateRoleStmt:
3001 tag = CMDTAG_CREATE_ROLE;
3002 break;
3003
3004 case T_AlterRoleStmt:
3005 tag = CMDTAG_ALTER_ROLE;
3006 break;
3007
3008 case T_AlterRoleSetStmt:
3009 tag = CMDTAG_ALTER_ROLE;
3010 break;
3011
3012 case T_DropRoleStmt:
3013 tag = CMDTAG_DROP_ROLE;
3014 break;
3015
3016 case T_DropOwnedStmt:
3017 tag = CMDTAG_DROP_OWNED;
3018 break;
3019
3020 case T_ReassignOwnedStmt:
3021 tag = CMDTAG_REASSIGN_OWNED;
3022 break;
3023
3024 case T_LockStmt:
3025 tag = CMDTAG_LOCK_TABLE;
3026 break;
3027
3028 case T_ConstraintsSetStmt:
3029 tag = CMDTAG_SET_CONSTRAINTS;
3030 break;
3031
3032 case T_CheckPointStmt:
3033 tag = CMDTAG_CHECKPOINT;
3034 break;
3035
3036 case T_ReindexStmt:
3037 tag = CMDTAG_REINDEX;
3038 break;
3039
3040 case T_CreateConversionStmt:
3041 tag = CMDTAG_CREATE_CONVERSION;
3042 break;
3043
3044 case T_CreateCastStmt:
3045 tag = CMDTAG_CREATE_CAST;
3046 break;
3047
3048 case T_CreateOpClassStmt:
3049 tag = CMDTAG_CREATE_OPERATOR_CLASS;
3050 break;
3051
3052 case T_CreateOpFamilyStmt:
3053 tag = CMDTAG_CREATE_OPERATOR_FAMILY;
3054 break;
3055
3056 case T_AlterOpFamilyStmt:
3057 tag = CMDTAG_ALTER_OPERATOR_FAMILY;
3058 break;
3059
3060 case T_AlterOperatorStmt:
3061 tag = CMDTAG_ALTER_OPERATOR;
3062 break;
3063
3064 case T_AlterTypeStmt:
3065 tag = CMDTAG_ALTER_TYPE;
3066 break;
3067
3068 case T_AlterTSDictionaryStmt:
3069 tag = CMDTAG_ALTER_TEXT_SEARCH_DICTIONARY;
3070 break;
3071
3072 case T_AlterTSConfigurationStmt:
3073 tag = CMDTAG_ALTER_TEXT_SEARCH_CONFIGURATION;
3074 break;
3075
3076 case T_CreatePolicyStmt:
3077 tag = CMDTAG_CREATE_POLICY;
3078 break;
3079
3080 case T_AlterPolicyStmt:
3081 tag = CMDTAG_ALTER_POLICY;
3082 break;
3083
3084 case T_CreateAmStmt:
3085 tag = CMDTAG_CREATE_ACCESS_METHOD;
3086 break;
3087
3088 case T_CreatePublicationStmt:
3089 tag = CMDTAG_CREATE_PUBLICATION;
3090 break;
3091
3092 case T_AlterPublicationStmt:
3093 tag = CMDTAG_ALTER_PUBLICATION;
3094 break;
3095
3096 case T_CreateSubscriptionStmt:
3097 tag = CMDTAG_CREATE_SUBSCRIPTION;
3098 break;
3099
3100 case T_AlterSubscriptionStmt:
3101 tag = CMDTAG_ALTER_SUBSCRIPTION;
3102 break;
3103
3104 case T_DropSubscriptionStmt:
3105 tag = CMDTAG_DROP_SUBSCRIPTION;
3106 break;
3107
3108 case T_AlterCollationStmt:
3109 tag = CMDTAG_ALTER_COLLATION;
3110 break;
3111
3112 case T_PrepareStmt:
3113 tag = CMDTAG_PREPARE;
3114 break;
3115
3116 case T_ExecuteStmt:
3117 tag = CMDTAG_EXECUTE;
3118 break;
3119
3120 case T_CreateStatsStmt:
3121 tag = CMDTAG_CREATE_STATISTICS;
3122 break;
3123
3124 case T_AlterStatsStmt:
3125 tag = CMDTAG_ALTER_STATISTICS;
3126 break;
3127
3128 case T_DeallocateStmt:
3129 {
3130 DeallocateStmt *stmt = (DeallocateStmt *) parsetree;
3131
3132 if (stmt->name == NULL)
3133 tag = CMDTAG_DEALLOCATE_ALL;
3134 else
3135 tag = CMDTAG_DEALLOCATE;
3136 }
3137 break;
3138
3139 case T_WaitStmt:
3140 tag = CMDTAG_WAIT;
3141 break;
3142
3143 /* already-planned queries */
3144 case T_PlannedStmt:
3145 {
3146 PlannedStmt *stmt = (PlannedStmt *) parsetree;
3147
3148 switch (stmt->commandType)
3149 {
3150 case CMD_SELECT:
3151
3152 /*
3153 * We take a little extra care here so that the result
3154 * will be useful for complaints about read-only
3155 * statements
3156 */
3157 if (stmt->rowMarks != NIL)
3158 {
3159 /* not 100% but probably close enough */
3160 switch (((PlanRowMark *) linitial(stmt->rowMarks))->strength)
3161 {
3162 case LCS_FORKEYSHARE:
3163 tag = CMDTAG_SELECT_FOR_KEY_SHARE;
3164 break;
3165 case LCS_FORSHARE:
3166 tag = CMDTAG_SELECT_FOR_SHARE;
3167 break;
3168 case LCS_FORNOKEYUPDATE:
3169 tag = CMDTAG_SELECT_FOR_NO_KEY_UPDATE;
3170 break;
3171 case LCS_FORUPDATE:
3172 tag = CMDTAG_SELECT_FOR_UPDATE;
3173 break;
3174 default:
3175 tag = CMDTAG_SELECT;
3176 break;
3177 }
3178 }
3179 else
3180 tag = CMDTAG_SELECT;
3181 break;
3182 case CMD_UPDATE:
3183 tag = CMDTAG_UPDATE;
3184 break;
3185 case CMD_INSERT:
3186 tag = CMDTAG_INSERT;
3187 break;
3188 case CMD_DELETE:
3189 tag = CMDTAG_DELETE;
3190 break;
3191 case CMD_MERGE:
3192 tag = CMDTAG_MERGE;
3193 break;
3194 case CMD_UTILITY:
3195 tag = CreateCommandTag(stmt->utilityStmt);
3196 break;
3197 default:
3198 elog(WARNING, "unrecognized commandType: %d",
3199 (int) stmt->commandType);
3200 tag = CMDTAG_UNKNOWN;
3201 break;
3202 }
3203 }
3204 break;
3205
3206 /* parsed-and-rewritten-but-not-planned queries */
3207 case T_Query:
3208 {
3209 Query *stmt = (Query *) parsetree;
3210
3211 switch (stmt->commandType)
3212 {
3213 case CMD_SELECT:
3214
3215 /*
3216 * We take a little extra care here so that the result
3217 * will be useful for complaints about read-only
3218 * statements
3219 */
3220 if (stmt->rowMarks != NIL)
3221 {
3222 /* not 100% but probably close enough */
3223 switch (((RowMarkClause *) linitial(stmt->rowMarks))->strength)
3224 {
3225 case LCS_FORKEYSHARE:
3226 tag = CMDTAG_SELECT_FOR_KEY_SHARE;
3227 break;
3228 case LCS_FORSHARE:
3229 tag = CMDTAG_SELECT_FOR_SHARE;
3230 break;
3231 case LCS_FORNOKEYUPDATE:
3232 tag = CMDTAG_SELECT_FOR_NO_KEY_UPDATE;
3233 break;
3234 case LCS_FORUPDATE:
3235 tag = CMDTAG_SELECT_FOR_UPDATE;
3236 break;
3237 default:
3238 tag = CMDTAG_UNKNOWN;
3239 break;
3240 }
3241 }
3242 else
3243 tag = CMDTAG_SELECT;
3244 break;
3245 case CMD_UPDATE:
3246 tag = CMDTAG_UPDATE;
3247 break;
3248 case CMD_INSERT:
3249 tag = CMDTAG_INSERT;
3250 break;
3251 case CMD_DELETE:
3252 tag = CMDTAG_DELETE;
3253 break;
3254 case CMD_MERGE:
3255 tag = CMDTAG_MERGE;
3256 break;
3257 case CMD_UTILITY:
3258 tag = CreateCommandTag(stmt->utilityStmt);
3259 break;
3260 default:
3261 elog(WARNING, "unrecognized commandType: %d",
3262 (int) stmt->commandType);
3263 tag = CMDTAG_UNKNOWN;
3264 break;
3265 }
3266 }
3267 break;
3268
3269 default:
3270 elog(WARNING, "unrecognized node type: %d",
3271 (int) nodeTag(parsetree));
3272 tag = CMDTAG_UNKNOWN;
3273 break;
3274 }
3275
3276 return tag;
3277}
CommandTag
CommandTag
Definition cmdtag.h:23
stmt
#define stmt
Definition indent_codes.h:59
LCS_FORUPDATE
@ LCS_FORUPDATE
Definition lockoptions.h:28
LCS_FORSHARE
@ LCS_FORSHARE
Definition lockoptions.h:26
LCS_FORKEYSHARE
@ LCS_FORKEYSHARE
Definition lockoptions.h:25
LCS_FORNOKEYUPDATE
@ LCS_FORNOKEYUPDATE
Definition lockoptions.h:27
nodeTag
#define nodeTag(nodeptr)
Definition nodes.h:139
TRANS_STMT_ROLLBACK_TO
@ TRANS_STMT_ROLLBACK_TO
Definition parsenodes.h:3906
TRANS_STMT_START
@ TRANS_STMT_START
Definition parsenodes.h:3901
TRANS_STMT_SAVEPOINT
@ TRANS_STMT_SAVEPOINT
Definition parsenodes.h:3904
TRANS_STMT_BEGIN
@ TRANS_STMT_BEGIN
Definition parsenodes.h:3900
TRANS_STMT_ROLLBACK
@ TRANS_STMT_ROLLBACK
Definition parsenodes.h:3903
TRANS_STMT_COMMIT_PREPARED
@ TRANS_STMT_COMMIT_PREPARED
Definition parsenodes.h:3908
TRANS_STMT_COMMIT
@ TRANS_STMT_COMMIT
Definition parsenodes.h:3902
TRANS_STMT_ROLLBACK_PREPARED
@ TRANS_STMT_ROLLBACK_PREPARED
Definition parsenodes.h:3909
TRANS_STMT_PREPARE
@ TRANS_STMT_PREPARE
Definition parsenodes.h:3907
TRANS_STMT_RELEASE
@ TRANS_STMT_RELEASE
Definition parsenodes.h:3905
REPACK_COMMAND_CLUSTER
@ REPACK_COMMAND_CLUSTER
Definition parsenodes.h:4099
VAR_SET_DEFAULT
@ VAR_SET_DEFAULT
Definition parsenodes.h:2804
VAR_RESET
@ VAR_RESET
Definition parsenodes.h:2807
VAR_SET_MULTI
@ VAR_SET_MULTI
Definition parsenodes.h:2806
VAR_SET_VALUE
@ VAR_SET_VALUE
Definition parsenodes.h:2803
VAR_SET_CURRENT
@ VAR_SET_CURRENT
Definition parsenodes.h:2805
VAR_RESET_ALL
@ VAR_RESET_ALL
Definition parsenodes.h:2808
OBJECT_EVENT_TRIGGER
@ OBJECT_EVENT_TRIGGER
Definition parsenodes.h:2445
OBJECT_FDW
@ OBJECT_FDW
Definition parsenodes.h:2447
OBJECT_TSPARSER
@ OBJECT_TSPARSER
Definition parsenodes.h:2479
OBJECT_COLLATION
@ OBJECT_COLLATION
Definition parsenodes.h:2438
OBJECT_PROPGRAPH
@ OBJECT_PROPGRAPH
Definition parsenodes.h:2461
OBJECT_ACCESS_METHOD
@ OBJECT_ACCESS_METHOD
Definition parsenodes.h:2431
OBJECT_OPCLASS
@ OBJECT_OPCLASS
Definition parsenodes.h:2455
OBJECT_AGGREGATE
@ OBJECT_AGGREGATE
Definition parsenodes.h:2432
OBJECT_MATVIEW
@ OBJECT_MATVIEW
Definition parsenodes.h:2454
OBJECT_SCHEMA
@ OBJECT_SCHEMA
Definition parsenodes.h:2468
OBJECT_POLICY
@ OBJECT_POLICY
Definition parsenodes.h:2459
OBJECT_OPERATOR
@ OBJECT_OPERATOR
Definition parsenodes.h:2456
OBJECT_FOREIGN_TABLE
@ OBJECT_FOREIGN_TABLE
Definition parsenodes.h:2449
OBJECT_TSCONFIGURATION
@ OBJECT_TSCONFIGURATION
Definition parsenodes.h:2477
OBJECT_OPFAMILY
@ OBJECT_OPFAMILY
Definition parsenodes.h:2457
OBJECT_DOMAIN
@ OBJECT_DOMAIN
Definition parsenodes.h:2443
OBJECT_COLUMN
@ OBJECT_COLUMN
Definition parsenodes.h:2437
OBJECT_ROUTINE
@ OBJECT_ROUTINE
Definition parsenodes.h:2466
OBJECT_PROCEDURE
@ OBJECT_PROCEDURE
Definition parsenodes.h:2460
OBJECT_EXTENSION
@ OBJECT_EXTENSION
Definition parsenodes.h:2446
OBJECT_INDEX
@ OBJECT_INDEX
Definition parsenodes.h:2451
OBJECT_SEQUENCE
@ OBJECT_SEQUENCE
Definition parsenodes.h:2469
OBJECT_TSTEMPLATE
@ OBJECT_TSTEMPLATE
Definition parsenodes.h:2480
OBJECT_LANGUAGE
@ OBJECT_LANGUAGE
Definition parsenodes.h:2452
OBJECT_FOREIGN_SERVER
@ OBJECT_FOREIGN_SERVER
Definition parsenodes.h:2448
OBJECT_TSDICTIONARY
@ OBJECT_TSDICTIONARY
Definition parsenodes.h:2478
OBJECT_PUBLICATION
@ OBJECT_PUBLICATION
Definition parsenodes.h:2462
OBJECT_RULE
@ OBJECT_RULE
Definition parsenodes.h:2467
OBJECT_CONVERSION
@ OBJECT_CONVERSION
Definition parsenodes.h:2439
OBJECT_TABLE
@ OBJECT_TABLE
Definition parsenodes.h:2473
OBJECT_VIEW
@ OBJECT_VIEW
Definition parsenodes.h:2483
OBJECT_TYPE
@ OBJECT_TYPE
Definition parsenodes.h:2481
OBJECT_FUNCTION
@ OBJECT_FUNCTION
Definition parsenodes.h:2450
OBJECT_STATISTIC_EXT
@ OBJECT_STATISTIC_EXT
Definition parsenodes.h:2471
OBJECT_CAST
@ OBJECT_CAST
Definition parsenodes.h:2436
OBJECT_TRIGGER
@ OBJECT_TRIGGER
Definition parsenodes.h:2476
OBJECT_TRANSFORM
@ OBJECT_TRANSFORM
Definition parsenodes.h:2475
DISCARD_ALL
@ DISCARD_ALL
Definition parsenodes.h:4181
DISCARD_PLANS
@ DISCARD_PLANS
Definition parsenodes.h:4182
DISCARD_SEQUENCES
@ DISCARD_SEQUENCES
Definition parsenodes.h:4183
DISCARD_TEMP
@ DISCARD_TEMP
Definition parsenodes.h:4184
linitial
#define linitial(l)
Definition pg_list.h:178
fb
static int fb(int x)
Definition preproc-init.c:92
CreateCommandTag
CommandTag CreateCommandTag(Node *parsetree)
Definition utility.c:2385
AlterObjectTypeCommandTag
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().

◆ GetCommandLogLevel()

LogStmtLevel GetCommandLogLevel ( Node *  parsetree)
extern

Definition at line 3290 of file utility.c.

3291{
3292 LogStmtLevel lev;
3293
3294 switch (nodeTag(parsetree))
3295 {
3296 /* recurse if we're given a RawStmt */
3297 case T_RawStmt:
3298 lev = GetCommandLogLevel(((RawStmt *) parsetree)->stmt);
3299 break;
3300
3301 /* raw plannable queries */
3302 case T_InsertStmt:
3303 case T_DeleteStmt:
3304 case T_UpdateStmt:
3305 case T_MergeStmt:
3306 lev = LOGSTMT_MOD;
3307 break;
3308
3309 case T_SelectStmt:
3310 if (((SelectStmt *) parsetree)->intoClause)
3311 lev = LOGSTMT_DDL; /* SELECT INTO */
3312 else
3313 lev = LOGSTMT_ALL;
3314 break;
3315
3316 case T_PLAssignStmt:
3317 lev = LOGSTMT_ALL;
3318 break;
3319
3320 /* utility statements --- same whether raw or cooked */
3321 case T_TransactionStmt:
3322 lev = LOGSTMT_ALL;
3323 break;
3324
3325 case T_DeclareCursorStmt:
3326 lev = LOGSTMT_ALL;
3327 break;
3328
3329 case T_ClosePortalStmt:
3330 lev = LOGSTMT_ALL;
3331 break;
3332
3333 case T_FetchStmt:
3334 lev = LOGSTMT_ALL;
3335 break;
3336
3337 case T_CreateSchemaStmt:
3338 lev = LOGSTMT_DDL;
3339 break;
3340
3341 case T_CreateStmt:
3342 case T_CreateForeignTableStmt:
3343 lev = LOGSTMT_DDL;
3344 break;
3345
3346 case T_CreateTableSpaceStmt:
3347 case T_DropTableSpaceStmt:
3348 case T_AlterTableSpaceOptionsStmt:
3349 lev = LOGSTMT_DDL;
3350 break;
3351
3352 case T_CreateExtensionStmt:
3353 case T_AlterExtensionStmt:
3354 case T_AlterExtensionContentsStmt:
3355 lev = LOGSTMT_DDL;
3356 break;
3357
3358 case T_CreateFdwStmt:
3359 case T_AlterFdwStmt:
3360 case T_CreateForeignServerStmt:
3361 case T_AlterForeignServerStmt:
3362 case T_CreateUserMappingStmt:
3363 case T_AlterUserMappingStmt:
3364 case T_DropUserMappingStmt:
3365 case T_ImportForeignSchemaStmt:
3366 lev = LOGSTMT_DDL;
3367 break;
3368
3369 case T_DropStmt:
3370 lev = LOGSTMT_DDL;
3371 break;
3372
3373 case T_TruncateStmt:
3374 lev = LOGSTMT_MOD;
3375 break;
3376
3377 case T_CommentStmt:
3378 lev = LOGSTMT_DDL;
3379 break;
3380
3381 case T_SecLabelStmt:
3382 lev = LOGSTMT_DDL;
3383 break;
3384
3385 case T_CopyStmt:
3386 if (((CopyStmt *) parsetree)->is_from)
3387 lev = LOGSTMT_MOD;
3388 else
3389 lev = LOGSTMT_ALL;
3390 break;
3391
3392 case T_PrepareStmt:
3393 {
3394 PrepareStmt *stmt = (PrepareStmt *) parsetree;
3395
3396 /* Look through a PREPARE to the contained stmt */
3397 lev = GetCommandLogLevel(stmt->query);
3398 }
3399 break;
3400
3401 case T_ExecuteStmt:
3402 {
3403 ExecuteStmt *stmt = (ExecuteStmt *) parsetree;
3404 PreparedStatement *ps;
3405
3406 /* Look through an EXECUTE to the referenced stmt */
3407 ps = FetchPreparedStatement(stmt->name, false);
3408 if (ps && ps->plansource->raw_parse_tree)
3409 lev = GetCommandLogLevel(ps->plansource->raw_parse_tree->stmt);
3410 else
3411 lev = LOGSTMT_ALL;
3412 }
3413 break;
3414
3415 case T_DeallocateStmt:
3416 lev = LOGSTMT_ALL;
3417 break;
3418
3419 case T_RenameStmt:
3420 lev = LOGSTMT_DDL;
3421 break;
3422
3423 case T_AlterObjectDependsStmt:
3424 lev = LOGSTMT_DDL;
3425 break;
3426
3427 case T_AlterObjectSchemaStmt:
3428 lev = LOGSTMT_DDL;
3429 break;
3430
3431 case T_AlterOwnerStmt:
3432 lev = LOGSTMT_DDL;
3433 break;
3434
3435 case T_AlterOperatorStmt:
3436 lev = LOGSTMT_DDL;
3437 break;
3438
3439 case T_AlterTypeStmt:
3440 lev = LOGSTMT_DDL;
3441 break;
3442
3443 case T_AlterTableMoveAllStmt:
3444 case T_AlterTableStmt:
3445 lev = LOGSTMT_DDL;
3446 break;
3447
3448 case T_AlterDomainStmt:
3449 lev = LOGSTMT_DDL;
3450 break;
3451
3452 case T_GrantStmt:
3453 lev = LOGSTMT_DDL;
3454 break;
3455
3456 case T_GrantRoleStmt:
3457 lev = LOGSTMT_DDL;
3458 break;
3459
3460 case T_AlterDefaultPrivilegesStmt:
3461 lev = LOGSTMT_DDL;
3462 break;
3463
3464 case T_DefineStmt:
3465 lev = LOGSTMT_DDL;
3466 break;
3467
3468 case T_CompositeTypeStmt:
3469 lev = LOGSTMT_DDL;
3470 break;
3471
3472 case T_CreateEnumStmt:
3473 lev = LOGSTMT_DDL;
3474 break;
3475
3476 case T_CreateRangeStmt:
3477 lev = LOGSTMT_DDL;
3478 break;
3479
3480 case T_AlterEnumStmt:
3481 lev = LOGSTMT_DDL;
3482 break;
3483
3484 case T_ViewStmt:
3485 lev = LOGSTMT_DDL;
3486 break;
3487
3488 case T_CreateFunctionStmt:
3489 lev = LOGSTMT_DDL;
3490 break;
3491
3492 case T_AlterFunctionStmt:
3493 lev = LOGSTMT_DDL;
3494 break;
3495
3496 case T_IndexStmt:
3497 lev = LOGSTMT_DDL;
3498 break;
3499
3500 case T_RuleStmt:
3501 lev = LOGSTMT_DDL;
3502 break;
3503
3504 case T_CreateSeqStmt:
3505 lev = LOGSTMT_DDL;
3506 break;
3507
3508 case T_AlterSeqStmt:
3509 lev = LOGSTMT_DDL;
3510 break;
3511
3512 case T_DoStmt:
3513 lev = LOGSTMT_ALL;
3514 break;
3515
3516 case T_CreatedbStmt:
3517 lev = LOGSTMT_DDL;
3518 break;
3519
3520 case T_AlterDatabaseStmt:
3521 case T_AlterDatabaseRefreshCollStmt:
3522 case T_AlterDatabaseSetStmt:
3523 lev = LOGSTMT_DDL;
3524 break;
3525
3526 case T_DropdbStmt:
3527 lev = LOGSTMT_DDL;
3528 break;
3529
3530 case T_NotifyStmt:
3531 lev = LOGSTMT_ALL;
3532 break;
3533
3534 case T_ListenStmt:
3535 lev = LOGSTMT_ALL;
3536 break;
3537
3538 case T_UnlistenStmt:
3539 lev = LOGSTMT_ALL;
3540 break;
3541
3542 case T_LoadStmt:
3543 lev = LOGSTMT_ALL;
3544 break;
3545
3546 case T_CallStmt:
3547 lev = LOGSTMT_ALL;
3548 break;
3549
3550 case T_RepackStmt:
3551 lev = LOGSTMT_DDL;
3552 break;
3553
3554 case T_VacuumStmt:
3555 lev = LOGSTMT_ALL;
3556 break;
3557
3558 case T_ExplainStmt:
3559 {
3560 ExplainStmt *stmt = (ExplainStmt *) parsetree;
3561 bool analyze = false;
3562 ListCell *lc;
3563
3564 /* Look through an EXPLAIN ANALYZE to the contained stmt */
3565 foreach(lc, stmt->options)
3566 {
3567 DefElem *opt = (DefElem *) lfirst(lc);
3568
3569 if (strcmp(opt->defname, "analyze") == 0)
3570 analyze = defGetBoolean(opt);
3571 /* don't "break", as explain.c will use the last value */
3572 }
3573 if (analyze)
3574 return GetCommandLogLevel(stmt->query);
3575
3576 /* Plain EXPLAIN isn't so interesting */
3577 lev = LOGSTMT_ALL;
3578 }
3579 break;
3580
3581 case T_CreateTableAsStmt:
3582 lev = LOGSTMT_DDL;
3583 break;
3584
3585 case T_RefreshMatViewStmt:
3586 lev = LOGSTMT_DDL;
3587 break;
3588
3589 case T_AlterSystemStmt:
3590 lev = LOGSTMT_DDL;
3591 break;
3592
3593 case T_VariableSetStmt:
3594 lev = LOGSTMT_ALL;
3595 break;
3596
3597 case T_VariableShowStmt:
3598 lev = LOGSTMT_ALL;
3599 break;
3600
3601 case T_DiscardStmt:
3602 lev = LOGSTMT_ALL;
3603 break;
3604
3605 case T_CreateTrigStmt:
3606 lev = LOGSTMT_DDL;
3607 break;
3608
3609 case T_CreateEventTrigStmt:
3610 lev = LOGSTMT_DDL;
3611 break;
3612
3613 case T_AlterEventTrigStmt:
3614 lev = LOGSTMT_DDL;
3615 break;
3616
3617 case T_CreatePLangStmt:
3618 lev = LOGSTMT_DDL;
3619 break;
3620
3621 case T_CreateDomainStmt:
3622 lev = LOGSTMT_DDL;
3623 break;
3624
3625 case T_CreateRoleStmt:
3626 lev = LOGSTMT_DDL;
3627 break;
3628
3629 case T_AlterRoleStmt:
3630 lev = LOGSTMT_DDL;
3631 break;
3632
3633 case T_AlterRoleSetStmt:
3634 lev = LOGSTMT_DDL;
3635 break;
3636
3637 case T_DropRoleStmt:
3638 lev = LOGSTMT_DDL;
3639 break;
3640
3641 case T_DropOwnedStmt:
3642 lev = LOGSTMT_DDL;
3643 break;
3644
3645 case T_ReassignOwnedStmt:
3646 lev = LOGSTMT_DDL;
3647 break;
3648
3649 case T_LockStmt:
3650 lev = LOGSTMT_ALL;
3651 break;
3652
3653 case T_ConstraintsSetStmt:
3654 lev = LOGSTMT_ALL;
3655 break;
3656
3657 case T_CheckPointStmt:
3658 lev = LOGSTMT_ALL;
3659 break;
3660
3661 case T_ReindexStmt:
3662 lev = LOGSTMT_ALL; /* should this be DDL? */
3663 break;
3664
3665 case T_CreateConversionStmt:
3666 lev = LOGSTMT_DDL;
3667 break;
3668
3669 case T_CreateCastStmt:
3670 lev = LOGSTMT_DDL;
3671 break;
3672
3673 case T_CreateOpClassStmt:
3674 lev = LOGSTMT_DDL;
3675 break;
3676
3677 case T_CreateOpFamilyStmt:
3678 lev = LOGSTMT_DDL;
3679 break;
3680
3681 case T_CreatePropGraphStmt:
3682 lev = LOGSTMT_DDL;
3683 break;
3684
3685 case T_AlterPropGraphStmt:
3686 lev = LOGSTMT_DDL;
3687 break;
3688
3689 case T_CreateTransformStmt:
3690 lev = LOGSTMT_DDL;
3691 break;
3692
3693 case T_AlterOpFamilyStmt:
3694 lev = LOGSTMT_DDL;
3695 break;
3696
3697 case T_CreatePolicyStmt:
3698 lev = LOGSTMT_DDL;
3699 break;
3700
3701 case T_AlterPolicyStmt:
3702 lev = LOGSTMT_DDL;
3703 break;
3704
3705 case T_AlterTSDictionaryStmt:
3706 lev = LOGSTMT_DDL;
3707 break;
3708
3709 case T_AlterTSConfigurationStmt:
3710 lev = LOGSTMT_DDL;
3711 break;
3712
3713 case T_CreateAmStmt:
3714 lev = LOGSTMT_DDL;
3715 break;
3716
3717 case T_CreatePublicationStmt:
3718 lev = LOGSTMT_DDL;
3719 break;
3720
3721 case T_AlterPublicationStmt:
3722 lev = LOGSTMT_DDL;
3723 break;
3724
3725 case T_CreateSubscriptionStmt:
3726 lev = LOGSTMT_DDL;
3727 break;
3728
3729 case T_AlterSubscriptionStmt:
3730 lev = LOGSTMT_DDL;
3731 break;
3732
3733 case T_DropSubscriptionStmt:
3734 lev = LOGSTMT_DDL;
3735 break;
3736
3737 case T_CreateStatsStmt:
3738 lev = LOGSTMT_DDL;
3739 break;
3740
3741 case T_AlterStatsStmt:
3742 lev = LOGSTMT_DDL;
3743 break;
3744
3745 case T_AlterCollationStmt:
3746 lev = LOGSTMT_DDL;
3747 break;
3748
3749 case T_WaitStmt:
3750 lev = LOGSTMT_ALL;
3751 break;
3752
3753 /* already-planned queries */
3754 case T_PlannedStmt:
3755 {
3756 PlannedStmt *stmt = (PlannedStmt *) parsetree;
3757
3758 switch (stmt->commandType)
3759 {
3760 case CMD_SELECT:
3761 lev = LOGSTMT_ALL;
3762 break;
3763
3764 case CMD_UPDATE:
3765 case CMD_INSERT:
3766 case CMD_DELETE:
3767 case CMD_MERGE:
3768 lev = LOGSTMT_MOD;
3769 break;
3770
3771 case CMD_UTILITY:
3772 lev = GetCommandLogLevel(stmt->utilityStmt);
3773 break;
3774
3775 default:
3776 elog(WARNING, "unrecognized commandType: %d",
3777 (int) stmt->commandType);
3778 lev = LOGSTMT_ALL;
3779 break;
3780 }
3781 }
3782 break;
3783
3784 /* parsed-and-rewritten-but-not-planned queries */
3785 case T_Query:
3786 {
3787 Query *stmt = (Query *) parsetree;
3788
3789 switch (stmt->commandType)
3790 {
3791 case CMD_SELECT:
3792 lev = LOGSTMT_ALL;
3793 break;
3794
3795 case CMD_UPDATE:
3796 case CMD_INSERT:
3797 case CMD_DELETE:
3798 case CMD_MERGE:
3799 lev = LOGSTMT_MOD;
3800 break;
3801
3802 case CMD_UTILITY:
3803 lev = GetCommandLogLevel(stmt->utilityStmt);
3804 break;
3805
3806 default:
3807 elog(WARNING, "unrecognized commandType: %d",
3808 (int) stmt->commandType);
3809 lev = LOGSTMT_ALL;
3810 break;
3811 }
3812 }
3813 break;
3814
3815 default:
3816 elog(WARNING, "unrecognized node type: %d",
3817 (int) nodeTag(parsetree));
3818 lev = LOGSTMT_ALL;
3819 break;
3820 }
3821
3822 return lev;
3823}
FetchPreparedStatement
PreparedStatement * FetchPreparedStatement(const char *stmt_name, bool throwError)
Definition prepare.c:436
defGetBoolean
bool defGetBoolean(DefElem *def)
Definition define.c:93
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
DefElem::defname
char * defname
Definition parsenodes.h:860
LOGSTMT_MOD
@ LOGSTMT_MOD
Definition tcopprot.h:36
LOGSTMT_DDL
@ LOGSTMT_DDL
Definition tcopprot.h:35
LOGSTMT_ALL
@ LOGSTMT_ALL
Definition tcopprot.h:37
GetCommandLogLevel
LogStmtLevel GetCommandLogLevel(Node *parsetree)
Definition utility.c:3290

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

◆ ProcessUtility()

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

Definition at line 504 of file utility.c.

512{
513 Assert(IsA(pstmt, PlannedStmt));
514 Assert(pstmt->commandType == CMD_UTILITY);
515 Assert(queryString != NULL); /* required as of 8.4 */
516 Assert(qc == NULL || qc->commandTag == CMDTAG_UNKNOWN);
517
518 /*
519 * We provide a function hook variable that lets loadable plugins get
520 * control when ProcessUtility is called. Such a plugin would normally
521 * call standard_ProcessUtility().
522 */
523 if (ProcessUtility_hook)
524 (*ProcessUtility_hook) (pstmt, queryString, readOnlyTree,
525 context, params, queryEnv,
526 dest, qc);
527 else
528 standard_ProcessUtility(pstmt, queryString, readOnlyTree,
529 context, params, queryEnv,
530 dest, qc);
531}
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:548
ProcessUtility_hook
ProcessUtility_hook_type ProcessUtility_hook
Definition utility.c:72

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 
)
extern

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 */
1983 wrapper = makeNode(PlannedStmt);
1984 wrapper->commandType = CMD_UTILITY;
1985 wrapper->canSetTag = false;
1986 wrapper->utilityStmt = stmt;
1987 wrapper->stmt_location = context->pstmt->stmt_location;
1988 wrapper->stmt_len = context->pstmt->stmt_len;
1989 wrapper->planOrigin = PLAN_STMT_INTERNAL;
1990
1991 ProcessUtility(wrapper,
1992 context->queryString,
1993 false,
1994 PROCESS_UTILITY_SUBCOMMAND,
1995 context->params,
1996 context->queryEnv,
1997 None_Receiver,
1998 NULL);
1999
2000 EventTriggerAlterTableStart(context->pstmt->utilityStmt);
2001 EventTriggerAlterTableRelid(context->relid);
2002}
None_Receiver
DestReceiver * None_Receiver
Definition dest.c:96
EventTriggerAlterTableRelid
void EventTriggerAlterTableRelid(Oid objectId)
Definition event_trigger.c:1789
EventTriggerAlterTableStart
void EventTriggerAlterTableStart(const Node *parsetree)
Definition event_trigger.c:1755
EventTriggerAlterTableEnd
void EventTriggerAlterTableEnd(void)
Definition event_trigger.c:1842
makeNode
#define makeNode(_type_)
Definition nodes.h:161
PLAN_STMT_INTERNAL
@ PLAN_STMT_INTERNAL
Definition plannodes.h:38
AlterTableUtilityContext::params
ParamListInfo params
Definition utility.h:35
AlterTableUtilityContext::queryEnv
QueryEnvironment * queryEnv
Definition utility.h:36
AlterTableUtilityContext::pstmt
PlannedStmt * pstmt
Definition utility.h:32
AlterTableUtilityContext::queryString
const char * queryString
Definition utility.h:33
PlannedStmt::canSetTag
bool canSetTag
Definition plannodes.h:84
PlannedStmt::stmt_len
ParseLoc stmt_len
Definition plannodes.h:171
PlannedStmt::planOrigin
PlannedStmtOrigin planOrigin
Definition plannodes.h:75
PlannedStmt::stmt_location
ParseLoc stmt_location
Definition plannodes.h:169
PlannedStmt::utilityStmt
Node * utilityStmt
Definition plannodes.h:153
ProcessUtility
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().

◆ standard_ProcessUtility()

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

Definition at line 548 of file utility.c.

556{
557 Node *parsetree;
558 bool isTopLevel = (context == PROCESS_UTILITY_TOPLEVEL);
559 bool isAtomicContext = (!(context == PROCESS_UTILITY_TOPLEVEL || context == PROCESS_UTILITY_QUERY_NONATOMIC) || IsTransactionBlock());
560 ParseState *pstate;
561 int readonly_flags;
562
563 /* This can recurse, so check for excessive recursion */
564 check_stack_depth();
565
566 /*
567 * If the given node tree is read-only, make a copy to ensure that parse
568 * transformations don't damage the original tree. This could be
569 * refactored to avoid making unnecessary copies in more cases, but it's
570 * not clear that it's worth a great deal of trouble over. Statements
571 * that are complex enough to be expensive to copy are exactly the ones
572 * we'd need to copy, so that only marginal savings seem possible.
573 */
574 if (readOnlyTree)
575 pstmt = copyObject(pstmt);
576 parsetree = pstmt->utilityStmt;
577
578 /* Prohibit read/write commands in read-only states. */
579 readonly_flags = ClassifyUtilityCommandAsReadOnly(parsetree);
580 if (readonly_flags != COMMAND_IS_STRICTLY_READ_ONLY &&
581 (XactReadOnly || IsInParallelMode()))
582 {
583 CommandTag commandtag = CreateCommandTag(parsetree);
584
585 if ((readonly_flags & COMMAND_OK_IN_READ_ONLY_TXN) == 0)
586 PreventCommandIfReadOnly(GetCommandTagName(commandtag));
587 if ((readonly_flags & COMMAND_OK_IN_PARALLEL_MODE) == 0)
588 PreventCommandIfParallelMode(GetCommandTagName(commandtag));
589 if ((readonly_flags & COMMAND_OK_IN_RECOVERY) == 0)
590 PreventCommandDuringRecovery(GetCommandTagName(commandtag));
591 }
592
593 pstate = make_parsestate(NULL);
594 pstate->p_sourcetext = queryString;
595 pstate->p_queryEnv = queryEnv;
596
597 switch (nodeTag(parsetree))
598 {
599 /*
600 * ******************** transactions ********************
601 */
602 case T_TransactionStmt:
603 {
604 TransactionStmt *stmt = (TransactionStmt *) parsetree;
605
606 switch (stmt->kind)
607 {
608 /*
609 * START TRANSACTION, as defined by SQL99: Identical
610 * to BEGIN. Same code for both.
611 */
612 case TRANS_STMT_BEGIN:
613 case TRANS_STMT_START:
614 {
615 ListCell *lc;
616
617 BeginTransactionBlock();
618 foreach(lc, stmt->options)
619 {
620 DefElem *item = (DefElem *) lfirst(lc);
621
622 if (strcmp(item->defname, "transaction_isolation") == 0)
623 SetPGVariable("transaction_isolation",
624 list_make1(item->arg),
625 true);
626 else if (strcmp(item->defname, "transaction_read_only") == 0)
627 SetPGVariable("transaction_read_only",
628 list_make1(item->arg),
629 true);
630 else if (strcmp(item->defname, "transaction_deferrable") == 0)
631 SetPGVariable("transaction_deferrable",
632 list_make1(item->arg),
633 true);
634 }
635 }
636 break;
637
638 case TRANS_STMT_COMMIT:
639 if (!EndTransactionBlock(stmt->chain))
640 {
641 /* report unsuccessful commit in qc */
642 if (qc)
643 SetQueryCompletion(qc, CMDTAG_ROLLBACK, 0);
644 }
645 break;
646
647 case TRANS_STMT_PREPARE:
648 if (!PrepareTransactionBlock(stmt->gid))
649 {
650 /* report unsuccessful commit in qc */
651 if (qc)
652 SetQueryCompletion(qc, CMDTAG_ROLLBACK, 0);
653 }
654 break;
655
656 case TRANS_STMT_COMMIT_PREPARED:
657 PreventInTransactionBlock(isTopLevel, "COMMIT PREPARED");
658 FinishPreparedTransaction(stmt->gid, true);
659 break;
660
661 case TRANS_STMT_ROLLBACK_PREPARED:
662 PreventInTransactionBlock(isTopLevel, "ROLLBACK PREPARED");
663 FinishPreparedTransaction(stmt->gid, false);
664 break;
665
666 case TRANS_STMT_ROLLBACK:
667 UserAbortTransactionBlock(stmt->chain);
668 break;
669
670 case TRANS_STMT_SAVEPOINT:
671 RequireTransactionBlock(isTopLevel, "SAVEPOINT");
672 DefineSavepoint(stmt->savepoint_name);
673 break;
674
675 case TRANS_STMT_RELEASE:
676 RequireTransactionBlock(isTopLevel, "RELEASE SAVEPOINT");
677 ReleaseSavepoint(stmt->savepoint_name);
678 break;
679
680 case TRANS_STMT_ROLLBACK_TO:
681 RequireTransactionBlock(isTopLevel, "ROLLBACK TO SAVEPOINT");
682 RollbackToSavepoint(stmt->savepoint_name);
683
684 /*
685 * CommitTransactionCommand is in charge of
686 * re-defining the savepoint again
687 */
688 break;
689 }
690 }
691 break;
692
693 /*
694 * Portal (cursor) manipulation
695 */
696 case T_DeclareCursorStmt:
697 PerformCursorOpen(pstate, (DeclareCursorStmt *) parsetree, params,
698 isTopLevel);
699 break;
700
701 case T_ClosePortalStmt:
702 {
703 ClosePortalStmt *stmt = (ClosePortalStmt *) parsetree;
704
705 CheckRestrictedOperation("CLOSE");
706 PerformPortalClose(stmt->portalname);
707 }
708 break;
709
710 case T_FetchStmt:
711 PerformPortalFetch((FetchStmt *) parsetree, dest, qc);
712 break;
713
714 case T_DoStmt:
715 ExecuteDoStmt(pstate, (DoStmt *) parsetree, isAtomicContext);
716 break;
717
718 case T_CreateTableSpaceStmt:
719 /* no event triggers for global objects */
720 PreventInTransactionBlock(isTopLevel, "CREATE TABLESPACE");
721 CreateTableSpace((CreateTableSpaceStmt *) parsetree);
722 break;
723
724 case T_DropTableSpaceStmt:
725 /* no event triggers for global objects */
726 PreventInTransactionBlock(isTopLevel, "DROP TABLESPACE");
727 DropTableSpace((DropTableSpaceStmt *) parsetree);
728 break;
729
730 case T_AlterTableSpaceOptionsStmt:
731 /* no event triggers for global objects */
732 AlterTableSpaceOptions((AlterTableSpaceOptionsStmt *) parsetree);
733 break;
734
735 case T_TruncateStmt:
736 ExecuteTruncate((TruncateStmt *) parsetree);
737 break;
738
739 case T_CopyStmt:
740 {
741 uint64 processed;
742
743 DoCopy(pstate, (CopyStmt *) parsetree,
744 pstmt->stmt_location, pstmt->stmt_len,
745 &processed);
746 if (qc)
747 SetQueryCompletion(qc, CMDTAG_COPY, processed);
748 }
749 break;
750
751 case T_PrepareStmt:
752 CheckRestrictedOperation("PREPARE");
753 PrepareQuery(pstate, (PrepareStmt *) parsetree,
754 pstmt->stmt_location, pstmt->stmt_len);
755 break;
756
757 case T_ExecuteStmt:
758 ExecuteQuery(pstate,
759 (ExecuteStmt *) parsetree, NULL,
760 params,
761 dest, qc);
762 break;
763
764 case T_DeallocateStmt:
765 CheckRestrictedOperation("DEALLOCATE");
766 DeallocateQuery((DeallocateStmt *) parsetree);
767 break;
768
769 case T_GrantRoleStmt:
770 /* no event triggers for global objects */
771 GrantRole(pstate, (GrantRoleStmt *) parsetree);
772 break;
773
774 case T_CreatedbStmt:
775 /* no event triggers for global objects */
776 PreventInTransactionBlock(isTopLevel, "CREATE DATABASE");
777 createdb(pstate, (CreatedbStmt *) parsetree);
778 break;
779
780 case T_AlterDatabaseStmt:
781 /* no event triggers for global objects */
782 AlterDatabase(pstate, (AlterDatabaseStmt *) parsetree, isTopLevel);
783 break;
784
785 case T_AlterDatabaseRefreshCollStmt:
786 /* no event triggers for global objects */
787 AlterDatabaseRefreshColl((AlterDatabaseRefreshCollStmt *) parsetree);
788 break;
789
790 case T_AlterDatabaseSetStmt:
791 /* no event triggers for global objects */
792 AlterDatabaseSet((AlterDatabaseSetStmt *) parsetree);
793 break;
794
795 case T_DropdbStmt:
796 /* no event triggers for global objects */
797 PreventInTransactionBlock(isTopLevel, "DROP DATABASE");
798 DropDatabase(pstate, (DropdbStmt *) parsetree);
799 break;
800
801 /* Query-level asynchronous notification */
802 case T_NotifyStmt:
803 {
804 NotifyStmt *stmt = (NotifyStmt *) parsetree;
805
806 Async_Notify(stmt->conditionname, stmt->payload);
807 }
808 break;
809
810 case T_ListenStmt:
811 {
812 ListenStmt *stmt = (ListenStmt *) parsetree;
813
814 CheckRestrictedOperation("LISTEN");
815
816 /*
817 * We don't allow LISTEN in background processes, as there is
818 * no mechanism for them to collect NOTIFY messages, so they'd
819 * just block cleanout of the async SLRU indefinitely.
820 * (Authors of custom background workers could bypass this
821 * restriction by calling Async_Listen directly, but then it's
822 * on them to provide some mechanism to process the message
823 * queue.) Note there seems no reason to forbid UNLISTEN.
824 */
825 if (MyBackendType != B_BACKEND)
826 ereport(ERROR,
827 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
828 /* translator: %s is name of a SQL command, eg LISTEN */
829 errmsg("cannot execute %s within a background process",
830 "LISTEN")));
831
832 Async_Listen(stmt->conditionname);
833 }
834 break;
835
836 case T_UnlistenStmt:
837 {
838 UnlistenStmt *stmt = (UnlistenStmt *) parsetree;
839
840 CheckRestrictedOperation("UNLISTEN");
841 if (stmt->conditionname)
842 Async_Unlisten(stmt->conditionname);
843 else
844 Async_UnlistenAll();
845 }
846 break;
847
848 case T_LoadStmt:
849 {
850 LoadStmt *stmt = (LoadStmt *) parsetree;
851
852 closeAllVfds(); /* probably not necessary... */
853 /* Allowed names are restricted if you're not superuser */
854 load_file(stmt->filename, !superuser());
855 }
856 break;
857
858 case T_CallStmt:
859 ExecuteCallStmt(castNode(CallStmt, parsetree), params, isAtomicContext, dest);
860 break;
861
862 case T_VacuumStmt:
863 ExecVacuum(pstate, (VacuumStmt *) parsetree, isTopLevel);
864 break;
865
866 case T_RepackStmt:
867 ExecRepack(pstate, (RepackStmt *) parsetree, isTopLevel);
868 break;
869
870 case T_ExplainStmt:
871 ExplainQuery(pstate, (ExplainStmt *) parsetree, params, dest);
872 break;
873
874 case T_AlterSystemStmt:
875 PreventInTransactionBlock(isTopLevel, "ALTER SYSTEM");
876 AlterSystemSetConfigFile((AlterSystemStmt *) parsetree);
877 break;
878
879 case T_VariableSetStmt:
880 ExecSetVariableStmt((VariableSetStmt *) parsetree, isTopLevel);
881 break;
882
883 case T_VariableShowStmt:
884 {
885 VariableShowStmt *n = (VariableShowStmt *) parsetree;
886
887 GetPGVariable(n->name, dest);
888 }
889 break;
890
891 case T_DiscardStmt:
892 /* should we allow DISCARD PLANS? */
893 CheckRestrictedOperation("DISCARD");
894 DiscardCommand((DiscardStmt *) parsetree, isTopLevel);
895 break;
896
897 case T_CreateEventTrigStmt:
898 /* no event triggers on event triggers */
899 CreateEventTrigger((CreateEventTrigStmt *) parsetree);
900 break;
901
902 case T_AlterEventTrigStmt:
903 /* no event triggers on event triggers */
904 AlterEventTrigger((AlterEventTrigStmt *) parsetree);
905 break;
906
907 /*
908 * ******************************** ROLE statements ****
909 */
910 case T_CreateRoleStmt:
911 /* no event triggers for global objects */
912 CreateRole(pstate, (CreateRoleStmt *) parsetree);
913 break;
914
915 case T_AlterRoleStmt:
916 /* no event triggers for global objects */
917 AlterRole(pstate, (AlterRoleStmt *) parsetree);
918 break;
919
920 case T_AlterRoleSetStmt:
921 /* no event triggers for global objects */
922 AlterRoleSet((AlterRoleSetStmt *) parsetree);
923 break;
924
925 case T_DropRoleStmt:
926 /* no event triggers for global objects */
927 DropRole((DropRoleStmt *) parsetree);
928 break;
929
930 case T_ReassignOwnedStmt:
931 /* no event triggers for global objects */
932 ReassignOwnedObjects((ReassignOwnedStmt *) parsetree);
933 break;
934
935 case T_LockStmt:
936
937 /*
938 * Since the lock would just get dropped immediately, LOCK TABLE
939 * outside a transaction block is presumed to be user error.
940 */
941 RequireTransactionBlock(isTopLevel, "LOCK TABLE");
942 LockTableCommand((LockStmt *) parsetree);
943 break;
944
945 case T_ConstraintsSetStmt:
946 WarnNoTransactionBlock(isTopLevel, "SET CONSTRAINTS");
947 AfterTriggerSetState((ConstraintsSetStmt *) parsetree);
948 break;
949
950 case T_CheckPointStmt:
951 ExecCheckpoint(pstate, (CheckPointStmt *) parsetree);
952 break;
953
954 /*
955 * The following statements are supported by Event Triggers only
956 * in some cases, so we "fast path" them in the other cases.
957 */
958
959 case T_GrantStmt:
960 {
961 GrantStmt *stmt = (GrantStmt *) parsetree;
962
963 if (EventTriggerSupportsObjectType(stmt->objtype))
964 ProcessUtilitySlow(pstate, pstmt, queryString,
965 context, params, queryEnv,
966 dest, qc);
967 else
968 ExecuteGrantStmt(stmt);
969 }
970 break;
971
972 case T_DropStmt:
973 {
974 DropStmt *stmt = (DropStmt *) parsetree;
975
976 if (EventTriggerSupportsObjectType(stmt->removeType))
977 ProcessUtilitySlow(pstate, pstmt, queryString,
978 context, params, queryEnv,
979 dest, qc);
980 else
981 ExecDropStmt(stmt, isTopLevel);
982 }
983 break;
984
985 case T_RenameStmt:
986 {
987 RenameStmt *stmt = (RenameStmt *) parsetree;
988
989 if (EventTriggerSupportsObjectType(stmt->renameType))
990 ProcessUtilitySlow(pstate, pstmt, queryString,
991 context, params, queryEnv,
992 dest, qc);
993 else
994 ExecRenameStmt(stmt);
995 }
996 break;
997
998 case T_AlterObjectDependsStmt:
999 {
1000 AlterObjectDependsStmt *stmt = (AlterObjectDependsStmt *) parsetree;
1001
1002 if (EventTriggerSupportsObjectType(stmt->objectType))
1003 ProcessUtilitySlow(pstate, pstmt, queryString,
1004 context, params, queryEnv,
1005 dest, qc);
1006 else
1007 ExecAlterObjectDependsStmt(stmt, NULL);
1008 }
1009 break;
1010
1011 case T_AlterObjectSchemaStmt:
1012 {
1013 AlterObjectSchemaStmt *stmt = (AlterObjectSchemaStmt *) parsetree;
1014
1015 if (EventTriggerSupportsObjectType(stmt->objectType))
1016 ProcessUtilitySlow(pstate, pstmt, queryString,
1017 context, params, queryEnv,
1018 dest, qc);
1019 else
1020 ExecAlterObjectSchemaStmt(stmt, NULL);
1021 }
1022 break;
1023
1024 case T_AlterOwnerStmt:
1025 {
1026 AlterOwnerStmt *stmt = (AlterOwnerStmt *) parsetree;
1027
1028 if (EventTriggerSupportsObjectType(stmt->objectType))
1029 ProcessUtilitySlow(pstate, pstmt, queryString,
1030 context, params, queryEnv,
1031 dest, qc);
1032 else
1033 ExecAlterOwnerStmt(stmt);
1034 }
1035 break;
1036
1037 case T_CommentStmt:
1038 {
1039 CommentStmt *stmt = (CommentStmt *) parsetree;
1040
1041 if (EventTriggerSupportsObjectType(stmt->objtype))
1042 ProcessUtilitySlow(pstate, pstmt, queryString,
1043 context, params, queryEnv,
1044 dest, qc);
1045 else
1046 CommentObject(stmt);
1047 break;
1048 }
1049
1050 case T_SecLabelStmt:
1051 {
1052 SecLabelStmt *stmt = (SecLabelStmt *) parsetree;
1053
1054 if (EventTriggerSupportsObjectType(stmt->objtype))
1055 ProcessUtilitySlow(pstate, pstmt, queryString,
1056 context, params, queryEnv,
1057 dest, qc);
1058 else
1059 ExecSecLabelStmt(stmt);
1060 break;
1061 }
1062
1063 case T_WaitStmt:
1064 {
1065 ExecWaitStmt(pstate, (WaitStmt *) parsetree, isTopLevel,
1066 dest);
1067 }
1068 break;
1069
1070 default:
1071 /* All other statement types have event trigger support */
1072 ProcessUtilitySlow(pstate, pstmt, queryString,
1073 context, params, queryEnv,
1074 dest, qc);
1075 break;
1076 }
1077
1078 free_parsestate(pstate);
1079
1080 /*
1081 * Make effects of commands visible, for instance so that
1082 * PreCommit_on_commit_actions() can see them (see for example bug
1083 * #15631).
1084 */
1085 CommandCounterIncrement();
1086}
ExecuteGrantStmt
void ExecuteGrantStmt(GrantStmt *stmt)
Definition aclchk.c:395
ExecAlterOwnerStmt
ObjectAddress ExecAlterOwnerStmt(AlterOwnerStmt *stmt)
Definition alter.c:833
ExecAlterObjectDependsStmt
ObjectAddress ExecAlterObjectDependsStmt(AlterObjectDependsStmt *stmt, ObjectAddress *refAddress)
Definition alter.c:466
ExecRenameStmt
ObjectAddress ExecRenameStmt(RenameStmt *stmt)
Definition alter.c:367
ExecAlterObjectSchemaStmt
ObjectAddress ExecAlterObjectSchemaStmt(AlterObjectSchemaStmt *stmt, ObjectAddress *oldSchemaAddr)
Definition alter.c:529
Async_UnlistenAll
void Async_UnlistenAll(void)
Definition async.c:1075
Async_Unlisten
void Async_Unlisten(const char *channel)
Definition async.c:1057
Async_Listen
void Async_Listen(const char *channel)
Definition async.c:1043
Async_Notify
void Async_Notify(const char *channel, const char *payload)
Definition async.c:894
DoCopy
void DoCopy(ParseState *pstate, const CopyStmt *stmt, int stmt_location, int stmt_len, uint64 *processed)
Definition copy.c:63
PrepareQuery
void PrepareQuery(ParseState *pstate, PrepareStmt *stmt, int stmt_location, int stmt_len)
Definition prepare.c:61
ExecuteQuery
void ExecuteQuery(ParseState *pstate, ExecuteStmt *stmt, IntoClause *intoClause, ParamListInfo params, DestReceiver *dest, QueryCompletion *qc)
Definition prepare.c:152
DeallocateQuery
void DeallocateQuery(DeallocateStmt *stmt)
Definition prepare.c:507
AlterTableSpaceOptions
Oid AlterTableSpaceOptions(AlterTableSpaceOptionsStmt *stmt)
Definition tablespace.c:1029
DropTableSpace
void DropTableSpace(DropTableSpaceStmt *stmt)
Definition tablespace.c:403
CreateTableSpace
Oid CreateTableSpace(CreateTableSpaceStmt *stmt)
Definition tablespace.c:210
uint64
uint64_t uint64
Definition c.h:625
ExecCheckpoint
void ExecCheckpoint(ParseState *pstate, CheckPointStmt *stmt)
Definition checkpointer.c:1006
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:2563
createdb
Oid createdb(ParseState *pstate, const CreatedbStmt *stmt)
Definition dbcommands.c:687
AlterDatabase
Oid AlterDatabase(ParseState *pstate, AlterDatabaseStmt *stmt, bool isTopLevel)
Definition dbcommands.c:2390
DropDatabase
void DropDatabase(ParseState *pstate, DropdbStmt *stmt)
Definition dbcommands.c:2364
AlterDatabaseSet
Oid AlterDatabaseSet(AlterDatabaseSetStmt *stmt)
Definition dbcommands.c:2660
load_file
void load_file(const char *filename, bool restricted)
Definition dfmgr.c:149
DiscardCommand
void DiscardCommand(DiscardStmt *stmt, bool isTopLevel)
Definition discard.c:32
errcode
int errcode(int sqlerrcode)
Definition elog.c:875
ERROR
#define ERROR
Definition elog.h:40
ereport
#define ereport(elevel,...)
Definition elog.h:152
EventTriggerSupportsObjectType
bool EventTriggerSupportsObjectType(ObjectType obtype)
Definition event_trigger.c:1135
CreateEventTrigger
Oid CreateEventTrigger(CreateEventTrigStmt *stmt)
Definition event_trigger.c:126
AlterEventTrigger
Oid AlterEventTrigger(AlterEventTrigStmt *stmt)
Definition event_trigger.c:429
ExplainQuery
void ExplainQuery(ParseState *pstate, ExplainStmt *stmt, ParamListInfo params, DestReceiver *dest)
Definition explain.c:181
closeAllVfds
void closeAllVfds(void)
Definition fd.c:3068
ExecuteCallStmt
void ExecuteCallStmt(CallStmt *stmt, ParamListInfo params, bool atomic, DestReceiver *dest)
Definition functioncmds.c:2209
ExecuteDoStmt
void ExecuteDoStmt(ParseState *pstate, DoStmt *stmt, bool atomic)
Definition functioncmds.c:2087
AlterSystemSetConfigFile
void AlterSystemSetConfigFile(AlterSystemStmt *altersysstmt)
Definition guc.c:4508
GetPGVariable
void GetPGVariable(const char *name, DestReceiver *dest)
Definition guc_funcs.c:410
SetPGVariable
void SetPGVariable(const char *name, List *args, bool is_local)
Definition guc_funcs.c:343
ExecSetVariableStmt
void ExecSetVariableStmt(VariableSetStmt *stmt, bool isTopLevel)
Definition guc_funcs.c:45
LockTableCommand
void LockTableCommand(LockStmt *lockstmt)
Definition lockcmds.c:41
B_BACKEND
@ B_BACKEND
Definition miscadmin.h:354
MyBackendType
BackendType MyBackendType
Definition miscinit.c:65
copyObject
#define copyObject(obj)
Definition nodes.h:232
castNode
#define castNode(_type_, nodeptr)
Definition nodes.h:182
errmsg
static char * errmsg
Definition oauth_hook_client.c:61
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:244
PerformCursorOpen
void PerformCursorOpen(ParseState *pstate, DeclareCursorStmt *cstmt, ParamListInfo params, bool isTopLevel)
Definition portalcmds.c:45
PerformPortalClose
void PerformPortalClose(const char *name)
Definition portalcmds.c:225
PerformPortalFetch
void PerformPortalFetch(FetchStmt *stmt, DestReceiver *dest, QueryCompletion *qc)
Definition portalcmds.c:178
ExecRepack
void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel)
Definition repack.c:238
ExecSecLabelStmt
ObjectAddress ExecSecLabelStmt(SecLabelStmt *stmt)
Definition seclabel.c:116
check_stack_depth
void check_stack_depth(void)
Definition stack_depth.c:95
DefElem::arg
Node * arg
Definition parsenodes.h:861
ParseState::p_queryEnv
QueryEnvironment * p_queryEnv
Definition parse_node.h:241
ParseState::p_sourcetext
const char * p_sourcetext
Definition parse_node.h:214
superuser
bool superuser(void)
Definition superuser.c:47
ExecuteTruncate
void ExecuteTruncate(TruncateStmt *stmt)
Definition tablecmds.c:1916
AfterTriggerSetState
void AfterTriggerSetState(ConstraintsSetStmt *stmt)
Definition trigger.c:5821
FinishPreparedTransaction
void FinishPreparedTransaction(const char *gid, bool isCommit)
Definition twophase.c:1503
ReassignOwnedObjects
void ReassignOwnedObjects(ReassignOwnedStmt *stmt)
Definition user.c:1624
AlterRole
Oid AlterRole(ParseState *pstate, AlterRoleStmt *stmt)
Definition user.c:626
AlterRoleSet
Oid AlterRoleSet(AlterRoleSetStmt *stmt)
Definition user.c:1007
DropRole
void DropRole(DropRoleStmt *stmt)
Definition user.c:1097
CreateRole
Oid CreateRole(ParseState *pstate, CreateRoleStmt *stmt)
Definition user.c:133
GrantRole
void GrantRole(ParseState *pstate, GrantRoleStmt *stmt)
Definition user.c:1493
ClassifyUtilityCommandAsReadOnly
static int ClassifyUtilityCommandAsReadOnly(Node *parsetree)
Definition utility.c:130
PreventCommandIfReadOnly
void PreventCommandIfReadOnly(const char *cmdname)
Definition utility.c:409
PreventCommandIfParallelMode
void PreventCommandIfParallelMode(const char *cmdname)
Definition utility.c:427
ExecDropStmt
static void ExecDropStmt(DropStmt *stmt, bool isTopLevel)
Definition utility.c:2008
CheckRestrictedOperation
static void CheckRestrictedOperation(const char *cmdname)
Definition utility.c:464
PreventCommandDuringRecovery
void PreventCommandDuringRecovery(const char *cmdname)
Definition utility.c:446
ProcessUtilitySlow
static void ProcessUtilitySlow(ParseState *pstate, PlannedStmt *pstmt, const char *queryString, ProcessUtilityContext context, ParamListInfo params, QueryEnvironment *queryEnv, DestReceiver *dest, QueryCompletion *qc)
Definition utility.c:1094
COMMAND_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:163
ExecWaitStmt
void ExecWaitStmt(ParseState *pstate, WaitStmt *stmt, bool isTopLevel, DestReceiver *dest)
Definition wait.c:34
WarnNoTransactionBlock
void WarnNoTransactionBlock(bool isTopLevel, const char *stmtType)
Definition xact.c:3761
UserAbortTransactionBlock
void UserAbortTransactionBlock(bool chain)
Definition xact.c:4255
PrepareTransactionBlock
bool PrepareTransactionBlock(const char *gid)
Definition xact.c:4043
RequireTransactionBlock
void RequireTransactionBlock(bool isTopLevel, const char *stmtType)
Definition xact.c:3767
DefineSavepoint
void DefineSavepoint(const char *name)
Definition xact.c:4424
XactReadOnly
bool XactReadOnly
Definition xact.c:84
CommandCounterIncrement
void CommandCounterIncrement(void)
Definition xact.c:1130
PreventInTransactionBlock
void PreventInTransactionBlock(bool isTopLevel, const char *stmtType)
Definition xact.c:3698
ReleaseSavepoint
void ReleaseSavepoint(const char *name)
Definition xact.c:4509
IsTransactionBlock
bool IsTransactionBlock(void)
Definition xact.c:5022
IsInParallelMode
bool IsInParallelMode(void)
Definition xact.c:1119
BeginTransactionBlock
void BeginTransactionBlock(void)
Definition xact.c:3975
RollbackToSavepoint
void RollbackToSavepoint(const char *name)
Definition xact.c:4618
EndTransactionBlock
bool EndTransactionBlock(bool chain)
Definition xact.c:4095

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

Query * UtilityContainsQuery ( Node *  parsetree)
extern

Definition at line 2199 of file utility.c.

2200{
2201 Query *qry;
2202
2203 switch (nodeTag(parsetree))
2204 {
2205 case T_DeclareCursorStmt:
2206 qry = castNode(Query, ((DeclareCursorStmt *) parsetree)->query);
2207 if (qry->commandType == CMD_UTILITY)
2208 return UtilityContainsQuery(qry->utilityStmt);
2209 return qry;
2210
2211 case T_ExplainStmt:
2212 qry = castNode(Query, ((ExplainStmt *) parsetree)->query);
2213 if (qry->commandType == CMD_UTILITY)
2214 return UtilityContainsQuery(qry->utilityStmt);
2215 return qry;
2216
2217 case T_CreateTableAsStmt:
2218 qry = castNode(Query, ((CreateTableAsStmt *) parsetree)->query);
2219 if (qry->commandType == CMD_UTILITY)
2220 return UtilityContainsQuery(qry->utilityStmt);
2221 return qry;
2222
2223 default:
2224 return NULL;
2225 }
2226}
Query::commandType
CmdType commandType
Definition parsenodes.h:121
Query::utilityStmt
Node * utilityStmt
Definition parsenodes.h:141
UtilityContainsQuery
Query * UtilityContainsQuery(Node *parsetree)
Definition utility.c:2199

References castNode, CMD_UTILITY, Query::commandType, fb(), nodeTag, UtilityContainsQuery(), and Query::utilityStmt.

Referenced by AcquireExecutorLocks(), AcquirePlannerLocks(), extract_query_dependencies_walker(), and UtilityContainsQuery().

◆ UtilityReturnsTuples()

bool UtilityReturnsTuples ( Node *  parsetree)
extern

Definition at line 2042 of file utility.c.

2043{
2044 switch (nodeTag(parsetree))
2045 {
2046 case T_CallStmt:
2047 {
2048 CallStmt *stmt = (CallStmt *) parsetree;
2049
2050 return (stmt->funcexpr->funcresulttype == RECORDOID);
2051 }
2052 case T_FetchStmt:
2053 {
2054 FetchStmt *stmt = (FetchStmt *) parsetree;
2055 Portal portal;
2056
2057 if (stmt->ismove)
2058 return false;
2059 portal = GetPortalByName(stmt->portalname);
2060 if (!PortalIsValid(portal))
2061 return false; /* not our business to raise error */
2062 return portal->tupDesc ? true : false;
2063 }
2064
2065 case T_ExecuteStmt:
2066 {
2067 ExecuteStmt *stmt = (ExecuteStmt *) parsetree;
2068 PreparedStatement *entry;
2069
2070 entry = FetchPreparedStatement(stmt->name, false);
2071 if (!entry)
2072 return false; /* not our business to raise error */
2073 if (entry->plansource->resultDesc)
2074 return true;
2075 return false;
2076 }
2077
2078 case T_ExplainStmt:
2079 return true;
2080
2081 case T_VariableShowStmt:
2082 return true;
2083
2084 case T_WaitStmt:
2085 return true;
2086
2087 default:
2088 return false;
2089 }
2090}
true
return true
Definition isn.c:130
PortalIsValid
#define PortalIsValid(p)
Definition portal.h:211
GetPortalByName
Portal GetPortalByName(const char *name)
Definition portalmem.c:132
CachedPlanSource::resultDesc
TupleDesc resultDesc
Definition plancache.h:120
PortalData::tupDesc
TupleDesc tupDesc
Definition portal.h:159
PreparedStatement::plansource
CachedPlanSource * plansource
Definition prepare.h:32

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

Referenced by ChoosePortalStrategy().

◆ UtilityTupleDescriptor()

TupleDesc UtilityTupleDescriptor ( Node *  parsetree)
extern

Definition at line 2101 of file utility.c.

2102{
2103 switch (nodeTag(parsetree))
2104 {
2105 case T_CallStmt:
2106 return CallStmtResultDesc((CallStmt *) parsetree);
2107
2108 case T_FetchStmt:
2109 {
2110 FetchStmt *stmt = (FetchStmt *) parsetree;
2111 Portal portal;
2112
2113 if (stmt->ismove)
2114 return NULL;
2115 portal = GetPortalByName(stmt->portalname);
2116 if (!PortalIsValid(portal))
2117 return NULL; /* not our business to raise error */
2118 return CreateTupleDescCopy(portal->tupDesc);
2119 }
2120
2121 case T_ExecuteStmt:
2122 {
2123 ExecuteStmt *stmt = (ExecuteStmt *) parsetree;
2124 PreparedStatement *entry;
2125
2126 entry = FetchPreparedStatement(stmt->name, false);
2127 if (!entry)
2128 return NULL; /* not our business to raise error */
2129 return FetchPreparedStatementResultDesc(entry);
2130 }
2131
2132 case T_ExplainStmt:
2133 return ExplainResultDesc((ExplainStmt *) parsetree);
2134
2135 case T_VariableShowStmt:
2136 {
2137 VariableShowStmt *n = (VariableShowStmt *) parsetree;
2138
2139 return GetPGVariableResultDesc(n->name);
2140 }
2141
2142 case T_WaitStmt:
2143 return WaitStmtResultDesc((WaitStmt *) parsetree);
2144
2145 default:
2146 return NULL;
2147 }
2148}
FetchPreparedStatementResultDesc
TupleDesc FetchPreparedStatementResultDesc(PreparedStatement *stmt)
Definition prepare.c:468
ExplainResultDesc
TupleDesc ExplainResultDesc(ExplainStmt *stmt)
Definition explain.c:259
CallStmtResultDesc
TupleDesc CallStmtResultDesc(CallStmt *stmt)
Definition functioncmds.c:2386
GetPGVariableResultDesc
TupleDesc GetPGVariableResultDesc(const char *name)
Definition guc_funcs.c:422
CreateTupleDescCopy
TupleDesc CreateTupleDescCopy(TupleDesc tupdesc)
Definition tupdesc.c:242
WaitStmtResultDesc
TupleDesc WaitStmtResultDesc(WaitStmt *stmt)
Definition wait.c:345

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

PGDLLIMPORT ProcessUtility_hook_type ProcessUtility_hook
extern

Definition at line 72 of file utility.c.

Referenced by _PG_init(), and ProcessUtility().