pg_query 2.2.0 → 6.1.0

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

@@ -1,168 +0,0 @@
-/*-------------------------------------------------------------------------
- *
- * fd.h
- *	  Virtual file descriptor definitions.
- *
- *
- * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group
- * Portions Copyright (c) 1994, Regents of the University of California
- *
- * src/include/storage/fd.h
- *
- *-------------------------------------------------------------------------
- */
-
-/*
- * calls:
- *
- *	File {Close, Read, Write, Size, Sync}
- *	{Path Name Open, Allocate, Free} File
- *
- * These are NOT JUST RENAMINGS OF THE UNIX ROUTINES.
- * Use them for all file activity...
- *
- *	File fd;
- *	fd = PathNameOpenFile("foo", O_RDONLY);
- *
- *	AllocateFile();
- *	FreeFile();
- *
- * Use AllocateFile, not fopen, if you need a stdio file (FILE*); then
- * use FreeFile, not fclose, to close it.  AVOID using stdio for files
- * that you intend to hold open for any length of time, since there is
- * no way for them to share kernel file descriptors with other files.
- *
- * Likewise, use AllocateDir/FreeDir, not opendir/closedir, to allocate
- * open directories (DIR*), and OpenTransientFile/CloseTransientFile for an
- * unbuffered file descriptor.
- *
- * If you really can't use any of the above, at least call AcquireExternalFD
- * or ReserveExternalFD to report any file descriptors that are held for any
- * length of time.  Failure to do so risks unnecessary EMFILE errors.
- */
-#ifndef FD_H
-#define FD_H
-
-#include <dirent.h>
-
-
-typedef int File;
-
-
-/* GUC parameter */
-extern PGDLLIMPORT int max_files_per_process;
-extern PGDLLIMPORT bool data_sync_retry;
-
-/*
- * This is private to fd.c, but exported for save/restore_backend_variables()
- */
-extern int	max_safe_fds;
-
-/*
- * On Windows, we have to interpret EACCES as possibly meaning the same as
- * ENOENT, because if a file is unlinked-but-not-yet-gone on that platform,
- * that's what you get.  Ugh.  This code is designed so that we don't
- * actually believe these cases are okay without further evidence (namely,
- * a pending fsync request getting canceled ... see ProcessSyncRequests).
- */
-#ifndef WIN32
-#define FILE_POSSIBLY_DELETED(err)	((err) == ENOENT)
-#else
-#define FILE_POSSIBLY_DELETED(err)	((err) == ENOENT || (err) == EACCES)
-#endif
-
-/*
- * prototypes for functions in fd.c
- */
-
-/* Operations on virtual Files --- equivalent to Unix kernel file ops */
-extern File PathNameOpenFile(const char *fileName, int fileFlags);
-extern File PathNameOpenFilePerm(const char *fileName, int fileFlags, mode_t fileMode);
-extern File OpenTemporaryFile(bool interXact);
-extern void FileClose(File file);
-extern int	FilePrefetch(File file, off_t offset, int amount, uint32 wait_event_info);
-extern int	FileRead(File file, char *buffer, int amount, off_t offset, uint32 wait_event_info);
-extern int	FileWrite(File file, char *buffer, int amount, off_t offset, uint32 wait_event_info);
-extern int	FileSync(File file, uint32 wait_event_info);
-extern off_t FileSize(File file);
-extern int	FileTruncate(File file, off_t offset, uint32 wait_event_info);
-extern void FileWriteback(File file, off_t offset, off_t nbytes, uint32 wait_event_info);
-extern char *FilePathName(File file);
-extern int	FileGetRawDesc(File file);
-extern int	FileGetRawFlags(File file);
-extern mode_t FileGetRawMode(File file);
-
-/* Operations used for sharing named temporary files */
-extern File PathNameCreateTemporaryFile(const char *name, bool error_on_failure);
-extern File PathNameOpenTemporaryFile(const char *name);
-extern bool PathNameDeleteTemporaryFile(const char *name, bool error_on_failure);
-extern void PathNameCreateTemporaryDir(const char *base, const char *name);
-extern void PathNameDeleteTemporaryDir(const char *name);
-extern void TempTablespacePath(char *path, Oid tablespace);
-
-/* Operations that allow use of regular stdio --- USE WITH CAUTION */
-extern FILE *AllocateFile(const char *name, const char *mode);
-extern int	FreeFile(FILE *file);
-
-/* Operations that allow use of pipe streams (popen/pclose) */
-extern FILE *OpenPipeStream(const char *command, const char *mode);
-extern int	ClosePipeStream(FILE *file);
-
-/* Operations to allow use of the <dirent.h> library routines */
-extern DIR *AllocateDir(const char *dirname);
-extern struct dirent *ReadDir(DIR *dir, const char *dirname);
-extern struct dirent *ReadDirExtended(DIR *dir, const char *dirname,
-									  int elevel);
-extern int	FreeDir(DIR *dir);
-
-/* Operations to allow use of a plain kernel FD, with automatic cleanup */
-extern int	OpenTransientFile(const char *fileName, int fileFlags);
-extern int	OpenTransientFilePerm(const char *fileName, int fileFlags, mode_t fileMode);
-extern int	CloseTransientFile(int fd);
-
-/* If you've really really gotta have a plain kernel FD, use this */
-extern int	BasicOpenFile(const char *fileName, int fileFlags);
-extern int	BasicOpenFilePerm(const char *fileName, int fileFlags, mode_t fileMode);
-
-/* Use these for other cases, and also for long-lived BasicOpenFile FDs */
-extern bool AcquireExternalFD(void);
-extern void ReserveExternalFD(void);
-extern void ReleaseExternalFD(void);
-
-/* Make a directory with default permissions */
-extern int	MakePGDirectory(const char *directoryName);
-
-/* Miscellaneous support routines */
-extern void InitFileAccess(void);
-extern void set_max_safe_fds(void);
-extern void closeAllVfds(void);
-extern void SetTempTablespaces(Oid *tableSpaces, int numSpaces);
-extern bool TempTablespacesAreSet(void);
-extern int	GetTempTablespaces(Oid *tableSpaces, int numSpaces);
-extern Oid	GetNextTempTableSpace(void);
-extern void AtEOXact_Files(bool isCommit);
-extern void AtEOSubXact_Files(bool isCommit, SubTransactionId mySubid,
-							  SubTransactionId parentSubid);
-extern void RemovePgTempFiles(void);
-extern void RemovePgTempFilesInDir(const char *tmpdirname, bool missing_ok,
-								   bool unlink_all);
-extern bool looks_like_temp_rel_name(const char *name);
-
-extern int	pg_fsync(int fd);
-extern int	pg_fsync_no_writethrough(int fd);
-extern int	pg_fsync_writethrough(int fd);
-extern int	pg_fdatasync(int fd);
-extern void pg_flush_data(int fd, off_t offset, off_t amount);
-extern void fsync_fname(const char *fname, bool isdir);
-extern int	fsync_fname_ext(const char *fname, bool isdir, bool ignore_perm, int elevel);
-extern int	durable_rename(const char *oldfile, const char *newfile, int loglevel);
-extern int	durable_unlink(const char *fname, int loglevel);
-extern int	durable_rename_excl(const char *oldfile, const char *newfile, int loglevel);
-extern void SyncDataDirectory(void);
-extern int	data_sync_elevel(int elevel);
-
-/* Filename components */
-#define PG_TEMP_FILES_DIR "pgsql_tmp"
-#define PG_TEMP_FILE_PREFIX "pgsql_tmp"
-
-#endif							/* FD_H */

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

