pg_query 4.2.3 → 5.1.0

data/ext/pg_query/include/{postgres.h → postgres/varatt.h}

@@ -1,56 +1,19 @@
 /*-------------------------------------------------------------------------
  *
- * postgres.h
- *	  Primary include file for PostgreSQL server .c files
+ * varatt.h
+ *	  variable-length datatypes (TOAST support)
  *
- * This should be the first file included by PostgreSQL backend modules.
- * Client-side code should include postgres_fe.h instead.
  *
- *
- * Portions Copyright (c) 1996-2022, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1996-2023, PostgreSQL Global Development Group
  * Portions Copyright (c) 1995, Regents of the University of California
  *
- * src/include/postgres.h
+ * src/include/varatt.h
  *
  *-------------------------------------------------------------------------
  */
-/*
- *----------------------------------------------------------------
- *	 TABLE OF CONTENTS
- *
- *		When adding stuff to this file, please try to put stuff
- *		into the relevant section, or add new sections as appropriate.
- *
- *	  section	description
- *	  -------	------------------------------------------------
- *		1)		variable-length datatypes (TOAST support)
- *		2)		Datum type + support macros
- *
- *	 NOTES
- *
- *	In general, this file should contain declarations that are widely needed
- *	in the backend environment, but are of no interest outside the backend.
- *
- *	Simple type definitions live in c.h, where they are shared with
- *	postgres_fe.h.  We do that since those type definitions are needed by
- *	frontend modules that want to deal with binary data transmission to or
- *	from the backend.  Type definitions in this file should be for
- *	representations that never escape the backend, such as Datum or
- *	TOASTed varlena objects.
- *
- *----------------------------------------------------------------
- */
-#ifndef POSTGRES_H
-#define POSTGRES_H
-
-#include "c.h"
-#include "utils/elog.h"
-#include "utils/palloc.h"
 
