pg_query 5.0.0 → 6.0.0

data/ext/pg_query/include/nodes/nodeFuncs.h

@@ -1,222 +0,0 @@
-/*-------------------------------------------------------------------------
- *
- * nodeFuncs.h
- *		Various general-purpose manipulations of Node trees
- *
- * Portions Copyright (c) 1996-2023, PostgreSQL Global Development Group
- * Portions Copyright (c) 1994, Regents of the University of California
- *
- * src/include/nodes/nodeFuncs.h
- *
- *-------------------------------------------------------------------------
- */
-#ifndef NODEFUNCS_H
-#define NODEFUNCS_H
-
-#include "nodes/parsenodes.h"
-
-struct PlanState;				/* avoid including execnodes.h too */
-
-
-/* flags bits for query_tree_walker and query_tree_mutator */
-#define QTW_IGNORE_RT_SUBQUERIES	0x01	/* subqueries in rtable */
-#define QTW_IGNORE_CTE_SUBQUERIES	0x02	/* subqueries in cteList */
-#define QTW_IGNORE_RC_SUBQUERIES	0x03	/* both of above */
-#define QTW_IGNORE_JOINALIASES		0x04	/* JOIN alias var lists */
-#define QTW_IGNORE_RANGE_TABLE		0x08	/* skip rangetable entirely */
-#define QTW_EXAMINE_RTES_BEFORE		0x10	/* examine RTE nodes before their
-											 * contents */
-#define QTW_EXAMINE_RTES_AFTER		0x20	/* examine RTE nodes after their
-											 * contents */
-#define QTW_DONT_COPY_QUERY			0x40	/* do not copy top Query */
-#define QTW_EXAMINE_SORTGROUP		0x80	/* include SortGroupClause lists */
-
-/* callback function for check_functions_in_node */
-typedef bool (*check_function_callback) (Oid func_id, void *context);
-
-/* callback functions for tree walkers */
-typedef bool (*tree_walker_callback) (Node *node, void *context);
-typedef bool (*planstate_tree_walker_callback) (struct PlanState *planstate,
-												void *context);
-
-/* callback functions for tree mutators */
-typedef Node *(*tree_mutator_callback) (Node *node, void *context);
-
-
-extern Oid	exprType(const Node *expr);
-extern int32 exprTypmod(const Node *expr);
-extern bool exprIsLengthCoercion(const Node *expr, int32 *coercedTypmod);
-extern Node *applyRelabelType(Node *arg, Oid rtype, int32 rtypmod, Oid rcollid,
-							  CoercionForm rformat, int rlocation,
-							  bool overwrite_ok);
-extern Node *relabel_to_typmod(Node *expr, int32 typmod);
-extern Node *strip_implicit_coercions(Node *node);
-extern bool expression_returns_set(Node *clause);
-
-extern Oid	exprCollation(const Node *expr);
-extern Oid	exprInputCollation(const Node *expr);
-extern void exprSetCollation(Node *expr, Oid collation);
-extern void exprSetInputCollation(Node *expr, Oid inputcollation);
-
-extern int	exprLocation(const Node *expr);
-
-extern void fix_opfuncids(Node *node);
-extern void set_opfuncid(OpExpr *opexpr);
-extern void set_sa_opfuncid(ScalarArrayOpExpr *opexpr);
-
-/* Is clause a FuncExpr clause? */
-static inline bool
-is_funcclause(const void *clause)
-{
-	return clause != NULL && IsA(clause, FuncExpr);
-}
-
-/* Is clause an OpExpr clause? */
-static inline bool
-is_opclause(const void *clause)
-{
-	return clause != NULL && IsA(clause, OpExpr);
-}
-
-/* Extract left arg of a binary opclause, or only arg of a unary opclause */
-static inline Node *
-get_leftop(const void *clause)
-{
-	const OpExpr *expr = (const OpExpr *) clause;
-
-	if (expr->args != NIL)
-		return (Node *) linitial(expr->args);
-	else
-		return NULL;
-}
-
-/* Extract right arg of a binary opclause (NULL if it's a unary opclause) */
-static inline Node *
-get_rightop(const void *clause)
-{
-	const OpExpr *expr = (const OpExpr *) clause;
-
-	if (list_length(expr->args) >= 2)
-		return (Node *) lsecond(expr->args);
-	else
-		return NULL;
-}
-
-/* Is clause an AND clause? */
-static inline bool
-is_andclause(const void *clause)
-{
-	return (clause != NULL &&
-			IsA(clause, BoolExpr) &&
-			((const BoolExpr *) clause)->boolop == AND_EXPR);
-}
-
-/* Is clause an OR clause? */
-static inline bool
-is_orclause(const void *clause)
-{
-	return (clause != NULL &&
-			IsA(clause, BoolExpr) &&
-			((const BoolExpr *) clause)->boolop == OR_EXPR);
-}
-
-/* Is clause a NOT clause? */
-static inline bool
-is_notclause(const void *clause)
-{
-	return (clause != NULL &&
-			IsA(clause, BoolExpr) &&
-			((const BoolExpr *) clause)->boolop == NOT_EXPR);
-}
-
-/* Extract argument from a clause known to be a NOT clause */
-static inline Expr *
-get_notclausearg(const void *notclause)
-{
-	return (Expr *) linitial(((const BoolExpr *) notclause)->args);
-}
-
-extern bool check_functions_in_node(Node *node, check_function_callback checker,
-									void *context);
-
-/*
- * The following functions are usually passed walker or mutator callbacks
- * that are declared like "bool walker(Node *node, my_struct *context)"
- * rather than "bool walker(Node *node, void *context)" as a strict reading
- * of the C standard would require.  Changing the callbacks' declarations
- * to "void *" would create serious hazards of passing them the wrong context
- * struct type, so we respectfully decline to support the standard's position
- * that a pointer to struct is incompatible with "void *".  Instead, silence
- * related compiler warnings by inserting casts into these macro wrappers.
- */
-
-#define expression_tree_walker(n, w, c) \
-	expression_tree_walker_impl(n, (tree_walker_callback) (w), c)
-#define expression_tree_mutator(n, m, c) \
-	expression_tree_mutator_impl(n, (tree_mutator_callback) (m), c)
-
-#define query_tree_walker(q, w, c, f) \
-	query_tree_walker_impl(q, (tree_walker_callback) (w), c, f)
-#define query_tree_mutator(q, m, c, f) \
-	query_tree_mutator_impl(q, (tree_mutator_callback) (m), c, f)
-
-#define range_table_walker(rt, w, c, f) \
-	range_table_walker_impl(rt, (tree_walker_callback) (w), c, f)
-#define range_table_mutator(rt, m, c, f) \
-	range_table_mutator_impl(rt, (tree_mutator_callback) (m), c, f)
-
-#define range_table_entry_walker(r, w, c, f) \
-	range_table_entry_walker_impl(r, (tree_walker_callback) (w), c, f)
-
-#define query_or_expression_tree_walker(n, w, c, f) \
-	query_or_expression_tree_walker_impl(n, (tree_walker_callback) (w), c, f)
-#define query_or_expression_tree_mutator(n, m, c, f) \
-	query_or_expression_tree_mutator_impl(n, (tree_mutator_callback) (m), c, f)
-
-#define raw_expression_tree_walker(n, w, c) \
-	raw_expression_tree_walker_impl(n, (tree_walker_callback) (w), c)
-
-#define planstate_tree_walker(ps, w, c) \
-	planstate_tree_walker_impl(ps, (planstate_tree_walker_callback) (w), c)
-
-extern bool expression_tree_walker_impl(Node *node,
-										tree_walker_callback walker,
-										void *context);
-extern Node *expression_tree_mutator_impl(Node *node,
-										  tree_mutator_callback mutator,
-										  void *context);
-
-extern bool query_tree_walker_impl(Query *query,
-								   tree_walker_callback walker,
-								   void *context, int flags);
-extern Query *query_tree_mutator_impl(Query *query,
-									  tree_mutator_callback mutator,
-									  void *context, int flags);
-
-extern bool range_table_walker_impl(List *rtable,
-									tree_walker_callback walker,
-									void *context, int flags);
-extern List *range_table_mutator_impl(List *rtable,
-									  tree_mutator_callback mutator,
-									  void *context, int flags);
-
-extern bool range_table_entry_walker_impl(RangeTblEntry *rte,
-										  tree_walker_callback walker,
-										  void *context, int flags);
-
-extern bool query_or_expression_tree_walker_impl(Node *node,
-												 tree_walker_callback walker,
-												 void *context, int flags);
-extern Node *query_or_expression_tree_mutator_impl(Node *node,
-												   tree_mutator_callback mutator,
-												   void *context, int flags);
-
-extern bool raw_expression_tree_walker_impl(Node *node,
-											tree_walker_callback walker,
-											void *context);
-
-extern bool planstate_tree_walker_impl(struct PlanState *planstate,
-									   planstate_tree_walker_callback walker,
-									   void *context);
-
-#endif							/* NODEFUNCS_H */

