pg_query 2.2.0 → 6.1.0

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

@@ -1,100 +0,0 @@
-/*-------------------------------------------------------------------------
- *
- * large_object.h
- *	  Declarations for PostgreSQL large objects.  POSTGRES 4.2 supported
- *	  zillions of large objects (internal, external, jaquith, inversion).
- *	  Now we only support inversion.
- *
- * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group
- * Portions Copyright (c) 1994, Regents of the University of California
- *
- * src/include/storage/large_object.h
- *
- *-------------------------------------------------------------------------
- */
-#ifndef LARGE_OBJECT_H
-#define LARGE_OBJECT_H
-
-#include "utils/snapshot.h"
-
-
-/*----------
- * Data about a currently-open large object.
- *
- * id is the logical OID of the large object
- * snapshot is the snapshot to use for read/write operations
- * subid is the subtransaction that opened the desc (or currently owns it)
- * offset is the current seek offset within the LO
- * flags contains some flag bits
- *
- * NOTE: as of v11, permission checks are made when the large object is
- * opened; therefore IFS_RDLOCK/IFS_WRLOCK indicate that read or write mode
- * has been requested *and* the corresponding permission has been checked.
- *
- * NOTE: before 7.1, we also had to store references to the separate table
- * and index of a specific large object.  Now they all live in pg_largeobject
- * and are accessed via a common relation descriptor.
- *----------
- */
-typedef struct LargeObjectDesc
-{
-	Oid			id;				/* LO's identifier */
-	Snapshot	snapshot;		/* snapshot to use */
-	SubTransactionId subid;		/* owning subtransaction ID */
-	uint64		offset;			/* current seek pointer */
-	int			flags;			/* see flag bits below */
-
-/* bits in flags: */
-#define IFS_RDLOCK		(1 << 0)	/* LO was opened for reading */
-#define IFS_WRLOCK		(1 << 1)	/* LO was opened for writing */
-
-} LargeObjectDesc;
-
-
-/*
- * Each "page" (tuple) of a large object can hold this much data
- *
- * We could set this as high as BLCKSZ less some overhead, but it seems
- * better to make it a smaller value, so that not as much space is used
- * up when a page-tuple is updated.  Note that the value is deliberately
- * chosen large enough to trigger the tuple toaster, so that we will
- * attempt to compress page tuples in-line.  (But they won't be moved off
- * unless the user creates a toast-table for pg_largeobject...)
- *
- * Also, it seems to be a smart move to make the page size be a power of 2,
- * since clients will often be written to send data in power-of-2 blocks.
- * This avoids unnecessary tuple updates caused by partial-page writes.
- *
- * NB: Changing LOBLKSIZE requires an initdb.
- */
-#define LOBLKSIZE		(BLCKSZ / 4)
-
-/*
- * Maximum length in bytes for a large object.  To make this larger, we'd
- * have to widen pg_largeobject.pageno as well as various internal variables.
- */
-#define MAX_LARGE_OBJECT_SIZE	((int64) INT_MAX * LOBLKSIZE)
-
-
-/*
- * GUC: backwards-compatibility flag to suppress LO permission checks
- */
-extern bool lo_compat_privileges;
-
-/*
- * Function definitions...
- */
-
-/* inversion stuff in inv_api.c */
-extern void close_lo_relation(bool isCommit);
-extern Oid	inv_create(Oid lobjId);
-extern LargeObjectDesc *inv_open(Oid lobjId, int flags, MemoryContext mcxt);
-extern void inv_close(LargeObjectDesc *obj_desc);
-extern int	inv_drop(Oid lobjId);
-extern int64 inv_seek(LargeObjectDesc *obj_desc, int64 offset, int whence);
-extern int64 inv_tell(LargeObjectDesc *obj_desc);
-extern int	inv_read(LargeObjectDesc *obj_desc, char *buf, int nbytes);
-extern int	inv_write(LargeObjectDesc *obj_desc, const char *buf, int nbytes);
-extern void inv_truncate(LargeObjectDesc *obj_desc, int64 len);
-
-#endif							/* LARGE_OBJECT_H */

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

