pg_query 4.2.3 → 5.0.0

data/ext/pg_query/include/storage/relfilenode.h

@@ -1,99 +0,0 @@
-/*-------------------------------------------------------------------------
- *
- * relfilenode.h
- *	  Physical access information for relations.
- *
- *
- * Portions Copyright (c) 1996-2022, PostgreSQL Global Development Group
- * Portions Copyright (c) 1994, Regents of the University of California
- *
- * src/include/storage/relfilenode.h
- *
- *-------------------------------------------------------------------------
- */
-#ifndef RELFILENODE_H
-#define RELFILENODE_H
-
-#include "common/relpath.h"
-#include "storage/backendid.h"
-
-/*
- * RelFileNode must provide all that we need to know to physically access
- * a relation, with the exception of the backend ID, which can be provided
- * separately. Note, however, that a "physical" relation is comprised of
- * multiple files on the filesystem, as each fork is stored as a separate
- * file, and each fork can be divided into multiple segments. See md.c.
- *
- * spcNode identifies the tablespace of the relation.  It corresponds to
- * pg_tablespace.oid.
- *
- * dbNode identifies the database of the relation.  It is zero for
- * "shared" relations (those common to all databases of a cluster).
- * Nonzero dbNode values correspond to pg_database.oid.
- *
- * relNode identifies the specific relation.  relNode corresponds to
- * pg_class.relfilenode (NOT pg_class.oid, because we need to be able
- * to assign new physical files to relations in some situations).
- * Notice that relNode is only unique within a database in a particular
- * tablespace.
- *
- * Note: spcNode must be GLOBALTABLESPACE_OID if and only if dbNode is
- * zero.  We support shared relations only in the "global" tablespace.
- *
- * Note: in pg_class we allow reltablespace == 0 to denote that the
- * relation is stored in its database's "default" tablespace (as
- * identified by pg_database.dattablespace).  However this shorthand
- * is NOT allowed in RelFileNode structs --- the real tablespace ID
- * must be supplied when setting spcNode.
- *
- * Note: in pg_class, relfilenode can be zero to denote that the relation
- * is a "mapped" relation, whose current true filenode number is available
- * from relmapper.c.  Again, this case is NOT allowed in RelFileNodes.
- *
- * Note: various places use RelFileNode in hashtable keys.  Therefore,
- * there *must not* be any unused padding bytes in this struct.  That
- * should be safe as long as all the fields are of type Oid.
- */
-typedef struct RelFileNode
-{
-	Oid			spcNode;		/* tablespace */
-	Oid			dbNode;			/* database */
-	Oid			relNode;		/* relation */
-} RelFileNode;
-
-/*
- * Augmenting a relfilenode with the backend ID provides all the information
- * we need to locate the physical storage.  The backend ID is InvalidBackendId
- * for regular relations (those accessible to more than one backend), or the
- * owning backend's ID for backend-local relations.  Backend-local relations
- * are always transient and removed in case of a database crash; they are
- * never WAL-logged or fsync'd.
- */
-typedef struct RelFileNodeBackend
-{
-	RelFileNode node;
-	BackendId	backend;
-} RelFileNodeBackend;
-
-#define RelFileNodeBackendIsTemp(rnode) \
-	((rnode).backend != InvalidBackendId)
-
-/*
- * Note: RelFileNodeEquals and RelFileNodeBackendEquals compare relNode first
- * since that is most likely to be different in two unequal RelFileNodes.  It
- * is probably redundant to compare spcNode if the other fields are found equal,
- * but do it anyway to be sure.  Likewise for checking the backend ID in
- * RelFileNodeBackendEquals.
- */
-#define RelFileNodeEquals(node1, node2) \
-	((node1).relNode == (node2).relNode && \
-	 (node1).dbNode == (node2).dbNode && \
-	 (node1).spcNode == (node2).spcNode)
-
-#define RelFileNodeBackendEquals(node1, node2) \
-	((node1).node.relNode == (node2).node.relNode && \
-	 (node1).node.dbNode == (node2).node.dbNode && \
-	 (node1).backend == (node2).backend && \
-	 (node1).node.spcNode == (node2).node.spcNode)
-
-#endif							/* RELFILENODE_H */

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

