pg_query 2.2.0 → 6.1.0

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

@@ -0,0 +1,47 @@
+/*-------------------------------------------------------------------------
+ *
+ * catalog.h
+ *	  prototypes for functions in backend/catalog/catalog.c
+ *
+ *
+ * Portions Copyright (c) 1996-2024, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/catalog/catalog.h
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef CATALOG_H
+#define CATALOG_H
+
+#include "catalog/pg_class.h"
+#include "utils/relcache.h"
+
+
+extern bool IsSystemRelation(Relation relation);
+extern bool IsToastRelation(Relation relation);
+extern bool IsCatalogRelation(Relation relation);
+extern bool IsInplaceUpdateRelation(Relation relation);
+
+extern bool IsSystemClass(Oid relid, Form_pg_class reltuple);
+extern bool IsToastClass(Form_pg_class reltuple);
+
+extern bool IsCatalogRelationOid(Oid relid);
+extern bool IsInplaceUpdateOid(Oid relid);
+
+extern bool IsCatalogNamespace(Oid namespaceId);
+extern bool IsToastNamespace(Oid namespaceId);
+
+extern bool IsReservedName(const char *name);
+
+extern bool IsSharedRelation(Oid relationId);
+
+extern bool IsPinnedObject(Oid classId, Oid objectId);
+
+extern Oid	GetNewOidWithIndex(Relation relation, Oid indexId,
+							   AttrNumber oidcolumn);
+extern RelFileNumber GetNewRelFileNumber(Oid reltablespace,
+										 Relation pg_class,
+										 char relpersistence);
+
+#endif							/* CATALOG_H */

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

@@ -0,0 +1,62 @@
+/*-------------------------------------------------------------------------
+ *
+ * catversion.h
+ *	  "Catalog version number" for PostgreSQL.
+ *
+ * The catalog version number is used to flag incompatible changes in
+ * the PostgreSQL system catalogs.  Whenever anyone changes the format of
+ * a system catalog relation, or adds, deletes, or modifies standard
+ * catalog entries in such a way that an updated backend wouldn't work
+ * with an old database (or vice versa), the catalog version number
+ * should be changed.  The version number stored in pg_control by initdb
+ * is checked against the version number compiled into the backend at
+ * startup time, so that a backend can refuse to run in an incompatible
+ * database.
+ *
+ * The point of this feature is to provide a finer grain of compatibility
+ * checking than is possible from looking at the major version number
+ * stored in PG_VERSION.  It shouldn't matter to end users, but during
+ * development cycles we usually make quite a few incompatible changes
+ * to the contents of the system catalogs, and we don't want to bump the
+ * major version number for each one.  What we can do instead is bump
+ * this internal version number.  This should save some grief for
+ * developers who might otherwise waste time tracking down "bugs" that
+ * are really just code-vs-database incompatibilities.
+ *
+ * The rule for developers is: if you commit a change that requires
+ * an initdb, you should update the catalog version number (as well as
+ * notifying the pgsql-hackers mailing list, which has been the
+ * informal practice for a long time).
+ *
+ * The catalog version number is placed here since modifying files in
+ * include/catalog is the most common kind of initdb-forcing change.
+ * But it could be used to protect any kind of incompatible change in
+ * database contents or layout, such as altering tuple headers.
+ * Another common reason for a catversion update is a change in parsetree
+ * external representation, since serialized parsetrees appear in stored
+ * rules and new-style SQL functions.  Almost any change in primnodes.h or
+ * parsenodes.h will warrant a catversion update.
+ *
+ *
+ * Portions Copyright (c) 1996-2024, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/catalog/catversion.h
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef CATVERSION_H
+#define CATVERSION_H
+
+/*
+ * We could use anything we wanted for version numbers, but I recommend
+ * following the "YYYYMMDDN" style often used for DNS zone serial numbers.
+ * YYYYMMDD are the date of the change, and N is the number of the change
+ * on that day.  (Hopefully we'll never commit ten independent sets of
+ * catalog changes on the same day...)
+ */
+
+/*							yyyymmddN */
+#define CATALOG_VERSION_NO	202406281
+
+#endif

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