@@ -1,190 +0,0 @@
-/*-------------------------------------------------------------------------
- *
- * latch.h
- *	  Routines for interprocess latches
- *
- * A latch is a boolean variable, with operations that let processes sleep
- * until it is set. A latch can be set from another process, or a signal
- * handler within the same process.
- *
- * The latch interface is a reliable replacement for the common pattern of
- * using pg_usleep() or select() to wait until a signal arrives, where the
- * signal handler sets a flag variable. Because on some platforms an
- * incoming signal doesn't interrupt sleep, and even on platforms where it
- * does there is a race condition if the signal arrives just before
- * entering the sleep, the common pattern must periodically wake up and
- * poll the flag variable. The pselect() system call was invented to solve
- * this problem, but it is not portable enough. Latches are designed to
- * overcome these limitations, allowing you to sleep without polling and
- * ensuring quick response to signals from other processes.
- *
- * There are two kinds of latches: local and shared. A local latch is
- * initialized by InitLatch, and can only be set from the same process.
- * A local latch can be used to wait for a signal to arrive, by calling
- * SetLatch in the signal handler. A shared latch resides in shared memory,
- * and must be initialized at postmaster startup by InitSharedLatch. Before
- * a shared latch can be waited on, it must be associated with a process
- * with OwnLatch. Only the process owning the latch can wait on it, but any
- * process can set it.
- *
- * There are three basic operations on a latch:
- *
- * SetLatch		- Sets the latch
- * ResetLatch	- Clears the latch, allowing it to be set again
- * WaitLatch	- Waits for the latch to become set
- *
- * WaitLatch includes a provision for timeouts (which should be avoided
- * when possible, as they incur extra overhead) and a provision for
- * postmaster child processes to wake up immediately on postmaster death.
- * See latch.c for detailed specifications for the exported functions.
- *
- * The correct pattern to wait for event(s) is:
- *
- * for (;;)
- * {
- *	   ResetLatch();
- *	   if (work to do)
- *		   Do Stuff();
- *	   WaitLatch();
- * }
- *
- * It's important to reset the latch *before* checking if there's work to
- * do. Otherwise, if someone sets the latch between the check and the
- * ResetLatch call, you will miss it and Wait will incorrectly block.
- *
- * Another valid coding pattern looks like:
- *
- * for (;;)
- * {
- *	   if (work to do)
- *		   Do Stuff(); // in particular, exit loop if some condition satisfied
- *	   WaitLatch();
- *	   ResetLatch();
- * }
- *
- * This is useful to reduce latch traffic if it's expected that the loop's
- * termination condition will often be satisfied in the first iteration;
- * the cost is an extra loop iteration before blocking when it is not.
- * What must be avoided is placing any checks for asynchronous events after
- * WaitLatch and before ResetLatch, as that creates a race condition.
- *
- * To wake up the waiter, you must first set a global flag or something
- * else that the wait loop tests in the "if (work to do)" part, and call
- * SetLatch *after* that. SetLatch is designed to return quickly if the
- * latch is already set.
- *
- * On some platforms, signals will not interrupt the latch wait primitive
- * by themselves.  Therefore, it is critical that any signal handler that
- * is meant to terminate a WaitLatch wait calls SetLatch.
- *
- * Note that use of the process latch (PGPROC.procLatch) is generally better
- * than an ad-hoc shared latch for signaling auxiliary processes.  This is
- * because generic signal handlers will call SetLatch on the process latch
- * only, so using any latch other than the process latch effectively precludes
- * use of any generic handler.
- *
- *
- * WaitEventSets allow to wait for latches being set and additional events -
- * postmaster dying and socket readiness of several sockets currently - at the
- * same time.  On many platforms using a long lived event set is more
- * efficient than using WaitLatch or WaitLatchOrSocket.
- *
- *
- * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group
- * Portions Copyright (c) 1994, Regents of the University of California
- *
- * src/include/storage/latch.h
- *
- *-------------------------------------------------------------------------
- */
-#ifndef LATCH_H
-#define LATCH_H
-
-#include <signal.h>
-
-/*
- * Latch structure should be treated as opaque and only accessed through
- * the public functions. It is defined here to allow embedding Latches as
- * part of bigger structs.
- */
-typedef struct Latch
-{
-	sig_atomic_t is_set;
-	bool		is_shared;
-	int			owner_pid;
-#ifdef WIN32
-	HANDLE		event;
-#endif
-} Latch;
-
-/*
- * Bitmasks for events that may wake-up WaitLatch(), WaitLatchOrSocket(), or
- * WaitEventSetWait().
- */
-#define WL_LATCH_SET		 (1 << 0)
-#define WL_SOCKET_READABLE	 (1 << 1)
-#define WL_SOCKET_WRITEABLE  (1 << 2)
-#define WL_TIMEOUT			 (1 << 3)	/* not for WaitEventSetWait() */
-#define WL_POSTMASTER_DEATH  (1 << 4)
-#define WL_EXIT_ON_PM_DEATH	 (1 << 5)
-#ifdef WIN32
-#define WL_SOCKET_CONNECTED  (1 << 6)
-#else
-/* avoid having to deal with case on platforms not requiring it */
-#define WL_SOCKET_CONNECTED  WL_SOCKET_WRITEABLE
-#endif
-
-#define WL_SOCKET_MASK		(WL_SOCKET_READABLE | \
-							 WL_SOCKET_WRITEABLE | \
-							 WL_SOCKET_CONNECTED)
-
-typedef struct WaitEvent
-{
-	int			pos;			/* position in the event data structure */
-	uint32		events;			/* triggered events */
-	pgsocket	fd;				/* socket fd associated with event */
-	void	   *user_data;		/* pointer provided in AddWaitEventToSet */
-#ifdef WIN32
-	bool		reset;			/* Is reset of the event required? */
-#endif
-} WaitEvent;
-
-/* forward declaration to avoid exposing latch.c implementation details */
-typedef struct WaitEventSet WaitEventSet;
-
-/*
- * prototypes for functions in latch.c
- */
-extern void InitializeLatchSupport(void);
-extern void InitLatch(Latch *latch);
-extern void InitSharedLatch(Latch *latch);
-extern void OwnLatch(Latch *latch);
-extern void DisownLatch(Latch *latch);
-extern void SetLatch(Latch *latch);
-extern void ResetLatch(Latch *latch);
-
-extern WaitEventSet *CreateWaitEventSet(MemoryContext context, int nevents);
-extern void FreeWaitEventSet(WaitEventSet *set);
-extern int	AddWaitEventToSet(WaitEventSet *set, uint32 events, pgsocket fd,
-							  Latch *latch, void *user_data);
-extern void ModifyWaitEvent(WaitEventSet *set, int pos, uint32 events, Latch *latch);
-
-extern int	WaitEventSetWait(WaitEventSet *set, long timeout,
-							 WaitEvent *occurred_events, int nevents,
-							 uint32 wait_event_info);
-extern int	WaitLatch(Latch *latch, int wakeEvents, long timeout,
-					  uint32 wait_event_info);
-extern int	WaitLatchOrSocket(Latch *latch, int wakeEvents,
-							  pgsocket sock, long timeout, uint32 wait_event_info);
-
-/*
- * Unix implementation uses SIGUSR1 for inter-process signaling.
- * Win32 doesn't need this.
- */
-#ifndef WIN32
-extern void latch_sigusr1_handler(void);
-#else
-#define latch_sigusr1_handler()  ((void) 0)
-#endif
-
-#endif							/* LATCH_H */

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

