pg_query 4.2.1 → 6.1.0

data/ext/pg_query/include/access/tupmacs.h

@@ -1,247 +0,0 @@
-/*-------------------------------------------------------------------------
- *
- * tupmacs.h
- *	  Tuple macros used by both index tuples and heap tuples.
- *
- *
- * Portions Copyright (c) 1996-2022, PostgreSQL Global Development Group
- * Portions Copyright (c) 1994, Regents of the University of California
- *
- * src/include/access/tupmacs.h
- *
- *-------------------------------------------------------------------------
- */
-#ifndef TUPMACS_H
-#define TUPMACS_H
-
-#include "catalog/pg_type_d.h"	/* for TYPALIGN macros */
-
-
-/*
- * Check a tuple's null bitmap to determine whether the attribute is null.
- * Note that a 0 in the null bitmap indicates a null, while 1 indicates
- * non-null.
- */
-#define att_isnull(ATT, BITS) (!((BITS)[(ATT) >> 3] & (1 << ((ATT) & 0x07))))
-
-/*
- * Given a Form_pg_attribute and a pointer into a tuple's data area,
- * return the correct value or pointer.
- *
- * We return a Datum value in all cases.  If the attribute has "byval" false,
- * we return the same pointer into the tuple data area that we're passed.
- * Otherwise, we return the correct number of bytes fetched from the data
- * area and extended to Datum form.
- *
- * On machines where Datum is 8 bytes, we support fetching 8-byte byval
- * attributes; otherwise, only 1, 2, and 4-byte values are supported.
- *
- * Note that T must already be properly aligned for this to work correctly.
- */
-#define fetchatt(A,T) fetch_att(T, (A)->attbyval, (A)->attlen)
-
-/*
- * Same, but work from byval/len parameters rather than Form_pg_attribute.
- */
-#if SIZEOF_DATUM == 8
-
-#define fetch_att(T,attbyval,attlen) \
-( \
-	(attbyval) ? \
-	( \
-		(attlen) == (int) sizeof(Datum) ? \
-			*((Datum *)(T)) \
-		: \
-	  ( \
-		(attlen) == (int) sizeof(int32) ? \
-			Int32GetDatum(*((int32 *)(T))) \
-		: \
-		( \
-			(attlen) == (int) sizeof(int16) ? \
-				Int16GetDatum(*((int16 *)(T))) \
-			: \
-			( \
-				AssertMacro((attlen) == 1), \
-				CharGetDatum(*((char *)(T))) \
-			) \
-		) \
-	  ) \
-	) \
-	: \
-	PointerGetDatum((char *) (T)) \
-)
-#else							/* SIZEOF_DATUM != 8 */
-
-#define fetch_att(T,attbyval,attlen) \
-( \
-	(attbyval) ? \
-	( \
-		(attlen) == (int) sizeof(int32) ? \
-			Int32GetDatum(*((int32 *)(T))) \
-		: \
-		( \
-			(attlen) == (int) sizeof(int16) ? \
-				Int16GetDatum(*((int16 *)(T))) \
-			: \
-			( \
-				AssertMacro((attlen) == 1), \
-				CharGetDatum(*((char *)(T))) \
-			) \
-		) \
-	) \
-	: \
-	PointerGetDatum((char *) (T)) \
-)
-#endif							/* SIZEOF_DATUM == 8 */
-
-/*
- * att_align_datum aligns the given offset as needed for a datum of alignment
- * requirement attalign and typlen attlen.  attdatum is the Datum variable
- * we intend to pack into a tuple (it's only accessed if we are dealing with
- * a varlena type).  Note that this assumes the Datum will be stored as-is;
- * callers that are intending to convert non-short varlena datums to short
- * format have to account for that themselves.
- */
-#define att_align_datum(cur_offset, attalign, attlen, attdatum) \
-( \
-	((attlen) == -1 && VARATT_IS_SHORT(DatumGetPointer(attdatum))) ? \
-	(uintptr_t) (cur_offset) : \
-	att_align_nominal(cur_offset, attalign) \
-)
-
-/*
- * att_align_pointer performs the same calculation as att_align_datum,
- * but is used when walking a tuple.  attptr is the current actual data
- * pointer; when accessing a varlena field we have to "peek" to see if we
- * are looking at a pad byte or the first byte of a 1-byte-header datum.
- * (A zero byte must be either a pad byte, or the first byte of a correctly
- * aligned 4-byte length word; in either case we can align safely.  A non-zero
- * byte must be either a 1-byte length word, or the first byte of a correctly
- * aligned 4-byte length word; in either case we need not align.)
- *
- * Note: some callers pass a "char *" pointer for cur_offset.  This is
- * a bit of a hack but should work all right as long as uintptr_t is the
- * correct width.
- */
-#define att_align_pointer(cur_offset, attalign, attlen, attptr) \
-( \
-	((attlen) == -1 && VARATT_NOT_PAD_BYTE(attptr)) ? \
-	(uintptr_t) (cur_offset) : \
-	att_align_nominal(cur_offset, attalign) \
-)
-
-/*
- * att_align_nominal aligns the given offset as needed for a datum of alignment
- * requirement attalign, ignoring any consideration of packed varlena datums.
- * There are three main use cases for using this macro directly:
- *	* we know that the att in question is not varlena (attlen != -1);
- *	  in this case it is cheaper than the above macros and just as good.
- *	* we need to estimate alignment padding cost abstractly, ie without
- *	  reference to a real tuple.  We must assume the worst case that
- *	  all varlenas are aligned.
- *	* within arrays and multiranges, we unconditionally align varlenas (XXX this
- *	  should be revisited, probably).
- *
- * The attalign cases are tested in what is hopefully something like their
- * frequency of occurrence.
- */
-#define att_align_nominal(cur_offset, attalign) \
-( \
-	((attalign) == TYPALIGN_INT) ? INTALIGN(cur_offset) : \
-	 (((attalign) == TYPALIGN_CHAR) ? (uintptr_t) (cur_offset) : \
-	  (((attalign) == TYPALIGN_DOUBLE) ? DOUBLEALIGN(cur_offset) : \
-	   ( \
-			AssertMacro((attalign) == TYPALIGN_SHORT), \
-			SHORTALIGN(cur_offset) \
-	   ))) \
-)
-
-/*
- * att_addlength_datum increments the given offset by the space needed for
- * the given Datum variable.  attdatum is only accessed if we are dealing
- * with a variable-length attribute.
- */
-#define att_addlength_datum(cur_offset, attlen, attdatum) \
-	att_addlength_pointer(cur_offset, attlen, DatumGetPointer(attdatum))
-
-/*
- * att_addlength_pointer performs the same calculation as att_addlength_datum,
- * but is used when walking a tuple --- attptr is the pointer to the field
- * within the tuple.
- *
- * Note: some callers pass a "char *" pointer for cur_offset.  This is
- * actually perfectly OK, but probably should be cleaned up along with
- * the same practice for att_align_pointer.
- */
-#define att_addlength_pointer(cur_offset, attlen, attptr) \
-( \
-	((attlen) > 0) ? \
-	( \
-		(cur_offset) + (attlen) \
-	) \
-	: (((attlen) == -1) ? \
-	( \
-		(cur_offset) + VARSIZE_ANY(attptr) \
-	) \
-	: \
-	( \
-		AssertMacro((attlen) == -2), \
-		(cur_offset) + (strlen((char *) (attptr)) + 1) \
-	)) \
-)
-
-/*
- * store_att_byval is a partial inverse of fetch_att: store a given Datum
- * value into a tuple data area at the specified address.  However, it only
- * handles the byval case, because in typical usage the caller needs to
- * distinguish by-val and by-ref cases anyway, and so a do-it-all macro
- * wouldn't be convenient.
- */
-#if SIZEOF_DATUM == 8
-
-#define store_att_byval(T,newdatum,attlen) \
-	do { \
-		switch (attlen) \
-		{ \
-			case sizeof(char): \
-				*(char *) (T) = DatumGetChar(newdatum); \
-				break; \
-			case sizeof(int16): \
-				*(int16 *) (T) = DatumGetInt16(newdatum); \
-				break; \
-			case sizeof(int32): \
-				*(int32 *) (T) = DatumGetInt32(newdatum); \
-				break; \
-			case sizeof(Datum): \
-				*(Datum *) (T) = (newdatum); \
-				break; \
-			default: \
-				elog(ERROR, "unsupported byval length: %d", \
-					 (int) (attlen)); \
-				break; \
-		} \
-	} while (0)
-#else							/* SIZEOF_DATUM != 8 */
-
-#define store_att_byval(T,newdatum,attlen) \
-	do { \
-		switch (attlen) \
-		{ \
-			case sizeof(char): \
-				*(char *) (T) = DatumGetChar(newdatum); \
-				break; \
-			case sizeof(int16): \
-				*(int16 *) (T) = DatumGetInt16(newdatum); \
-				break; \
-			case sizeof(int32): \
-				*(int32 *) (T) = DatumGetInt32(newdatum); \
-				break; \
-			default: \
-				elog(ERROR, "unsupported byval length: %d", \
-					 (int) (attlen)); \
-				break; \
-		} \
-	} while (0)
-#endif							/* SIZEOF_DATUM == 8 */
-
-#endif

