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:95
CreateCommandTag
CommandTag CreateCommandTag(Node *parsetree)
Definition utility.c:2369
GetCommandLogLevel
LogStmtLevel GetCommandLogLevel(Node *parsetree)
Definition utility.c:3263

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

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

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

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

References AlterObjectTypeCommandTag(), CMD_DELETE, CMD_INSERT, CMD_MERGE, CMD_SELECT, CMD_UPDATE, CMD_UTILITY, CreateCommandTag(), DISCARD_ALL, DISCARD_PLANS, DISCARD_SEQUENCES, DISCARD_TEMP, elog, 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_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 3263 of file utility.c.

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

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

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

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

1960{
1961 PlannedStmt *wrapper;
1962
1963 /*
1964 * For event triggers, we must "close" the current complex-command set,
1965 * and start a new one afterwards; this is needed to ensure the ordering
1966 * of command events is consistent with the way they were executed.
1967 */
1968 EventTriggerAlterTableEnd();
1969
1970 /* Create a suitable wrapper */
1971 wrapper = makeNode(PlannedStmt);
1972 wrapper->commandType = CMD_UTILITY;
1973 wrapper->canSetTag = false;
1974 wrapper->utilityStmt = stmt;
1975 wrapper->stmt_location = context->pstmt->stmt_location;
1976 wrapper->stmt_len = context->pstmt->stmt_len;
1977 wrapper->planOrigin = PLAN_STMT_INTERNAL;
1978
1979 ProcessUtility(wrapper,
1980 context->queryString,
1981 false,
1982 PROCESS_UTILITY_SUBCOMMAND,
1983 context->params,
1984 context->queryEnv,
1985 None_Receiver,
1986 NULL);
1987
1988 EventTriggerAlterTableStart(context->pstmt->utilityStmt);
1989 EventTriggerAlterTableRelid(context->relid);
1990}
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::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:171
PlannedStmt::planOrigin
PlannedStmtOrigin planOrigin
Definition plannodes.h:77
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:501

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

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

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

2187{
2188 Query *qry;
2189
2190 switch (nodeTag(parsetree))
2191 {
2192 case T_DeclareCursorStmt:
2193 qry = castNode(Query, ((DeclareCursorStmt *) parsetree)->query);
2194 if (qry->commandType == CMD_UTILITY)
2195 return UtilityContainsQuery(qry->utilityStmt);
2196 return qry;
2197
2198 case T_ExplainStmt:
2199 qry = castNode(Query, ((ExplainStmt *) parsetree)->query);
2200 if (qry->commandType == CMD_UTILITY)
2201 return UtilityContainsQuery(qry->utilityStmt);
2202 return qry;
2203
2204 case T_CreateTableAsStmt:
2205 qry = castNode(Query, ((CreateTableAsStmt *) parsetree)->query);
2206 if (qry->commandType == CMD_UTILITY)
2207 return UtilityContainsQuery(qry->utilityStmt);
2208 return qry;
2209
2210 default:
2211 return NULL;
2212 }
2213}
Query::commandType
CmdType commandType
Definition parsenodes.h:121
Query::utilityStmt
Node * utilityStmt
Definition parsenodes.h:141
UtilityContainsQuery
Query * UtilityContainsQuery(Node *parsetree)
Definition utility.c:2186

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

2030{
2031 switch (nodeTag(parsetree))
2032 {
2033 case T_CallStmt:
2034 {
2035 CallStmt *stmt = (CallStmt *) parsetree;
2036
2037 return (stmt->funcexpr->funcresulttype == RECORDOID);
2038 }
2039 case T_FetchStmt:
2040 {
2041 FetchStmt *stmt = (FetchStmt *) parsetree;
2042 Portal portal;
2043
2044 if (stmt->ismove)
2045 return false;
2046 portal = GetPortalByName(stmt->portalname);
2047 if (!PortalIsValid(portal))
2048 return false; /* not our business to raise error */
2049 return portal->tupDesc ? true : false;
2050 }
2051
2052 case T_ExecuteStmt:
2053 {
2054 ExecuteStmt *stmt = (ExecuteStmt *) parsetree;
2055 PreparedStatement *entry;
2056
2057 entry = FetchPreparedStatement(stmt->name, false);
2058 if (!entry)
2059 return false; /* not our business to raise error */
2060 if (entry->plansource->resultDesc)
2061 return true;
2062 return false;
2063 }
2064
2065 case T_ExplainStmt:
2066 return true;
2067
2068 case T_VariableShowStmt:
2069 return true;
2070
2071 case T_WaitStmt:
2072 return true;
2073
2074 default:
2075 return false;
2076 }
2077}
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::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 2088 of file utility.c.

2089{
2090 switch (nodeTag(parsetree))
2091 {
2092 case T_CallStmt:
2093 return CallStmtResultDesc((CallStmt *) parsetree);
2094
2095 case T_FetchStmt:
2096 {
2097 FetchStmt *stmt = (FetchStmt *) parsetree;
2098 Portal portal;
2099
2100 if (stmt->ismove)
2101 return NULL;
2102 portal = GetPortalByName(stmt->portalname);
2103 if (!PortalIsValid(portal))
2104 return NULL; /* not our business to raise error */
2105 return CreateTupleDescCopy(portal->tupDesc);
2106 }
2107
2108 case T_ExecuteStmt:
2109 {
2110 ExecuteStmt *stmt = (ExecuteStmt *) parsetree;
2111 PreparedStatement *entry;
2112
2113 entry = FetchPreparedStatement(stmt->name, false);
2114 if (!entry)
2115 return NULL; /* not our business to raise error */
2116 return FetchPreparedStatementResultDesc(entry);
2117 }
2118
2119 case T_ExplainStmt:
2120 return ExplainResultDesc((ExplainStmt *) parsetree);
2121
2122 case T_VariableShowStmt:
2123 {
2124 VariableShowStmt *n = (VariableShowStmt *) parsetree;
2125
2126 return GetPGVariableResultDesc(n->name);
2127 }
2128
2129 case T_WaitStmt:
2130 return WaitStmtResultDesc((WaitStmt *) parsetree);
2131
2132 default:
2133 return NULL;
2134 }
2135}
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:2386
GetPGVariableResultDesc
TupleDesc GetPGVariableResultDesc(const char *name)
Definition guc_funcs.c:420
CreateTupleDescCopy
TupleDesc CreateTupleDescCopy(TupleDesc tupdesc)
Definition tupdesc.c:235
WaitStmtResultDesc
TupleDesc WaitStmtResultDesc(WaitStmt *stmt)
Definition wait.c:333

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

Referenced by _PG_init(), and ProcessUtility().