pg_query 4.2.1 → 6.1.0

data/ext/pg_query/include/postgres/catalog/pg_constraint.h

@@ -0,0 +1,278 @@
+/*-------------------------------------------------------------------------
+ *
+ * pg_constraint.h
+ *	  definition of the "constraint" system catalog (pg_constraint)
+ *
+ *
+ * Portions Copyright (c) 1996-2024, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/catalog/pg_constraint.h
+ *
+ * NOTES
+ *	  The Catalog.pm module reads this file and derives schema
+ *	  information.
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef PG_CONSTRAINT_H
+#define PG_CONSTRAINT_H
+
+#include "catalog/dependency.h"
+#include "catalog/genbki.h"
+#include "catalog/pg_constraint_d.h"
+#include "nodes/pg_list.h"
+
+/* ----------------
+ *		pg_constraint definition.  cpp turns this into
+ *		typedef struct FormData_pg_constraint
+ * ----------------
+ */
+CATALOG(pg_constraint,2606,ConstraintRelationId)
+{
+	Oid			oid;			/* oid */
+
+	/*
+	 * conname + connamespace is deliberately not unique; we allow, for
+	 * example, the same name to be used for constraints of different
+	 * relations.  This is partly for backwards compatibility with past
+	 * Postgres practice, and partly because we don't want to have to obtain a
+	 * global lock to generate a globally unique name for a nameless
+	 * constraint.  We associate a namespace with constraint names only for
+	 * SQL-spec compatibility.
+	 *
+	 * However, we do require conname to be unique among the constraints of a
+	 * single relation or domain.  This is enforced by a unique index on
+	 * conrelid + contypid + conname.
+	 */
+	NameData	conname;		/* name of this constraint */
+	Oid			connamespace BKI_LOOKUP(pg_namespace);	/* OID of namespace
+														 * containing constraint */
+	char		contype;		/* constraint type; see codes below */
+	bool		condeferrable;	/* deferrable constraint? */
+	bool		condeferred;	/* deferred by default? */
+	bool		convalidated;	/* constraint has been validated? */
+
+	/*
+	 * conrelid and conkey are only meaningful if the constraint applies to a
+	 * specific relation (this excludes domain constraints and assertions).
+	 * Otherwise conrelid is 0 and conkey is NULL.
+	 */
+	Oid			conrelid BKI_LOOKUP_OPT(pg_class);	/* relation this
+													 * constraint constrains */
+
+	/*
+	 * contypid links to the pg_type row for a domain if this is a domain
+	 * constraint.  Otherwise it's 0.
+	 *
+	 * For SQL-style global ASSERTIONs, both conrelid and contypid would be
+	 * zero. This is not presently supported, however.
+	 */
+	Oid			contypid BKI_LOOKUP_OPT(pg_type);	/* domain this constraint
+													 * constrains */
+
+	/*
+	 * conindid links to the index supporting the constraint, if any;
+	 * otherwise it's 0.  This is used for unique, primary-key, and exclusion
+	 * constraints, and less obviously for foreign-key constraints (where the
+	 * index is a unique index on the referenced relation's referenced
+	 * columns).  Notice that the index is on conrelid in the first case but
+	 * confrelid in the second.
+	 */
+	Oid			conindid BKI_LOOKUP_OPT(pg_class);	/* index supporting this
+													 * constraint */
+
+	/*
+	 * If this constraint is on a partition inherited from a partitioned
+	 * table, this is the OID of the corresponding constraint in the parent.
+	 */
+	Oid			conparentid BKI_LOOKUP_OPT(pg_constraint);
+
+	/*
+	 * These fields, plus confkey, are only meaningful for a foreign-key
+	 * constraint.  Otherwise confrelid is 0 and the char fields are spaces.
+	 */
+	Oid			confrelid BKI_LOOKUP_OPT(pg_class); /* relation referenced by
+													 * foreign key */
+	char		confupdtype;	/* foreign key's ON UPDATE action */
+	char		confdeltype;	/* foreign key's ON DELETE action */
+	char		confmatchtype;	/* foreign key's match type */
+
+	/* Has a local definition (hence, do not drop when coninhcount is 0) */
+	bool		conislocal;
+
+	/* Number of times inherited from direct parent relation(s) */
+	int16		coninhcount;
+
+	/* Has a local definition and cannot be inherited */
+	bool		connoinherit;
+
+#ifdef CATALOG_VARLEN			/* variable-length fields start here */
+
+	/*
+	 * Columns of conrelid that the constraint applies to, if known (this is
+	 * NULL for trigger constraints)
+	 */
+	int16		conkey[1];
+
+	/*
+	 * If a foreign key, the referenced columns of confrelid
+	 */
+	int16		confkey[1];
+
+	/*
+	 * If a foreign key, the OIDs of the PK = FK equality operators for each
+	 * column of the constraint
+	 */
+	Oid			conpfeqop[1] BKI_LOOKUP(pg_operator);
+
+	/*
+	 * If a foreign key, the OIDs of the PK = PK equality operators for each
+	 * column of the constraint (i.e., equality for the referenced columns)
+	 */
+	Oid			conppeqop[1] BKI_LOOKUP(pg_operator);
+
+	/*
+	 * If a foreign key, the OIDs of the FK = FK equality operators for each
+	 * column of the constraint (i.e., equality for the referencing columns)
+	 */
+	Oid			conffeqop[1] BKI_LOOKUP(pg_operator);
+
+	/*
+	 * If a foreign key with an ON DELETE SET NULL/DEFAULT action, the subset
+	 * of conkey to updated.  If null, all columns are updated.
+	 */
+	int16		confdelsetcols[1];
+
+	/*
+	 * If an exclusion constraint, the OIDs of the exclusion operators for
+	 * each column of the constraint
+	 */
+	Oid			conexclop[1] BKI_LOOKUP(pg_operator);
+
+	/*
+	 * If a check constraint, nodeToString representation of expression
+	 */
+	pg_node_tree conbin;
+#endif
+} FormData_pg_constraint;
+
+/* ----------------
+ *		Form_pg_constraint corresponds to a pointer to a tuple with
+ *		the format of pg_constraint relation.
+ * ----------------
+ */
+typedef FormData_pg_constraint *Form_pg_constraint;
+
+DECLARE_TOAST(pg_constraint, 2832, 2833);
+
+DECLARE_INDEX(pg_constraint_conname_nsp_index, 2664, ConstraintNameNspIndexId, pg_constraint, btree(conname name_ops, connamespace oid_ops));
+DECLARE_UNIQUE_INDEX(pg_constraint_conrelid_contypid_conname_index, 2665, ConstraintRelidTypidNameIndexId, pg_constraint, btree(conrelid oid_ops, contypid oid_ops, conname name_ops));
+DECLARE_INDEX(pg_constraint_contypid_index, 2666, ConstraintTypidIndexId, pg_constraint, btree(contypid oid_ops));
+DECLARE_UNIQUE_INDEX_PKEY(pg_constraint_oid_index, 2667, ConstraintOidIndexId, pg_constraint, btree(oid oid_ops));
+DECLARE_INDEX(pg_constraint_conparentid_index, 2579, ConstraintParentIndexId, pg_constraint, btree(conparentid oid_ops));
+
+MAKE_SYSCACHE(CONSTROID, pg_constraint_oid_index, 16);
+
+/* conkey can contain zero (InvalidAttrNumber) if a whole-row Var is used */
+DECLARE_ARRAY_FOREIGN_KEY_OPT((conrelid, conkey), pg_attribute, (attrelid, attnum));
+DECLARE_ARRAY_FOREIGN_KEY((confrelid, confkey), pg_attribute, (attrelid, attnum));
+
+#ifdef EXPOSE_TO_CLIENT_CODE
+
+/* Valid values for contype */
+#define CONSTRAINT_CHECK			'c'
+#define CONSTRAINT_FOREIGN			'f'
+#define CONSTRAINT_NOTNULL			'n'
+#define CONSTRAINT_PRIMARY			'p'
+#define CONSTRAINT_UNIQUE			'u'
+#define CONSTRAINT_TRIGGER			't'
+#define CONSTRAINT_EXCLUSION		'x'
+
+/*
+ * Valid values for confupdtype and confdeltype are the FKCONSTR_ACTION_xxx
+ * constants defined in parsenodes.h.  Valid values for confmatchtype are
+ * the FKCONSTR_MATCH_xxx constants defined in parsenodes.h.
+ */
+
+#endif							/* EXPOSE_TO_CLIENT_CODE */
+
+/*
+ * Identify constraint type for lookup purposes
+ */
+typedef enum ConstraintCategory
+{
+	CONSTRAINT_RELATION,
+	CONSTRAINT_DOMAIN,
+	CONSTRAINT_ASSERTION,		/* for future expansion */
+} ConstraintCategory;
+
+
+extern Oid	CreateConstraintEntry(const char *constraintName,
+								  Oid constraintNamespace,
+								  char constraintType,
+								  bool isDeferrable,
+								  bool isDeferred,
+								  bool isValidated,
+								  Oid parentConstrId,
+								  Oid relId,
+								  const int16 *constraintKey,
+								  int constraintNKeys,
+								  int constraintNTotalKeys,
+								  Oid domainId,
+								  Oid indexRelId,
+								  Oid foreignRelId,
+								  const int16 *foreignKey,
+								  const Oid *pfEqOp,
+								  const Oid *ppEqOp,
+								  const Oid *ffEqOp,
+								  int foreignNKeys,
+								  char foreignUpdateType,
+								  char foreignDeleteType,
+								  const int16 *fkDeleteSetCols,
+								  int numFkDeleteSetCols,
+								  char foreignMatchType,
+								  const Oid *exclOp,
+								  Node *conExpr,
+								  const char *conBin,
+								  bool conIsLocal,
+								  int conInhCount,
+								  bool conNoInherit,
+								  bool is_internal);
+
+extern bool ConstraintNameIsUsed(ConstraintCategory conCat, Oid objId,
+								 const char *conname);
+extern bool ConstraintNameExists(const char *conname, Oid namespaceid);
+extern char *ChooseConstraintName(const char *name1, const char *name2,
+								  const char *label, Oid namespaceid,
+								  List *others);
+
+extern HeapTuple findDomainNotNullConstraint(Oid typid);
+
+extern void RemoveConstraintById(Oid conId);
+extern void RenameConstraintById(Oid conId, const char *newname);
+
+extern void AlterConstraintNamespaces(Oid ownerId, Oid oldNspId,
+									  Oid newNspId, bool isType, ObjectAddresses *objsMoved);
+extern void ConstraintSetParentConstraint(Oid childConstrId,
+										  Oid parentConstrId,
+										  Oid childTableId);
+extern Oid	get_relation_constraint_oid(Oid relid, const char *conname, bool missing_ok);
+extern Bitmapset *get_relation_constraint_attnos(Oid relid, const char *conname,
+												 bool missing_ok, Oid *constraintOid);
+extern Oid	get_domain_constraint_oid(Oid typid, const char *conname, bool missing_ok);
+extern Oid	get_relation_idx_constraint_oid(Oid relationId, Oid indexId);
+
+extern Bitmapset *get_primary_key_attnos(Oid relid, bool deferrableOk,
+										 Oid *constraintOid);
+extern void DeconstructFkConstraintRow(HeapTuple tuple, int *numfks,
+									   AttrNumber *conkey, AttrNumber *confkey,
+									   Oid *pf_eq_oprs, Oid *pp_eq_oprs, Oid *ff_eq_oprs,
+									   int *num_fk_del_set_cols, AttrNumber *fk_del_set_cols);
+
+extern bool check_functional_grouping(Oid relid,
+									  Index varno, Index varlevelsup,
+									  List *grouping_columns,
+									  List **constraintDeps);
+
+#endif							/* PG_CONSTRAINT_H */