-/* ----------------------------------------------------------------
- *				Section 1:	variable-length datatypes (TOAST support)
- * ----------------------------------------------------------------
- */
+#ifndef VARATT_H
+#define VARATT_H
 
 /*
  * struct varatt_external is a traditional "TOAST pointer", that is, the
@@ -134,7 +97,7 @@ typedef enum vartag_external
 	((tag) == VARTAG_INDIRECT ? sizeof(varatt_indirect) : \
 	 VARTAG_IS_EXPANDED(tag) ? sizeof(varatt_expanded) : \
 	 (tag) == VARTAG_ONDISK ? sizeof(varatt_external) : \
-	 TrapMacro(true, "unrecognized TOAST vartag"))
+	 (AssertMacro(false), 0))
 
 /*
  * These structs describe the header of a varlena object that may have been
@@ -392,417 +355,4 @@ typedef struct
 	(VARATT_EXTERNAL_GET_EXTSIZE(toast_pointer) < \
 	 (toast_pointer).va_rawsize - VARHDRSZ)
 
-
-/* ----------------------------------------------------------------
- *				Section 2:	Datum type + support macros
- * ----------------------------------------------------------------
- */
-
-/*
- * A Datum contains either a value of a pass-by-value type or a pointer to a
- * value of a pass-by-reference type.  Therefore, we require:
- *
- * sizeof(Datum) == sizeof(void *) == 4 or 8
- *
- * The macros below and the analogous macros for other types should be used to
- * convert between a Datum and the appropriate C type.
- */
-
-typedef uintptr_t Datum;
-
-/*
- * A NullableDatum is used in places where both a Datum and its nullness needs
- * to be stored. This can be more efficient than storing datums and nullness
- * in separate arrays, due to better spatial locality, even if more space may
- * be wasted due to padding.
- */
-typedef struct NullableDatum
-{
-#define FIELDNO_NULLABLE_DATUM_DATUM 0
-	Datum		value;
-#define FIELDNO_NULLABLE_DATUM_ISNULL 1
-	bool		isnull;
-	/* due to alignment padding this could be used for flags for free */
-} NullableDatum;
-
-#define SIZEOF_DATUM SIZEOF_VOID_P
-
-/*
- * DatumGetBool
- *		Returns boolean value of a datum.
- *
- * Note: any nonzero value will be considered true.
- */
-
-#define DatumGetBool(X) ((bool) ((X) != 0))
-
-/*
- * BoolGetDatum
- *		Returns datum representation for a boolean.
- *
- * Note: any nonzero value will be considered true.
- */
-
-#define BoolGetDatum(X) ((Datum) ((X) ? 1 : 0))
-
-/*
- * DatumGetChar
- *		Returns character value of a datum.
- */
-
-#define DatumGetChar(X) ((char) (X))
-
-/*
- * CharGetDatum
- *		Returns datum representation for a character.
- */
-
-#define CharGetDatum(X) ((Datum) (X))
-
-/*
- * Int8GetDatum
- *		Returns datum representation for an 8-bit integer.
- */
-
-#define Int8GetDatum(X) ((Datum) (X))
-
-/*
- * DatumGetUInt8
- *		Returns 8-bit unsigned integer value of a datum.
- */
-
-#define DatumGetUInt8(X) ((uint8) (X))
-
-/*
- * UInt8GetDatum
- *		Returns datum representation for an 8-bit unsigned integer.
- */
-
-#define UInt8GetDatum(X) ((Datum) (X))
-
-/*
- * DatumGetInt16
- *		Returns 16-bit integer value of a datum.
- */
-
-#define DatumGetInt16(X) ((int16) (X))
-
-/*
- * Int16GetDatum
- *		Returns datum representation for a 16-bit integer.
- */
-
-#define Int16GetDatum(X) ((Datum) (X))
-
-/*
- * DatumGetUInt16
- *		Returns 16-bit unsigned integer value of a datum.
- */
-
-#define DatumGetUInt16(X) ((uint16) (X))
-
-/*
- * UInt16GetDatum
- *		Returns datum representation for a 16-bit unsigned integer.
- */
-
-#define UInt16GetDatum(X) ((Datum) (X))
-
-/*
- * DatumGetInt32
- *		Returns 32-bit integer value of a datum.
- */
-
-#define DatumGetInt32(X) ((int32) (X))
-
-/*
- * Int32GetDatum
- *		Returns datum representation for a 32-bit integer.
- */
-
-#define Int32GetDatum(X) ((Datum) (X))
-
-/*
- * DatumGetUInt32
- *		Returns 32-bit unsigned integer value of a datum.
- */
-
-#define DatumGetUInt32(X) ((uint32) (X))
-
-/*
- * UInt32GetDatum
- *		Returns datum representation for a 32-bit unsigned integer.
- */
-
-#define UInt32GetDatum(X) ((Datum) (X))
-
-/*
- * DatumGetObjectId
- *		Returns object identifier value of a datum.
- */
-
-#define DatumGetObjectId(X) ((Oid) (X))
-
-/*
- * ObjectIdGetDatum
- *		Returns datum representation for an object identifier.
- */
-
-#define ObjectIdGetDatum(X) ((Datum) (X))
-
-/*
- * DatumGetTransactionId
- *		Returns transaction identifier value of a datum.
- */
-
-#define DatumGetTransactionId(X) ((TransactionId) (X))
-
-/*
- * TransactionIdGetDatum
- *		Returns datum representation for a transaction identifier.
- */
-
-#define TransactionIdGetDatum(X) ((Datum) (X))
-
-/*
- * MultiXactIdGetDatum
- *		Returns datum representation for a multixact identifier.
- */
-
-#define MultiXactIdGetDatum(X) ((Datum) (X))
-
-/*
- * DatumGetCommandId
- *		Returns command identifier value of a datum.
- */
-
-#define DatumGetCommandId(X) ((CommandId) (X))
-
-/*
- * CommandIdGetDatum
- *		Returns datum representation for a command identifier.
- */
-
-#define CommandIdGetDatum(X) ((Datum) (X))
-
-/*
- * DatumGetPointer
- *		Returns pointer value of a datum.
- */
-
-#define DatumGetPointer(X) ((Pointer) (X))
-
-/*
- * PointerGetDatum
- *		Returns datum representation for a pointer.
- */
-
-#define PointerGetDatum(X) ((Datum) (X))
-
-/*
- * DatumGetCString
- *		Returns C string (null-terminated string) value of a datum.
- *
- * Note: C string is not a full-fledged Postgres type at present,
- * but type input functions use this conversion for their inputs.
- */
-
-#define DatumGetCString(X) ((char *) DatumGetPointer(X))
-
-/*
- * CStringGetDatum
- *		Returns datum representation for a C string (null-terminated string).
- *
- * Note: C string is not a full-fledged Postgres type at present,
- * but type output functions use this conversion for their outputs.
- * Note: CString is pass-by-reference; caller must ensure the pointed-to
- * value has adequate lifetime.
- */
-
-#define CStringGetDatum(X) PointerGetDatum(X)
-
-/*
- * DatumGetName
- *		Returns name value of a datum.
- */
-
-#define DatumGetName(X) ((Name) DatumGetPointer(X))
-
-/*
- * NameGetDatum
- *		Returns datum representation for a name.
- *
- * Note: Name is pass-by-reference; caller must ensure the pointed-to
- * value has adequate lifetime.
- */
-
-#define NameGetDatum(X) CStringGetDatum(NameStr(*(X)))
-
-/*
- * DatumGetInt64
- *		Returns 64-bit integer value of a datum.
- *
- * Note: this macro hides whether int64 is pass by value or by reference.
- */
-
-#ifdef USE_FLOAT8_BYVAL
-#define DatumGetInt64(X) ((int64) (X))
-#else
-#define DatumGetInt64(X) (* ((int64 *) DatumGetPointer(X)))
-#endif
-
-/*
- * Int64GetDatum
- *		Returns datum representation for a 64-bit integer.
- *
- * Note: if int64 is pass by reference, this function returns a reference
- * to palloc'd space.
- */
-
-#ifdef USE_FLOAT8_BYVAL
-#define Int64GetDatum(X) ((Datum) (X))
-#else
-extern Datum Int64GetDatum(int64 X);
-#endif
-
-/*
- * DatumGetUInt64
- *		Returns 64-bit unsigned integer value of a datum.
- *
- * Note: this macro hides whether int64 is pass by value or by reference.
- */
-
-#ifdef USE_FLOAT8_BYVAL
-#define DatumGetUInt64(X) ((uint64) (X))
-#else
-#define DatumGetUInt64(X) (* ((uint64 *) DatumGetPointer(X)))
 #endif
