pg_query 4.2.1 → 6.1.0

data/ext/pg_query/include/utils/memdebug.h

@@ -1,82 +0,0 @@
-/*-------------------------------------------------------------------------
- *
- * memdebug.h
- *	  Memory debugging support.
- *
- * Currently, this file either wraps <valgrind/memcheck.h> or substitutes
- * empty definitions for Valgrind client request macros we use.
- *
- *
- * Portions Copyright (c) 1996-2022, PostgreSQL Global Development Group
- * Portions Copyright (c) 1994, Regents of the University of California
- *
- * src/include/utils/memdebug.h
- *
- *-------------------------------------------------------------------------
- */
-#ifndef MEMDEBUG_H
-#define MEMDEBUG_H
-
-#ifdef USE_VALGRIND
-#include <valgrind/memcheck.h>
-#else
-#define VALGRIND_CHECK_MEM_IS_DEFINED(addr, size)			do {} while (0)
-#define VALGRIND_CREATE_MEMPOOL(context, redzones, zeroed)	do {} while (0)
-#define VALGRIND_DESTROY_MEMPOOL(context)					do {} while (0)
-#define VALGRIND_MAKE_MEM_DEFINED(addr, size)				do {} while (0)
-#define VALGRIND_MAKE_MEM_NOACCESS(addr, size)				do {} while (0)
-#define VALGRIND_MAKE_MEM_UNDEFINED(addr, size)				do {} while (0)
-#define VALGRIND_MEMPOOL_ALLOC(context, addr, size)			do {} while (0)
-#define VALGRIND_MEMPOOL_FREE(context, addr)				do {} while (0)
-#define VALGRIND_MEMPOOL_CHANGE(context, optr, nptr, size)	do {} while (0)
-#endif
-
-
-#ifdef CLOBBER_FREED_MEMORY
-
-/* Wipe freed memory for debugging purposes */
-static inline void
-wipe_mem(void *ptr, size_t size)
-{
-	VALGRIND_MAKE_MEM_UNDEFINED(ptr, size);
-	memset(ptr, 0x7F, size);
-	VALGRIND_MAKE_MEM_NOACCESS(ptr, size);
-}
-
-#endif							/* CLOBBER_FREED_MEMORY */
-
-#ifdef MEMORY_CONTEXT_CHECKING
-
-static inline void
-set_sentinel(void *base, Size offset)
-{
-	char	   *ptr = (char *) base + offset;
-
-	VALGRIND_MAKE_MEM_UNDEFINED(ptr, 1);
-	*ptr = 0x7E;
-	VALGRIND_MAKE_MEM_NOACCESS(ptr, 1);
-}
-
-static inline bool
-sentinel_ok(const void *base, Size offset)
-{
-	const char *ptr = (const char *) base + offset;
-	bool		ret;
-
-	VALGRIND_MAKE_MEM_DEFINED(ptr, 1);
-	ret = *ptr == 0x7E;
-	VALGRIND_MAKE_MEM_NOACCESS(ptr, 1);
-
-	return ret;
-}
-
-#endif							/* MEMORY_CONTEXT_CHECKING */
-
-#ifdef RANDOMIZE_ALLOCATED_MEMORY
-
-void		randomize_mem(char *ptr, size_t size);
-
-#endif							/* RANDOMIZE_ALLOCATED_MEMORY */
-
-
-#endif							/* MEMDEBUG_H */

data/ext/pg_query/include/utils/memutils.h

