pg_query 4.2.1 → 6.1.0

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

@@ -1,73 +0,0 @@
-/*-------------------------------------------------------------------------
- *
- * toast_compression.h
- *	  Functions for toast compression.
- *
- * Copyright (c) 2021-2022, PostgreSQL Global Development Group
- *
- * src/include/access/toast_compression.h
- *
- *-------------------------------------------------------------------------
- */
-
-#ifndef TOAST_COMPRESSION_H
-#define TOAST_COMPRESSION_H
-
-/*
- * GUC support.
- *
- * default_toast_compression is an integer for purposes of the GUC machinery,
- * but the value is one of the char values defined below, as they appear in
- * pg_attribute.attcompression, e.g. TOAST_PGLZ_COMPRESSION.
- */
-extern PGDLLIMPORT int default_toast_compression;
-
-/*
- * Built-in compression method ID.  The toast compression header will store
- * this in the first 2 bits of the raw length.  These built-in compression
- * method IDs are directly mapped to the built-in compression methods.
- *
- * Don't use these values for anything other than understanding the meaning
- * of the raw bits from a varlena; in particular, if the goal is to identify
- * a compression method, use the constants TOAST_PGLZ_COMPRESSION, etc.
- * below. We might someday support more than 4 compression methods, but
- * we can never have more than 4 values in this enum, because there are
- * only 2 bits available in the places where this is stored.
- */
-typedef enum ToastCompressionId
-{
-	TOAST_PGLZ_COMPRESSION_ID = 0,
-	TOAST_LZ4_COMPRESSION_ID = 1,
-	TOAST_INVALID_COMPRESSION_ID = 2
-} ToastCompressionId;
-
-/*
- * Built-in compression methods.  pg_attribute will store these in the
- * attcompression column.  In attcompression, InvalidCompressionMethod
- * denotes the default behavior.
- */
-#define TOAST_PGLZ_COMPRESSION			'p'
-#define TOAST_LZ4_COMPRESSION			'l'
-#define InvalidCompressionMethod		'\0'
-
-#define CompressionMethodIsValid(cm)  ((cm) != InvalidCompressionMethod)
-
-
-/* pglz compression/decompression routines */
-extern struct varlena *pglz_compress_datum(const struct varlena *value);
-extern struct varlena *pglz_decompress_datum(const struct varlena *value);
-extern struct varlena *pglz_decompress_datum_slice(const struct varlena *value,
-												   int32 slicelength);
-
-/* lz4 compression/decompression routines */
-extern struct varlena *lz4_compress_datum(const struct varlena *value);
-extern struct varlena *lz4_decompress_datum(const struct varlena *value);
-extern struct varlena *lz4_decompress_datum_slice(const struct varlena *value,
-												  int32 slicelength);
-
-/* other stuff */
-extern ToastCompressionId toast_get_compression_id(struct varlena *attr);
-extern char CompressionNameToMethod(const char *compression);
-extern const char *GetCompressionMethodName(char method);
-
-#endif							/* TOAST_COMPRESSION_H */

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