@@ -0,0 +1,228 @@
+/*-------------------------------------------------------------------------
+ *
+ * dependency.h
+ *	  Routines to support inter-object dependencies.
+ *
+ *
+ * Portions Copyright (c) 1996-2024, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/catalog/dependency.h
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef DEPENDENCY_H
+#define DEPENDENCY_H
+
+#include "catalog/objectaddress.h"
+
+
+/*
+ * Precise semantics of a dependency relationship are specified by the
+ * DependencyType code (which is stored in a "char" field in pg_depend,
+ * so we assign ASCII-code values to the enumeration members).
+ *
+ * In all cases, a dependency relationship indicates that the referenced
+ * object may not be dropped without also dropping the dependent object.
+ * However, there are several subflavors; see the description of pg_depend
+ * in catalogs.sgml for details.
+ */
+
+typedef enum DependencyType
+{
+	DEPENDENCY_NORMAL = 'n',
+	DEPENDENCY_AUTO = 'a',
+	DEPENDENCY_INTERNAL = 'i',
+	DEPENDENCY_PARTITION_PRI = 'P',
+	DEPENDENCY_PARTITION_SEC = 'S',
+	DEPENDENCY_EXTENSION = 'e',
+	DEPENDENCY_AUTO_EXTENSION = 'x',
+} DependencyType;
+
+/*
+ * There is also a SharedDependencyType enum type that determines the exact
+ * semantics of an entry in pg_shdepend.  Just like regular dependency entries,
+ * any pg_shdepend entry means that the referenced object cannot be dropped
+ * unless the dependent object is dropped at the same time.  There are some
+ * additional rules however:
+ *
+ * (a) a SHARED_DEPENDENCY_OWNER entry means that the referenced object is
+ * the role owning the dependent object.  The referenced object must be
+ * a pg_authid entry.
+ *
+ * (b) a SHARED_DEPENDENCY_ACL entry means that the referenced object is
+ * a role mentioned in the ACL field of the dependent object.  The referenced
+ * object must be a pg_authid entry.  (SHARED_DEPENDENCY_ACL entries are not
+ * created for the owner of an object; hence two objects may be linked by
+ * one or the other, but not both, of these dependency types.)
+ *
+ * (c) a SHARED_DEPENDENCY_INITACL entry means that the referenced object is
+ * a role mentioned in a pg_init_privs entry for the dependent object.
+ * The referenced object must be a pg_authid entry.  (Unlike the case for
+ * SHARED_DEPENDENCY_ACL, we make an entry for such a role whether or not
+ * it is the object's owner.)
+ *
+ * (d) a SHARED_DEPENDENCY_POLICY entry means that the referenced object is
+ * a role mentioned in a policy object.  The referenced object must be a
+ * pg_authid entry.
+ *
+ * (e) a SHARED_DEPENDENCY_TABLESPACE entry means that the referenced
+ * object is a tablespace mentioned in a relation without storage.  The
+ * referenced object must be a pg_tablespace entry.  (Relations that have
+ * storage don't need this: they are protected by the existence of a physical
+ * file in the tablespace.)
+ *
+ * SHARED_DEPENDENCY_INVALID is a value used as a parameter in internal
+ * routines, and is not valid in the catalog itself.
+ */
+typedef enum SharedDependencyType
+{
+	SHARED_DEPENDENCY_OWNER = 'o',
+	SHARED_DEPENDENCY_ACL = 'a',
+	SHARED_DEPENDENCY_INITACL = 'i',
+	SHARED_DEPENDENCY_POLICY = 'r',
+	SHARED_DEPENDENCY_TABLESPACE = 't',
+	SHARED_DEPENDENCY_INVALID = 0,
+} SharedDependencyType;
+
+/* expansible list of ObjectAddresses (private in dependency.c) */
+typedef struct ObjectAddresses ObjectAddresses;
+
+/* flag bits for performDeletion/performMultipleDeletions: */
+#define PERFORM_DELETION_INTERNAL			0x0001	/* internal action */
+#define PERFORM_DELETION_CONCURRENTLY		0x0002	/* concurrent drop */
+#define PERFORM_DELETION_QUIETLY			0x0004	/* suppress notices */
+#define PERFORM_DELETION_SKIP_ORIGINAL		0x0008	/* keep original obj */
+#define PERFORM_DELETION_SKIP_EXTENSIONS	0x0010	/* keep extensions */
+#define PERFORM_DELETION_CONCURRENT_LOCK	0x0020	/* normal drop with
+													 * concurrent lock mode */
+
+
+/* in dependency.c */
+
+extern void AcquireDeletionLock(const ObjectAddress *object, int flags);
+
+extern void ReleaseDeletionLock(const ObjectAddress *object);
+
+extern void performDeletion(const ObjectAddress *object,
+							DropBehavior behavior, int flags);
+
+extern void performMultipleDeletions(const ObjectAddresses *objects,
+									 DropBehavior behavior, int flags);
+
+extern void recordDependencyOnExpr(const ObjectAddress *depender,
+								   Node *expr, List *rtable,
+								   DependencyType behavior);
+
+extern void recordDependencyOnSingleRelExpr(const ObjectAddress *depender,
+											Node *expr, Oid relId,
+											DependencyType behavior,
+											DependencyType self_behavior,
+											bool reverse_self);
+
+extern ObjectAddresses *new_object_addresses(void);
+
+extern void add_exact_object_address(const ObjectAddress *object,
+									 ObjectAddresses *addrs);
+
+extern bool object_address_present(const ObjectAddress *object,
+								   const ObjectAddresses *addrs);
+
+extern void record_object_address_dependencies(const ObjectAddress *depender,
+											   ObjectAddresses *referenced,
+											   DependencyType behavior);
+
+extern void sort_object_addresses(ObjectAddresses *addrs);
+
+extern void free_object_addresses(ObjectAddresses *addrs);
+
+/* in pg_depend.c */
+
+extern void recordDependencyOn(const ObjectAddress *depender,
+							   const ObjectAddress *referenced,
+							   DependencyType behavior);
+
+extern void recordMultipleDependencies(const ObjectAddress *depender,
+									   const ObjectAddress *referenced,
+									   int nreferenced,
+									   DependencyType behavior);
+
+extern void recordDependencyOnCurrentExtension(const ObjectAddress *object,
+											   bool isReplace);
+
+extern void checkMembershipInCurrentExtension(const ObjectAddress *object);
+
+extern long deleteDependencyRecordsFor(Oid classId, Oid objectId,
+									   bool skipExtensionDeps);
+
+extern long deleteDependencyRecordsForClass(Oid classId, Oid objectId,
+											Oid refclassId, char deptype);
+
+extern long deleteDependencyRecordsForSpecific(Oid classId, Oid objectId,
+											   char deptype,
+											   Oid refclassId, Oid refobjectId);
+
+extern long changeDependencyFor(Oid classId, Oid objectId,
+								Oid refClassId, Oid oldRefObjectId,
+								Oid newRefObjectId);
+
+extern long changeDependenciesOf(Oid classId, Oid oldObjectId,
+								 Oid newObjectId);
+
+extern long changeDependenciesOn(Oid refClassId, Oid oldRefObjectId,
+								 Oid newRefObjectId);
+
+extern Oid	getExtensionOfObject(Oid classId, Oid objectId);
+extern List *getAutoExtensionsOfObject(Oid classId, Oid objectId);
+
+extern bool sequenceIsOwned(Oid seqId, char deptype, Oid *tableId, int32 *colId);
+extern List *getOwnedSequences(Oid relid);
+extern Oid	getIdentitySequence(Relation rel, AttrNumber attnum, bool missing_ok);
+
+extern Oid	get_index_constraint(Oid indexId);
+
+extern List *get_index_ref_constraints(Oid indexId);
+
+/* in pg_shdepend.c */
+
+extern void recordSharedDependencyOn(ObjectAddress *depender,
+									 ObjectAddress *referenced,
+									 SharedDependencyType deptype);
+
+extern void deleteSharedDependencyRecordsFor(Oid classId, Oid objectId,
+											 int32 objectSubId);
+
+extern void recordDependencyOnOwner(Oid classId, Oid objectId, Oid owner);
+
+extern void changeDependencyOnOwner(Oid classId, Oid objectId,
+									Oid newOwnerId);
+
+extern void recordDependencyOnTablespace(Oid classId, Oid objectId,
+										 Oid tablespace);
+
+extern void changeDependencyOnTablespace(Oid classId, Oid objectId,
+										 Oid newTablespaceId);
+
+extern void updateAclDependencies(Oid classId, Oid objectId, int32 objsubId,
+								  Oid ownerId,
+								  int noldmembers, Oid *oldmembers,
+								  int nnewmembers, Oid *newmembers);
+
+extern void updateInitAclDependencies(Oid classId, Oid objectId, int32 objsubId,
+									  int noldmembers, Oid *oldmembers,
+									  int nnewmembers, Oid *newmembers);
+
+extern bool checkSharedDependencies(Oid classId, Oid objectId,
+									char **detail_msg, char **detail_log_msg);
+
+extern void shdepLockAndCheckObject(Oid classId, Oid objectId);
+
+extern void copyTemplateDependencies(Oid templateDbId, Oid newDbId);
+
+extern void dropDatabaseDependencies(Oid databaseId);
+
+extern void shdepDropOwned(List *roleids, DropBehavior behavior);
+
+extern void shdepReassignOwned(List *roleids, Oid newrole);
+
+#endif							/* DEPENDENCY_H */

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

