pg_query 2.2.0 → 6.1.0

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

@@ -1,160 +0,0 @@
-/*-------------------------------------------------------------------------
- *
- * extensible.h
- *	  Definitions for extensible nodes and custom scans
- *
- *
- * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group
- * Portions Copyright (c) 1994, Regents of the University of California
- *
- * src/include/nodes/extensible.h
- *
- *-------------------------------------------------------------------------
- */
-#ifndef EXTENSIBLE_H
-#define EXTENSIBLE_H
-
-#include "access/parallel.h"
-#include "commands/explain.h"
-#include "nodes/execnodes.h"
-#include "nodes/pathnodes.h"
-#include "nodes/plannodes.h"
-
-/* maximum length of an extensible node identifier */
-#define EXTNODENAME_MAX_LEN					64
-
-/*
- * An extensible node is a new type of node defined by an extension.  The
- * type is always T_ExtensibleNode, while the extnodename identifies the
- * specific type of node.  extnodename can be looked up to find the
- * ExtensibleNodeMethods for this node type.
- */
-typedef struct ExtensibleNode
-{
-	NodeTag		type;
-	const char *extnodename;	/* identifier of ExtensibleNodeMethods */
-} ExtensibleNode;
-
-/*
- * node_size is the size of an extensible node of this type in bytes.
- *
- * nodeCopy is a function which performs a deep copy from oldnode to newnode.
- * It does not need to copy type or extnodename, which are copied by the
- * core system.
- *
- * nodeEqual is a function which performs a deep equality comparison between
- * a and b and returns true or false accordingly.  It does not need to compare
- * type or extnodename, which are compared by the core system.
- *
- * nodeOut is a serialization function for the node type.  It should use the
- * output conventions typical for outfuncs.c.  It does not need to output
- * type or extnodename; the core system handles those.
- *
- * nodeRead is a deserialization function for the node type.  It does not need
- * to read type or extnodename; the core system handles those.  It should fetch
- * the next token using pg_strtok() from the current input stream, and then
- * reconstruct the private fields according to the manner in readfuncs.c.
- *
- * All callbacks are mandatory.
- */
-typedef struct ExtensibleNodeMethods
-{
-	const char *extnodename;
-	Size		node_size;
-	void		(*nodeCopy) (struct ExtensibleNode *newnode,
-							 const struct ExtensibleNode *oldnode);
-	bool		(*nodeEqual) (const struct ExtensibleNode *a,
-							  const struct ExtensibleNode *b);
-	void		(*nodeOut) (struct StringInfoData *str,
-							const struct ExtensibleNode *node);
-	void		(*nodeRead) (struct ExtensibleNode *node);
-} ExtensibleNodeMethods;
-
-extern void RegisterExtensibleNodeMethods(const ExtensibleNodeMethods *method);
-extern const ExtensibleNodeMethods *GetExtensibleNodeMethods(const char *name,
-															 bool missing_ok);
-
-/*
- * Flags for custom paths, indicating what capabilities the resulting scan
- * will have.
- */
-#define CUSTOMPATH_SUPPORT_BACKWARD_SCAN	0x0001
-#define CUSTOMPATH_SUPPORT_MARK_RESTORE		0x0002
-
-/*
- * Custom path methods.  Mostly, we just need to know how to convert a
- * CustomPath to a plan.
- */
-typedef struct CustomPathMethods
-{
-	const char *CustomName;
-
-	/* Convert Path to a Plan */
-	struct Plan *(*PlanCustomPath) (PlannerInfo *root,
-									RelOptInfo *rel,
-									struct CustomPath *best_path,
-									List *tlist,
-									List *clauses,
-									List *custom_plans);
-	struct List *(*ReparameterizeCustomPathByChild) (PlannerInfo *root,
-													 List *custom_private,
-													 RelOptInfo *child_rel);
-}			CustomPathMethods;
-
-/*
- * Custom scan.  Here again, there's not much to do: we need to be able to
- * generate a ScanState corresponding to the scan.
- */
-typedef struct CustomScanMethods
-{
-	const char *CustomName;
-
-	/* Create execution state (CustomScanState) from a CustomScan plan node */
-	Node	   *(*CreateCustomScanState) (CustomScan *cscan);
-} CustomScanMethods;
-
-/*
- * Execution-time methods for a CustomScanState.  This is more complex than
- * what we need for a custom path or scan.
- */
-typedef struct CustomExecMethods
-{
-	const char *CustomName;
-
-	/* Required executor methods */
-	void		(*BeginCustomScan) (CustomScanState *node,
-									EState *estate,
-									int eflags);
-	TupleTableSlot *(*ExecCustomScan) (CustomScanState *node);
-	void		(*EndCustomScan) (CustomScanState *node);
-	void		(*ReScanCustomScan) (CustomScanState *node);
-
-	/* Optional methods: needed if mark/restore is supported */
-	void		(*MarkPosCustomScan) (CustomScanState *node);
-	void		(*RestrPosCustomScan) (CustomScanState *node);
-
-	/* Optional methods: needed if parallel execution is supported */
-	Size		(*EstimateDSMCustomScan) (CustomScanState *node,
-										  ParallelContext *pcxt);
-	void		(*InitializeDSMCustomScan) (CustomScanState *node,
-											ParallelContext *pcxt,
-											void *coordinate);
-	void		(*ReInitializeDSMCustomScan) (CustomScanState *node,
-											  ParallelContext *pcxt,
-											  void *coordinate);
-	void		(*InitializeWorkerCustomScan) (CustomScanState *node,
-											   shm_toc *toc,
-											   void *coordinate);
-	void		(*ShutdownCustomScan) (CustomScanState *node);
-
-	/* Optional: print additional information in EXPLAIN */
-	void		(*ExplainCustomScan) (CustomScanState *node,
-									  List *ancestors,
-									  ExplainState *es);
-} CustomExecMethods;
-
-extern void RegisterCustomScanMethods(const CustomScanMethods *methods);
-extern const CustomScanMethods *GetCustomScanMethods(const char *CustomName,
-													 bool missing_ok);
-
-#endif							/* EXTENSIBLE_H */

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

