pg_query 5.0.0 → 6.0.0

data/ext/pg_query/include/common/int.h

@@ -1,437 +0,0 @@
-/*-------------------------------------------------------------------------
- *
- * int.h
- *	  Routines to perform integer math, while checking for overflows.
- *
- * The routines in this file are intended to be well defined C, without
- * relying on compiler flags like -fwrapv.
- *
- * To reduce the overhead of these routines try to use compiler intrinsics
- * where available. That's not that important for the 16, 32 bit cases, but
- * the 64 bit cases can be considerably faster with intrinsics. In case no
- * intrinsics are available 128 bit math is used where available.
- *
- * Copyright (c) 2017-2023, PostgreSQL Global Development Group
- *
- * src/include/common/int.h
- *
- *-------------------------------------------------------------------------
- */
-#ifndef COMMON_INT_H
-#define COMMON_INT_H
-
-
-/*---------
- * The following guidelines apply to all the routines:
- * - If a + b overflows, return true, otherwise store the result of a + b
- * into *result. The content of *result is implementation defined in case of
- * overflow.
- * - If a - b overflows, return true, otherwise store the result of a - b
- * into *result. The content of *result is implementation defined in case of
- * overflow.
- * - If a * b overflows, return true, otherwise store the result of a * b
- * into *result. The content of *result is implementation defined in case of
- * overflow.
- *---------
- */
-
-/*------------------------------------------------------------------------
- * Overflow routines for signed integers
- *------------------------------------------------------------------------
- */
-
-/*
- * INT16
- */
-static inline bool
-pg_add_s16_overflow(int16 a, int16 b, int16 *result)
-{
-#if defined(HAVE__BUILTIN_OP_OVERFLOW)
-	return __builtin_add_overflow(a, b, result);
-#else
-	int32		res = (int32) a + (int32) b;
-
-	if (res > PG_INT16_MAX || res < PG_INT16_MIN)
-	{
-		*result = 0x5EED;		/* to avoid spurious warnings */
-		return true;
-	}
-	*result = (int16) res;
-	return false;
-#endif
-}
-
-static inline bool
-pg_sub_s16_overflow(int16 a, int16 b, int16 *result)
-{
-#if defined(HAVE__BUILTIN_OP_OVERFLOW)
-	return __builtin_sub_overflow(a, b, result);
-#else
-	int32		res = (int32) a - (int32) b;
-
-	if (res > PG_INT16_MAX || res < PG_INT16_MIN)
-	{
-		*result = 0x5EED;		/* to avoid spurious warnings */
-		return true;
-	}
-	*result = (int16) res;
-	return false;
-#endif
-}
-
-static inline bool
-pg_mul_s16_overflow(int16 a, int16 b, int16 *result)
-{
-#if defined(HAVE__BUILTIN_OP_OVERFLOW)
-	return __builtin_mul_overflow(a, b, result);
-#else
-	int32		res = (int32) a * (int32) b;
-
-	if (res > PG_INT16_MAX || res < PG_INT16_MIN)
-	{
-		*result = 0x5EED;		/* to avoid spurious warnings */
-		return true;
-	}
-	*result = (int16) res;
-	return false;
-#endif
-}
-
-/*
- * INT32
- */
-static inline bool
-pg_add_s32_overflow(int32 a, int32 b, int32 *result)
-{
-#if defined(HAVE__BUILTIN_OP_OVERFLOW)
-	return __builtin_add_overflow(a, b, result);
-#else
-	int64		res = (int64) a + (int64) b;
-
-	if (res > PG_INT32_MAX || res < PG_INT32_MIN)
-	{
-		*result = 0x5EED;		/* to avoid spurious warnings */
-		return true;
-	}
-	*result = (int32) res;
-	return false;
-#endif
-}
-
-static inline bool
-pg_sub_s32_overflow(int32 a, int32 b, int32 *result)
-{
-#if defined(HAVE__BUILTIN_OP_OVERFLOW)
-	return __builtin_sub_overflow(a, b, result);
-#else
-	int64		res = (int64) a - (int64) b;
-
-	if (res > PG_INT32_MAX || res < PG_INT32_MIN)
-	{
-		*result = 0x5EED;		/* to avoid spurious warnings */
-		return true;
-	}
-	*result = (int32) res;
-	return false;
-#endif
-}
-
-static inline bool
-pg_mul_s32_overflow(int32 a, int32 b, int32 *result)
-{
-#if defined(HAVE__BUILTIN_OP_OVERFLOW)
-	return __builtin_mul_overflow(a, b, result);
-#else
-	int64		res = (int64) a * (int64) b;
-
-	if (res > PG_INT32_MAX || res < PG_INT32_MIN)
-	{
-		*result = 0x5EED;		/* to avoid spurious warnings */
-		return true;
-	}
-	*result = (int32) res;
-	return false;
-#endif
-}
-
-/*
- * INT64
- */
-static inline bool
-pg_add_s64_overflow(int64 a, int64 b, int64 *result)
-{
-#if defined(HAVE__BUILTIN_OP_OVERFLOW)
-	return __builtin_add_overflow(a, b, result);
-#elif defined(HAVE_INT128)
-	int128		res = (int128) a + (int128) b;
-
-	if (res > PG_INT64_MAX || res < PG_INT64_MIN)
-	{
-		*result = 0x5EED;		/* to avoid spurious warnings */
-		return true;
-	}
-	*result = (int64) res;
-	return false;
-#else
-	if ((a > 0 && b > 0 && a > PG_INT64_MAX - b) ||
-		(a < 0 && b < 0 && a < PG_INT64_MIN - b))
-	{
-		*result = 0x5EED;		/* to avoid spurious warnings */
-		return true;
-	}
-	*result = a + b;
-	return false;
-#endif
-}
-
-static inline bool
-pg_sub_s64_overflow(int64 a, int64 b, int64 *result)
-{
-#if defined(HAVE__BUILTIN_OP_OVERFLOW)
-	return __builtin_sub_overflow(a, b, result);
-#elif defined(HAVE_INT128)
-	int128		res = (int128) a - (int128) b;
-
-	if (res > PG_INT64_MAX || res < PG_INT64_MIN)
-	{
-		*result = 0x5EED;		/* to avoid spurious warnings */
-		return true;
-	}
-	*result = (int64) res;
-	return false;
-#else
-	if ((a < 0 && b > 0 && a < PG_INT64_MIN + b) ||
-		(a > 0 && b < 0 && a > PG_INT64_MAX + b))
-	{
-		*result = 0x5EED;		/* to avoid spurious warnings */
-		return true;
-	}
-	*result = a - b;
-	return false;
-#endif
-}
-
-static inline bool
-pg_mul_s64_overflow(int64 a, int64 b, int64 *result)
-{
-#if defined(HAVE__BUILTIN_OP_OVERFLOW)
-	return __builtin_mul_overflow(a, b, result);
-#elif defined(HAVE_INT128)
-	int128		res = (int128) a * (int128) b;
-
-	if (res > PG_INT64_MAX || res < PG_INT64_MIN)
-	{
-		*result = 0x5EED;		/* to avoid spurious warnings */
-		return true;
-	}
-	*result = (int64) res;
-	return false;
-#else
-	/*
-	 * Overflow can only happen if at least one value is outside the range
-	 * sqrt(min)..sqrt(max) so check that first as the division can be quite a
-	 * bit more expensive than the multiplication.
-	 *
-	 * Multiplying by 0 or 1 can't overflow of course and checking for 0
-	 * separately avoids any risk of dividing by 0.  Be careful about dividing
-	 * INT_MIN by -1 also, note reversing the a and b to ensure we're always
-	 * dividing it by a positive value.
-	 *
-	 */
-	if ((a > PG_INT32_MAX || a < PG_INT32_MIN ||
-		 b > PG_INT32_MAX || b < PG_INT32_MIN) &&
-		a != 0 && a != 1 && b != 0 && b != 1 &&
-		((a > 0 && b > 0 && a > PG_INT64_MAX / b) ||
-		 (a > 0 && b < 0 && b < PG_INT64_MIN / a) ||
-		 (a < 0 && b > 0 && a < PG_INT64_MIN / b) ||
-		 (a < 0 && b < 0 && a < PG_INT64_MAX / b)))
-	{
-		*result = 0x5EED;		/* to avoid spurious warnings */
-		return true;
-	}
-	*result = a * b;
-	return false;
-#endif
-}
-
-/*------------------------------------------------------------------------
- * Overflow routines for unsigned integers
- *------------------------------------------------------------------------
- */
-
-/*
- * UINT16
- */
-static inline bool
-pg_add_u16_overflow(uint16 a, uint16 b, uint16 *result)
-{
-#if defined(HAVE__BUILTIN_OP_OVERFLOW)
-	return __builtin_add_overflow(a, b, result);
-#else
-	uint16		res = a + b;
-
-	if (res < a)
-	{
-		*result = 0x5EED;		/* to avoid spurious warnings */
-		return true;
-	}
-	*result = res;
-	return false;
-#endif
-}
-
-static inline bool
-pg_sub_u16_overflow(uint16 a, uint16 b, uint16 *result)
-{
-#if defined(HAVE__BUILTIN_OP_OVERFLOW)
-	return __builtin_sub_overflow(a, b, result);
-#else
-	if (b > a)
-	{
-		*result = 0x5EED;		/* to avoid spurious warnings */
-		return true;
-	}
-	*result = a - b;
-	return false;
-#endif
-}
-
-static inline bool
-pg_mul_u16_overflow(uint16 a, uint16 b, uint16 *result)
-{
-#if defined(HAVE__BUILTIN_OP_OVERFLOW)
-	return __builtin_mul_overflow(a, b, result);
-#else
-	uint32		res = (uint32) a * (uint32) b;
-
-	if (res > PG_UINT16_MAX)
-	{
-		*result = 0x5EED;		/* to avoid spurious warnings */
-		return true;
-	}
-	*result = (uint16) res;
-	return false;
-#endif
-}
-
-/*
- * INT32
- */
-static inline bool
-pg_add_u32_overflow(uint32 a, uint32 b, uint32 *result)
-{
-#if defined(HAVE__BUILTIN_OP_OVERFLOW)
-	return __builtin_add_overflow(a, b, result);
-#else
-	uint32		res = a + b;
-
-	if (res < a)
-	{
-		*result = 0x5EED;		/* to avoid spurious warnings */
-		return true;
-	}
-	*result = res;
-	return false;
-#endif
-}
-
-static inline bool
-pg_sub_u32_overflow(uint32 a, uint32 b, uint32 *result)
-{
-#if defined(HAVE__BUILTIN_OP_OVERFLOW)
-	return __builtin_sub_overflow(a, b, result);
-#else
-	if (b > a)
-	{
-		*result = 0x5EED;		/* to avoid spurious warnings */
-		return true;
-	}
-	*result = a - b;
-	return false;
-#endif
-}
-
-static inline bool
-pg_mul_u32_overflow(uint32 a, uint32 b, uint32 *result)
-{
-#if defined(HAVE__BUILTIN_OP_OVERFLOW)
-	return __builtin_mul_overflow(a, b, result);
-#else
-	uint64		res = (uint64) a * (uint64) b;
-
-	if (res > PG_UINT32_MAX)
-	{
-		*result = 0x5EED;		/* to avoid spurious warnings */
-		return true;
-	}
-	*result = (uint32) res;
-	return false;
-#endif
-}
-
-/*
- * UINT64
- */
-static inline bool
-pg_add_u64_overflow(uint64 a, uint64 b, uint64 *result)
-{
-#if defined(HAVE__BUILTIN_OP_OVERFLOW)
-	return __builtin_add_overflow(a, b, result);
-#else
-	uint64		res = a + b;
-
-	if (res < a)
-	{
-		*result = 0x5EED;		/* to avoid spurious warnings */
-		return true;
-	}
-	*result = res;
-	return false;
-#endif
-}
-
-static inline bool
-pg_sub_u64_overflow(uint64 a, uint64 b, uint64 *result)
-{
-#if defined(HAVE__BUILTIN_OP_OVERFLOW)
-	return __builtin_sub_overflow(a, b, result);
-#else
-	if (b > a)
-	{
-		*result = 0x5EED;		/* to avoid spurious warnings */
-		return true;
-	}
-	*result = a - b;
-	return false;
-#endif
-}
-
-static inline bool
-pg_mul_u64_overflow(uint64 a, uint64 b, uint64 *result)
-{
-#if defined(HAVE__BUILTIN_OP_OVERFLOW)
-	return __builtin_mul_overflow(a, b, result);
-#elif defined(HAVE_INT128)
-	uint128		res = (uint128) a * (uint128) b;
-
-	if (res > PG_UINT64_MAX)
-	{
-		*result = 0x5EED;		/* to avoid spurious warnings */
-		return true;
-	}
-	*result = (uint64) res;
-	return false;
-#else
-	uint64		res = a * b;
-
-	if (a != 0 && b != res / a)
-	{
-		*result = 0x5EED;		/* to avoid spurious warnings */
-		return true;
-	}
-	*result = res;
-	return false;
-#endif
-}
-
-#endif							/* COMMON_INT_H */