@@ -1,81 +0,0 @@
-/*-------------------------------------------------------------------------
- *
- * ipc.h
- *	  POSTGRES inter-process communication definitions.
- *
- * This file is misnamed, as it no longer has much of anything directly
- * to do with IPC.  The functionality here is concerned with managing
- * exit-time cleanup for either a postmaster or a backend.
- *
- *
- * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group
- * Portions Copyright (c) 1994, Regents of the University of California
- *
- * src/include/storage/ipc.h
- *
- *-------------------------------------------------------------------------
- */
-#ifndef IPC_H
-#define IPC_H
-
-typedef void (*pg_on_exit_callback) (int code, Datum arg);
-typedef void (*shmem_startup_hook_type) (void);
-
-/*----------
- * API for handling cleanup that must occur during either ereport(ERROR)
- * or ereport(FATAL) exits from a block of code.  (Typical examples are
- * undoing transient changes to shared-memory state.)
- *
- *		PG_ENSURE_ERROR_CLEANUP(cleanup_function, arg);
- *		{
- *			... code that might throw ereport(ERROR) or ereport(FATAL) ...
- *		}
- *		PG_END_ENSURE_ERROR_CLEANUP(cleanup_function, arg);
- *
- * where the cleanup code is in a function declared per pg_on_exit_callback.
- * The Datum value "arg" can carry any information the cleanup function
- * needs.
- *
- * This construct ensures that cleanup_function() will be called during
- * either ERROR or FATAL exits.  It will not be called on successful
- * exit from the controlled code.  (If you want it to happen then too,
- * call the function yourself from just after the construct.)
- *
- * Note: the macro arguments are multiply evaluated, so avoid side-effects.
- *----------
- */
-#define PG_ENSURE_ERROR_CLEANUP(cleanup_function, arg)	\
-	do { \
-		before_shmem_exit(cleanup_function, arg); \
-		PG_TRY()
-
-#define PG_END_ENSURE_ERROR_CLEANUP(cleanup_function, arg)	\
-		cancel_before_shmem_exit(cleanup_function, arg); \
-		PG_CATCH(); \
-		{ \
-			cancel_before_shmem_exit(cleanup_function, arg); \
-			cleanup_function (0, arg); \
-			PG_RE_THROW(); \
-		} \
-		PG_END_TRY(); \
-	} while (0)
-
-
-/* ipc.c */
-extern PGDLLIMPORT __thread  bool proc_exit_inprogress;
-extern PGDLLIMPORT bool shmem_exit_inprogress;
-
-extern void proc_exit(int code) pg_attribute_noreturn();
-extern void shmem_exit(int code);
-extern void on_proc_exit(pg_on_exit_callback function, Datum arg);
-extern void on_shmem_exit(pg_on_exit_callback function, Datum arg);
-extern void before_shmem_exit(pg_on_exit_callback function, Datum arg);
-extern void cancel_before_shmem_exit(pg_on_exit_callback function, Datum arg);
-extern void on_exit_reset(void);
-
-/* ipci.c */
-extern PGDLLIMPORT shmem_startup_hook_type shmem_startup_hook;
-
-extern void CreateSharedMemoryAndSemaphores(void);
-
-#endif							/* IPC_H */

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

