From fba83e468a8ea881f0bdd6cf49aef13b71f67273 Mon Sep 17 00:00:00 2001 From: Peter Eisentraut Date: Wed, 28 Dec 2022 13:30:05 +0100 Subject: [PATCH] New header varatt.h split off from postgres.h This new header contains all the variable-length data types support (TOAST support) from postgres.h, which isn't needed by large parts of the backend code. This new header file is included by fmgr.h, so most data type and extension code won't need any changes. --- contrib/cube/cubedata.h | 2 + contrib/pg_trgm/trgm_regexp.c | 1 + src/backend/access/table/toast_helper.c | 1 + src/backend/libpq/pqformat.c | 1 + src/include/access/htup_details.h | 1 + src/include/fmgr.h | 2 + src/include/meson.build | 1 + src/include/postgres.h | 358 +-------------- src/include/utils/expandeddatum.h | 2 + src/include/{postgres.h => varatt.h} | 579 +----------------------- 10 files changed, 21 insertions(+), 927 deletions(-) copy src/include/{postgres.h => varatt.h} (53%) diff --git a/contrib/cube/cubedata.h b/contrib/cube/cubedata.h index 96fa41a04e..d8df478059 100644 --- a/contrib/cube/cubedata.h +++ b/contrib/cube/cubedata.h @@ -1,5 +1,7 @@ /* contrib/cube/cubedata.h */ +#include "fmgr.h" + /* * This limit is pretty arbitrary, but don't make it so large that you * risk overflow in sizing calculations. diff --git a/contrib/pg_trgm/trgm_regexp.c b/contrib/pg_trgm/trgm_regexp.c index 58d32ba946..08eecd269b 100644 --- a/contrib/pg_trgm/trgm_regexp.c +++ b/contrib/pg_trgm/trgm_regexp.c @@ -196,6 +196,7 @@ #include "tsearch/ts_locale.h" #include "utils/hsearch.h" #include "utils/memutils.h" +#include "varatt.h" /* * Uncomment (or use -DTRGM_REGEXP_DEBUG) to print debug info, diff --git a/src/backend/access/table/toast_helper.c b/src/backend/access/table/toast_helper.c index 74ba2189f0..a4889d7642 100644 --- a/src/backend/access/table/toast_helper.c +++ b/src/backend/access/table/toast_helper.c @@ -19,6 +19,7 @@ #include "access/toast_helper.h" #include "access/toast_internals.h" #include "catalog/pg_type_d.h" +#include "varatt.h" /* diff --git a/src/backend/libpq/pqformat.c b/src/backend/libpq/pqformat.c index 9c24df3360..65a913e893 100644 --- a/src/backend/libpq/pqformat.c +++ b/src/backend/libpq/pqformat.c @@ -77,6 +77,7 @@ #include "libpq/pqformat.h" #include "mb/pg_wchar.h" #include "port/pg_bswap.h" +#include "varatt.h" /* -------------------------------- diff --git a/src/include/access/htup_details.h b/src/include/access/htup_details.h index c1af814e8d..c7b505e33f 100644 --- a/src/include/access/htup_details.h +++ b/src/include/access/htup_details.h @@ -19,6 +19,7 @@ #include "access/tupdesc.h" #include "access/tupmacs.h" #include "storage/bufpage.h" +#include "varatt.h" /* * MaxTupleAttributeNumber limits the number of (user) columns in a tuple. diff --git a/src/include/fmgr.h b/src/include/fmgr.h index 972afe3aff..0ce0090360 100644 --- a/src/include/fmgr.h +++ b/src/include/fmgr.h @@ -18,6 +18,8 @@ #ifndef FMGR_H #define FMGR_H +#include "varatt.h" + /* We don't want to include primnodes.h here, so make some stub references */ typedef struct Node *fmNodePtr; typedef struct Aggref *fmAggrefPtr; diff --git a/src/include/meson.build b/src/include/meson.build index b4820049c8..63b444bc99 100644 --- a/src/include/meson.build +++ b/src/include/meson.build @@ -113,6 +113,7 @@ install_headers( 'postgres.h', 'postgres_ext.h', 'postgres_fe.h', + 'varatt.h', 'windowapi.h', pg_config_ext, pg_config_os, diff --git a/src/include/postgres.h b/src/include/postgres.h index 54730dfb38..a915f2b97f 100644 --- a/src/include/postgres.h +++ b/src/include/postgres.h @@ -23,9 +23,8 @@ * * section description * ------- ------------------------------------------------ - * 1) variable-length datatypes (TOAST support) - * 2) Datum type + support functions - * 3) miscellaneous + * 1) Datum type + support functions + * 2) miscellaneous * * NOTES * @@ -36,8 +35,7 @@ * 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. + * representations that never escape the backend, such as Datum. * *---------------------------------------------------------------- */ @@ -49,353 +47,7 @@ #include "utils/palloc.h" /* ---------------------------------------------------------------- - * Section 1: variable-length datatypes (TOAST support) - * ---------------------------------------------------------------- - */ - -/* - * struct varatt_external is a traditional "TOAST pointer", that is, the - * information needed to fetch a Datum stored out-of-line in a TOAST table. - * The data is compressed if and only if the external size stored in - * va_extinfo is less than va_rawsize - VARHDRSZ. - * - * This struct must not contain any padding, because we sometimes compare - * these pointers using memcmp. - * - * Note that this information is stored unaligned within actual tuples, so - * you need to memcpy from the tuple into a local struct variable before - * you can look at these fields! (The reason we use memcmp is to avoid - * having to do that just to detect equality of two TOAST pointers...) - */ -typedef struct varatt_external -{ - int32 va_rawsize; /* Original data size (includes header) */ - uint32 va_extinfo; /* External saved size (without header) and - * compression method */ - Oid va_valueid; /* Unique ID of value within TOAST table */ - Oid va_toastrelid; /* RelID of TOAST table containing it */ -} varatt_external; - -/* - * These macros define the "saved size" portion of va_extinfo. Its remaining - * two high-order bits identify the compression method. - */ -#define VARLENA_EXTSIZE_BITS 30 -#define VARLENA_EXTSIZE_MASK ((1U << VARLENA_EXTSIZE_BITS) - 1) - -/* - * struct varatt_indirect is a "TOAST pointer" representing an out-of-line - * Datum that's stored in memory, not in an external toast relation. - * The creator of such a Datum is entirely responsible that the referenced - * storage survives for as long as referencing pointer Datums can exist. - * - * Note that just as for struct varatt_external, this struct is stored - * unaligned within any containing tuple. - */ -typedef struct varatt_indirect -{ - struct varlena *pointer; /* Pointer to in-memory varlena */ -} varatt_indirect; - -/* - * struct varatt_expanded is a "TOAST pointer" representing an out-of-line - * Datum that is stored in memory, in some type-specific, not necessarily - * physically contiguous format that is convenient for computation not - * storage. APIs for this, in particular the definition of struct - * ExpandedObjectHeader, are in src/include/utils/expandeddatum.h. - * - * Note that just as for struct varatt_external, this struct is stored - * unaligned within any containing tuple. - */ -typedef struct ExpandedObjectHeader ExpandedObjectHeader; - -typedef struct varatt_expanded -{ - ExpandedObjectHeader *eohptr; -} varatt_expanded; - -/* - * Type tag for the various sorts of "TOAST pointer" datums. The peculiar - * value for VARTAG_ONDISK comes from a requirement for on-disk compatibility - * with a previous notion that the tag field was the pointer datum's length. - */ -typedef enum vartag_external -{ - VARTAG_INDIRECT = 1, - VARTAG_EXPANDED_RO = 2, - VARTAG_EXPANDED_RW = 3, - VARTAG_ONDISK = 18 -} vartag_external; - -/* this test relies on the specific tag values above */ -#define VARTAG_IS_EXPANDED(tag) \ - (((tag) & ~1) == VARTAG_EXPANDED_RO) - -#define VARTAG_SIZE(tag) \ - ((tag) == VARTAG_INDIRECT ? sizeof(varatt_indirect) : \ - VARTAG_IS_EXPANDED(tag) ? sizeof(varatt_expanded) : \ - (tag) == VARTAG_ONDISK ? sizeof(varatt_external) : \ - (AssertMacro(false), 0)) - -/* - * These structs describe the header of a varlena object that may have been - * TOASTed. Generally, don't reference these structs directly, but use the - * macros below. - * - * We use separate structs for the aligned and unaligned cases because the - * compiler might otherwise think it could generate code that assumes - * alignment while touching fields of a 1-byte-header varlena. - */ -typedef union -{ - struct /* Normal varlena (4-byte length) */ - { - uint32 va_header; - char va_data[FLEXIBLE_ARRAY_MEMBER]; - } va_4byte; - struct /* Compressed-in-line format */ - { - uint32 va_header; - uint32 va_tcinfo; /* Original data size (excludes header) and - * compression method; see va_extinfo */ - char va_data[FLEXIBLE_ARRAY_MEMBER]; /* Compressed data */ - } va_compressed; -} varattrib_4b; - -typedef struct -{ - uint8 va_header; - char va_data[FLEXIBLE_ARRAY_MEMBER]; /* Data begins here */ -} varattrib_1b; - -/* TOAST pointers are a subset of varattrib_1b with an identifying tag byte */ -typedef struct -{ - uint8 va_header; /* Always 0x80 or 0x01 */ - uint8 va_tag; /* Type of datum */ - char va_data[FLEXIBLE_ARRAY_MEMBER]; /* Type-specific data */ -} varattrib_1b_e; - -/* - * Bit layouts for varlena headers on big-endian machines: - * - * 00xxxxxx 4-byte length word, aligned, uncompressed data (up to 1G) - * 01xxxxxx 4-byte length word, aligned, *compressed* data (up to 1G) - * 10000000 1-byte length word, unaligned, TOAST pointer - * 1xxxxxxx 1-byte length word, unaligned, uncompressed data (up to 126b) - * - * Bit layouts for varlena headers on little-endian machines: - * - * xxxxxx00 4-byte length word, aligned, uncompressed data (up to 1G) - * xxxxxx10 4-byte length word, aligned, *compressed* data (up to 1G) - * 00000001 1-byte length word, unaligned, TOAST pointer - * xxxxxxx1 1-byte length word, unaligned, uncompressed data (up to 126b) - * - * The "xxx" bits are the length field (which includes itself in all cases). - * In the big-endian case we mask to extract the length, in the little-endian - * case we shift. Note that in both cases the flag bits are in the physically - * first byte. Also, it is not possible for a 1-byte length word to be zero; - * this lets us disambiguate alignment padding bytes from the start of an - * unaligned datum. (We now *require* pad bytes to be filled with zero!) - * - * In TOAST pointers the va_tag field (see varattrib_1b_e) is used to discern - * the specific type and length of the pointer datum. - */ - -/* - * Endian-dependent macros. These are considered internal --- use the - * external macros below instead of using these directly. - * - * Note: IS_1B is true for external toast records but VARSIZE_1B will return 0 - * for such records. Hence you should usually check for IS_EXTERNAL before - * checking for IS_1B. - */ - -#ifdef WORDS_BIGENDIAN - -#define VARATT_IS_4B(PTR) \ - ((((varattrib_1b *) (PTR))->va_header & 0x80) == 0x00) -#define VARATT_IS_4B_U(PTR) \ - ((((varattrib_1b *) (PTR))->va_header & 0xC0) == 0x00) -#define VARATT_IS_4B_C(PTR) \ - ((((varattrib_1b *) (PTR))->va_header & 0xC0) == 0x40) -#define VARATT_IS_1B(PTR) \ - ((((varattrib_1b *) (PTR))->va_header & 0x80) == 0x80) -#define VARATT_IS_1B_E(PTR) \ - ((((varattrib_1b *) (PTR))->va_header) == 0x80) -#define VARATT_NOT_PAD_BYTE(PTR) \ - (*((uint8 *) (PTR)) != 0) - -/* VARSIZE_4B() should only be used on known-aligned data */ -#define VARSIZE_4B(PTR) \ - (((varattrib_4b *) (PTR))->va_4byte.va_header & 0x3FFFFFFF) -#define VARSIZE_1B(PTR) \ - (((varattrib_1b *) (PTR))->va_header & 0x7F) -#define VARTAG_1B_E(PTR) \ - (((varattrib_1b_e *) (PTR))->va_tag) - -#define SET_VARSIZE_4B(PTR,len) \ - (((varattrib_4b *) (PTR))->va_4byte.va_header = (len) & 0x3FFFFFFF) -#define SET_VARSIZE_4B_C(PTR,len) \ - (((varattrib_4b *) (PTR))->va_4byte.va_header = ((len) & 0x3FFFFFFF) | 0x40000000) -#define SET_VARSIZE_1B(PTR,len) \ - (((varattrib_1b *) (PTR))->va_header = (len) | 0x80) -#define SET_VARTAG_1B_E(PTR,tag) \ - (((varattrib_1b_e *) (PTR))->va_header = 0x80, \ - ((varattrib_1b_e *) (PTR))->va_tag = (tag)) - -#else /* !WORDS_BIGENDIAN */ - -#define VARATT_IS_4B(PTR) \ - ((((varattrib_1b *) (PTR))->va_header & 0x01) == 0x00) -#define VARATT_IS_4B_U(PTR) \ - ((((varattrib_1b *) (PTR))->va_header & 0x03) == 0x00) -#define VARATT_IS_4B_C(PTR) \ - ((((varattrib_1b *) (PTR))->va_header & 0x03) == 0x02) -#define VARATT_IS_1B(PTR) \ - ((((varattrib_1b *) (PTR))->va_header & 0x01) == 0x01) -#define VARATT_IS_1B_E(PTR) \ - ((((varattrib_1b *) (PTR))->va_header) == 0x01) -#define VARATT_NOT_PAD_BYTE(PTR) \ - (*((uint8 *) (PTR)) != 0) - -/* VARSIZE_4B() should only be used on known-aligned data */ -#define VARSIZE_4B(PTR) \ - ((((varattrib_4b *) (PTR))->va_4byte.va_header >> 2) & 0x3FFFFFFF) -#define VARSIZE_1B(PTR) \ - ((((varattrib_1b *) (PTR))->va_header >> 1) & 0x7F) -#define VARTAG_1B_E(PTR) \ - (((varattrib_1b_e *) (PTR))->va_tag) - -#define SET_VARSIZE_4B(PTR,len) \ - (((varattrib_4b *) (PTR))->va_4byte.va_header = (((uint32) (len)) << 2)) -#define SET_VARSIZE_4B_C(PTR,len) \ - (((varattrib_4b *) (PTR))->va_4byte.va_header = (((uint32) (len)) << 2) | 0x02) -#define SET_VARSIZE_1B(PTR,len) \ - (((varattrib_1b *) (PTR))->va_header = (((uint8) (len)) << 1) | 0x01) -#define SET_VARTAG_1B_E(PTR,tag) \ - (((varattrib_1b_e *) (PTR))->va_header = 0x01, \ - ((varattrib_1b_e *) (PTR))->va_tag = (tag)) - -#endif /* WORDS_BIGENDIAN */ - -#define VARDATA_4B(PTR) (((varattrib_4b *) (PTR))->va_4byte.va_data) -#define VARDATA_4B_C(PTR) (((varattrib_4b *) (PTR))->va_compressed.va_data) -#define VARDATA_1B(PTR) (((varattrib_1b *) (PTR))->va_data) -#define VARDATA_1B_E(PTR) (((varattrib_1b_e *) (PTR))->va_data) - -/* - * Externally visible TOAST macros begin here. - */ - -#define VARHDRSZ_EXTERNAL offsetof(varattrib_1b_e, va_data) -#define VARHDRSZ_COMPRESSED offsetof(varattrib_4b, va_compressed.va_data) -#define VARHDRSZ_SHORT offsetof(varattrib_1b, va_data) - -#define VARATT_SHORT_MAX 0x7F -#define VARATT_CAN_MAKE_SHORT(PTR) \ - (VARATT_IS_4B_U(PTR) && \ - (VARSIZE(PTR) - VARHDRSZ + VARHDRSZ_SHORT) <= VARATT_SHORT_MAX) -#define VARATT_CONVERTED_SHORT_SIZE(PTR) \ - (VARSIZE(PTR) - VARHDRSZ + VARHDRSZ_SHORT) - -/* - * In consumers oblivious to data alignment, call PG_DETOAST_DATUM_PACKED(), - * VARDATA_ANY(), VARSIZE_ANY() and VARSIZE_ANY_EXHDR(). Elsewhere, call - * PG_DETOAST_DATUM(), VARDATA() and VARSIZE(). Directly fetching an int16, - * int32 or wider field in the struct representing the datum layout requires - * aligned data. memcpy() is alignment-oblivious, as are most operations on - * datatypes, such as text, whose layout struct contains only char fields. - * - * Code assembling a new datum should call VARDATA() and SET_VARSIZE(). - * (Datums begin life untoasted.) - * - * Other macros here should usually be used only by tuple assembly/disassembly - * code and code that specifically wants to work with still-toasted Datums. - */ -#define VARDATA(PTR) VARDATA_4B(PTR) -#define VARSIZE(PTR) VARSIZE_4B(PTR) - -#define VARSIZE_SHORT(PTR) VARSIZE_1B(PTR) -#define VARDATA_SHORT(PTR) VARDATA_1B(PTR) - -#define VARTAG_EXTERNAL(PTR) VARTAG_1B_E(PTR) -#define VARSIZE_EXTERNAL(PTR) (VARHDRSZ_EXTERNAL + VARTAG_SIZE(VARTAG_EXTERNAL(PTR))) -#define VARDATA_EXTERNAL(PTR) VARDATA_1B_E(PTR) - -#define VARATT_IS_COMPRESSED(PTR) VARATT_IS_4B_C(PTR) -#define VARATT_IS_EXTERNAL(PTR) VARATT_IS_1B_E(PTR) -#define VARATT_IS_EXTERNAL_ONDISK(PTR) \ - (VARATT_IS_EXTERNAL(PTR) && VARTAG_EXTERNAL(PTR) == VARTAG_ONDISK) -#define VARATT_IS_EXTERNAL_INDIRECT(PTR) \ - (VARATT_IS_EXTERNAL(PTR) && VARTAG_EXTERNAL(PTR) == VARTAG_INDIRECT) -#define VARATT_IS_EXTERNAL_EXPANDED_RO(PTR) \ - (VARATT_IS_EXTERNAL(PTR) && VARTAG_EXTERNAL(PTR) == VARTAG_EXPANDED_RO) -#define VARATT_IS_EXTERNAL_EXPANDED_RW(PTR) \ - (VARATT_IS_EXTERNAL(PTR) && VARTAG_EXTERNAL(PTR) == VARTAG_EXPANDED_RW) -#define VARATT_IS_EXTERNAL_EXPANDED(PTR) \ - (VARATT_IS_EXTERNAL(PTR) && VARTAG_IS_EXPANDED(VARTAG_EXTERNAL(PTR))) -#define VARATT_IS_EXTERNAL_NON_EXPANDED(PTR) \ - (VARATT_IS_EXTERNAL(PTR) && !VARTAG_IS_EXPANDED(VARTAG_EXTERNAL(PTR))) -#define VARATT_IS_SHORT(PTR) VARATT_IS_1B(PTR) -#define VARATT_IS_EXTENDED(PTR) (!VARATT_IS_4B_U(PTR)) - -#define SET_VARSIZE(PTR, len) SET_VARSIZE_4B(PTR, len) -#define SET_VARSIZE_SHORT(PTR, len) SET_VARSIZE_1B(PTR, len) -#define SET_VARSIZE_COMPRESSED(PTR, len) SET_VARSIZE_4B_C(PTR, len) - -#define SET_VARTAG_EXTERNAL(PTR, tag) SET_VARTAG_1B_E(PTR, tag) - -#define VARSIZE_ANY(PTR) \ - (VARATT_IS_1B_E(PTR) ? VARSIZE_EXTERNAL(PTR) : \ - (VARATT_IS_1B(PTR) ? VARSIZE_1B(PTR) : \ - VARSIZE_4B(PTR))) - -/* Size of a varlena data, excluding header */ -#define VARSIZE_ANY_EXHDR(PTR) \ - (VARATT_IS_1B_E(PTR) ? VARSIZE_EXTERNAL(PTR)-VARHDRSZ_EXTERNAL : \ - (VARATT_IS_1B(PTR) ? VARSIZE_1B(PTR)-VARHDRSZ_SHORT : \ - VARSIZE_4B(PTR)-VARHDRSZ)) - -/* caution: this will not work on an external or compressed-in-line Datum */ -/* caution: this will return a possibly unaligned pointer */ -#define VARDATA_ANY(PTR) \ - (VARATT_IS_1B(PTR) ? VARDATA_1B(PTR) : VARDATA_4B(PTR)) - -/* Decompressed size and compression method of a compressed-in-line Datum */ -#define VARDATA_COMPRESSED_GET_EXTSIZE(PTR) \ - (((varattrib_4b *) (PTR))->va_compressed.va_tcinfo & VARLENA_EXTSIZE_MASK) -#define VARDATA_COMPRESSED_GET_COMPRESS_METHOD(PTR) \ - (((varattrib_4b *) (PTR))->va_compressed.va_tcinfo >> VARLENA_EXTSIZE_BITS) - -/* Same for external Datums; but note argument is a struct varatt_external */ -#define VARATT_EXTERNAL_GET_EXTSIZE(toast_pointer) \ - ((toast_pointer).va_extinfo & VARLENA_EXTSIZE_MASK) -#define VARATT_EXTERNAL_GET_COMPRESS_METHOD(toast_pointer) \ - ((toast_pointer).va_extinfo >> VARLENA_EXTSIZE_BITS) - -#define VARATT_EXTERNAL_SET_SIZE_AND_COMPRESS_METHOD(toast_pointer, len, cm) \ - do { \ - Assert((cm) == TOAST_PGLZ_COMPRESSION_ID || \ - (cm) == TOAST_LZ4_COMPRESSION_ID); \ - ((toast_pointer).va_extinfo = \ - (len) | ((uint32) (cm) << VARLENA_EXTSIZE_BITS)); \ - } while (0) - -/* - * Testing whether an externally-stored value is compressed now requires - * comparing size stored in va_extinfo (the actual length of the external data) - * to rawsize (the original uncompressed datum's size). The latter includes - * VARHDRSZ overhead, the former doesn't. We never use compression unless it - * actually saves space, so we expect either equality or less-than. - */ -#define VARATT_EXTERNAL_IS_COMPRESSED(toast_pointer) \ - (VARATT_EXTERNAL_GET_EXTSIZE(toast_pointer) < \ - (toast_pointer).va_rawsize - VARHDRSZ) - - -/* ---------------------------------------------------------------- - * Section 2: Datum type + support functions + * Section 1: Datum type + support functions * ---------------------------------------------------------------- */ @@ -907,7 +559,7 @@ extern Datum Float8GetDatum(float8 X); /* ---------------------------------------------------------------- - * Section 3: miscellaneous + * Section 2: miscellaneous * ---------------------------------------------------------------- */ diff --git a/src/include/utils/expandeddatum.h b/src/include/utils/expandeddatum.h index c4818eb054..139f49d940 100644 --- a/src/include/utils/expandeddatum.h +++ b/src/include/utils/expandeddatum.h @@ -44,6 +44,8 @@ #ifndef EXPANDEDDATUM_H #define EXPANDEDDATUM_H +#include "varatt.h" + /* Size of an EXTERNAL datum that contains a pointer to an expanded object */ #define EXPANDED_POINTER_SIZE (VARHDRSZ_EXTERNAL + sizeof(varatt_expanded)) diff --git a/src/include/postgres.h b/src/include/varatt.h similarity index 53% copy from src/include/postgres.h copy to src/include/varatt.h index 54730dfb38..37a139145e 100644 --- a/src/include/postgres.h +++ b/src/include/varatt.h @@ -1,57 +1,19 @@ /*------------------------------------------------------------------------- * - * postgres.h - * Primary include file for PostgreSQL server .c files - * - * This should be the first file included by PostgreSQL backend modules. - * Client-side code should include postgres_fe.h instead. + * varatt.h + * variable-length datatypes (TOAST support) * * * Portions Copyright (c) 1996-2022, 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 functions - * 3) miscellaneous - * - * 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 @@ -393,535 +355,4 @@ typedef struct (VARATT_EXTERNAL_GET_EXTSIZE(toast_pointer) < \ (toast_pointer).va_rawsize - VARHDRSZ) - -/* ---------------------------------------------------------------- - * Section 2: Datum type + support functions - * ---------------------------------------------------------------- - */ - -/* - * 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 functions below and the analogous functions 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. - */ -static inline bool -DatumGetBool(Datum X) -{ - return (X != 0); -} - -/* - * BoolGetDatum - * Returns datum representation for a boolean. - * - * Note: any nonzero value will be considered true. - */ -static inline Datum -BoolGetDatum(bool X) -{ - return (Datum) (X ? 1 : 0); -} - -/* - * DatumGetChar - * Returns character value of a datum. - */ -static inline char -DatumGetChar(Datum X) -{ - return (char) X; -} - -/* - * CharGetDatum - * Returns datum representation for a character. - */ -static inline Datum -CharGetDatum(char X) -{ - return (Datum) X; -} - -/* - * Int8GetDatum - * Returns datum representation for an 8-bit integer. - */ -static inline Datum -Int8GetDatum(int8 X) -{ - return (Datum) X; -} - -/* - * DatumGetUInt8 - * Returns 8-bit unsigned integer value of a datum. - */ -static inline uint8 -DatumGetUInt8(Datum X) -{ - return (uint8) X; -} - -/* - * UInt8GetDatum - * Returns datum representation for an 8-bit unsigned integer. - */ -static inline Datum -UInt8GetDatum(uint8 X) -{ - return (Datum) X; -} - -/* - * DatumGetInt16 - * Returns 16-bit integer value of a datum. - */ -static inline int16 -DatumGetInt16(Datum X) -{ - return (int16) X; -} - -/* - * Int16GetDatum - * Returns datum representation for a 16-bit integer. - */ -static inline Datum -Int16GetDatum(int16 X) -{ - return (Datum) X; -} - -/* - * DatumGetUInt16 - * Returns 16-bit unsigned integer value of a datum. - */ -static inline uint16 -DatumGetUInt16(Datum X) -{ - return (uint16) X; -} - -/* - * UInt16GetDatum - * Returns datum representation for a 16-bit unsigned integer. - */ -static inline Datum -UInt16GetDatum(uint16 X) -{ - return (Datum) X; -} - -/* - * DatumGetInt32 - * Returns 32-bit integer value of a datum. - */ -static inline int32 -DatumGetInt32(Datum X) -{ - return (int32) X; -} - -/* - * Int32GetDatum - * Returns datum representation for a 32-bit integer. - */ -static inline Datum -Int32GetDatum(int32 X) -{ - return (Datum) X; -} - -/* - * DatumGetUInt32 - * Returns 32-bit unsigned integer value of a datum. - */ -static inline uint32 -DatumGetUInt32(Datum X) -{ - return (uint32) X; -} - -/* - * UInt32GetDatum - * Returns datum representation for a 32-bit unsigned integer. - */ -static inline Datum -UInt32GetDatum(uint32 X) -{ - return (Datum) X; -} - -/* - * DatumGetObjectId - * Returns object identifier value of a datum. - */ -static inline Oid -DatumGetObjectId(Datum X) -{ - return (Oid) X; -} - -/* - * ObjectIdGetDatum - * Returns datum representation for an object identifier. - */ -static inline Datum -ObjectIdGetDatum(Oid X) -{ - return (Datum) X; -} - -/* - * DatumGetTransactionId - * Returns transaction identifier value of a datum. - */ -static inline TransactionId -DatumGetTransactionId(Datum X) -{ - return (TransactionId) X; -} - -/* - * TransactionIdGetDatum - * Returns datum representation for a transaction identifier. - */ -static inline Datum -TransactionIdGetDatum(TransactionId X) -{ - return (Datum) X; -} - -/* - * MultiXactIdGetDatum - * Returns datum representation for a multixact identifier. - */ -static inline Datum -MultiXactIdGetDatum(MultiXactId X) -{ - return (Datum) X; -} - -/* - * DatumGetCommandId - * Returns command identifier value of a datum. - */ -static inline CommandId -DatumGetCommandId(Datum X) -{ - return (CommandId) X; -} - -/* - * CommandIdGetDatum - * Returns datum representation for a command identifier. - */ -static inline Datum -CommandIdGetDatum(CommandId X) -{ - return (Datum) X; -} - -/* - * DatumGetPointer - * Returns pointer value of a datum. - */ -static inline Pointer -DatumGetPointer(Datum X) -{ - return (Pointer) X; -} - -/* - * PointerGetDatum - * Returns datum representation for a pointer. - */ -static inline Datum -PointerGetDatum(const void *X) -{ - return (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. - */ -static inline char * -DatumGetCString(Datum X) -{ - return (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. - */ -static inline Datum -CStringGetDatum(const char *X) -{ - return PointerGetDatum(X); -} - -/* - * DatumGetName - * Returns name value of a datum. - */ -static inline Name -DatumGetName(Datum X) -{ - return (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. - */ -static inline Datum -NameGetDatum(const NameData *X) -{ - return CStringGetDatum(NameStr(*X)); -} - -/* - * DatumGetInt64 - * Returns 64-bit integer value of a datum. - * - * Note: this function hides whether int64 is pass by value or by reference. - */ -static inline int64 -DatumGetInt64(Datum X) -{ -#ifdef USE_FLOAT8_BYVAL - return (int64) X; -#else - return *((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 -static inline Datum -Int64GetDatum(int64 X) -{ - return (Datum) X; -} -#else -extern Datum Int64GetDatum(int64 X); -#endif - - -/* - * DatumGetUInt64 - * Returns 64-bit unsigned integer value of a datum. - * - * Note: this function hides whether int64 is pass by value or by reference. - */ -static inline uint64 -DatumGetUInt64(Datum X) -{ -#ifdef USE_FLOAT8_BYVAL - return (uint64) X; -#else - return *((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. - */ -static inline Datum -UInt64GetDatum(uint64 X) -{ -#ifdef USE_FLOAT8_BYVAL - return (Datum) X; -#else - return 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 function hides whether float8 is pass by value or by reference. - */ -static inline float8 -DatumGetFloat8(Datum X) -{ -#ifdef USE_FLOAT8_BYVAL - union - { - int64 value; - float8 retval; - } myunion; - - myunion.value = DatumGetInt64(X); - return myunion.retval; -#else - return *((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 are the same as the non-Fast - * functions, except for asserting that the variable is of the correct type. - */ - -#ifdef USE_FLOAT8_BYVAL -#define Int64GetDatumFast(X) \ - (AssertVariableIsOfTypeMacro(X, int64), Int64GetDatum(X)) -#define Float8GetDatumFast(X) \ - (AssertVariableIsOfTypeMacro(X, double), Float8GetDatum(X)) -#else -#define Int64GetDatumFast(X) \ - (AssertVariableIsOfTypeMacro(X, int64), PointerGetDatum(&(X))) -#define Float8GetDatumFast(X) \ - (AssertVariableIsOfTypeMacro(X, double), PointerGetDatum(&(X))) -#endif - - -/* ---------------------------------------------------------------- - * Section 3: miscellaneous - * ---------------------------------------------------------------- - */ - -/* - * NON_EXEC_STATIC: It's sometimes useful to define a variable or function - * that is normally static but extern when using EXEC_BACKEND (see - * pg_config_manual.h). There would then typically be some code in - * postmaster.c that uses those extern symbols to transfer state between - * processes or do whatever other things it needs to do in EXEC_BACKEND mode. - */ -#ifdef EXEC_BACKEND -#define NON_EXEC_STATIC -#else -#define NON_EXEC_STATIC static -#endif - -#endif /* POSTGRES_H */ base-commit: adb5c32eb53e1ffdc5c954aafcc5bc9ed93f3de6 -- 2.39.0