data/ext/pg_query/include/common/ip.h

@@ -1,33 +0,0 @@
-/*-------------------------------------------------------------------------
- *
- * ip.h
- *	  Definitions for IPv6-aware network access.
- *
- * These definitions are used by both frontend and backend code.
- *
- * Copyright (c) 2003-2023, PostgreSQL Global Development Group
- *
- * src/include/common/ip.h
- *
- *-------------------------------------------------------------------------
- */
-#ifndef IP_H
-#define IP_H
-
-#include <netdb.h>
-#include <sys/socket.h>
-
-#include "libpq/pqcomm.h"		/* pgrminclude ignore */
-
-
-extern int	pg_getaddrinfo_all(const char *hostname, const char *servname,
-							   const struct addrinfo *hintp,
-							   struct addrinfo **result);
-extern void pg_freeaddrinfo_all(int hint_ai_family, struct addrinfo *ai);
-
-extern int	pg_getnameinfo_all(const struct sockaddr_storage *addr, int salen,
-							   char *node, int nodelen,
-							   char *service, int servicelen,
-							   int flags);
-
-#endif							/* IP_H */

data/ext/pg_query/include/common/keywords.h

@@ -1,29 +0,0 @@
-/*-------------------------------------------------------------------------
- *
- * keywords.h
- *	  PostgreSQL's list of SQL keywords
- *
- *
- * Portions Copyright (c) 1996-2023, PostgreSQL Global Development Group
- * Portions Copyright (c) 1994, Regents of the University of California
- *
- * src/include/common/keywords.h
- *
- *-------------------------------------------------------------------------
- */
-#ifndef KEYWORDS_H
-#define KEYWORDS_H
-
-#include "common/kwlookup.h"
-
-/* Keyword categories --- should match lists in gram.y */
-#define UNRESERVED_KEYWORD		0
-#define COL_NAME_KEYWORD		1
-#define TYPE_FUNC_NAME_KEYWORD	2
-#define RESERVED_KEYWORD		3
-
-extern PGDLLIMPORT const ScanKeywordList ScanKeywords;
-extern PGDLLIMPORT const uint8 ScanKeywordCategories[];
-extern PGDLLIMPORT const bool ScanKeywordBareLabel[];
-
-#endif							/* KEYWORDS_H */