@@ -1,19 +0,0 @@
-/*-------------------------------------------------------------------------
- *
- * item.h
- *	  POSTGRES disk item definitions.
- *
- *
- * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group
- * Portions Copyright (c) 1994, Regents of the University of California
- *
- * src/include/storage/item.h
- *
- *-------------------------------------------------------------------------
- */
-#ifndef ITEM_H
-#define ITEM_H
-
-typedef Pointer Item;
-
-#endif							/* ITEM_H */

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

@@ -1,184 +0,0 @@
-/*-------------------------------------------------------------------------
- *
- * itemid.h
- *	  Standard POSTGRES buffer page item identifier/line pointer definitions.
- *
- *
- * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group
- * Portions Copyright (c) 1994, Regents of the University of California
- *
- * src/include/storage/itemid.h
- *
- *-------------------------------------------------------------------------
- */
-#ifndef ITEMID_H
-#define ITEMID_H
-
-/*
- * A line pointer on a buffer page.  See buffer page definitions and comments
- * for an explanation of how line pointers are used.
- *
- * In some cases a line pointer is "in use" but does not have any associated
- * storage on the page.  By convention, lp_len == 0 in every line pointer
- * that does not have storage, independently of its lp_flags state.
- */
-typedef struct ItemIdData
-{
-	unsigned	lp_off:15,		/* offset to tuple (from start of page) */
-				lp_flags:2,		/* state of line pointer, see below */
-				lp_len:15;		/* byte length of tuple */
-} ItemIdData;
-
-typedef ItemIdData *ItemId;
-
-/*
- * lp_flags has these possible states.  An UNUSED line pointer is available
- * for immediate re-use, the other states are not.
- */
-#define LP_UNUSED		0		/* unused (should always have lp_len=0) */
-#define LP_NORMAL		1		/* used (should always have lp_len>0) */
-#define LP_REDIRECT		2		/* HOT redirect (should have lp_len=0) */
-#define LP_DEAD			3		/* dead, may or may not have storage */
-
-/*
- * Item offsets and lengths are represented by these types when
- * they're not actually stored in an ItemIdData.
- */
-typedef uint16 ItemOffset;
-typedef uint16 ItemLength;
-
-
-/* ----------------
- *		support macros
- * ----------------
- */
-
-/*
- *		ItemIdGetLength
- */
-#define ItemIdGetLength(itemId) \
-   ((itemId)->lp_len)
-
-/*
- *		ItemIdGetOffset
- */
-#define ItemIdGetOffset(itemId) \
-   ((itemId)->lp_off)
-
-/*
- *		ItemIdGetFlags
- */
-#define ItemIdGetFlags(itemId) \
-   ((itemId)->lp_flags)
-
-/*
- *		ItemIdGetRedirect
- * In a REDIRECT pointer, lp_off holds offset number for next line pointer
- */
-#define ItemIdGetRedirect(itemId) \
-   ((itemId)->lp_off)
-
-/*
- * ItemIdIsValid
- *		True iff item identifier is valid.
- *		This is a pretty weak test, probably useful only in Asserts.
- */
-#define ItemIdIsValid(itemId)	PointerIsValid(itemId)
-
-/*
- * ItemIdIsUsed
- *		True iff item identifier is in use.
- */
-#define ItemIdIsUsed(itemId) \
-	((itemId)->lp_flags != LP_UNUSED)
-
-/*
- * ItemIdIsNormal
- *		True iff item identifier is in state NORMAL.
- */
-#define ItemIdIsNormal(itemId) \
-	((itemId)->lp_flags == LP_NORMAL)
-
-/*
- * ItemIdIsRedirected
- *		True iff item identifier is in state REDIRECT.
- */
-#define ItemIdIsRedirected(itemId) \
-	((itemId)->lp_flags == LP_REDIRECT)
-
-/*
- * ItemIdIsDead
- *		True iff item identifier is in state DEAD.
- */
-#define ItemIdIsDead(itemId) \
-	((itemId)->lp_flags == LP_DEAD)
-
-/*
- * ItemIdHasStorage
- *		True iff item identifier has associated storage.
- */
-#define ItemIdHasStorage(itemId) \
-	((itemId)->lp_len != 0)
-
-/*
- * ItemIdSetUnused
- *		Set the item identifier to be UNUSED, with no storage.
- *		Beware of multiple evaluations of itemId!
- */
-#define ItemIdSetUnused(itemId) \
-( \
-	(itemId)->lp_flags = LP_UNUSED, \
-	(itemId)->lp_off = 0, \
-	(itemId)->lp_len = 0 \
-)
-
-/*
- * ItemIdSetNormal
- *		Set the item identifier to be NORMAL, with the specified storage.
- *		Beware of multiple evaluations of itemId!
- */
-#define ItemIdSetNormal(itemId, off, len) \
-( \
-	(itemId)->lp_flags = LP_NORMAL, \
-	(itemId)->lp_off = (off), \
-	(itemId)->lp_len = (len) \
-)
-
-/*
- * ItemIdSetRedirect
- *		Set the item identifier to be REDIRECT, with the specified link.
- *		Beware of multiple evaluations of itemId!
- */
-#define ItemIdSetRedirect(itemId, link) \
-( \
-	(itemId)->lp_flags = LP_REDIRECT, \
-	(itemId)->lp_off = (link), \
-	(itemId)->lp_len = 0 \
-)
-
-/*
- * ItemIdSetDead
- *		Set the item identifier to be DEAD, with no storage.
- *		Beware of multiple evaluations of itemId!
- */
-#define ItemIdSetDead(itemId) \
-( \
-	(itemId)->lp_flags = LP_DEAD, \
-	(itemId)->lp_off = 0, \
-	(itemId)->lp_len = 0 \
-)
-
-/*
- * ItemIdMarkDead
- *		Set the item identifier to be DEAD, keeping its existing storage.
- *
- * Note: in indexes, this is used as if it were a hint-bit mechanism;
- * we trust that multiple processors can do this in parallel and get
- * the same result.
- */
-#define ItemIdMarkDead(itemId) \
-( \
-	(itemId)->lp_flags = LP_DEAD \
-)
-
-#endif							/* ITEMID_H */

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