@@ -1,61 +0,0 @@
-/*-------------------------------------------------------------------------
- *
- * lockoptions.h
- *	  Common header for some locking-related declarations.
- *
- *
- * Copyright (c) 2014-2020, PostgreSQL Global Development Group
- *
- * src/include/nodes/lockoptions.h
- *
- *-------------------------------------------------------------------------
- */
-#ifndef LOCKOPTIONS_H
-#define LOCKOPTIONS_H
-
-/*
- * This enum represents the different strengths of FOR UPDATE/SHARE clauses.
- * The ordering here is important, because the highest numerical value takes
- * precedence when a RTE is specified multiple ways.  See applyLockingClause.
- */
-typedef enum LockClauseStrength
-{
-	LCS_NONE,					/* no such clause - only used in PlanRowMark */
-	LCS_FORKEYSHARE,			/* FOR KEY SHARE */
-	LCS_FORSHARE,				/* FOR SHARE */
-	LCS_FORNOKEYUPDATE,			/* FOR NO KEY UPDATE */
-	LCS_FORUPDATE				/* FOR UPDATE */
-} LockClauseStrength;
-
-/*
- * This enum controls how to deal with rows being locked by FOR UPDATE/SHARE
- * clauses (i.e., it represents the NOWAIT and SKIP LOCKED options).
- * The ordering here is important, because the highest numerical value takes
- * precedence when a RTE is specified multiple ways.  See applyLockingClause.
- */
-typedef enum LockWaitPolicy
-{
-	/* Wait for the lock to become available (default behavior) */
-	LockWaitBlock,
-	/* Skip rows that can't be locked (SKIP LOCKED) */
-	LockWaitSkip,
-	/* Raise an error if a row cannot be locked (NOWAIT) */
-	LockWaitError
-} LockWaitPolicy;
-
-/*
- * Possible lock modes for a tuple.
- */
-typedef enum LockTupleMode
-{
-	/* SELECT FOR KEY SHARE */
-	LockTupleKeyShare,
-	/* SELECT FOR SHARE */
-	LockTupleShare,
-	/* SELECT FOR NO KEY UPDATE, and UPDATEs that don't modify key columns */
-	LockTupleNoKeyExclusive,
-	/* SELECT FOR UPDATE, UPDATEs that modify key columns, and DELETE */
-	LockTupleExclusive
-} LockTupleMode;
-
-#endif							/* LOCKOPTIONS_H */

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

