pub type AclMode = u32;
pub type Selectivity = f64;
pub type Cost = f64;
pub type AttrNumber = i16;
pub type Pointer = char;
pub type Index = u32;
pub type Offset = i32;
pub type regproc = Oid;
pub type RegProcedure = regproc;
pub type TransactionId = u32;
pub type LocalTransactionId = u32;
pub type SubTransactionId = u32;
pub type MultiXactId = TransactionId;
pub type MultiXactOffset = u32;
pub type CommandId = u32;
pub type Datum = usize;
pub type Oid = u32;
pub type BlockNumber = u32;
pub type pg_wchar = u32;
#[derive(Debug, serde::Deserialize)]
pub enum A_Expr_Kind {
AEXPR_OP = 0,
AEXPR_OP_ANY = 1,
AEXPR_OP_ALL = 2,
AEXPR_DISTINCT = 3,
AEXPR_NOT_DISTINCT = 4,
AEXPR_NULLIF = 5,
AEXPR_OF = 6,
AEXPR_IN = 7,
AEXPR_LIKE = 8,
AEXPR_ILIKE = 9,
AEXPR_SIMILAR = 10,
AEXPR_BETWEEN = 11,
AEXPR_NOT_BETWEEN = 12,
AEXPR_BETWEEN_SYM = 13,
AEXPR_NOT_BETWEEN_SYM = 14,
AEXPR_PAREN = 15,
}
#[derive(Debug, serde::Deserialize)]
pub enum AlterSubscriptionType {
ALTER_SUBSCRIPTION_OPTIONS = 0,
ALTER_SUBSCRIPTION_CONNECTION = 1,
ALTER_SUBSCRIPTION_PUBLICATION = 2,
ALTER_SUBSCRIPTION_REFRESH = 3,
ALTER_SUBSCRIPTION_ENABLED = 4,
}
#[derive(Debug, serde::Deserialize)]
pub enum AlterTSConfigType {
ALTER_TSCONFIG_ADD_MAPPING = 0,
ALTER_TSCONFIG_ALTER_MAPPING_FOR_TOKEN = 1,
ALTER_TSCONFIG_REPLACE_DICT = 2,
ALTER_TSCONFIG_REPLACE_DICT_FOR_TOKEN = 3,
ALTER_TSCONFIG_DROP_MAPPING = 4,
}
#[derive(Debug, serde::Deserialize)]
pub enum AlterTableType {
AT_AddColumn = 0,
AT_AddColumnRecurse = 1,
AT_AddColumnToView = 2,
AT_ColumnDefault = 3,
AT_CookedColumnDefault = 4,
AT_DropNotNull = 5,
AT_SetNotNull = 6,
AT_DropExpression = 7,
AT_CheckNotNull = 8,
AT_SetStatistics = 9,
AT_SetOptions = 10,
AT_ResetOptions = 11,
AT_SetStorage = 12,
AT_DropColumn = 13,
AT_DropColumnRecurse = 14,
AT_AddIndex = 15,
AT_ReAddIndex = 16,
AT_AddConstraint = 17,
AT_AddConstraintRecurse = 18,
AT_ReAddConstraint = 19,
AT_ReAddDomainConstraint = 20,
AT_AlterConstraint = 21,
AT_ValidateConstraint = 22,
AT_ValidateConstraintRecurse = 23,
AT_AddIndexConstraint = 24,
AT_DropConstraint = 25,
AT_DropConstraintRecurse = 26,
AT_ReAddComment = 27,
AT_AlterColumnType = 28,
AT_AlterColumnGenericOptions = 29,
AT_ChangeOwner = 30,
AT_ClusterOn = 31,
AT_DropCluster = 32,
AT_SetLogged = 33,
AT_SetUnLogged = 34,
AT_DropOids = 35,
AT_SetTableSpace = 36,
AT_SetRelOptions = 37,
AT_ResetRelOptions = 38,
AT_ReplaceRelOptions = 39,
AT_EnableTrig = 40,
AT_EnableAlwaysTrig = 41,
AT_EnableReplicaTrig = 42,
AT_DisableTrig = 43,
AT_EnableTrigAll = 44,
AT_DisableTrigAll = 45,
AT_EnableTrigUser = 46,
AT_DisableTrigUser = 47,
AT_EnableRule = 48,
AT_EnableAlwaysRule = 49,
AT_EnableReplicaRule = 50,
AT_DisableRule = 51,
AT_AddInherit = 52,
AT_DropInherit = 53,
AT_AddOf = 54,
AT_DropOf = 55,
AT_ReplicaIdentity = 56,
AT_EnableRowSecurity = 57,
AT_DisableRowSecurity = 58,
AT_ForceRowSecurity = 59,
AT_NoForceRowSecurity = 60,
AT_GenericOptions = 61,
AT_AttachPartition = 62,
AT_DetachPartition = 63,
AT_AddIdentity = 64,
AT_SetIdentity = 65,
AT_DropIdentity = 66,
}
#[derive(Debug, serde::Deserialize)]
pub enum CTEMaterialize {
CTEMaterializeDefault = 0,
CTEMaterializeAlways = 1,
CTEMaterializeNever = 2,
}
#[derive(Debug, serde::Deserialize)]
pub enum ClusterOption {
CLUOPT_RECHECK = 1,
CLUOPT_VERBOSE = 2,
}
#[derive(Debug, serde::Deserialize)]
pub enum ConstrType {
CONSTR_NULL = 0,
CONSTR_NOTNULL = 1,
CONSTR_DEFAULT = 2,
CONSTR_IDENTITY = 3,
CONSTR_GENERATED = 4,
CONSTR_CHECK = 5,
CONSTR_PRIMARY = 6,
CONSTR_UNIQUE = 7,
CONSTR_EXCLUSION = 8,
CONSTR_FOREIGN = 9,
CONSTR_ATTR_DEFERRABLE = 10,
CONSTR_ATTR_NOT_DEFERRABLE = 11,
CONSTR_ATTR_DEFERRED = 12,
CONSTR_ATTR_IMMEDIATE = 13,
}
#[derive(Debug, serde::Deserialize)]
pub enum DefElemAction {
DEFELEM_UNSPEC = 0,
DEFELEM_SET = 1,
DEFELEM_ADD = 2,
DEFELEM_DROP = 3,
}
#[derive(Debug, serde::Deserialize)]
pub enum DiscardMode {
DISCARD_ALL = 0,
DISCARD_PLANS = 1,
DISCARD_SEQUENCES = 2,
DISCARD_TEMP = 3,
}
#[derive(Debug, serde::Deserialize)]
pub enum DropBehavior {
DROP_RESTRICT = 0,
DROP_CASCADE = 1,
}
#[derive(Debug, serde::Deserialize)]
pub enum FetchDirection {
FETCH_FORWARD = 0,
FETCH_BACKWARD = 1,
FETCH_ABSOLUTE = 2,
FETCH_RELATIVE = 3,
}
#[derive(Debug, serde::Deserialize)]
pub enum FunctionParameterMode {
FUNC_PARAM_IN = 105,
FUNC_PARAM_OUT = 111,
FUNC_PARAM_INOUT = 98,
FUNC_PARAM_VARIADIC = 118,
FUNC_PARAM_TABLE = 116,
}
#[derive(Debug, serde::Deserialize)]
pub enum GrantTargetType {
ACL_TARGET_OBJECT = 0,
ACL_TARGET_ALL_IN_SCHEMA = 1,
ACL_TARGET_DEFAULTS = 2,
}
#[derive(Debug, serde::Deserialize)]
pub enum GroupingSetKind {
GROUPING_SET_EMPTY = 0,
GROUPING_SET_SIMPLE = 1,
GROUPING_SET_ROLLUP = 2,
GROUPING_SET_CUBE = 3,
GROUPING_SET_SETS = 4,
}
#[derive(Debug, serde::Deserialize)]
pub enum ImportForeignSchemaType {
FDW_IMPORT_SCHEMA_ALL = 0,
FDW_IMPORT_SCHEMA_LIMIT_TO = 1,
FDW_IMPORT_SCHEMA_EXCEPT = 2,
}
#[derive(Debug, serde::Deserialize)]
pub enum ObjectType {
OBJECT_ACCESS_METHOD = 0,
OBJECT_AGGREGATE = 1,
OBJECT_AMOP = 2,
OBJECT_AMPROC = 3,
OBJECT_ATTRIBUTE = 4,
OBJECT_CAST = 5,
OBJECT_COLUMN = 6,
OBJECT_COLLATION = 7,
OBJECT_CONVERSION = 8,
OBJECT_DATABASE = 9,
OBJECT_DEFAULT = 10,
OBJECT_DEFACL = 11,
OBJECT_DOMAIN = 12,
OBJECT_DOMCONSTRAINT = 13,
OBJECT_EVENT_TRIGGER = 14,
OBJECT_EXTENSION = 15,
OBJECT_FDW = 16,
OBJECT_FOREIGN_SERVER = 17,
OBJECT_FOREIGN_TABLE = 18,
OBJECT_FUNCTION = 19,
OBJECT_INDEX = 20,
OBJECT_LANGUAGE = 21,
OBJECT_LARGEOBJECT = 22,
OBJECT_MATVIEW = 23,
OBJECT_OPCLASS = 24,
OBJECT_OPERATOR = 25,
OBJECT_OPFAMILY = 26,
OBJECT_POLICY = 27,
OBJECT_PROCEDURE = 28,
OBJECT_PUBLICATION = 29,
OBJECT_PUBLICATION_REL = 30,
OBJECT_ROLE = 31,
OBJECT_ROUTINE = 32,
OBJECT_RULE = 33,
OBJECT_SCHEMA = 34,
OBJECT_SEQUENCE = 35,
OBJECT_SUBSCRIPTION = 36,
OBJECT_STATISTIC_EXT = 37,
OBJECT_TABCONSTRAINT = 38,
OBJECT_TABLE = 39,
OBJECT_TABLESPACE = 40,
OBJECT_TRANSFORM = 41,
OBJECT_TRIGGER = 42,
OBJECT_TSCONFIGURATION = 43,
OBJECT_TSDICTIONARY = 44,
OBJECT_TSPARSER = 45,
OBJECT_TSTEMPLATE = 46,
OBJECT_TYPE = 47,
OBJECT_USER_MAPPING = 48,
OBJECT_VIEW = 49,
}
#[derive(Debug, serde::Deserialize)]
pub enum OverridingKind {
OVERRIDING_NOT_SET = 0,
OVERRIDING_USER_VALUE = 1,
OVERRIDING_SYSTEM_VALUE = 2,
}
#[derive(Debug, serde::Deserialize)]
pub enum PartitionRangeDatumKind {
PARTITION_RANGE_DATUM_MINVALUE,
PARTITION_RANGE_DATUM_VALUE,
PARTITION_RANGE_DATUM_MAXVALUE,
}
#[derive(Debug, serde::Deserialize)]
pub enum QuerySource {
QSRC_ORIGINAL = 0,
QSRC_PARSER = 1,
QSRC_INSTEAD_RULE = 2,
QSRC_QUAL_INSTEAD_RULE = 3,
QSRC_NON_INSTEAD_RULE = 4,
}
#[derive(Debug, serde::Deserialize)]
pub enum RTEKind {
RTE_RELATION = 0,
RTE_SUBQUERY = 1,
RTE_JOIN = 2,
RTE_FUNCTION = 3,
RTE_TABLEFUNC = 4,
RTE_VALUES = 5,
RTE_CTE = 6,
RTE_NAMEDTUPLESTORE = 7,
RTE_RESULT = 8,
}
#[derive(Debug, serde::Deserialize)]
pub enum ReindexObjectType {
REINDEX_OBJECT_INDEX = 0,
REINDEX_OBJECT_TABLE = 1,
REINDEX_OBJECT_SCHEMA = 2,
REINDEX_OBJECT_SYSTEM = 3,
REINDEX_OBJECT_DATABASE = 4,
}
#[derive(Debug, serde::Deserialize)]
pub enum RoleSpecType {
ROLESPEC_CSTRING = 0,
ROLESPEC_CURRENT_USER = 1,
ROLESPEC_SESSION_USER = 2,
ROLESPEC_PUBLIC = 3,
}
#[derive(Debug, serde::Deserialize)]
pub enum RoleStmtType {
ROLESTMT_ROLE = 0,
ROLESTMT_USER = 1,
ROLESTMT_GROUP = 2,
}
#[derive(Debug, serde::Deserialize)]
pub enum SetOperation {
SETOP_NONE = 0,
SETOP_UNION = 1,
SETOP_INTERSECT = 2,
SETOP_EXCEPT = 3,
}
#[derive(Debug, serde::Deserialize)]
pub enum SortByDir {
SORTBY_DEFAULT = 0,
SORTBY_ASC = 1,
SORTBY_DESC = 2,
SORTBY_USING = 3,
}
#[derive(Debug, serde::Deserialize)]
pub enum SortByNulls {
SORTBY_NULLS_DEFAULT = 0,
SORTBY_NULLS_FIRST = 1,
SORTBY_NULLS_LAST = 2,
}
#[derive(Debug, serde::Deserialize)]
pub enum TableLikeOption {
CREATE_TABLE_LIKE_COMMENTS = 1,
CREATE_TABLE_LIKE_CONSTRAINTS = 2,
CREATE_TABLE_LIKE_DEFAULTS = 4,
CREATE_TABLE_LIKE_GENERATED = 8,
CREATE_TABLE_LIKE_IDENTITY = 16,
CREATE_TABLE_LIKE_INDEXES = 32,
CREATE_TABLE_LIKE_STATISTICS = 64,
CREATE_TABLE_LIKE_STORAGE = 128,
CREATE_TABLE_LIKE_ALL = 2147483647,
}
#[derive(Debug, serde::Deserialize)]
pub enum TransactionStmtKind {
TRANS_STMT_BEGIN = 0,
TRANS_STMT_START = 1,
TRANS_STMT_COMMIT = 2,
TRANS_STMT_ROLLBACK = 3,
TRANS_STMT_SAVEPOINT = 4,
TRANS_STMT_RELEASE = 5,
TRANS_STMT_ROLLBACK_TO = 6,
TRANS_STMT_PREPARE = 7,
TRANS_STMT_COMMIT_PREPARED = 8,
TRANS_STMT_ROLLBACK_PREPARED = 9,
}
#[derive(Debug, serde::Deserialize)]
pub enum VariableSetKind {
VAR_SET_VALUE = 0,
VAR_SET_DEFAULT = 1,
VAR_SET_CURRENT = 2,
VAR_SET_MULTI = 3,
VAR_RESET = 4,
VAR_RESET_ALL = 5,
}
#[derive(Debug, serde::Deserialize)]
pub enum ViewCheckOption {
NO_CHECK_OPTION = 0,
LOCAL_CHECK_OPTION = 1,
CASCADED_CHECK_OPTION = 2,
}
#[derive(Debug, serde::Deserialize)]
pub enum WCOKind {
WCO_VIEW_CHECK = 0,
WCO_RLS_INSERT_CHECK = 1,
WCO_RLS_UPDATE_CHECK = 2,
WCO_RLS_CONFLICT_CHECK = 3,
}
#[derive(Debug, serde::Deserialize)]
pub enum BoolExprType {
AND_EXPR = 0,
OR_EXPR,
NOT_EXPR,
}
#[derive(Debug, serde::Deserialize)]
pub enum BoolTestType {
IS_TRUE = 0,
IS_NOT_TRUE,
IS_FALSE,
IS_NOT_FALSE,
IS_UNKNOWN,
IS_NOT_UNKNOWN,
}
#[derive(Debug, serde::Deserialize)]
pub enum CoercionContext {
COERCION_IMPLICIT = 0,
COERCION_ASSIGNMENT = 1,
COERCION_EXPLICIT = 2,
}
#[derive(Debug, serde::Deserialize)]
pub enum CoercionForm {
COERCE_EXPLICIT_CALL = 0,
COERCE_EXPLICIT_CAST = 1,
COERCE_IMPLICIT_CAST = 2,
}
#[derive(Debug, serde::Deserialize)]
pub enum MinMaxOp {
IS_GREATEST = 0,
IS_LEAST = 1,
}
#[derive(Debug, serde::Deserialize)]
pub enum NullTestType {
IS_NULL = 0,
IS_NOT_NULL,
}
#[derive(Debug, serde::Deserialize)]
pub enum OnCommitAction {
ONCOMMIT_NOOP = 0,
ONCOMMIT_PRESERVE_ROWS = 1,
ONCOMMIT_DELETE_ROWS = 2,
ONCOMMIT_DROP = 3,
}
#[derive(Debug, serde::Deserialize)]
pub enum ParamKind {
PARAM_EXTERN = 0,
PARAM_EXEC = 1,
PARAM_SUBLINK = 2,
PARAM_MULTIEXPR = 3,
}
#[derive(Debug, serde::Deserialize)]
pub enum RowCompareType {
ROWCOMPARE_LT = 1,
ROWCOMPARE_LE = 2,
ROWCOMPARE_EQ = 3,
ROWCOMPARE_GE = 4,
ROWCOMPARE_GT = 5,
ROWCOMPARE_NE = 6,
}
#[derive(Debug, serde::Deserialize)]
pub enum SQLValueFunctionOp {
SVFOP_CURRENT_DATE = 0,
SVFOP_CURRENT_TIME = 1,
SVFOP_CURRENT_TIME_N = 2,
SVFOP_CURRENT_TIMESTAMP = 3,
SVFOP_CURRENT_TIMESTAMP_N = 4,
SVFOP_LOCALTIME = 5,
SVFOP_LOCALTIME_N = 6,
SVFOP_LOCALTIMESTAMP = 7,
SVFOP_LOCALTIMESTAMP_N = 8,
SVFOP_CURRENT_ROLE = 9,
SVFOP_CURRENT_USER = 10,
SVFOP_USER = 11,
SVFOP_SESSION_USER = 12,
SVFOP_CURRENT_CATALOG = 13,
SVFOP_CURRENT_SCHEMA = 14,
}
#[derive(Debug, serde::Deserialize)]
pub enum SubLinkType {
EXISTS_SUBLINK = 0,
ALL_SUBLINK = 1,
ANY_SUBLINK = 2,
ROWCOMPARE_SUBLINK = 3,
EXPR_SUBLINK = 4,
MULTIEXPR_SUBLINK = 5,
ARRAY_SUBLINK = 6,
CTE_SUBLINK = 7,
}
#[derive(Debug, serde::Deserialize)]
pub enum XmlExprOp {
IS_XMLCONCAT = 0,
IS_XMLELEMENT = 1,
IS_XMLFOREST = 2,
IS_XMLPARSE = 3,
IS_XMLPI = 4,
IS_XMLROOT = 5,
IS_XMLSERIALIZE = 6,
IS_DOCUMENT = 7,
}
#[derive(Debug, serde::Deserialize)]
pub enum XmlOptionType {
XMLOPTION_DOCUMENT = 0,
XMLOPTION_CONTENT = 1,
}
#[derive(Debug, serde::Deserialize)]
pub enum LockClauseStrength {
LCS_NONE = 0,
LCS_FORKEYSHARE = 1,
LCS_FORSHARE = 2,
LCS_FORNOKEYUPDATE = 3,
LCS_FORUPDATE = 4,
}
#[derive(Debug, serde::Deserialize)]
pub enum LockTupleMode {
LockTupleKeyShare = 0,
LockTupleShare = 1,
LockTupleNoKeyExclusive = 2,
LockTupleExclusive = 3,
}
#[derive(Debug, serde::Deserialize)]
pub enum LockWaitPolicy {
LockWaitBlock = 0,
LockWaitSkip = 1,
LockWaitError = 2,
}
#[derive(Debug, serde::Deserialize)]
pub enum AggSplit {
AGGSPLIT_SIMPLE = 0,
AGGSPLIT_INITIAL_SERIAL = 1,
AGGSPLIT_FINAL_DESERIAL = 2,
}
#[derive(Debug, serde::Deserialize)]
pub enum AggStrategy {
AGG_PLAIN = 0,
AGG_SORTED = 1,
AGG_HASHED = 2,
AGG_MIXED = 3,
}
#[derive(Debug, serde::Deserialize)]
pub enum CmdType {
CMD_UNKNOWN = 0,
CMD_SELECT = 1,
CMD_UPDATE = 2,
CMD_INSERT = 3,
CMD_DELETE = 4,
CMD_UTILITY = 5,
CMD_NOTHING = 6,
}
#[derive(Debug, serde::Deserialize)]
pub enum JoinType {
JOIN_INNER = 0,
JOIN_LEFT = 1,
JOIN_FULL = 2,
JOIN_RIGHT = 3,
JOIN_SEMI = 4,
JOIN_ANTI = 5,
JOIN_UNIQUE_OUTER = 6,
JOIN_UNIQUE_INNER = 7,
}
#[derive(Debug, serde::Deserialize)]
pub enum LimitOption {
LIMIT_OPTION_DEFAULT = 0,
LIMIT_OPTION_COUNT = 1,
LIMIT_OPTION_WITH_TIES = 2,
}
#[derive(Debug, serde::Deserialize)]
pub enum NodeTag {
T_Invalid = 0,
T_IndexInfo = 1,
T_ExprContext = 2,
T_ProjectionInfo = 3,
T_JunkFilter = 4,
T_OnConflictSetState = 5,
T_ResultRelInfo = 6,
T_EState = 7,
T_TupleTableSlot = 8,
T_Plan = 9,
T_Result = 10,
T_ProjectSet = 11,
T_ModifyTable = 12,
T_Append = 13,
T_MergeAppend = 14,
T_RecursiveUnion = 15,
T_BitmapAnd = 16,
T_BitmapOr = 17,
T_Scan = 18,
T_SeqScan = 19,
T_SampleScan = 20,
T_IndexScan = 21,
T_IndexOnlyScan = 22,
T_BitmapIndexScan = 23,
T_BitmapHeapScan = 24,
T_TidScan = 25,
T_SubqueryScan = 26,
T_FunctionScan = 27,
T_ValuesScan = 28,
T_TableFuncScan = 29,
T_CteScan = 30,
T_NamedTuplestoreScan = 31,
T_WorkTableScan = 32,
T_ForeignScan = 33,
T_CustomScan = 34,
T_Join = 35,
T_NestLoop = 36,
T_MergeJoin = 37,
T_HashJoin = 38,
T_Material = 39,
T_Sort = 40,
T_IncrementalSort = 41,
T_Group = 42,
T_Agg = 43,
T_WindowAgg = 44,
T_Unique = 45,
T_Gather = 46,
T_GatherMerge = 47,
T_Hash = 48,
T_SetOp = 49,
T_LockRows = 50,
T_Limit = 51,
T_NestLoopParam = 52,
T_PlanRowMark = 53,
T_PartitionPruneInfo = 54,
T_PartitionedRelPruneInfo = 55,
T_PartitionPruneStepOp = 56,
T_PartitionPruneStepCombine = 57,
T_PlanInvalItem = 58,
T_PlanState = 59,
T_ResultState = 60,
T_ProjectSetState = 61,
T_ModifyTableState = 62,
T_AppendState = 63,
T_MergeAppendState = 64,
T_RecursiveUnionState = 65,
T_BitmapAndState = 66,
T_BitmapOrState = 67,
T_ScanState = 68,
T_SeqScanState = 69,
T_SampleScanState = 70,
T_IndexScanState = 71,
T_IndexOnlyScanState = 72,
T_BitmapIndexScanState = 73,
T_BitmapHeapScanState = 74,
T_TidScanState = 75,
T_SubqueryScanState = 76,
T_FunctionScanState = 77,
T_TableFuncScanState = 78,
T_ValuesScanState = 79,
T_CteScanState = 80,
T_NamedTuplestoreScanState = 81,
T_WorkTableScanState = 82,
T_ForeignScanState = 83,
T_CustomScanState = 84,
T_JoinState = 85,
T_NestLoopState = 86,
T_MergeJoinState = 87,
T_HashJoinState = 88,
T_MaterialState = 89,
T_SortState = 90,
T_IncrementalSortState = 91,
T_GroupState = 92,
T_AggState = 93,
T_WindowAggState = 94,
T_UniqueState = 95,
T_GatherState = 96,
T_GatherMergeState = 97,
T_HashState = 98,
T_SetOpState = 99,
T_LockRowsState = 100,
T_LimitState = 101,
T_Alias = 102,
T_RangeVar = 103,
T_TableFunc = 104,
T_Expr = 105,
T_Var = 106,
T_Const = 107,
T_Param = 108,
T_Aggref = 109,
T_GroupingFunc = 110,
T_WindowFunc = 111,
T_SubscriptingRef = 112,
T_FuncExpr = 113,
T_NamedArgExpr = 114,
T_OpExpr = 115,
T_DistinctExpr = 116,
T_NullIfExpr = 117,
T_ScalarArrayOpExpr = 118,
T_BoolExpr = 119,
T_SubLink = 120,
T_SubPlan = 121,
T_AlternativeSubPlan = 122,
T_FieldSelect = 123,
T_FieldStore = 124,
T_RelabelType = 125,
T_CoerceViaIO = 126,
T_ArrayCoerceExpr = 127,
T_ConvertRowtypeExpr = 128,
T_CollateExpr = 129,
T_CaseExpr = 130,
T_CaseWhen = 131,
T_CaseTestExpr = 132,
T_ArrayExpr = 133,
T_RowExpr = 134,
T_RowCompareExpr = 135,
T_CoalesceExpr = 136,
T_MinMaxExpr = 137,
T_SQLValueFunction = 138,
T_XmlExpr = 139,
T_NullTest = 140,
T_BooleanTest = 141,
T_CoerceToDomain = 142,
T_CoerceToDomainValue = 143,
T_SetToDefault = 144,
T_CurrentOfExpr = 145,
T_NextValueExpr = 146,
T_InferenceElem = 147,
T_TargetEntry = 148,
T_RangeTblRef = 149,
T_JoinExpr = 150,
T_FromExpr = 151,
T_OnConflictExpr = 152,
T_IntoClause = 153,
T_ExprState = 154,
T_AggrefExprState = 155,
T_WindowFuncExprState = 156,
T_SetExprState = 157,
T_SubPlanState = 158,
T_AlternativeSubPlanState = 159,
T_DomainConstraintState = 160,
T_PlannerInfo = 161,
T_PlannerGlobal = 162,
T_RelOptInfo = 163,
T_IndexOptInfo = 164,
T_ForeignKeyOptInfo = 165,
T_ParamPathInfo = 166,
T_Path = 167,
T_IndexPath = 168,
T_BitmapHeapPath = 169,
T_BitmapAndPath = 170,
T_BitmapOrPath = 171,
T_TidPath = 172,
T_SubqueryScanPath = 173,
T_ForeignPath = 174,
T_CustomPath = 175,
T_NestPath = 176,
T_MergePath = 177,
T_HashPath = 178,
T_AppendPath = 179,
T_MergeAppendPath = 180,
T_GroupResultPath = 181,
T_MaterialPath = 182,
T_UniquePath = 183,
T_GatherPath = 184,
T_GatherMergePath = 185,
T_ProjectionPath = 186,
T_ProjectSetPath = 187,
T_SortPath = 188,
T_IncrementalSortPath = 189,
T_GroupPath = 190,
T_UpperUniquePath = 191,
T_AggPath = 192,
T_GroupingSetsPath = 193,
T_MinMaxAggPath = 194,
T_WindowAggPath = 195,
T_SetOpPath = 196,
T_RecursiveUnionPath = 197,
T_LockRowsPath = 198,
T_ModifyTablePath = 199,
T_LimitPath = 200,
T_EquivalenceClass = 201,
T_EquivalenceMember = 202,
T_PathKey = 203,
T_PathTarget = 204,
T_RestrictInfo = 205,
T_IndexClause = 206,
T_PlaceHolderVar = 207,
T_SpecialJoinInfo = 208,
T_AppendRelInfo = 209,
T_PlaceHolderInfo = 210,
T_MinMaxAggInfo = 211,
T_PlannerParamItem = 212,
T_RollupData = 213,
T_GroupingSetData = 214,
T_StatisticExtInfo = 215,
T_MemoryContext = 216,
T_AllocSetContext = 217,
T_SlabContext = 218,
T_GenerationContext = 219,
T_Value = 220,
T_Integer = 221,
T_Float = 222,
T_String = 223,
T_BitString = 224,
T_Null = 225,
T_List = 226,
T_IntList = 227,
T_OidList = 228,
T_ExtensibleNode = 229,
T_RawStmt = 230,
T_Query = 231,
T_PlannedStmt = 232,
T_InsertStmt = 233,
T_DeleteStmt = 234,
T_UpdateStmt = 235,
T_SelectStmt = 236,
T_AlterTableStmt = 237,
T_AlterTableCmd = 238,
T_AlterDomainStmt = 239,
T_SetOperationStmt = 240,
T_GrantStmt = 241,
T_GrantRoleStmt = 242,
T_AlterDefaultPrivilegesStmt = 243,
T_ClosePortalStmt = 244,
T_ClusterStmt = 245,
T_CopyStmt = 246,
T_CreateStmt = 247,
T_DefineStmt = 248,
T_DropStmt = 249,
T_TruncateStmt = 250,
T_CommentStmt = 251,
T_FetchStmt = 252,
T_IndexStmt = 253,
T_CreateFunctionStmt = 254,
T_AlterFunctionStmt = 255,
T_DoStmt = 256,
T_RenameStmt = 257,
T_RuleStmt = 258,
T_NotifyStmt = 259,
T_ListenStmt = 260,
T_UnlistenStmt = 261,
T_TransactionStmt = 262,
T_ViewStmt = 263,
T_LoadStmt = 264,
T_CreateDomainStmt = 265,
T_CreatedbStmt = 266,
T_DropdbStmt = 267,
T_VacuumStmt = 268,
T_ExplainStmt = 269,
T_CreateTableAsStmt = 270,
T_CreateSeqStmt = 271,
T_AlterSeqStmt = 272,
T_VariableSetStmt = 273,
T_VariableShowStmt = 274,
T_DiscardStmt = 275,
T_CreateTrigStmt = 276,
T_CreatePLangStmt = 277,
T_CreateRoleStmt = 278,
T_AlterRoleStmt = 279,
T_DropRoleStmt = 280,
T_LockStmt = 281,
T_ConstraintsSetStmt = 282,
T_ReindexStmt = 283,
T_CheckPointStmt = 284,
T_CreateSchemaStmt = 285,
T_AlterDatabaseStmt = 286,
T_AlterDatabaseSetStmt = 287,
T_AlterRoleSetStmt = 288,
T_CreateConversionStmt = 289,
T_CreateCastStmt = 290,
T_CreateOpClassStmt = 291,
T_CreateOpFamilyStmt = 292,
T_AlterOpFamilyStmt = 293,
T_PrepareStmt = 294,
T_ExecuteStmt = 295,
T_DeallocateStmt = 296,
T_DeclareCursorStmt = 297,
T_CreateTableSpaceStmt = 298,
T_DropTableSpaceStmt = 299,
T_AlterObjectDependsStmt = 300,
T_AlterObjectSchemaStmt = 301,
T_AlterOwnerStmt = 302,
T_AlterOperatorStmt = 303,
T_AlterTypeStmt = 304,
T_DropOwnedStmt = 305,
T_ReassignOwnedStmt = 306,
T_CompositeTypeStmt = 307,
T_CreateEnumStmt = 308,
T_CreateRangeStmt = 309,
T_AlterEnumStmt = 310,
T_AlterTSDictionaryStmt = 311,
T_AlterTSConfigurationStmt = 312,
T_CreateFdwStmt = 313,
T_AlterFdwStmt = 314,
T_CreateForeignServerStmt = 315,
T_AlterForeignServerStmt = 316,
T_CreateUserMappingStmt = 317,
T_AlterUserMappingStmt = 318,
T_DropUserMappingStmt = 319,
T_AlterTableSpaceOptionsStmt = 320,
T_AlterTableMoveAllStmt = 321,
T_SecLabelStmt = 322,
T_CreateForeignTableStmt = 323,
T_ImportForeignSchemaStmt = 324,
T_CreateExtensionStmt = 325,
T_AlterExtensionStmt = 326,
T_AlterExtensionContentsStmt = 327,
T_CreateEventTrigStmt = 328,
T_AlterEventTrigStmt = 329,
T_RefreshMatViewStmt = 330,
T_ReplicaIdentityStmt = 331,
T_AlterSystemStmt = 332,
T_CreatePolicyStmt = 333,
T_AlterPolicyStmt = 334,
T_CreateTransformStmt = 335,
T_CreateAmStmt = 336,
T_CreatePublicationStmt = 337,
T_AlterPublicationStmt = 338,
T_CreateSubscriptionStmt = 339,
T_AlterSubscriptionStmt = 340,
T_DropSubscriptionStmt = 341,
T_CreateStatsStmt = 342,
T_AlterCollationStmt = 343,
T_CallStmt = 344,
T_AlterStatsStmt = 345,
T_A_Expr = 346,
T_ColumnRef = 347,
T_ParamRef = 348,
T_A_Const = 349,
T_FuncCall = 350,
T_A_Star = 351,
T_A_Indices = 352,
T_A_Indirection = 353,
T_A_ArrayExpr = 354,
T_ResTarget = 355,
T_MultiAssignRef = 356,
T_TypeCast = 357,
T_CollateClause = 358,
T_SortBy = 359,
T_WindowDef = 360,
T_RangeSubselect = 361,
T_RangeFunction = 362,
T_RangeTableSample = 363,
T_RangeTableFunc = 364,
T_RangeTableFuncCol = 365,
T_TypeName = 366,
T_ColumnDef = 367,
T_IndexElem = 368,
T_Constraint = 369,
T_DefElem = 370,
T_RangeTblEntry = 371,
T_RangeTblFunction = 372,
T_TableSampleClause = 373,
T_WithCheckOption = 374,
T_SortGroupClause = 375,
T_GroupingSet = 376,
T_WindowClause = 377,
T_ObjectWithArgs = 378,
T_AccessPriv = 379,
T_CreateOpClassItem = 380,
T_TableLikeClause = 381,
T_FunctionParameter = 382,
T_LockingClause = 383,
T_RowMarkClause = 384,
T_XmlSerialize = 385,
T_WithClause = 386,
T_InferClause = 387,
T_OnConflictClause = 388,
T_CommonTableExpr = 389,
T_RoleSpec = 390,
T_TriggerTransition = 391,
T_PartitionElem = 392,
T_PartitionSpec = 393,
T_PartitionBoundSpec = 394,
T_PartitionRangeDatum = 395,
T_PartitionCmd = 396,
T_VacuumRelation = 397,
T_IdentifySystemCmd = 398,
T_BaseBackupCmd = 399,
T_CreateReplicationSlotCmd = 400,
T_DropReplicationSlotCmd = 401,
T_StartReplicationCmd = 402,
T_TimeLineHistoryCmd = 403,
T_SQLCmd = 404,
T_TriggerData = 405,
T_EventTriggerData = 406,
T_ReturnSetInfo = 407,
T_WindowObjectData = 408,
T_TIDBitmap = 409,
T_InlineCodeBlock = 410,
T_FdwRoutine = 411,
T_IndexAmRoutine = 412,
T_TableAmRoutine = 413,
T_TsmRoutine = 414,
T_ForeignKeyCacheInfo = 415,
T_CallContext = 416,
T_SupportRequestSimplify = 417,
T_SupportRequestSelectivity = 418,
T_SupportRequestCost = 419,
T_SupportRequestRows = 420,
T_SupportRequestIndexCondition = 421,
}
#[derive(Debug, serde::Deserialize)]
pub enum OnConflictAction {
ONCONFLICT_NONE = 0,
ONCONFLICT_NOTHING = 1,
ONCONFLICT_UPDATE = 2,
}
#[derive(Debug, serde::Deserialize)]
pub enum SetOpCmd {
SETOPCMD_INTERSECT = 0,
SETOPCMD_INTERSECT_ALL = 1,
SETOPCMD_EXCEPT = 2,
SETOPCMD_EXCEPT_ALL = 3,
}
#[derive(Debug, serde::Deserialize)]
pub enum SetOpStrategy {
SETOP_SORTED = 0,
SETOP_HASHED = 1,
}
#[derive(Debug, serde::Deserialize)]
pub enum Node {
A_ArrayExpr(A_ArrayExpr),
A_Const(A_Const),
A_Expr(A_Expr),
A_Indices(A_Indices),
A_Indirection(A_Indirection),
A_Star(A_Star),
AccessPriv(AccessPriv),
AlterCollationStmt(AlterCollationStmt),
AlterDatabaseSetStmt(AlterDatabaseSetStmt),
AlterDatabaseStmt(AlterDatabaseStmt),
AlterDefaultPrivilegesStmt(AlterDefaultPrivilegesStmt),
AlterDomainStmt(AlterDomainStmt),
AlterEnumStmt(AlterEnumStmt),
AlterEventTrigStmt(AlterEventTrigStmt),
AlterExtensionContentsStmt(AlterExtensionContentsStmt),
AlterExtensionStmt(AlterExtensionStmt),
AlterFdwStmt(AlterFdwStmt),
AlterForeignServerStmt(AlterForeignServerStmt),
AlterFunctionStmt(AlterFunctionStmt),
AlterObjectDependsStmt(AlterObjectDependsStmt),
AlterObjectSchemaStmt(AlterObjectSchemaStmt),
AlterOpFamilyStmt(AlterOpFamilyStmt),
AlterOperatorStmt(AlterOperatorStmt),
AlterOwnerStmt(AlterOwnerStmt),
AlterPolicyStmt(AlterPolicyStmt),
AlterPublicationStmt(AlterPublicationStmt),
AlterRoleSetStmt(AlterRoleSetStmt),
AlterRoleStmt(AlterRoleStmt),
AlterSeqStmt(AlterSeqStmt),
AlterStatsStmt(AlterStatsStmt),
AlterSubscriptionStmt(AlterSubscriptionStmt),
AlterSystemStmt(AlterSystemStmt),
AlterTSConfigurationStmt(AlterTSConfigurationStmt),
AlterTSDictionaryStmt(AlterTSDictionaryStmt),
AlterTableCmd(AlterTableCmd),
AlterTableMoveAllStmt(AlterTableMoveAllStmt),
AlterTableSpaceOptionsStmt(AlterTableSpaceOptionsStmt),
AlterTableStmt(AlterTableStmt),
AlterTypeStmt(AlterTypeStmt),
AlterUserMappingStmt(AlterUserMappingStmt),
CallContext(CallContext),
CallStmt(CallStmt),
CheckPointStmt(CheckPointStmt),
ClosePortalStmt(ClosePortalStmt),
ClusterStmt(ClusterStmt),
CollateClause(CollateClause),
ColumnDef(ColumnDef),
ColumnRef(ColumnRef),
CommentStmt(CommentStmt),
CommonTableExpr(CommonTableExpr),
CompositeTypeStmt(CompositeTypeStmt),
Constraint(Constraint),
ConstraintsSetStmt(ConstraintsSetStmt),
CopyStmt(CopyStmt),
CreateAmStmt(CreateAmStmt),
CreateCastStmt(CreateCastStmt),
CreateConversionStmt(CreateConversionStmt),
CreateDomainStmt(CreateDomainStmt),
CreateEnumStmt(CreateEnumStmt),
CreateEventTrigStmt(CreateEventTrigStmt),
CreateExtensionStmt(CreateExtensionStmt),
CreateFdwStmt(CreateFdwStmt),
CreateForeignServerStmt(CreateForeignServerStmt),
CreateForeignTableStmt(CreateForeignTableStmt),
CreateFunctionStmt(CreateFunctionStmt),
CreateOpClassItem(CreateOpClassItem),
CreateOpClassStmt(CreateOpClassStmt),
CreateOpFamilyStmt(CreateOpFamilyStmt),
CreatePLangStmt(CreatePLangStmt),
CreatePolicyStmt(CreatePolicyStmt),
CreatePublicationStmt(CreatePublicationStmt),
CreateRangeStmt(CreateRangeStmt),
CreateRoleStmt(CreateRoleStmt),
CreateSchemaStmt(CreateSchemaStmt),
CreateSeqStmt(CreateSeqStmt),
CreateStatsStmt(CreateStatsStmt),
CreateStmt(CreateStmt),
CreateSubscriptionStmt(CreateSubscriptionStmt),
CreateTableAsStmt(CreateTableAsStmt),
CreateTableSpaceStmt(CreateTableSpaceStmt),
CreateTransformStmt(CreateTransformStmt),
CreateTrigStmt(CreateTrigStmt),
CreateUserMappingStmt(CreateUserMappingStmt),
CreatedbStmt(CreatedbStmt),
DeallocateStmt(DeallocateStmt),
DeclareCursorStmt(DeclareCursorStmt),
DefElem(DefElem),
DefineStmt(DefineStmt),
DeleteStmt(DeleteStmt),
DiscardStmt(DiscardStmt),
DoStmt(DoStmt),
DropOwnedStmt(DropOwnedStmt),
DropRoleStmt(DropRoleStmt),
DropStmt(DropStmt),
DropSubscriptionStmt(DropSubscriptionStmt),
DropTableSpaceStmt(DropTableSpaceStmt),
DropUserMappingStmt(DropUserMappingStmt),
DropdbStmt(DropdbStmt),
ExecuteStmt(ExecuteStmt),
ExplainStmt(ExplainStmt),
FetchStmt(FetchStmt),
FuncCall(FuncCall),
FunctionParameter(FunctionParameter),
GrantRoleStmt(GrantRoleStmt),
GrantStmt(GrantStmt),
GroupingSet(GroupingSet),
ImportForeignSchemaStmt(ImportForeignSchemaStmt),
IndexElem(IndexElem),
IndexStmt(IndexStmt),
InferClause(InferClause),
InlineCodeBlock(InlineCodeBlock),
InsertStmt(InsertStmt),
ListenStmt(ListenStmt),
LoadStmt(LoadStmt),
LockStmt(LockStmt),
LockingClause(LockingClause),
MultiAssignRef(MultiAssignRef),
NotifyStmt(NotifyStmt),
ObjectWithArgs(ObjectWithArgs),
OnConflictClause(OnConflictClause),
ParamRef(ParamRef),
PartitionBoundSpec(PartitionBoundSpec),
PartitionCmd(PartitionCmd),
PartitionElem(PartitionElem),
PartitionRangeDatum(PartitionRangeDatum),
PartitionSpec(PartitionSpec),
PrepareStmt(PrepareStmt),
Query(Query),
RangeFunction(RangeFunction),
RangeSubselect(RangeSubselect),
RangeTableFunc(RangeTableFunc),
RangeTableFuncCol(RangeTableFuncCol),
RangeTableSample(RangeTableSample),
RangeTblEntry(RangeTblEntry),
RangeTblFunction(RangeTblFunction),
RawStmt(RawStmt),
ReassignOwnedStmt(ReassignOwnedStmt),
RefreshMatViewStmt(RefreshMatViewStmt),
ReindexStmt(ReindexStmt),
RenameStmt(RenameStmt),
ReplicaIdentityStmt(ReplicaIdentityStmt),
ResTarget(ResTarget),
RoleSpec(RoleSpec),
RowMarkClause(RowMarkClause),
RuleStmt(RuleStmt),
SecLabelStmt(SecLabelStmt),
SelectStmt(SelectStmt),
SetOperationStmt(SetOperationStmt),
SortBy(SortBy),
SortGroupClause(SortGroupClause),
TableLikeClause(TableLikeClause),
TableSampleClause(TableSampleClause),
TransactionStmt(TransactionStmt),
TriggerTransition(TriggerTransition),
TruncateStmt(TruncateStmt),
TypeCast(TypeCast),
TypeName(TypeName),
UnlistenStmt(UnlistenStmt),
UpdateStmt(UpdateStmt),
VacuumRelation(VacuumRelation),
VacuumStmt(VacuumStmt),
VariableSetStmt(VariableSetStmt),
VariableShowStmt(VariableShowStmt),
ViewStmt(ViewStmt),
WindowClause(WindowClause),
WindowDef(WindowDef),
WithCheckOption(WithCheckOption),
WithClause(WithClause),
XmlSerialize(XmlSerialize),
Aggref(Aggref),
Alias(Alias),
AlternativeSubPlan(AlternativeSubPlan),
ArrayCoerceExpr(ArrayCoerceExpr),
ArrayExpr(ArrayExpr),
BoolExpr(BoolExpr),
BooleanTest(BooleanTest),
CaseExpr(CaseExpr),
CaseTestExpr(CaseTestExpr),
CaseWhen(CaseWhen),
CoalesceExpr(CoalesceExpr),
CoerceToDomain(CoerceToDomain),
CoerceToDomainValue(CoerceToDomainValue),
CoerceViaIO(CoerceViaIO),
CollateExpr(CollateExpr),
Const(Const),
ConvertRowtypeExpr(ConvertRowtypeExpr),
CurrentOfExpr(CurrentOfExpr),
Expr(Expr),
FieldSelect(FieldSelect),
FieldStore(FieldStore),
FromExpr(FromExpr),
FuncExpr(FuncExpr),
GroupingFunc(GroupingFunc),
InferenceElem(InferenceElem),
IntoClause(IntoClause),
JoinExpr(JoinExpr),
MinMaxExpr(MinMaxExpr),
NamedArgExpr(NamedArgExpr),
NextValueExpr(NextValueExpr),
NullTest(NullTest),
OnConflictExpr(OnConflictExpr),
OpExpr(OpExpr),
Param(Param),
RangeTblRef(RangeTblRef),
RangeVar(RangeVar),
RelabelType(RelabelType),
RowCompareExpr(RowCompareExpr),
RowExpr(RowExpr),
SQLValueFunction(SQLValueFunction),
ScalarArrayOpExpr(ScalarArrayOpExpr),
SetToDefault(SetToDefault),
SubLink(SubLink),
SubPlan(SubPlan),
SubscriptingRef(SubscriptingRef),
TableFunc(TableFunc),
TargetEntry(TargetEntry),
Var(Var),
WindowFunc(WindowFunc),
XmlExpr(XmlExpr),
BitString {
#[serde(rename = "str")]
value: Option<String>
},
Float {
#[serde(rename = "str")]
value: Option<String>
},
Integer {
#[serde(rename = "ival")]
value: i64
},
Null,
String {
#[serde(rename = "str")]
value: Option<String>
},
}
#[derive(Debug, serde::Deserialize)]
pub struct A_ArrayExpr {
#[serde(default)]
pub elements: Option<Vec<Node>>,
#[serde(default)]
pub location: i32,
}
#[derive(Debug, serde::Deserialize)]
pub struct A_Const {
pub val: Box<Value>,
#[serde(default)]
pub location: i32,
}
#[derive(Debug, serde::Deserialize)]
pub struct A_Expr {
pub kind: Box<A_Expr_Kind>,
#[serde(default)]
pub name: Option<Vec<Node>>,
#[serde(default)]
pub lexpr: Option<Box<Node>>,
#[serde(default)]
pub rexpr: Option<Box<Node>>,
#[serde(default)]
pub location: i32,
}
#[derive(Debug, serde::Deserialize)]
pub struct A_Indices {
#[serde(default)]
pub is_slice: bool,
#[serde(default)]
pub lidx: Option<Box<Node>>,
#[serde(default)]
pub uidx: Option<Box<Node>>,
}
#[derive(Debug, serde::Deserialize)]
pub struct A_Indirection {
#[serde(default)]
pub arg: Option<Box<Node>>,
#[serde(default)]
pub indirection: Option<Vec<Node>>,
}
#[derive(Debug, serde::Deserialize)]
pub struct A_Star {
}
#[derive(Debug, serde::Deserialize)]
pub struct AccessPriv {
#[serde(default)]
pub priv_name: Option<String>,
#[serde(default)]
pub cols: Option<Vec<Node>>,
}
#[derive(Debug, serde::Deserialize)]
pub struct AlterCollationStmt {
#[serde(default)]
pub collname: Option<Vec<Node>>,
}
#[derive(Debug, serde::Deserialize)]
pub struct AlterDatabaseSetStmt {
#[serde(default)]
pub dbname: Option<String>,
pub setstmt: Option<Box<VariableSetStmt>>,
}
#[derive(Debug, serde::Deserialize)]
pub struct AlterDatabaseStmt {
#[serde(default)]
pub dbname: Option<String>,
#[serde(default)]
pub options: Option<Vec<Node>>,
}
#[derive(Debug, serde::Deserialize)]
pub struct AlterDefaultPrivilegesStmt {
#[serde(default)]
pub options: Option<Vec<Node>>,
pub action: Option<Box<GrantStmt>>,
}
#[derive(Debug, serde::Deserialize)]
pub struct AlterDomainStmt {
#[serde(default)]
pub subtype: char,
#[serde(rename = "typeName", default)]
pub type_name: Option<Vec<Node>>,
#[serde(default)]
pub name: Option<String>,
#[serde(default)]
pub def: Option<Box<Node>>,
pub behavior: Box<DropBehavior>,
#[serde(default)]
pub missing_ok: bool,
}
#[derive(Debug, serde::Deserialize)]
pub struct AlterEnumStmt {
#[serde(rename = "typeName", default)]
pub type_name: Option<Vec<Node>>,
#[serde(rename = "oldVal", default)]
pub old_val: Option<String>,
#[serde(rename = "newVal", default)]
pub new_val: Option<String>,
#[serde(rename = "newValNeighbor", default)]
pub new_val_neighbor: Option<String>,
#[serde(rename = "newValIsAfter", default)]
pub new_val_is_after: bool,
#[serde(rename = "skipIfNewValExists", default)]
pub skip_if_new_val_exists: bool,
}
#[derive(Debug, serde::Deserialize)]
pub struct AlterEventTrigStmt {
#[serde(default)]
pub trigname: Option<String>,
#[serde(default)]
pub tgenabled: char,
}
#[derive(Debug, serde::Deserialize)]
pub struct AlterExtensionContentsStmt {
#[serde(default)]
pub extname: Option<String>,
#[serde(default)]
pub action: i32,
pub objtype: Box<ObjectType>,
#[serde(default)]
pub object: Option<Box<Node>>,
}
#[derive(Debug, serde::Deserialize)]
pub struct AlterExtensionStmt {
#[serde(default)]
pub extname: Option<String>,
#[serde(default)]
pub options: Option<Vec<Node>>,
}
#[derive(Debug, serde::Deserialize)]
pub struct AlterFdwStmt {
#[serde(default)]
pub fdwname: Option<String>,
#[serde(default)]
pub func_options: Option<Vec<Node>>,
#[serde(default)]
pub options: Option<Vec<Node>>,
}
#[derive(Debug, serde::Deserialize)]
pub struct AlterForeignServerStmt {
#[serde(default)]
pub servername: Option<String>,
#[serde(default)]
pub version: Option<String>,
#[serde(default)]
pub options: Option<Vec<Node>>,
#[serde(default)]
pub has_version: bool,
}
#[derive(Debug, serde::Deserialize)]
pub struct AlterFunctionStmt {
pub objtype: Box<ObjectType>,
pub func: Option<Box<ObjectWithArgs>>,
#[serde(default)]
pub actions: Option<Vec<Node>>,
}
#[derive(Debug, serde::Deserialize)]
pub struct AlterObjectDependsStmt {
#[serde(rename = "objectType")]
pub object_type: Box<ObjectType>,
pub relation: Option<Box<RangeVar>>,
#[serde(default)]
pub object: Option<Box<Node>>,
pub extname: Option<Box<Value>>,
#[serde(default)]
pub remove: bool,
}
#[derive(Debug, serde::Deserialize)]
pub struct AlterObjectSchemaStmt {
#[serde(rename = "objectType")]
pub object_type: Box<ObjectType>,
pub relation: Option<Box<RangeVar>>,
#[serde(default)]
pub object: Option<Box<Node>>,
#[serde(default)]
pub newschema: Option<String>,
#[serde(default)]
pub missing_ok: bool,
}
#[derive(Debug, serde::Deserialize)]
pub struct AlterOpFamilyStmt {
#[serde(default)]
pub opfamilyname: Option<Vec<Node>>,
#[serde(default)]
pub amname: Option<String>,
#[serde(rename = "isDrop", default)]
pub is_drop: bool,
#[serde(default)]
pub items: Option<Vec<Node>>,
}
#[derive(Debug, serde::Deserialize)]
pub struct AlterOperatorStmt {
pub opername: Option<Box<ObjectWithArgs>>,
#[serde(default)]
pub options: Option<Vec<Node>>,
}
#[derive(Debug, serde::Deserialize)]
pub struct AlterOwnerStmt {
#[serde(rename = "objectType")]
pub object_type: Box<ObjectType>,
pub relation: Option<Box<RangeVar>>,
#[serde(default)]
pub object: Option<Box<Node>>,
pub newowner: Option<Box<RoleSpec>>,
}
#[derive(Debug, serde::Deserialize)]
pub struct AlterPolicyStmt {
#[serde(default)]
pub policy_name: Option<String>,
pub table: Option<Box<RangeVar>>,
#[serde(default)]
pub roles: Option<Vec<Node>>,
#[serde(default)]
pub qual: Option<Box<Node>>,
#[serde(default)]
pub with_check: Option<Box<Node>>,
}
#[derive(Debug, serde::Deserialize)]
pub struct AlterPublicationStmt {
#[serde(default)]
pub pubname: Option<String>,
#[serde(default)]
pub options: Option<Vec<Node>>,
#[serde(default)]
pub tables: Option<Vec<Node>>,
#[serde(default)]
pub for_all_tables: bool,
#[serde(rename = "tableAction")]
pub table_action: Box<DefElemAction>,
}
#[derive(Debug, serde::Deserialize)]
pub struct AlterRoleSetStmt {
pub role: Option<Box<RoleSpec>>,
#[serde(default)]
pub database: Option<String>,
pub setstmt: Option<Box<VariableSetStmt>>,
}
#[derive(Debug, serde::Deserialize)]
pub struct AlterRoleStmt {
pub role: Option<Box<RoleSpec>>,
#[serde(default)]
pub options: Option<Vec<Node>>,
#[serde(default)]
pub action: i32,
}
#[derive(Debug, serde::Deserialize)]
pub struct AlterSeqStmt {
pub sequence: Option<Box<RangeVar>>,
#[serde(default)]
pub options: Option<Vec<Node>>,
#[serde(default)]
pub for_identity: bool,
#[serde(default)]
pub missing_ok: bool,
}
#[derive(Debug, serde::Deserialize)]
pub struct AlterStatsStmt {
#[serde(default)]
pub defnames: Option<Vec<Node>>,
#[serde(default)]
pub stxstattarget: i32,
#[serde(default)]
pub missing_ok: bool,
}
#[derive(Debug, serde::Deserialize)]
pub struct AlterSubscriptionStmt {
pub kind: Box<AlterSubscriptionType>,
#[serde(default)]
pub subname: Option<String>,
#[serde(default)]
pub conninfo: Option<String>,
#[serde(default)]
pub publication: Option<Vec<Node>>,
#[serde(default)]
pub options: Option<Vec<Node>>,
}
#[derive(Debug, serde::Deserialize)]
pub struct AlterSystemStmt {
pub setstmt: Option<Box<VariableSetStmt>>,
}
#[derive(Debug, serde::Deserialize)]
pub struct AlterTSConfigurationStmt {
pub kind: Box<AlterTSConfigType>,
#[serde(default)]
pub cfgname: Option<Vec<Node>>,
#[serde(default)]
pub tokentype: Option<Vec<Node>>,
#[serde(default)]
pub dicts: Option<Vec<Node>>,
#[serde(rename = "override", default)]
pub override_: bool,
#[serde(default)]
pub replace: bool,
#[serde(default)]
pub missing_ok: bool,
}
#[derive(Debug, serde::Deserialize)]
pub struct AlterTSDictionaryStmt {
#[serde(default)]
pub dictname: Option<Vec<Node>>,
#[serde(default)]
pub options: Option<Vec<Node>>,
}
#[derive(Debug, serde::Deserialize)]
pub struct AlterTableCmd {
pub subtype: Box<AlterTableType>,
#[serde(default)]
pub name: Option<String>,
#[serde(default)]
pub num: i16,
pub newowner: Option<Box<RoleSpec>>,
#[serde(default)]
pub def: Option<Box<Node>>,
pub behavior: Box<DropBehavior>,
#[serde(default)]
pub missing_ok: bool,
}
#[derive(Debug, serde::Deserialize)]
pub struct AlterTableMoveAllStmt {
#[serde(default)]
pub orig_tablespacename: Option<String>,
pub objtype: Box<ObjectType>,
#[serde(default)]
pub roles: Option<Vec<Node>>,
#[serde(default)]
pub new_tablespacename: Option<String>,
#[serde(default)]
pub nowait: bool,
}
#[derive(Debug, serde::Deserialize)]
pub struct AlterTableSpaceOptionsStmt {
#[serde(default)]
pub tablespacename: Option<String>,
#[serde(default)]
pub options: Option<Vec<Node>>,
#[serde(rename = "isReset", default)]
pub is_reset: bool,
}
#[derive(Debug, serde::Deserialize)]
pub struct AlterTableStmt {
pub relation: Option<Box<RangeVar>>,
#[serde(default)]
pub cmds: Option<Vec<Node>>,
pub relkind: Box<ObjectType>,
#[serde(default)]
pub missing_ok: bool,
}
#[derive(Debug, serde::Deserialize)]
pub struct AlterTypeStmt {
#[serde(rename = "typeName", default)]
pub type_name: Option<Vec<Node>>,
#[serde(default)]
pub options: Option<Vec<Node>>,
}
#[derive(Debug, serde::Deserialize)]
pub struct AlterUserMappingStmt {
pub user: Option<Box<RoleSpec>>,
#[serde(default)]
pub servername: Option<String>,
#[serde(default)]
pub options: Option<Vec<Node>>,
}
#[derive(Debug, serde::Deserialize)]
pub struct CallContext {
#[serde(default)]
pub atomic: bool,
}
#[derive(Debug, serde::Deserialize)]
pub struct CallStmt {
pub funccall: Option<Box<FuncCall>>,
pub funcexpr: Option<Box<FuncExpr>>,
}
#[derive(Debug, serde::Deserialize)]
pub struct CheckPointStmt {
}
#[derive(Debug, serde::Deserialize)]
pub struct ClosePortalStmt {
#[serde(default)]
pub portalname: Option<String>,
}
#[derive(Debug, serde::Deserialize)]
pub struct ClusterStmt {
pub relation: Option<Box<RangeVar>>,
#[serde(default)]
pub indexname: Option<String>,
#[serde(default)]
pub options: i32,
}
#[derive(Debug, serde::Deserialize)]
pub struct CollateClause {
#[serde(default)]
pub arg: Option<Box<Node>>,
#[serde(default)]
pub collname: Option<Vec<Node>>,
#[serde(default)]
pub location: i32,
}
#[derive(Debug, serde::Deserialize)]
pub struct ColumnDef {
#[serde(default)]
pub colname: Option<String>,
#[serde(rename = "typeName")]
pub type_name: Option<Box<TypeName>>,
#[serde(default)]
pub inhcount: i32,
#[serde(default)]
pub is_local: bool,
#[serde(default)]
pub is_not_null: bool,
#[serde(default)]
pub is_from_type: bool,
#[serde(default)]
pub storage: char,
#[serde(default)]
pub raw_default: Option<Box<Node>>,
#[serde(default)]
pub cooked_default: Option<Box<Node>>,
#[serde(default)]
pub identity: char,
#[serde(rename = "identitySequence")]
pub identity_sequence: Option<Box<RangeVar>>,
#[serde(default)]
pub generated: char,
#[serde(rename = "collClause")]
pub coll_clause: Option<Box<CollateClause>>,
#[serde(rename = "collOid", default)]
pub coll_oid: Oid,
#[serde(default)]
pub constraints: Option<Vec<Node>>,
#[serde(default)]
pub fdwoptions: Option<Vec<Node>>,
#[serde(default)]
pub location: i32,
}
#[derive(Debug, serde::Deserialize)]
pub struct ColumnRef {
#[serde(default)]
pub fields: Option<Vec<Node>>,
#[serde(default)]
pub location: i32,
}
#[derive(Debug, serde::Deserialize)]
pub struct CommentStmt {
pub objtype: Box<ObjectType>,
#[serde(default)]
pub object: Option<Box<Node>>,
#[serde(default)]
pub comment: Option<String>,
}
#[derive(Debug, serde::Deserialize)]
pub struct CommonTableExpr {
#[serde(default)]
pub ctename: Option<String>,
#[serde(default)]
pub aliascolnames: Option<Vec<Node>>,
pub ctematerialized: Box<CTEMaterialize>,
#[serde(default)]
pub ctequery: Option<Box<Node>>,
#[serde(default)]
pub location: i32,
#[serde(default)]
pub cterecursive: bool,
#[serde(default)]
pub cterefcount: i32,
#[serde(default)]
pub ctecolnames: Option<Vec<Node>>,
#[serde(default)]
pub ctecoltypes: Option<Vec<Node>>,
#[serde(default)]
pub ctecoltypmods: Option<Vec<Node>>,
#[serde(default)]
pub ctecolcollations: Option<Vec<Node>>,
}
#[derive(Debug, serde::Deserialize)]
pub struct CompositeTypeStmt {
pub typevar: Option<Box<RangeVar>>,
#[serde(default)]
pub coldeflist: Option<Vec<Node>>,
}
#[derive(Debug, serde::Deserialize)]
pub struct Constraint {
pub contype: Box<ConstrType>,
#[serde(default)]
pub conname: Option<String>,
#[serde(default)]
pub deferrable: bool,
#[serde(default)]
pub initdeferred: bool,
#[serde(default)]
pub location: i32,
#[serde(default)]
pub is_no_inherit: bool,
#[serde(default)]
pub raw_expr: Option<Box<Node>>,
#[serde(default)]
pub cooked_expr: Option<String>,
#[serde(default)]
pub generated_when: char,
#[serde(default)]
pub keys: Option<Vec<Node>>,
#[serde(default)]
pub including: Option<Vec<Node>>,
#[serde(default)]
pub exclusions: Option<Vec<Node>>,
#[serde(default)]
pub options: Option<Vec<Node>>,
#[serde(default)]
pub indexname: Option<String>,
#[serde(default)]
pub indexspace: Option<String>,
#[serde(default)]
pub reset_default_tblspc: bool,
#[serde(default)]
pub access_method: Option<String>,
#[serde(default)]
pub where_clause: Option<Box<Node>>,
pub pktable: Option<Box<RangeVar>>,
#[serde(default)]
pub fk_attrs: Option<Vec<Node>>,
#[serde(default)]
pub pk_attrs: Option<Vec<Node>>,
#[serde(default)]
pub fk_matchtype: char,
#[serde(default)]
pub fk_upd_action: char,
#[serde(default)]
pub fk_del_action: char,
#[serde(default)]
pub old_conpfeqop: Option<Vec<Node>>,
#[serde(default)]
pub old_pktable_oid: Oid,
#[serde(default)]
pub skip_validation: bool,
#[serde(default)]
pub initially_valid: bool,
}
#[derive(Debug, serde::Deserialize)]
pub struct ConstraintsSetStmt {
#[serde(default)]
pub constraints: Option<Vec<Node>>,
#[serde(default)]
pub deferred: bool,
}
#[derive(Debug, serde::Deserialize)]
pub struct CopyStmt {
pub relation: Option<Box<RangeVar>>,
#[serde(default)]
pub query: Option<Box<Node>>,
#[serde(default)]
pub attlist: Option<Vec<Node>>,
#[serde(default)]
pub is_from: bool,
#[serde(default)]
pub is_program: bool,
#[serde(default)]
pub filename: Option<String>,
#[serde(default)]
pub options: Option<Vec<Node>>,
#[serde(rename = "whereClause", default)]
pub where_clause: Option<Box<Node>>,
}
#[derive(Debug, serde::Deserialize)]
pub struct CreateAmStmt {
#[serde(default)]
pub amname: Option<String>,
#[serde(default)]
pub handler_name: Option<Vec<Node>>,
#[serde(default)]
pub amtype: char,
}
#[derive(Debug, serde::Deserialize)]
pub struct CreateCastStmt {
pub sourcetype: Option<Box<TypeName>>,
pub targettype: Option<Box<TypeName>>,
pub func: Option<Box<ObjectWithArgs>>,
pub context: Box<CoercionContext>,
#[serde(default)]
pub inout: bool,
}
#[derive(Debug, serde::Deserialize)]
pub struct CreateConversionStmt {
#[serde(default)]
pub conversion_name: Option<Vec<Node>>,
#[serde(default)]
pub for_encoding_name: Option<String>,
#[serde(default)]
pub to_encoding_name: Option<String>,
#[serde(default)]
pub func_name: Option<Vec<Node>>,
#[serde(default)]
pub def: bool,
}
#[derive(Debug, serde::Deserialize)]
pub struct CreateDomainStmt {
#[serde(default)]
pub domainname: Option<Vec<Node>>,
#[serde(rename = "typeName")]
pub type_name: Option<Box<TypeName>>,
#[serde(rename = "collClause")]
pub coll_clause: Option<Box<CollateClause>>,
#[serde(default)]
pub constraints: Option<Vec<Node>>,
}
#[derive(Debug, serde::Deserialize)]
pub struct CreateEnumStmt {
#[serde(rename = "typeName", default)]
pub type_name: Option<Vec<Node>>,
#[serde(default)]
pub vals: Option<Vec<Node>>,
}
#[derive(Debug, serde::Deserialize)]
pub struct CreateEventTrigStmt {
#[serde(default)]
pub trigname: Option<String>,
#[serde(default)]
pub eventname: Option<String>,
#[serde(default)]
pub whenclause: Option<Vec<Node>>,
#[serde(default)]
pub funcname: Option<Vec<Node>>,
}
#[derive(Debug, serde::Deserialize)]
pub struct CreateExtensionStmt {
#[serde(default)]
pub extname: Option<String>,
#[serde(default)]
pub if_not_exists: bool,
#[serde(default)]
pub options: Option<Vec<Node>>,
}
#[derive(Debug, serde::Deserialize)]
pub struct CreateFdwStmt {
#[serde(default)]
pub fdwname: Option<String>,
#[serde(default)]
pub func_options: Option<Vec<Node>>,
#[serde(default)]
pub options: Option<Vec<Node>>,
}
#[derive(Debug, serde::Deserialize)]
pub struct CreateForeignServerStmt {
#[serde(default)]
pub servername: Option<String>,
#[serde(default)]
pub servertype: Option<String>,
#[serde(default)]
pub version: Option<String>,
#[serde(default)]
pub fdwname: Option<String>,
#[serde(default)]
pub if_not_exists: bool,
#[serde(default)]
pub options: Option<Vec<Node>>,
}
#[derive(Debug, serde::Deserialize)]
pub struct CreateForeignTableStmt {
pub base: Box<CreateStmt>,
#[serde(default)]
pub servername: Option<String>,
#[serde(default)]
pub options: Option<Vec<Node>>,
}
#[derive(Debug, serde::Deserialize)]
pub struct CreateFunctionStmt {
#[serde(default)]
pub is_procedure: bool,
#[serde(default)]
pub replace: bool,
#[serde(default)]
pub funcname: Option<Vec<Node>>,
#[serde(default)]
pub parameters: Option<Vec<Node>>,
#[serde(rename = "returnType")]
pub return_type: Option<Box<TypeName>>,
#[serde(default)]
pub options: Option<Vec<Node>>,
}
#[derive(Debug, serde::Deserialize)]
pub struct CreateOpClassItem {
#[serde(default)]
pub itemtype: i32,
pub name: Option<Box<ObjectWithArgs>>,
#[serde(default)]
pub number: i32,
#[serde(default)]
pub order_family: Option<Vec<Node>>,
#[serde(default)]
pub class_args: Option<Vec<Node>>,
pub storedtype: Option<Box<TypeName>>,
}
#[derive(Debug, serde::Deserialize)]
pub struct CreateOpClassStmt {
#[serde(default)]
pub opclassname: Option<Vec<Node>>,
#[serde(default)]
pub opfamilyname: Option<Vec<Node>>,
#[serde(default)]
pub amname: Option<String>,
pub datatype: Option<Box<TypeName>>,
#[serde(default)]
pub items: Option<Vec<Node>>,
#[serde(rename = "isDefault", default)]
pub is_default: bool,
}
#[derive(Debug, serde::Deserialize)]
pub struct CreateOpFamilyStmt {
#[serde(default)]
pub opfamilyname: Option<Vec<Node>>,
#[serde(default)]
pub amname: Option<String>,
}
#[derive(Debug, serde::Deserialize)]
pub struct CreatePLangStmt {
#[serde(default)]
pub replace: bool,
#[serde(default)]
pub plname: Option<String>,
#[serde(default)]
pub plhandler: Option<Vec<Node>>,
#[serde(default)]
pub plinline: Option<Vec<Node>>,
#[serde(default)]
pub plvalidator: Option<Vec<Node>>,
#[serde(default)]
pub pltrusted: bool,
}
#[derive(Debug, serde::Deserialize)]
pub struct CreatePolicyStmt {
#[serde(default)]
pub policy_name: Option<String>,
pub table: Option<Box<RangeVar>>,
#[serde(default)]
pub cmd_name: Option<String>,
#[serde(default)]
pub permissive: bool,
#[serde(default)]
pub roles: Option<Vec<Node>>,
#[serde(default)]
pub qual: Option<Box<Node>>,
#[serde(default)]
pub with_check: Option<Box<Node>>,
}
#[derive(Debug, serde::Deserialize)]
pub struct CreatePublicationStmt {
#[serde(default)]
pub pubname: Option<String>,
#[serde(default)]
pub options: Option<Vec<Node>>,
#[serde(default)]
pub tables: Option<Vec<Node>>,
#[serde(default)]
pub for_all_tables: bool,
}
#[derive(Debug, serde::Deserialize)]
pub struct CreateRangeStmt {
#[serde(rename = "typeName", default)]
pub type_name: Option<Vec<Node>>,
#[serde(default)]
pub params: Option<Vec<Node>>,
}
#[derive(Debug, serde::Deserialize)]
pub struct CreateRoleStmt {
pub stmt_type: Box<RoleStmtType>,
#[serde(default)]
pub role: Option<String>,
#[serde(default)]
pub options: Option<Vec<Node>>,
}
#[derive(Debug, serde::Deserialize)]
pub struct CreateSchemaStmt {
#[serde(default)]
pub schemaname: Option<String>,
pub authrole: Option<Box<RoleSpec>>,
#[serde(rename = "schemaElts", default)]
pub schema_elts: Option<Vec<Node>>,
#[serde(default)]
pub if_not_exists: bool,
}
#[derive(Debug, serde::Deserialize)]
pub struct CreateSeqStmt {
pub sequence: Option<Box<RangeVar>>,
#[serde(default)]
pub options: Option<Vec<Node>>,
#[serde(rename = "ownerId", default)]
pub owner_id: Oid,
#[serde(default)]
pub for_identity: bool,
#[serde(default)]
pub if_not_exists: bool,
}
#[derive(Debug, serde::Deserialize)]
pub struct CreateStatsStmt {
#[serde(default)]
pub defnames: Option<Vec<Node>>,
#[serde(default)]
pub stat_types: Option<Vec<Node>>,
#[serde(default)]
pub exprs: Option<Vec<Node>>,
#[serde(default)]
pub relations: Option<Vec<Node>>,
#[serde(default)]
pub stxcomment: Option<String>,
#[serde(default)]
pub if_not_exists: bool,
}
#[derive(Debug, serde::Deserialize)]
pub struct CreateStmt {
pub relation: Option<Box<RangeVar>>,
#[serde(rename = "tableElts", default)]
pub table_elts: Option<Vec<Node>>,
#[serde(rename = "inhRelations", default)]
pub inh_relations: Option<Vec<Node>>,
pub partbound: Option<Box<PartitionBoundSpec>>,
pub partspec: Option<Box<PartitionSpec>>,
#[serde(rename = "ofTypename")]
pub of_typename: Option<Box<TypeName>>,
#[serde(default)]
pub constraints: Option<Vec<Node>>,
#[serde(default)]
pub options: Option<Vec<Node>>,
pub oncommit: Box<OnCommitAction>,
#[serde(default)]
pub tablespacename: Option<String>,
#[serde(rename = "accessMethod", default)]
pub access_method: Option<String>,
#[serde(default)]
pub if_not_exists: bool,
}
#[derive(Debug, serde::Deserialize)]
pub struct CreateSubscriptionStmt {
#[serde(default)]
pub subname: Option<String>,
#[serde(default)]
pub conninfo: Option<String>,
#[serde(default)]
pub publication: Option<Vec<Node>>,
#[serde(default)]
pub options: Option<Vec<Node>>,
}
#[derive(Debug, serde::Deserialize)]
pub struct CreateTableAsStmt {
#[serde(default)]
pub query: Option<Box<Node>>,
pub into: Option<Box<IntoClause>>,
pub relkind: Box<ObjectType>,
#[serde(default)]
pub is_select_into: bool,
#[serde(default)]
pub if_not_exists: bool,
}
#[derive(Debug, serde::Deserialize)]
pub struct CreateTableSpaceStmt {
#[serde(default)]
pub tablespacename: Option<String>,
pub owner: Option<Box<RoleSpec>>,
#[serde(default)]
pub location: Option<String>,
#[serde(default)]
pub options: Option<Vec<Node>>,
}
#[derive(Debug, serde::Deserialize)]
pub struct CreateTransformStmt {
#[serde(default)]
pub replace: bool,
pub type_name: Option<Box<TypeName>>,
#[serde(default)]
pub lang: Option<String>,
pub fromsql: Option<Box<ObjectWithArgs>>,
pub tosql: Option<Box<ObjectWithArgs>>,
}
#[derive(Debug, serde::Deserialize)]
pub struct CreateTrigStmt {
#[serde(default)]
pub trigname: Option<String>,
pub relation: Option<Box<RangeVar>>,
#[serde(default)]
pub funcname: Option<Vec<Node>>,
#[serde(default)]
pub args: Option<Vec<Node>>,
#[serde(default)]
pub row: bool,
#[serde(default)]
pub timing: i16,
#[serde(default)]
pub events: i16,
#[serde(default)]
pub columns: Option<Vec<Node>>,
#[serde(rename = "whenClause", default)]
pub when_clause: Option<Box<Node>>,
#[serde(default)]
pub isconstraint: bool,
#[serde(rename = "transitionRels", default)]
pub transition_rels: Option<Vec<Node>>,
#[serde(default)]
pub deferrable: bool,
#[serde(default)]
pub initdeferred: bool,
pub constrrel: Option<Box<RangeVar>>,
}
#[derive(Debug, serde::Deserialize)]
pub struct CreateUserMappingStmt {
pub user: Option<Box<RoleSpec>>,
#[serde(default)]
pub servername: Option<String>,
#[serde(default)]
pub if_not_exists: bool,
#[serde(default)]
pub options: Option<Vec<Node>>,
}
#[derive(Debug, serde::Deserialize)]
pub struct CreatedbStmt {
#[serde(default)]
pub dbname: Option<String>,
#[serde(default)]
pub options: Option<Vec<Node>>,
}
#[derive(Debug, serde::Deserialize)]
pub struct DeallocateStmt {
#[serde(default)]
pub name: Option<String>,
}
#[derive(Debug, serde::Deserialize)]
pub struct DeclareCursorStmt {
#[serde(default)]
pub portalname: Option<String>,
#[serde(default)]
pub options: i32,
#[serde(default)]
pub query: Option<Box<Node>>,
}
#[derive(Debug, serde::Deserialize)]
pub struct DefElem {
#[serde(default)]
pub defnamespace: Option<String>,
#[serde(default)]
pub defname: Option<String>,
#[serde(default)]
pub arg: Option<Box<Node>>,
pub defaction: Box<DefElemAction>,
#[serde(default)]
pub location: i32,
}
#[derive(Debug, serde::Deserialize)]
pub struct DefineStmt {
pub kind: Box<ObjectType>,
#[serde(default)]
pub oldstyle: bool,
#[serde(default)]
pub defnames: Option<Vec<Node>>,
#[serde(default)]
pub args: Option<Vec<Node>>,
#[serde(default)]
pub definition: Option<Vec<Node>>,
#[serde(default)]
pub if_not_exists: bool,
#[serde(default)]
pub replace: bool,
}
#[derive(Debug, serde::Deserialize)]
pub struct DeleteStmt {
pub relation: Option<Box<RangeVar>>,
#[serde(rename = "usingClause", default)]
pub using_clause: Option<Vec<Node>>,
#[serde(rename = "whereClause", default)]
pub where_clause: Option<Box<Node>>,
#[serde(rename = "returningList", default)]
pub returning_list: Option<Vec<Node>>,
#[serde(rename = "withClause")]
pub with_clause: Option<Box<WithClause>>,
}
#[derive(Debug, serde::Deserialize)]
pub struct DiscardStmt {
pub target: Box<DiscardMode>,
}
#[derive(Debug, serde::Deserialize)]
pub struct DoStmt {
#[serde(default)]
pub args: Option<Vec<Node>>,
}
#[derive(Debug, serde::Deserialize)]
pub struct DropOwnedStmt {
#[serde(default)]
pub roles: Option<Vec<Node>>,
pub behavior: Box<DropBehavior>,
}
#[derive(Debug, serde::Deserialize)]
pub struct DropRoleStmt {
#[serde(default)]
pub roles: Option<Vec<Node>>,
#[serde(default)]
pub missing_ok: bool,
}
#[derive(Debug, serde::Deserialize)]
pub struct DropStmt {
#[serde(default)]
pub objects: Option<Vec<Node>>,
#[serde(rename = "removeType")]
pub remove_type: Box<ObjectType>,
pub behavior: Box<DropBehavior>,
#[serde(default)]
pub missing_ok: bool,
#[serde(default)]
pub concurrent: bool,
}
#[derive(Debug, serde::Deserialize)]
pub struct DropSubscriptionStmt {
#[serde(default)]
pub subname: Option<String>,
#[serde(default)]
pub missing_ok: bool,
pub behavior: Box<DropBehavior>,
}
#[derive(Debug, serde::Deserialize)]
pub struct DropTableSpaceStmt {
#[serde(default)]
pub tablespacename: Option<String>,
#[serde(default)]
pub missing_ok: bool,
}
#[derive(Debug, serde::Deserialize)]
pub struct DropUserMappingStmt {
pub user: Option<Box<RoleSpec>>,
#[serde(default)]
pub servername: Option<String>,
#[serde(default)]
pub missing_ok: bool,
}
#[derive(Debug, serde::Deserialize)]
pub struct DropdbStmt {
#[serde(default)]
pub dbname: Option<String>,
#[serde(default)]
pub missing_ok: bool,
#[serde(default)]
pub options: Option<Vec<Node>>,
}
#[derive(Debug, serde::Deserialize)]
pub struct ExecuteStmt {
#[serde(default)]
pub name: Option<String>,
#[serde(default)]
pub params: Option<Vec<Node>>,
}
#[derive(Debug, serde::Deserialize)]
pub struct ExplainStmt {
#[serde(default)]
pub query: Option<Box<Node>>,
#[serde(default)]
pub options: Option<Vec<Node>>,
}
#[derive(Debug, serde::Deserialize)]
pub struct FetchStmt {
pub direction: Box<FetchDirection>,
#[serde(rename = "howMany", default)]
pub how_many: i64,
#[serde(default)]
pub portalname: Option<String>,
#[serde(default)]
pub ismove: bool,
}
#[derive(Debug, serde::Deserialize)]
pub struct FuncCall {
#[serde(default)]
pub funcname: Option<Vec<Node>>,
#[serde(default)]
pub args: Option<Vec<Node>>,
#[serde(default)]
pub agg_order: Option<Vec<Node>>,
#[serde(default)]
pub agg_filter: Option<Box<Node>>,
#[serde(default)]
pub agg_within_group: bool,
#[serde(default)]
pub agg_star: bool,
#[serde(default)]
pub agg_distinct: bool,
#[serde(default)]
pub func_variadic: bool,
pub over: Option<Box<WindowDef>>,
#[serde(default)]
pub location: i32,
}
#[derive(Debug, serde::Deserialize)]
pub struct FunctionParameter {
#[serde(default)]
pub name: Option<String>,
#[serde(rename = "argType")]
pub arg_type: Option<Box<TypeName>>,
pub mode: Box<FunctionParameterMode>,
#[serde(default)]
pub defexpr: Option<Box<Node>>,
}
#[derive(Debug, serde::Deserialize)]
pub struct GrantRoleStmt {
#[serde(default)]
pub granted_roles: Option<Vec<Node>>,
#[serde(default)]
pub grantee_roles: Option<Vec<Node>>,
#[serde(default)]
pub is_grant: bool,
#[serde(default)]
pub admin_opt: bool,
pub grantor: Option<Box<RoleSpec>>,
pub behavior: Box<DropBehavior>,
}
#[derive(Debug, serde::Deserialize)]
pub struct GrantStmt {
#[serde(default)]
pub is_grant: bool,
pub targtype: Box<GrantTargetType>,
pub objtype: Box<ObjectType>,
#[serde(default)]
pub objects: Option<Vec<Node>>,
#[serde(default)]
pub privileges: Option<Vec<Node>>,
#[serde(default)]
pub grantees: Option<Vec<Node>>,
#[serde(default)]
pub grant_option: bool,
pub behavior: Box<DropBehavior>,
}
#[derive(Debug, serde::Deserialize)]
pub struct GroupingSet {
pub kind: Box<GroupingSetKind>,
#[serde(default)]
pub content: Option<Vec<Node>>,
#[serde(default)]
pub location: i32,
}
#[derive(Debug, serde::Deserialize)]
pub struct ImportForeignSchemaStmt {
#[serde(default)]
pub server_name: Option<String>,
#[serde(default)]
pub remote_schema: Option<String>,
#[serde(default)]
pub local_schema: Option<String>,
pub list_type: Box<ImportForeignSchemaType>,
#[serde(default)]
pub table_list: Option<Vec<Node>>,
#[serde(default)]
pub options: Option<Vec<Node>>,
}
#[derive(Debug, serde::Deserialize)]
pub struct IndexElem {
#[serde(default)]
pub name: Option<String>,
#[serde(default)]
pub expr: Option<Box<Node>>,
#[serde(default)]
pub indexcolname: Option<String>,
#[serde(default)]
pub collation: Option<Vec<Node>>,
#[serde(default)]
pub opclass: Option<Vec<Node>>,
#[serde(default)]
pub opclassopts: Option<Vec<Node>>,
pub ordering: Box<SortByDir>,
pub nulls_ordering: Box<SortByNulls>,
}
#[derive(Debug, serde::Deserialize)]
pub struct IndexStmt {
#[serde(default)]
pub idxname: Option<String>,
pub relation: Option<Box<RangeVar>>,
#[serde(rename = "accessMethod", default)]
pub access_method: Option<String>,
#[serde(rename = "tableSpace", default)]
pub table_space: Option<String>,
#[serde(rename = "indexParams", default)]
pub index_params: Option<Vec<Node>>,
#[serde(rename = "indexIncludingParams", default)]
pub index_including_params: Option<Vec<Node>>,
#[serde(default)]
pub options: Option<Vec<Node>>,
#[serde(rename = "whereClause", default)]
pub where_clause: Option<Box<Node>>,
#[serde(rename = "excludeOpNames", default)]
pub exclude_op_names: Option<Vec<Node>>,
#[serde(default)]
pub idxcomment: Option<String>,
#[serde(rename = "indexOid", default)]
pub index_oid: Oid,
#[serde(rename = "oldNode", default)]
pub old_node: Oid,
#[serde(rename = "oldCreateSubid", default)]
pub old_create_subid: SubTransactionId,
#[serde(rename = "oldFirstRelfilenodeSubid", default)]
pub old_first_relfilenode_subid: SubTransactionId,
#[serde(default)]
pub unique: bool,
#[serde(default)]
pub primary: bool,
#[serde(default)]
pub isconstraint: bool,
#[serde(default)]
pub deferrable: bool,
#[serde(default)]
pub initdeferred: bool,
#[serde(default)]
pub transformed: bool,
#[serde(default)]
pub concurrent: bool,
#[serde(default)]
pub if_not_exists: bool,
#[serde(default)]
pub reset_default_tblspc: bool,
}
#[derive(Debug, serde::Deserialize)]
pub struct InferClause {
#[serde(rename = "indexElems", default)]
pub index_elems: Option<Vec<Node>>,
#[serde(rename = "whereClause", default)]
pub where_clause: Option<Box<Node>>,
#[serde(default)]
pub conname: Option<String>,
#[serde(default)]
pub location: i32,
}
#[derive(Debug, serde::Deserialize)]
pub struct InlineCodeBlock {
#[serde(default)]
pub source_text: Option<String>,
#[serde(rename = "langOid", default)]
pub lang_oid: Oid,
#[serde(rename = "langIsTrusted", default)]
pub lang_is_trusted: bool,
#[serde(default)]
pub atomic: bool,
}
#[derive(Debug, serde::Deserialize)]
pub struct InsertStmt {
pub relation: Option<Box<RangeVar>>,
#[serde(default)]
pub cols: Option<Vec<Node>>,
#[serde(rename = "selectStmt", default)]
pub select_stmt: Option<Box<Node>>,
#[serde(rename = "onConflictClause")]
pub on_conflict_clause: Option<Box<OnConflictClause>>,
#[serde(rename = "returningList", default)]
pub returning_list: Option<Vec<Node>>,
#[serde(rename = "withClause")]
pub with_clause: Option<Box<WithClause>>,
#[serde(rename = "override")]
pub override_: Box<OverridingKind>,
}
#[derive(Debug, serde::Deserialize)]
pub struct ListenStmt {
#[serde(default)]
pub conditionname: Option<String>,
}
#[derive(Debug, serde::Deserialize)]
pub struct LoadStmt {
#[serde(default)]
pub filename: Option<String>,
}
#[derive(Debug, serde::Deserialize)]
pub struct LockStmt {
#[serde(default)]
pub relations: Option<Vec<Node>>,
#[serde(default)]
pub mode: i32,
#[serde(default)]
pub nowait: bool,
}
#[derive(Debug, serde::Deserialize)]
pub struct LockingClause {
#[serde(rename = "lockedRels", default)]
pub locked_rels: Option<Vec<Node>>,
pub strength: Box<LockClauseStrength>,
#[serde(rename = "waitPolicy")]
pub wait_policy: Box<LockWaitPolicy>,
}
#[derive(Debug, serde::Deserialize)]
pub struct MultiAssignRef {
#[serde(default)]
pub source: Option<Box<Node>>,
#[serde(default)]
pub colno: i32,
#[serde(default)]
pub ncolumns: i32,
}
#[derive(Debug, serde::Deserialize)]
pub struct NotifyStmt {
#[serde(default)]
pub conditionname: Option<String>,
#[serde(default)]
pub payload: Option<String>,
}
#[derive(Debug, serde::Deserialize)]
pub struct ObjectWithArgs {
#[serde(default)]
pub objname: Option<Vec<Node>>,
#[serde(default)]
pub objargs: Option<Vec<Node>>,
#[serde(default)]
pub args_unspecified: bool,
}
#[derive(Debug, serde::Deserialize)]
pub struct OnConflictClause {
pub action: Box<OnConflictAction>,
pub infer: Option<Box<InferClause>>,
#[serde(rename = "targetList", default)]
pub target_list: Option<Vec<Node>>,
#[serde(rename = "whereClause", default)]
pub where_clause: Option<Box<Node>>,
#[serde(default)]
pub location: i32,
}
#[derive(Debug, serde::Deserialize)]
pub struct ParamRef {
#[serde(default)]
pub number: i32,
#[serde(default)]
pub location: i32,
}
#[derive(Debug, serde::Deserialize)]
pub struct PartitionBoundSpec {
#[serde(default)]
pub strategy: char,
#[serde(default)]
pub is_default: bool,
#[serde(default)]
pub modulus: i32,
#[serde(default)]
pub remainder: i32,
#[serde(default)]
pub listdatums: Option<Vec<Node>>,
#[serde(default)]
pub lowerdatums: Option<Vec<Node>>,
#[serde(default)]
pub upperdatums: Option<Vec<Node>>,
#[serde(default)]
pub location: i32,
}
#[derive(Debug, serde::Deserialize)]
pub struct PartitionCmd {
pub name: Option<Box<RangeVar>>,
pub bound: Option<Box<PartitionBoundSpec>>,
}
#[derive(Debug, serde::Deserialize)]
pub struct PartitionElem {
#[serde(default)]
pub name: Option<String>,
#[serde(default)]
pub expr: Option<Box<Node>>,
#[serde(default)]
pub collation: Option<Vec<Node>>,
#[serde(default)]
pub opclass: Option<Vec<Node>>,
#[serde(default)]
pub location: i32,
}
#[derive(Debug, serde::Deserialize)]
pub struct PartitionRangeDatum {
pub kind: Box<PartitionRangeDatumKind>,
#[serde(default)]
pub value: Option<Box<Node>>,
#[serde(default)]
pub location: i32,
}
#[derive(Debug, serde::Deserialize)]
pub struct PartitionSpec {
#[serde(default)]
pub strategy: Option<String>,
#[serde(rename = "partParams", default)]
pub part_params: Option<Vec<Node>>,
#[serde(default)]
pub location: i32,
}
#[derive(Debug, serde::Deserialize)]
pub struct PrepareStmt {
#[serde(default)]
pub name: Option<String>,
#[serde(default)]
pub argtypes: Option<Vec<Node>>,
#[serde(default)]
pub query: Option<Box<Node>>,
}
#[derive(Debug, serde::Deserialize)]
pub struct Query {
#[serde(rename = "commandType")]
pub command_type: Box<CmdType>,
#[serde(rename = "querySource")]
pub query_source: Box<QuerySource>,
#[serde(rename = "queryId", default)]
pub query_id: u64,
#[serde(rename = "canSetTag", default)]
pub can_set_tag: bool,
#[serde(rename = "utilityStmt", default)]
pub utility_stmt: Option<Box<Node>>,
#[serde(rename = "resultRelation", default)]
pub result_relation: i32,
#[serde(rename = "hasAggs", default)]
pub has_aggs: bool,
#[serde(rename = "hasWindowFuncs", default)]
pub has_window_funcs: bool,
#[serde(rename = "hasTargetSRFs", default)]
pub has_target_sr_fs: bool,
#[serde(rename = "hasSubLinks", default)]
pub has_sub_links: bool,
#[serde(rename = "hasDistinctOn", default)]
pub has_distinct_on: bool,
#[serde(rename = "hasRecursive", default)]
pub has_recursive: bool,
#[serde(rename = "hasModifyingCTE", default)]
pub has_modifying_cte: bool,
#[serde(rename = "hasForUpdate", default)]
pub has_for_update: bool,
#[serde(rename = "hasRowSecurity", default)]
pub has_row_security: bool,
#[serde(rename = "cteList", default)]
pub cte_list: Option<Vec<Node>>,
#[serde(default)]
pub rtable: Option<Vec<Node>>,
pub jointree: Option<Box<FromExpr>>,
#[serde(rename = "targetList", default)]
pub target_list: Option<Vec<Node>>,
#[serde(rename = "override")]
pub override_: Box<OverridingKind>,
#[serde(rename = "onConflict")]
pub on_conflict: Option<Box<OnConflictExpr>>,
#[serde(rename = "returningList", default)]
pub returning_list: Option<Vec<Node>>,
#[serde(rename = "groupClause", default)]
pub group_clause: Option<Vec<Node>>,
#[serde(rename = "groupingSets", default)]
pub grouping_sets: Option<Vec<Node>>,
#[serde(rename = "havingQual", default)]
pub having_qual: Option<Box<Node>>,
#[serde(rename = "windowClause", default)]
pub window_clause: Option<Vec<Node>>,
#[serde(rename = "distinctClause", default)]
pub distinct_clause: Option<Vec<Node>>,
#[serde(rename = "sortClause", default)]
pub sort_clause: Option<Vec<Node>>,
#[serde(rename = "limitOffset", default)]
pub limit_offset: Option<Box<Node>>,
#[serde(rename = "limitCount", default)]
pub limit_count: Option<Box<Node>>,
#[serde(rename = "limitOption")]
pub limit_option: Box<LimitOption>,
#[serde(rename = "rowMarks", default)]
pub row_marks: Option<Vec<Node>>,
#[serde(rename = "setOperations", default)]
pub set_operations: Option<Box<Node>>,
#[serde(rename = "constraintDeps", default)]
pub constraint_deps: Option<Vec<Node>>,
#[serde(rename = "withCheckOptions", default)]
pub with_check_options: Option<Vec<Node>>,
#[serde(default)]
pub stmt_location: i32,
#[serde(default)]
pub stmt_len: i32,
}
#[derive(Debug, serde::Deserialize)]
pub struct RangeFunction {
#[serde(default)]
pub lateral: bool,
#[serde(default)]
pub ordinality: bool,
#[serde(default)]
pub is_rowsfrom: bool,
#[serde(default)]
pub functions: Option<Vec<Node>>,
pub alias: Option<Box<Alias>>,
#[serde(default)]
pub coldeflist: Option<Vec<Node>>,
}
#[derive(Debug, serde::Deserialize)]
pub struct RangeSubselect {
#[serde(default)]
pub lateral: bool,
#[serde(default)]
pub subquery: Option<Box<Node>>,
pub alias: Option<Box<Alias>>,
}
#[derive(Debug, serde::Deserialize)]
pub struct RangeTableFunc {
#[serde(default)]
pub lateral: bool,
#[serde(default)]
pub docexpr: Option<Box<Node>>,
#[serde(default)]
pub rowexpr: Option<Box<Node>>,
#[serde(default)]
pub namespaces: Option<Vec<Node>>,
#[serde(default)]
pub columns: Option<Vec<Node>>,
pub alias: Option<Box<Alias>>,
#[serde(default)]
pub location: i32,
}
#[derive(Debug, serde::Deserialize)]
pub struct RangeTableFuncCol {
#[serde(default)]
pub colname: Option<String>,
#[serde(rename = "typeName")]
pub type_name: Option<Box<TypeName>>,
#[serde(default)]
pub for_ordinality: bool,
#[serde(default)]
pub is_not_null: bool,
#[serde(default)]
pub colexpr: Option<Box<Node>>,
#[serde(default)]
pub coldefexpr: Option<Box<Node>>,
#[serde(default)]
pub location: i32,
}
#[derive(Debug, serde::Deserialize)]
pub struct RangeTableSample {
#[serde(default)]
pub relation: Option<Box<Node>>,
#[serde(default)]
pub method: Option<Vec<Node>>,
#[serde(default)]
pub args: Option<Vec<Node>>,
#[serde(default)]
pub repeatable: Option<Box<Node>>,
#[serde(default)]
pub location: i32,
}
#[derive(Debug, serde::Deserialize)]
pub struct RangeTblEntry {
pub rtekind: Box<RTEKind>,
#[serde(default)]
pub relid: Oid,
#[serde(default)]
pub relkind: char,
#[serde(default)]
pub rellockmode: i32,
pub tablesample: Option<Box<TableSampleClause>>,
pub subquery: Option<Box<Query>>,
#[serde(default)]
pub security_barrier: bool,
pub jointype: Box<JoinType>,
#[serde(default)]
pub joinmergedcols: i32,
#[serde(default)]
pub joinaliasvars: Option<Vec<Node>>,
#[serde(default)]
pub joinleftcols: Option<Vec<Node>>,
#[serde(default)]
pub joinrightcols: Option<Vec<Node>>,
#[serde(default)]
pub functions: Option<Vec<Node>>,
#[serde(default)]
pub funcordinality: bool,
pub tablefunc: Option<Box<TableFunc>>,
#[serde(default)]
pub values_lists: Option<Vec<Node>>,
#[serde(default)]
pub ctename: Option<String>,
#[serde(default)]
pub ctelevelsup: Index,
#[serde(default)]
pub self_reference: bool,
#[serde(default)]
pub coltypes: Option<Vec<Node>>,
#[serde(default)]
pub coltypmods: Option<Vec<Node>>,
#[serde(default)]
pub colcollations: Option<Vec<Node>>,
#[serde(default)]
pub enrname: Option<String>,
#[serde(default)]
pub enrtuples: f64,
pub alias: Option<Box<Alias>>,
pub eref: Option<Box<Alias>>,
#[serde(default)]
pub lateral: bool,
#[serde(default)]
pub inh: bool,
#[serde(rename = "inFromCl", default)]
pub in_from_cl: bool,
#[serde(rename = "requiredPerms", default)]
pub required_perms: AclMode,
#[serde(rename = "checkAsUser", default)]
pub check_as_user: Oid,
#[serde(rename = "selectedCols", default)]
pub selected_cols: Option<Vec<u32>>,
#[serde(rename = "insertedCols", default)]
pub inserted_cols: Option<Vec<u32>>,
#[serde(rename = "updatedCols", default)]
pub updated_cols: Option<Vec<u32>>,
#[serde(rename = "extraUpdatedCols", default)]
pub extra_updated_cols: Option<Vec<u32>>,
#[serde(rename = "securityQuals", default)]
pub security_quals: Option<Vec<Node>>,
}
#[derive(Debug, serde::Deserialize)]
pub struct RangeTblFunction {
#[serde(default)]
pub funcexpr: Option<Box<Node>>,
#[serde(default)]
pub funccolcount: i32,
#[serde(default)]
pub funccolnames: Option<Vec<Node>>,
#[serde(default)]
pub funccoltypes: Option<Vec<Node>>,
#[serde(default)]
pub funccoltypmods: Option<Vec<Node>>,
#[serde(default)]
pub funccolcollations: Option<Vec<Node>>,
#[serde(default)]
pub funcparams: Option<Vec<u32>>,
}
#[derive(Debug, serde::Deserialize)]
pub struct RawStmt {
#[serde(default)]
pub stmt: Option<Box<Node>>,
#[serde(default)]
pub stmt_location: i32,
#[serde(default)]
pub stmt_len: i32,
}
#[derive(Debug, serde::Deserialize)]
pub struct ReassignOwnedStmt {
#[serde(default)]
pub roles: Option<Vec<Node>>,
pub newrole: Option<Box<RoleSpec>>,
}
#[derive(Debug, serde::Deserialize)]
pub struct RefreshMatViewStmt {
#[serde(default)]
pub concurrent: bool,
#[serde(rename = "skipData", default)]
pub skip_data: bool,
pub relation: Option<Box<RangeVar>>,
}
#[derive(Debug, serde::Deserialize)]
pub struct ReindexStmt {
pub kind: Box<ReindexObjectType>,
pub relation: Option<Box<RangeVar>>,
#[serde(default)]
pub name: Option<String>,
#[serde(default)]
pub options: i32,
#[serde(default)]
pub concurrent: bool,
}
#[derive(Debug, serde::Deserialize)]
pub struct RenameStmt {
#[serde(rename = "renameType")]
pub rename_type: Box<ObjectType>,
#[serde(rename = "relationType")]
pub relation_type: Box<ObjectType>,
pub relation: Option<Box<RangeVar>>,
#[serde(default)]
pub object: Option<Box<Node>>,
#[serde(default)]
pub subname: Option<String>,
#[serde(default)]
pub newname: Option<String>,
pub behavior: Box<DropBehavior>,
#[serde(default)]
pub missing_ok: bool,
}
#[derive(Debug, serde::Deserialize)]
pub struct ReplicaIdentityStmt {
#[serde(default)]
pub identity_type: char,
#[serde(default)]
pub name: Option<String>,
}
#[derive(Debug, serde::Deserialize)]
pub struct ResTarget {
#[serde(default)]
pub name: Option<String>,
#[serde(default)]
pub indirection: Option<Vec<Node>>,
#[serde(default)]
pub val: Option<Box<Node>>,
#[serde(default)]
pub location: i32,
}
#[derive(Debug, serde::Deserialize)]
pub struct RoleSpec {
pub roletype: Box<RoleSpecType>,
#[serde(default)]
pub rolename: Option<String>,
#[serde(default)]
pub location: i32,
}
#[derive(Debug, serde::Deserialize)]
pub struct RowMarkClause {
#[serde(default)]
pub rti: Index,
pub strength: Box<LockClauseStrength>,
#[serde(rename = "waitPolicy")]
pub wait_policy: Box<LockWaitPolicy>,
#[serde(rename = "pushedDown", default)]
pub pushed_down: bool,
}
#[derive(Debug, serde::Deserialize)]
pub struct RuleStmt {
pub relation: Option<Box<RangeVar>>,
#[serde(default)]
pub rulename: Option<String>,
#[serde(rename = "whereClause", default)]
pub where_clause: Option<Box<Node>>,
pub event: Box<CmdType>,
#[serde(default)]
pub instead: bool,
#[serde(default)]
pub actions: Option<Vec<Node>>,
#[serde(default)]
pub replace: bool,
}
#[derive(Debug, serde::Deserialize)]
pub struct SecLabelStmt {
pub objtype: Box<ObjectType>,
#[serde(default)]
pub object: Option<Box<Node>>,
#[serde(default)]
pub provider: Option<String>,
#[serde(default)]
pub label: Option<String>,
}
#[derive(Debug, serde::Deserialize)]
pub struct SelectStmt {
#[serde(rename = "distinctClause", default)]
pub distinct_clause: Option<Vec<Node>>,
#[serde(rename = "intoClause")]
pub into_clause: Option<Box<IntoClause>>,
#[serde(rename = "targetList", default)]
pub target_list: Option<Vec<Node>>,
#[serde(rename = "fromClause", default)]
pub from_clause: Option<Vec<Node>>,
#[serde(rename = "whereClause", default)]
pub where_clause: Option<Box<Node>>,
#[serde(rename = "groupClause", default)]
pub group_clause: Option<Vec<Node>>,
#[serde(rename = "havingClause", default)]
pub having_clause: Option<Box<Node>>,
#[serde(rename = "windowClause", default)]
pub window_clause: Option<Vec<Node>>,
#[serde(rename = "valuesLists", default)]
pub values_lists: Option<Vec<Node>>,
#[serde(rename = "sortClause", default)]
pub sort_clause: Option<Vec<Node>>,
#[serde(rename = "limitOffset", default)]
pub limit_offset: Option<Box<Node>>,
#[serde(rename = "limitCount", default)]
pub limit_count: Option<Box<Node>>,
#[serde(rename = "limitOption")]
pub limit_option: Box<LimitOption>,
#[serde(rename = "lockingClause", default)]
pub locking_clause: Option<Vec<Node>>,
#[serde(rename = "withClause")]
pub with_clause: Option<Box<WithClause>>,
pub op: Box<SetOperation>,
#[serde(default)]
pub all: bool,
pub larg: Option<Box<SelectStmt>>,
pub rarg: Option<Box<SelectStmt>>,
}
#[derive(Debug, serde::Deserialize)]
pub struct SetOperationStmt {
pub op: Box<SetOperation>,
#[serde(default)]
pub all: bool,
#[serde(default)]
pub larg: Option<Box<Node>>,
#[serde(default)]
pub rarg: Option<Box<Node>>,
#[serde(rename = "colTypes", default)]
pub col_types: Option<Vec<Node>>,
#[serde(rename = "colTypmods", default)]
pub col_typmods: Option<Vec<Node>>,
#[serde(rename = "colCollations", default)]
pub col_collations: Option<Vec<Node>>,
#[serde(rename = "groupClauses", default)]
pub group_clauses: Option<Vec<Node>>,
}
#[derive(Debug, serde::Deserialize)]
pub struct SortBy {
#[serde(default)]
pub node: Option<Box<Node>>,
pub sortby_dir: Box<SortByDir>,
pub sortby_nulls: Box<SortByNulls>,
#[serde(rename = "useOp", default)]
pub use_op: Option<Vec<Node>>,
#[serde(default)]
pub location: i32,
}
#[derive(Debug, serde::Deserialize)]
pub struct SortGroupClause {
#[serde(rename = "tleSortGroupRef", default)]
pub tle_sort_group_ref: Index,
#[serde(default)]
pub eqop: Oid,
#[serde(default)]
pub sortop: Oid,
#[serde(default)]
pub nulls_first: bool,
#[serde(default)]
pub hashable: bool,
}
#[derive(Debug, serde::Deserialize)]
pub struct TableLikeClause {
pub relation: Option<Box<RangeVar>>,
#[serde(default)]
pub options: bits32,
#[serde(rename = "relationOid", default)]
pub relation_oid: Oid,
}
#[derive(Debug, serde::Deserialize)]
pub struct TableSampleClause {
#[serde(default)]
pub tsmhandler: Oid,
#[serde(default)]
pub args: Option<Vec<Node>>,
#[serde(default)]
pub repeatable: Option<Box<Node>>,
}
#[derive(Debug, serde::Deserialize)]
pub struct TransactionStmt {
pub kind: Box<TransactionStmtKind>,
#[serde(default)]
pub options: Option<Vec<Node>>,
#[serde(default)]
pub savepoint_name: Option<String>,
#[serde(default)]
pub gid: Option<String>,
#[serde(default)]
pub chain: bool,
}
#[derive(Debug, serde::Deserialize)]
pub struct TriggerTransition {
#[serde(default)]
pub name: Option<String>,
#[serde(rename = "isNew", default)]
pub is_new: bool,
#[serde(rename = "isTable", default)]
pub is_table: bool,
}
#[derive(Debug, serde::Deserialize)]
pub struct TruncateStmt {
#[serde(default)]
pub relations: Option<Vec<Node>>,
#[serde(default)]
pub restart_seqs: bool,
pub behavior: Box<DropBehavior>,
}
#[derive(Debug, serde::Deserialize)]
pub struct TypeCast {
#[serde(default)]
pub arg: Option<Box<Node>>,
#[serde(rename = "typeName")]
pub type_name: Option<Box<TypeName>>,
#[serde(default)]
pub location: i32,
}
#[derive(Debug, serde::Deserialize)]
pub struct TypeName {
#[serde(default)]
pub names: Option<Vec<Node>>,
#[serde(rename = "typeOid", default)]
pub type_oid: Oid,
#[serde(default)]
pub setof: bool,
#[serde(default)]
pub pct_type: bool,
#[serde(default)]
pub typmods: Option<Vec<Node>>,
#[serde(default)]
pub typemod: i32,
#[serde(rename = "arrayBounds", default)]
pub array_bounds: Option<Vec<Node>>,
#[serde(default)]
pub location: i32,
}
#[derive(Debug, serde::Deserialize)]
pub struct UnlistenStmt {
#[serde(default)]
pub conditionname: Option<String>,
}
#[derive(Debug, serde::Deserialize)]
pub struct UpdateStmt {
pub relation: Option<Box<RangeVar>>,
#[serde(rename = "targetList", default)]
pub target_list: Option<Vec<Node>>,
#[serde(rename = "whereClause", default)]
pub where_clause: Option<Box<Node>>,
#[serde(rename = "fromClause", default)]
pub from_clause: Option<Vec<Node>>,
#[serde(rename = "returningList", default)]
pub returning_list: Option<Vec<Node>>,
#[serde(rename = "withClause")]
pub with_clause: Option<Box<WithClause>>,
}
#[derive(Debug, serde::Deserialize)]
pub struct VacuumRelation {
pub relation: Option<Box<RangeVar>>,
#[serde(default)]
pub oid: Oid,
#[serde(default)]
pub va_cols: Option<Vec<Node>>,
}
#[derive(Debug, serde::Deserialize)]
pub struct VacuumStmt {
#[serde(default)]
pub options: Option<Vec<Node>>,
#[serde(default)]
pub rels: Option<Vec<Node>>,
#[serde(default)]
pub is_vacuumcmd: bool,
}
#[derive(Debug, serde::Deserialize)]
pub struct VariableSetStmt {
pub kind: Box<VariableSetKind>,
#[serde(default)]
pub name: Option<String>,
#[serde(default)]
pub args: Option<Vec<Node>>,
#[serde(default)]
pub is_local: bool,
}
#[derive(Debug, serde::Deserialize)]
pub struct VariableShowStmt {
#[serde(default)]
pub name: Option<String>,
}
#[derive(Debug, serde::Deserialize)]
pub struct ViewStmt {
pub view: Option<Box<RangeVar>>,
#[serde(default)]
pub aliases: Option<Vec<Node>>,
#[serde(default)]
pub query: Option<Box<Node>>,
#[serde(default)]
pub replace: bool,
#[serde(default)]
pub options: Option<Vec<Node>>,
#[serde(rename = "withCheckOption")]
pub with_check_option: Box<ViewCheckOption>,
}
#[derive(Debug, serde::Deserialize)]
pub struct WindowClause {
#[serde(default)]
pub name: Option<String>,
#[serde(default)]
pub refname: Option<String>,
#[serde(rename = "partitionClause", default)]
pub partition_clause: Option<Vec<Node>>,
#[serde(rename = "orderClause", default)]
pub order_clause: Option<Vec<Node>>,
#[serde(rename = "frameOptions", default)]
pub frame_options: i32,
#[serde(rename = "startOffset", default)]
pub start_offset: Option<Box<Node>>,
#[serde(rename = "endOffset", default)]
pub end_offset: Option<Box<Node>>,
#[serde(rename = "startInRangeFunc", default)]
pub start_in_range_func: Oid,
#[serde(rename = "endInRangeFunc", default)]
pub end_in_range_func: Oid,
#[serde(rename = "inRangeColl", default)]
pub in_range_coll: Oid,
#[serde(rename = "inRangeAsc", default)]
pub in_range_asc: bool,
#[serde(rename = "inRangeNullsFirst", default)]
pub in_range_nulls_first: bool,
#[serde(default)]
pub winref: Index,
#[serde(rename = "copiedOrder", default)]
pub copied_order: bool,
}
#[derive(Debug, serde::Deserialize)]
pub struct WindowDef {
#[serde(default)]
pub name: Option<String>,
#[serde(default)]
pub refname: Option<String>,
#[serde(rename = "partitionClause", default)]
pub partition_clause: Option<Vec<Node>>,
#[serde(rename = "orderClause", default)]
pub order_clause: Option<Vec<Node>>,
#[serde(rename = "frameOptions", default)]
pub frame_options: i32,
#[serde(rename = "startOffset", default)]
pub start_offset: Option<Box<Node>>,
#[serde(rename = "endOffset", default)]
pub end_offset: Option<Box<Node>>,
#[serde(default)]
pub location: i32,
}
#[derive(Debug, serde::Deserialize)]
pub struct WithCheckOption {
pub kind: Box<WCOKind>,
#[serde(default)]
pub relname: Option<String>,
#[serde(default)]
pub polname: Option<String>,
#[serde(default)]
pub qual: Option<Box<Node>>,
#[serde(default)]
pub cascaded: bool,
}
#[derive(Debug, serde::Deserialize)]
pub struct WithClause {
#[serde(default)]
pub ctes: Option<Vec<Node>>,
#[serde(default)]
pub recursive: bool,
#[serde(default)]
pub location: i32,
}
#[derive(Debug, serde::Deserialize)]
pub struct XmlSerialize {
pub xmloption: Box<XmlOptionType>,
#[serde(default)]
pub expr: Option<Box<Node>>,
#[serde(rename = "typeName")]
pub type_name: Option<Box<TypeName>>,
#[serde(default)]
pub location: i32,
}
#[derive(Debug, serde::Deserialize)]
pub struct Aggref {
#[serde(default)]
pub aggfnoid: Oid,
#[serde(default)]
pub aggtype: Oid,
#[serde(default)]
pub aggcollid: Oid,
#[serde(default)]
pub inputcollid: Oid,
#[serde(default)]
pub aggtranstype: Oid,
#[serde(default)]
pub aggargtypes: Option<Vec<Node>>,
#[serde(default)]
pub aggdirectargs: Option<Vec<Node>>,
#[serde(default)]
pub args: Option<Vec<Node>>,
#[serde(default)]
pub aggorder: Option<Vec<Node>>,
#[serde(default)]
pub aggdistinct: Option<Vec<Node>>,
#[serde(default)]
pub aggfilter: Option<Box<Node>>,
#[serde(default)]
pub aggstar: bool,
#[serde(default)]
pub aggvariadic: bool,
#[serde(default)]
pub aggkind: char,
#[serde(default)]
pub agglevelsup: Index,
pub aggsplit: Box<AggSplit>,
#[serde(default)]
pub location: i32,
}
#[derive(Debug, serde::Deserialize)]
pub struct Alias {
#[serde(default)]
pub aliasname: Option<String>,
#[serde(default)]
pub colnames: Option<Vec<Node>>,
}
#[derive(Debug, serde::Deserialize)]
pub struct AlternativeSubPlan {
#[serde(default)]
pub subplans: Option<Vec<Node>>,
}
#[derive(Debug, serde::Deserialize)]
pub struct ArrayCoerceExpr {
#[serde(default)]
pub arg: Option<Box<Node>>,
#[serde(default)]
pub elemexpr: Option<Box<Node>>,
#[serde(default)]
pub resulttype: Oid,
#[serde(default)]
pub resulttypmod: i32,
#[serde(default)]
pub resultcollid: Oid,
pub coerceformat: Box<CoercionForm>,
#[serde(default)]
pub location: i32,
}
#[derive(Debug, serde::Deserialize)]
pub struct ArrayExpr {
#[serde(default)]
pub array_typeid: Oid,
#[serde(default)]
pub array_collid: Oid,
#[serde(default)]
pub element_typeid: Oid,
#[serde(default)]
pub elements: Option<Vec<Node>>,
#[serde(default)]
pub multidims: bool,
#[serde(default)]
pub location: i32,
}
#[derive(Debug, serde::Deserialize)]
pub struct BoolExpr {
pub boolop: Box<BoolExprType>,
#[serde(default)]
pub args: Option<Vec<Node>>,
#[serde(default)]
pub location: i32,
}
#[derive(Debug, serde::Deserialize)]
pub struct BooleanTest {
#[serde(default)]
pub arg: Option<Box<Node>>,
pub booltesttype: Box<BoolTestType>,
#[serde(default)]
pub location: i32,
}
#[derive(Debug, serde::Deserialize)]
pub struct CaseExpr {
#[serde(default)]
pub casetype: Oid,
#[serde(default)]
pub casecollid: Oid,
#[serde(default)]
pub arg: Option<Box<Node>>,
#[serde(default)]
pub args: Option<Vec<Node>>,
#[serde(default)]
pub defresult: Option<Box<Node>>,
#[serde(default)]
pub location: i32,
}
#[derive(Debug, serde::Deserialize)]
pub struct CaseTestExpr {
#[serde(rename = "typeId", default)]
pub type_id: Oid,
#[serde(rename = "typeMod", default)]
pub type_mod: i32,
#[serde(default)]
pub collation: Oid,
}
#[derive(Debug, serde::Deserialize)]
pub struct CaseWhen {
#[serde(default)]
pub expr: Option<Box<Node>>,
#[serde(default)]
pub result: Option<Box<Node>>,
#[serde(default)]
pub location: i32,
}
#[derive(Debug, serde::Deserialize)]
pub struct CoalesceExpr {
#[serde(default)]
pub coalescetype: Oid,
#[serde(default)]
pub coalescecollid: Oid,
#[serde(default)]
pub args: Option<Vec<Node>>,
#[serde(default)]
pub location: i32,
}
#[derive(Debug, serde::Deserialize)]
pub struct CoerceToDomain {
#[serde(default)]
pub arg: Option<Box<Node>>,
#[serde(default)]
pub resulttype: Oid,
#[serde(default)]
pub resulttypmod: i32,
#[serde(default)]
pub resultcollid: Oid,
pub coercionformat: Box<CoercionForm>,
#[serde(default)]
pub location: i32,
}
#[derive(Debug, serde::Deserialize)]
pub struct CoerceToDomainValue {
#[serde(rename = "typeId", default)]
pub type_id: Oid,
#[serde(rename = "typeMod", default)]
pub type_mod: i32,
#[serde(default)]
pub collation: Oid,
#[serde(default)]
pub location: i32,
}
#[derive(Debug, serde::Deserialize)]
pub struct CoerceViaIO {
#[serde(default)]
pub arg: Option<Box<Node>>,
#[serde(default)]
pub resulttype: Oid,
#[serde(default)]
pub resultcollid: Oid,
pub coerceformat: Box<CoercionForm>,
#[serde(default)]
pub location: i32,
}
#[derive(Debug, serde::Deserialize)]
pub struct CollateExpr {
#[serde(default)]
pub arg: Option<Box<Node>>,
#[serde(rename = "collOid", default)]
pub coll_oid: Oid,
#[serde(default)]
pub location: i32,
}
#[derive(Debug, serde::Deserialize)]
pub struct Const {
#[serde(default)]
pub consttype: Oid,
#[serde(default)]
pub consttypmod: i32,
#[serde(default)]
pub constcollid: Oid,
#[serde(default)]
pub constlen: i32,
#[serde(default)]
pub constvalue: Datum,
#[serde(default)]
pub constisnull: bool,
#[serde(default)]
pub constbyval: bool,
#[serde(default)]
pub location: i32,
}
#[derive(Debug, serde::Deserialize)]
pub struct ConvertRowtypeExpr {
#[serde(default)]
pub arg: Option<Box<Node>>,
#[serde(default)]
pub resulttype: Oid,
pub convertformat: Box<CoercionForm>,
#[serde(default)]
pub location: i32,
}
#[derive(Debug, serde::Deserialize)]
pub struct CurrentOfExpr {
#[serde(default)]
pub cvarno: Index,
#[serde(default)]
pub cursor_name: Option<String>,
#[serde(default)]
pub cursor_param: i32,
}
#[derive(Debug, serde::Deserialize)]
pub struct Expr {
}
#[derive(Debug, serde::Deserialize)]
pub struct FieldSelect {
#[serde(default)]
pub arg: Option<Box<Node>>,
#[serde(default)]
pub fieldnum: AttrNumber,
#[serde(default)]
pub resulttype: Oid,
#[serde(default)]
pub resulttypmod: i32,
#[serde(default)]
pub resultcollid: Oid,
}
#[derive(Debug, serde::Deserialize)]
pub struct FieldStore {
#[serde(default)]
pub arg: Option<Box<Node>>,
#[serde(default)]
pub newvals: Option<Vec<Node>>,
#[serde(default)]
pub fieldnums: Option<Vec<Node>>,
#[serde(default)]
pub resulttype: Oid,
}
#[derive(Debug, serde::Deserialize)]
pub struct FromExpr {
#[serde(default)]
pub fromlist: Option<Vec<Node>>,
#[serde(default)]
pub quals: Option<Box<Node>>,
}
#[derive(Debug, serde::Deserialize)]
pub struct FuncExpr {
#[serde(default)]
pub funcid: Oid,
#[serde(default)]
pub funcresulttype: Oid,
#[serde(default)]
pub funcretset: bool,
#[serde(default)]
pub funcvariadic: bool,
pub funcformat: Box<CoercionForm>,
#[serde(default)]
pub funccollid: Oid,
#[serde(default)]
pub inputcollid: Oid,
#[serde(default)]
pub args: Option<Vec<Node>>,
#[serde(default)]
pub location: i32,
}
#[derive(Debug, serde::Deserialize)]
pub struct GroupingFunc {
#[serde(default)]
pub args: Option<Vec<Node>>,
#[serde(default)]
pub refs: Option<Vec<Node>>,
#[serde(default)]
pub cols: Option<Vec<Node>>,
#[serde(default)]
pub agglevelsup: Index,
#[serde(default)]
pub location: i32,
}
#[derive(Debug, serde::Deserialize)]
pub struct InferenceElem {
#[serde(default)]
pub expr: Option<Box<Node>>,
#[serde(default)]
pub infercollid: Oid,
#[serde(default)]
pub inferopclass: Oid,
}
#[derive(Debug, serde::Deserialize)]
pub struct IntoClause {
pub rel: Option<Box<RangeVar>>,
#[serde(rename = "colNames", default)]
pub col_names: Option<Vec<Node>>,
#[serde(rename = "accessMethod", default)]
pub access_method: Option<String>,
#[serde(default)]
pub options: Option<Vec<Node>>,
#[serde(rename = "onCommit")]
pub on_commit: Box<OnCommitAction>,
#[serde(rename = "tableSpaceName", default)]
pub table_space_name: Option<String>,
#[serde(rename = "viewQuery", default)]
pub view_query: Option<Box<Node>>,
#[serde(rename = "skipData", default)]
pub skip_data: bool,
}
#[derive(Debug, serde::Deserialize)]
pub struct JoinExpr {
pub jointype: Box<JoinType>,
#[serde(rename = "isNatural", default)]
pub is_natural: bool,
#[serde(default)]
pub larg: Option<Box<Node>>,
#[serde(default)]
pub rarg: Option<Box<Node>>,
#[serde(rename = "usingClause", default)]
pub using_clause: Option<Vec<Node>>,
#[serde(default)]
pub quals: Option<Box<Node>>,
pub alias: Option<Box<Alias>>,
#[serde(default)]
pub rtindex: i32,
}
#[derive(Debug, serde::Deserialize)]
pub struct MinMaxExpr {
#[serde(default)]
pub minmaxtype: Oid,
#[serde(default)]
pub minmaxcollid: Oid,
#[serde(default)]
pub inputcollid: Oid,
pub op: Box<MinMaxOp>,
#[serde(default)]
pub args: Option<Vec<Node>>,
#[serde(default)]
pub location: i32,
}
#[derive(Debug, serde::Deserialize)]
pub struct NamedArgExpr {
#[serde(default)]
pub arg: Option<Box<Node>>,
#[serde(default)]
pub name: Option<String>,
#[serde(default)]
pub argnumber: i32,
#[serde(default)]
pub location: i32,
}
#[derive(Debug, serde::Deserialize)]
pub struct NextValueExpr {
#[serde(default)]
pub seqid: Oid,
#[serde(rename = "typeId", default)]
pub type_id: Oid,
}
#[derive(Debug, serde::Deserialize)]
pub struct NullTest {
#[serde(default)]
pub arg: Option<Box<Node>>,
pub nulltesttype: Box<NullTestType>,
#[serde(default)]
pub argisrow: bool,
#[serde(default)]
pub location: i32,
}
#[derive(Debug, serde::Deserialize)]
pub struct OnConflictExpr {
pub action: Box<OnConflictAction>,
#[serde(rename = "arbiterElems", default)]
pub arbiter_elems: Option<Vec<Node>>,
#[serde(rename = "arbiterWhere", default)]
pub arbiter_where: Option<Box<Node>>,
#[serde(default)]
pub constraint: Oid,
#[serde(rename = "onConflictSet", default)]
pub on_conflict_set: Option<Vec<Node>>,
#[serde(rename = "onConflictWhere", default)]
pub on_conflict_where: Option<Box<Node>>,
#[serde(rename = "exclRelIndex", default)]
pub excl_rel_index: i32,
#[serde(rename = "exclRelTlist", default)]
pub excl_rel_tlist: Option<Vec<Node>>,
}
#[derive(Debug, serde::Deserialize)]
pub struct OpExpr {
#[serde(default)]
pub opno: Oid,
#[serde(default)]
pub opfuncid: Oid,
#[serde(default)]
pub opresulttype: Oid,
#[serde(default)]
pub opretset: bool,
#[serde(default)]
pub opcollid: Oid,
#[serde(default)]
pub inputcollid: Oid,
#[serde(default)]
pub args: Option<Vec<Node>>,
#[serde(default)]
pub location: i32,
}
#[derive(Debug, serde::Deserialize)]
pub struct Param {
pub paramkind: Box<ParamKind>,
#[serde(default)]
pub paramid: i32,
#[serde(default)]
pub paramtype: Oid,
#[serde(default)]
pub paramtypmod: i32,
#[serde(default)]
pub paramcollid: Oid,
#[serde(default)]
pub location: i32,
}
#[derive(Debug, serde::Deserialize)]
pub struct RangeTblRef {
#[serde(default)]
pub rtindex: i32,
}
#[derive(Debug, serde::Deserialize)]
pub struct RangeVar {
#[serde(default)]
pub catalogname: Option<String>,
#[serde(default)]
pub schemaname: Option<String>,
#[serde(default)]
pub relname: Option<String>,
#[serde(default)]
pub inh: bool,
#[serde(default)]
pub relpersistence: char,
pub alias: Option<Box<Alias>>,
#[serde(default)]
pub location: i32,
}
#[derive(Debug, serde::Deserialize)]
pub struct RelabelType {
#[serde(default)]
pub arg: Option<Box<Node>>,
#[serde(default)]
pub resulttype: Oid,
#[serde(default)]
pub resulttypmod: i32,
#[serde(default)]
pub resultcollid: Oid,
pub relabelformat: Box<CoercionForm>,
#[serde(default)]
pub location: i32,
}
#[derive(Debug, serde::Deserialize)]
pub struct RowCompareExpr {
pub rctype: Box<RowCompareType>,
#[serde(default)]
pub opnos: Option<Vec<Node>>,
#[serde(default)]
pub opfamilies: Option<Vec<Node>>,
#[serde(default)]
pub inputcollids: Option<Vec<Node>>,
#[serde(default)]
pub largs: Option<Vec<Node>>,
#[serde(default)]
pub rargs: Option<Vec<Node>>,
}
#[derive(Debug, serde::Deserialize)]
pub struct RowExpr {
#[serde(default)]
pub args: Option<Vec<Node>>,
#[serde(default)]
pub row_typeid: Oid,
pub row_format: Box<CoercionForm>,
#[serde(default)]
pub colnames: Option<Vec<Node>>,
#[serde(default)]
pub location: i32,
}
#[derive(Debug, serde::Deserialize)]
pub struct SQLValueFunction {
pub op: Box<SQLValueFunctionOp>,
#[serde(default)]
pub typmod: i32,
#[serde(default)]
pub location: i32,
}
#[derive(Debug, serde::Deserialize)]
pub struct ScalarArrayOpExpr {
#[serde(default)]
pub opno: Oid,
#[serde(default)]
pub opfuncid: Oid,
#[serde(rename = "useOr", default)]
pub use_or: bool,
#[serde(default)]
pub inputcollid: Oid,
#[serde(default)]
pub args: Option<Vec<Node>>,
#[serde(default)]
pub location: i32,
}
#[derive(Debug, serde::Deserialize)]
pub struct SetToDefault {
#[serde(rename = "typeId", default)]
pub type_id: Oid,
#[serde(rename = "typeMod", default)]
pub type_mod: i32,
#[serde(default)]
pub collation: Oid,
#[serde(default)]
pub location: i32,
}
#[derive(Debug, serde::Deserialize)]
pub struct SubLink {
#[serde(rename = "subLinkType")]
pub sub_link_type: Box<SubLinkType>,
#[serde(rename = "subLinkId", default)]
pub sub_link_id: i32,
#[serde(default)]
pub testexpr: Option<Box<Node>>,
#[serde(rename = "operName", default)]
pub oper_name: Option<Vec<Node>>,
#[serde(default)]
pub subselect: Option<Box<Node>>,
#[serde(default)]
pub location: i32,
}
#[derive(Debug, serde::Deserialize)]
pub struct SubPlan {
#[serde(rename = "subLinkType")]
pub sub_link_type: Box<SubLinkType>,
#[serde(default)]
pub testexpr: Option<Box<Node>>,
#[serde(rename = "paramIds", default)]
pub param_ids: Option<Vec<Node>>,
#[serde(default)]
pub plan_id: i32,
#[serde(default)]
pub plan_name: Option<String>,
#[serde(rename = "firstColType", default)]
pub first_col_type: Oid,
#[serde(rename = "firstColTypmod", default)]
pub first_col_typmod: i32,
#[serde(rename = "firstColCollation", default)]
pub first_col_collation: Oid,
#[serde(rename = "useHashTable", default)]
pub use_hash_table: bool,
#[serde(rename = "unknownEqFalse", default)]
pub unknown_eq_false: bool,
#[serde(default)]
pub parallel_safe: bool,
#[serde(rename = "setParam", default)]
pub set_param: Option<Vec<Node>>,
#[serde(rename = "parParam", default)]
pub par_param: Option<Vec<Node>>,
#[serde(default)]
pub args: Option<Vec<Node>>,
#[serde(default)]
pub startup_cost: Cost,
#[serde(default)]
pub per_call_cost: Cost,
}
#[derive(Debug, serde::Deserialize)]
pub struct SubscriptingRef {
#[serde(default)]
pub refcontainertype: Oid,
#[serde(default)]
pub refelemtype: Oid,
#[serde(default)]
pub reftypmod: i32,
#[serde(default)]
pub refcollid: Oid,
#[serde(default)]
pub refupperindexpr: Option<Vec<Node>>,
#[serde(default)]
pub reflowerindexpr: Option<Vec<Node>>,
#[serde(default)]
pub refexpr: Option<Box<Node>>,
#[serde(default)]
pub refassgnexpr: Option<Box<Node>>,
}
#[derive(Debug, serde::Deserialize)]
pub struct TableFunc {
#[serde(default)]
pub ns_uris: Option<Vec<Node>>,
#[serde(default)]
pub ns_names: Option<Vec<Node>>,
#[serde(default)]
pub docexpr: Option<Box<Node>>,
#[serde(default)]
pub rowexpr: Option<Box<Node>>,
#[serde(default)]
pub colnames: Option<Vec<Node>>,
#[serde(default)]
pub coltypes: Option<Vec<Node>>,
#[serde(default)]
pub coltypmods: Option<Vec<Node>>,
#[serde(default)]
pub colcollations: Option<Vec<Node>>,
#[serde(default)]
pub colexprs: Option<Vec<Node>>,
#[serde(default)]
pub coldefexprs: Option<Vec<Node>>,
#[serde(default)]
pub notnulls: Option<Vec<u32>>,
#[serde(default)]
pub ordinalitycol: i32,
#[serde(default)]
pub location: i32,
}
#[derive(Debug, serde::Deserialize)]
pub struct TargetEntry {
#[serde(default)]
pub expr: Option<Box<Node>>,
#[serde(default)]
pub resno: AttrNumber,
#[serde(default)]
pub resname: Option<String>,
#[serde(default)]
pub ressortgroupref: Index,
#[serde(default)]
pub resorigtbl: Oid,
#[serde(default)]
pub resorigcol: AttrNumber,
#[serde(default)]
pub resjunk: bool,
}
#[derive(Debug, serde::Deserialize)]
pub struct Var {
#[serde(default)]
pub varno: Index,
#[serde(default)]
pub varattno: AttrNumber,
#[serde(default)]
pub vartype: Oid,
#[serde(default)]
pub vartypmod: i32,
#[serde(default)]
pub varcollid: Oid,
#[serde(default)]
pub varlevelsup: Index,
#[serde(default)]
pub varnosyn: Index,
#[serde(default)]
pub varattnosyn: AttrNumber,
#[serde(default)]
pub location: i32,
}
#[derive(Debug, serde::Deserialize)]
pub struct WindowFunc {
#[serde(default)]
pub winfnoid: Oid,
#[serde(default)]
pub wintype: Oid,
#[serde(default)]
pub wincollid: Oid,
#[serde(default)]
pub inputcollid: Oid,
#[serde(default)]
pub args: Option<Vec<Node>>,
#[serde(default)]
pub aggfilter: Option<Box<Node>>,
#[serde(default)]
pub winref: Index,
#[serde(default)]
pub winstar: bool,
#[serde(default)]
pub winagg: bool,
#[serde(default)]
pub location: i32,
}
#[derive(Debug, serde::Deserialize)]
pub struct XmlExpr {
pub op: Box<XmlExprOp>,
#[serde(default)]
pub name: Option<String>,
#[serde(default)]
pub named_args: Option<Vec<Node>>,
#[serde(default)]
pub arg_names: Option<Vec<Node>>,
#[serde(default)]
pub args: Option<Vec<Node>>,
pub xmloption: Box<XmlOptionType>,
#[serde(default)]
pub typmod: i32,
#[serde(default)]
pub location: i32,
}