pg_query 1.1.0 → 2.0.1

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

@@ -0,0 +1,197 @@
+/*
+ * objectaccess.h
+ *
+ *		Object access hooks.
+ *
+ * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ */
+
+#ifndef OBJECTACCESS_H
+#define OBJECTACCESS_H
+
+/*
+ * Object access hooks are intended to be called just before or just after
+ * performing certain actions on a SQL object.  This is intended as
+ * infrastructure for security or logging plugins.
+ *
+ * OAT_POST_CREATE should be invoked just after the object is created.
+ * Typically, this is done after inserting the primary catalog records and
+ * associated dependencies.
+ *
+ * OAT_DROP should be invoked just before deletion of objects; typically
+ * deleteOneObject(). Its arguments are packed within ObjectAccessDrop.
+ *
+ * OAT_POST_ALTER should be invoked just after the object is altered,
+ * but before the command counter is incremented.  An extension using the
+ * hook can use a current MVCC snapshot to get the old version of the tuple,
+ * and can use SnapshotSelf to get the new version of the tuple.
+ *
+ * OAT_NAMESPACE_SEARCH should be invoked prior to object name lookup under
+ * a particular namespace. This event is equivalent to usage permission
+ * on a schema under the default access control mechanism.
+ *
+ * OAT_FUNCTION_EXECUTE should be invoked prior to function execution.
+ * This event is almost equivalent to execute permission on functions,
+ * except for the case when execute permission is checked during object
+ * creation or altering, because OAT_POST_CREATE or OAT_POST_ALTER are
+ * sufficient for extensions to track these kind of checks.
+ *
+ * OAT_TRUNCATE should be invoked just before truncation of objects. This
+ * event is equivalent to truncate permission on a relation under the
+ * default access control mechanism.
+ *
+ * Other types may be added in the future.
+ */
+typedef enum ObjectAccessType
+{
+	OAT_POST_CREATE,
+	OAT_DROP,
+	OAT_POST_ALTER,
+	OAT_NAMESPACE_SEARCH,
+	OAT_FUNCTION_EXECUTE,
+	OAT_TRUNCATE
+} ObjectAccessType;
+
+/*
+ * Arguments of OAT_POST_CREATE event
+ */
+typedef struct
+{
+	/*
+	 * This flag informs extensions whether the context of this creation is
+	 * invoked by user's operations, or not. E.g, it shall be dealt as
+	 * internal stuff on toast tables or indexes due to type changes.
+	 */
+	bool		is_internal;
+} ObjectAccessPostCreate;
+
+/*
+ * Arguments of OAT_DROP event
+ */
+typedef struct
+{
+	/*
+	 * Flags to inform extensions the context of this deletion. Also see
+	 * PERFORM_DELETION_* in dependency.h
+	 */
+	int			dropflags;
+} ObjectAccessDrop;
+
+/*
+ * Arguments of OAT_POST_ALTER event
+ */
+typedef struct
+{
+	/*
+	 * This identifier is used when system catalog takes two IDs to identify a
+	 * particular tuple of the catalog. It is only used when the caller want
+	 * to identify an entry of pg_inherits, pg_db_role_setting or
+	 * pg_user_mapping. Elsewhere, InvalidOid should be set.
+	 */
+	Oid			auxiliary_id;
+
+	/*
+	 * If this flag is set, the user hasn't requested that the object be
+	 * altered, but we're doing it anyway for some internal reason.
+	 * Permissions-checking hooks may want to skip checks if, say, we're alter
+	 * the constraints of a temporary heap during CLUSTER.
+	 */
+	bool		is_internal;
+} ObjectAccessPostAlter;
+
+/*
+ * Arguments of OAT_NAMESPACE_SEARCH
+ */
+typedef struct
+{
+	/*
+	 * If true, hook should report an error when permission to search this
+	 * schema is denied.
+	 */
+	bool		ereport_on_violation;
+
+	/*
+	 * This is, in essence, an out parameter.  Core code should initialize
+	 * this to true, and any extension that wants to deny access should reset
+	 * it to false.  But an extension should be careful never to store a true
+	 * value here, so that in case there are multiple extensions access is
+	 * only allowed if all extensions agree.
+	 */
+	bool		result;
+} ObjectAccessNamespaceSearch;
+
+/* Plugin provides a hook function matching this signature. */
+typedef void (*object_access_hook_type) (ObjectAccessType access,
+										 Oid classId,
+										 Oid objectId,
+										 int subId,
+										 void *arg);
+
+/* Plugin sets this variable to a suitable hook function. */
+extern PGDLLIMPORT object_access_hook_type object_access_hook;
+
+/* Core code uses these functions to call the hook (see macros below). */
+extern void RunObjectPostCreateHook(Oid classId, Oid objectId, int subId,
+									bool is_internal);
+extern void RunObjectDropHook(Oid classId, Oid objectId, int subId,
+							  int dropflags);
+extern void RunObjectTruncateHook(Oid objectId);
+extern void RunObjectPostAlterHook(Oid classId, Oid objectId, int subId,
+								   Oid auxiliaryId, bool is_internal);
+extern bool RunNamespaceSearchHook(Oid objectId, bool ereport_on_violation);
+extern void RunFunctionExecuteHook(Oid objectId);
+
+/*
+ * The following macros are wrappers around the functions above; these should
+ * normally be used to invoke the hook in lieu of calling the above functions
+ * directly.
+ */
+
+#define InvokeObjectPostCreateHook(classId,objectId,subId)			\
+	InvokeObjectPostCreateHookArg((classId),(objectId),(subId),false)
+#define InvokeObjectPostCreateHookArg(classId,objectId,subId,is_internal) \
+	do {															\
+		if (object_access_hook)										\
+			RunObjectPostCreateHook((classId),(objectId),(subId),	\
+									(is_internal));					\
+	} while(0)
+
+#define InvokeObjectDropHook(classId,objectId,subId)				\
+	InvokeObjectDropHookArg((classId),(objectId),(subId),0)
+#define InvokeObjectDropHookArg(classId,objectId,subId,dropflags)	\
+	do {															\
+		if (object_access_hook)										\
+			RunObjectDropHook((classId),(objectId),(subId),			\
+							  (dropflags));							\
+	} while(0)
+
+#define InvokeObjectTruncateHook(objectId)							\
+	do {															\
+		if (object_access_hook)										\
+			RunObjectTruncateHook(objectId);						\
+	} while(0)
+
+#define InvokeObjectPostAlterHook(classId,objectId,subId)			\
+	InvokeObjectPostAlterHookArg((classId),(objectId),(subId),		\
+								 InvalidOid,false)
+#define InvokeObjectPostAlterHookArg(classId,objectId,subId,		\
+									 auxiliaryId,is_internal)		\
+	do {															\
+		if (object_access_hook)										\
+			RunObjectPostAlterHook((classId),(objectId),(subId),	\
+								   (auxiliaryId),(is_internal));	\
+	} while(0)
+
+#define InvokeNamespaceSearchHook(objectId, ereport_on_violation)	\
+	(!object_access_hook											\
+	 ? true															\
+	 : RunNamespaceSearchHook((objectId), (ereport_on_violation)))
+
+#define InvokeFunctionExecuteHook(objectId)		\
+	do {										\
+		if (object_access_hook)					\
+			RunFunctionExecuteHook(objectId);	\
+	} while(0)
+
+#endif							/* OBJECTACCESS_H */

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