@@ -1,20 +0,0 @@
-/*-------------------------------------------------------------------------
- *
- * dynahash.h
- *	  POSTGRES dynahash.h file definitions
- *
- *
- * Portions Copyright (c) 1996-2022, PostgreSQL Global Development Group
- * Portions Copyright (c) 1994, Regents of the University of California
- *
- * IDENTIFICATION
- *		src/include/utils/dynahash.h
- *
- *-------------------------------------------------------------------------
- */
-#ifndef DYNAHASH_H
-#define DYNAHASH_H
-
-extern int	my_log2(long num);
-
-#endif							/* DYNAHASH_H */

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

@@ -1,29 +0,0 @@
-/*-------------------------------------------------------------------------
- *
- * pg_lsn.h
- *		Declarations for operations on log sequence numbers (LSNs) of
- *		PostgreSQL.
- *
- *
- * Portions Copyright (c) 1996-2022, PostgreSQL Global Development Group
- * Portions Copyright (c) 1994, Regents of the University of California
- *
- * src/include/utils/pg_lsn.h
- *
- *-------------------------------------------------------------------------
- */
-#ifndef PG_LSN_H
-#define PG_LSN_H
-
-#include "access/xlogdefs.h"
-#include "fmgr.h"
-
-#define DatumGetLSN(X) ((XLogRecPtr) DatumGetInt64(X))
-#define LSNGetDatum(X) (Int64GetDatum((int64) (X)))
-
-#define PG_GETARG_LSN(n)	 DatumGetLSN(PG_GETARG_DATUM(n))
-#define PG_RETURN_LSN(x)	 return LSNGetDatum(x)
-
-extern XLogRecPtr pg_lsn_in_internal(const char *str, bool *have_error);
-
-#endif							/* PG_LSN_H */

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

@@ -1,50 +0,0 @@
-/*-------------------------------------------------------------------------
- *
- * rls.h
- *	  Header file for Row Level Security (RLS) utility commands to be used
- *	  with the rowsecurity feature.
- *
- * Copyright (c) 2007-2022, PostgreSQL Global Development Group
- *
- * src/include/utils/rls.h
- *
- *-------------------------------------------------------------------------
- */
-#ifndef RLS_H
-#define RLS_H
-
-/* GUC variable */
-extern PGDLLIMPORT bool row_security;
-
-/*
- * Used by callers of check_enable_rls.
- *
- * RLS could be completely disabled on the tables involved in the query,
- * which is the simple case, or it may depend on the current environment
- * (the role which is running the query or the value of the row_security
- * GUC), or it might be simply enabled as usual.
- *
- * If RLS isn't on the table involved then RLS_NONE is returned to indicate
- * that we don't need to worry about invalidating the query plan for RLS
- * reasons.  If RLS is on the table, but we are bypassing it for now, then
- * we return RLS_NONE_ENV to indicate that, if the environment changes,
- * we need to invalidate and replan.  Finally, if RLS should be turned on
- * for the query, then we return RLS_ENABLED, which means we also need to
- * invalidate if the environment changes.
- *
- * Note that RLS_ENABLED will also be returned if noError is true
- * (indicating that the caller simply want to know if RLS should be applied
- * for this user but doesn't want an error thrown if it is; this is used
- * by other error cases where we're just trying to decide if data from the
- * table should be passed back to the user or not).
- */
-enum CheckEnableRlsResult
-{
-	RLS_NONE,
-	RLS_NONE_ENV,
-	RLS_ENABLED
-};
-
-extern int	check_enable_rls(Oid relid, Oid checkAsUser, bool noError);
-
-#endif							/* RLS_H */

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

@@ -1,39 +0,0 @@
-/*-------------------------------------------------------------------------
- *
- * tzparser.h
- *	  Timezone offset file parsing definitions.
- *
- * Portions Copyright (c) 1996-2022, PostgreSQL Global Development Group
- * Portions Copyright (c) 1994, Regents of the University of California
- *
- * src/include/utils/tzparser.h
- *
- *-------------------------------------------------------------------------
- */
-#ifndef TZPARSER_H
-#define TZPARSER_H
-
-#include "utils/datetime.h"
-
-/*
- * The result of parsing a timezone configuration file is an array of
- * these structs, in order by abbrev.  We export this because datetime.c
- * needs it.
- */
-typedef struct tzEntry
-{
-	/* the actual data */
-	char	   *abbrev;			/* TZ abbreviation (downcased) */
-	char	   *zone;			/* zone name if dynamic abbrev, else NULL */
-	/* for a dynamic abbreviation, offset/is_dst are not used */
-	int			offset;			/* offset in seconds from UTC */
-	bool		is_dst;			/* true if a DST abbreviation */
-	/* source information (for error messages) */
-	int			lineno;
-	const char *filename;
-} tzEntry;
-
-
-extern TimeZoneAbbrevTable *load_tzoffsets(const char *filename);
-
-#endif							/* TZPARSER_H */