data/ext/pg_query/include/common/kwlookup.h

@@ -1,44 +0,0 @@
-/*-------------------------------------------------------------------------
- *
- * kwlookup.h
- *	  Key word lookup for PostgreSQL
- *
- *
- * Portions Copyright (c) 1996-2023, PostgreSQL Global Development Group
- * Portions Copyright (c) 1994, Regents of the University of California
- *
- * src/include/common/kwlookup.h
- *
- *-------------------------------------------------------------------------
- */
-#ifndef KWLOOKUP_H
-#define KWLOOKUP_H
-
-/* Hash function used by ScanKeywordLookup */
-typedef int (*ScanKeywordHashFunc) (const void *key, size_t keylen);
-
-/*
- * This struct contains the data needed by ScanKeywordLookup to perform a
- * search within a set of keywords.  The contents are typically generated by
- * src/tools/gen_keywordlist.pl from a header containing PG_KEYWORD macros.
- */
-typedef struct ScanKeywordList
-{
-	const char *kw_string;		/* all keywords in order, separated by \0 */
-	const uint16 *kw_offsets;	/* offsets to the start of each keyword */
-	ScanKeywordHashFunc hash;	/* perfect hash function for keywords */
-	int			num_keywords;	/* number of keywords */
-	int			max_kw_len;		/* length of longest keyword */
-} ScanKeywordList;
-
-
-extern int	ScanKeywordLookup(const char *str, const ScanKeywordList *keywords);
-
-/* Code that wants to retrieve the text of the N'th keyword should use this. */
-static inline const char *
-GetScanKeyword(int n, const ScanKeywordList *keywords)
-{
-	return keywords->kw_string + keywords->kw_offsets[n];
-}
-
-#endif							/* KWLOOKUP_H */

