pg_query 4.2.1 → 6.1.0

data/ext/pg_query/include/postgres/catalog/index.h

@@ -0,0 +1,218 @@
+/*-------------------------------------------------------------------------
+ *
+ * index.h
+ *	  prototypes for catalog/index.c.
+ *
+ *
+ * Portions Copyright (c) 1996-2024, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/catalog/index.h
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef INDEX_H
+#define INDEX_H
+
+#include "catalog/objectaddress.h"
+#include "nodes/execnodes.h"
+
+
+#define DEFAULT_INDEX_TYPE	"btree"
+
+/* Action code for index_set_state_flags */
+typedef enum
+{
+	INDEX_CREATE_SET_READY,
+	INDEX_CREATE_SET_VALID,
+	INDEX_DROP_CLEAR_VALID,
+	INDEX_DROP_SET_DEAD,
+} IndexStateFlagsAction;
+
+/* options for REINDEX */
+typedef struct ReindexParams
+{
+	bits32		options;		/* bitmask of REINDEXOPT_* */
+	Oid			tablespaceOid;	/* New tablespace to move indexes to.
+								 * InvalidOid to do nothing. */
+} ReindexParams;
+
+/* flag bits for ReindexParams->flags */
+#define REINDEXOPT_VERBOSE		0x01	/* print progress info */
+#define REINDEXOPT_REPORT_PROGRESS 0x02 /* report pgstat progress */
+#define REINDEXOPT_MISSING_OK 	0x04	/* skip missing relations */
+#define REINDEXOPT_CONCURRENTLY	0x08	/* concurrent mode */
+
+/* state info for validate_index bulkdelete callback */
+typedef struct ValidateIndexState
+{
+	Tuplesortstate *tuplesort;	/* for sorting the index TIDs */
+	/* statistics (for debug purposes only): */
+	double		htups,
+				itups,
+				tups_inserted;
+} ValidateIndexState;
+
+extern void index_check_primary_key(Relation heapRel,
+									const IndexInfo *indexInfo,
+									bool is_alter_table,
+									const IndexStmt *stmt);
+
+#define	INDEX_CREATE_IS_PRIMARY				(1 << 0)
+#define	INDEX_CREATE_ADD_CONSTRAINT			(1 << 1)
+#define	INDEX_CREATE_SKIP_BUILD				(1 << 2)
+#define	INDEX_CREATE_CONCURRENT				(1 << 3)
+#define	INDEX_CREATE_IF_NOT_EXISTS			(1 << 4)
+#define	INDEX_CREATE_PARTITIONED			(1 << 5)
+#define INDEX_CREATE_INVALID				(1 << 6)
+
+extern Oid	index_create(Relation heapRelation,
+						 const char *indexRelationName,
+						 Oid indexRelationId,
+						 Oid parentIndexRelid,
+						 Oid parentConstraintId,
+						 RelFileNumber relFileNumber,
+						 IndexInfo *indexInfo,
+						 const List *indexColNames,
+						 Oid accessMethodId,
+						 Oid tableSpaceId,
+						 const Oid *collationIds,
+						 const Oid *opclassIds,
+						 const Datum *opclassOptions,
+						 const int16 *coloptions,
+						 const NullableDatum *stattargets,
+						 Datum reloptions,
+						 bits16 flags,
+						 bits16 constr_flags,
+						 bool allow_system_table_mods,
+						 bool is_internal,
+						 Oid *constraintId);
+
+#define	INDEX_CONSTR_CREATE_MARK_AS_PRIMARY	(1 << 0)
+#define	INDEX_CONSTR_CREATE_DEFERRABLE		(1 << 1)
+#define	INDEX_CONSTR_CREATE_INIT_DEFERRED	(1 << 2)
+#define	INDEX_CONSTR_CREATE_UPDATE_INDEX	(1 << 3)
+#define	INDEX_CONSTR_CREATE_REMOVE_OLD_DEPS	(1 << 4)
+
+extern Oid	index_concurrently_create_copy(Relation heapRelation,
+										   Oid oldIndexId,
+										   Oid tablespaceOid,
+										   const char *newName);
+
+extern void index_concurrently_build(Oid heapRelationId,
+									 Oid indexRelationId);
+
+extern void index_concurrently_swap(Oid newIndexId,
+									Oid oldIndexId,
+									const char *oldName);
+
+extern void index_concurrently_set_dead(Oid heapId,
+										Oid indexId);
+
+extern ObjectAddress index_constraint_create(Relation heapRelation,
+											 Oid indexRelationId,
+											 Oid parentConstraintId,
+											 const IndexInfo *indexInfo,
+											 const char *constraintName,
+											 char constraintType,
+											 bits16 constr_flags,
+											 bool allow_system_table_mods,
+											 bool is_internal);
+
+extern void index_drop(Oid indexId, bool concurrent, bool concurrent_lock_mode);
+
+extern IndexInfo *BuildIndexInfo(Relation index);
+
+extern IndexInfo *BuildDummyIndexInfo(Relation index);
+
+extern bool CompareIndexInfo(const IndexInfo *info1, const IndexInfo *info2,
+							 const Oid *collations1, const Oid *collations2,
+							 const Oid *opfamilies1, const Oid *opfamilies2,
+							 const AttrMap *attmap);
+
+extern void BuildSpeculativeIndexInfo(Relation index, IndexInfo *ii);
+
+extern void FormIndexDatum(IndexInfo *indexInfo,
+						   TupleTableSlot *slot,
+						   EState *estate,
+						   Datum *values,
+						   bool *isnull);
+
+extern void index_build(Relation heapRelation,
+						Relation indexRelation,
+						IndexInfo *indexInfo,
+						bool isreindex,
+						bool parallel);
+
+extern void validate_index(Oid heapId, Oid indexId, Snapshot snapshot);
+
+extern void index_set_state_flags(Oid indexId, IndexStateFlagsAction action);
+
+extern Oid	IndexGetRelation(Oid indexId, bool missing_ok);
+
+extern void reindex_index(const ReindexStmt *stmt, Oid indexId,
+						  bool skip_constraint_checks, char persistence,
+						  const ReindexParams *params);
+
+/* Flag bits for reindex_relation(): */
+#define REINDEX_REL_PROCESS_TOAST			0x01
+#define REINDEX_REL_SUPPRESS_INDEX_USE		0x02
+#define REINDEX_REL_CHECK_CONSTRAINTS		0x04
+#define REINDEX_REL_FORCE_INDEXES_UNLOGGED	0x08
+#define REINDEX_REL_FORCE_INDEXES_PERMANENT 0x10
+
+extern bool reindex_relation(const ReindexStmt *stmt, Oid relid, int flags,
+							 const ReindexParams *params);
+
+extern bool ReindexIsProcessingHeap(Oid heapOid);
+extern bool ReindexIsProcessingIndex(Oid indexOid);
+
+extern void ResetReindexState(int nestLevel);
+extern Size EstimateReindexStateSpace(void);
+extern void SerializeReindexState(Size maxsize, char *start_address);
+extern void RestoreReindexState(const void *reindexstate);
+
+extern void IndexSetParentIndex(Relation partitionIdx, Oid parentOid);
+
+
+/*
+ * itemptr_encode - Encode ItemPointer as int64/int8
+ *
+ * This representation must produce values encoded as int64 that sort in the
+ * same order as their corresponding original TID values would (using the
+ * default int8 opclass to produce a result equivalent to the default TID
+ * opclass).
+ *
+ * As noted in validate_index(), this can be significantly faster.
+ */
+static inline int64
+itemptr_encode(ItemPointer itemptr)
+{
+	BlockNumber block = ItemPointerGetBlockNumber(itemptr);
+	OffsetNumber offset = ItemPointerGetOffsetNumber(itemptr);
+	int64		encoded;
+
+	/*
+	 * Use the 16 least significant bits for the offset.  32 adjacent bits are
+	 * used for the block number.  Since remaining bits are unused, there
+	 * cannot be negative encoded values (We assume a two's complement
+	 * representation).
+	 */
+	encoded = ((uint64) block << 16) | (uint16) offset;
+
+	return encoded;
+}
+
+/*
+ * itemptr_decode - Decode int64/int8 representation back to ItemPointer
+ */
+static inline void
+itemptr_decode(ItemPointer itemptr, int64 encoded)
+{
+	BlockNumber block = (BlockNumber) (encoded >> 16);
+	OffsetNumber offset = (OffsetNumber) (encoded & 0xFFFF);
+
+	ItemPointerSet(itemptr, block, offset);
+}
+
+#endif							/* INDEX_H */