@@ -1,375 +0,0 @@
-/*-------------------------------------------------------------------------
- *
- * transam.h
- *	  postgres transaction access method support code
- *
- *
- * Portions Copyright (c) 1996-2022, PostgreSQL Global Development Group
- * Portions Copyright (c) 1994, Regents of the University of California
- *
- * src/include/access/transam.h
- *
- *-------------------------------------------------------------------------
- */
-#ifndef TRANSAM_H
-#define TRANSAM_H
-
-#include "access/xlogdefs.h"
-
-
-/* ----------------
- *		Special transaction ID values
- *
- * BootstrapTransactionId is the XID for "bootstrap" operations, and
- * FrozenTransactionId is used for very old tuples.  Both should
- * always be considered valid.
- *
- * FirstNormalTransactionId is the first "normal" transaction id.
- * Note: if you need to change it, you must change pg_class.h as well.
- * ----------------
- */
-#define InvalidTransactionId		((TransactionId) 0)
-#define BootstrapTransactionId		((TransactionId) 1)
-#define FrozenTransactionId			((TransactionId) 2)
-#define FirstNormalTransactionId	((TransactionId) 3)
-#define MaxTransactionId			((TransactionId) 0xFFFFFFFF)
-
-/* ----------------
- *		transaction ID manipulation macros
- * ----------------
- */
-#define TransactionIdIsValid(xid)		((xid) != InvalidTransactionId)
-#define TransactionIdIsNormal(xid)		((xid) >= FirstNormalTransactionId)
-#define TransactionIdEquals(id1, id2)	((id1) == (id2))
-#define TransactionIdStore(xid, dest)	(*(dest) = (xid))
-#define StoreInvalidTransactionId(dest) (*(dest) = InvalidTransactionId)
-
-#define EpochFromFullTransactionId(x)	((uint32) ((x).value >> 32))
-#define XidFromFullTransactionId(x)		((uint32) (x).value)
-#define U64FromFullTransactionId(x)		((x).value)
-#define FullTransactionIdEquals(a, b)	((a).value == (b).value)
-#define FullTransactionIdPrecedes(a, b)	((a).value < (b).value)
-#define FullTransactionIdPrecedesOrEquals(a, b) ((a).value <= (b).value)
-#define FullTransactionIdFollows(a, b) ((a).value > (b).value)
-#define FullTransactionIdFollowsOrEquals(a, b) ((a).value >= (b).value)
-#define FullTransactionIdIsValid(x)		TransactionIdIsValid(XidFromFullTransactionId(x))
-#define InvalidFullTransactionId		FullTransactionIdFromEpochAndXid(0, InvalidTransactionId)
-#define FirstNormalFullTransactionId	FullTransactionIdFromEpochAndXid(0, FirstNormalTransactionId)
-#define FullTransactionIdIsNormal(x)	FullTransactionIdFollowsOrEquals(x, FirstNormalFullTransactionId)
-
-/*
- * A 64 bit value that contains an epoch and a TransactionId.  This is
- * wrapped in a struct to prevent implicit conversion to/from TransactionId.
- * Not all values represent valid normal XIDs.
- */
-typedef struct FullTransactionId
-{
-	uint64		value;
-} FullTransactionId;
-
-static inline FullTransactionId
-FullTransactionIdFromEpochAndXid(uint32 epoch, TransactionId xid)
-{
-	FullTransactionId result;
-
-	result.value = ((uint64) epoch) << 32 | xid;
-
-	return result;
-}
-
-static inline FullTransactionId
-FullTransactionIdFromU64(uint64 value)
-{
-	FullTransactionId result;
-
-	result.value = value;
-
-	return result;
-}
-
-/* advance a transaction ID variable, handling wraparound correctly */
-#define TransactionIdAdvance(dest)	\
-	do { \
-		(dest)++; \
-		if ((dest) < FirstNormalTransactionId) \
-			(dest) = FirstNormalTransactionId; \
-	} while(0)
-
-/*
- * Retreat a FullTransactionId variable, stepping over xids that would appear
- * to be special only when viewed as 32bit XIDs.
- */
-static inline void
-FullTransactionIdRetreat(FullTransactionId *dest)
-{
-	dest->value--;
-
-	/*
-	 * In contrast to 32bit XIDs don't step over the "actual" special xids.
-	 * For 64bit xids these can't be reached as part of a wraparound as they
-	 * can in the 32bit case.
-	 */
-	if (FullTransactionIdPrecedes(*dest, FirstNormalFullTransactionId))
-		return;
-
-	/*
-	 * But we do need to step over XIDs that'd appear special only for 32bit
-	 * XIDs.
-	 */
-	while (XidFromFullTransactionId(*dest) < FirstNormalTransactionId)
-		dest->value--;
-}
-
-/*
- * Advance a FullTransactionId variable, stepping over xids that would appear
- * to be special only when viewed as 32bit XIDs.
- */
-static inline void
-FullTransactionIdAdvance(FullTransactionId *dest)
-{
-	dest->value++;
-
-	/* see FullTransactionIdAdvance() */
-	if (FullTransactionIdPrecedes(*dest, FirstNormalFullTransactionId))
-		return;
-
-	while (XidFromFullTransactionId(*dest) < FirstNormalTransactionId)
-		dest->value++;
-}
-
-/* back up a transaction ID variable, handling wraparound correctly */
-#define TransactionIdRetreat(dest)	\
-	do { \
-		(dest)--; \
-	} while ((dest) < FirstNormalTransactionId)
-
-/* compare two XIDs already known to be normal; this is a macro for speed */
-#define NormalTransactionIdPrecedes(id1, id2) \
-	(AssertMacro(TransactionIdIsNormal(id1) && TransactionIdIsNormal(id2)), \
-	(int32) ((id1) - (id2)) < 0)
-
-/* compare two XIDs already known to be normal; this is a macro for speed */
-#define NormalTransactionIdFollows(id1, id2) \
-	(AssertMacro(TransactionIdIsNormal(id1) && TransactionIdIsNormal(id2)), \
-	(int32) ((id1) - (id2)) > 0)
-
-/* ----------
- *		Object ID (OID) zero is InvalidOid.
- *
- *		OIDs 1-9999 are reserved for manual assignment (see .dat files in
- *		src/include/catalog/).  Of these, 8000-9999 are reserved for
- *		development purposes (such as in-progress patches and forks);
- *		they should not appear in released versions.
- *
- *		OIDs 10000-11999 are reserved for assignment by genbki.pl, for use
- *		when the .dat files in src/include/catalog/ do not specify an OID
- *		for a catalog entry that requires one.  Note that genbki.pl assigns
- *		these OIDs independently in each catalog, so they're not guaranteed
- *		to be globally unique.  Furthermore, the bootstrap backend and
- *		initdb's post-bootstrap processing can also assign OIDs in this range.
- *		The normal OID-generation logic takes care of any OID conflicts that
- *		might arise from that.
- *
- *		OIDs 12000-16383 are reserved for unpinned objects created by initdb's
- *		post-bootstrap processing.  initdb forces the OID generator up to
- *		12000 as soon as it's made the pinned objects it's responsible for.
- *
- *		OIDs beginning at 16384 are assigned from the OID generator
- *		during normal multiuser operation.  (We force the generator up to
- *		16384 as soon as we are in normal operation.)
- *
- * The choices of 8000, 10000 and 12000 are completely arbitrary, and can be
- * moved if we run low on OIDs in any category.  Changing the macros below,
- * and updating relevant documentation (see bki.sgml and RELEASE_CHANGES),
- * should be sufficient to do this.  Moving the 16384 boundary between
- * initdb-assigned OIDs and user-defined objects would be substantially
- * more painful, however, since some user-defined OIDs will appear in
- * on-disk data; such a change would probably break pg_upgrade.
- *
- * NOTE: if the OID generator wraps around, we skip over OIDs 0-16383
- * and resume with 16384.  This minimizes the odds of OID conflict, by not
- * reassigning OIDs that might have been assigned during initdb.  Critically,
- * it also ensures that no user-created object will be considered pinned.
- * ----------
- */
-#define FirstGenbkiObjectId		10000
-#define FirstUnpinnedObjectId	12000
-#define FirstNormalObjectId		16384
-
-/*
- * VariableCache is a data structure in shared memory that is used to track
- * OID and XID assignment state.  For largely historical reasons, there is
- * just one struct with different fields that are protected by different
- * LWLocks.
- *
- * Note: xidWrapLimit and oldestXidDB are not "active" values, but are
- * used just to generate useful messages when xidWarnLimit or xidStopLimit
- * are exceeded.
- */
-typedef struct VariableCacheData
-{
-	/*
-	 * These fields are protected by OidGenLock.
-	 */
-	Oid			nextOid;		/* next OID to assign */
-	uint32		oidCount;		/* OIDs available before must do XLOG work */
-
-	/*
-	 * These fields are protected by XidGenLock.
-	 */
-	FullTransactionId nextXid;	/* next XID to assign */
-
-	TransactionId oldestXid;	/* cluster-wide minimum datfrozenxid */
-	TransactionId xidVacLimit;	/* start forcing autovacuums here */
-	TransactionId xidWarnLimit; /* start complaining here */
-	TransactionId xidStopLimit; /* refuse to advance nextXid beyond here */
-	TransactionId xidWrapLimit; /* where the world ends */
-	Oid			oldestXidDB;	/* database with minimum datfrozenxid */
-
-	/*
-	 * These fields are protected by CommitTsLock
-	 */
-	TransactionId oldestCommitTsXid;
-	TransactionId newestCommitTsXid;
-
-	/*
-	 * These fields are protected by ProcArrayLock.
-	 */
-	FullTransactionId latestCompletedXid;	/* newest full XID that has
-											 * committed or aborted */
-
-	/*
-	 * Number of top-level transactions with xids (i.e. which may have
-	 * modified the database) that completed in some form since the start of
-	 * the server. This currently is solely used to check whether
-	 * GetSnapshotData() needs to recompute the contents of the snapshot, or
-	 * not. There are likely other users of this.  Always above 1.
-	 */
-	uint64		xactCompletionCount;
-
-	/*
-	 * These fields are protected by XactTruncationLock
-	 */
-	TransactionId oldestClogXid;	/* oldest it's safe to look up in clog */
-
-} VariableCacheData;
-
-typedef VariableCacheData *VariableCache;
-
-
-/* ----------------
- *		extern declarations
- * ----------------
- */
-
-/* in transam/xact.c */
-extern bool TransactionStartedDuringRecovery(void);
-
-/* in transam/varsup.c */
-extern PGDLLIMPORT VariableCache ShmemVariableCache;
-
-/*
- * prototypes for functions in transam/transam.c
- */
-extern bool TransactionIdDidCommit(TransactionId transactionId);
-extern bool TransactionIdDidAbort(TransactionId transactionId);
-extern void TransactionIdCommitTree(TransactionId xid, int nxids, TransactionId *xids);
-extern void TransactionIdAsyncCommitTree(TransactionId xid, int nxids, TransactionId *xids, XLogRecPtr lsn);
-extern void TransactionIdAbortTree(TransactionId xid, int nxids, TransactionId *xids);
-extern bool TransactionIdPrecedes(TransactionId id1, TransactionId id2);
-extern bool TransactionIdPrecedesOrEquals(TransactionId id1, TransactionId id2);
-extern bool TransactionIdFollows(TransactionId id1, TransactionId id2);
-extern bool TransactionIdFollowsOrEquals(TransactionId id1, TransactionId id2);
-extern TransactionId TransactionIdLatest(TransactionId mainxid,
-										 int nxids, const TransactionId *xids);
-extern XLogRecPtr TransactionIdGetCommitLSN(TransactionId xid);
-
-/* in transam/varsup.c */
-extern FullTransactionId GetNewTransactionId(bool isSubXact);
-extern void AdvanceNextFullTransactionIdPastXid(TransactionId xid);
-extern FullTransactionId ReadNextFullTransactionId(void);
-extern void SetTransactionIdLimit(TransactionId oldest_datfrozenxid,
-								  Oid oldest_datoid);
-extern void AdvanceOldestClogXid(TransactionId oldest_datfrozenxid);
-extern bool ForceTransactionIdLimitUpdate(void);
-extern Oid	GetNewObjectId(void);
-extern void StopGeneratingPinnedObjectIds(void);
-
-#ifdef USE_ASSERT_CHECKING
-extern void AssertTransactionIdInAllowableRange(TransactionId xid);
-#else
-#define AssertTransactionIdInAllowableRange(xid) ((void)true)
-#endif
-
-/*
- * Some frontend programs include this header.  For compilers that emit static
- * inline functions even when they're unused, that leads to unsatisfied
- * external references; hence hide them with #ifndef FRONTEND.
- */
-#ifndef FRONTEND
-
-/*
- * For callers that just need the XID part of the next transaction ID.
- */
-static inline TransactionId
-ReadNextTransactionId(void)
-{
-	return XidFromFullTransactionId(ReadNextFullTransactionId());
-}
-
-/* return transaction ID backed up by amount, handling wraparound correctly */
-static inline TransactionId
-TransactionIdRetreatedBy(TransactionId xid, uint32 amount)
-{
-	xid -= amount;
-
-	while (xid < FirstNormalTransactionId)
-		xid--;
-
-	return xid;
-}
-
-/* return the older of the two IDs */
-static inline TransactionId
-TransactionIdOlder(TransactionId a, TransactionId b)
-{
-	if (!TransactionIdIsValid(a))
-		return b;
-
-	if (!TransactionIdIsValid(b))
-		return a;
-
-	if (TransactionIdPrecedes(a, b))
-		return a;
-	return b;
-}
-
-/* return the older of the two IDs, assuming they're both normal */
-static inline TransactionId
-NormalTransactionIdOlder(TransactionId a, TransactionId b)
-{
-	Assert(TransactionIdIsNormal(a));
-	Assert(TransactionIdIsNormal(b));
-	if (NormalTransactionIdPrecedes(a, b))
-		return a;
-	return b;
-}
-
-/* return the newer of the two IDs */
-static inline FullTransactionId
-FullTransactionIdNewer(FullTransactionId a, FullTransactionId b)
-{
-	if (!FullTransactionIdIsValid(a))
-		return b;
-
-	if (!FullTransactionIdIsValid(b))
-		return a;
-
-	if (FullTransactionIdFollows(a, b))
-		return a;
-	return b;
-}
-
-#endif							/* FRONTEND */
-
-#endif							/* TRANSAM_H */

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