@@ -1,230 +0,0 @@
-/*-------------------------------------------------------------------------
- *
- * memutils.h
- *	  This file contains declarations for memory allocation utility
- *	  functions.  These are functions that are not quite widely used
- *	  enough to justify going in utils/palloc.h, but are still part
- *	  of the API of the memory management subsystem.
- *
- *
- * Portions Copyright (c) 1996-2022, PostgreSQL Global Development Group
- * Portions Copyright (c) 1994, Regents of the University of California
- *
- * src/include/utils/memutils.h
- *
- *-------------------------------------------------------------------------
- */
-#ifndef MEMUTILS_H
-#define MEMUTILS_H
-
-#include "nodes/memnodes.h"
-
-
-/*
- * MaxAllocSize, MaxAllocHugeSize
- *		Quasi-arbitrary limits on size of allocations.
- *
- * Note:
- *		There is no guarantee that smaller allocations will succeed, but
- *		larger requests will be summarily denied.
- *
- * palloc() enforces MaxAllocSize, chosen to correspond to the limiting size
- * of varlena objects under TOAST.  See VARSIZE_4B() and related macros in
- * postgres.h.  Many datatypes assume that any allocatable size can be
- * represented in a varlena header.  This limit also permits a caller to use
- * an "int" variable for an index into or length of an allocation.  Callers
- * careful to avoid these hazards can access the higher limit with
- * MemoryContextAllocHuge().  Both limits permit code to assume that it may
- * compute twice an allocation's size without overflow.
- */
-#define MaxAllocSize	((Size) 0x3fffffff) /* 1 gigabyte - 1 */
-
-#define AllocSizeIsValid(size)	((Size) (size) <= MaxAllocSize)
-
-#define MaxAllocHugeSize	(SIZE_MAX / 2)
-
-#define AllocHugeSizeIsValid(size)	((Size) (size) <= MaxAllocHugeSize)
-
-
-/*
- * Standard top-level memory contexts.
- *
- * Only TopMemoryContext and ErrorContext are initialized by
- * MemoryContextInit() itself.
- */
-extern PGDLLIMPORT __thread  MemoryContext TopMemoryContext;
-extern PGDLLIMPORT __thread  MemoryContext ErrorContext;
-extern PGDLLIMPORT MemoryContext PostmasterContext;
-extern PGDLLIMPORT MemoryContext CacheMemoryContext;
-extern PGDLLIMPORT MemoryContext MessageContext;
-extern PGDLLIMPORT MemoryContext TopTransactionContext;
-extern PGDLLIMPORT MemoryContext CurTransactionContext;
-
-/* This is a transient link to the active portal's memory context: */
-extern PGDLLIMPORT MemoryContext PortalContext;
-
-/* Backwards compatibility macro */
-#define MemoryContextResetAndDeleteChildren(ctx) MemoryContextReset(ctx)
-
-
-/*
- * Memory-context-type-independent functions in mcxt.c
- */
-extern void MemoryContextInit(void);
-extern void MemoryContextReset(MemoryContext context);
-extern void MemoryContextDelete(MemoryContext context);
-extern void MemoryContextResetOnly(MemoryContext context);
-extern void MemoryContextResetChildren(MemoryContext context);
-extern void MemoryContextDeleteChildren(MemoryContext context);
-extern void MemoryContextSetIdentifier(MemoryContext context, const char *id);
-extern void MemoryContextSetParent(MemoryContext context,
-								   MemoryContext new_parent);
-extern Size GetMemoryChunkSpace(void *pointer);
-extern MemoryContext MemoryContextGetParent(MemoryContext context);
-extern bool MemoryContextIsEmpty(MemoryContext context);
-extern Size MemoryContextMemAllocated(MemoryContext context, bool recurse);
-extern void MemoryContextStats(MemoryContext context);
-extern void MemoryContextStatsDetail(MemoryContext context, int max_children,
-									 bool print_to_stderr);
-extern void MemoryContextAllowInCriticalSection(MemoryContext context,
-												bool allow);
-
-#ifdef MEMORY_CONTEXT_CHECKING
-extern void MemoryContextCheck(MemoryContext context);
-#endif
-extern bool MemoryContextContains(MemoryContext context, void *pointer);
-
-/* Handy macro for copying and assigning context ID ... but note double eval */
-#define MemoryContextCopyAndSetIdentifier(cxt, id) \
-	MemoryContextSetIdentifier(cxt, MemoryContextStrdup(cxt, id))
-
-/*
- * GetMemoryChunkContext
- *		Given a currently-allocated chunk, determine the context
- *		it belongs to.
- *
- * All chunks allocated by any memory context manager are required to be
- * preceded by the corresponding MemoryContext stored, without padding, in the
- * preceding sizeof(void*) bytes.  A currently-allocated chunk must contain a
- * backpointer to its owning context.  The backpointer is used by pfree() and
- * repalloc() to find the context to call.
- */
-#ifndef FRONTEND
-static inline MemoryContext
-GetMemoryChunkContext(void *pointer)
-{
-	MemoryContext context;
-
-	/*
-	 * Try to detect bogus pointers handed to us, poorly though we can.
-	 * Presumably, a pointer that isn't MAXALIGNED isn't pointing at an
-	 * allocated chunk.
-	 */
-	Assert(pointer != NULL);
-	Assert(pointer == (void *) MAXALIGN(pointer));
-
-	/*
-	 * OK, it's probably safe to look at the context.
-	 */
-	context = *(MemoryContext *) (((char *) pointer) - sizeof(void *));
-
-	AssertArg(MemoryContextIsValid(context));
-
-	return context;
-}
-#endif
-
-/*
- * This routine handles the context-type-independent part of memory
- * context creation.  It's intended to be called from context-type-
- * specific creation routines, and noplace else.
- */
-extern void MemoryContextCreate(MemoryContext node,
-								NodeTag tag,
-								const MemoryContextMethods *methods,
-								MemoryContext parent,
-								const char *name);
-
-extern void HandleLogMemoryContextInterrupt(void);
-extern void ProcessLogMemoryContextInterrupt(void);
-
-/*
- * Memory-context-type-specific functions
- */
-
-/* aset.c */
-extern MemoryContext AllocSetContextCreateInternal(MemoryContext parent,
-												   const char *name,
-												   Size minContextSize,
-												   Size initBlockSize,
-												   Size maxBlockSize);
-extern void AllocSetDeleteFreeList(MemoryContext context);
-
-/*
- * This wrapper macro exists to check for non-constant strings used as context
- * names; that's no longer supported.  (Use MemoryContextSetIdentifier if you
- * want to provide a variable identifier.)
- */
-#ifdef HAVE__BUILTIN_CONSTANT_P
-#define AllocSetContextCreate(parent, name, ...) \
-	(StaticAssertExpr(__builtin_constant_p(name), \
-					  "memory context names must be constant strings"), \
-	 AllocSetContextCreateInternal(parent, name, __VA_ARGS__))
-#else
-#define AllocSetContextCreate \
-	AllocSetContextCreateInternal
-#endif
-
-/* slab.c */
-extern MemoryContext SlabContextCreate(MemoryContext parent,
-									   const char *name,
-									   Size blockSize,
-									   Size chunkSize);
-
-/* generation.c */
-extern MemoryContext GenerationContextCreate(MemoryContext parent,
-											 const char *name,
-											 Size minContextSize,
-											 Size initBlockSize,
-											 Size maxBlockSize);
-
-/*
- * Recommended default alloc parameters, suitable for "ordinary" contexts
- * that might hold quite a lot of data.
- */
-#define ALLOCSET_DEFAULT_MINSIZE   0
-#define ALLOCSET_DEFAULT_INITSIZE  (8 * 1024)
-#define ALLOCSET_DEFAULT_MAXSIZE   (8 * 1024 * 1024)
-#define ALLOCSET_DEFAULT_SIZES \
-	ALLOCSET_DEFAULT_MINSIZE, ALLOCSET_DEFAULT_INITSIZE, ALLOCSET_DEFAULT_MAXSIZE
-
-/*
- * Recommended alloc parameters for "small" contexts that are never expected
- * to contain much data (for example, a context to contain a query plan).
- */
-#define ALLOCSET_SMALL_MINSIZE	 0
-#define ALLOCSET_SMALL_INITSIZE  (1 * 1024)
-#define ALLOCSET_SMALL_MAXSIZE	 (8 * 1024)
-#define ALLOCSET_SMALL_SIZES \
-	ALLOCSET_SMALL_MINSIZE, ALLOCSET_SMALL_INITSIZE, ALLOCSET_SMALL_MAXSIZE
-
-/*
- * Recommended alloc parameters for contexts that should start out small,
- * but might sometimes grow big.
- */
-#define ALLOCSET_START_SMALL_SIZES \
-	ALLOCSET_SMALL_MINSIZE, ALLOCSET_SMALL_INITSIZE, ALLOCSET_DEFAULT_MAXSIZE
-
-
-/*
- * Threshold above which a request in an AllocSet context is certain to be
- * allocated separately (and thereby have constant allocation overhead).
- * Few callers should be interested in this, but tuplesort/tuplestore need
- * to know it.
- */
-#define ALLOCSET_SEPARATE_THRESHOLD  8192
-
-#define SLAB_DEFAULT_BLOCK_SIZE		(8 * 1024)
-#define SLAB_LARGE_BLOCK_SIZE		(8 * 1024 * 1024)
-
-#endif							/* MEMUTILS_H */