data/ext/pg_query/include/postgres/catalog/indexing.h

@@ -0,0 +1,54 @@
+/*-------------------------------------------------------------------------
+ *
+ * indexing.h
+ *	  This file provides some definitions to support indexing
+ *	  on system catalogs
+ *
+ *
+ * Portions Copyright (c) 1996-2024, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/catalog/indexing.h
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef INDEXING_H
+#define INDEXING_H
+
+#include "access/htup.h"
+#include "nodes/execnodes.h"
+#include "utils/relcache.h"
+
+/*
+ * The state object used by CatalogOpenIndexes and friends is actually the
+ * same as the executor's ResultRelInfo, but we give it another type name
+ * to decouple callers from that fact.
+ */
+typedef struct ResultRelInfo *CatalogIndexState;
+
+/*
+ * Cap the maximum amount of bytes allocated for multi-inserts with system
+ * catalogs, limiting the number of slots used.
+ */
+#define MAX_CATALOG_MULTI_INSERT_BYTES 65535
+
+/*
+ * indexing.c prototypes
+ */
+extern CatalogIndexState CatalogOpenIndexes(Relation heapRel);
+extern void CatalogCloseIndexes(CatalogIndexState indstate);
+extern void CatalogTupleInsert(Relation heapRel, HeapTuple tup);
+extern void CatalogTupleInsertWithInfo(Relation heapRel, HeapTuple tup,
+									   CatalogIndexState indstate);
+extern void CatalogTuplesMultiInsertWithInfo(Relation heapRel,
+											 TupleTableSlot **slot,
+											 int ntuples,
+											 CatalogIndexState indstate);
+extern void CatalogTupleUpdate(Relation heapRel, ItemPointer otid,
+							   HeapTuple tup);
+extern void CatalogTupleUpdateWithInfo(Relation heapRel,
+									   ItemPointer otid, HeapTuple tup,
+									   CatalogIndexState indstate);
+extern void CatalogTupleDelete(Relation heapRel, ItemPointer tid);
+
+#endif							/* INDEXING_H */