@@ -0,0 +1,84 @@
+/*-------------------------------------------------------------------------
+ *
+ * objectaddress.h
+ *	  functions for working with object addresses
+ *
+ * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/catalog/objectaddress.h
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef OBJECTADDRESS_H
+#define OBJECTADDRESS_H
+
+#include "access/htup.h"
+#include "nodes/parsenodes.h"
+#include "storage/lockdefs.h"
+#include "utils/relcache.h"
+
+/*
+ * An ObjectAddress represents a database object of any type.
+ */
+typedef struct ObjectAddress
+{
+	Oid			classId;		/* Class Id from pg_class */
+	Oid			objectId;		/* OID of the object */
+	int32		objectSubId;	/* Subitem within object (eg column), or 0 */
+} ObjectAddress;
+
+extern const ObjectAddress InvalidObjectAddress;
+
+#define ObjectAddressSubSet(addr, class_id, object_id, object_sub_id) \
+	do { \
+		(addr).classId = (class_id); \
+		(addr).objectId = (object_id); \
+		(addr).objectSubId = (object_sub_id); \
+	} while (0)
+
+#define ObjectAddressSet(addr, class_id, object_id) \
+	ObjectAddressSubSet(addr, class_id, object_id, 0)
+
+extern ObjectAddress get_object_address(ObjectType objtype, Node *object,
+										Relation *relp,
+										LOCKMODE lockmode, bool missing_ok);
+
+extern ObjectAddress get_object_address_rv(ObjectType objtype, RangeVar *rel,
+										   List *object, Relation *relp,
+										   LOCKMODE lockmode, bool missing_ok);
+
+extern void check_object_ownership(Oid roleid,
+								   ObjectType objtype, ObjectAddress address,
+								   Node *object, Relation relation);
+
+extern Oid	get_object_namespace(const ObjectAddress *address);
+
+extern bool is_objectclass_supported(Oid class_id);
+extern Oid	get_object_oid_index(Oid class_id);
+extern int	get_object_catcache_oid(Oid class_id);
+extern int	get_object_catcache_name(Oid class_id);
+extern AttrNumber get_object_attnum_oid(Oid class_id);
+extern AttrNumber get_object_attnum_name(Oid class_id);
+extern AttrNumber get_object_attnum_namespace(Oid class_id);
+extern AttrNumber get_object_attnum_owner(Oid class_id);
+extern AttrNumber get_object_attnum_acl(Oid class_id);
+extern ObjectType get_object_type(Oid class_id, Oid object_id);
+extern bool get_object_namensp_unique(Oid class_id);
+
+extern HeapTuple get_catalog_object_by_oid(Relation catalog,
+										   AttrNumber oidcol, Oid objectId);
+
+extern char *getObjectDescription(const ObjectAddress *object);
+extern char *getObjectDescriptionOids(Oid classid, Oid objid);
+
+extern int	read_objtype_from_string(const char *objtype);
+extern char *getObjectTypeDescription(const ObjectAddress *object);
+extern char *getObjectIdentity(const ObjectAddress *address);
+extern char *getObjectIdentityParts(const ObjectAddress *address,
+									List **objname, List **objargs);
+extern struct ArrayType *strlist_to_textarray(List *list);
+
+extern ObjectType get_relkind_objtype(char relkind);
+
+#endif							/* OBJECTADDRESS_H */

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