data/ext/pg_query/include/common/pg_prng.h

@@ -1,61 +0,0 @@
-/*-------------------------------------------------------------------------
- *
- * Pseudo-Random Number Generator
- *
- * Copyright (c) 2021-2023, PostgreSQL Global Development Group
- *
- * src/include/common/pg_prng.h
- *
- *-------------------------------------------------------------------------
- */
-#ifndef PG_PRNG_H
-#define PG_PRNG_H
-
-/*
- * State vector for PRNG generation.  Callers should treat this as an
- * opaque typedef, but we expose its definition to allow it to be
- * embedded in other structs.
- */
-typedef struct pg_prng_state
-{
-	uint64		s0,
-				s1;
-} pg_prng_state;
-
-/*
- * Callers not needing local PRNG series may use this global state vector,
- * after initializing it with one of the pg_prng_...seed functions.
- */
-extern PGDLLIMPORT pg_prng_state pg_global_prng_state;
-
-extern void pg_prng_seed(pg_prng_state *state, uint64 seed);
-extern void pg_prng_fseed(pg_prng_state *state, double fseed);
-extern bool pg_prng_seed_check(pg_prng_state *state);
-
-/*
- * Initialize the PRNG state from the pg_strong_random source,
- * taking care that we don't produce all-zeroes.  If this returns false,
- * caller should initialize the PRNG state from some other random seed,
- * using pg_prng_[f]seed.
- *
- * We implement this as a macro, so that the pg_strong_random() call is
- * in the caller.  If it were in pg_prng.c, programs using pg_prng.c
- * but not needing strong seeding would nonetheless be forced to pull in
- * pg_strong_random.c and thence OpenSSL.
- */
-#define pg_prng_strong_seed(state) \
-	(pg_strong_random((void *) (state), sizeof(pg_prng_state)) ? \
-	 pg_prng_seed_check(state) : false)
-
-extern uint64 pg_prng_uint64(pg_prng_state *state);
-extern uint64 pg_prng_uint64_range(pg_prng_state *state, uint64 rmin, uint64 rmax);
-extern int64 pg_prng_int64(pg_prng_state *state);
-extern int64 pg_prng_int64p(pg_prng_state *state);
-extern uint32 pg_prng_uint32(pg_prng_state *state);
-extern int32 pg_prng_int32(pg_prng_state *state);
-extern int32 pg_prng_int32p(pg_prng_state *state);
-extern double pg_prng_double(pg_prng_state *state);
-extern double pg_prng_double_normal(pg_prng_state *state);
-extern bool pg_prng_bool(pg_prng_state *state);
-
-#endif							/* PG_PRNG_H */