data/ext/pg_query/include/access/twophase.h

@@ -1,65 +0,0 @@
-/*-------------------------------------------------------------------------
- *
- * twophase.h
- *	  Two-phase-commit related declarations.
- *
- *
- * Portions Copyright (c) 1996-2022, PostgreSQL Global Development Group
- * Portions Copyright (c) 1994, Regents of the University of California
- *
- * src/include/access/twophase.h
- *
- *-------------------------------------------------------------------------
- */
-#ifndef TWOPHASE_H
-#define TWOPHASE_H
-
-#include "access/xact.h"
-#include "access/xlogdefs.h"
-#include "datatype/timestamp.h"
-#include "storage/lock.h"
-
-/*
- * GlobalTransactionData is defined in twophase.c; other places have no
- * business knowing the internal definition.
- */
-typedef struct GlobalTransactionData *GlobalTransaction;
-
-/* GUC variable */
-extern PGDLLIMPORT int max_prepared_xacts;
-
-extern Size TwoPhaseShmemSize(void);
-extern void TwoPhaseShmemInit(void);
-
-extern void AtAbort_Twophase(void);
-extern void PostPrepare_Twophase(void);
-
-extern TransactionId TwoPhaseGetXidByVirtualXID(VirtualTransactionId vxid,
-												bool *have_more);
-extern PGPROC *TwoPhaseGetDummyProc(TransactionId xid, bool lock_held);
-extern BackendId TwoPhaseGetDummyBackendId(TransactionId xid, bool lock_held);
-
-extern GlobalTransaction MarkAsPreparing(TransactionId xid, const char *gid,
-										 TimestampTz prepared_at,
-										 Oid owner, Oid databaseid);
-
-extern void StartPrepare(GlobalTransaction gxact);
-extern void EndPrepare(GlobalTransaction gxact);
-extern bool StandbyTransactionIdIsPrepared(TransactionId xid);
-
-extern TransactionId PrescanPreparedTransactions(TransactionId **xids_p,
-												 int *nxids_p);
-extern void StandbyRecoverPreparedTransactions(void);
-extern void RecoverPreparedTransactions(void);
-
-extern void CheckPointTwoPhase(XLogRecPtr redo_horizon);
-
-extern void FinishPreparedTransaction(const char *gid, bool isCommit);
-
-extern void PrepareRedoAdd(char *buf, XLogRecPtr start_lsn,
-						   XLogRecPtr end_lsn, RepOriginId origin_id);
-extern void PrepareRedoRemove(TransactionId xid, bool giveWarning);
-extern void restoreTwoPhaseData(void);
-extern bool LookupGXact(const char *gid, XLogRecPtr prepare_at_lsn,
-						TimestampTz origin_prepare_timestamp);
-#endif							/* TWOPHASE_H */