@@ -1,108 +0,0 @@
-/*-------------------------------------------------------------------------
- *
- * makefuncs.h
- *	  prototypes for the creator functions of various nodes
- *
- *
- * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group
- * Portions Copyright (c) 1994, Regents of the University of California
- *
- * src/include/nodes/makefuncs.h
- *
- *-------------------------------------------------------------------------
- */
-#ifndef MAKEFUNC_H
-#define MAKEFUNC_H
-
-#include "nodes/execnodes.h"
-#include "nodes/parsenodes.h"
-
-
-extern A_Expr *makeA_Expr(A_Expr_Kind kind, List *name,
-						  Node *lexpr, Node *rexpr, int location);
-
-extern A_Expr *makeSimpleA_Expr(A_Expr_Kind kind, char *name,
-								Node *lexpr, Node *rexpr, int location);
-
-extern Var *makeVar(Index varno,
-					AttrNumber varattno,
-					Oid vartype,
-					int32 vartypmod,
-					Oid varcollid,
-					Index varlevelsup);
-
-extern Var *makeVarFromTargetEntry(Index varno,
-								   TargetEntry *tle);
-
-extern Var *makeWholeRowVar(RangeTblEntry *rte,
-							Index varno,
-							Index varlevelsup,
-							bool allowScalar);
-
-extern TargetEntry *makeTargetEntry(Expr *expr,
-									AttrNumber resno,
-									char *resname,
-									bool resjunk);
-
-extern TargetEntry *flatCopyTargetEntry(TargetEntry *src_tle);
-
-extern FromExpr *makeFromExpr(List *fromlist, Node *quals);
-
-extern Const *makeConst(Oid consttype,
-						int32 consttypmod,
-						Oid constcollid,
-						int constlen,
-						Datum constvalue,
-						bool constisnull,
-						bool constbyval);
-
-extern Const *makeNullConst(Oid consttype, int32 consttypmod, Oid constcollid);
-
-extern Node *makeBoolConst(bool value, bool isnull);
-
-extern Expr *makeBoolExpr(BoolExprType boolop, List *args, int location);
-
-extern Alias *makeAlias(const char *aliasname, List *colnames);
-
-extern RelabelType *makeRelabelType(Expr *arg, Oid rtype, int32 rtypmod,
-									Oid rcollid, CoercionForm rformat);
-
-extern RangeVar *makeRangeVar(char *schemaname, char *relname, int location);
-
-extern TypeName *makeTypeName(char *typnam);
-extern TypeName *makeTypeNameFromNameList(List *names);
-extern TypeName *makeTypeNameFromOid(Oid typeOid, int32 typmod);
-
-extern ColumnDef *makeColumnDef(const char *colname,
-								Oid typeOid, int32 typmod, Oid collOid);
-
-extern FuncExpr *makeFuncExpr(Oid funcid, Oid rettype, List *args,
-							  Oid funccollid, Oid inputcollid, CoercionForm fformat);
-
-extern FuncCall *makeFuncCall(List *name, List *args, int location);
-
-extern Expr *make_opclause(Oid opno, Oid opresulttype, bool opretset,
-						   Expr *leftop, Expr *rightop,
-						   Oid opcollid, Oid inputcollid);
-
-extern Expr *make_andclause(List *andclauses);
-extern Expr *make_orclause(List *orclauses);
-extern Expr *make_notclause(Expr *notclause);
-
-extern Node *make_and_qual(Node *qual1, Node *qual2);
-extern Expr *make_ands_explicit(List *andclauses);
-extern List *make_ands_implicit(Expr *clause);
-
-extern IndexInfo *makeIndexInfo(int numattrs, int numkeyattrs, Oid amoid,
-								List *expressions, List *predicates,
-								bool unique, bool isready, bool concurrent);
-
-extern DefElem *makeDefElem(char *name, Node *arg, int location);
-extern DefElem *makeDefElemExtended(char *nameSpace, char *name, Node *arg,
-									DefElemAction defaction, int location);
-
-extern GroupingSet *makeGroupingSet(GroupingSetKind kind, List *content, int location);
-
-extern VacuumRelation *makeVacuumRelation(RangeVar *relation, Oid oid, List *va_cols);
-
-#endif							/* MAKEFUNC_H */

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