data/ext/pg_query/include/postgres/catalog/pg_constraint_d.h

@@ -0,0 +1,74 @@
+/*-------------------------------------------------------------------------
+ *
+ * pg_constraint_d.h
+ *    Macro definitions for pg_constraint
+ *
+ * Portions Copyright (c) 1996-2024, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * NOTES
+ *  ******************************
+ *  *** DO NOT EDIT THIS FILE! ***
+ *  ******************************
+ *
+ *  It has been GENERATED by src/backend/catalog/genbki.pl
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef PG_CONSTRAINT_D_H
+#define PG_CONSTRAINT_D_H
+
+#define ConstraintRelationId 2606
+#define ConstraintNameNspIndexId 2664
+#define ConstraintRelidTypidNameIndexId 2665
+#define ConstraintTypidIndexId 2666
+#define ConstraintOidIndexId 2667
+#define ConstraintParentIndexId 2579
+
+#define Anum_pg_constraint_oid 1
+#define Anum_pg_constraint_conname 2
+#define Anum_pg_constraint_connamespace 3
+#define Anum_pg_constraint_contype 4
+#define Anum_pg_constraint_condeferrable 5
+#define Anum_pg_constraint_condeferred 6
+#define Anum_pg_constraint_convalidated 7
+#define Anum_pg_constraint_conrelid 8
+#define Anum_pg_constraint_contypid 9
+#define Anum_pg_constraint_conindid 10
+#define Anum_pg_constraint_conparentid 11
+#define Anum_pg_constraint_confrelid 12
+#define Anum_pg_constraint_confupdtype 13
+#define Anum_pg_constraint_confdeltype 14
+#define Anum_pg_constraint_confmatchtype 15
+#define Anum_pg_constraint_conislocal 16
+#define Anum_pg_constraint_coninhcount 17
+#define Anum_pg_constraint_connoinherit 18
+#define Anum_pg_constraint_conkey 19
+#define Anum_pg_constraint_confkey 20
+#define Anum_pg_constraint_conpfeqop 21
+#define Anum_pg_constraint_conppeqop 22
+#define Anum_pg_constraint_conffeqop 23
+#define Anum_pg_constraint_confdelsetcols 24
+#define Anum_pg_constraint_conexclop 25
+#define Anum_pg_constraint_conbin 26
+
+#define Natts_pg_constraint 26
+
+
+/* Valid values for contype */
+#define CONSTRAINT_CHECK			'c'
+#define CONSTRAINT_FOREIGN			'f'
+#define CONSTRAINT_NOTNULL			'n'
+#define CONSTRAINT_PRIMARY			'p'
+#define CONSTRAINT_UNIQUE			'u'
+#define CONSTRAINT_TRIGGER			't'
+#define CONSTRAINT_EXCLUSION		'x'
+
+/*
+ * Valid values for confupdtype and confdeltype are the FKCONSTR_ACTION_xxx
+ * constants defined in parsenodes.h.  Valid values for confmatchtype are
+ * the FKCONSTR_MATCH_xxx constants defined in parsenodes.h.
+ */
+
+
+#endif							/* PG_CONSTRAINT_D_H */