@@ -0,0 +1,176 @@
+/*-------------------------------------------------------------------------
+ *
+ * pg_aggregate.h
+ *	  definition of the "aggregate" system catalog (pg_aggregate)
+ *
+ *
+ * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/catalog/pg_aggregate.h
+ *
+ * NOTES
+ *	  The Catalog.pm module reads this file and derives schema
+ *	  information.
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef PG_AGGREGATE_H
+#define PG_AGGREGATE_H
+
+#include "catalog/genbki.h"
+#include "catalog/pg_aggregate_d.h"
+
+#include "catalog/objectaddress.h"
+#include "nodes/pg_list.h"
+
+/* ----------------------------------------------------------------
+ *		pg_aggregate definition.
+ *		cpp turns this into typedef struct FormData_pg_aggregate
+ * ----------------------------------------------------------------
+ */
+CATALOG(pg_aggregate,2600,AggregateRelationId)
+{
+	/* pg_proc OID of the aggregate itself */
+	regproc		aggfnoid BKI_LOOKUP(pg_proc);
+
+	/* aggregate kind, see AGGKIND_ categories below */
+	char		aggkind BKI_DEFAULT(n);
+
+	/* number of arguments that are "direct" arguments */
+	int16		aggnumdirectargs BKI_DEFAULT(0);
+
+	/* transition function */
+	regproc		aggtransfn BKI_LOOKUP(pg_proc);
+
+	/* final function (0 if none) */
+	regproc		aggfinalfn BKI_DEFAULT(-) BKI_LOOKUP(pg_proc);
+
+	/* combine function (0 if none) */
+	regproc		aggcombinefn BKI_DEFAULT(-) BKI_LOOKUP(pg_proc);
+
+	/* function to convert transtype to bytea (0 if none) */
+	regproc		aggserialfn BKI_DEFAULT(-) BKI_LOOKUP(pg_proc);
+
+	/* function to convert bytea to transtype (0 if none) */
+	regproc		aggdeserialfn BKI_DEFAULT(-) BKI_LOOKUP(pg_proc);
+
+	/* forward function for moving-aggregate mode (0 if none) */
+	regproc		aggmtransfn BKI_DEFAULT(-) BKI_LOOKUP(pg_proc);
+
+	/* inverse function for moving-aggregate mode (0 if none) */
+	regproc		aggminvtransfn BKI_DEFAULT(-) BKI_LOOKUP(pg_proc);
+
+	/* final function for moving-aggregate mode (0 if none) */
+	regproc		aggmfinalfn BKI_DEFAULT(-) BKI_LOOKUP(pg_proc);
+
+	/* true to pass extra dummy arguments to aggfinalfn */
+	bool		aggfinalextra BKI_DEFAULT(f);
+
+	/* true to pass extra dummy arguments to aggmfinalfn */
+	bool		aggmfinalextra BKI_DEFAULT(f);
+
+	/* tells whether aggfinalfn modifies transition state */
+	char		aggfinalmodify BKI_DEFAULT(r);
+
+	/* tells whether aggmfinalfn modifies transition state */
+	char		aggmfinalmodify BKI_DEFAULT(r);
+
+	/* associated sort operator (0 if none) */
+	Oid			aggsortop BKI_DEFAULT(0) BKI_LOOKUP(pg_operator);
+
+	/* type of aggregate's transition (state) data */
+	Oid			aggtranstype BKI_LOOKUP(pg_type);
+
+	/* estimated size of state data (0 for default estimate) */
+	int32		aggtransspace BKI_DEFAULT(0);
+
+	/* type of moving-aggregate state data (0 if none) */
+	Oid			aggmtranstype BKI_DEFAULT(0) BKI_LOOKUP(pg_type);
+
+	/* estimated size of moving-agg state (0 for default est) */
+	int32		aggmtransspace BKI_DEFAULT(0);
+
+#ifdef CATALOG_VARLEN			/* variable-length fields start here */
+
+	/* initial value for transition state (can be NULL) */
+	text		agginitval BKI_DEFAULT(_null_);
+
+	/* initial value for moving-agg state (can be NULL) */
+	text		aggminitval BKI_DEFAULT(_null_);
+#endif
+} FormData_pg_aggregate;
+
+/* ----------------
+ *		Form_pg_aggregate corresponds to a pointer to a tuple with
+ *		the format of pg_aggregate relation.
+ * ----------------
+ */
+typedef FormData_pg_aggregate *Form_pg_aggregate;
+
+#ifdef EXPOSE_TO_CLIENT_CODE
+
+/*
+ * Symbolic values for aggkind column.  We distinguish normal aggregates
+ * from ordered-set aggregates (which have two sets of arguments, namely
+ * direct and aggregated arguments) and from hypothetical-set aggregates
+ * (which are a subclass of ordered-set aggregates in which the last
+ * direct arguments have to match up in number and datatypes with the
+ * aggregated arguments).
+ */
+#define AGGKIND_NORMAL			'n'
+#define AGGKIND_ORDERED_SET		'o'
+#define AGGKIND_HYPOTHETICAL	'h'
+
+/* Use this macro to test for "ordered-set agg including hypothetical case" */
+#define AGGKIND_IS_ORDERED_SET(kind)  ((kind) != AGGKIND_NORMAL)
+
+/*
+ * Symbolic values for aggfinalmodify and aggmfinalmodify columns.
+ * Preferably, finalfns do not modify the transition state value at all,
+ * but in some cases that would cost too much performance.  We distinguish
+ * "pure read only" and "trashes it arbitrarily" cases, as well as the
+ * intermediate case where multiple finalfn calls are allowed but the
+ * transfn cannot be applied anymore after the first finalfn call.
+ */
+#define AGGMODIFY_READ_ONLY			'r'
+#define AGGMODIFY_SHAREABLE			's'
+#define AGGMODIFY_READ_WRITE		'w'
+
+#endif							/* EXPOSE_TO_CLIENT_CODE */
+
+
+extern ObjectAddress AggregateCreate(const char *aggName,
+									 Oid aggNamespace,
+									 bool replace,
+									 char aggKind,
+									 int numArgs,
+									 int numDirectArgs,
+									 oidvector *parameterTypes,
+									 Datum allParameterTypes,
+									 Datum parameterModes,
+									 Datum parameterNames,
+									 List *parameterDefaults,
+									 Oid variadicArgType,
+									 List *aggtransfnName,
+									 List *aggfinalfnName,
+									 List *aggcombinefnName,
+									 List *aggserialfnName,
+									 List *aggdeserialfnName,
+									 List *aggmtransfnName,
+									 List *aggminvtransfnName,
+									 List *aggmfinalfnName,
+									 bool finalfnExtraArgs,
+									 bool mfinalfnExtraArgs,
+									 char finalfnModify,
+									 char mfinalfnModify,
+									 List *aggsortopName,
+									 Oid aggTransType,
+									 int32 aggTransSpace,
+									 Oid aggmTransType,
+									 int32 aggmTransSpace,
+									 const char *agginitval,
+									 const char *aggminitval,
+									 char proparallel);
+
+#endif							/* PG_AGGREGATE_H */