data/ext/pg_query/include/utils/numeric.h

@@ -1,90 +0,0 @@
-/*-------------------------------------------------------------------------
- *
- * numeric.h
- *	  Definitions for the exact numeric data type of Postgres
- *
- * Original coding 1998, Jan Wieck.  Heavily revised 2003, Tom Lane.
- *
- * Copyright (c) 1998-2022, PostgreSQL Global Development Group
- *
- * src/include/utils/numeric.h
- *
- *-------------------------------------------------------------------------
- */
-#ifndef _PG_NUMERIC_H_
-#define _PG_NUMERIC_H_
-
-#include "fmgr.h"
-
-/*
- * Limits on the precision and scale specifiable in a NUMERIC typmod.  The
- * precision is strictly positive, but the scale may be positive or negative.
- * A negative scale implies rounding before the decimal point.
- *
- * Note that the minimum display scale defined below is zero --- we always
- * display all digits before the decimal point, even when the scale is
- * negative.
- *
- * Note that the implementation limits on the precision and display scale of a
- * numeric value are much larger --- beware of what you use these for!
- */
-#define NUMERIC_MAX_PRECISION		1000
-
-#define NUMERIC_MIN_SCALE			(-1000)
-#define NUMERIC_MAX_SCALE			1000
-
-/*
- * Internal limits on the scales chosen for calculation results
- */
-#define NUMERIC_MAX_DISPLAY_SCALE	NUMERIC_MAX_PRECISION
-#define NUMERIC_MIN_DISPLAY_SCALE	0
-
-#define NUMERIC_MAX_RESULT_SCALE	(NUMERIC_MAX_PRECISION * 2)
-
-/*
- * For inherently inexact calculations such as division and square root,
- * we try to get at least this many significant digits; the idea is to
- * deliver a result no worse than float8 would.
- */
-#define NUMERIC_MIN_SIG_DIGITS		16
-
-/* The actual contents of Numeric are private to numeric.c */
-struct NumericData;
-typedef struct NumericData *Numeric;
-
-/*
- * fmgr interface macros
- */
-
-#define DatumGetNumeric(X)		  ((Numeric) PG_DETOAST_DATUM(X))
-#define DatumGetNumericCopy(X)	  ((Numeric) PG_DETOAST_DATUM_COPY(X))
-#define NumericGetDatum(X)		  PointerGetDatum(X)
-#define PG_GETARG_NUMERIC(n)	  DatumGetNumeric(PG_GETARG_DATUM(n))
-#define PG_GETARG_NUMERIC_COPY(n) DatumGetNumericCopy(PG_GETARG_DATUM(n))
-#define PG_RETURN_NUMERIC(x)	  return NumericGetDatum(x)
-
-/*
- * Utility functions in numeric.c
- */
-extern bool numeric_is_nan(Numeric num);
-extern bool numeric_is_inf(Numeric num);
-extern int32 numeric_maximum_size(int32 typmod);
-extern char *numeric_out_sci(Numeric num, int scale);
-extern char *numeric_normalize(Numeric num);
-
-extern Numeric int64_to_numeric(int64 val);
-extern Numeric int64_div_fast_to_numeric(int64 val1, int log10val2);
-
-extern Numeric numeric_add_opt_error(Numeric num1, Numeric num2,
-									 bool *have_error);
-extern Numeric numeric_sub_opt_error(Numeric num1, Numeric num2,
-									 bool *have_error);
-extern Numeric numeric_mul_opt_error(Numeric num1, Numeric num2,
-									 bool *have_error);
-extern Numeric numeric_div_opt_error(Numeric num1, Numeric num2,
-									 bool *have_error);
-extern Numeric numeric_mod_opt_error(Numeric num1, Numeric num2,
-									 bool *have_error);
-extern int32 numeric_int4_opt_error(Numeric num, bool *error);
-
-#endif							/* _PG_NUMERIC_H_ */