data/ext/pg_query/include/postgres/catalog/pg_control.h

@@ -0,0 +1,260 @@
+/*-------------------------------------------------------------------------
+ *
+ * pg_control.h
+ *	  The system control file "pg_control" is not a heap relation.
+ *	  However, we define it here so that the format is documented.
+ *
+ *
+ * Portions Copyright (c) 1996-2024, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/catalog/pg_control.h
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef PG_CONTROL_H
+#define PG_CONTROL_H
+
+#include "access/transam.h"
+#include "access/xlogdefs.h"
+#include "pgtime.h"				/* for pg_time_t */
+#include "port/pg_crc32c.h"
+
+
+/* Version identifier for this pg_control format */
+#define PG_CONTROL_VERSION	1700
+
+/* Nonce key length, see below */
+#define MOCK_AUTH_NONCE_LEN		32
+
+/*
+ * Body of CheckPoint XLOG records.  This is declared here because we keep
+ * a copy of the latest one in pg_control for possible disaster recovery.
+ * Changing this struct requires a PG_CONTROL_VERSION bump.
+ */
+typedef struct CheckPoint
+{
+	XLogRecPtr	redo;			/* next RecPtr available when we began to
+								 * create CheckPoint (i.e. REDO start point) */
+	TimeLineID	ThisTimeLineID; /* current TLI */
+	TimeLineID	PrevTimeLineID; /* previous TLI, if this record begins a new
+								 * timeline (equals ThisTimeLineID otherwise) */
+	bool		fullPageWrites; /* current full_page_writes */
+	int			wal_level;		/* current wal_level */
+	FullTransactionId nextXid;	/* next free transaction ID */
+	Oid			nextOid;		/* next free OID */
+	MultiXactId nextMulti;		/* next free MultiXactId */
+	MultiXactOffset nextMultiOffset;	/* next free MultiXact offset */
+	TransactionId oldestXid;	/* cluster-wide minimum datfrozenxid */
+	Oid			oldestXidDB;	/* database with minimum datfrozenxid */
+	MultiXactId oldestMulti;	/* cluster-wide minimum datminmxid */
+	Oid			oldestMultiDB;	/* database with minimum datminmxid */
+	pg_time_t	time;			/* time stamp of checkpoint */
+	TransactionId oldestCommitTsXid;	/* oldest Xid with valid commit
+										 * timestamp */
+	TransactionId newestCommitTsXid;	/* newest Xid with valid commit
+										 * timestamp */
+
+	/*
+	 * Oldest XID still running. This is only needed to initialize hot standby
+	 * mode from an online checkpoint, so we only bother calculating this for
+	 * online checkpoints and only when wal_level is replica. Otherwise it's
+	 * set to InvalidTransactionId.
+	 */
+	TransactionId oldestActiveXid;
+} CheckPoint;
+
+/* XLOG info values for XLOG rmgr */
+#define XLOG_CHECKPOINT_SHUTDOWN		0x00
+#define XLOG_CHECKPOINT_ONLINE			0x10
+#define XLOG_NOOP						0x20
+#define XLOG_NEXTOID					0x30
+#define XLOG_SWITCH						0x40
+#define XLOG_BACKUP_END					0x50
+#define XLOG_PARAMETER_CHANGE			0x60
+#define XLOG_RESTORE_POINT				0x70
+#define XLOG_FPW_CHANGE					0x80
+#define XLOG_END_OF_RECOVERY			0x90
+#define XLOG_FPI_FOR_HINT				0xA0
+#define XLOG_FPI						0xB0
+/* 0xC0 is used in Postgres 9.5-11 */
+#define XLOG_OVERWRITE_CONTRECORD		0xD0
+#define XLOG_CHECKPOINT_REDO			0xE0
+
+
+/*
+ * System status indicator.  Note this is stored in pg_control; if you change
+ * it, you must bump PG_CONTROL_VERSION
+ */
+typedef enum DBState
+{
+	DB_STARTUP = 0,
+	DB_SHUTDOWNED,
+	DB_SHUTDOWNED_IN_RECOVERY,
+	DB_SHUTDOWNING,
+	DB_IN_CRASH_RECOVERY,
+	DB_IN_ARCHIVE_RECOVERY,
+	DB_IN_PRODUCTION,
+} DBState;
+
+/*
+ * Contents of pg_control.
+ */
+
+typedef struct ControlFileData
+{
+	/*
+	 * Unique system identifier --- to ensure we match up xlog files with the
+	 * installation that produced them.
+	 */
+	uint64		system_identifier;
+
+	/*
+	 * Version identifier information.  Keep these fields at the same offset,
+	 * especially pg_control_version; they won't be real useful if they move
+	 * around.  (For historical reasons they must be 8 bytes into the file
+	 * rather than immediately at the front.)
+	 *
+	 * pg_control_version identifies the format of pg_control itself.
+	 * catalog_version_no identifies the format of the system catalogs.
+	 *
+	 * There are additional version identifiers in individual files; for
+	 * example, WAL logs contain per-page magic numbers that can serve as
+	 * version cues for the WAL log.
+	 */
+	uint32		pg_control_version; /* PG_CONTROL_VERSION */
+	uint32		catalog_version_no; /* see catversion.h */
+
+	/*
+	 * System status data
+	 */
+	DBState		state;			/* see enum above */
+	pg_time_t	time;			/* time stamp of last pg_control update */
+	XLogRecPtr	checkPoint;		/* last check point record ptr */
+
+	CheckPoint	checkPointCopy; /* copy of last check point record */
+
+	XLogRecPtr	unloggedLSN;	/* current fake LSN value, for unlogged rels */
+
+	/*
+	 * These two values determine the minimum point we must recover up to
+	 * before starting up:
+	 *
+	 * minRecoveryPoint is updated to the latest replayed LSN whenever we
+	 * flush a data change during archive recovery. That guards against
+	 * starting archive recovery, aborting it, and restarting with an earlier
+	 * stop location. If we've already flushed data changes from WAL record X
+	 * to disk, we mustn't start up until we reach X again. Zero when not
+	 * doing archive recovery.
+	 *
+	 * backupStartPoint is the redo pointer of the backup start checkpoint, if
+	 * we are recovering from an online backup and haven't reached the end of
+	 * backup yet. It is reset to zero when the end of backup is reached, and
+	 * we mustn't start up before that. A boolean would suffice otherwise, but
+	 * we use the redo pointer as a cross-check when we see an end-of-backup
+	 * record, to make sure the end-of-backup record corresponds the base
+	 * backup we're recovering from.
+	 *
+	 * backupEndPoint is the backup end location, if we are recovering from an
+	 * online backup which was taken from the standby and haven't reached the
+	 * end of backup yet. It is initialized to the minimum recovery point in
+	 * pg_control which was backed up last. It is reset to zero when the end
+	 * of backup is reached, and we mustn't start up before that.
+	 *
+	 * If backupEndRequired is true, we know for sure that we're restoring
+	 * from a backup, and must see a backup-end record before we can safely
+	 * start up.
+	 */
+	XLogRecPtr	minRecoveryPoint;
+	TimeLineID	minRecoveryPointTLI;
+	XLogRecPtr	backupStartPoint;
+	XLogRecPtr	backupEndPoint;
+	bool		backupEndRequired;
+
+	/*
+	 * Parameter settings that determine if the WAL can be used for archival
+	 * or hot standby.
+	 */
+	int			wal_level;
+	bool		wal_log_hints;
+	int			MaxConnections;
+	int			max_worker_processes;
+	int			max_wal_senders;
+	int			max_prepared_xacts;
+	int			max_locks_per_xact;
+	bool		track_commit_timestamp;
+
+	/*
+	 * This data is used to check for hardware-architecture compatibility of
+	 * the database and the backend executable.  We need not check endianness
+	 * explicitly, since the pg_control version will surely look wrong to a
+	 * machine of different endianness, but we do need to worry about MAXALIGN
+	 * and floating-point format.  (Note: storage layout nominally also
+	 * depends on SHORTALIGN and INTALIGN, but in practice these are the same
+	 * on all architectures of interest.)
+	 *
+	 * Testing just one double value is not a very bulletproof test for
+	 * floating-point compatibility, but it will catch most cases.
+	 */
+	uint32		maxAlign;		/* alignment requirement for tuples */
+	double		floatFormat;	/* constant 1234567.0 */
+#define FLOATFORMAT_VALUE	1234567.0
+
+	/*
+	 * This data is used to make sure that configuration of this database is
+	 * compatible with the backend executable.
+	 */
+	uint32		blcksz;			/* data block size for this DB */
+	uint32		relseg_size;	/* blocks per segment of large relation */
+
+	uint32		xlog_blcksz;	/* block size within WAL files */
+	uint32		xlog_seg_size;	/* size of each WAL segment */
+
+	uint32		nameDataLen;	/* catalog name field width */
+	uint32		indexMaxKeys;	/* max number of columns in an index */
+
+	uint32		toast_max_chunk_size;	/* chunk size in TOAST tables */
+	uint32		loblksize;		/* chunk size in pg_largeobject */
+
+	bool		float8ByVal;	/* float8, int8, etc pass-by-value? */
+
+	/* Are data pages protected by checksums? Zero if no checksum version */
+	uint32		data_checksum_version;
+
+	/*
+	 * Random nonce, used in authentication requests that need to proceed
+	 * based on values that are cluster-unique, like a SASL exchange that
+	 * failed at an early stage.
+	 */
+	char		mock_authentication_nonce[MOCK_AUTH_NONCE_LEN];
+
+	/* CRC of all above ... MUST BE LAST! */
+	pg_crc32c	crc;
+} ControlFileData;
+
+/*
+ * Maximum safe value of sizeof(ControlFileData).  For reliability's sake,
+ * it's critical that pg_control updates be atomic writes.  That generally
+ * means the active data can't be more than one disk sector, which is 512
+ * bytes on common hardware.  Be very careful about raising this limit.
+ */
+#define PG_CONTROL_MAX_SAFE_SIZE	512
+
+/*
+ * Physical size of the pg_control file.  Note that this is considerably
+ * bigger than the actually used size (ie, sizeof(ControlFileData)).
+ * The idea is to keep the physical size constant independent of format
+ * changes, so that ReadControlFile will deliver a suitable wrong-version
+ * message instead of a read error if it's looking at an incompatible file.
+ */
+#define PG_CONTROL_FILE_SIZE		8192
+
+/*
+ * Ensure that the size of the pg_control data structure is sane.
+ */
+StaticAssertDecl(sizeof(ControlFileData) <= PG_CONTROL_MAX_SAFE_SIZE,
+				 "pg_control is too large for atomic disk writes");
+StaticAssertDecl(sizeof(ControlFileData) <= PG_CONTROL_FILE_SIZE,
+				 "sizeof(ControlFileData) exceeds PG_CONTROL_FILE_SIZE");
+
+#endif							/* PG_CONTROL_H */

