pg_query 5.0.0 → 6.0.0

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

@@ -1,164 +0,0 @@
-/*-------------------------------------------------------------------------
- *
- * extensible.h
- *	  Definitions for extensible nodes and custom scans
- *
- *
- * Portions Copyright (c) 1996-2023, 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
-{
-	pg_node_attr(custom_copy_equal, custom_read_write)
-
-	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 *methods);
-extern const ExtensibleNodeMethods *GetExtensibleNodeMethods(const char *extnodename,
-															 bool missing_ok);
-
-/*
- * Flags for custom paths, indicating what capabilities the resulting scan
- * will have.  The flags fields of CustomPath and CustomScan nodes are
- * bitmasks of these flags.
- */
-#define CUSTOMPATH_SUPPORT_BACKWARD_SCAN	0x0001
-#define CUSTOMPATH_SUPPORT_MARK_RESTORE		0x0002
-#define CUSTOMPATH_SUPPORT_PROJECTION		0x0004
-
-/*
- * 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-2023, 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,121 +0,0 @@
-/*-------------------------------------------------------------------------
- *
- * makefuncs.h
- *	  prototypes for the creator functions of various nodes
- *
- *
- * Portions Copyright (c) 1996-2023, 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(int varno,
-					AttrNumber varattno,
-					Oid vartype,
-					int32 vartypmod,
-					Oid varcollid,
-					Index varlevelsup);
-
-extern Var *makeVarFromTargetEntry(int varno,
-								   TargetEntry *tle);
-
-extern Var *makeWholeRowVar(RangeTblEntry *rte,
-							int 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,
-							  CoercionForm funcformat, 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 nulls_not_distinct,
-								bool isready, bool concurrent,
-								bool summarizing);
-
-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);
-
-extern JsonFormat *makeJsonFormat(JsonFormatType type, JsonEncoding encoding,
-								  int location);
-extern JsonValueExpr *makeJsonValueExpr(Expr *raw_expr, Expr *formatted_expr,
-										JsonFormat *format);
-extern Node *makeJsonKeyValue(Node *key, Node *value);
-extern Node *makeJsonIsPredicate(Node *expr, JsonFormat *format,
-								 JsonValueType item_type, bool unique_keys,
-								 int location);
-extern JsonEncoding makeJsonEncoding(char *name);
-
-#endif							/* MAKEFUNC_H */

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

@@ -1,113 +0,0 @@
-/*-------------------------------------------------------------------------
- *
- * memnodes.h
- *	  POSTGRES memory context node definitions.
- *
- *
- * Portions Copyright (c) 1996-2023, 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,
-									  bool print_to_stderr);
-
-typedef struct MemoryContextMethods
-{
-	void	   *(*alloc) (MemoryContext context, Size size);
-	/* call this free_p in case someone #define's free() */
-	void		(*free_p) (void *pointer);
-	void	   *(*realloc) (void *pointer, Size size);
-	void		(*reset) (MemoryContext context);
-	void		(*delete_context) (MemoryContext context);
-	MemoryContext (*get_chunk_context) (void *pointer);
-	Size		(*get_chunk_space) (void *pointer);
-	bool		(*is_empty) (MemoryContext context);
-	void		(*stats) (MemoryContext context,
-						  MemoryStatsPrintFunc printfunc, void *passthru,
-						  MemoryContextCounters *totals,
-						  bool print_to_stderr);
-#ifdef MEMORY_CONTEXT_CHECKING
-	void		(*check) (MemoryContext context);
-#endif
-} MemoryContextMethods;
-
-
-typedef struct MemoryContextData
-{
-	pg_node_attr(abstract)		/* there are no nodes of this type */
-
-	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/miscnodes.h

@@ -1,56 +0,0 @@
-/*-------------------------------------------------------------------------
- *
- * miscnodes.h
- *	  Definitions for hard-to-classify node types.
- *
- * Node types declared here are not part of parse trees, plan trees,
- * or execution state trees.  We only assign them NodeTag values because
- * IsA() tests provide a convenient way to disambiguate what kind of
- * structure is being passed through assorted APIs, such as function
- * "context" pointers.
- *
- *
- * Portions Copyright (c) 1996-2023, PostgreSQL Global Development Group
- * Portions Copyright (c) 1994, Regents of the University of California
- *
- * src/include/nodes/miscnodes.h
- *
- *-------------------------------------------------------------------------
- */
-#ifndef MISCNODES_H
-#define MISCNODES_H
-
-#include "nodes/nodes.h"
-
-/*
- * ErrorSaveContext -
- *		function call context node for handling of "soft" errors
- *
- * A caller wishing to trap soft errors must initialize a struct like this
- * with all fields zero/NULL except for the NodeTag.  Optionally, set
- * details_wanted = true if more than the bare knowledge that a soft error
- * occurred is required.  The struct is then passed to a SQL-callable function
- * via the FunctionCallInfo.context field; or below the level of SQL calls,
- * it could be passed to a subroutine directly.
- *
- * After calling code that might report an error this way, check
- * error_occurred to see if an error happened.  If so, and if details_wanted
- * is true, error_data has been filled with error details (stored in the
- * callee's memory context!).  FreeErrorData() can be called to release
- * error_data, although that step is typically not necessary if the called
- * code was run in a short-lived context.
- */
-typedef struct ErrorSaveContext
-{
-	NodeTag		type;
-	bool		error_occurred; /* set to true if we detect a soft error */
-	bool		details_wanted; /* does caller want more info than that? */
-	ErrorData  *error_data;		/* details of error, if so */
-} ErrorSaveContext;
-
-/* Often-useful macro for checking if a soft error was reported */
-#define SOFT_ERROR_OCCURRED(escontext) \
-	((escontext) != NULL && IsA(escontext, ErrorSaveContext) && \
-	 ((ErrorSaveContext *) (escontext))->error_occurred)
-
-#endif							/* MISCNODES_H */