@@ -1,206 +0,0 @@
-/*-------------------------------------------------------------------------
- *
- * itemptr.h
- *	  POSTGRES disk item pointer definitions.
- *
- *
- * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group
- * Portions Copyright (c) 1994, Regents of the University of California
- *
- * src/include/storage/itemptr.h
- *
- *-------------------------------------------------------------------------
- */
-#ifndef ITEMPTR_H
-#define ITEMPTR_H
-
-#include "storage/block.h"
-#include "storage/off.h"
-
-/*
- * ItemPointer:
- *
- * This is a pointer to an item within a disk page of a known file
- * (for example, a cross-link from an index to its parent table).
- * ip_blkid tells us which block, ip_posid tells us which entry in
- * the linp (ItemIdData) array we want.
- *
- * Note: because there is an item pointer in each tuple header and index
- * tuple header on disk, it's very important not to waste space with
- * structure padding bytes.  The struct is designed to be six bytes long
- * (it contains three int16 fields) but a few compilers will pad it to
- * eight bytes unless coerced.  We apply appropriate persuasion where
- * possible.  If your compiler can't be made to play along, you'll waste
- * lots of space.
- */
-typedef struct ItemPointerData
-{
-	BlockIdData ip_blkid;
-	OffsetNumber ip_posid;
-}
-
-/* If compiler understands packed and aligned pragmas, use those */
-#if defined(pg_attribute_packed) && defined(pg_attribute_aligned)
-			pg_attribute_packed()
-			pg_attribute_aligned(2)
-#endif
-ItemPointerData;
-
-typedef ItemPointerData *ItemPointer;
-
-/* ----------------
- *		special values used in heap tuples (t_ctid)
- * ----------------
- */
-
-/*
- * If a heap tuple holds a speculative insertion token rather than a real
- * TID, ip_posid is set to SpecTokenOffsetNumber, and the token is stored in
- * ip_blkid. SpecTokenOffsetNumber must be higher than MaxOffsetNumber, so
- * that it can be distinguished from a valid offset number in a regular item
- * pointer.
- */
-#define SpecTokenOffsetNumber		0xfffe
-
-/*
- * When a tuple is moved to a different partition by UPDATE, the t_ctid of
- * the old tuple version is set to this magic value.
- */
-#define MovedPartitionsOffsetNumber 0xfffd
-#define MovedPartitionsBlockNumber	InvalidBlockNumber
-
-
-/* ----------------
- *		support macros
- * ----------------
- */
-
-/*
- * ItemPointerIsValid
- *		True iff the disk item pointer is not NULL.
- */
-#define ItemPointerIsValid(pointer) \
-	((bool) (PointerIsValid(pointer) && ((pointer)->ip_posid != 0)))
-
-/*
- * ItemPointerGetBlockNumberNoCheck
- *		Returns the block number of a disk item pointer.
- */
-#define ItemPointerGetBlockNumberNoCheck(pointer) \
-( \
-	BlockIdGetBlockNumber(&(pointer)->ip_blkid) \
-)
-
-/*
- * ItemPointerGetBlockNumber
- *		As above, but verifies that the item pointer looks valid.
- */
-#define ItemPointerGetBlockNumber(pointer) \
-( \
-	AssertMacro(ItemPointerIsValid(pointer)), \
-	ItemPointerGetBlockNumberNoCheck(pointer) \
-)
-
-/*
- * ItemPointerGetOffsetNumberNoCheck
- *		Returns the offset number of a disk item pointer.
- */
-#define ItemPointerGetOffsetNumberNoCheck(pointer) \
-( \
-	(pointer)->ip_posid \
-)
-
-/*
- * ItemPointerGetOffsetNumber
- *		As above, but verifies that the item pointer looks valid.
- */
-#define ItemPointerGetOffsetNumber(pointer) \
-( \
-	AssertMacro(ItemPointerIsValid(pointer)), \
-	ItemPointerGetOffsetNumberNoCheck(pointer) \
-)
-
-/*
- * ItemPointerSet
- *		Sets a disk item pointer to the specified block and offset.
- */
-#define ItemPointerSet(pointer, blockNumber, offNum) \
-( \
-	AssertMacro(PointerIsValid(pointer)), \
-	BlockIdSet(&((pointer)->ip_blkid), blockNumber), \
-	(pointer)->ip_posid = offNum \
-)
-
-/*
- * ItemPointerSetBlockNumber
- *		Sets a disk item pointer to the specified block.
- */
-#define ItemPointerSetBlockNumber(pointer, blockNumber) \
-( \
-	AssertMacro(PointerIsValid(pointer)), \
-	BlockIdSet(&((pointer)->ip_blkid), blockNumber) \
-)
-
-/*
- * ItemPointerSetOffsetNumber
- *		Sets a disk item pointer to the specified offset.
- */
-#define ItemPointerSetOffsetNumber(pointer, offsetNumber) \
-( \
-	AssertMacro(PointerIsValid(pointer)), \
-	(pointer)->ip_posid = (offsetNumber) \
-)
-
-/*
- * ItemPointerCopy
- *		Copies the contents of one disk item pointer to another.
- *
- * Should there ever be padding in an ItemPointer this would need to be handled
- * differently as it's used as hash key.
- */
-#define ItemPointerCopy(fromPointer, toPointer) \
-( \
-	AssertMacro(PointerIsValid(toPointer)), \
-	AssertMacro(PointerIsValid(fromPointer)), \
-	*(toPointer) = *(fromPointer) \
-)
-
-/*
- * ItemPointerSetInvalid
- *		Sets a disk item pointer to be invalid.
- */
-#define ItemPointerSetInvalid(pointer) \
-( \
-	AssertMacro(PointerIsValid(pointer)), \
-	BlockIdSet(&((pointer)->ip_blkid), InvalidBlockNumber), \
-	(pointer)->ip_posid = InvalidOffsetNumber \
-)
-
-/*
- * ItemPointerIndicatesMovedPartitions
- *		True iff the block number indicates the tuple has moved to another
- *		partition.
- */
-#define ItemPointerIndicatesMovedPartitions(pointer) \
-( \
-	ItemPointerGetOffsetNumber(pointer) == MovedPartitionsOffsetNumber && \
-	ItemPointerGetBlockNumberNoCheck(pointer) == MovedPartitionsBlockNumber \
-)
-
-/*
- * ItemPointerSetMovedPartitions
- *		Indicate that the item referenced by the itempointer has moved into a
- *		different partition.
- */
-#define ItemPointerSetMovedPartitions(pointer) \
-	ItemPointerSet((pointer), MovedPartitionsBlockNumber, MovedPartitionsOffsetNumber)
-
-/* ----------------
- *		externs
- * ----------------
- */
-
-extern bool ItemPointerEquals(ItemPointer pointer1, ItemPointer pointer2);
-extern int32 ItemPointerCompare(ItemPointer arg1, ItemPointer arg2);
-
-#endif							/* ITEMPTR_H */