@@ -0,0 +1,149 @@
+/*-------------------------------------------------------------------------
+ *
+ * genbki.h
+ *	  Required include file for all POSTGRES catalog header files
+ *
+ * genbki.h defines CATALOG(), BKI_BOOTSTRAP and related macros
+ * so that the catalog header files can be read by the C compiler.
+ * (These same words are recognized by genbki.pl to build the BKI
+ * bootstrap file from these header files.)
+ *
+ *
+ * Portions Copyright (c) 1996-2024, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/catalog/genbki.h
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef GENBKI_H
+#define GENBKI_H
+
+/* Introduces a catalog's structure definition */
+#define CATALOG(name,oid,oidmacro)	typedef struct CppConcat(FormData_,name)
+
+/* Options that may appear after CATALOG (on the same line) */
+#define BKI_BOOTSTRAP
+#define BKI_SHARED_RELATION
+#define BKI_ROWTYPE_OID(oid,oidmacro)
+#define BKI_SCHEMA_MACRO
+
+/* Options that may appear after an attribute (on the same line) */
+#define BKI_FORCE_NULL
+#define BKI_FORCE_NOT_NULL
+/* Specifies a default value for a catalog field */
+#define BKI_DEFAULT(value)
+/* Specifies a default value for auto-generated array types */
+#define BKI_ARRAY_DEFAULT(value)
+/*
+ * Indicates that the attribute contains OIDs referencing the named catalog;
+ * can be applied to columns of oid, regproc, oid[], or oidvector type.
+ * genbki.pl uses this to know how to perform name lookups in the initial
+ * data (if any), and it also feeds into regression-test validity checks.
+ * The _OPT suffix indicates that values can be zero instead of
+ * a valid OID reference.
+ */
+#define BKI_LOOKUP(catalog)
+#define BKI_LOOKUP_OPT(catalog)
+
+/*
+ * These lines are processed by genbki.pl to create the statements
+ * the bootstrap parser will turn into BootstrapToastTable commands.
+ * Each line specifies the system catalog that needs a toast table,
+ * the OID to assign to the toast table, and the OID to assign to the
+ * toast table's index.  The reason we hard-wire these OIDs is that we
+ * need stable OIDs for shared relations, and that includes toast tables
+ * of shared relations.
+ *
+ * The DECLARE_TOAST_WITH_MACRO variant is used when C macros are needed
+ * for the toast table/index OIDs (usually only for shared catalogs).
+ *
+ * The macro definitions are just to keep the C compiler from spitting up.
+ */
+#define DECLARE_TOAST(name,toastoid,indexoid) extern int no_such_variable
+#define DECLARE_TOAST_WITH_MACRO(name,toastoid,indexoid,toastoidmacro,indexoidmacro) extern int no_such_variable
+
+/*
+ * These lines are processed by genbki.pl to create the statements
+ * the bootstrap parser will turn into DefineIndex calls.
+ *
+ * The keyword is DECLARE_INDEX or DECLARE_UNIQUE_INDEX or
+ * DECLARE_UNIQUE_INDEX_PKEY.  ("PKEY" marks the index as being the catalog's
+ * primary key; currently this is only cosmetically different from a regular
+ * unique index.  By convention, we usually make a catalog's OID column its
+ * pkey, if it has one.)
+ *
+ * The first two arguments are the index's name and OID.  The third argument
+ * is the name of a #define to generate for its OID.  References to the index
+ * in the C code should always use these #defines, not the actual index name
+ * (much less the numeric OID).  The fourth argument is the table name.  The
+ * rest is much like a standard 'create index' SQL command.
+ *
+ * The macro definitions are just to keep the C compiler from spitting up.
+ */
+#define DECLARE_INDEX(name,oid,oidmacro,tblname,decl) extern int no_such_variable
+#define DECLARE_UNIQUE_INDEX(name,oid,oidmacro,tblname,decl) extern int no_such_variable
+#define DECLARE_UNIQUE_INDEX_PKEY(name,oid,oidmacro,tblname,decl) extern int no_such_variable
+
+/*
+ * These lines inform genbki.pl about manually-assigned OIDs that do not
+ * correspond to any entry in the catalog *.dat files, but should be subject
+ * to uniqueness verification and renumber_oids.pl renumbering.  A C macro
+ * to #define the given name is emitted into the corresponding *_d.h file.
+ */
+#define DECLARE_OID_DEFINING_MACRO(name,oid) extern int no_such_variable
+
+/*
+ * These lines are processed by genbki.pl to create a table for use
+ * by the pg_get_catalog_foreign_keys() function.  We do not have any
+ * mechanism that actually enforces foreign-key relationships in the
+ * system catalogs, but it is still useful to record the intended
+ * relationships in a machine-readable form.
+ *
+ * The keyword is DECLARE_FOREIGN_KEY[_OPT] or DECLARE_ARRAY_FOREIGN_KEY[_OPT].
+ * The first argument is a parenthesized list of the referencing columns;
+ * the second, the name of the referenced table; the third, a parenthesized
+ * list of the referenced columns.  Use of the ARRAY macros means that the
+ * last referencing column is an array, each of whose elements is supposed
+ * to match some entry in the last referenced column.  Use of the OPT suffix
+ * indicates that the referencing column(s) can be zero instead of a valid
+ * reference.
+ *
+ * Columns that are marked with a BKI_LOOKUP rule do not need an explicit
+ * DECLARE_FOREIGN_KEY macro, as genbki.pl can infer the FK relationship
+ * from that.  Thus, these macros are only needed in special cases.
+ *
+ * The macro definitions are just to keep the C compiler from spitting up.
+ */
+#define DECLARE_FOREIGN_KEY(cols,reftbl,refcols) extern int no_such_variable
+#define DECLARE_FOREIGN_KEY_OPT(cols,reftbl,refcols) extern int no_such_variable
+#define DECLARE_ARRAY_FOREIGN_KEY(cols,reftbl,refcols) extern int no_such_variable
+#define DECLARE_ARRAY_FOREIGN_KEY_OPT(cols,reftbl,refcols) extern int no_such_variable
+
+/*
+ * Create a syscache with the given name, index, and bucket size.  See
+ * syscache.c.
+ */
+#define MAKE_SYSCACHE(name,idxname,nbuckets) extern int no_such_variable
+
+/* The following are never defined; they are here only for documentation. */
+
+/*
+ * Variable-length catalog fields (except possibly the first not nullable one)
+ * should not be visible in C structures, so they are made invisible by #ifdefs
+ * of an undefined symbol.  See also the BOOTCOL_NULL_AUTO code in bootstrap.c
+ * for how this is handled.
+ */
+#undef CATALOG_VARLEN
+
+/*
+ * There is code in some catalog headers that needs to be visible to clients,
+ * but we don't want clients to include the full header because of safety
+ * issues with other code in the header.  To handle that, surround code that
+ * should be visible to clients with "#ifdef EXPOSE_TO_CLIENT_CODE".  That
+ * instructs genbki.pl to copy the section when generating the corresponding
+ * "_d" header, which can be included by both client and backend code.
+ */
+#undef EXPOSE_TO_CLIENT_CODE
+
+#endif							/* GENBKI_H */