-
-/*
- * UInt64GetDatum
- *		Returns datum representation for a 64-bit unsigned integer.
- *
- * Note: if int64 is pass by reference, this function returns a reference
- * to palloc'd space.
- */
-
-#ifdef USE_FLOAT8_BYVAL
-#define UInt64GetDatum(X) ((Datum) (X))
-#else
-#define UInt64GetDatum(X) Int64GetDatum((int64) (X))
-#endif
-
-/*
- * Float <-> Datum conversions
- *
- * These have to be implemented as inline functions rather than macros, when
- * passing by value, because many machines pass int and float function
- * parameters/results differently; so we need to play weird games with unions.
- */
-
-/*
- * DatumGetFloat4
- *		Returns 4-byte floating point value of a datum.
- */
-static inline float4
-DatumGetFloat4(Datum X)
-{
-	union
-	{
-		int32		value;
-		float4		retval;
-	}			myunion;
-
-	myunion.value = DatumGetInt32(X);
-	return myunion.retval;
-}
-
-/*
- * Float4GetDatum
- *		Returns datum representation for a 4-byte floating point number.
- */
-static inline Datum
-Float4GetDatum(float4 X)
-{
-	union
-	{
-		float4		value;
-		int32		retval;
-	}			myunion;
-
-	myunion.value = X;
-	return Int32GetDatum(myunion.retval);
-}
-
-/*
- * DatumGetFloat8
- *		Returns 8-byte floating point value of a datum.
- *
- * Note: this macro hides whether float8 is pass by value or by reference.
- */
-
-#ifdef USE_FLOAT8_BYVAL
-static inline float8
-DatumGetFloat8(Datum X)
-{
-	union
-	{
-		int64		value;
-		float8		retval;
-	}			myunion;
-
-	myunion.value = DatumGetInt64(X);
-	return myunion.retval;
-}
-#else
-#define DatumGetFloat8(X) (* ((float8 *) DatumGetPointer(X)))
-#endif
-
-/*
- * Float8GetDatum
- *		Returns datum representation for an 8-byte floating point number.
- *
- * Note: if float8 is pass by reference, this function returns a reference
- * to palloc'd space.
- */
-
-#ifdef USE_FLOAT8_BYVAL
-static inline Datum
-Float8GetDatum(float8 X)
-{
-	union
-	{
-		float8		value;
-		int64		retval;
-	}			myunion;
-
-	myunion.value = X;
-	return Int64GetDatum(myunion.retval);
-}
-#else
-extern Datum Float8GetDatum(float8 X);
-#endif
-
-
-/*
- * Int64GetDatumFast
- * Float8GetDatumFast
- *
- * These macros are intended to allow writing code that does not depend on
- * whether int64 and float8 are pass-by-reference types, while not
- * sacrificing performance when they are.  The argument must be a variable
- * that will exist and have the same value for as long as the Datum is needed.
- * In the pass-by-ref case, the address of the variable is taken to use as
- * the Datum.  In the pass-by-val case, these will be the same as the non-Fast
- * macros.
- */
-
-#ifdef USE_FLOAT8_BYVAL
-#define Int64GetDatumFast(X)  Int64GetDatum(X)
-#define Float8GetDatumFast(X) Float8GetDatum(X)
-#else
-#define Int64GetDatumFast(X)  PointerGetDatum(&(X))
-#define Float8GetDatumFast(X) PointerGetDatum(&(X))
-#endif
-
-#endif							/* POSTGRES_H */