data/ext/pg_query/src_backend_storage_lmgr_s_lock.c

@@ -1,371 +0,0 @@
-/*--------------------------------------------------------------------
- * Symbols referenced in this file:
- * - s_lock
- * - perform_spin_delay
- * - spins_per_delay
- * - s_lock_stuck
- * - finish_spin_delay
- *--------------------------------------------------------------------
- */
-
-/*-------------------------------------------------------------------------
- *
- * s_lock.c
- *	   Hardware-dependent implementation of spinlocks.
- *
- * When waiting for a contended spinlock we loop tightly for awhile, then
- * delay using pg_usleep() and try again.  Preferably, "awhile" should be a
- * small multiple of the maximum time we expect a spinlock to be held.  100
- * iterations seems about right as an initial guess.  However, on a
- * uniprocessor the loop is a waste of cycles, while in a multi-CPU scenario
- * it's usually better to spin a bit longer than to call the kernel, so we try
- * to adapt the spin loop count depending on whether we seem to be in a
- * uniprocessor or multiprocessor.
- *
- * Note: you might think MIN_SPINS_PER_DELAY should be just 1, but you'd
- * be wrong; there are platforms where that can result in a "stuck
- * spinlock" failure.  This has been seen particularly on Alphas; it seems
- * that the first TAS after returning from kernel space will always fail
- * on that hardware.
- *
- * Once we do decide to block, we use randomly increasing pg_usleep()
- * delays. The first delay is 1 msec, then the delay randomly increases to
- * about one second, after which we reset to 1 msec and start again.  The
- * idea here is that in the presence of heavy contention we need to
- * increase the delay, else the spinlock holder may never get to run and
- * release the lock.  (Consider situation where spinlock holder has been
- * nice'd down in priority by the scheduler --- it will not get scheduled
- * until all would-be acquirers are sleeping, so if we always use a 1-msec
- * sleep, there is a real possibility of starvation.)  But we can't just
- * clamp the delay to an upper bound, else it would take a long time to
- * make a reasonable number of tries.
- *
- * We time out and declare error after NUM_DELAYS delays (thus, exactly
- * that many tries).  With the given settings, this will usually take 2 or
- * so minutes.  It seems better to fix the total number of tries (and thus
- * the probability of unintended failure) than to fix the total time
- * spent.
- *
- * Portions Copyright (c) 1996-2022, PostgreSQL Global Development Group
- * Portions Copyright (c) 1994, Regents of the University of California
- *
- *
- * IDENTIFICATION
- *	  src/backend/storage/lmgr/s_lock.c
- *
- *-------------------------------------------------------------------------
- */
-#include "postgres.h"
-
-#include <time.h>
-#include <unistd.h>
-
-#include "common/pg_prng.h"
-#include "port/atomics.h"
-#include "storage/s_lock.h"
-
-#define MIN_SPINS_PER_DELAY 10
-#define MAX_SPINS_PER_DELAY 1000
-#define NUM_DELAYS			1000
-#define MIN_DELAY_USEC		1000L
-#define MAX_DELAY_USEC		1000000L
-
-
-
-
-static __thread int	spins_per_delay = DEFAULT_SPINS_PER_DELAY;
-
-
-
-/*
- * s_lock_stuck() - complain about a stuck spinlock
- */
-static void
-s_lock_stuck(const char *file, int line, const char *func)
-{
-	if (!func)
-		func = "(unknown)";
-#if defined(S_LOCK_TEST)
-	fprintf(stderr,
-			"\nStuck spinlock detected at %s, %s:%d.\n",
-			func, file, line);
-	exit(1);
-#else
-	elog(PANIC, "stuck spinlock detected at %s, %s:%d",
-		 func, file, line);
-#endif
-}
-
-/*
- * s_lock(lock) - platform-independent portion of waiting for a spinlock.
- */
-int
-s_lock(volatile slock_t *lock, const char *file, int line, const char *func)
-{
-	SpinDelayStatus delayStatus;
-
-	init_spin_delay(&delayStatus, file, line, func);
-
-	while (TAS_SPIN(lock))
-	{
-		perform_spin_delay(&delayStatus);
-	}
-
-	finish_spin_delay(&delayStatus);
-
-	return delayStatus.delays;
-}
-
-#ifdef USE_DEFAULT_S_UNLOCK
-void
-s_unlock(volatile slock_t *lock)
-{
-#ifdef TAS_ACTIVE_WORD
-	/* HP's PA-RISC */
-	*TAS_ACTIVE_WORD(lock) = -1;
-#else
-	*lock = 0;
-#endif
-}
-#endif
-
-/*
- * Wait while spinning on a contended spinlock.
- */
-void
-perform_spin_delay(SpinDelayStatus *status)
-{
-	/* CPU-specific delay each time through the loop */
-	SPIN_DELAY();
-
-	/* Block the process every spins_per_delay tries */
-	if (++(status->spins) >= spins_per_delay)
-	{
-		if (++(status->delays) > NUM_DELAYS)
-			s_lock_stuck(status->file, status->line, status->func);
-
-		if (status->cur_delay == 0) /* first time to delay? */
-			status->cur_delay = MIN_DELAY_USEC;
-
-		pg_usleep(status->cur_delay);
-
-#if defined(S_LOCK_TEST)
-		fprintf(stdout, "*");
-		fflush(stdout);
-#endif
-
-		/* increase delay by a random fraction between 1X and 2X */
-		status->cur_delay += (int) (status->cur_delay *
-									pg_prng_double(&pg_global_prng_state) + 0.5);
-		/* wrap back to minimum delay when max is exceeded */
-		if (status->cur_delay > MAX_DELAY_USEC)
-			status->cur_delay = MIN_DELAY_USEC;
-
-		status->spins = 0;
-	}
-}
-
-/*
- * After acquiring a spinlock, update estimates about how long to loop.
- *
- * If we were able to acquire the lock without delaying, it's a good
- * indication we are in a multiprocessor.  If we had to delay, it's a sign
- * (but not a sure thing) that we are in a uniprocessor. Hence, we
- * decrement spins_per_delay slowly when we had to delay, and increase it
- * rapidly when we didn't.  It's expected that spins_per_delay will
- * converge to the minimum value on a uniprocessor and to the maximum
- * value on a multiprocessor.
- *
- * Note: spins_per_delay is local within our current process. We want to
- * average these observations across multiple backends, since it's
- * relatively rare for this function to even get entered, and so a single
- * backend might not live long enough to converge on a good value.  That
- * is handled by the two routines below.
- */
-void
-finish_spin_delay(SpinDelayStatus *status)
-{
-	if (status->cur_delay == 0)
-	{
-		/* we never had to delay */
-		if (spins_per_delay < MAX_SPINS_PER_DELAY)
-			spins_per_delay = Min(spins_per_delay + 100, MAX_SPINS_PER_DELAY);
-	}
-	else
-	{
-		if (spins_per_delay > MIN_SPINS_PER_DELAY)
-			spins_per_delay = Max(spins_per_delay - 1, MIN_SPINS_PER_DELAY);
-	}
-}
-
-/*
- * Set local copy of spins_per_delay during backend startup.
- *
- * NB: this has to be pretty fast as it is called while holding a spinlock
- */
-
-
-/*
- * Update shared estimate of spins_per_delay during backend exit.
- *
- * NB: this has to be pretty fast as it is called while holding a spinlock
- */
-
-
-
-/*
- * Various TAS implementations that cannot live in s_lock.h as no inline
- * definition exists (yet).
- * In the future, get rid of tas.[cso] and fold it into this file.
- *
- * If you change something here, you will likely need to modify s_lock.h too,
- * because the definitions for these are split between this file and s_lock.h.
- */
-
-
-#ifdef HAVE_SPINLOCKS			/* skip spinlocks if requested */
-
-
-#if defined(__GNUC__)
-
-/*
- * All the gcc flavors that are not inlined
- */
-
-
-/*
- * Note: all the if-tests here probably ought to be testing gcc version
- * rather than platform, but I don't have adequate info to know what to
- * write.  Ideally we'd flush all this in favor of the inline version.
- */
-#if defined(__m68k__) && !defined(__linux__)
-/* really means: extern int tas(slock_t* **lock); */
-static void
-tas_dummy()
-{
-	__asm__ __volatile__(
-#if (defined(__NetBSD__) || defined(__OpenBSD__)) && defined(__ELF__)
-/* no underscore for label and % for registers */
-						 "\
-.global		tas 				\n\
-tas:							\n\
-			movel	%sp@(0x4),%a0	\n\
-			tas 	%a0@		\n\
-			beq 	_success	\n\
-			moveq	#-128,%d0	\n\
-			rts 				\n\
-_success:						\n\
-			moveq	#0,%d0		\n\
-			rts 				\n"
-#else
-						 "\
-.global		_tas				\n\
-_tas:							\n\
-			movel	sp@(0x4),a0	\n\
-			tas 	a0@			\n\
-			beq 	_success	\n\
-			moveq 	#-128,d0	\n\
-			rts					\n\
-_success:						\n\
-			moveq 	#0,d0		\n\
-			rts					\n"
-#endif							/* (__NetBSD__ || __OpenBSD__) && __ELF__ */
-		);
-}
-#endif							/* __m68k__ && !__linux__ */
-#endif							/* not __GNUC__ */
-#endif							/* HAVE_SPINLOCKS */
-
-
-
-/*****************************************************************************/
-#if defined(S_LOCK_TEST)
-
-/*
- * test program for verifying a port's spinlock support.
- */
-
-struct test_lock_struct
-{
-	char		pad1;
-	slock_t		lock;
-	char		pad2;
-};
-
-volatile struct test_lock_struct test_lock;
-
-int
-main()
-{
-	pg_prng_seed(&pg_global_prng_state, (uint64) time(NULL));
-
-	test_lock.pad1 = test_lock.pad2 = 0x44;
-
-	S_INIT_LOCK(&test_lock.lock);
-
-	if (test_lock.pad1 != 0x44 || test_lock.pad2 != 0x44)
-	{
-		printf("S_LOCK_TEST: failed, declared datatype is wrong size\n");
-		return 1;
-	}
-
-	if (!S_LOCK_FREE(&test_lock.lock))
-	{
-		printf("S_LOCK_TEST: failed, lock not initialized\n");
-		return 1;
-	}
-
-	S_LOCK(&test_lock.lock);
-
-	if (test_lock.pad1 != 0x44 || test_lock.pad2 != 0x44)
-	{
-		printf("S_LOCK_TEST: failed, declared datatype is wrong size\n");
-		return 1;
-	}
-
-	if (S_LOCK_FREE(&test_lock.lock))
-	{
-		printf("S_LOCK_TEST: failed, lock not locked\n");
-		return 1;
-	}
-
-	S_UNLOCK(&test_lock.lock);
-
-	if (test_lock.pad1 != 0x44 || test_lock.pad2 != 0x44)
-	{
-		printf("S_LOCK_TEST: failed, declared datatype is wrong size\n");
-		return 1;
-	}
-
-	if (!S_LOCK_FREE(&test_lock.lock))
-	{
-		printf("S_LOCK_TEST: failed, lock not unlocked\n");
-		return 1;
-	}
-
-	S_LOCK(&test_lock.lock);
-
-	if (test_lock.pad1 != 0x44 || test_lock.pad2 != 0x44)
-	{
-		printf("S_LOCK_TEST: failed, declared datatype is wrong size\n");
-		return 1;
-	}
-
-	if (S_LOCK_FREE(&test_lock.lock))
-	{
-		printf("S_LOCK_TEST: failed, lock not re-locked\n");
-		return 1;
-	}
-
-	printf("S_LOCK_TEST: this will print %d stars and then\n", NUM_DELAYS);
-	printf("             exit with a 'stuck spinlock' message\n");
-	printf("             if S_LOCK() and TAS() are working.\n");
-	fflush(stdout);
-
-	s_lock(&test_lock.lock, __FILE__, __LINE__, PG_FUNCNAME_MACRO);
-
-	printf("S_LOCK_TEST: failed, lock not locked\n");
-	return 1;
-}
-
-#endif							/* S_LOCK_TEST */