@@ -1,51 +0,0 @@
-/*-------------------------------------------------------------------------
- *
- * tupconvert.h
- *	  Tuple conversion support.
- *
- *
- * Portions Copyright (c) 1996-2022, PostgreSQL Global Development Group
- * Portions Copyright (c) 1994, Regents of the University of California
- *
- * src/include/access/tupconvert.h
- *
- *-------------------------------------------------------------------------
- */
-#ifndef TUPCONVERT_H
-#define TUPCONVERT_H
-
-#include "access/attmap.h"
-#include "access/htup.h"
-#include "access/tupdesc.h"
-#include "executor/tuptable.h"
-#include "nodes/bitmapset.h"
-
-
-typedef struct TupleConversionMap
-{
-	TupleDesc	indesc;			/* tupdesc for source rowtype */
-	TupleDesc	outdesc;		/* tupdesc for result rowtype */
-	AttrMap    *attrMap;		/* indexes of input fields, or 0 for null */
-	Datum	   *invalues;		/* workspace for deconstructing source */
-	bool	   *inisnull;
-	Datum	   *outvalues;		/* workspace for constructing result */
-	bool	   *outisnull;
-} TupleConversionMap;
-
-
-extern TupleConversionMap *convert_tuples_by_position(TupleDesc indesc,
-													  TupleDesc outdesc,
-													  const char *msg);
-
-extern TupleConversionMap *convert_tuples_by_name(TupleDesc indesc,
-												  TupleDesc outdesc);
-
-extern HeapTuple execute_attr_map_tuple(HeapTuple tuple, TupleConversionMap *map);
-extern TupleTableSlot *execute_attr_map_slot(AttrMap *attrMap,
-											 TupleTableSlot *in_slot,
-											 TupleTableSlot *out_slot);
-extern Bitmapset *execute_attr_map_cols(AttrMap *attrMap, Bitmapset *inbitmap);
-
-extern void free_conversion_map(TupleConversionMap *map);
-
-#endif							/* TUPCONVERT_H */

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

