pg_query 5.0.0 → 6.0.0

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

@@ -1,237 +0,0 @@
-/*-------------------------------------------------------------------------
- *
- * memutils_memorychunk.h
- *	  Here we define a struct named MemoryChunk which implementations of
- *	  MemoryContexts may use as a header for chunks of memory they allocate.
- *
- * MemoryChunk provides a lightweight header that a MemoryContext can use to
- * store a reference back to the block which the given chunk is allocated on
- * and also an additional 30-bits to store another value such as the size of
- * the allocated chunk.
- *
- * Although MemoryChunks are used by each of our MemoryContexts, future
- * implementations may choose to implement their own method for storing chunk
- * headers.  The only requirement is that the header ends with an 8-byte value
- * which the least significant 3-bits of are set to the MemoryContextMethodID
- * of the given context.
- *
- * By default, a MemoryChunk is 8 bytes in size, however, when
- * MEMORY_CONTEXT_CHECKING is defined the header becomes 16 bytes in size due
- * to the additional requested_size field.  The MemoryContext may use this
- * field for whatever they wish, but it is intended to be used for additional
- * checks which are only done in MEMORY_CONTEXT_CHECKING builds.
- *
- * The MemoryChunk contains a uint64 field named 'hdrmask'.  This field is
- * used to encode 4 separate pieces of information.  Starting with the least
- * significant bits of 'hdrmask', the bit space is reserved as follows:
- *
- * 1.	3-bits to indicate the MemoryContextMethodID as defined by
- *		MEMORY_CONTEXT_METHODID_MASK
- * 2.	1-bit to denote an "external" chunk (see below)
- * 3.	30-bits reserved for the MemoryContext to use for anything it
- *		requires.  Most MemoryContext likely want to store the size of the
- *		chunk here.
- * 4.	30-bits for the number of bytes that must be subtracted from the chunk
- *		to obtain the address of the block that the chunk is stored on.
- *
- * In some cases, for example when memory allocations become large, it's
- * possible fields 3 and 4 above are not large enough to store the values
- * required for the chunk.  In this case, the MemoryContext can choose to mark
- * the chunk as "external" by calling the MemoryChunkSetHdrMaskExternal()
- * function.  When this is done, fields 3 and 4 are unavailable for use by the
- * MemoryContext and it's up to the MemoryContext itself to devise its own
- * method for getting the reference to the block.
- *
- * Interface:
- *
- * MemoryChunkSetHdrMask:
- *		Used to set up a non-external MemoryChunk.
- *
- * MemoryChunkSetHdrMaskExternal:
- *		Used to set up an externally managed MemoryChunk.
- *
- * MemoryChunkIsExternal:
- *		Determine if the given MemoryChunk is externally managed, i.e.
- *		MemoryChunkSetHdrMaskExternal() was called on the chunk.
- *
- * MemoryChunkGetValue:
- *		For non-external chunks, return the stored 30-bit value as it was set
- *		in the call to MemoryChunkSetHdrMask().
- *
- * MemoryChunkGetBlock:
- *		For non-external chunks, return a pointer to the block as it was set
- *		in the call to MemoryChunkSetHdrMask().
- *
- * Also exports:
- *		MEMORYCHUNK_MAX_VALUE
- *		MEMORYCHUNK_MAX_BLOCKOFFSET
- *		PointerGetMemoryChunk
- *		MemoryChunkGetPointer
- *
- * Portions Copyright (c) 2022-2023, PostgreSQL Global Development Group
- * Portions Copyright (c) 1994, Regents of the University of California
- *
- * src/include/utils/memutils_memorychunk.h
- *
- *-------------------------------------------------------------------------
- */
-
-#ifndef MEMUTILS_MEMORYCHUNK_H
-#define MEMUTILS_MEMORYCHUNK_H
-
-#include "utils/memutils_internal.h"
-
- /*
-  * The maximum allowed value that MemoryContexts can store in the value
-  * field.  Must be 1 less than a power of 2.
-  */
-#define MEMORYCHUNK_MAX_VALUE			UINT64CONST(0x3FFFFFFF)
-
-/*
- * The maximum distance in bytes that a MemoryChunk can be offset from the
- * block that is storing the chunk.  Must be 1 less than a power of 2.
- */
-#define MEMORYCHUNK_MAX_BLOCKOFFSET		UINT64CONST(0x3FFFFFFF)
-
-/* define the least significant base-0 bit of each portion of the hdrmask */
-#define MEMORYCHUNK_EXTERNAL_BASEBIT	MEMORY_CONTEXT_METHODID_BITS
-#define MEMORYCHUNK_VALUE_BASEBIT		(MEMORYCHUNK_EXTERNAL_BASEBIT + 1)
-#define MEMORYCHUNK_BLOCKOFFSET_BASEBIT	(MEMORYCHUNK_VALUE_BASEBIT + 30)
-
-/*
- * A magic number for storing in the free bits of an external chunk.  This
- * must mask out the bits used for storing the MemoryContextMethodID and the
- * external bit.
- */
-#define MEMORYCHUNK_MAGIC		(UINT64CONST(0xB1A8DB858EB6EFBA) >> \
-								 MEMORYCHUNK_VALUE_BASEBIT << \
-								 MEMORYCHUNK_VALUE_BASEBIT)
-
-typedef struct MemoryChunk
-{
-#ifdef MEMORY_CONTEXT_CHECKING
-	Size		requested_size;
-#endif
-
-	/* bitfield for storing details about the chunk */
-	uint64		hdrmask;		/* must be last */
-} MemoryChunk;
-
-/* Get the MemoryChunk from the pointer */
-#define PointerGetMemoryChunk(p) \
-	((MemoryChunk *) ((char *) (p) - sizeof(MemoryChunk)))
-/* Get the pointer from the MemoryChunk */
-#define MemoryChunkGetPointer(c) \
-	((void *) ((char *) (c) + sizeof(MemoryChunk)))
-
-/* private macros for making the inline functions below more simple */
-#define HdrMaskIsExternal(hdrmask) \
-	((hdrmask) & (((uint64) 1) << MEMORYCHUNK_EXTERNAL_BASEBIT))
-#define HdrMaskGetValue(hdrmask) \
-	(((hdrmask) >> MEMORYCHUNK_VALUE_BASEBIT) & MEMORYCHUNK_MAX_VALUE)
-
-/*
- * We should have used up all the bits here, so the compiler is likely to
- * optimize out the & MEMORYCHUNK_MAX_BLOCKOFFSET.
- */
-#define HdrMaskBlockOffset(hdrmask) \
-	(((hdrmask) >> MEMORYCHUNK_BLOCKOFFSET_BASEBIT) & MEMORYCHUNK_MAX_BLOCKOFFSET)
-
-/* For external chunks only, check the magic number matches */
-#define HdrMaskCheckMagic(hdrmask) \
-	(MEMORYCHUNK_MAGIC == \
-	 ((hdrmask) >> MEMORYCHUNK_VALUE_BASEBIT << MEMORYCHUNK_VALUE_BASEBIT))
-/*
- * MemoryChunkSetHdrMask
- *		Store the given 'block', 'chunk_size' and 'methodid' in the given
- *		MemoryChunk.
- *
- * The number of bytes between 'block' and 'chunk' must be <=
- * MEMORYCHUNK_MAX_BLOCKOFFSET.
- * 'value' must be <= MEMORYCHUNK_MAX_VALUE.
- */
-static inline void
-MemoryChunkSetHdrMask(MemoryChunk *chunk, void *block,
-					  Size value, MemoryContextMethodID methodid)
-{
-	Size		blockoffset = (char *) chunk - (char *) block;
-
-	Assert((char *) chunk >= (char *) block);
-	Assert(blockoffset <= MEMORYCHUNK_MAX_BLOCKOFFSET);
-	Assert(value <= MEMORYCHUNK_MAX_VALUE);
-	Assert((int) methodid <= MEMORY_CONTEXT_METHODID_MASK);
-
-	chunk->hdrmask = (((uint64) blockoffset) << MEMORYCHUNK_BLOCKOFFSET_BASEBIT) |
-		(((uint64) value) << MEMORYCHUNK_VALUE_BASEBIT) |
-		methodid;
-}
-
-/*
- * MemoryChunkSetHdrMaskExternal
- *		Set 'chunk' as an externally managed chunk.  Here we only record the
- *		MemoryContextMethodID and set the external chunk bit.
- */
-static inline void
-MemoryChunkSetHdrMaskExternal(MemoryChunk *chunk,
-							  MemoryContextMethodID methodid)
-{
-	Assert((int) methodid <= MEMORY_CONTEXT_METHODID_MASK);
-
-	chunk->hdrmask = MEMORYCHUNK_MAGIC | (((uint64) 1) << MEMORYCHUNK_EXTERNAL_BASEBIT) |
-		methodid;
-}
-
-/*
- * MemoryChunkIsExternal
- *		Return true if 'chunk' is marked as external.
- */
-static inline bool
-MemoryChunkIsExternal(MemoryChunk *chunk)
-{
-	/*
-	 * External chunks should always store MEMORYCHUNK_MAGIC in the upper
-	 * portion of the hdrmask, check that nothing has stomped on that.
-	 */
-	Assert(!HdrMaskIsExternal(chunk->hdrmask) ||
-		   HdrMaskCheckMagic(chunk->hdrmask));
-
-	return HdrMaskIsExternal(chunk->hdrmask);
-}
-
-/*
- * MemoryChunkGetValue
- *		For non-external chunks, returns the value field as it was set in
- *		MemoryChunkSetHdrMask.
- */
-static inline Size
-MemoryChunkGetValue(MemoryChunk *chunk)
-{
-	Assert(!HdrMaskIsExternal(chunk->hdrmask));
-
-	return HdrMaskGetValue(chunk->hdrmask);
-}
-
-/*
- * MemoryChunkGetBlock
- *		For non-external chunks, returns the pointer to the block as was set
- *		in MemoryChunkSetHdrMask.
- */
-static inline void *
-MemoryChunkGetBlock(MemoryChunk *chunk)
-{
-	Assert(!HdrMaskIsExternal(chunk->hdrmask));
-
-	return (void *) ((char *) chunk - HdrMaskBlockOffset(chunk->hdrmask));
-}
-
-/* cleanup all internal definitions */
-#undef MEMORYCHUNK_EXTERNAL_BASEBIT
-#undef MEMORYCHUNK_VALUE_BASEBIT
-#undef MEMORYCHUNK_BLOCKOFFSET_BASEBIT
-#undef MEMORYCHUNK_MAGIC
-#undef HdrMaskIsExternal
-#undef HdrMaskGetValue
-#undef HdrMaskBlockOffset
-#undef HdrMaskCheckMagic
-
-#endif							/* MEMUTILS_MEMORYCHUNK_H */

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