data/ext/pg_query/include/postgres/catalog/namespace.h

@@ -0,0 +1,189 @@
+/*-------------------------------------------------------------------------
+ *
+ * namespace.h
+ *	  prototypes for functions in backend/catalog/namespace.c
+ *
+ *
+ * Portions Copyright (c) 1996-2024, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/catalog/namespace.h
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef NAMESPACE_H
+#define NAMESPACE_H
+
+#include "nodes/primnodes.h"
+#include "storage/lock.h"
+#include "storage/procnumber.h"
+
+
+/*
+ *	This structure holds a list of possible functions or operators
+ *	found by namespace lookup.  Each function/operator is identified
+ *	by OID and by argument types; the list must be pruned by type
+ *	resolution rules that are embodied in the parser, not here.
+ *	See FuncnameGetCandidates's comments for more info.
+ */
+typedef struct _FuncCandidateList
+{
+	struct _FuncCandidateList *next;
+	int			pathpos;		/* for internal use of namespace lookup */
+	Oid			oid;			/* the function or operator's OID */
+	int			nominalnargs;	/* either pronargs or length(proallargtypes) */
+	int			nargs;			/* number of arg types returned */
+	int			nvargs;			/* number of args to become variadic array */
+	int			ndargs;			/* number of defaulted args */
+	int		   *argnumbers;		/* args' positional indexes, if named call */
+	Oid			args[FLEXIBLE_ARRAY_MEMBER];	/* arg types */
+}		   *FuncCandidateList;
+
+/*
+ * Result of checkTempNamespaceStatus
+ */
+typedef enum TempNamespaceStatus
+{
+	TEMP_NAMESPACE_NOT_TEMP,	/* nonexistent, or non-temp namespace */
+	TEMP_NAMESPACE_IDLE,		/* exists, belongs to no active session */
+	TEMP_NAMESPACE_IN_USE,		/* belongs to some active session */
+} TempNamespaceStatus;
+
+/*
+ *	Structure for xxxSearchPathMatcher functions
+ *
+ * The generation counter is private to namespace.c and shouldn't be touched
+ * by other code.  It can be initialized to zero if necessary (that means
+ * "not known equal to the current active path").
+ */
+typedef struct SearchPathMatcher
+{
+	List	   *schemas;		/* OIDs of explicitly named schemas */
+	bool		addCatalog;		/* implicitly prepend pg_catalog? */
+	bool		addTemp;		/* implicitly prepend temp schema? */
+	uint64		generation;		/* for quick detection of equality to active */
+} SearchPathMatcher;
+
+/*
+ * Option flag bits for RangeVarGetRelidExtended().
+ */
+typedef enum RVROption
+{
+	RVR_MISSING_OK = 1 << 0,	/* don't error if relation doesn't exist */
+	RVR_NOWAIT = 1 << 1,		/* error if relation cannot be locked */
+	RVR_SKIP_LOCKED = 1 << 2,	/* skip if relation cannot be locked */
+}			RVROption;
+
+typedef void (*RangeVarGetRelidCallback) (const RangeVar *relation, Oid relId,
+										  Oid oldRelId, void *callback_arg);
+
+#define RangeVarGetRelid(relation, lockmode, missing_ok) \
+	RangeVarGetRelidExtended(relation, lockmode, \
+							 (missing_ok) ? RVR_MISSING_OK : 0, NULL, NULL)
+
+extern Oid	RangeVarGetRelidExtended(const RangeVar *relation,
+									 LOCKMODE lockmode, uint32 flags,
+									 RangeVarGetRelidCallback callback,
+									 void *callback_arg);
+extern Oid	RangeVarGetCreationNamespace(const RangeVar *newRelation);
+extern Oid	RangeVarGetAndCheckCreationNamespace(RangeVar *relation,
+												 LOCKMODE lockmode,
+												 Oid *existing_relation_id);
+extern void RangeVarAdjustRelationPersistence(RangeVar *newRelation, Oid nspid);
+extern Oid	RelnameGetRelid(const char *relname);
+extern bool RelationIsVisible(Oid relid);
+
+extern Oid	TypenameGetTypid(const char *typname);
+extern Oid	TypenameGetTypidExtended(const char *typname, bool temp_ok);
+extern bool TypeIsVisible(Oid typid);
+
+extern FuncCandidateList FuncnameGetCandidates(List *names,
+											   int nargs, List *argnames,
+											   bool expand_variadic,
+											   bool expand_defaults,
+											   bool include_out_arguments,
+											   bool missing_ok);
+extern bool FunctionIsVisible(Oid funcid);
+
+extern Oid	OpernameGetOprid(List *names, Oid oprleft, Oid oprright);
+extern FuncCandidateList OpernameGetCandidates(List *names, char oprkind,
+											   bool missing_schema_ok);
+extern bool OperatorIsVisible(Oid oprid);
+
+extern Oid	OpclassnameGetOpcid(Oid amid, const char *opcname);
+extern bool OpclassIsVisible(Oid opcid);
+
+extern Oid	OpfamilynameGetOpfid(Oid amid, const char *opfname);
+extern bool OpfamilyIsVisible(Oid opfid);
+
+extern Oid	CollationGetCollid(const char *collname);
+extern bool CollationIsVisible(Oid collid);
+
+extern Oid	ConversionGetConid(const char *conname);
+extern bool ConversionIsVisible(Oid conid);
+
+extern Oid	get_statistics_object_oid(List *names, bool missing_ok);
+extern bool StatisticsObjIsVisible(Oid stxid);
+
+extern Oid	get_ts_parser_oid(List *names, bool missing_ok);
+extern bool TSParserIsVisible(Oid prsId);
+
+extern Oid	get_ts_dict_oid(List *names, bool missing_ok);
+extern bool TSDictionaryIsVisible(Oid dictId);
+
+extern Oid	get_ts_template_oid(List *names, bool missing_ok);
+extern bool TSTemplateIsVisible(Oid tmplId);
+
+extern Oid	get_ts_config_oid(List *names, bool missing_ok);
+extern bool TSConfigIsVisible(Oid cfgid);
+
+extern void DeconstructQualifiedName(const List *names,
+									 char **nspname_p,
+									 char **objname_p);
+extern Oid	LookupNamespaceNoError(const char *nspname);
+extern Oid	LookupExplicitNamespace(const char *nspname, bool missing_ok);
+extern Oid	get_namespace_oid(const char *nspname, bool missing_ok);
+
+extern Oid	LookupCreationNamespace(const char *nspname);
+extern void CheckSetNamespace(Oid oldNspOid, Oid nspOid);
+extern Oid	QualifiedNameGetCreationNamespace(const List *names, char **objname_p);
+extern RangeVar *makeRangeVarFromNameList(const List *names);
+extern char *NameListToString(const List *names);
+extern char *NameListToQuotedString(const List *names);
+
+extern bool isTempNamespace(Oid namespaceId);
+extern bool isTempToastNamespace(Oid namespaceId);
+extern bool isTempOrTempToastNamespace(Oid namespaceId);
+extern bool isAnyTempNamespace(Oid namespaceId);
+extern bool isOtherTempNamespace(Oid namespaceId);
+extern TempNamespaceStatus checkTempNamespaceStatus(Oid namespaceId);
+extern ProcNumber GetTempNamespaceProcNumber(Oid namespaceId);
+extern Oid	GetTempToastNamespace(void);
+extern void GetTempNamespaceState(Oid *tempNamespaceId,
+								  Oid *tempToastNamespaceId);
+extern void SetTempNamespaceState(Oid tempNamespaceId,
+								  Oid tempToastNamespaceId);
+extern void ResetTempTableNamespace(void);
+
+extern SearchPathMatcher *GetSearchPathMatcher(MemoryContext context);
+extern SearchPathMatcher *CopySearchPathMatcher(SearchPathMatcher *path);
+extern bool SearchPathMatchesCurrentEnvironment(SearchPathMatcher *path);
+
+extern Oid	get_collation_oid(List *collname, bool missing_ok);
+extern Oid	get_conversion_oid(List *conname, bool missing_ok);
+extern Oid	FindDefaultConversionProc(int32 for_encoding, int32 to_encoding);
+
+
+/* initialization & transaction cleanup code */
+extern void InitializeSearchPath(void);
+extern void AtEOXact_Namespace(bool isCommit, bool parallel);
+extern void AtEOSubXact_Namespace(bool isCommit, SubTransactionId mySubid,
+								  SubTransactionId parentSubid);
+
+/* stuff for search_path GUC variable */
+extern PGDLLIMPORT char *namespace_search_path;
+
+extern List *fetch_search_path(bool includeImplicit);
+extern int	fetch_search_path_array(Oid *sarray, int sarray_len);
+
+#endif							/* NAMESPACE_H */