@@ -1,108 +0,0 @@
-/*-------------------------------------------------------------------------
- *
- * memnodes.h
- *	  POSTGRES memory context node definitions.
- *
- *
- * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group
- * Portions Copyright (c) 1994, Regents of the University of California
- *
- * src/include/nodes/memnodes.h
- *
- *-------------------------------------------------------------------------
- */
-#ifndef MEMNODES_H
-#define MEMNODES_H
-
-#include "nodes/nodes.h"
-
-/*
- * MemoryContextCounters
- *		Summarization state for MemoryContextStats collection.
- *
- * The set of counters in this struct is biased towards AllocSet; if we ever
- * add any context types that are based on fundamentally different approaches,
- * we might need more or different counters here.  A possible API spec then
- * would be to print only nonzero counters, but for now we just summarize in
- * the format historically used by AllocSet.
- */
-typedef struct MemoryContextCounters
-{
-	Size		nblocks;		/* Total number of malloc blocks */
-	Size		freechunks;		/* Total number of free chunks */
-	Size		totalspace;		/* Total bytes requested from malloc */
-	Size		freespace;		/* The unused portion of totalspace */
-} MemoryContextCounters;
-
-/*
- * MemoryContext
- *		A logical context in which memory allocations occur.
- *
- * MemoryContext itself is an abstract type that can have multiple
- * implementations.
- * The function pointers in MemoryContextMethods define one specific
- * implementation of MemoryContext --- they are a virtual function table
- * in C++ terms.
- *
- * Node types that are actual implementations of memory contexts must
- * begin with the same fields as MemoryContextData.
- *
- * Note: for largely historical reasons, typedef MemoryContext is a pointer
- * to the context struct rather than the struct type itself.
- */
-
-typedef void (*MemoryStatsPrintFunc) (MemoryContext context, void *passthru,
-									  const char *stats_string);
-
-typedef struct MemoryContextMethods
-{
-	void	   *(*alloc) (MemoryContext context, Size size);
-	/* call this free_p in case someone #define's free() */
-	void		(*free_p) (MemoryContext context, void *pointer);
-	void	   *(*realloc) (MemoryContext context, void *pointer, Size size);
-	void		(*reset) (MemoryContext context);
-	void		(*delete_context) (MemoryContext context);
-	Size		(*get_chunk_space) (MemoryContext context, void *pointer);
-	bool		(*is_empty) (MemoryContext context);
-	void		(*stats) (MemoryContext context,
-						  MemoryStatsPrintFunc printfunc, void *passthru,
-						  MemoryContextCounters *totals);
-#ifdef MEMORY_CONTEXT_CHECKING
-	void		(*check) (MemoryContext context);
-#endif
-} MemoryContextMethods;
-
-
-typedef struct MemoryContextData
-{
-	NodeTag		type;			/* identifies exact kind of context */
-	/* these two fields are placed here to minimize alignment wastage: */
-	bool		isReset;		/* T = no space alloced since last reset */
-	bool		allowInCritSection; /* allow palloc in critical section */
-	Size		mem_allocated;	/* track memory allocated for this context */
-	const MemoryContextMethods *methods;	/* virtual function table */
-	MemoryContext parent;		/* NULL if no parent (toplevel context) */
-	MemoryContext firstchild;	/* head of linked list of children */
-	MemoryContext prevchild;	/* previous child of same parent */
-	MemoryContext nextchild;	/* next child of same parent */
-	const char *name;			/* context name (just for debugging) */
-	const char *ident;			/* context ID if any (just for debugging) */
-	MemoryContextCallback *reset_cbs;	/* list of reset/delete callbacks */
-} MemoryContextData;
-
-/* utils/palloc.h contains typedef struct MemoryContextData *MemoryContext */
-
-
-/*
- * MemoryContextIsValid
- *		True iff memory context is valid.
- *
- * Add new context types to the set accepted by this macro.
- */
-#define MemoryContextIsValid(context) \
-	((context) != NULL && \
-	 (IsA((context), AllocSetContext) || \
-	  IsA((context), SlabContext) || \
-	  IsA((context), GenerationContext)))
-
-#endif							/* MEMNODES_H */

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

@@ -1,162 +0,0 @@
-/*-------------------------------------------------------------------------
- *
- * nodeFuncs.h
- *		Various general-purpose manipulations of Node trees
- *
- * Portions Copyright (c) 1996-2020, 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"
-
-
-/* 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 SortGroupNode lists */
-
-/* callback function for check_functions_in_node */
-typedef bool (*check_function_callback) (Oid func_id, 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);
-
-extern bool expression_tree_walker(Node *node, bool (*walker) (),
-								   void *context);
-extern Node *expression_tree_mutator(Node *node, Node *(*mutator) (),
-									 void *context);
-
-extern bool query_tree_walker(Query *query, bool (*walker) (),
-							  void *context, int flags);
-extern Query *query_tree_mutator(Query *query, Node *(*mutator) (),
-								 void *context, int flags);
-
-extern bool range_table_walker(List *rtable, bool (*walker) (),
-							   void *context, int flags);
-extern List *range_table_mutator(List *rtable, Node *(*mutator) (),
-								 void *context, int flags);
-
-extern bool range_table_entry_walker(RangeTblEntry *rte, bool (*walker) (),
-									 void *context, int flags);
-
-extern bool query_or_expression_tree_walker(Node *node, bool (*walker) (),
-											void *context, int flags);
-extern Node *query_or_expression_tree_mutator(Node *node, Node *(*mutator) (),
-											  void *context, int flags);
-
-extern bool raw_expression_tree_walker(Node *node, bool (*walker) (),
-									   void *context);
-
-struct PlanState;
-extern bool planstate_tree_walker(struct PlanState *planstate, bool (*walker) (),
-								  void *context);
-
-#endif							/* NODEFUNCS_H */