@@ -1,105 +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-2023, 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
- */
-
-static inline Numeric
-DatumGetNumeric(Datum X)
-{
-	return (Numeric) PG_DETOAST_DATUM(X);
-}
-
-static inline Numeric
-DatumGetNumericCopy(Datum X)
-{
-	return (Numeric) PG_DETOAST_DATUM_COPY(X);
-}
-
-static inline Datum
-NumericGetDatum(Numeric X)
-{
-	return 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 *have_error);
-
-#endif							/* _PG_NUMERIC_H_ */

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

@@ -1,165 +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-2023, 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 *MemoryContextAllocAligned(MemoryContext context,
-									   Size size, Size alignto, int flags);
-
-extern void *palloc(Size size);
-extern void *palloc0(Size size);
-extern void *palloc_extended(Size size, int flags);
-extern void *palloc_aligned(Size size, Size alignto, int flags);
-extern pg_nodiscard void *repalloc(void *pointer, Size size);
-extern pg_nodiscard void *repalloc_extended(void *pointer,
-											Size size, int flags);
-extern pg_nodiscard void *repalloc0(void *pointer, Size oldsize, 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)))
-#define repalloc0_array(pointer, type, oldcount, count) ((type *) repalloc0(pointer, sizeof(type) * (oldcount), 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,103 +0,0 @@
-/*-------------------------------------------------------------------------
- *
- * partcache.h
- *
- * Copyright (c) 1996-2023, PostgreSQL Global Development Group
- *
- * src/include/utils/partcache.h
- *
- *-------------------------------------------------------------------------
- */
-#ifndef PARTCACHE_H
-#define PARTCACHE_H
-
-#include "access/attnum.h"
-#include "fmgr.h"
-#include "nodes/parsenodes.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
-{
-	PartitionStrategy 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 */