data/ext/pg_query/include/nodes/nodes.h

@@ -1,446 +0,0 @@
-/*-------------------------------------------------------------------------
- *
- * nodes.h
- *	  Definitions for tagged nodes.
- *
- *
- * Portions Copyright (c) 1996-2023, PostgreSQL Global Development Group
- * Portions Copyright (c) 1994, Regents of the University of California
- *
- * src/include/nodes/nodes.h
- *
- *-------------------------------------------------------------------------
- */
-#ifndef NODES_H
-#define NODES_H
-
-/*
- * The first field of every node is NodeTag. Each node created (with makeNode)
- * will have one of the following tags as the value of its first field.
- *
- * Note that inserting or deleting node types changes the numbers of other
- * node types later in the list.  This is no problem during development, since
- * the node numbers are never stored on disk.  But don't do it in a released
- * branch, because that would represent an ABI break for extensions.
- */
-typedef enum NodeTag
-{
-	T_Invalid = 0,
-
-#include "nodes/nodetags.h"
-} NodeTag;
-
-/*
- * pg_node_attr() - Used in node definitions to set extra information for
- * gen_node_support.pl
- *
- * Attributes can be attached to a node as a whole (place the attribute
- * specification on the first line after the struct's opening brace)
- * or to a specific field (place it at the end of that field's line).  The
- * argument is a comma-separated list of attributes.  Unrecognized attributes
- * cause an error.
- *
- * Valid node attributes:
- *
- * - abstract: Abstract types are types that cannot be instantiated but that
- *   can be supertypes of other types.  We track their fields, so that
- *   subtypes can use them, but we don't emit a node tag, so you can't
- *   instantiate them.
- *
- * - custom_copy_equal: Has custom implementations in copyfuncs.c and
- *   equalfuncs.c.
- *
- * - custom_read_write: Has custom implementations in outfuncs.c and
- *   readfuncs.c.
- *
- * - custom_query_jumble: Has custom implementation in queryjumblefuncs.c.
- *
- * - no_copy: Does not support copyObject() at all.
- *
- * - no_equal: Does not support equal() at all.
- *
- * - no_copy_equal: Shorthand for both no_copy and no_equal.
- *
- * - no_query_jumble: Does not support JumbleQuery() at all.
- *
- * - no_read: Does not support nodeRead() at all.
- *
- * - nodetag_only: Does not support copyObject(), equal(), jumbleQuery()
- *   outNode() or nodeRead().
- *
- * - special_read_write: Has special treatment in outNode() and nodeRead().
- *
- * - nodetag_number(VALUE): assign the specified nodetag number instead of
- *   an auto-generated number.  Typically this would only be used in stable
- *   branches, to give a newly-added node type a number without breaking ABI
- *   by changing the numbers of existing node types.
- *
- * Node types can be supertypes of other types whether or not they are marked
- * abstract: if a node struct appears as the first field of another struct
- * type, then it is the supertype of that type.  The no_copy, no_equal,
- * no_query_jumble and no_read node attributes are automatically inherited
- * from the supertype.  (Notice that nodetag_only does not inherit, so it's
- * not quite equivalent to a combination of other attributes.)
- *
- * Valid node field attributes:
- *
- * - array_size(OTHERFIELD): This field is a dynamically allocated array with
- *   size indicated by the mentioned other field.  The other field is either a
- *   scalar or a list, in which case the length of the list is used.
- *
- * - copy_as(VALUE): In copyObject(), replace the field's value with VALUE.
- *
- * - copy_as_scalar: In copyObject(), copy the field as a scalar value
- *   (e.g. a pointer) even if it is a node-type pointer.
- *
- * - equal_as_scalar: In equal(), compare the field as a scalar value
- *   even if it is a node-type pointer.
- *
- * - equal_ignore: Ignore the field for equality.
- *
- * - equal_ignore_if_zero: Ignore the field for equality if it is zero.
- *   (Otherwise, compare normally.)
- *
- * - query_jumble_ignore: Ignore the field for the query jumbling.  Note
- *   that typmod and collation information are usually irrelevant for the
- *   query jumbling.
- *
- * - query_jumble_location: Mark the field as a location to track.  This is
- *   only allowed for integer fields that include "location" in their name.
- *
- * - read_as(VALUE): In nodeRead(), replace the field's value with VALUE.
- *
- * - read_write_ignore: Ignore the field for read/write.  This is only allowed
- *   if the node type is marked no_read or read_as() is also specified.
- *
- * - write_only_relids, write_only_nondefault_pathtarget, write_only_req_outer:
- *   Special handling for Path struct; see there.
- *
- */
-#define pg_node_attr(...)
-
-/*
- * The first field of a node of any type is guaranteed to be the NodeTag.
- * Hence the type of any node can be gotten by casting it to Node. Declaring
- * a variable to be of Node * (instead of void *) can also facilitate
- * debugging.
- */
-typedef struct Node
-{
-	NodeTag		type;
-} Node;
-
-#define nodeTag(nodeptr)		(((const Node*)(nodeptr))->type)
-
-/*
- * newNode -
- *	  create a new node of the specified size and tag the node with the
- *	  specified tag.
- *
- * !WARNING!: Avoid using newNode directly. You should be using the
- *	  macro makeNode.  eg. to create a Query node, use makeNode(Query)
- *
- * Note: the size argument should always be a compile-time constant, so the
- * apparent risk of multiple evaluation doesn't matter in practice.
- */
-#ifdef __GNUC__
-
-/* With GCC, we can use a compound statement within an expression */
-#define newNode(size, tag) \
-({	Node   *_result; \
-	AssertMacro((size) >= sizeof(Node));		/* need the tag, at least */ \
-	_result = (Node *) palloc0fast(size); \
-	_result->type = (tag); \
-	_result; \
-})
-#else
-
-/*
- *	There is no way to dereference the palloc'ed pointer to assign the
- *	tag, and also return the pointer itself, so we need a holder variable.
- *	Fortunately, this macro isn't recursive so we just define
- *	a global variable for this purpose.
- */
-extern PGDLLIMPORT Node *newNodeMacroHolder;
-
-#define newNode(size, tag) \
-( \
-	AssertMacro((size) >= sizeof(Node)),		/* need the tag, at least */ \
-	newNodeMacroHolder = (Node *) palloc0fast(size), \
-	newNodeMacroHolder->type = (tag), \
-	newNodeMacroHolder \
-)
-#endif							/* __GNUC__ */
-
-
-#define makeNode(_type_)		((_type_ *) newNode(sizeof(_type_),T_##_type_))
-#define NodeSetTag(nodeptr,t)	(((Node*)(nodeptr))->type = (t))
-
-#define IsA(nodeptr,_type_)		(nodeTag(nodeptr) == T_##_type_)
-
-/*
- * castNode(type, ptr) casts ptr to "type *", and if assertions are enabled,
- * verifies that the node has the appropriate type (using its nodeTag()).
- *
- * Use an inline function when assertions are enabled, to avoid multiple
- * evaluations of the ptr argument (which could e.g. be a function call).
- */
-#ifdef USE_ASSERT_CHECKING
-static inline Node *
-castNodeImpl(NodeTag type, void *ptr)
-{
-	Assert(ptr == NULL || nodeTag(ptr) == type);
-	return (Node *) ptr;
-}
-#define castNode(_type_, nodeptr) ((_type_ *) castNodeImpl(T_##_type_, nodeptr))
-#else
-#define castNode(_type_, nodeptr) ((_type_ *) (nodeptr))
-#endif							/* USE_ASSERT_CHECKING */
-
-
-/* ----------------------------------------------------------------
- *					  extern declarations follow
- * ----------------------------------------------------------------
- */
-
-/*
- * nodes/{outfuncs.c,print.c}
- */
-struct Bitmapset;				/* not to include bitmapset.h here */
-struct StringInfoData;			/* not to include stringinfo.h here */
-
-extern void outNode(struct StringInfoData *str, const void *obj);
-extern void outToken(struct StringInfoData *str, const char *s);
-extern void outBitmapset(struct StringInfoData *str,
-						 const struct Bitmapset *bms);
-extern void outDatum(struct StringInfoData *str, uintptr_t value,
-					 int typlen, bool typbyval);
-extern char *nodeToString(const void *obj);
-extern char *bmsToString(const struct Bitmapset *bms);
-
-/*
- * nodes/{readfuncs.c,read.c}
- */
-extern void *stringToNode(const char *str);
-#ifdef WRITE_READ_PARSE_PLAN_TREES
-extern void *stringToNodeWithLocations(const char *str);
-#endif
-extern struct Bitmapset *readBitmapset(void);
-extern uintptr_t readDatum(bool typbyval);
-extern bool *readBoolCols(int numCols);
-extern int *readIntCols(int numCols);
-extern Oid *readOidCols(int numCols);
-extern int16 *readAttrNumberCols(int numCols);
-
-/*
- * nodes/copyfuncs.c
- */
-extern void *copyObjectImpl(const void *from);
-
-/* cast result back to argument type, if supported by compiler */
-#ifdef HAVE_TYPEOF
-#define copyObject(obj) ((typeof(obj)) copyObjectImpl(obj))
-#else
-#define copyObject(obj) copyObjectImpl(obj)
-#endif
-
-/*
- * nodes/equalfuncs.c
- */
-extern bool equal(const void *a, const void *b);
-
-
-/*
- * Typedefs for identifying qualifier selectivities and plan costs as such.
- * These are just plain "double"s, but declaring a variable as Selectivity
- * or Cost makes the intent more obvious.
- *
- * These could have gone into plannodes.h or some such, but many files
- * depend on them...
- */
-typedef double Selectivity;		/* fraction of tuples a qualifier will pass */
-typedef double Cost;			/* execution cost (in page-access units) */
-typedef double Cardinality;		/* (estimated) number of rows or other integer
-								 * count */
-
-
-/*
- * CmdType -
- *	  enums for type of operation represented by a Query or PlannedStmt
- *
- * This is needed in both parsenodes.h and plannodes.h, so put it here...
- */
-typedef enum CmdType
-{
-	CMD_UNKNOWN,
-	CMD_SELECT,					/* select stmt */
-	CMD_UPDATE,					/* update stmt */
-	CMD_INSERT,					/* insert stmt */
-	CMD_DELETE,					/* delete stmt */
-	CMD_MERGE,					/* merge stmt */
-	CMD_UTILITY,				/* cmds like create, destroy, copy, vacuum,
-								 * etc. */
-	CMD_NOTHING					/* dummy command for instead nothing rules
-								 * with qual */
-} CmdType;
-
-
-/*
- * JoinType -
- *	  enums for types of relation joins
- *
- * JoinType determines the exact semantics of joining two relations using
- * a matching qualification.  For example, it tells what to do with a tuple
- * that has no match in the other relation.
- *
- * This is needed in both parsenodes.h and plannodes.h, so put it here...
- */
-typedef enum JoinType
-{
-	/*
-	 * The canonical kinds of joins according to the SQL JOIN syntax. Only
-	 * these codes can appear in parser output (e.g., JoinExpr nodes).
-	 */
-	JOIN_INNER,					/* matching tuple pairs only */
-	JOIN_LEFT,					/* pairs + unmatched LHS tuples */
-	JOIN_FULL,					/* pairs + unmatched LHS + unmatched RHS */
-	JOIN_RIGHT,					/* pairs + unmatched RHS tuples */
-
-	/*
-	 * Semijoins and anti-semijoins (as defined in relational theory) do not
-	 * appear in the SQL JOIN syntax, but there are standard idioms for
-	 * representing them (e.g., using EXISTS).  The planner recognizes these
-	 * cases and converts them to joins.  So the planner and executor must
-	 * support these codes.  NOTE: in JOIN_SEMI output, it is unspecified
-	 * which matching RHS row is joined to.  In JOIN_ANTI output, the row is
-	 * guaranteed to be null-extended.
-	 */
-	JOIN_SEMI,					/* 1 copy of each LHS row that has match(es) */
-	JOIN_ANTI,					/* 1 copy of each LHS row that has no match */
-	JOIN_RIGHT_ANTI,			/* 1 copy of each RHS row that has no match */
-
-	/*
-	 * These codes are used internally in the planner, but are not supported
-	 * by the executor (nor, indeed, by most of the planner).
-	 */
-	JOIN_UNIQUE_OUTER,			/* LHS path must be made unique */
-	JOIN_UNIQUE_INNER			/* RHS path must be made unique */
-
-	/*
-	 * We might need additional join types someday.
-	 */
-} JoinType;
-
-/*
- * OUTER joins are those for which pushed-down quals must behave differently
- * from the join's own quals.  This is in fact everything except INNER and
- * SEMI joins.  However, this macro must also exclude the JOIN_UNIQUE symbols
- * since those are temporary proxies for what will eventually be an INNER
- * join.
- *
- * Note: semijoins are a hybrid case, but we choose to treat them as not
- * being outer joins.  This is okay principally because the SQL syntax makes
- * it impossible to have a pushed-down qual that refers to the inner relation
- * of a semijoin; so there is no strong need to distinguish join quals from
- * pushed-down quals.  This is convenient because for almost all purposes,
- * quals attached to a semijoin can be treated the same as innerjoin quals.
- */
-#define IS_OUTER_JOIN(jointype) \
-	(((1 << (jointype)) & \
-	  ((1 << JOIN_LEFT) | \
-	   (1 << JOIN_FULL) | \
-	   (1 << JOIN_RIGHT) | \
-	   (1 << JOIN_ANTI) | \
-	   (1 << JOIN_RIGHT_ANTI))) != 0)
-
-/*
- * AggStrategy -
- *	  overall execution strategies for Agg plan nodes
- *
- * This is needed in both pathnodes.h and plannodes.h, so put it here...
- */
-typedef enum AggStrategy
-{
-	AGG_PLAIN,					/* simple agg across all input rows */
-	AGG_SORTED,					/* grouped agg, input must be sorted */
-	AGG_HASHED,					/* grouped agg, use internal hashtable */
-	AGG_MIXED					/* grouped agg, hash and sort both used */
-} AggStrategy;
-
-/*
- * AggSplit -
- *	  splitting (partial aggregation) modes for Agg plan nodes
- *
- * This is needed in both pathnodes.h and plannodes.h, so put it here...
- */
-
-/* Primitive options supported by nodeAgg.c: */
-#define AGGSPLITOP_COMBINE		0x01	/* substitute combinefn for transfn */
-#define AGGSPLITOP_SKIPFINAL	0x02	/* skip finalfn, return state as-is */
-#define AGGSPLITOP_SERIALIZE	0x04	/* apply serialfn to output */
-#define AGGSPLITOP_DESERIALIZE	0x08	/* apply deserialfn to input */
-
-/* Supported operating modes (i.e., useful combinations of these options): */
-typedef enum AggSplit
-{
-	/* Basic, non-split aggregation: */
-	AGGSPLIT_SIMPLE = 0,
-	/* Initial phase of partial aggregation, with serialization: */
-	AGGSPLIT_INITIAL_SERIAL = AGGSPLITOP_SKIPFINAL | AGGSPLITOP_SERIALIZE,
-	/* Final phase of partial aggregation, with deserialization: */
-	AGGSPLIT_FINAL_DESERIAL = AGGSPLITOP_COMBINE | AGGSPLITOP_DESERIALIZE
-} AggSplit;
-
-/* Test whether an AggSplit value selects each primitive option: */
-#define DO_AGGSPLIT_COMBINE(as)		(((as) & AGGSPLITOP_COMBINE) != 0)
-#define DO_AGGSPLIT_SKIPFINAL(as)	(((as) & AGGSPLITOP_SKIPFINAL) != 0)
-#define DO_AGGSPLIT_SERIALIZE(as)	(((as) & AGGSPLITOP_SERIALIZE) != 0)
-#define DO_AGGSPLIT_DESERIALIZE(as) (((as) & AGGSPLITOP_DESERIALIZE) != 0)
-
-/*
- * SetOpCmd and SetOpStrategy -
- *	  overall semantics and execution strategies for SetOp plan nodes
- *
- * This is needed in both pathnodes.h and plannodes.h, so put it here...
- */
-typedef enum SetOpCmd
-{
-	SETOPCMD_INTERSECT,
-	SETOPCMD_INTERSECT_ALL,
-	SETOPCMD_EXCEPT,
-	SETOPCMD_EXCEPT_ALL
-} SetOpCmd;
-
-typedef enum SetOpStrategy
-{
-	SETOP_SORTED,				/* input must be sorted */
-	SETOP_HASHED				/* use internal hashtable */
-} SetOpStrategy;
-
-/*
- * OnConflictAction -
- *	  "ON CONFLICT" clause type of query
- *
- * This is needed in both parsenodes.h and plannodes.h, so put it here...
- */
-typedef enum OnConflictAction
-{
-	ONCONFLICT_NONE,			/* No "ON CONFLICT" clause */
-	ONCONFLICT_NOTHING,			/* ON CONFLICT ... DO NOTHING */
-	ONCONFLICT_UPDATE			/* ON CONFLICT ... DO UPDATE */
-} OnConflictAction;
-
-/*
- * LimitOption -
- *	LIMIT option of query
- *
- * This is needed in both parsenodes.h and plannodes.h, so put it here...
- */
-typedef enum LimitOption
-{
-	LIMIT_OPTION_DEFAULT,		/* No limit present */
-	LIMIT_OPTION_COUNT,			/* FETCH FIRST... ONLY */
-	LIMIT_OPTION_WITH_TIES,		/* FETCH FIRST... WITH TIES */
-} LimitOption;
-
-#endif							/* NODES_H */