@@ -1,154 +0,0 @@
-/*-------------------------------------------------------------------------
- *
- * tupdesc.h
- *	  POSTGRES tuple descriptor definitions.
- *
- *
- * Portions Copyright (c) 1996-2022, PostgreSQL Global Development Group
- * Portions Copyright (c) 1994, Regents of the University of California
- *
- * src/include/access/tupdesc.h
- *
- *-------------------------------------------------------------------------
- */
-#ifndef TUPDESC_H
-#define TUPDESC_H
-
-#include "access/attnum.h"
-#include "catalog/pg_attribute.h"
-#include "nodes/pg_list.h"
-
-
-typedef struct AttrDefault
-{
-	AttrNumber	adnum;
-	char	   *adbin;			/* nodeToString representation of expr */
-} AttrDefault;
-
-typedef struct ConstrCheck
-{
-	char	   *ccname;
-	char	   *ccbin;			/* nodeToString representation of expr */
-	bool		ccvalid;
-	bool		ccnoinherit;	/* this is a non-inheritable constraint */
-} ConstrCheck;
-
-/* This structure contains constraints of a tuple */
-typedef struct TupleConstr
-{
-	AttrDefault *defval;		/* array */
-	ConstrCheck *check;			/* array */
-	struct AttrMissing *missing;	/* missing attributes values, NULL if none */
-	uint16		num_defval;
-	uint16		num_check;
-	bool		has_not_null;
-	bool		has_generated_stored;
-} TupleConstr;
-
-/*
- * This struct is passed around within the backend to describe the structure
- * of tuples.  For tuples coming from on-disk relations, the information is
- * collected from the pg_attribute, pg_attrdef, and pg_constraint catalogs.
- * Transient row types (such as the result of a join query) have anonymous
- * TupleDesc structs that generally omit any constraint info; therefore the
- * structure is designed to let the constraints be omitted efficiently.
- *
- * Note that only user attributes, not system attributes, are mentioned in
- * TupleDesc.
- *
- * If the tupdesc is known to correspond to a named rowtype (such as a table's
- * rowtype) then tdtypeid identifies that type and tdtypmod is -1.  Otherwise
- * tdtypeid is RECORDOID, and tdtypmod can be either -1 for a fully anonymous
- * row type, or a value >= 0 to allow the rowtype to be looked up in the
- * typcache.c type cache.
- *
- * Note that tdtypeid is never the OID of a domain over composite, even if
- * we are dealing with values that are known (at some higher level) to be of
- * a domain-over-composite type.  This is because tdtypeid/tdtypmod need to
- * match up with the type labeling of composite Datums, and those are never
- * explicitly marked as being of a domain type, either.
- *
- * Tuple descriptors that live in caches (relcache or typcache, at present)
- * are reference-counted: they can be deleted when their reference count goes
- * to zero.  Tuple descriptors created by the executor need no reference
- * counting, however: they are simply created in the appropriate memory
- * context and go away when the context is freed.  We set the tdrefcount
- * field of such a descriptor to -1, while reference-counted descriptors
- * always have tdrefcount >= 0.
- */
-typedef struct TupleDescData
-{
-	int			natts;			/* number of attributes in the tuple */
-	Oid			tdtypeid;		/* composite type ID for tuple type */
-	int32		tdtypmod;		/* typmod for tuple type */
-	int			tdrefcount;		/* reference count, or -1 if not counting */
-	TupleConstr *constr;		/* constraints, or NULL if none */
-	/* attrs[N] is the description of Attribute Number N+1 */
-	FormData_pg_attribute attrs[FLEXIBLE_ARRAY_MEMBER];
-}			TupleDescData;
-typedef struct TupleDescData *TupleDesc;
-
-/* Accessor for the i'th attribute of tupdesc. */
-#define TupleDescAttr(tupdesc, i) (&(tupdesc)->attrs[(i)])
-
-extern TupleDesc CreateTemplateTupleDesc(int natts);
-
-extern TupleDesc CreateTupleDesc(int natts, Form_pg_attribute *attrs);
-
-extern TupleDesc CreateTupleDescCopy(TupleDesc tupdesc);
-
-extern TupleDesc CreateTupleDescCopyConstr(TupleDesc tupdesc);
-
-#define TupleDescSize(src) \
-	(offsetof(struct TupleDescData, attrs) + \
-	 (src)->natts * sizeof(FormData_pg_attribute))
-
-extern void TupleDescCopy(TupleDesc dst, TupleDesc src);
-
-extern void TupleDescCopyEntry(TupleDesc dst, AttrNumber dstAttno,
-							   TupleDesc src, AttrNumber srcAttno);
-
-extern void FreeTupleDesc(TupleDesc tupdesc);
-
-extern void IncrTupleDescRefCount(TupleDesc tupdesc);
-extern void DecrTupleDescRefCount(TupleDesc tupdesc);
-
-#define PinTupleDesc(tupdesc) \
-	do { \
-		if ((tupdesc)->tdrefcount >= 0) \
-			IncrTupleDescRefCount(tupdesc); \
-	} while (0)
-
-#define ReleaseTupleDesc(tupdesc) \
-	do { \
-		if ((tupdesc)->tdrefcount >= 0) \
-			DecrTupleDescRefCount(tupdesc); \
-	} while (0)
-
-extern bool equalTupleDescs(TupleDesc tupdesc1, TupleDesc tupdesc2);
-
-extern uint32 hashTupleDesc(TupleDesc tupdesc);
-
-extern void TupleDescInitEntry(TupleDesc desc,
-							   AttrNumber attributeNumber,
-							   const char *attributeName,
-							   Oid oidtypeid,
-							   int32 typmod,
-							   int attdim);
-
-extern void TupleDescInitBuiltinEntry(TupleDesc desc,
-									  AttrNumber attributeNumber,
-									  const char *attributeName,
-									  Oid oidtypeid,
-									  int32 typmod,
-									  int attdim);
-
-extern void TupleDescInitEntryCollation(TupleDesc desc,
-										AttrNumber attributeNumber,
-										Oid collationid);
-
-extern TupleDesc BuildDescForRelation(List *schema);
-
-extern TupleDesc BuildDescFromLists(List *names, List *types, List *typmods, List *collations);
-
-#endif							/* TUPDESC_H */