XID_IN_FUTURE,
XID_PRECEDES_CLUSTERMIN,
XID_PRECEDES_RELMIN,
- XID_BOUNDS_OK
+ XID_BOUNDS_OK,
} XidBoundsViolation;
typedef enum XidCommitStatus
XID_COMMITTED,
XID_IS_CURRENT_XID,
XID_IN_PROGRESS,
- XID_ABORTED
+ XID_ABORTED,
} XidCommitStatus;
typedef enum SkipPages
{
SKIP_PAGES_ALL_FROZEN,
SKIP_PAGES_ALL_VISIBLE,
- SKIP_PAGES_NONE
+ SKIP_PAGES_NONE,
} SkipPages;
/*
gbt_t_bool,
gbt_t_inet,
gbt_t_uuid,
- gbt_t_enum
+ gbt_t_enum,
};
#endif
{
PREWARM_PREFETCH,
PREWARM_READ,
- PREWARM_BUFFER
+ PREWARM_BUFFER,
} PrewarmType;
static PGIOAlignedBlock blockbuffer;
PGSS_V1_8,
PGSS_V1_9,
PGSS_V1_10,
- PGSS_V1_11
+ PGSS_V1_11,
} pgssVersion;
typedef enum pgssStoreKind
{
PGSS_TRACK_NONE, /* track no statements */
PGSS_TRACK_TOP, /* only top level statements */
- PGSS_TRACK_ALL /* all statements, including nested ones */
+ PGSS_TRACK_ALL, /* all statements, including nested ones */
} PGSSTrackLevel;
static const struct config_enum_entry track_options[] =
typedef enum HeapTupleForceOption
{
HEAP_FORCE_KILL,
- HEAP_FORCE_FREEZE
+ HEAP_FORCE_FREEZE,
} HeapTupleForceOption;
PG_FUNCTION_INFO_V1(heap_force_kill);
{
PGP_S2K_SIMPLE = 0,
PGP_S2K_SALTED = 1,
- PGP_S2K_ISALTED = 3
+ PGP_S2K_ISALTED = 3,
};
enum PGP_PKT_TYPE
PGP_PKT_USER_ATTR = 17,
PGP_PKT_SYMENCRYPTED_DATA_MDC = 18,
PGP_PKT_MDC = 19,
- PGP_PKT_PRIV_61 = 61 /* occurs in gpg secring */
+ PGP_PKT_PRIV_61 = 61, /* occurs in gpg secring */
};
enum PGP_PUB_ALGO_TYPE
PGP_PUB_RSA_ENCRYPT = 2,
PGP_PUB_RSA_SIGN = 3,
PGP_PUB_ELG_ENCRYPT = 16,
- PGP_PUB_DSA_SIGN = 17
+ PGP_PUB_DSA_SIGN = 17,
};
enum PGP_SYMENC_TYPE
PGP_SYM_AES_128 = 7, /* should */
PGP_SYM_AES_192 = 8,
PGP_SYM_AES_256 = 9,
- PGP_SYM_TWOFISH = 10
+ PGP_SYM_TWOFISH = 10,
};
enum PGP_COMPR_TYPE
PGP_COMPR_NONE = 0, /* must */
PGP_COMPR_ZIP = 1, /* should */
PGP_COMPR_ZLIB = 2,
- PGP_COMPR_BZIP2 = 3
+ PGP_COMPR_BZIP2 = 3,
};
enum PGP_DIGEST_TYPE
PGP_DIGEST_HAVAL5_160 = 7, /* obsolete */
PGP_DIGEST_SHA256 = 8,
PGP_DIGEST_SHA384 = 9,
- PGP_DIGEST_SHA512 = 10
+ PGP_DIGEST_SHA512 = 10,
};
#define PGP_MAX_KEY (256/8)
* it has default collation that is not
* traceable to a foreign Var */
FDW_COLLATE_SAFE, /* collation derives from a foreign Var */
- FDW_COLLATE_UNSAFE /* collation is non-default and derives from
+ FDW_COLLATE_UNSAFE, /* collation is non-default and derives from
* something other than a foreign Var */
} FDWCollateState;
* String describing join i.e. names of relations being joined and types
* of join, added when the scan is join
*/
- FdwScanPrivateRelations
+ FdwScanPrivateRelations,
};
/*
/* has-returning flag (as a Boolean node) */
FdwModifyPrivateHasReturning,
/* Integer list of attribute numbers retrieved by RETURNING */
- FdwModifyPrivateRetrievedAttrs
+ FdwModifyPrivateRetrievedAttrs,
};
/*
/* Integer list of attribute numbers retrieved by RETURNING */
FdwDirectModifyPrivateRetrievedAttrs,
/* set-processed flag (as a Boolean node) */
- FdwDirectModifyPrivateSetProcessed
+ FdwDirectModifyPrivateSetProcessed,
};
/*
/* has-final-sort flag (as a Boolean node) */
FdwPathPrivateHasFinalSort,
/* has-limit flag (as a Boolean node) */
- FdwPathPrivateHasLimit
+ FdwPathPrivateHasLimit,
};
/* Struct for extra information passed to estimate_path_cost_size() */
ANALYZE_SAMPLE_AUTO, /* choose by server version */
ANALYZE_SAMPLE_RANDOM, /* remote random() */
ANALYZE_SAMPLE_SYSTEM, /* TABLESAMPLE system */
- ANALYZE_SAMPLE_BERNOULLI /* TABLESAMPLE bernoulli */
+ ANALYZE_SAMPLE_BERNOULLI, /* TABLESAMPLE bernoulli */
} PgFdwSamplingMethod;
/* in postgres_fdw.c */
{
TRI_DEFAULT,
TRI_NO,
- TRI_YES
+ TRI_YES,
};
struct _param
GIST_BUFFERING_STATS, /* gathering statistics of index tuple size
* before switching to the buffering build
* mode */
- GIST_BUFFERING_ACTIVE /* in buffering build mode */
+ GIST_BUFFERING_ACTIVE, /* in buffering build mode */
} GistBuildMode;
/* Working state for gistbuild and its callback */
VACUUM_ERRCB_PHASE_VACUUM_INDEX,
VACUUM_ERRCB_PHASE_VACUUM_HEAP,
VACUUM_ERRCB_PHASE_INDEX_CLEANUP,
- VACUUM_ERRCB_PHASE_TRUNCATE
+ VACUUM_ERRCB_PHASE_TRUNCATE,
} VacErrPhase;
typedef struct LVRelState
BTPARALLEL_NOT_INITIALIZED,
BTPARALLEL_ADVANCING,
BTPARALLEL_IDLE,
- BTPARALLEL_DONE
+ BTPARALLEL_DONE,
} BTPS_State;
/*
/* strategy for searching through materialized list of split points */
SPLIT_DEFAULT, /* give some weight to truncation */
SPLIT_MANY_DUPLICATES, /* find minimally distinguishing point */
- SPLIT_SINGLE_VALUE /* leave left page almost full */
+ SPLIT_SINGLE_VALUE, /* leave left page almost full */
} FindSplitStrat;
typedef struct
{
SpGistBreakOffsetNumber = InvalidOffsetNumber,
SpGistRedirectOffsetNumber = MaxOffsetNumber + 1,
- SpGistErrorOffsetNumber = MaxOffsetNumber + 2
+ SpGistErrorOffsetNumber = MaxOffsetNumber + 2,
};
static OffsetNumber
SLRU_READ_FAILED,
SLRU_WRITE_FAILED,
SLRU_FSYNC_FAILED,
- SLRU_CLOSE_FAILED
+ SLRU_CLOSE_FAILED,
} SlruErrorCause;
static SlruErrorCause slru_errcause;
TRANS_INPROGRESS, /* inside a valid transaction */
TRANS_COMMIT, /* commit in progress */
TRANS_ABORT, /* abort in progress */
- TRANS_PREPARE /* prepare in progress */
+ TRANS_PREPARE, /* prepare in progress */
} TransState;
/*
TBLOCK_SUBABORT_END, /* failed subxact, ROLLBACK received */
TBLOCK_SUBABORT_PENDING, /* live subxact, ROLLBACK received */
TBLOCK_SUBRESTART, /* live subxact, ROLLBACK TO received */
- TBLOCK_SUBABORT_RESTART /* failed subxact, ROLLBACK TO received */
+ TBLOCK_SUBABORT_RESTART, /* failed subxact, ROLLBACK TO received */
} TBlockState;
/*
{
LRQ_NEXT_NO_IO,
LRQ_NEXT_IO,
- LRQ_NEXT_AGAIN
+ LRQ_NEXT_AGAIN,
} LsnReadQueueNextStatus;
/*
XLOG_FROM_ANY = 0, /* request to read WAL from any source */
XLOG_FROM_ARCHIVE, /* restored using restore_command */
XLOG_FROM_PG_WAL, /* existing file in pg_wal */
- XLOG_FROM_STREAM /* streamed from primary */
+ XLOG_FROM_STREAM, /* streamed from primary */
} XLogSource;
/* human-readable names for XLogSources, for debugging output */
{
LOCAL_OBJECT,
SHARED_OBJECT,
- REMOTE_OBJECT
+ REMOTE_OBJECT,
} SharedDependencyObjectType;
typedef struct
{
LISTEN_LISTEN,
LISTEN_UNLISTEN,
- LISTEN_UNLISTEN_ALL
+ LISTEN_UNLISTEN_ALL,
} ListenActionKind;
typedef struct
{
COPY_FILE, /* to file (or a piped program) */
COPY_FRONTEND, /* to frontend */
- COPY_CALLBACK /* to callback function */
+ COPY_CALLBACK, /* to callback function */
} CopyDest;
/*
typedef enum CreateDBStrategy
{
CREATEDB_WAL_LOG,
- CREATEDB_FILE_COPY
+ CREATEDB_FILE_COPY,
} CreateDBStrategy;
typedef struct
RRG_REMOVE_ADMIN_OPTION,
RRG_REMOVE_INHERIT_OPTION,
RRG_REMOVE_SET_OPTION,
- RRG_DELETE_GRANT
+ RRG_DELETE_GRANT,
} RevokeRoleGrantAction;
/* Potentially set by pg_upgrade_support functions */
PARALLEL_INDVAC_STATUS_INITIAL = 0,
PARALLEL_INDVAC_STATUS_NEED_BULKDELETE,
PARALLEL_INDVAC_STATUS_NEED_CLEANUP,
- PARALLEL_INDVAC_STATUS_COMPLETED
+ PARALLEL_INDVAC_STATUS_COMPLETED,
} PVIndVacStatus;
/*
{
CEOUC_WAIT,
CEOUC_NOWAIT,
- CEOUC_LIVELOCK_PREVENTING_WAIT
+ CEOUC_LIVELOCK_PREVENTING_WAIT,
} CEOUC_WAIT_MODE;
static bool check_exclusion_or_unique_constraint(Relation heap, Relation index,
*/
typedef enum
{
- F_EXEC_START, F_EXEC_RUN, F_EXEC_DONE
+ F_EXEC_START, F_EXEC_RUN, F_EXEC_DONE,
} ExecStatus;
typedef struct execution_state
{
MJEVAL_MATCHABLE, /* normal, potentially matchable tuple */
MJEVAL_NONMATCHABLE, /* tuple cannot join because it has a null */
- MJEVAL_ENDOFJOIN /* end of input (physical or effective) */
+ MJEVAL_ENDOFJOIN, /* end of input (physical or effective) */
} MJEvalResult;
typedef enum
{
TIDEXPR_UPPER_BOUND,
- TIDEXPR_LOWER_BOUND
+ TIDEXPR_LOWER_BOUND,
} TidExprType;
/* Upper or lower range bound for scan */
{
SCRAM_AUTH_INIT,
SCRAM_AUTH_SALT_SENT,
- SCRAM_AUTH_FINISHED
+ SCRAM_AUTH_FINISHED,
} scram_state_enum;
typedef struct
{
TBM_EMPTY, /* no hashtable, nentries == 0 */
TBM_ONE_PAGE, /* entry1 contains the single entry */
- TBM_HASH /* pagetable is valid, entry1 is not */
+ TBM_HASH, /* pagetable is valid, entry1 is not */
} TBMStatus;
/*
{
TBM_NOT_ITERATING, /* not yet converted to page and chunk array */
TBM_ITERATING_PRIVATE, /* converted to local page and chunk array */
- TBM_ITERATING_SHARED /* converted to shared page and chunk array */
+ TBM_ITERATING_SHARED, /* converted to shared page and chunk array */
} TBMIteratingState;
/*
{
PUSHDOWN_UNSAFE, /* unsafe to push qual into subquery */
PUSHDOWN_SAFE, /* safe to push qual into subquery */
- PUSHDOWN_WINDOWCLAUSE_RUNCOND /* unsafe, but may work as WindowClause
+ PUSHDOWN_WINDOWCLAUSE_RUNCOND, /* unsafe, but may work as WindowClause
* run condition */
} pushdown_safe_type;
{
ST_INDEXSCAN, /* must support amgettuple */
ST_BITMAPSCAN, /* must support amgetbitmap */
- ST_ANYSCAN /* either is okay */
+ ST_ANYSCAN, /* either is okay */
} ScanTypeControl;
/* Data structure for collecting qual clauses that match an index */
{
NRM_EQUAL, /* expect exact match of nullingrels */
NRM_SUBSET, /* actual Var may have a subset of input */
- NRM_SUPERSET /* actual Var may have a superset of input */
+ NRM_SUPERSET, /* actual Var may have a superset of input */
} NullingRelsMatch;
typedef struct
COSTS_EQUAL, /* path costs are fuzzily equal */
COSTS_BETTER1, /* first path is cheaper than second */
COSTS_BETTER2, /* second path is cheaper than first */
- COSTS_DIFFERENT /* neither path dominates the other on cost */
+ COSTS_DIFFERENT, /* neither path dominates the other on cost */
} PathCostComparison;
/*
{
CLASS_ATOM, /* expression that's not AND or OR */
CLASS_AND, /* expression with AND semantics */
- CLASS_OR /* expression with OR semantics */
+ CLASS_OR, /* expression with OR semantics */
} PredClass;
typedef struct PredIterInfoData *PredIterInfo;
COLLATE_NONE, /* expression is of a noncollatable datatype */
COLLATE_IMPLICIT, /* collation was derived implicitly */
COLLATE_CONFLICT, /* we had a conflict of implicit collations */
- COLLATE_EXPLICIT /* collation was derived explicitly */
+ COLLATE_EXPLICIT, /* collation was derived explicitly */
} CollateStrength;
typedef struct
RECURSION_SUBLINK, /* inside a sublink */
RECURSION_OUTERJOIN, /* inside nullable side of an outer join */
RECURSION_INTERSECT, /* underneath INTERSECT (ALL) */
- RECURSION_EXCEPT /* underneath EXCEPT (ALL) */
+ RECURSION_EXCEPT, /* underneath EXCEPT (ALL) */
} RecursionContext;
/* Associated error messages --- each must have one %s for CTE name */
typedef enum
{
FUNCLOOKUP_NOSUCHFUNC,
- FUNCLOOKUP_AMBIGUOUS
+ FUNCLOOKUP_AMBIGUOUS,
} FuncLookupError;
static void unify_hypothetical_args(ParseState *pstate,
PARTCLAUSE_MATCH_NULLNESS,
PARTCLAUSE_MATCH_STEPS,
PARTCLAUSE_MATCH_CONTRADICT,
- PARTCLAUSE_UNSUPPORTED
+ PARTCLAUSE_UNSUPPORTED,
} PartClauseMatchStatus;
/*
{
PARTTARGET_PLANNER, /* want to prune during planning */
PARTTARGET_INITIAL, /* want to prune during executor startup */
- PARTTARGET_EXEC /* want to prune during each plan node scan */
+ PARTTARGET_EXEC, /* want to prune during each plan node scan */
} PartClauseTarget;
/*
SHMSTATE_ATTACHED, /* pertinent to DataDir, has attached PIDs */
SHMSTATE_ENOENT, /* no segment of that ID */
SHMSTATE_FOREIGN, /* exists, but not pertinent to DataDir */
- SHMSTATE_UNATTACHED /* pertinent to DataDir, no attached PIDs */
+ SHMSTATE_UNATTACHED, /* pertinent to DataDir, no attached PIDs */
} IpcMemoryState;
{
AutoVacForkFailed, /* failed trying to start a worker */
AutoVacRebalance, /* rebalance the cost limits */
- AutoVacNumSignals /* must be last */
+ AutoVacNumSignals, /* must be last */
} AutoVacuumSignal;
/*
STARTUP_NOT_RUNNING,
STARTUP_RUNNING,
STARTUP_SIGNALED, /* we sent it a SIGQUIT or SIGKILL */
- STARTUP_CRASHED
+ STARTUP_CRASHED,
} StartupStatusEnum;
static StartupStatusEnum StartupStatus = STARTUP_NOT_RUNNING;
PM_SHUTDOWN_2, /* waiting for archiver and walsenders to
* finish */
PM_WAIT_DEAD_END, /* waiting for dead_end children to exit */
- PM_NO_CHILDREN /* all important children have exited */
+ PM_NO_CHILDREN, /* all important children have exited */
} PMState;
static PMState pmState = PM_INIT;
PG_REGEX_LOCALE_1BYTE, /* Use <ctype.h> functions */
PG_REGEX_LOCALE_WIDE_L, /* Use locale_t <wctype.h> functions */
PG_REGEX_LOCALE_1BYTE_L, /* Use locale_t <ctype.h> functions */
- PG_REGEX_LOCALE_ICU /* Use ICU uchar.h functions */
+ PG_REGEX_LOCALE_ICU, /* Use ICU uchar.h functions */
} PG_Locale_Strategy;
static PG_Locale_Strategy pg_regex_strategy;
TRANS_LEADER_SERIALIZE,
TRANS_LEADER_SEND_TO_PARALLEL,
TRANS_LEADER_PARTIAL_SERIALIZE,
- TRANS_PARALLEL_APPLY
+ TRANS_PARALLEL_APPLY,
} TransApplyAction;
/* errcontext tracker */
{
PUBACTION_INSERT,
PUBACTION_UPDATE,
- PUBACTION_DELETE
+ PUBACTION_DELETE,
};
#define NUM_ROWFILTER_PUBACTIONS (PUBACTION_DELETE+1)
WALRCV_WAKEUP_TERMINATE,
WALRCV_WAKEUP_PING,
WALRCV_WAKEUP_REPLY,
- WALRCV_WAKEUP_HSFEEDBACK
+ WALRCV_WAKEUP_HSFEEDBACK,
#define NUM_WALRCV_WAKEUPS (WALRCV_WAKEUP_HSFEEDBACK + 1)
} WalRcvWakeupReason;
AllocateDescFile,
AllocateDescPipe,
AllocateDescDir,
- AllocateDescRawFD
+ AllocateDescRawFD,
} AllocateDescKind;
typedef struct
VISHORIZON_SHARED,
VISHORIZON_CATALOG,
VISHORIZON_DATA,
- VISHORIZON_TEMP
+ VISHORIZON_TEMP,
} GlobalVisHorizonKind;
/*
KAX_NO_SPACE, /* need to free up space at array end */
KAX_PRUNE, /* we just pruned old entries */
KAX_TRANSACTION_END, /* we just committed/removed some XIDs */
- KAX_STARTUP_PROCESS_IDLE /* startup process is about to sleep */
+ KAX_STARTUP_PROCESS_IDLE, /* startup process is about to sleep */
} KAXCompressReason;
ARRAY_QUOTED_ELEM_COMPLETED,
ARRAY_ELEM_DELIMITED,
ARRAY_LEVEL_COMPLETED,
- ARRAY_LEVEL_DELIMITED
+ ARRAY_LEVEL_DELIMITED,
} ArrayParseState;
/* Working state for array_iterate() */
{
FROM_CHAR_DATE_NONE = 0, /* Value does not affect date mode. */
FROM_CHAR_DATE_GREGORIAN, /* Gregorian (day, month, year) style date */
- FROM_CHAR_DATE_ISOWEEK /* ISO 8601 week date */
+ FROM_CHAR_DATE_ISOWEEK, /* ISO 8601 week date */
} FromCharDateMode;
typedef struct
{
JSP_GIN_OR,
JSP_GIN_AND,
- JSP_GIN_ENTRY
+ JSP_GIN_ENTRY,
} JsonPathGinNodeType;
typedef struct JsonPathGinNode JsonPathGinNode;
TYPECAT_ARRAY = 'a',
TYPECAT_COMPOSITE = 'c',
TYPECAT_COMPOSITE_DOMAIN = 'C',
- TYPECAT_DOMAIN = 'd'
+ TYPECAT_DOMAIN = 'd',
} TypeCat;
/* these two are stolen from hstore / record_out, used in populate_record* */
Pattern_Type_Like_IC,
Pattern_Type_Regex,
Pattern_Type_Regex_IC,
- Pattern_Type_Prefix
+ Pattern_Type_Prefix,
} Pattern_Type;
typedef enum
{
- Pattern_Prefix_None, Pattern_Prefix_Partial, Pattern_Prefix_Exact
+ Pattern_Prefix_None, Pattern_Prefix_Partial, Pattern_Prefix_Exact,
} Pattern_Prefix_Status;
static Node *like_regex_support(Node *rawreq, Pattern_Type ptype);
typedef enum
{
SPLIT_LEFT = 0, /* makes initialization to SPLIT_LEFT easier */
- SPLIT_RIGHT
+ SPLIT_RIGHT,
} SplitLR;
/*
{
WAITOPERAND = 1,
WAITOPERATOR = 2,
- WAITFIRSTOPERAND = 3
+ WAITFIRSTOPERAND = 3,
} ts_parserstate;
/*
PT_VAL = 2,
PT_OPR = 3,
PT_OPEN = 4,
- PT_CLOSE = 5
+ PT_CLOSE = 5,
} ts_tokentype;
/*
{
ETCS_NEEDS_REBUILD,
ETCS_REBUILD_STARTED,
- ETCS_VALID
+ ETCS_VALID,
} EventTriggerCacheStateType;
typedef struct
TSS_BUILDRUNS, /* Loading tuples; writing to tape */
TSS_SORTEDINMEM, /* Sort completed entirely in memory */
TSS_SORTEDONTAPE, /* Sort completed, final run is on tape */
- TSS_FINALMERGE /* Performing final merge on-the-fly */
+ TSS_FINALMERGE, /* Performing final merge on-the-fly */
} TupSortStatus;
/*
{
TSS_INMEM, /* Tuples still fit in memory */
TSS_WRITEFILE, /* Writing to temp file */
- TSS_READFILE /* Reading from temp file */
+ TSS_READFILE, /* Reading from temp file */
} TupStoreStatus;
/*
BBSTREAMER_MEMBER_HEADER,
BBSTREAMER_MEMBER_CONTENTS,
BBSTREAMER_MEMBER_TRAILER,
- BBSTREAMER_ARCHIVE_TRAILER
+ BBSTREAMER_ARCHIVE_TRAILER,
} bbstreamer_archive_context;
/*
{
NO_WAL,
FETCH_WAL,
- STREAM_WAL
+ STREAM_WAL,
} IncludeWal;
/*
{
COMPRESS_LOCATION_UNSPECIFIED,
COMPRESS_LOCATION_CLIENT,
- COMPRESS_LOCATION_SERVER
+ COMPRESS_LOCATION_SERVER,
} CompressionLocation;
/* Global options */
{
CLOSE_NORMAL,
CLOSE_UNLINK,
- CLOSE_NO_RENAME
+ CLOSE_NO_RENAME,
} WalCloseMethod;
/*
{
PG_MODE_CHECK,
PG_MODE_DISABLE,
- PG_MODE_ENABLE
+ PG_MODE_ENABLE,
} PgChecksumMode;
static PgChecksumMode mode = PG_MODE_CHECK;
{
SMART_MODE,
FAST_MODE,
- IMMEDIATE_MODE
+ IMMEDIATE_MODE,
} ShutdownMode;
typedef enum
{
POSTMASTER_READY,
POSTMASTER_STILL_STARTING,
- POSTMASTER_FAILED
+ POSTMASTER_FAILED,
} WaitPMResult;
typedef enum
KILL_COMMAND,
REGISTER_COMMAND,
UNREGISTER_COMMAND,
- RUN_AS_SERVICE_COMMAND
+ RUN_AS_SERVICE_COMMAND,
} CtlCommand;
#define DEFAULT_WAIT 60
WRKR_NOT_STARTED = 0,
WRKR_IDLE,
WRKR_WORKING,
- WRKR_TERMINATED
+ WRKR_TERMINATED,
} T_WorkerStatus;
#define WORKER_IS_RUNNING(workerStatus) \
WFW_NO_WAIT,
WFW_GOT_STATUS,
WFW_ONE_IDLE,
- WFW_ALL_IDLE
+ WFW_ALL_IDLE,
} WFW_WaitOption;
/*
{
TRI_DEFAULT,
TRI_NO,
- TRI_YES
+ TRI_YES,
} trivalue;
typedef enum _archiveFormat
archCustom = 1,
archTar = 3,
archNull = 4,
- archDirectory = 5
+ archDirectory = 5,
} ArchiveFormat;
typedef enum _archiveMode
{
archModeAppend,
archModeWrite,
- archModeRead
+ archModeRead,
} ArchiveMode;
typedef enum _teSection
SECTION_NONE = 1, /* comments, ACLs, etc; can be anywhere */
SECTION_PRE_DATA, /* stuff to be processed before data */
SECTION_DATA, /* table data, large objects, LO comments */
- SECTION_POST_DATA /* stuff to be processed after data */
+ SECTION_POST_DATA, /* stuff to be processed after data */
} teSection;
/* We need one enum entry per prepared query in pg_dump */
typedef enum T_Action
{
ACT_DUMP,
- ACT_RESTORE
+ ACT_RESTORE,
} T_Action;
typedef void (*ClosePtrType) (ArchiveHandle *AH);
{
SQL_SCAN = 0, /* normal */
SQL_IN_SINGLE_QUOTE, /* '...' literal */
- SQL_IN_DOUBLE_QUOTE /* "..." identifier */
+ SQL_IN_DOUBLE_QUOTE, /* "..." identifier */
} sqlparseState;
typedef struct
STAGE_NONE = 0,
STAGE_INITIALIZING,
STAGE_PROCESSING,
- STAGE_FINALIZING
+ STAGE_FINALIZING,
} ArchiverStage;
typedef enum
{
OUTPUT_SQLCMDS = 0, /* emitting general SQL commands */
OUTPUT_COPYDATA, /* writing COPY data */
- OUTPUT_OTHERDATA /* writing data as INSERT commands */
+ OUTPUT_OTHERDATA, /* writing data as INSERT commands */
} ArchiverOutput;
/*
{
RESTORE_PASS_MAIN = 0, /* Main pass (most TOC item types) */
RESTORE_PASS_ACL, /* ACL item types */
- RESTORE_PASS_POST_ACL /* Event trigger and matview refresh items */
+ RESTORE_PASS_POST_ACL, /* Event trigger and matview refresh items */
#define RESTORE_PASS_LAST RESTORE_PASS_POST_ACL
} RestorePass;
{
zeroIsError = 1,
zeroAsStar = 2,
- zeroAsNone = 4
+ zeroAsNone = 4,
} OidOptions;
/* global decls */
DO_PUBLICATION,
DO_PUBLICATION_REL,
DO_PUBLICATION_TABLE_IN_SCHEMA,
- DO_SUBSCRIPTION
+ DO_SUBSCRIPTION,
} DumpableObjectType;
/*
FILE_ACTION_NONE, /* no action (we might still copy modified
* blocks based on the parsed WAL) */
FILE_ACTION_TRUNCATE, /* truncate local file to 'newsize' bytes */
- FILE_ACTION_REMOVE /* remove local file / directory / symlink */
+ FILE_ACTION_REMOVE, /* remove local file / directory / symlink */
} file_action_t;
typedef enum
FILE_TYPE_REGULAR,
FILE_TYPE_DIRECTORY,
- FILE_TYPE_SYMLINK
+ FILE_TYPE_SYMLINK,
} file_type_t;
/*
{
TRANSFER_MODE_CLONE,
TRANSFER_MODE_COPY,
- TRANSFER_MODE_LINK
+ TRANSFER_MODE_LINK,
} transferMode;
/*
PG_REPORT_NONL, /* these too */
PG_REPORT,
PG_WARNING,
- PG_FATAL
+ PG_FATAL,
} eLogType;
JM_EXPECT_THIS_WAL_RANGE_FIELD,
JM_EXPECT_THIS_WAL_RANGE_VALUE,
JM_EXPECT_MANIFEST_CHECKSUM_VALUE,
- JM_EXPECT_EOF
+ JM_EXPECT_EOF,
} JsonManifestSemanticState;
/*
JMFF_SIZE,
JMFF_LAST_MODIFIED,
JMFF_CHECKSUM_ALGORITHM,
- JMFF_CHECKSUM
+ JMFF_CHECKSUM,
} JsonManifestFileField;
/*
{
JMWRF_TIMELINE,
JMWRF_START_LSN,
- JMWRF_END_LSN
+ JMWRF_END_LSN,
} JsonManifestWALRangeField;
/*
{
PART_NONE, /* no partitioning */
PART_RANGE, /* range partitioning */
- PART_HASH /* hash partitioning */
+ PART_HASH, /* hash partitioning */
} partition_method_t;
static partition_method_t partition_method = PART_NONE;
/* SQL errors */
ESTATUS_SERIALIZATION_ERROR,
ESTATUS_DEADLOCK_ERROR,
- ESTATUS_OTHER_SQL_ERROR
+ ESTATUS_OTHER_SQL_ERROR,
} EStatus;
/*
TSTATUS_IDLE,
TSTATUS_IN_BLOCK,
TSTATUS_CONN_ERROR,
- TSTATUS_OTHER_ERROR
+ TSTATUS_OTHER_ERROR,
} TStatus;
/* Various random sequences are initialized from this one. */
* aborted because a command failed, CSTATE_FINISHED means success.
*/
CSTATE_ABORTED,
- CSTATE_FINISHED
+ CSTATE_FINISHED,
} ConnectionStateEnum;
/*
META_ELSE, /* \else */
META_ENDIF, /* \endif */
META_STARTPIPELINE, /* \startpipeline */
- META_ENDPIPELINE /* \endpipeline */
+ META_ENDPIPELINE, /* \endpipeline */
} MetaCommand;
typedef enum QueryMode
PGBT_NULL,
PGBT_INT,
PGBT_DOUBLE,
- PGBT_BOOLEAN
+ PGBT_BOOLEAN,
/* add other types here */
} PgBenchValueType;
{
ENODE_CONSTANT,
ENODE_VARIABLE,
- ENODE_FUNCTION
+ ENODE_FUNCTION,
} PgBenchExprType;
/* List of operators and callable functions */
PGBENCH_CASE,
PGBENCH_HASH_FNV1A,
PGBENCH_HASH_MURMUR2,
- PGBENCH_PERMUTE
+ PGBENCH_PERMUTE,
} PgBenchFunction;
typedef struct PgBenchExpr PgBenchExpr;
typedef enum EditableObjectType
{
EditableFunction,
- EditableView
+ EditableView,
} EditableObjectType;
/* local function declarations */
PSQL_CMD_SKIP_LINE, /* keep building query */
PSQL_CMD_TERMINATE, /* quit program */
PSQL_CMD_NEWEDIT, /* query buffer was changed (e.g., via \e) */
- PSQL_CMD_ERROR /* the execution of the backslash command
+ PSQL_CMD_ERROR, /* the execution of the backslash command
* resulted in an error */
} backslashResult;
OT_SQLID, /* treat as SQL identifier */
OT_SQLIDHACK, /* SQL identifier, but don't downcase */
OT_FILEPIPE, /* it's a filename or pipe */
- OT_WHOLE_LINE /* just snarf the rest of the line */
+ OT_WHOLE_LINE, /* just snarf the rest of the line */
};
PSQL_ECHO_NONE,
PSQL_ECHO_QUERIES,
PSQL_ECHO_ERRORS,
- PSQL_ECHO_ALL
+ PSQL_ECHO_ALL,
} PSQL_ECHO;
typedef enum
{
PSQL_ECHO_HIDDEN_OFF,
PSQL_ECHO_HIDDEN_ON,
- PSQL_ECHO_HIDDEN_NOEXEC
+ PSQL_ECHO_HIDDEN_NOEXEC,
} PSQL_ECHO_HIDDEN;
typedef enum
{
PSQL_ERROR_ROLLBACK_OFF,
PSQL_ERROR_ROLLBACK_INTERACTIVE,
- PSQL_ERROR_ROLLBACK_ON
+ PSQL_ERROR_ROLLBACK_ON,
} PSQL_ERROR_ROLLBACK;
typedef enum
PSQL_COMP_CASE_PRESERVE_UPPER,
PSQL_COMP_CASE_PRESERVE_LOWER,
PSQL_COMP_CASE_UPPER,
- PSQL_COMP_CASE_LOWER
+ PSQL_COMP_CASE_LOWER,
} PSQL_COMP_CASE;
typedef enum
hctl_none = 0,
hctl_ignorespace = 1,
hctl_ignoredups = 2,
- hctl_ignoreboth = hctl_ignorespace | hctl_ignoredups
+ hctl_ignoreboth = hctl_ignorespace | hctl_ignoredups,
} HistControl;
enum trivalue
{
TRI_DEFAULT,
TRI_NO,
- TRI_YES
+ TRI_YES,
};
typedef struct _psqlSettings
{
ACT_SINGLE_QUERY,
ACT_SINGLE_SLASH,
- ACT_FILE
+ ACT_FILE,
};
typedef struct SimpleActionListCell
REINDEX_INDEX,
REINDEX_SCHEMA,
REINDEX_SYSTEM,
- REINDEX_TABLE
+ REINDEX_TABLE,
} ReindexType;
OBJFILTER_DATABASE = (1 << 1), /* -d | --dbname */
OBJFILTER_TABLE = (1 << 2), /* -t | --table */
OBJFILTER_SCHEMA = (1 << 3), /* -n | --schema */
- OBJFILTER_SCHEMA_EXCLUDE = (1 << 4) /* -N | --exclude-schema */
+ OBJFILTER_SCHEMA_EXCLUDE = (1 << 4), /* -N | --exclude-schema */
} VacObjFilter;
VacObjFilter objfilter = OBJFILTER_NONE;
typedef enum pg_cryptohash_errno
{
PG_CRYPTOHASH_ERROR_NONE = 0,
- PG_CRYPTOHASH_ERROR_DEST_LEN
+ PG_CRYPTOHASH_ERROR_DEST_LEN,
} pg_cryptohash_errno;
/* Internal pg_cryptohash_ctx structure */
{
PG_CRYPTOHASH_ERROR_NONE = 0,
PG_CRYPTOHASH_ERROR_DEST_LEN,
- PG_CRYPTOHASH_ERROR_OPENSSL
+ PG_CRYPTOHASH_ERROR_OPENSSL,
} pg_cryptohash_errno;
/*
{
PG_HMAC_ERROR_NONE = 0,
PG_HMAC_ERROR_OOM,
- PG_HMAC_ERROR_INTERNAL
+ PG_HMAC_ERROR_INTERNAL,
} pg_hmac_errno;
/* Internal pg_hmac_ctx structure */
{
PG_HMAC_ERROR_NONE = 0,
PG_HMAC_ERROR_DEST_LEN,
- PG_HMAC_ERROR_OPENSSL
+ PG_HMAC_ERROR_OPENSSL,
} pg_hmac_errno;
/* Internal pg_hmac_ctx structure */
JSON_PARSE_OBJECT_LABEL, /* saw object label, expecting ':' */
JSON_PARSE_OBJECT_NEXT, /* saw object value, expecting ',' or '}' */
JSON_PARSE_OBJECT_COMMA, /* saw object ',', expecting next label */
- JSON_PARSE_END /* saw the end of a document, expect nothing */
+ JSON_PARSE_END, /* saw the end of a document, expect nothing */
} JsonParseContext;
static inline JsonParseErrorType json_lex_string(JsonLexContext *lex);
AMPROP_CAN_UNIQUE,
AMPROP_CAN_MULTI_COL,
AMPROP_CAN_EXCLUDE,
- AMPROP_CAN_INCLUDE
+ AMPROP_CAN_INCLUDE,
} IndexAMProperty;
/*
UNIQUE_CHECK_NO, /* Don't do any uniqueness checking */
UNIQUE_CHECK_YES, /* Enforce uniqueness at insertion time */
UNIQUE_CHECK_PARTIAL, /* Test uniqueness, but no error */
- UNIQUE_CHECK_EXISTING /* Check if existing tuple is unique */
+ UNIQUE_CHECK_EXISTING, /* Check if existing tuple is unique */
} IndexUniqueCheck;
{
GPTP_NO_WORK,
GPTP_INSERT,
- GPTP_SPLIT
+ GPTP_SPLIT,
} GinPlaceToPageRC;
typedef struct GinBtreeData
{
GIST_OPTION_BUFFERING_AUTO,
GIST_OPTION_BUFFERING_ON,
- GIST_OPTION_BUFFERING_OFF
+ GIST_OPTION_BUFFERING_OFF,
} GistOptBufferingMode;
/*
HEAPTUPLE_LIVE, /* tuple is live (committed, no deleter) */
HEAPTUPLE_RECENTLY_DEAD, /* tuple is dead, but not deletable yet */
HEAPTUPLE_INSERT_IN_PROGRESS, /* inserting xact is still in progress */
- HEAPTUPLE_DELETE_IN_PROGRESS /* deleting xact is still in progress */
+ HEAPTUPLE_DELETE_IN_PROGRESS, /* deleting xact is still in progress */
} HTSV_Result;
/*
/* an update that doesn't touch "key" columns */
MultiXactStatusNoKeyUpdate = 0x04,
/* other updates, and delete */
- MultiXactStatusUpdate = 0x05
+ MultiXactStatusUpdate = 0x05,
} MultiXactStatus;
#define MaxMultiXactStatus MultiXactStatusUpdate
RELOPT_TYPE_INT,
RELOPT_TYPE_REAL,
RELOPT_TYPE_ENUM,
- RELOPT_TYPE_STRING
+ RELOPT_TYPE_STRING,
} relopt_type;
/* kinds supported by reloptions */
SLRU_PAGE_EMPTY, /* buffer is not in use */
SLRU_PAGE_READ_IN_PROGRESS, /* page is being read in */
SLRU_PAGE_VALID, /* page is valid and not being written */
- SLRU_PAGE_WRITE_IN_PROGRESS /* page is being written out */
+ SLRU_PAGE_WRITE_IN_PROGRESS, /* page is being written out */
} SlruPageStatus;
/*
{
spgMatchNode = 1, /* descend into existing node */
spgAddNode, /* add a node to the inner tuple */
- spgSplitTuple /* split inner tuple (change its prefix) */
+ spgSplitTuple, /* split inner tuple (change its prefix) */
} spgChooseResultType;
typedef struct spgChooseOut
SO_ALLOW_PAGEMODE = 1 << 8,
/* unregister snapshot at scan end? */
- SO_TEMP_SNAPSHOT = 1 << 9
-} ScanOptions;
+ SO_TEMP_SNAPSHOT = 1 << 9,
+} ScanOptions;
/*
* Result codes for table_{update,delete,lock_tuple}, and for visibility
TM_BeingModified,
/* lock couldn't be acquired, action skipped. Only used by lock_tuple */
- TM_WouldBlock
+ TM_WouldBlock,
} TM_Result;
/*
TU_All,
/* Only summarized columns were updated, TID is unchanged */
- TU_Summarizing
+ TU_Summarizing,
} TU_UpdateIndexes;
/*
{
TOAST_PGLZ_COMPRESSION_ID = 0,
TOAST_LZ4_COMPRESSION_ID = 1,
- TOAST_INVALID_COMPRESSION_ID = 2
+ TOAST_INVALID_COMPRESSION_ID = 2,
} ToastCompressionId;
/*
SYNCHRONOUS_COMMIT_REMOTE_WRITE, /* wait for local flush and remote
* write */
SYNCHRONOUS_COMMIT_REMOTE_FLUSH, /* wait for local and remote flush */
- SYNCHRONOUS_COMMIT_REMOTE_APPLY /* wait for local and remote flush and
- * remote apply */
+ SYNCHRONOUS_COMMIT_REMOTE_APPLY, /* wait for local and remote flush and
+ * remote apply */
} SyncCommitLevel;
/* Define the default setting for synchronous_commit */
XACT_EVENT_PREPARE,
XACT_EVENT_PRE_COMMIT,
XACT_EVENT_PARALLEL_PRE_COMMIT,
- XACT_EVENT_PRE_PREPARE
+ XACT_EVENT_PRE_PREPARE,
} XactEvent;
typedef void (*XactCallback) (XactEvent event, void *arg);
SUBXACT_EVENT_START_SUB,
SUBXACT_EVENT_COMMIT_SUB,
SUBXACT_EVENT_ABORT_SUB,
- SUBXACT_EVENT_PRE_COMMIT_SUB
+ SUBXACT_EVENT_PRE_COMMIT_SUB,
} SubXactEvent;
typedef void (*SubXactCallback) (SubXactEvent event, SubTransactionId mySubid,
{
ARCHIVE_MODE_OFF = 0, /* disabled */
ARCHIVE_MODE_ON, /* enabled while server is running normally */
- ARCHIVE_MODE_ALWAYS /* enabled always (even during recovery) */
+ ARCHIVE_MODE_ALWAYS, /* enabled always (even during recovery) */
} ArchiveMode;
extern PGDLLIMPORT int XLogArchiveMode;
{
WAL_LEVEL_MINIMAL = 0,
WAL_LEVEL_REPLICA,
- WAL_LEVEL_LOGICAL
+ WAL_LEVEL_LOGICAL,
} WalLevel;
/* Compression algorithms for WAL */
WAL_COMPRESSION_NONE = 0,
WAL_COMPRESSION_PGLZ,
WAL_COMPRESSION_LZ4,
- WAL_COMPRESSION_ZSTD
+ WAL_COMPRESSION_ZSTD,
} WalCompression;
/* Recovery states */
{
RECOVERY_STATE_CRASH = 0, /* crash recovery */
RECOVERY_STATE_ARCHIVE, /* archive recovery */
- RECOVERY_STATE_DONE /* currently in production */
+ RECOVERY_STATE_DONE, /* currently in production */
} RecoveryState;
extern PGDLLIMPORT int wal_level;
WALAVAIL_EXTENDED, /* WAL segment is reserved by a slot or
* wal_keep_size */
WALAVAIL_UNRESERVED, /* no longer reserved, but not removed yet */
- WALAVAIL_REMOVED /* WAL segment has been removed */
+ WALAVAIL_REMOVED, /* WAL segment has been removed */
} WALAvailability;
struct XLogRecData;
{
RECOVERY_TARGET_ACTION_PAUSE,
RECOVERY_TARGET_ACTION_PROMOTE,
- RECOVERY_TARGET_ACTION_SHUTDOWN
+ RECOVERY_TARGET_ACTION_SHUTDOWN,
} RecoveryTargetAction;
struct LogicalDecodingContext;
{
RECOVERY_PREFETCH_OFF,
RECOVERY_PREFETCH_ON,
- RECOVERY_PREFETCH_TRY
+ RECOVERY_PREFETCH_TRY,
} RecoveryPrefetchValue;
struct XLogPrefetcher;
{
XLREAD_SUCCESS = 0, /* record is successfully read */
XLREAD_FAIL = -1, /* failed during reading a record */
- XLREAD_WOULDBLOCK = -2 /* nonblocking mode only, no data */
+ XLREAD_WOULDBLOCK = -2, /* nonblocking mode only, no data */
} XLogPageReadResult;
/* Read the next XLog record. Returns NULL on end-of-WAL or failure */
RECOVERY_TARGET_TIME,
RECOVERY_TARGET_NAME,
RECOVERY_TARGET_LSN,
- RECOVERY_TARGET_IMMEDIATE
+ RECOVERY_TARGET_IMMEDIATE,
} RecoveryTargetType;
/*
{
RECOVERY_TARGET_TIMELINE_CONTROLFILE,
RECOVERY_TARGET_TIMELINE_LATEST,
- RECOVERY_TARGET_TIMELINE_NUMERIC
+ RECOVERY_TARGET_TIMELINE_NUMERIC,
} RecoveryTargetTimeLineGoal;
/* Recovery pause states */
{
RECOVERY_NOT_PAUSED, /* pause not requested */
RECOVERY_PAUSE_REQUESTED, /* pause requested, but not yet paused */
- RECOVERY_PAUSED /* recovery is paused */
+ RECOVERY_PAUSED, /* recovery is paused */
} RecoveryPauseState;
/* User-settable GUC parameters */
STANDBY_DISABLED,
STANDBY_INITIALIZED,
STANDBY_SNAPSHOT_PENDING,
- STANDBY_SNAPSHOT_READY
+ STANDBY_SNAPSHOT_READY,
} HotStandbyState;
extern PGDLLIMPORT HotStandbyState standbyState;
BLK_NEEDS_REDO, /* changes from WAL record need to be applied */
BLK_DONE, /* block is already up-to-date */
BLK_RESTORED, /* block was restored from a full-page image */
- BLK_NOTFOUND /* block was not found (and hence does not
+ BLK_NOTFOUND, /* block was not found (and hence does not
* need to be replayed) */
} XLogRedoAction;
{
MANIFEST_OPTION_YES,
MANIFEST_OPTION_NO,
- MANIFEST_OPTION_FORCE_ENCODE
+ MANIFEST_OPTION_FORCE_ENCODE,
} backup_manifest_option;
typedef struct backup_manifest_info
DEPENDENCY_PARTITION_PRI = 'P',
DEPENDENCY_PARTITION_SEC = 'S',
DEPENDENCY_EXTENSION = 'e',
- DEPENDENCY_AUTO_EXTENSION = 'x'
+ DEPENDENCY_AUTO_EXTENSION = 'x',
} DependencyType;
/*
SHARED_DEPENDENCY_ACL = 'a',
SHARED_DEPENDENCY_POLICY = 'r',
SHARED_DEPENDENCY_TABLESPACE = 't',
- SHARED_DEPENDENCY_INVALID = 0
+ SHARED_DEPENDENCY_INVALID = 0,
} SharedDependencyType;
/* expansible list of ObjectAddresses (private in dependency.c) */
OCLASS_PUBLICATION_NAMESPACE, /* pg_publication_namespace */
OCLASS_PUBLICATION_REL, /* pg_publication_rel */
OCLASS_SUBSCRIPTION, /* pg_subscription */
- OCLASS_TRANSFORM /* pg_transform */
+ OCLASS_TRANSFORM, /* pg_transform */
} ObjectClass;
#define LAST_OCLASS OCLASS_TRANSFORM
INDEX_CREATE_SET_READY,
INDEX_CREATE_SET_VALID,
INDEX_DROP_CLEAR_VALID,
- INDEX_DROP_SET_DEAD
+ INDEX_DROP_SET_DEAD,
} IndexStateFlagsAction;
/* options for REINDEX */
{
TEMP_NAMESPACE_NOT_TEMP, /* nonexistent, or non-temp namespace */
TEMP_NAMESPACE_IDLE, /* exists, belongs to no active session */
- TEMP_NAMESPACE_IN_USE /* belongs to some active session */
+ TEMP_NAMESPACE_IN_USE, /* belongs to some active session */
} TempNamespaceStatus;
/*
{
RVR_MISSING_OK = 1 << 0, /* don't error if relation doesn't exist */
RVR_NOWAIT = 1 << 1, /* error if relation cannot be locked */
- RVR_SKIP_LOCKED = 1 << 2 /* skip if relation cannot be locked */
-} RVROption;
+ RVR_SKIP_LOCKED = 1 << 2, /* skip if relation cannot be locked */
+} RVROption;
typedef void (*RangeVarGetRelidCallback) (const RangeVar *relation, Oid relId,
Oid oldRelId, void *callback_arg);
OAT_POST_ALTER,
OAT_NAMESPACE_SEARCH,
OAT_FUNCTION_EXECUTE,
- OAT_TRUNCATE
+ OAT_TRUNCATE,
} ObjectAccessType;
/*
{
COERCION_CODE_IMPLICIT = 'i', /* coercion in context of expression */
COERCION_CODE_ASSIGNMENT = 'a', /* coercion in context of assignment */
- COERCION_CODE_EXPLICIT = 'e' /* explicit cast operation */
-} CoercionCodes;
+ COERCION_CODE_EXPLICIT = 'e', /* explicit cast operation */
+} CoercionCodes;
/*
* The allowable values for pg_cast.castmethod are specified by this enum.
{
COERCION_METHOD_FUNCTION = 'f', /* use a function */
COERCION_METHOD_BINARY = 'b', /* types are binary-compatible */
- COERCION_METHOD_INOUT = 'i' /* use input/output functions */
-} CoercionMethod;
+ COERCION_METHOD_INOUT = 'i', /* use input/output functions */
+} CoercionMethod;
#endif /* EXPOSE_TO_CLIENT_CODE */
{
CONSTRAINT_RELATION,
CONSTRAINT_DOMAIN,
- CONSTRAINT_ASSERTION /* for future expansion */
+ CONSTRAINT_ASSERTION, /* for future expansion */
} ConstraintCategory;
DB_SHUTDOWNING,
DB_IN_CRASH_RECOVERY,
DB_IN_ARCHIVE_RECOVERY,
- DB_IN_PRODUCTION
+ DB_IN_PRODUCTION,
} DBState;
/*
typedef enum InitPrivsType
{
INITPRIVS_INITDB = 'i',
- INITPRIVS_EXTENSION = 'e'
-} InitPrivsType;
+ INITPRIVS_EXTENSION = 'e',
+} InitPrivsType;
#endif /* PG_INIT_PRIVS_H */
{
COPY_FILE, /* from file (or a piped program) */
COPY_FRONTEND, /* from frontend */
- COPY_CALLBACK /* from callback function */
+ COPY_CALLBACK, /* from callback function */
} CopySource;
/*
EOL_UNKNOWN,
EOL_NL,
EOL_CR,
- EOL_CRNL
+ EOL_CRNL,
} EolType;
/*
CIM_SINGLE, /* use table_tuple_insert or ExecForeignInsert */
CIM_MULTI, /* always use table_multi_insert or
* ExecForeignBatchInsert */
- CIM_MULTI_CONDITIONAL /* use table_multi_insert or
+ CIM_MULTI_CONDITIONAL, /* use table_multi_insert or
* ExecForeignBatchInsert only if valid */
} CopyInsertMethod;
EXPLAIN_FORMAT_TEXT,
EXPLAIN_FORMAT_XML,
EXPLAIN_FORMAT_JSON,
- EXPLAIN_FORMAT_YAML
+ EXPLAIN_FORMAT_YAML,
} ExplainFormat;
typedef struct ExplainWorkersState
CHECKSUM_TYPE_SHA224,
CHECKSUM_TYPE_SHA256,
CHECKSUM_TYPE_SHA384,
- CHECKSUM_TYPE_SHA512
+ CHECKSUM_TYPE_SHA512,
} pg_checksum_type;
/*
PG_COMPRESSION_NONE,
PG_COMPRESSION_GZIP,
PG_COMPRESSION_LZ4,
- PG_COMPRESSION_ZSTD
+ PG_COMPRESSION_ZSTD,
} pg_compress_algorithm;
#define PG_COMPRESSION_OPTION_WORKERS (1 << 0)
PG_SHA224,
PG_SHA256,
PG_SHA384,
- PG_SHA512
+ PG_SHA512,
} pg_cryptohash_type;
/* opaque context, private to each cryptohash implementation */
PGFILETYPE_UNKNOWN,
PGFILETYPE_REG,
PGFILETYPE_DIR,
- PGFILETYPE_LNK
+ PGFILETYPE_LNK,
} PGFileType;
typedef enum DataDirSyncMethod
{
DATA_DIR_SYNC_METHOD_FSYNC,
- DATA_DIR_SYNC_METHOD_SYNCFS
+ DATA_DIR_SYNC_METHOD_SYNCFS,
} DataDirSyncMethod;
struct iovec; /* avoid including port/pg_iovec.h here */
JSON_TOKEN_TRUE,
JSON_TOKEN_FALSE,
JSON_TOKEN_NULL,
- JSON_TOKEN_END
+ JSON_TOKEN_END,
} JsonTokenType;
typedef enum JsonParseErrorType
JSON_UNICODE_UNTRANSLATABLE,
JSON_UNICODE_HIGH_SURROGATE,
JSON_UNICODE_LOW_SURROGATE,
- JSON_SEM_ACTION_FAILED /* error should already be reported */
+ JSON_SEM_ACTION_FAILED, /* error should already be reported */
} JsonParseErrorType;
MAIN_FORKNUM = 0,
FSM_FORKNUM,
VISIBILITYMAP_FORKNUM,
- INIT_FORKNUM
+ INIT_FORKNUM,
/*
* NOTE: if you add a new fork, change MAX_FORKNUM and possibly
SASLPREP_SUCCESS = 0,
SASLPREP_OOM = -1, /* out of memory (only in frontend) */
SASLPREP_INVALID_UTF8 = -2, /* input is not a valid UTF-8 string */
- SASLPREP_PROHIBITED = -3 /* output would contain prohibited characters */
+ SASLPREP_PROHIBITED = -3, /* output would contain prohibited characters */
} pg_saslprep_rc;
extern pg_saslprep_rc pg_saslprep(const char *input, char **output);
/* The memory budget would be exhausted, so we need to repartition. */
PHJ_GROWTH_NEED_MORE_BATCHES,
/* Repartitioning didn't help last time, so don't try to do that again. */
- PHJ_GROWTH_DISABLED
+ PHJ_GROWTH_DISABLED,
} ParallelHashGrowth;
/*
* false parent branch */
IFSTATE_ELSE_TRUE, /* currently in an \else that is true and all
* parent branches (if any) are true */
- IFSTATE_ELSE_FALSE /* currently in an \else that is false or
+ IFSTATE_ELSE_FALSE, /* currently in an \else that is false or
* ignored */
} ifState;
PRINT_LATEX_LONGTABLE,
PRINT_TROFF_MS,
PRINT_UNALIGNED,
- PRINT_WRAPPED
+ PRINT_WRAPPED,
/* add your favourite output format here ... */
};
PRINT_RULE_TOP, /* top horizontal line */
PRINT_RULE_MIDDLE, /* intra-data horizontal line */
PRINT_RULE_BOTTOM, /* bottom horizontal line */
- PRINT_RULE_DATA /* data line (hrule is unused here) */
+ PRINT_RULE_DATA, /* data line (hrule is unused here) */
} printTextRule;
typedef enum printTextLineWrap
/* Line wrapping conditions */
PRINT_LINE_WRAP_NONE, /* No wrapping */
PRINT_LINE_WRAP_WRAP, /* Wraparound due to overlength line */
- PRINT_LINE_WRAP_NEWLINE /* Newline in data */
+ PRINT_LINE_WRAP_NEWLINE, /* Newline in data */
} printTextLineWrap;
typedef enum printXheaderWidthType
typedef enum unicode_linestyle
{
UNICODE_LINESTYLE_SINGLE = 0,
- UNICODE_LINESTYLE_DOUBLE
+ UNICODE_LINESTYLE_DOUBLE,
} unicode_linestyle;
struct separator
PSCAN_SEMICOLON, /* found command-ending semicolon */
PSCAN_BACKSLASH, /* found backslash command */
PSCAN_INCOMPLETE, /* end of line, SQL statement incomplete */
- PSCAN_EOL /* end of line, SQL possibly complete */
+ PSCAN_EOL, /* end of line, SQL possibly complete */
} PsqlScanResult;
/* Prompt type returned by psql_scan() */
PROMPT_DOUBLEQUOTE,
PROMPT_DOLLARQUOTE,
PROMPT_PAREN,
- PROMPT_COPY
+ PROMPT_COPY,
} promptStatus_t;
/* Quoting request types for get_variable() callback */
PQUOTE_PLAIN, /* just return the actual value */
PQUOTE_SQL_LITERAL, /* add quotes to make a valid SQL literal */
PQUOTE_SQL_IDENT, /* quote if needed to make a SQL identifier */
- PQUOTE_SHELL_ARG /* quote if needed to be safe in a shell cmd */
+ PQUOTE_SHELL_ARG, /* quote if needed to be safe in a shell cmd */
} PsqlScanQuoteType;
/* Callback functions to be used by the lexer */
{
FHET_START,
FHET_END,
- FHET_ABORT
+ FHET_ABORT,
} FmgrHookEventType;
typedef bool (*needs_fmgr_hook_type) (Oid fn_oid);
TYPEFUNC_COMPOSITE, /* determinable rowtype result */
TYPEFUNC_COMPOSITE_DOMAIN, /* domain over determinable rowtype result */
TYPEFUNC_RECORD, /* indeterminate rowtype result */
- TYPEFUNC_OTHER /* bogus type, eg pseudotype */
+ TYPEFUNC_OTHER, /* bogus type, eg pseudotype */
} TypeFuncClass;
extern TypeFuncClass get_call_result_type(FunctionCallInfo fcinfo,
{
PASSWORD_TYPE_PLAINTEXT = 0,
PASSWORD_TYPE_MD5,
- PASSWORD_TYPE_SCRAM_SHA_256
+ PASSWORD_TYPE_SCRAM_SHA_256,
} PasswordType;
extern PasswordType get_password_type(const char *shadow_pass);
uaLDAP,
uaCert,
uaRADIUS,
- uaPeer
+ uaPeer,
#define USER_AUTH_LAST uaPeer /* Must be last value of this enum */
} UserAuth;
ipCmpMask,
ipCmpSameHost,
ipCmpSameNet,
- ipCmpAll
+ ipCmpAll,
} IPCompareMethod;
typedef enum ConnType
{
clientCertOff,
clientCertCA,
- clientCertFull
+ clientCertFull,
} ClientCertMode;
typedef enum ClientCertName
{
clientCertCN,
- clientCertDN
+ clientCertDN,
} ClientCertName;
/*
CAC_SHUTDOWN,
CAC_RECOVERY,
CAC_NOTCONSISTENT,
- CAC_TOOMANY
+ CAC_TOOMANY,
} CAC_state;
{
BootstrapProcessing, /* bootstrap creation of template database */
InitProcessing, /* initializing system */
- NormalProcessing /* normal processing */
+ NormalProcessing, /* normal processing */
} ProcessingMode;
extern PGDLLIMPORT ProcessingMode Mode;
BMS_EQUAL, /* sets are equal */
BMS_SUBSET1, /* first set is a subset of the second */
BMS_SUBSET2, /* second set is a subset of the first */
- BMS_DIFFERENT /* neither set is a subset of the other */
+ BMS_DIFFERENT, /* neither set is a subset of the other */
} BMS_Comparison;
/* result of bms_membership */
{
BMS_EMPTY_SET, /* 0 members */
BMS_SINGLETON, /* 1 member */
- BMS_MULTIPLE /* >1 member */
+ BMS_MULTIPLE, /* >1 member */
} BMS_Membership;
{
ExprSingleResult, /* expression does not return a set */
ExprMultipleResult, /* this result is an element of a set */
- ExprEndResult /* there are no more elements in the set */
+ ExprEndResult, /* there are no more elements in the set */
} ExprDoneCond;
/*
SFRM_ValuePerCall = 0x01, /* one value returned per call */
SFRM_Materialize = 0x02, /* result set instantiated in Tuplestore */
SFRM_Materialize_Random = 0x04, /* Tuplestore needs randomAccess */
- SFRM_Materialize_Preferred = 0x08 /* caller prefers Tuplestore */
+ SFRM_Materialize_Preferred = 0x08, /* caller prefers Tuplestore */
} SetFunctionReturnMode;
/*
typedef enum DomainConstraintType
{
DOM_CONSTRAINT_NOTNULL,
- DOM_CONSTRAINT_CHECK
+ DOM_CONSTRAINT_CHECK,
} DomainConstraintType;
typedef struct DomainConstraintState
{
BM_INITIAL,
BM_INPROGRESS,
- BM_FINISHED
+ BM_FINISHED,
} SharedBitmapState;
/* ----------------
WINDOWAGG_DONE, /* No more processing to do */
WINDOWAGG_RUN, /* Normal processing of window funcs */
WINDOWAGG_PASSTHROUGH, /* Don't eval window funcs */
- WINDOWAGG_PASSTHROUGH_STRICT /* Pass-through plus don't store new
+ WINDOWAGG_PASSTHROUGH_STRICT, /* Pass-through plus don't store new
* tuples during spool */
} WindowAggStatus;
LIMIT_WINDOWEND_TIES, /* have returned a tied row */
LIMIT_SUBPLANEOF, /* at EOF of subplan (within window) */
LIMIT_WINDOWEND, /* stepped off end of window */
- LIMIT_WINDOWSTART /* stepped off beginning of window */
+ LIMIT_WINDOWSTART, /* stepped off beginning of window */
} LimitStateCond;
typedef struct LimitState
LCS_FORKEYSHARE, /* FOR KEY SHARE */
LCS_FORSHARE, /* FOR SHARE */
LCS_FORNOKEYUPDATE, /* FOR NO KEY UPDATE */
- LCS_FORUPDATE /* FOR UPDATE */
+ LCS_FORUPDATE, /* FOR UPDATE */
} LockClauseStrength;
/*
/* Skip rows that can't be locked (SKIP LOCKED) */
LockWaitSkip,
/* Raise an error if a row cannot be locked (NOWAIT) */
- LockWaitError
+ LockWaitError,
} LockWaitPolicy;
/*
/* SELECT FOR NO KEY UPDATE, and UPDATEs that don't modify key columns */
LockTupleNoKeyExclusive,
/* SELECT FOR UPDATE, UPDATEs that modify key columns, and DELETE */
- LockTupleExclusive
+ LockTupleExclusive,
} LockTupleMode;
#endif /* LOCKOPTIONS_H */
CMD_MERGE, /* merge stmt */
CMD_UTILITY, /* cmds like create, destroy, copy, vacuum,
* etc. */
- CMD_NOTHING /* dummy command for instead nothing rules
+ CMD_NOTHING, /* dummy command for instead nothing rules
* with qual */
} CmdType;
* by the executor (nor, indeed, by most of the planner).
*/
JOIN_UNIQUE_OUTER, /* LHS path must be made unique */
- JOIN_UNIQUE_INNER /* RHS path must be made unique */
+ JOIN_UNIQUE_INNER, /* RHS path must be made unique */
/*
* We might need additional join types someday.
AGG_PLAIN, /* simple agg across all input rows */
AGG_SORTED, /* grouped agg, input must be sorted */
AGG_HASHED, /* grouped agg, use internal hashtable */
- AGG_MIXED /* grouped agg, hash and sort both used */
+ AGG_MIXED, /* grouped agg, hash and sort both used */
} AggStrategy;
/*
/* Initial phase of partial aggregation, with serialization: */
AGGSPLIT_INITIAL_SERIAL = AGGSPLITOP_SKIPFINAL | AGGSPLITOP_SERIALIZE,
/* Final phase of partial aggregation, with deserialization: */
- AGGSPLIT_FINAL_DESERIAL = AGGSPLITOP_COMBINE | AGGSPLITOP_DESERIALIZE
+ AGGSPLIT_FINAL_DESERIAL = AGGSPLITOP_COMBINE | AGGSPLITOP_DESERIALIZE,
} AggSplit;
/* Test whether an AggSplit value selects each primitive option: */
SETOPCMD_INTERSECT,
SETOPCMD_INTERSECT_ALL,
SETOPCMD_EXCEPT,
- SETOPCMD_EXCEPT_ALL
+ SETOPCMD_EXCEPT_ALL,
} SetOpCmd;
typedef enum SetOpStrategy
{
SETOP_SORTED, /* input must be sorted */
- SETOP_HASHED /* use internal hashtable */
+ SETOP_HASHED, /* use internal hashtable */
} SetOpStrategy;
/*
{
ONCONFLICT_NONE, /* No "ON CONFLICT" clause */
ONCONFLICT_NOTHING, /* ON CONFLICT ... DO NOTHING */
- ONCONFLICT_UPDATE /* ON CONFLICT ... DO UPDATE */
+ ONCONFLICT_UPDATE, /* ON CONFLICT ... DO UPDATE */
} OnConflictAction;
/*
{
OVERRIDING_NOT_SET = 0,
OVERRIDING_USER_VALUE,
- OVERRIDING_SYSTEM_VALUE
+ OVERRIDING_SYSTEM_VALUE,
} OverridingKind;
/* Possible sources of a Query */
QSRC_PARSER, /* added by parse analysis (now unused) */
QSRC_INSTEAD_RULE, /* added by unconditional INSTEAD rule */
QSRC_QUAL_INSTEAD_RULE, /* added by conditional INSTEAD rule */
- QSRC_NON_INSTEAD_RULE /* added by non-INSTEAD rule */
+ QSRC_NON_INSTEAD_RULE, /* added by non-INSTEAD rule */
} QuerySource;
/* Sort ordering options for ORDER BY and CREATE INDEX */
SORTBY_DEFAULT,
SORTBY_ASC,
SORTBY_DESC,
- SORTBY_USING /* not allowed in CREATE INDEX ... */
+ SORTBY_USING, /* not allowed in CREATE INDEX ... */
} SortByDir;
typedef enum SortByNulls
{
SORTBY_NULLS_DEFAULT,
SORTBY_NULLS_FIRST,
- SORTBY_NULLS_LAST
+ SORTBY_NULLS_LAST,
} SortByNulls;
/* Options for [ ALL | DISTINCT ] */
{
SET_QUANTIFIER_DEFAULT,
SET_QUANTIFIER_ALL,
- SET_QUANTIFIER_DISTINCT
+ SET_QUANTIFIER_DISTINCT,
} SetQuantifier;
/*
AEXPR_BETWEEN, /* name must be "BETWEEN" */
AEXPR_NOT_BETWEEN, /* name must be "NOT BETWEEN" */
AEXPR_BETWEEN_SYM, /* name must be "BETWEEN SYMMETRIC" */
- AEXPR_NOT_BETWEEN_SYM /* name must be "NOT BETWEEN SYMMETRIC" */
+ AEXPR_NOT_BETWEEN_SYM, /* name must be "NOT BETWEEN SYMMETRIC" */
} A_Expr_Kind;
typedef struct A_Expr
ROLESPEC_CURRENT_ROLE, /* role spec is CURRENT_ROLE */
ROLESPEC_CURRENT_USER, /* role spec is CURRENT_USER */
ROLESPEC_SESSION_USER, /* role spec is SESSION_USER */
- ROLESPEC_PUBLIC /* role name is "public" */
+ ROLESPEC_PUBLIC, /* role name is "public" */
} RoleSpecType;
typedef struct RoleSpec
DEFELEM_UNSPEC, /* no action given */
DEFELEM_SET,
DEFELEM_ADD,
- DEFELEM_DROP
+ DEFELEM_DROP,
} DefElemAction;
typedef struct DefElem
{
PARTITION_STRATEGY_LIST = 'l',
PARTITION_STRATEGY_RANGE = 'r',
- PARTITION_STRATEGY_HASH = 'h'
+ PARTITION_STRATEGY_HASH = 'h',
} PartitionStrategy;
/*
{
PARTITION_RANGE_DATUM_MINVALUE = -1, /* less than any other value */
PARTITION_RANGE_DATUM_VALUE = 0, /* a specific (bounded) value */
- PARTITION_RANGE_DATUM_MAXVALUE = 1 /* greater than any other value */
+ PARTITION_RANGE_DATUM_MAXVALUE = 1, /* greater than any other value */
} PartitionRangeDatumKind;
typedef struct PartitionRangeDatum
RTE_VALUES, /* VALUES (<exprlist>), (<exprlist>), ... */
RTE_CTE, /* common table expr (WITH list element) */
RTE_NAMEDTUPLESTORE, /* tuplestore, e.g. for AFTER triggers */
- RTE_RESULT /* RTE represents an empty FROM clause; such
+ RTE_RESULT, /* RTE represents an empty FROM clause; such
* RTEs are added by the planner, they're not
* present during parsing or rewriting */
} RTEKind;
WCO_RLS_UPDATE_CHECK, /* RLS UPDATE WITH CHECK policy */
WCO_RLS_CONFLICT_CHECK, /* RLS ON CONFLICT DO UPDATE USING policy */
WCO_RLS_MERGE_UPDATE_CHECK, /* RLS MERGE UPDATE USING policy */
- WCO_RLS_MERGE_DELETE_CHECK /* RLS MERGE DELETE USING policy */
+ WCO_RLS_MERGE_DELETE_CHECK, /* RLS MERGE DELETE USING policy */
} WCOKind;
typedef struct WithCheckOption
GROUPING_SET_SIMPLE,
GROUPING_SET_ROLLUP,
GROUPING_SET_CUBE,
- GROUPING_SET_SETS
+ GROUPING_SET_SETS,
} GroupingSetKind;
typedef struct GroupingSet
{
CTEMaterializeDefault, /* no option specified */
CTEMaterializeAlways, /* MATERIALIZED */
- CTEMaterializeNever /* NOT MATERIALIZED */
+ CTEMaterializeNever, /* NOT MATERIALIZED */
} CTEMaterialize;
typedef struct CTESearchClause
SETOP_NONE = 0,
SETOP_UNION,
SETOP_INTERSECT,
- SETOP_EXCEPT
+ SETOP_EXCEPT,
} SetOperation;
typedef struct SelectStmt
OBJECT_TSTEMPLATE,
OBJECT_TYPE,
OBJECT_USER_MAPPING,
- OBJECT_VIEW
+ OBJECT_VIEW,
} ObjectType;
/* ----------------------
typedef enum DropBehavior
{
DROP_RESTRICT, /* drop fails if any dependent objects */
- DROP_CASCADE /* remove dependent objects too */
+ DROP_CASCADE, /* remove dependent objects too */
} DropBehavior;
/* ----------------------
AT_AddIdentity, /* ADD IDENTITY */
AT_SetIdentity, /* SET identity column options */
AT_DropIdentity, /* DROP IDENTITY */
- AT_ReAddStatistics /* internal to commands/tablecmds.c */
+ AT_ReAddStatistics, /* internal to commands/tablecmds.c */
} AlterTableType;
typedef struct ReplicaIdentityStmt
{
ACL_TARGET_OBJECT, /* grant on specific named object(s) */
ACL_TARGET_ALL_IN_SCHEMA, /* grant on all objects in given schema(s) */
- ACL_TARGET_DEFAULTS /* ALTER DEFAULT PRIVILEGES */
+ ACL_TARGET_DEFAULTS, /* ALTER DEFAULT PRIVILEGES */
} GrantTargetType;
typedef struct GrantStmt
VAR_SET_CURRENT, /* SET var FROM CURRENT */
VAR_SET_MULTI, /* special case for SET TRANSACTION ... */
VAR_RESET, /* RESET var */
- VAR_RESET_ALL /* RESET ALL */
+ VAR_RESET_ALL, /* RESET ALL */
} VariableSetKind;
typedef struct VariableSetStmt
CONSTR_ATTR_DEFERRABLE, /* attributes for previous constraint node */
CONSTR_ATTR_NOT_DEFERRABLE,
CONSTR_ATTR_DEFERRED,
- CONSTR_ATTR_IMMEDIATE
+ CONSTR_ATTR_IMMEDIATE,
} ConstrType;
/* Foreign key action codes */
{
FDW_IMPORT_SCHEMA_ALL, /* all relations wanted */
FDW_IMPORT_SCHEMA_LIMIT_TO, /* include only listed tables in import */
- FDW_IMPORT_SCHEMA_EXCEPT /* exclude listed tables from import */
+ FDW_IMPORT_SCHEMA_EXCEPT, /* exclude listed tables from import */
} ImportForeignSchemaType;
typedef struct ImportForeignSchemaStmt
{
ROLESTMT_ROLE,
ROLESTMT_USER,
- ROLESTMT_GROUP
+ ROLESTMT_GROUP,
} RoleStmtType;
typedef struct CreateRoleStmt
FETCH_BACKWARD,
/* for these, howMany indicates a position; only one row is fetched */
FETCH_ABSOLUTE,
- FETCH_RELATIVE
+ FETCH_RELATIVE,
} FetchDirection;
#define FETCH_ALL LONG_MAX
FUNC_PARAM_VARIADIC = 'v', /* variadic (always input) */
FUNC_PARAM_TABLE = 't', /* table function output column */
/* this is not used in pg_proc: */
- FUNC_PARAM_DEFAULT = 'd' /* default; effectively same as IN */
+ FUNC_PARAM_DEFAULT = 'd', /* default; effectively same as IN */
} FunctionParameterMode;
typedef struct FunctionParameter
TRANS_STMT_ROLLBACK_TO,
TRANS_STMT_PREPARE,
TRANS_STMT_COMMIT_PREPARED,
- TRANS_STMT_ROLLBACK_PREPARED
+ TRANS_STMT_ROLLBACK_PREPARED,
} TransactionStmtKind;
typedef struct TransactionStmt
{
NO_CHECK_OPTION,
LOCAL_CHECK_OPTION,
- CASCADED_CHECK_OPTION
+ CASCADED_CHECK_OPTION,
} ViewCheckOption;
typedef struct ViewStmt
DISCARD_ALL,
DISCARD_PLANS,
DISCARD_SEQUENCES,
- DISCARD_TEMP
+ DISCARD_TEMP,
} DiscardMode;
typedef struct DiscardStmt
REINDEX_OBJECT_TABLE, /* table or materialized view */
REINDEX_OBJECT_SCHEMA, /* schema */
REINDEX_OBJECT_SYSTEM, /* system catalogs */
- REINDEX_OBJECT_DATABASE /* database */
+ REINDEX_OBJECT_DATABASE, /* database */
} ReindexObjectType;
typedef struct ReindexStmt
ALTER_TSCONFIG_ALTER_MAPPING_FOR_TOKEN,
ALTER_TSCONFIG_REPLACE_DICT,
ALTER_TSCONFIG_REPLACE_DICT_FOR_TOKEN,
- ALTER_TSCONFIG_DROP_MAPPING
+ ALTER_TSCONFIG_DROP_MAPPING,
} AlterTSConfigType;
typedef struct AlterTSConfigurationStmt
PUBLICATIONOBJ_TABLES_IN_SCHEMA, /* All tables in schema */
PUBLICATIONOBJ_TABLES_IN_CUR_SCHEMA, /* All tables in first element of
* search_path */
- PUBLICATIONOBJ_CONTINUATION /* Continuation of previous type */
+ PUBLICATIONOBJ_CONTINUATION, /* Continuation of previous type */
} PublicationObjSpecType;
typedef struct PublicationObjSpec
{
AP_AddObjects, /* add objects to publication */
AP_DropObjects, /* remove objects from publication */
- AP_SetObjects /* set list of objects */
+ AP_SetObjects, /* set list of objects */
} AlterPublicationAction;
typedef struct AlterPublicationStmt
ALTER_SUBSCRIPTION_DROP_PUBLICATION,
ALTER_SUBSCRIPTION_REFRESH,
ALTER_SUBSCRIPTION_ENABLED,
- ALTER_SUBSCRIPTION_SKIP
+ ALTER_SUBSCRIPTION_SKIP,
} AlterSubscriptionType;
typedef struct AlterSubscriptionStmt
UPPERREL_PARTIAL_DISTINCT, /* result of partial "SELECT DISTINCT", if any */
UPPERREL_DISTINCT, /* result of "SELECT DISTINCT", if any */
UPPERREL_ORDERED, /* result of ORDER BY, if any */
- UPPERREL_FINAL /* result of any remaining top-level actions */
+ UPPERREL_FINAL, /* result of any remaining top-level actions */
/* NB: UPPERREL_FINAL must be last enum entry; it's used to size arrays */
} UpperRelationKind;
RELOPT_OTHER_MEMBER_REL,
RELOPT_OTHER_JOINREL,
RELOPT_UPPER_REL,
- RELOPT_OTHER_UPPER_REL
+ RELOPT_OTHER_UPPER_REL,
} RelOptKind;
/*
{
VOLATILITY_UNKNOWN = 0,
VOLATILITY_VOLATILE,
- VOLATILITY_NOVOLATILE
+ VOLATILITY_NOVOLATILE,
} VolatileFunctionStatus;
/*
{
UNIQUE_PATH_NOOP, /* input is known unique already */
UNIQUE_PATH_HASH, /* use hashing */
- UNIQUE_PATH_SORT /* use sorting */
+ UNIQUE_PATH_SORT, /* use sorting */
} UniquePathMethod;
typedef struct UniquePath
{
PARTITIONWISE_AGGREGATE_NONE,
PARTITIONWISE_AGGREGATE_FULL,
- PARTITIONWISE_AGGREGATE_PARTIAL
+ PARTITIONWISE_AGGREGATE_PARTIAL,
} PartitionwiseAggregateType;
/*
{
SUBQUERY_SCAN_UNKNOWN,
SUBQUERY_SCAN_TRIVIAL,
- SUBQUERY_SCAN_NONTRIVIAL
+ SUBQUERY_SCAN_NONTRIVIAL,
} SubqueryScanStatus;
typedef struct SubqueryScan
ROW_MARK_SHARE, /* obtain shared tuple lock */
ROW_MARK_KEYSHARE, /* obtain keyshare tuple lock */
ROW_MARK_REFERENCE, /* just fetch the TID, don't lock it */
- ROW_MARK_COPY /* physically copy the row value */
+ ROW_MARK_COPY, /* physically copy the row value */
} RowMarkType;
#define RowMarkRequiresRowShareLock(marktype) ((marktype) <= ROW_MARK_KEYSHARE)
typedef enum PartitionPruneCombineOp
{
PARTPRUNE_COMBINE_UNION,
- PARTPRUNE_COMBINE_INTERSECT
+ PARTPRUNE_COMBINE_INTERSECT,
} PartitionPruneCombineOp;
typedef struct PartitionPruneStepCombine
MONOTONICFUNC_NONE = 0,
MONOTONICFUNC_INCREASING = (1 << 0),
MONOTONICFUNC_DECREASING = (1 << 1),
- MONOTONICFUNC_BOTH = MONOTONICFUNC_INCREASING | MONOTONICFUNC_DECREASING
+ MONOTONICFUNC_BOTH = MONOTONICFUNC_INCREASING | MONOTONICFUNC_DECREASING,
} MonotonicFunction;
#endif /* PLANNODES_H */
ONCOMMIT_NOOP, /* No ON COMMIT clause (do nothing) */
ONCOMMIT_PRESERVE_ROWS, /* ON COMMIT PRESERVE ROWS (do nothing) */
ONCOMMIT_DELETE_ROWS, /* ON COMMIT DELETE ROWS */
- ONCOMMIT_DROP /* ON COMMIT DROP */
+ ONCOMMIT_DROP, /* ON COMMIT DROP */
} OnCommitAction;
/*
PARAM_EXTERN,
PARAM_EXEC,
PARAM_SUBLINK,
- PARAM_MULTIEXPR
+ PARAM_MULTIEXPR,
} ParamKind;
typedef struct Param
COERCION_IMPLICIT, /* coercion in context of expression */
COERCION_ASSIGNMENT, /* coercion in context of assignment */
COERCION_PLPGSQL, /* if no assignment cast, use CoerceViaIO */
- COERCION_EXPLICIT /* explicit cast operation */
+ COERCION_EXPLICIT, /* explicit cast operation */
} CoercionContext;
/*
COERCE_EXPLICIT_CALL, /* display as a function call */
COERCE_EXPLICIT_CAST, /* display as an explicit cast */
COERCE_IMPLICIT_CAST, /* implicit cast, so hide it */
- COERCE_SQL_SYNTAX /* display with SQL-mandated special syntax */
+ COERCE_SQL_SYNTAX, /* display with SQL-mandated special syntax */
} CoercionForm;
/*
EXPR_SUBLINK,
MULTIEXPR_SUBLINK,
ARRAY_SUBLINK,
- CTE_SUBLINK /* for SubPlans only */
+ CTE_SUBLINK, /* for SubPlans only */
} SubLinkType;
ROWCOMPARE_EQ = 3, /* BTEqualStrategyNumber */
ROWCOMPARE_GE = 4, /* BTGreaterEqualStrategyNumber */
ROWCOMPARE_GT = 5, /* BTGreaterStrategyNumber */
- ROWCOMPARE_NE = 6 /* no such btree strategy */
+ ROWCOMPARE_NE = 6, /* no such btree strategy */
} RowCompareType;
typedef struct RowCompareExpr
SVFOP_USER,
SVFOP_SESSION_USER,
SVFOP_CURRENT_CATALOG,
- SVFOP_CURRENT_SCHEMA
+ SVFOP_CURRENT_SCHEMA,
} SQLValueFunctionOp;
typedef struct SQLValueFunction
IS_XMLPI, /* XMLPI(name [, args]) */
IS_XMLROOT, /* XMLROOT(xml, version, standalone) */
IS_XMLSERIALIZE, /* XMLSERIALIZE(is_document, xmlval, indent) */
- IS_DOCUMENT /* xmlval IS DOCUMENT */
+ IS_DOCUMENT, /* xmlval IS DOCUMENT */
} XmlExprOp;
typedef enum XmlOptionType
{
XMLOPTION_DOCUMENT,
- XMLOPTION_CONTENT
+ XMLOPTION_CONTENT,
} XmlOptionType;
typedef struct XmlExpr
{
JS_FORMAT_DEFAULT, /* unspecified */
JS_FORMAT_JSON, /* FORMAT JSON [ENCODING ...] */
- JS_FORMAT_JSONB /* implicit internal format for RETURNING
+ JS_FORMAT_JSONB, /* implicit internal format for RETURNING
* jsonb */
} JsonFormatType;
JSCTOR_JSON_ARRAYAGG = 4,
JSCTOR_JSON_PARSE = 5,
JSCTOR_JSON_SCALAR = 6,
- JSCTOR_JSON_SERIALIZE = 7
+ JSCTOR_JSON_SERIALIZE = 7,
} JsonConstructorType;
/*
JS_TYPE_ANY, /* IS JSON [VALUE] */
JS_TYPE_OBJECT, /* IS JSON OBJECT */
JS_TYPE_ARRAY, /* IS JSON ARRAY */
- JS_TYPE_SCALAR /* IS JSON SCALAR */
+ JS_TYPE_SCALAR, /* IS JSON SCALAR */
} JsonValueType;
/*
COMPUTE_QUERY_ID_OFF,
COMPUTE_QUERY_ID_ON,
COMPUTE_QUERY_ID_AUTO,
- COMPUTE_QUERY_ID_REGRESS
+ COMPUTE_QUERY_ID_REGRESS,
};
/* GUC parameters */
typedef enum ReplicationKind
{
REPLICATION_KIND_PHYSICAL,
- REPLICATION_KIND_LOGICAL
+ REPLICATION_KIND_LOGICAL,
} ReplicationKind;
{
CONSTRAINT_EXCLUSION_OFF, /* do not use c_e */
CONSTRAINT_EXCLUSION_ON, /* apply c_e to all rels */
- CONSTRAINT_EXCLUSION_PARTITION /* apply c_e to otherrels only */
+ CONSTRAINT_EXCLUSION_PARTITION, /* apply c_e to otherrels only */
} ConstraintExclusionType;
{
DEBUG_PARALLEL_OFF,
DEBUG_PARALLEL_ON,
- DEBUG_PARALLEL_REGRESS
+ DEBUG_PARALLEL_REGRESS,
} DebugParallelMode;
/* GUC parameters */
PATHKEYS_EQUAL, /* pathkeys are identical */
PATHKEYS_BETTER1, /* pathkey 1 is a superset of pathkey 2 */
PATHKEYS_BETTER2, /* vice versa */
- PATHKEYS_DIFFERENT /* neither pathkey includes the other */
+ PATHKEYS_DIFFERENT, /* neither pathkey includes the other */
} PathKeysComparison;
extern PathKeysComparison compare_pathkeys(List *keys1, List *keys2);
COERCION_PATH_FUNC, /* apply the specified coercion function */
COERCION_PATH_RELABELTYPE, /* binary-compatible cast, no function */
COERCION_PATH_ARRAYCOERCE, /* need an ArrayCoerceExpr node */
- COERCION_PATH_COERCEVIAIO /* need a CoerceViaIO node */
+ COERCION_PATH_COERCEVIAIO, /* need a CoerceViaIO node */
} CoercionPathType;
FUNCDETAIL_PROCEDURE, /* found a matching procedure */
FUNCDETAIL_AGGREGATE, /* found a matching aggregate function */
FUNCDETAIL_WINDOWFUNC, /* found a matching window function */
- FUNCDETAIL_COERCION /* it's a type coercion request */
+ FUNCDETAIL_COERCION, /* it's a type coercion request */
} FuncDetailCode;
RAW_PARSE_PLPGSQL_EXPR,
RAW_PARSE_PLPGSQL_ASSIGN1,
RAW_PARSE_PLPGSQL_ASSIGN2,
- RAW_PARSE_PLPGSQL_ASSIGN3
+ RAW_PARSE_PLPGSQL_ASSIGN3,
} RawParseMode;
/* Values for the backslash_quote GUC */
{
BACKSLASH_QUOTE_OFF,
BACKSLASH_QUOTE_ON,
- BACKSLASH_QUOTE_SAFE_ENCODING
+ BACKSLASH_QUOTE_SAFE_ENCODING,
} BackslashQuoteType;
/* GUC variables in scan.l (every one of these is a bad idea :-() */
{
TRACK_FUNC_OFF,
TRACK_FUNC_PL,
- TRACK_FUNC_ALL
+ TRACK_FUNC_ALL,
} TrackFunctionsLevel;
typedef enum PgStat_FetchConsistency
DISCONNECT_NORMAL,
DISCONNECT_CLIENT_EOF,
DISCONNECT_FATAL,
- DISCONNECT_KILLED
+ DISCONNECT_KILLED,
} SessionEndType;
/* ----------
{
TAR_OK = 0,
TAR_NAME_TOO_LONG,
- TAR_SYMLINK_TOO_LONG
+ TAR_SYMLINK_TOO_LONG,
};
/*
TAR_OFFSET_GNAME = 297, /* 32 byte string */
TAR_OFFSET_DEVMAJOR = 329, /* 8 byte tar number */
TAR_OFFSET_DEVMINOR = 337, /* 8 byte tar number */
- TAR_OFFSET_PREFIX = 345 /* 155 byte string */
+ TAR_OFFSET_PREFIX = 345, /* 155 byte string */
/* last 12 bytes of the 512-byte block are unassigned */
};
{
TAR_FILETYPE_PLAIN = '0',
TAR_FILETYPE_SYMLINK = '2',
- TAR_FILETYPE_DIRECTORY = '5'
+ TAR_FILETYPE_DIRECTORY = '5',
};
extern enum tarError tarCreateHeader(char *h, const char *filename,
*/
typedef enum
{
- AVW_BRINSummarizeRange
+ AVW_BRINSummarizeRange,
} AutoVacuumWorkItemType;
{
BgWorkerStart_PostmasterStart,
BgWorkerStart_ConsistentState,
- BgWorkerStart_RecoveryFinished
+ BgWorkerStart_RecoveryFinished,
} BgWorkerStartTime;
#define BGW_DEFAULT_RESTART_INTERVAL 60
BGWH_STARTED, /* worker is running */
BGWH_NOT_YET_STARTED, /* worker hasn't been started yet */
BGWH_STOPPED, /* worker has exited */
- BGWH_POSTMASTER_DIED /* postmaster died; worker status unclear */
+ BGWH_POSTMASTER_DIED, /* postmaster died; worker status unclear */
} BgwHandleStatus;
struct BackgroundWorkerHandle;
LOGICAL_REP_MSG_STREAM_STOP = 'E',
LOGICAL_REP_MSG_STREAM_COMMIT = 'c',
LOGICAL_REP_MSG_STREAM_ABORT = 'A',
- LOGICAL_REP_MSG_STREAM_PREPARE = 'p'
+ LOGICAL_REP_MSG_STREAM_PREPARE = 'p',
} LogicalRepMsgType;
/*
typedef enum OutputPluginOutputType
{
OUTPUT_PLUGIN_BINARY_OUTPUT,
- OUTPUT_PLUGIN_TEXTUAL_OUTPUT
+ OUTPUT_PLUGIN_TEXTUAL_OUTPUT,
} OutputPluginOutputType;
/*
typedef enum
{
DEBUG_LOGICAL_REP_STREAMING_BUFFERED,
- DEBUG_LOGICAL_REP_STREAMING_IMMEDIATE
+ DEBUG_LOGICAL_REP_STREAMING_IMMEDIATE,
} DebugLogicalRepStreamingMode;
/* an individual tuple, stored in one chunk of memory */
REORDER_BUFFER_CHANGE_INTERNAL_SPEC_INSERT,
REORDER_BUFFER_CHANGE_INTERNAL_SPEC_CONFIRM,
REORDER_BUFFER_CHANGE_INTERNAL_SPEC_ABORT,
- REORDER_BUFFER_CHANGE_TRUNCATE
+ REORDER_BUFFER_CHANGE_TRUNCATE,
} ReorderBufferChangeType;
/* forward declaration */
{
RS_PERSISTENT,
RS_EPHEMERAL,
- RS_TEMPORARY
+ RS_TEMPORARY,
} ReplicationSlotPersistency;
/*
* were running at that point finished. Till we reach that we hold off
* calling any commit callbacks.
*/
- SNAPBUILD_CONSISTENT = 2
+ SNAPBUILD_CONSISTENT = 2,
} SnapBuildState;
/* forward declare so we don't have to expose the struct to the public */
WALRCV_STREAMING, /* walreceiver is streaming */
WALRCV_WAITING, /* stopped streaming, waiting for orders */
WALRCV_RESTARTING, /* asked to restart streaming */
- WALRCV_STOPPING /* requested to stop, but still running */
+ WALRCV_STOPPING, /* requested to stop, but still running */
} WalRcvState;
/* Shared memory area for management of walreceiver process */
WALRCV_OK_TUPLES, /* Query returned tuples. */
WALRCV_OK_COPY_IN, /* Query started COPY FROM. */
WALRCV_OK_COPY_OUT, /* Query started COPY TO. */
- WALRCV_OK_COPY_BOTH /* Query started COPY BOTH replication
+ WALRCV_OK_COPY_BOTH, /* Query started COPY BOTH replication
* protocol. */
} WalRcvExecStatus;
{
CRS_EXPORT_SNAPSHOT,
CRS_NOEXPORT_SNAPSHOT,
- CRS_USE_SNAPSHOT
+ CRS_USE_SNAPSHOT,
} CRSSnapshotAction;
/* global state */
WALSNDSTATE_BACKUP,
WALSNDSTATE_CATCHUP,
WALSNDSTATE_STREAMING,
- WALSNDSTATE_STOPPING
+ WALSNDSTATE_STOPPING,
} WalSndState;
/*
WORKERTYPE_UNKNOWN = 0,
WORKERTYPE_TABLESYNC,
WORKERTYPE_APPLY,
- WORKERTYPE_PARALLEL_APPLY
+ WORKERTYPE_PARALLEL_APPLY,
} LogicalRepWorkerType;
typedef struct LogicalRepWorker
{
PARALLEL_TRANS_UNKNOWN,
PARALLEL_TRANS_STARTED,
- PARALLEL_TRANS_FINISHED
+ PARALLEL_TRANS_FINISHED,
} ParallelTransState;
/*
FS_EMPTY,
FS_SERIALIZE_IN_PROGRESS,
FS_SERIALIZE_DONE,
- FS_READY
+ FS_READY,
} PartialFileSetState;
/*
{
REPLACEVARS_REPORT_ERROR, /* throw error if no match */
REPLACEVARS_CHANGE_VARNO, /* change the Var's varno, nothing else */
- REPLACEVARS_SUBSTITUTE_NULL /* replace with a NULL Const */
+ REPLACEVARS_SUBSTITUTE_NULL, /* replace with a NULL Const */
} ReplaceVarsNoMatchOption;
BAS_BULKREAD, /* Large read-only scan (hint bit updates are
* ok) */
BAS_BULKWRITE, /* Large multi-block write (e.g. COPY IN) */
- BAS_VACUUM /* VACUUM */
+ BAS_VACUUM, /* VACUUM */
} BufferAccessStrategyType;
/* Possible modes for ReadBufferExtended() */
RBM_ZERO_AND_CLEANUP_LOCK, /* Like RBM_ZERO_AND_LOCK, but locks the page
* in "cleanup" mode */
RBM_ZERO_ON_ERROR, /* Read, but return an all-zeros page on error */
- RBM_NORMAL_NO_LOG /* Don't log page as invalid during WAL
+ RBM_NORMAL_NO_LOG, /* Don't log page as invalid during WAL
* replay; otherwise same as RBM_NORMAL */
} ReadBufferMode;
DSM_OP_CREATE,
DSM_OP_ATTACH,
DSM_OP_DETACH,
- DSM_OP_DESTROY
+ DSM_OP_DESTROY,
} dsm_op;
/* Create, attach to, detach from, resize, or destroy a segment. */
XLTW_InsertIndex,
XLTW_InsertIndexUnique,
XLTW_FetchUpdated,
- XLTW_RecheckExclusionConstr
+ XLTW_RecheckExclusionConstr,
} XLTW_Oper;
extern void RelationInitLockInfo(Relation relation);
LOCKTAG_OBJECT, /* non-relation database object */
LOCKTAG_USERLOCK, /* reserved for old contrib/userlock code */
LOCKTAG_ADVISORY, /* advisory user locks */
- LOCKTAG_APPLY_TRANSACTION /* transaction being applied on a logical
+ LOCKTAG_APPLY_TRANSACTION, /* transaction being applied on a logical
* replication subscriber */
} LockTagType;
LOCKACQUIRE_NOT_AVAIL, /* lock not available, and dontWait=true */
LOCKACQUIRE_OK, /* lock successfully acquired */
LOCKACQUIRE_ALREADY_HELD, /* incremented count for lock already held */
- LOCKACQUIRE_ALREADY_CLEAR /* incremented count for lock already clear */
+ LOCKACQUIRE_ALREADY_CLEAR, /* incremented count for lock already clear */
} LockAcquireResult;
/* Deadlock states identified by DeadLockCheck() */
DS_NO_DEADLOCK, /* no deadlock detected */
DS_SOFT_DEADLOCK, /* deadlock avoided by queue rearrangement */
DS_HARD_DEADLOCK, /* deadlock, no way out but ERROR */
- DS_BLOCKED_BY_AUTOVACUUM /* no deadlock; queue blocked by autovacuum
+ DS_BLOCKED_BY_AUTOVACUUM, /* no deadlock; queue blocked by autovacuum
* worker */
} DeadLockState;
{
LW_EXCLUSIVE,
LW_SHARED,
- LW_WAIT_UNTIL_FREE /* A special mode used in PGPROC->lwWaitMode,
+ LW_WAIT_UNTIL_FREE, /* A special mode used in PGPROC->lwWaitMode,
* when waiting for lock to become free. Not
* to be used as LWLockAcquire argument */
} LWLockMode;
LWTRANCHE_PGSTATS_DATA,
LWTRANCHE_LAUNCHER_DSA,
LWTRANCHE_LAUNCHER_HASH,
- LWTRANCHE_FIRST_USER_DEFINED
+ LWTRANCHE_FIRST_USER_DEFINED,
} BuiltinTrancheIds;
/*
HUGE_PAGES_OFF,
HUGE_PAGES_ON,
HUGE_PAGES_TRY, /* only for huge_pages */
- HUGE_PAGES_UNKNOWN /* only for huge_pages_status */
+ HUGE_PAGES_UNKNOWN, /* only for huge_pages_status */
} HugePagesType;
/* Possible values for shared_memory_type */
{
SHMEM_TYPE_WINDOWS,
SHMEM_TYPE_SYSV,
- SHMEM_TYPE_MMAP
+ SHMEM_TYPE_MMAP,
} PGShmemType;
#ifndef WIN32
{
PMQUIT_NOT_SENT = 0, /* postmaster hasn't sent SIGQUIT */
PMQUIT_FOR_CRASH, /* some other backend bought the farm */
- PMQUIT_FOR_STOP /* immediate stop was commanded */
+ PMQUIT_FOR_STOP, /* immediate stop was commanded */
} QuitSignalReason;
/* PMSignalData is an opaque struct, details known only within pmsignal.c */
{
PREDLOCKTAG_RELATION,
PREDLOCKTAG_PAGE,
- PREDLOCKTAG_TUPLE
+ PREDLOCKTAG_TUPLE,
/* TODO SSI: Other types may be needed for index locking */
} PredicateLockTargetType;
typedef enum TwoPhasePredicateRecordType
{
TWOPHASEPREDICATERECORD_XACT,
- TWOPHASEPREDICATERECORD_LOCK
+ TWOPHASEPREDICATERECORD_LOCK,
} TwoPhasePredicateRecordType;
/*
typedef enum
{
- PROCSIGNAL_BARRIER_SMGRRELEASE /* ask smgr to close files */
+ PROCSIGNAL_BARRIER_SMGRRELEASE, /* ask smgr to close files */
} ProcSignalBarrierType;
/*
{
SHM_MQ_SUCCESS, /* Sent or received a message. */
SHM_MQ_WOULD_BLOCK, /* Not completed; retry later. */
- SHM_MQ_DETACHED /* Other process has detached queue. */
+ SHM_MQ_DETACHED, /* Other process has detached queue. */
} shm_mq_result;
/*
SYNC_REQUEST, /* schedule a call of sync function */
SYNC_UNLINK_REQUEST, /* schedule a call of unlink function */
SYNC_FORGET_REQUEST, /* forget all calls for a tag */
- SYNC_FILTER_REQUEST /* forget all calls satisfying match fn */
+ SYNC_FILTER_REQUEST, /* forget all calls satisfying match fn */
} SyncRequestType;
/*
SYNC_HANDLER_COMMIT_TS,
SYNC_HANDLER_MULTIXACT_OFFSET,
SYNC_HANDLER_MULTIXACT_MEMBER,
- SYNC_HANDLER_NONE
+ SYNC_HANDLER_NONE,
} SyncRequestHandler;
/*
SCT_AlterOpFamily,
SCT_AlterDefaultPrivileges,
SCT_CreateOpClass,
- SCT_AlterTSConfig
+ SCT_AlterTSConfig,
} CollectedCommandType;
/*
DestCopyOut, /* results sent to COPY TO code */
DestSQLFunction, /* results sent to SQL-language func mgr */
DestTransientRel, /* results sent to transient relation */
- DestTupleQueue /* results sent to tuple queue */
+ DestTupleQueue, /* results sent to tuple queue */
} CommandDest;
/* ----------------
LOGSTMT_NONE, /* log no statements */
LOGSTMT_DDL, /* log data definition statements */
LOGSTMT_MOD, /* log modification statements, plus DDL */
- LOGSTMT_ALL /* log all statements */
+ LOGSTMT_ALL, /* log all statements */
} LogStmtLevel;
extern PGDLLIMPORT int log_statement;
PROCESS_UTILITY_QUERY, /* a complete query, but not toplevel */
PROCESS_UTILITY_QUERY_NONATOMIC, /* a complete query, nonatomic
* execution context */
- PROCESS_UTILITY_SUBCOMMAND /* a portion of a query */
+ PROCESS_UTILITY_SUBCOMMAND, /* a portion of a query */
} ProcessUtilityContext;
/* Info needed when recursing from ALTER TABLE */
{
FM_CHAR, /* one character (like ispell) */
FM_LONG, /* two characters */
- FM_NUM /* number, >= 0 and < 65536 */
+ FM_NUM, /* number, >= 0 and < 65536 */
} FlagMode;
/*
{
TS_NO, /* definitely no match */
TS_YES, /* definitely does match */
- TS_MAYBE /* can't verify match for lack of pos data */
+ TS_MAYBE, /* can't verify match for lack of pos data */
} TSTernaryValue;
/*
typedef enum
{
ACLMASK_ALL, /* normal case: compute all bits */
- ACLMASK_ANY /* return when result is known nonzero */
+ ACLMASK_ANY, /* return when result is known nonzero */
} AclMaskHow;
/* result codes for pg_*_aclcheck */
{
ACLCHECK_OK = 0,
ACLCHECK_NO_PRIV,
- ACLCHECK_NOT_OWNER
+ ACLCHECK_NOT_OWNER,
} AclResult;
PROGRESS_COMMAND_CLUSTER,
PROGRESS_COMMAND_CREATE_INDEX,
PROGRESS_COMMAND_BASEBACKUP,
- PROGRESS_COMMAND_COPY
+ PROGRESS_COMMAND_COPY,
} ProgressCommandType;
#define PGSTAT_NUM_PROGRESS_PARAM 20
STATE_IDLEINTRANSACTION,
STATE_FASTPATH,
STATE_IDLEINTRANSACTION_ABORTED,
- STATE_DISABLED
+ STATE_DISABLED,
} BackendState;
typedef enum
{
BYTEA_OUTPUT_ESCAPE,
- BYTEA_OUTPUT_HEX
+ BYTEA_OUTPUT_HEX,
} ByteaOutputType;
extern PGDLLIMPORT int bytea_output; /* ByteaOutputType, but int for GUC
{
PGERROR_TERSE, /* single-line error messages */
PGERROR_DEFAULT, /* recommended style */
- PGERROR_VERBOSE /* all the facts, ma'am */
+ PGERROR_VERBOSE, /* all the facts, ma'am */
} PGErrorVerbosity;
extern PGDLLIMPORT int Log_error_verbosity;
PGC_SU_BACKEND,
PGC_BACKEND,
PGC_SUSET,
- PGC_USERSET
+ PGC_USERSET,
} GucContext;
/*
PGC_S_OVERRIDE, /* special case to forcibly set default */
PGC_S_INTERACTIVE, /* dividing line for error reporting */
PGC_S_TEST, /* test per-database or per-user setting */
- PGC_S_SESSION /* SET command */
+ PGC_S_SESSION, /* SET command */
} GucSource;
/*
/* Types of set_config_option actions */
GUC_ACTION_SET, /* regular SET command */
GUC_ACTION_LOCAL, /* SET LOCAL command */
- GUC_ACTION_SAVE /* function SET option, or temp assignment */
+ GUC_ACTION_SAVE, /* function SET option, or temp assignment */
} GucAction;
#define GUC_QUALIFIER_SEPARATOR '.'
PGC_INT,
PGC_REAL,
PGC_STRING,
- PGC_ENUM
+ PGC_ENUM,
};
union config_var_val
ERROR_HANDLING_OPTIONS,
PRESET_OPTIONS,
CUSTOM_OPTIONS,
- DEVELOPER_OPTIONS
+ DEVELOPER_OPTIONS,
};
/*
GUC_SAVE, /* entry caused by function SET option */
GUC_SET, /* entry caused by plain SET command */
GUC_LOCAL, /* entry caused by SET LOCAL command */
- GUC_SET_LOCAL /* entry caused by SET then SET LOCAL */
+ GUC_SET_LOCAL, /* entry caused by SET then SET LOCAL */
} GucStackState;
typedef struct guc_stack
HASH_FIND,
HASH_ENTER,
HASH_REMOVE,
- HASH_ENTER_NULL
+ HASH_ENTER_NULL,
} HASHACTION;
/* hash_seq status (should be considered an opaque type by callers) */
WJB_BEGIN_ARRAY,
WJB_END_ARRAY,
WJB_BEGIN_OBJECT,
- WJB_END_OBJECT
+ WJB_END_OBJECT,
} JsonbIteratorToken;
/* Strategy numbers for GIN index opclasses */
JBI_ARRAY_ELEM,
JBI_OBJECT_START,
JBI_OBJECT_KEY,
- JBI_OBJECT_VALUE
+ JBI_OBJECT_VALUE,
} JsonbIterState;
typedef struct JsonbIterator
IOFunc_input,
IOFunc_output,
IOFunc_receive,
- IOFunc_send
+ IOFunc_send,
} IOFuncSelector;
/* Flag bits for get_attstatsslot */
MCTX_GENERATION_ID,
MCTX_SLAB_ID,
MCTX_ALIGNED_REDIRECT_ID,
- MCTX_UNUSED4_ID /* 111 occurs in wipe_mem'd memory */
+ MCTX_UNUSED4_ID, /* 111 occurs in wipe_mem'd memory */
} MemoryContextMethodID;
/*
{
PLAN_CACHE_MODE_AUTO,
PLAN_CACHE_MODE_FORCE_GENERIC_PLAN,
- PLAN_CACHE_MODE_FORCE_CUSTOM_PLAN
+ PLAN_CACHE_MODE_FORCE_CUSTOM_PLAN,
} PlanCacheMode;
/* GUC parameter */
PORTAL_ONE_RETURNING,
PORTAL_ONE_MOD_WITH,
PORTAL_UTIL_SELECT,
- PORTAL_MULTI_QUERY
+ PORTAL_MULTI_QUERY,
} PortalStrategy;
/*
PORTAL_READY, /* PortalStart complete, can run it */
PORTAL_ACTIVE, /* portal is running (can't delete it) */
PORTAL_DONE, /* portal is finished (don't re-run it) */
- PORTAL_FAILED /* portal got error (can't re-run it) */
+ PORTAL_FAILED, /* portal got error (can't re-run it) */
} PortalStatus;
typedef struct PortalData *Portal;
typedef enum EphemeralNameRelationType
{
- ENR_NAMED_TUPLESTORE /* named tuplestore relation; e.g., deltas */
+ ENR_NAMED_TUPLESTORE, /* named tuplestore relation; e.g., deltas */
} EphemeralNameRelationType;
/*
{
STDRD_OPTION_VACUUM_INDEX_CLEANUP_AUTO = 0,
STDRD_OPTION_VACUUM_INDEX_CLEANUP_OFF,
- STDRD_OPTION_VACUUM_INDEX_CLEANUP_ON
+ STDRD_OPTION_VACUUM_INDEX_CLEANUP_ON,
} StdRdOptIndexCleanup;
typedef struct StdRdOptions
{
VIEW_OPTION_CHECK_OPTION_NOT_SET,
VIEW_OPTION_CHECK_OPTION_LOCAL,
- VIEW_OPTION_CHECK_OPTION_CASCADED
+ VIEW_OPTION_CHECK_OPTION_CASCADED,
} ViewOptCheckOption;
/*
INDEX_ATTR_BITMAP_PRIMARY_KEY,
INDEX_ATTR_BITMAP_IDENTITY_KEY,
INDEX_ATTR_BITMAP_HOT_BLOCKING,
- INDEX_ATTR_BITMAP_SUMMARIZED
+ INDEX_ATTR_BITMAP_SUMMARIZED,
} IndexAttrBitmapKind;
extern Bitmapset *RelationGetIndexAttrBitmap(Relation relation,
{
RESOURCE_RELEASE_BEFORE_LOCKS,
RESOURCE_RELEASE_LOCKS,
- RESOURCE_RELEASE_AFTER_LOCKS
+ RESOURCE_RELEASE_AFTER_LOCKS,
} ResourceReleasePhase;
/*
{
RLS_NONE,
RLS_NONE_ENV,
- RLS_ENABLED
+ RLS_ENABLED,
};
extern int check_enable_rls(Oid relid, Oid checkAsUser, bool noError);
* For visibility checks snapshot->min must have been set up with the xmin
* horizon to use.
*/
- SNAPSHOT_NON_VACUUMABLE
+ SNAPSHOT_NON_VACUUMABLE,
} SnapshotType;
typedef struct SnapshotData *Snapshot;
TYPENAMENSP,
TYPEOID,
USERMAPPINGOID,
- USERMAPPINGUSERSERVER
+ USERMAPPINGUSERSERVER,
#define SysCacheSize (USERMAPPINGUSERSERVER + 1)
};
{
TMPARAM_AFTER,
TMPARAM_AT,
- TMPARAM_EVERY
+ TMPARAM_EVERY,
} TimeoutType;
typedef struct
SORT_TYPE_TOP_N_HEAPSORT = 1 << 0,
SORT_TYPE_QUICKSORT = 1 << 1,
SORT_TYPE_EXTERNAL_SORT = 1 << 2,
- SORT_TYPE_EXTERNAL_MERGE = 1 << 3
+ SORT_TYPE_EXTERNAL_MERGE = 1 << 3,
} TuplesortMethod;
#define NUM_TUPLESORTMETHODS 4
typedef enum
{
SORT_SPACE_TYPE_DISK,
- SORT_SPACE_TYPE_MEMORY
+ SORT_SPACE_TYPE_MEMORY,
} TuplesortSpaceType;
/* Bitwise option flags for tuple sorts */
typedef enum
{
WAIT_EVENT_EXTENSION = PG_WAIT_EXTENSION,
- WAIT_EVENT_EXTENSION_FIRST_USER_DEFINED
+ WAIT_EVENT_EXTENSION_FIRST_USER_DEFINED,
} WaitEventExtension;
extern void WaitEventExtensionShmemInit(void);
XML_STANDALONE_YES,
XML_STANDALONE_NO,
XML_STANDALONE_NO_VALUE,
- XML_STANDALONE_OMITTED
+ XML_STANDALONE_OMITTED,
} XmlStandaloneType;
typedef enum
{
XMLBINARY_BASE64,
- XMLBINARY_HEX
+ XMLBINARY_HEX,
} XmlBinaryType;
typedef enum
PG_XML_STRICTNESS_LEGACY, /* ignore errors unless function result
* indicates error condition */
PG_XML_STRICTNESS_WELLFORMED, /* ignore non-parser messages */
- PG_XML_STRICTNESS_ALL /* report all notices/warnings/errors */
+ PG_XML_STRICTNESS_ALL, /* report all notices/warnings/errors */
} PgXmlStrictness;
/* struct PgXmlErrorContext is private to xml.c */
FE_SCRAM_INIT,
FE_SCRAM_NONCE_SENT,
FE_SCRAM_PROOF_SENT,
- FE_SCRAM_FINISHED
+ FE_SCRAM_FINISHED,
} fe_scram_state_enum;
typedef struct
{
PLPGSQL_NSTYPE_LABEL, /* block label */
PLPGSQL_NSTYPE_VAR, /* scalar variable */
- PLPGSQL_NSTYPE_REC /* composite variable */
+ PLPGSQL_NSTYPE_REC, /* composite variable */
} PLpgSQL_nsitem_type;
/*
{
PLPGSQL_LABEL_BLOCK, /* DECLARE/BEGIN block */
PLPGSQL_LABEL_LOOP, /* looping construct */
- PLPGSQL_LABEL_OTHER /* anything else */
+ PLPGSQL_LABEL_OTHER, /* anything else */
} PLpgSQL_label_type;
/*
PLPGSQL_DTYPE_ROW,
PLPGSQL_DTYPE_REC,
PLPGSQL_DTYPE_RECFIELD,
- PLPGSQL_DTYPE_PROMISE
+ PLPGSQL_DTYPE_PROMISE,
} PLpgSQL_datum_type;
/*
PLPGSQL_PROMISE_TG_NARGS,
PLPGSQL_PROMISE_TG_ARGV,
PLPGSQL_PROMISE_TG_EVENT,
- PLPGSQL_PROMISE_TG_TAG
+ PLPGSQL_PROMISE_TG_TAG,
} PLpgSQL_promise_type;
/*
{
PLPGSQL_TTYPE_SCALAR, /* scalar types and domains */
PLPGSQL_TTYPE_REC, /* composite types, including RECORD */
- PLPGSQL_TTYPE_PSEUDO /* pseudotypes */
+ PLPGSQL_TTYPE_PSEUDO, /* pseudotypes */
} PLpgSQL_type_type;
/*
PLPGSQL_STMT_PERFORM,
PLPGSQL_STMT_CALL,
PLPGSQL_STMT_COMMIT,
- PLPGSQL_STMT_ROLLBACK
+ PLPGSQL_STMT_ROLLBACK,
} PLpgSQL_stmt_type;
/*
PLPGSQL_RC_OK,
PLPGSQL_RC_EXIT,
PLPGSQL_RC_RETURN,
- PLPGSQL_RC_CONTINUE
+ PLPGSQL_RC_CONTINUE,
};
/*
PLPGSQL_GETDIAG_DATATYPE_NAME,
PLPGSQL_GETDIAG_MESSAGE_TEXT,
PLPGSQL_GETDIAG_TABLE_NAME,
- PLPGSQL_GETDIAG_SCHEMA_NAME
+ PLPGSQL_GETDIAG_SCHEMA_NAME,
} PLpgSQL_getdiag_kind;
/*
PLPGSQL_RAISEOPTION_CONSTRAINT,
PLPGSQL_RAISEOPTION_DATATYPE,
PLPGSQL_RAISEOPTION_TABLE,
- PLPGSQL_RAISEOPTION_SCHEMA
+ PLPGSQL_RAISEOPTION_SCHEMA,
} PLpgSQL_raise_option_type;
/*
{
PLPGSQL_RESOLVE_ERROR, /* throw error if ambiguous */
PLPGSQL_RESOLVE_VARIABLE, /* prefer plpgsql var to table column */
- PLPGSQL_RESOLVE_COLUMN /* prefer table column to plpgsql var */
+ PLPGSQL_RESOLVE_COLUMN, /* prefer table column to plpgsql var */
} PLpgSQL_resolve_option;
{
PLPGSQL_DML_TRIGGER,
PLPGSQL_EVENT_TRIGGER,
- PLPGSQL_NOT_TRIGGER
+ PLPGSQL_NOT_TRIGGER,
} PLpgSQL_trigtype;
/*
{
IDENTIFIER_LOOKUP_NORMAL, /* normal processing of var names */
IDENTIFIER_LOOKUP_DECLARE, /* In DECLARE --- don't look up names */
- IDENTIFIER_LOOKUP_EXPR /* In SQL expression --- special case */
+ IDENTIFIER_LOOKUP_EXPR, /* In SQL expression --- special case */
} IdentifierLookup;
extern IdentifierLookup plpgsql_IdentifierLookup;
RELATIVE_PATH_INIT, /* At start of a relative path */
RELATIVE_WITH_N_DEPTH, /* We collected 'pathdepth' directories in a
* relative path */
- RELATIVE_WITH_PARENT_REF /* Relative path containing only double-dots */
+ RELATIVE_WITH_PARENT_REF, /* Relative path containing only double-dots */
} canonicalize_state;
/*
{
PSB_ONCE, /* force step to wait once */
PSB_OTHER_STEP, /* wait for another step to complete first */
- PSB_NUM_NOTICES /* wait for N notices from another session */
+ PSB_NUM_NOTICES, /* wait for N notices from another session */
} PermutationStepBlockerType;
typedef struct
typedef enum DummyAmEnum
{
DUMMY_AM_ENUM_ONE,
- DUMMY_AM_ENUM_TWO
+ DUMMY_AM_ENUM_TWO,
} DummyAmEnum;
/* Dummy index options */
BI_INSERT_ROWS,
BI_COMMIT_TX,
BI_SYNC,
- BI_DONE
+ BI_DONE,
};
static void
NOTE_END,
TEST_STATUS,
PLAN,
- NONE
+ NONE,
} TAPtype;
/* options settable from command line */
{
JULIAN_DAY, /* Jn = Julian day */
DAY_OF_YEAR, /* n = day of year */
- MONTH_NTH_DAY_OF_WEEK /* Mm.n.d = month, week, day of week */
+ MONTH_NTH_DAY_OF_WEEK, /* Mm.n.d = month, week, day of week */
};
struct rule
projects / users / c2main / postgres.git / commitdiff