data/ext/pg_query/include/utils/palloc.h

@@ -1,158 +0,0 @@
-/*-------------------------------------------------------------------------
- *
- * palloc.h
- *	  POSTGRES memory allocator definitions.
- *
- * This file contains the basic memory allocation interface that is
- * needed by almost every backend module.  It is included directly by
- * postgres.h, so the definitions here are automatically available
- * everywhere.  Keep it lean!
- *
- * Memory allocation occurs within "contexts".  Every chunk obtained from
- * palloc()/MemoryContextAlloc() is allocated within a specific context.
- * The entire contents of a context can be freed easily and quickly by
- * resetting or deleting the context --- this is both faster and less
- * prone to memory-leakage bugs than releasing chunks individually.
- * We organize contexts into context trees to allow fine-grain control
- * over chunk lifetime while preserving the certainty that we will free
- * everything that should be freed.  See utils/mmgr/README for more info.
- *
- *
- * Portions Copyright (c) 1996-2022, PostgreSQL Global Development Group
- * Portions Copyright (c) 1994, Regents of the University of California
- *
- * src/include/utils/palloc.h
- *
- *-------------------------------------------------------------------------
- */
-#ifndef PALLOC_H
-#define PALLOC_H
-
-/*
- * Type MemoryContextData is declared in nodes/memnodes.h.  Most users
- * of memory allocation should just treat it as an abstract type, so we
- * do not provide the struct contents here.
- */
-typedef struct MemoryContextData *MemoryContext;
-
-/*
- * A memory context can have callback functions registered on it.  Any such
- * function will be called once just before the context is next reset or
- * deleted.  The MemoryContextCallback struct describing such a callback
- * typically would be allocated within the context itself, thereby avoiding
- * any need to manage it explicitly (the reset/delete action will free it).
- */
-typedef void (*MemoryContextCallbackFunction) (void *arg);
-
-typedef struct MemoryContextCallback
-{
-	MemoryContextCallbackFunction func; /* function to call */
-	void	   *arg;			/* argument to pass it */
-	struct MemoryContextCallback *next; /* next in list of callbacks */
-} MemoryContextCallback;
-
-/*
- * CurrentMemoryContext is the default allocation context for palloc().
- * Avoid accessing it directly!  Instead, use MemoryContextSwitchTo()
- * to change the setting.
- */
-extern PGDLLIMPORT __thread  MemoryContext CurrentMemoryContext;
-
-/*
- * Flags for MemoryContextAllocExtended.
- */
-#define MCXT_ALLOC_HUGE			0x01	/* allow huge allocation (> 1 GB) */
-#define MCXT_ALLOC_NO_OOM		0x02	/* no failure if out-of-memory */
-#define MCXT_ALLOC_ZERO			0x04	/* zero allocated memory */
-
-/*
- * Fundamental memory-allocation operations (more are in utils/memutils.h)
- */
-extern void *MemoryContextAlloc(MemoryContext context, Size size);
-extern void *MemoryContextAllocZero(MemoryContext context, Size size);
-extern void *MemoryContextAllocZeroAligned(MemoryContext context, Size size);
-extern void *MemoryContextAllocExtended(MemoryContext context,
-										Size size, int flags);
-
-extern void *palloc(Size size);
-extern void *palloc0(Size size);
-extern void *palloc_extended(Size size, int flags);
-extern pg_nodiscard void *repalloc(void *pointer, Size size);
-extern void pfree(void *pointer);
-
-/*
- * Variants with easier notation and more type safety
- */
-
-/*
- * Allocate space for one object of type "type"
- */
-#define palloc_object(type) ((type *) palloc(sizeof(type)))
-#define palloc0_object(type) ((type *) palloc0(sizeof(type)))
-
-/*
- * Allocate space for "count" objects of type "type"
- */
-#define palloc_array(type, count) ((type *) palloc(sizeof(type) * (count)))
-#define palloc0_array(type, count) ((type *) palloc0(sizeof(type) * (count)))
-
-/*
- * Change size of allocation pointed to by "pointer" to have space for "count"
- * objects of type "type"
- */
-#define repalloc_array(pointer, type, count) ((type *) repalloc(pointer, sizeof(type) * (count)))
-
-/*
- * The result of palloc() is always word-aligned, so we can skip testing
- * alignment of the pointer when deciding which MemSet variant to use.
- * Note that this variant does not offer any advantage, and should not be
- * used, unless its "sz" argument is a compile-time constant; therefore, the
- * issue that it evaluates the argument multiple times isn't a problem in
- * practice.
- */
-#define palloc0fast(sz) \
-	( MemSetTest(0, sz) ? \
-		MemoryContextAllocZeroAligned(CurrentMemoryContext, sz) : \
-		MemoryContextAllocZero(CurrentMemoryContext, sz) )
-
-/* Higher-limit allocators. */
-extern void *MemoryContextAllocHuge(MemoryContext context, Size size);
-extern pg_nodiscard void *repalloc_huge(void *pointer, Size size);
-
-/*
- * Although this header file is nominally backend-only, certain frontend
- * programs like pg_controldata include it via postgres.h.  For some compilers
- * it's necessary to hide the inline definition of MemoryContextSwitchTo in
- * this scenario; hence the #ifndef FRONTEND.
- */
-
-#ifndef FRONTEND
-static inline MemoryContext
-MemoryContextSwitchTo(MemoryContext context)
-{
-	MemoryContext old = CurrentMemoryContext;
-
-	CurrentMemoryContext = context;
-	return old;
-}
-#endif							/* FRONTEND */
-
-/* Registration of memory context reset/delete callbacks */
-extern void MemoryContextRegisterResetCallback(MemoryContext context,
-											   MemoryContextCallback *cb);
-
-/*
- * These are like standard strdup() except the copied string is
- * allocated in a context, not with malloc().
- */
-extern char *MemoryContextStrdup(MemoryContext context, const char *string);
-extern char *pstrdup(const char *in);
-extern char *pnstrdup(const char *in, Size len);
-
-extern char *pchomp(const char *in);
-
-/* sprintf into a palloc'd buffer --- these are in psprintf.c */
-extern char *psprintf(const char *fmt,...) pg_attribute_printf(1, 2);
-extern size_t pvsnprintf(char *buf, size_t len, const char *fmt, va_list args) pg_attribute_printf(3, 0);
-
-#endif							/* PALLOC_H */