@@ -1,114 +0,0 @@
-/*-------------------------------------------------------------------------
- *
- * lmgr.h
- *	  POSTGRES lock manager definitions.
- *
- *
- * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group
- * Portions Copyright (c) 1994, Regents of the University of California
- *
- * src/include/storage/lmgr.h
- *
- *-------------------------------------------------------------------------
- */
-#ifndef LMGR_H
-#define LMGR_H
-
-#include "lib/stringinfo.h"
-#include "storage/itemptr.h"
-#include "storage/lock.h"
-#include "utils/rel.h"
-
-
-/* XactLockTableWait operations */
-typedef enum XLTW_Oper
-{
-	XLTW_None,
-	XLTW_Update,
-	XLTW_Delete,
-	XLTW_Lock,
-	XLTW_LockUpdated,
-	XLTW_InsertIndex,
-	XLTW_InsertIndexUnique,
-	XLTW_FetchUpdated,
-	XLTW_RecheckExclusionConstr
-} XLTW_Oper;
-
-extern void RelationInitLockInfo(Relation relation);
-
-/* Lock a relation */
-extern void LockRelationOid(Oid relid, LOCKMODE lockmode);
-extern bool ConditionalLockRelationOid(Oid relid, LOCKMODE lockmode);
-extern void UnlockRelationId(LockRelId *relid, LOCKMODE lockmode);
-extern void UnlockRelationOid(Oid relid, LOCKMODE lockmode);
-
-extern void LockRelation(Relation relation, LOCKMODE lockmode);
-extern bool ConditionalLockRelation(Relation relation, LOCKMODE lockmode);
-extern void UnlockRelation(Relation relation, LOCKMODE lockmode);
-extern bool CheckRelationLockedByMe(Relation relation, LOCKMODE lockmode,
-									bool orstronger);
-extern bool LockHasWaitersRelation(Relation relation, LOCKMODE lockmode);
-
-extern void LockRelationIdForSession(LockRelId *relid, LOCKMODE lockmode);
-extern void UnlockRelationIdForSession(LockRelId *relid, LOCKMODE lockmode);
-
-/* Lock a relation for extension */
-extern void LockRelationForExtension(Relation relation, LOCKMODE lockmode);
-extern void UnlockRelationForExtension(Relation relation, LOCKMODE lockmode);
-extern bool ConditionalLockRelationForExtension(Relation relation,
-												LOCKMODE lockmode);
-extern int	RelationExtensionLockWaiterCount(Relation relation);
-
-/* Lock to recompute pg_database.datfrozenxid in the current database */
-extern void LockDatabaseFrozenIds(LOCKMODE lockmode);
-
-/* Lock a page (currently only used within indexes) */
-extern void LockPage(Relation relation, BlockNumber blkno, LOCKMODE lockmode);
-extern bool ConditionalLockPage(Relation relation, BlockNumber blkno, LOCKMODE lockmode);
-extern void UnlockPage(Relation relation, BlockNumber blkno, LOCKMODE lockmode);
-
-/* Lock a tuple (see heap_lock_tuple before assuming you understand this) */
-extern void LockTuple(Relation relation, ItemPointer tid, LOCKMODE lockmode);
-extern bool ConditionalLockTuple(Relation relation, ItemPointer tid,
-								 LOCKMODE lockmode);
-extern void UnlockTuple(Relation relation, ItemPointer tid, LOCKMODE lockmode);
-
-/* Lock an XID (used to wait for a transaction to finish) */
-extern void XactLockTableInsert(TransactionId xid);
-extern void XactLockTableDelete(TransactionId xid);
-extern void XactLockTableWait(TransactionId xid, Relation rel,
-							  ItemPointer ctid, XLTW_Oper oper);
-extern bool ConditionalXactLockTableWait(TransactionId xid);
-
-/* Lock VXIDs, specified by conflicting locktags */
-extern void WaitForLockers(LOCKTAG heaplocktag, LOCKMODE lockmode, bool progress);
-extern void WaitForLockersMultiple(List *locktags, LOCKMODE lockmode, bool progress);
-
-/* Lock an XID for tuple insertion (used to wait for an insertion to finish) */
-extern uint32 SpeculativeInsertionLockAcquire(TransactionId xid);
-extern void SpeculativeInsertionLockRelease(TransactionId xid);
-extern void SpeculativeInsertionWait(TransactionId xid, uint32 token);
-
-/* Lock a general object (other than a relation) of the current database */
-extern void LockDatabaseObject(Oid classid, Oid objid, uint16 objsubid,
-							   LOCKMODE lockmode);
-extern void UnlockDatabaseObject(Oid classid, Oid objid, uint16 objsubid,
-								 LOCKMODE lockmode);
-
-/* Lock a shared-across-databases object (other than a relation) */
-extern void LockSharedObject(Oid classid, Oid objid, uint16 objsubid,
-							 LOCKMODE lockmode);
-extern void UnlockSharedObject(Oid classid, Oid objid, uint16 objsubid,
-							   LOCKMODE lockmode);
-
-extern void LockSharedObjectForSession(Oid classid, Oid objid, uint16 objsubid,
-									   LOCKMODE lockmode);
-extern void UnlockSharedObjectForSession(Oid classid, Oid objid, uint16 objsubid,
-										 LOCKMODE lockmode);
-
-/* Describe a locktag for error messages */
-extern void DescribeLockTag(StringInfo buf, const LOCKTAG *tag);
-
-extern const char *GetLockNameFromTagType(uint16 locktag_type);
-
-#endif							/* LMGR_H */