data/ext/pg_query/include/common/relpath.h

@@ -1,97 +0,0 @@
-/*-------------------------------------------------------------------------
- *
- * relpath.h
- *		Declarations for GetRelationPath() and friends
- *
- * Portions Copyright (c) 1996-2023, PostgreSQL Global Development Group
- * Portions Copyright (c) 1994, Regents of the University of California
- *
- * src/include/common/relpath.h
- *
- *-------------------------------------------------------------------------
- */
-#ifndef RELPATH_H
-#define RELPATH_H
-
-/*
- *	'pgrminclude ignore' needed here because CppAsString2() does not throw
- *	an error if the symbol is not defined.
- */
-#include "catalog/catversion.h" /* pgrminclude ignore */
-
-/*
- * RelFileNumber data type identifies the specific relation file name.
- */
-typedef Oid RelFileNumber;
-#define InvalidRelFileNumber		((RelFileNumber) InvalidOid)
-#define RelFileNumberIsValid(relnumber) \
-				((bool) ((relnumber) != InvalidRelFileNumber))
-
-/*
- * Name of major-version-specific tablespace subdirectories
- */
-#define TABLESPACE_VERSION_DIRECTORY	"PG_" PG_MAJORVERSION "_" \
-									CppAsString2(CATALOG_VERSION_NO)
-
-/* Characters to allow for an OID in a relation path */
-#define OIDCHARS		10		/* max chars printed by %u */
-
-/*
- * Stuff for fork names.
- *
- * The physical storage of a relation consists of one or more forks.
- * The main fork is always created, but in addition to that there can be
- * additional forks for storing various metadata. ForkNumber is used when
- * we need to refer to a specific fork in a relation.
- */
-typedef enum ForkNumber
-{
-	InvalidForkNumber = -1,
-	MAIN_FORKNUM = 0,
-	FSM_FORKNUM,
-	VISIBILITYMAP_FORKNUM,
-	INIT_FORKNUM
-
-	/*
-	 * NOTE: if you add a new fork, change MAX_FORKNUM and possibly
-	 * FORKNAMECHARS below, and update the forkNames array in
-	 * src/common/relpath.c
-	 */
-} ForkNumber;
-
-#define MAX_FORKNUM		INIT_FORKNUM
-
-#define FORKNAMECHARS	4		/* max chars for a fork name */
-
-extern PGDLLIMPORT const char *const forkNames[];
-
-extern ForkNumber forkname_to_number(const char *forkName);
-extern int	forkname_chars(const char *str, ForkNumber *fork);
-
-/*
- * Stuff for computing filesystem pathnames for relations.
- */
-extern char *GetDatabasePath(Oid dbOid, Oid spcOid);
-
-extern char *GetRelationPath(Oid dbOid, Oid spcOid, RelFileNumber relNumber,
-							 int backendId, ForkNumber forkNumber);
-
-/*
- * Wrapper macros for GetRelationPath.  Beware of multiple
- * evaluation of the RelFileLocator or RelFileLocatorBackend argument!
- */
-
-/* First argument is a RelFileLocator */
-#define relpathbackend(rlocator, backend, forknum) \
-	GetRelationPath((rlocator).dbOid, (rlocator).spcOid, (rlocator).relNumber, \
-					backend, forknum)
-
-/* First argument is a RelFileLocator */
-#define relpathperm(rlocator, forknum) \
-	relpathbackend(rlocator, InvalidBackendId, forknum)
-
-/* First argument is a RelFileLocatorBackend */
-#define relpath(rlocator, forknum) \
-	relpathbackend((rlocator).locator, (rlocator).backend, forknum)
-
-#endif							/* RELPATH_H */