data/ext/pg_query/include/postgres/catalog/pg_conversion.h

@@ -0,0 +1,79 @@
+/*-------------------------------------------------------------------------
+ *
+ * pg_conversion.h
+ *	  definition of the "conversion" system catalog (pg_conversion)
+ *
+ * Portions Copyright (c) 1996-2024, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/catalog/pg_conversion.h
+ *
+ * NOTES
+ *	  The Catalog.pm module reads this file and derives schema
+ *	  information.
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef PG_CONVERSION_H
+#define PG_CONVERSION_H
+
+#include "catalog/genbki.h"
+#include "catalog/objectaddress.h"
+#include "catalog/pg_conversion_d.h"
+
+/* ----------------
+ *		pg_conversion definition.  cpp turns this into
+ *		typedef struct FormData_pg_conversion
+ * ----------------
+ */
+CATALOG(pg_conversion,2607,ConversionRelationId)
+{
+	/* oid */
+	Oid			oid;
+
+	/* name of the conversion */
+	NameData	conname;
+
+	/* namespace that the conversion belongs to */
+	Oid			connamespace BKI_DEFAULT(pg_catalog) BKI_LOOKUP(pg_namespace);
+
+	/* owner of the conversion */
+	Oid			conowner BKI_DEFAULT(POSTGRES) BKI_LOOKUP(pg_authid);
+
+	/* FOR encoding id */
+	int32		conforencoding BKI_LOOKUP(encoding);
+
+	/* TO encoding id */
+	int32		contoencoding BKI_LOOKUP(encoding);
+
+	/* OID of the conversion proc */
+	regproc		conproc BKI_LOOKUP(pg_proc);
+
+	/* true if this is a default conversion */
+	bool		condefault BKI_DEFAULT(t);
+} FormData_pg_conversion;
+
+/* ----------------
+ *		Form_pg_conversion corresponds to a pointer to a tuple with
+ *		the format of pg_conversion relation.
+ * ----------------
+ */
+typedef FormData_pg_conversion *Form_pg_conversion;
+
+DECLARE_UNIQUE_INDEX(pg_conversion_default_index, 2668, ConversionDefaultIndexId, pg_conversion, btree(connamespace oid_ops, conforencoding int4_ops, contoencoding int4_ops, oid oid_ops));
+DECLARE_UNIQUE_INDEX(pg_conversion_name_nsp_index, 2669, ConversionNameNspIndexId, pg_conversion, btree(conname name_ops, connamespace oid_ops));
+DECLARE_UNIQUE_INDEX_PKEY(pg_conversion_oid_index, 2670, ConversionOidIndexId, pg_conversion, btree(oid oid_ops));
+
+MAKE_SYSCACHE(CONDEFAULT, pg_conversion_default_index, 8);
+MAKE_SYSCACHE(CONNAMENSP, pg_conversion_name_nsp_index, 8);
+MAKE_SYSCACHE(CONVOID, pg_conversion_oid_index, 8);
+
+
+extern ObjectAddress ConversionCreate(const char *conname, Oid connamespace,
+									  Oid conowner,
+									  int32 conforencoding, int32 contoencoding,
+									  Oid conproc, bool def);
+extern Oid	FindDefaultConversion(Oid name_space, int32 for_encoding,
+								  int32 to_encoding);
+
+#endif							/* PG_CONVERSION_H */