data/ext/pg_query/include/utils/partcache.h

@@ -1,102 +0,0 @@
-/*-------------------------------------------------------------------------
- *
- * partcache.h
- *
- * Copyright (c) 1996-2022, PostgreSQL Global Development Group
- *
- * src/include/utils/partcache.h
- *
- *-------------------------------------------------------------------------
- */
-#ifndef PARTCACHE_H
-#define PARTCACHE_H
-
-#include "access/attnum.h"
-#include "fmgr.h"
-#include "nodes/pg_list.h"
-#include "nodes/primnodes.h"
-#include "partitioning/partdefs.h"
-#include "utils/relcache.h"
-
-/*
- * Information about the partition key of a relation
- */
-typedef struct PartitionKeyData
-{
-	char		strategy;		/* partitioning strategy */
-	int16		partnatts;		/* number of columns in the partition key */
-	AttrNumber *partattrs;		/* attribute numbers of columns in the
-								 * partition key or 0 if it's an expr */
-	List	   *partexprs;		/* list of expressions in the partitioning
-								 * key, one for each zero-valued partattrs */
-
-	Oid		   *partopfamily;	/* OIDs of operator families */
-	Oid		   *partopcintype;	/* OIDs of opclass declared input data types */
-	FmgrInfo   *partsupfunc;	/* lookup info for support funcs */
-
-	/* Partitioning collation per attribute */
-	Oid		   *partcollation;
-
-	/* Type information per attribute */
-	Oid		   *parttypid;
-	int32	   *parttypmod;
-	int16	   *parttyplen;
-	bool	   *parttypbyval;
-	char	   *parttypalign;
-	Oid		   *parttypcoll;
-}			PartitionKeyData;
-
-
-extern PartitionKey RelationGetPartitionKey(Relation rel);
-extern List *RelationGetPartitionQual(Relation rel);
-extern Expr *get_partition_qual_relid(Oid relid);
-
-/*
- * PartitionKey inquiry functions
- */
-static inline int
-get_partition_strategy(PartitionKey key)
-{
-	return key->strategy;
-}
-
-static inline int
-get_partition_natts(PartitionKey key)
-{
-	return key->partnatts;
-}
-
-static inline List *
-get_partition_exprs(PartitionKey key)
-{
-	return key->partexprs;
-}
-
-/*
- * PartitionKey inquiry functions - one column
- */
-static inline int16
-get_partition_col_attnum(PartitionKey key, int col)
-{
-	return key->partattrs[col];
-}
-
-static inline Oid
-get_partition_col_typid(PartitionKey key, int col)
-{
-	return key->parttypid[col];
-}
-
-static inline int32
-get_partition_col_typmod(PartitionKey key, int col)
-{
-	return key->parttypmod[col];
-}
-
-static inline Oid
-get_partition_col_collation(PartitionKey key, int col)
-{
-	return key->partcollation[col];
-}
-
-#endif							/* PARTCACHE_H */