pg_query 2.0.0 → 2.0.1

data/ext/pg_query/include/commands/prepare.h

@@ -0,0 +1,61 @@
+/*-------------------------------------------------------------------------
+ *
+ * prepare.h
+ *	  PREPARE, EXECUTE and DEALLOCATE commands, and prepared-stmt storage
+ *
+ *
+ * Copyright (c) 2002-2020, PostgreSQL Global Development Group
+ *
+ * src/include/commands/prepare.h
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef PREPARE_H
+#define PREPARE_H
+
+#include "commands/explain.h"
+#include "datatype/timestamp.h"
+#include "utils/plancache.h"
+
+/*
+ * The data structure representing a prepared statement.  This is now just
+ * a thin veneer over a plancache entry --- the main addition is that of
+ * a name.
+ *
+ * Note: all subsidiary storage lives in the referenced plancache entry.
+ */
+typedef struct
+{
+	/* dynahash.c requires key to be first field */
+	char		stmt_name[NAMEDATALEN];
+	CachedPlanSource *plansource;	/* the actual cached plan */
+	bool		from_sql;		/* prepared via SQL, not FE/BE protocol? */
+	TimestampTz prepare_time;	/* the time when the stmt was prepared */
+} PreparedStatement;
+
+
+/* Utility statements PREPARE, EXECUTE, DEALLOCATE, EXPLAIN EXECUTE */
+extern void PrepareQuery(ParseState *pstate, PrepareStmt *stmt,
+						 int stmt_location, int stmt_len);
+extern void ExecuteQuery(ParseState *pstate,
+						 ExecuteStmt *stmt, IntoClause *intoClause,
+						 ParamListInfo params,
+						 DestReceiver *dest, QueryCompletion *qc);
+extern void DeallocateQuery(DeallocateStmt *stmt);
+extern void ExplainExecuteQuery(ExecuteStmt *execstmt, IntoClause *into,
+								ExplainState *es, const char *queryString,
+								ParamListInfo params, QueryEnvironment *queryEnv);
+
+/* Low-level access to stored prepared statements */
+extern void StorePreparedStatement(const char *stmt_name,
+								   CachedPlanSource *plansource,
+								   bool from_sql);
+extern PreparedStatement *FetchPreparedStatement(const char *stmt_name,
+												 bool throwError);
+extern void DropPreparedStatement(const char *stmt_name, bool showError);
+extern TupleDesc FetchPreparedStatementResultDesc(PreparedStatement *stmt);
+extern List *FetchPreparedStatementTargetList(PreparedStatement *stmt);
+
+extern void DropAllPreparedStatements(void);
+
+#endif							/* PREPARE_H */

data/ext/pg_query/include/commands/tablespace.h

@@ -0,0 +1,67 @@
+/*-------------------------------------------------------------------------
+ *
+ * tablespace.h
+ *		Tablespace management commands (create/drop tablespace).
+ *
+ *
+ * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/commands/tablespace.h
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef TABLESPACE_H
+#define TABLESPACE_H
+
+#include "access/xlogreader.h"
+#include "catalog/objectaddress.h"
+#include "lib/stringinfo.h"
+#include "nodes/parsenodes.h"
+
+/* XLOG stuff */
+#define XLOG_TBLSPC_CREATE		0x00
+#define XLOG_TBLSPC_DROP		0x10
+
+typedef struct xl_tblspc_create_rec
+{
+	Oid			ts_id;
+	char		ts_path[FLEXIBLE_ARRAY_MEMBER]; /* null-terminated string */
+} xl_tblspc_create_rec;
+
+typedef struct xl_tblspc_drop_rec
+{
+	Oid			ts_id;
+} xl_tblspc_drop_rec;
+
+typedef struct TableSpaceOpts
+{
+	int32		vl_len_;		/* varlena header (do not touch directly!) */
+	float8		random_page_cost;
+	float8		seq_page_cost;
+	int			effective_io_concurrency;
+	int			maintenance_io_concurrency;
+} TableSpaceOpts;
+
+extern Oid	CreateTableSpace(CreateTableSpaceStmt *stmt);
+extern void DropTableSpace(DropTableSpaceStmt *stmt);
+extern ObjectAddress RenameTableSpace(const char *oldname, const char *newname);
+extern Oid	AlterTableSpaceOptions(AlterTableSpaceOptionsStmt *stmt);
+
+extern void TablespaceCreateDbspace(Oid spcNode, Oid dbNode, bool isRedo);
+
+extern Oid	GetDefaultTablespace(char relpersistence, bool partitioned);
+
+extern void PrepareTempTablespaces(void);
+
+extern Oid	get_tablespace_oid(const char *tablespacename, bool missing_ok);
+extern char *get_tablespace_name(Oid spc_oid);
+
+extern bool directory_is_empty(const char *path);
+extern void remove_tablespace_symlink(const char *linkloc);
+
+extern void tblspc_redo(XLogReaderState *rptr);
+extern void tblspc_desc(StringInfo buf, XLogReaderState *rptr);
+extern const char *tblspc_identify(uint8 info);
+
+#endif							/* TABLESPACE_H */

data/ext/pg_query/include/commands/trigger.h

@@ -0,0 +1,277 @@
+/*-------------------------------------------------------------------------
+ *
+ * trigger.h
+ *	  Declarations for trigger handling.
+ *
+ * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/commands/trigger.h
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef TRIGGER_H
+#define TRIGGER_H
+
+#include "catalog/objectaddress.h"
+#include "nodes/execnodes.h"
+#include "nodes/parsenodes.h"
+
+/*
+ * TriggerData is the node type that is passed as fmgr "context" info
+ * when a function is called by the trigger manager.
+ */
+
+#define CALLED_AS_TRIGGER(fcinfo) \
+	((fcinfo)->context != NULL && IsA((fcinfo)->context, TriggerData))
+
+typedef uint32 TriggerEvent;
+
+typedef struct TriggerData
+{
+	NodeTag		type;
+	TriggerEvent tg_event;
+	Relation	tg_relation;
+	HeapTuple	tg_trigtuple;
+	HeapTuple	tg_newtuple;
+	Trigger    *tg_trigger;
+	TupleTableSlot *tg_trigslot;
+	TupleTableSlot *tg_newslot;
+	Tuplestorestate *tg_oldtable;
+	Tuplestorestate *tg_newtable;
+	const Bitmapset *tg_updatedcols;
+} TriggerData;
+
+/*
+ * The state for capturing old and new tuples into transition tables for a
+ * single ModifyTable node (or other operation source, e.g. copy.c).
+ *
+ * This is per-caller to avoid conflicts in setting tcs_map or
+ * tcs_original_insert_tuple.  Note, however, that the pointed-to
+ * private data may be shared across multiple callers.
+ */
+struct AfterTriggersTableData;	/* private in trigger.c */
+
+typedef struct TransitionCaptureState
+{
+	/*
+	 * Is there at least one trigger specifying each transition relation on
+	 * the relation explicitly named in the DML statement or COPY command?
+	 * Note: in current usage, these flags could be part of the private state,
+	 * but it seems possibly useful to let callers see them.
+	 */
+	bool		tcs_delete_old_table;
+	bool		tcs_update_old_table;
+	bool		tcs_update_new_table;
+	bool		tcs_insert_new_table;
+
+	/*
+	 * For UPDATE and DELETE, AfterTriggerSaveEvent may need to convert the
+	 * new and old tuples from a child table's format to the format of the
+	 * relation named in a query so that it is compatible with the transition
+	 * tuplestores.  The caller must store the conversion map here if so.
+	 */
+	TupleConversionMap *tcs_map;
+
+	/*
+	 * For INSERT and COPY, it would be wasteful to convert tuples from child
+	 * format to parent format after they have already been converted in the
+	 * opposite direction during routing.  In that case we bypass conversion
+	 * and allow the inserting code (copy.c and nodeModifyTable.c) to provide
+	 * a slot containing the original tuple directly.
+	 */
+	TupleTableSlot *tcs_original_insert_tuple;
+
+	/*
+	 * Private data including the tuplestore(s) into which to insert tuples.
+	 */
+	struct AfterTriggersTableData *tcs_private;
+} TransitionCaptureState;
+
+/*
+ * TriggerEvent bit flags
+ *
+ * Note that we assume different event types (INSERT/DELETE/UPDATE/TRUNCATE)
+ * can't be OR'd together in a single TriggerEvent.  This is unlike the
+ * situation for pg_trigger rows, so pg_trigger.tgtype uses a different
+ * representation!
+ */
+#define TRIGGER_EVENT_INSERT			0x00000000
+#define TRIGGER_EVENT_DELETE			0x00000001
+#define TRIGGER_EVENT_UPDATE			0x00000002
+#define TRIGGER_EVENT_TRUNCATE			0x00000003
+#define TRIGGER_EVENT_OPMASK			0x00000003
+
+#define TRIGGER_EVENT_ROW				0x00000004
+
+#define TRIGGER_EVENT_BEFORE			0x00000008
+#define TRIGGER_EVENT_AFTER				0x00000000
+#define TRIGGER_EVENT_INSTEAD			0x00000010
+#define TRIGGER_EVENT_TIMINGMASK		0x00000018
+
+/* More TriggerEvent flags, used only within trigger.c */
+
+#define AFTER_TRIGGER_DEFERRABLE		0x00000020
+#define AFTER_TRIGGER_INITDEFERRED		0x00000040
+
+#define TRIGGER_FIRED_BY_INSERT(event) \
+	(((event) & TRIGGER_EVENT_OPMASK) == TRIGGER_EVENT_INSERT)
+
+#define TRIGGER_FIRED_BY_DELETE(event) \
+	(((event) & TRIGGER_EVENT_OPMASK) == TRIGGER_EVENT_DELETE)
+
+#define TRIGGER_FIRED_BY_UPDATE(event) \
+	(((event) & TRIGGER_EVENT_OPMASK) == TRIGGER_EVENT_UPDATE)
+
+#define TRIGGER_FIRED_BY_TRUNCATE(event) \
+	(((event) & TRIGGER_EVENT_OPMASK) == TRIGGER_EVENT_TRUNCATE)
+
+#define TRIGGER_FIRED_FOR_ROW(event) \
+	((event) & TRIGGER_EVENT_ROW)
+
+#define TRIGGER_FIRED_FOR_STATEMENT(event) \
+	(!TRIGGER_FIRED_FOR_ROW(event))
+
+#define TRIGGER_FIRED_BEFORE(event) \
+	(((event) & TRIGGER_EVENT_TIMINGMASK) == TRIGGER_EVENT_BEFORE)
+
+#define TRIGGER_FIRED_AFTER(event) \
+	(((event) & TRIGGER_EVENT_TIMINGMASK) == TRIGGER_EVENT_AFTER)
+
+#define TRIGGER_FIRED_INSTEAD(event) \
+	(((event) & TRIGGER_EVENT_TIMINGMASK) == TRIGGER_EVENT_INSTEAD)
+
+/*
+ * Definitions for replication role based firing.
+ */
+#define SESSION_REPLICATION_ROLE_ORIGIN		0
+#define SESSION_REPLICATION_ROLE_REPLICA	1
+#define SESSION_REPLICATION_ROLE_LOCAL		2
+extern PGDLLIMPORT int SessionReplicationRole;
+
+/*
+ * States at which a trigger can be fired. These are the
+ * possible values for pg_trigger.tgenabled.
+ */
+#define TRIGGER_FIRES_ON_ORIGIN				'O'
+#define TRIGGER_FIRES_ALWAYS				'A'
+#define TRIGGER_FIRES_ON_REPLICA			'R'
+#define TRIGGER_DISABLED					'D'
+
+extern ObjectAddress CreateTrigger(CreateTrigStmt *stmt, const char *queryString,
+								   Oid relOid, Oid refRelOid, Oid constraintOid, Oid indexOid,
+								   Oid funcoid, Oid parentTriggerOid, Node *whenClause,
+								   bool isInternal, bool in_partition);
+
+extern void RemoveTriggerById(Oid trigOid);
+extern Oid	get_trigger_oid(Oid relid, const char *name, bool missing_ok);
+
+extern ObjectAddress renametrig(RenameStmt *stmt);
+
+extern void EnableDisableTrigger(Relation rel, const char *tgname,
+								 char fires_when, bool skip_system, LOCKMODE lockmode);
+
+extern void RelationBuildTriggers(Relation relation);
+
+extern TriggerDesc *CopyTriggerDesc(TriggerDesc *trigdesc);
+
+extern const char *FindTriggerIncompatibleWithInheritance(TriggerDesc *trigdesc);
+
+extern TransitionCaptureState *MakeTransitionCaptureState(TriggerDesc *trigdesc,
+														  Oid relid, CmdType cmdType);
+
+extern void FreeTriggerDesc(TriggerDesc *trigdesc);
+
+extern void ExecBSInsertTriggers(EState *estate,
+								 ResultRelInfo *relinfo);
+extern void ExecASInsertTriggers(EState *estate,
+								 ResultRelInfo *relinfo,
+								 TransitionCaptureState *transition_capture);
+extern bool ExecBRInsertTriggers(EState *estate,
+								 ResultRelInfo *relinfo,
+								 TupleTableSlot *slot);
+extern void ExecARInsertTriggers(EState *estate,
+								 ResultRelInfo *relinfo,
+								 TupleTableSlot *slot,
+								 List *recheckIndexes,
+								 TransitionCaptureState *transition_capture);
+extern bool ExecIRInsertTriggers(EState *estate,
+								 ResultRelInfo *relinfo,
+								 TupleTableSlot *slot);
+extern void ExecBSDeleteTriggers(EState *estate,
+								 ResultRelInfo *relinfo);
+extern void ExecASDeleteTriggers(EState *estate,
+								 ResultRelInfo *relinfo,
+								 TransitionCaptureState *transition_capture);
+extern bool ExecBRDeleteTriggers(EState *estate,
+								 EPQState *epqstate,
+								 ResultRelInfo *relinfo,
+								 ItemPointer tupleid,
+								 HeapTuple fdw_trigtuple,
+								 TupleTableSlot **epqslot);
+extern void ExecARDeleteTriggers(EState *estate,
+								 ResultRelInfo *relinfo,
+								 ItemPointer tupleid,
+								 HeapTuple fdw_trigtuple,
+								 TransitionCaptureState *transition_capture);
+extern bool ExecIRDeleteTriggers(EState *estate,
+								 ResultRelInfo *relinfo,
+								 HeapTuple trigtuple);
+extern void ExecBSUpdateTriggers(EState *estate,
+								 ResultRelInfo *relinfo);
+extern void ExecASUpdateTriggers(EState *estate,
+								 ResultRelInfo *relinfo,
+								 TransitionCaptureState *transition_capture);
+extern bool ExecBRUpdateTriggers(EState *estate,
+								 EPQState *epqstate,
+								 ResultRelInfo *relinfo,
+								 ItemPointer tupleid,
+								 HeapTuple fdw_trigtuple,
+								 TupleTableSlot *slot);
+extern void ExecARUpdateTriggers(EState *estate,
+								 ResultRelInfo *relinfo,
+								 ItemPointer tupleid,
+								 HeapTuple fdw_trigtuple,
+								 TupleTableSlot *slot,
+								 List *recheckIndexes,
+								 TransitionCaptureState *transition_capture);
+extern bool ExecIRUpdateTriggers(EState *estate,
+								 ResultRelInfo *relinfo,
+								 HeapTuple trigtuple,
+								 TupleTableSlot *slot);
+extern void ExecBSTruncateTriggers(EState *estate,
+								   ResultRelInfo *relinfo);
+extern void ExecASTruncateTriggers(EState *estate,
+								   ResultRelInfo *relinfo);
+
+extern void AfterTriggerBeginXact(void);
+extern void AfterTriggerBeginQuery(void);
+extern void AfterTriggerEndQuery(EState *estate);
+extern void AfterTriggerFireDeferred(void);
+extern void AfterTriggerEndXact(bool isCommit);
+extern void AfterTriggerBeginSubXact(void);
+extern void AfterTriggerEndSubXact(bool isCommit);
+extern void AfterTriggerSetState(ConstraintsSetStmt *stmt);
+extern bool AfterTriggerPendingOnRel(Oid relid);
+
+
+/*
+ * in utils/adt/ri_triggers.c
+ */
+extern bool RI_FKey_pk_upd_check_required(Trigger *trigger, Relation pk_rel,
+										  TupleTableSlot *old_slot, TupleTableSlot *new_slot);
+extern bool RI_FKey_fk_upd_check_required(Trigger *trigger, Relation fk_rel,
+										  TupleTableSlot *old_slot, TupleTableSlot *new_slot);
+extern bool RI_Initial_Check(Trigger *trigger,
+							 Relation fk_rel, Relation pk_rel);
+extern void RI_PartitionRemove_Check(Trigger *trigger, Relation fk_rel,
+									 Relation pk_rel);
+
+/* result values for RI_FKey_trigger_type: */
+#define RI_TRIGGER_PK	1		/* is a trigger on the PK relation */
+#define RI_TRIGGER_FK	2		/* is a trigger on the FK relation */
+#define RI_TRIGGER_NONE 0		/* is not an RI trigger function */
+
+extern int	RI_FKey_trigger_type(Oid tgfoid);
+
+#endif							/* TRIGGER_H */

data/ext/pg_query/include/commands/user.h

@@ -0,0 +1,37 @@
+/*-------------------------------------------------------------------------
+ *
+ * user.h
+ *	  Commands for manipulating roles (formerly called users).
+ *
+ *
+ * src/include/commands/user.h
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef USER_H
+#define USER_H
+
+#include "catalog/objectaddress.h"
+#include "libpq/crypt.h"
+#include "nodes/parsenodes.h"
+#include "parser/parse_node.h"
+
+/* GUC. Is actually of type PasswordType. */
+extern int	Password_encryption;
+
+/* Hook to check passwords in CreateRole() and AlterRole() */
+typedef void (*check_password_hook_type) (const char *username, const char *shadow_pass, PasswordType password_type, Datum validuntil_time, bool validuntil_null);
+
+extern PGDLLIMPORT check_password_hook_type check_password_hook;
+
+extern Oid	CreateRole(ParseState *pstate, CreateRoleStmt *stmt);
+extern Oid	AlterRole(AlterRoleStmt *stmt);
+extern Oid	AlterRoleSet(AlterRoleSetStmt *stmt);
+extern void DropRole(DropRoleStmt *stmt);
+extern void GrantRole(GrantRoleStmt *stmt);
+extern ObjectAddress RenameRole(const char *oldname, const char *newname);
+extern void DropOwnedObjects(DropOwnedStmt *stmt);
+extern void ReassignOwnedObjects(ReassignOwnedStmt *stmt);
+extern List *roleSpecsToIds(List *memberNames);
+
+#endif							/* USER_H */

data/ext/pg_query/include/commands/vacuum.h

@@ -0,0 +1,293 @@
+/*-------------------------------------------------------------------------
+ *
+ * vacuum.h
+ *	  header file for postgres vacuum cleaner and statistics analyzer
+ *
+ *
+ * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/commands/vacuum.h
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef VACUUM_H
+#define VACUUM_H
+
+#include "access/htup.h"
+#include "catalog/pg_class.h"
+#include "catalog/pg_statistic.h"
+#include "catalog/pg_type.h"
+#include "parser/parse_node.h"
+#include "storage/buf.h"
+#include "storage/lock.h"
+#include "utils/relcache.h"
+
+/*
+ * Flags for amparallelvacuumoptions to control the participation of bulkdelete
+ * and vacuumcleanup in parallel vacuum.
+ */
+
+/*
+ * Both bulkdelete and vacuumcleanup are disabled by default.  This will be
+ * used by IndexAM's that don't want to or cannot participate in parallel
+ * vacuum.  For example, if an index AM doesn't have a way to communicate the
+ * index statistics allocated by the first ambulkdelete call to the subsequent
+ * ones until amvacuumcleanup, the index AM cannot participate in parallel
+ * vacuum.
+ */
+#define VACUUM_OPTION_NO_PARALLEL			0
+
+/*
+ * bulkdelete can be performed in parallel.  This option can be used by
+ * IndexAm's that need to scan the index to delete the tuples.
+ */
+#define VACUUM_OPTION_PARALLEL_BULKDEL		(1 << 0)
+
+/*
+ * vacuumcleanup can be performed in parallel if bulkdelete is not performed
+ * yet.  This will be used by IndexAM's that can scan the index if the
+ * bulkdelete is not performed.
+ */
+#define VACUUM_OPTION_PARALLEL_COND_CLEANUP	(1 << 1)
+
+/*
+ * vacuumcleanup can be performed in parallel even if bulkdelete has already
+ * processed the index.  This will be used by IndexAM's that scan the index
+ * during the cleanup phase of index irrespective of whether the index is
+ * already scanned or not during bulkdelete phase.
+ */
+#define VACUUM_OPTION_PARALLEL_CLEANUP		(1 << 2)
+
+/* value for checking vacuum flags */
+#define VACUUM_OPTION_MAX_VALID_VALUE		((1 << 3) - 1)
+
+/*----------
+ * ANALYZE builds one of these structs for each attribute (column) that is
+ * to be analyzed.  The struct and subsidiary data are in anl_context,
+ * so they live until the end of the ANALYZE operation.
+ *
+ * The type-specific typanalyze function is passed a pointer to this struct
+ * and must return true to continue analysis, false to skip analysis of this
+ * column.  In the true case it must set the compute_stats and minrows fields,
+ * and can optionally set extra_data to pass additional info to compute_stats.
+ * minrows is its request for the minimum number of sample rows to be gathered
+ * (but note this request might not be honored, eg if there are fewer rows
+ * than that in the table).
+ *
+ * The compute_stats routine will be called after sample rows have been
+ * gathered.  Aside from this struct, it is passed:
+ *		fetchfunc: a function for accessing the column values from the
+ *				   sample rows
+ *		samplerows: the number of sample tuples
+ *		totalrows: estimated total number of rows in relation
+ * The fetchfunc may be called with rownum running from 0 to samplerows-1.
+ * It returns a Datum and an isNull flag.
+ *
+ * compute_stats should set stats_valid true if it is able to compute
+ * any useful statistics.  If it does, the remainder of the struct holds
+ * the information to be stored in a pg_statistic row for the column.  Be
+ * careful to allocate any pointed-to data in anl_context, which will NOT
+ * be CurrentMemoryContext when compute_stats is called.
+ *
+ * Note: all comparisons done for statistical purposes should use the
+ * underlying column's collation (attcollation), except in situations
+ * where a noncollatable container type contains a collatable type;
+ * in that case use the type's default collation.  Be sure to record
+ * the appropriate collation in stacoll.
+ *----------
+ */
+typedef struct VacAttrStats *VacAttrStatsP;
+
+typedef Datum (*AnalyzeAttrFetchFunc) (VacAttrStatsP stats, int rownum,
+									   bool *isNull);
+
+typedef void (*AnalyzeAttrComputeStatsFunc) (VacAttrStatsP stats,
+											 AnalyzeAttrFetchFunc fetchfunc,
+											 int samplerows,
+											 double totalrows);
+
+typedef struct VacAttrStats
+{
+	/*
+	 * These fields are set up by the main ANALYZE code before invoking the
+	 * type-specific typanalyze function.
+	 *
+	 * Note: do not assume that the data being analyzed has the same datatype
+	 * shown in attr, ie do not trust attr->atttypid, attlen, etc.  This is
+	 * because some index opclasses store a different type than the underlying
+	 * column/expression.  Instead use attrtypid, attrtypmod, and attrtype for
+	 * information about the datatype being fed to the typanalyze function.
+	 * Likewise, use attrcollid not attr->attcollation.
+	 */
+	Form_pg_attribute attr;		/* copy of pg_attribute row for column */
+	Oid			attrtypid;		/* type of data being analyzed */
+	int32		attrtypmod;		/* typmod of data being analyzed */
+	Form_pg_type attrtype;		/* copy of pg_type row for attrtypid */
+	Oid			attrcollid;		/* collation of data being analyzed */
+	MemoryContext anl_context;	/* where to save long-lived data */
+
+	/*
+	 * These fields must be filled in by the typanalyze routine, unless it
+	 * returns false.
+	 */
+	AnalyzeAttrComputeStatsFunc compute_stats;	/* function pointer */
+	int			minrows;		/* Minimum # of rows wanted for stats */
+	void	   *extra_data;		/* for extra type-specific data */
+
+	/*
+	 * These fields are to be filled in by the compute_stats routine. (They
+	 * are initialized to zero when the struct is created.)
+	 */
+	bool		stats_valid;
+	float4		stanullfrac;	/* fraction of entries that are NULL */
+	int32		stawidth;		/* average width of column values */
+	float4		stadistinct;	/* # distinct values */
+	int16		stakind[STATISTIC_NUM_SLOTS];
+	Oid			staop[STATISTIC_NUM_SLOTS];
+	Oid			stacoll[STATISTIC_NUM_SLOTS];
+	int			numnumbers[STATISTIC_NUM_SLOTS];
+	float4	   *stanumbers[STATISTIC_NUM_SLOTS];
+	int			numvalues[STATISTIC_NUM_SLOTS];
+	Datum	   *stavalues[STATISTIC_NUM_SLOTS];
+
+	/*
+	 * These fields describe the stavalues[n] element types. They will be
+	 * initialized to match attrtypid, but a custom typanalyze function might
+	 * want to store an array of something other than the analyzed column's
+	 * elements. It should then overwrite these fields.
+	 */
+	Oid			statypid[STATISTIC_NUM_SLOTS];
+	int16		statyplen[STATISTIC_NUM_SLOTS];
+	bool		statypbyval[STATISTIC_NUM_SLOTS];
+	char		statypalign[STATISTIC_NUM_SLOTS];
+
+	/*
+	 * These fields are private to the main ANALYZE code and should not be
+	 * looked at by type-specific functions.
+	 */
+	int			tupattnum;		/* attribute number within tuples */
+	HeapTuple  *rows;			/* access info for std fetch function */
+	TupleDesc	tupDesc;
+	Datum	   *exprvals;		/* access info for index fetch function */
+	bool	   *exprnulls;
+	int			rowstride;
+} VacAttrStats;
+
+typedef enum VacuumOption
+{
+	VACOPT_VACUUM = 1 << 0,		/* do VACUUM */
+	VACOPT_ANALYZE = 1 << 1,	/* do ANALYZE */
+	VACOPT_VERBOSE = 1 << 2,	/* print progress info */
+	VACOPT_FREEZE = 1 << 3,		/* FREEZE option */
+	VACOPT_FULL = 1 << 4,		/* FULL (non-concurrent) vacuum */
+	VACOPT_SKIP_LOCKED = 1 << 5,	/* skip if cannot get lock */
+	VACOPT_SKIPTOAST = 1 << 6,	/* don't process the TOAST table, if any */
+	VACOPT_DISABLE_PAGE_SKIPPING = 1 << 7	/* don't skip any pages */
+} VacuumOption;
+
+/*
+ * A ternary value used by vacuum parameters.
+ *
+ * DEFAULT value is used to determine the value based on other
+ * configurations, e.g. reloptions.
+ */
+typedef enum VacOptTernaryValue
+{
+	VACOPT_TERNARY_DEFAULT = 0,
+	VACOPT_TERNARY_DISABLED,
+	VACOPT_TERNARY_ENABLED,
+} VacOptTernaryValue;
+
+/*
+ * Parameters customizing behavior of VACUUM and ANALYZE.
+ *
+ * Note that at least one of VACOPT_VACUUM and VACOPT_ANALYZE must be set
+ * in options.
+ */
+typedef struct VacuumParams
+{
+	int			options;		/* bitmask of VacuumOption */
+	int			freeze_min_age; /* min freeze age, -1 to use default */
+	int			freeze_table_age;	/* age at which to scan whole table */
+	int			multixact_freeze_min_age;	/* min multixact freeze age, -1 to
+											 * use default */
+	int			multixact_freeze_table_age; /* multixact age at which to scan
+											 * whole table */
+	bool		is_wraparound;	/* force a for-wraparound vacuum */
+	int			log_min_duration;	/* minimum execution threshold in ms at
+									 * which  verbose logs are activated, -1
+									 * to use default */
+	VacOptTernaryValue index_cleanup;	/* Do index vacuum and cleanup,
+										 * default value depends on reloptions */
+	VacOptTernaryValue truncate;	/* Truncate empty pages at the end,
+									 * default value depends on reloptions */
+
+	/*
+	 * The number of parallel vacuum workers.  0 by default which means choose
+	 * based on the number of indexes.  -1 indicates parallel vacuum is
+	 * disabled.
+	 */
+	int			nworkers;
+} VacuumParams;
+
+/* GUC parameters */
+extern PGDLLIMPORT int default_statistics_target;	/* PGDLLIMPORT for PostGIS */
+extern int	vacuum_freeze_min_age;
+extern int	vacuum_freeze_table_age;
+extern int	vacuum_multixact_freeze_min_age;
+extern int	vacuum_multixact_freeze_table_age;
+
+/* Variables for cost-based parallel vacuum */
+extern pg_atomic_uint32 *VacuumSharedCostBalance;
+extern pg_atomic_uint32 *VacuumActiveNWorkers;
+extern int	VacuumCostBalanceLocal;
+
+
+/* in commands/vacuum.c */
+extern void ExecVacuum(ParseState *pstate, VacuumStmt *vacstmt, bool isTopLevel);
+extern void vacuum(List *relations, VacuumParams *params,
+				   BufferAccessStrategy bstrategy, bool isTopLevel);
+extern void vac_open_indexes(Relation relation, LOCKMODE lockmode,
+							 int *nindexes, Relation **Irel);
+extern void vac_close_indexes(int nindexes, Relation *Irel, LOCKMODE lockmode);
+extern double vac_estimate_reltuples(Relation relation,
+									 BlockNumber total_pages,
+									 BlockNumber scanned_pages,
+									 double scanned_tuples);
+extern void vac_update_relstats(Relation relation,
+								BlockNumber num_pages,
+								double num_tuples,
+								BlockNumber num_all_visible_pages,
+								bool hasindex,
+								TransactionId frozenxid,
+								MultiXactId minmulti,
+								bool in_outer_xact);
+extern void vacuum_set_xid_limits(Relation rel,
+								  int freeze_min_age, int freeze_table_age,
+								  int multixact_freeze_min_age,
+								  int multixact_freeze_table_age,
+								  TransactionId *oldestXmin,
+								  TransactionId *freezeLimit,
+								  TransactionId *xidFullScanLimit,
+								  MultiXactId *multiXactCutoff,
+								  MultiXactId *mxactFullScanLimit);
+extern void vac_update_datfrozenxid(void);
+extern void vacuum_delay_point(void);
+extern bool vacuum_is_relation_owner(Oid relid, Form_pg_class reltuple,
+									 int options);
+extern Relation vacuum_open_relation(Oid relid, RangeVar *relation,
+									 int options, bool verbose, LOCKMODE lmode);
+
+/* in commands/analyze.c */
+extern void analyze_rel(Oid relid, RangeVar *relation,
+						VacuumParams *params, List *va_cols, bool in_outer_xact,
+						BufferAccessStrategy bstrategy);
+extern bool std_typanalyze(VacAttrStats *stats);
+
+/* in utils/misc/sampling.c --- duplicate of declarations in utils/sampling.h */
+extern double anl_random_fract(void);
+extern double anl_init_selection_state(int n);
+extern double anl_get_next_S(double t, int n, double *stateptr);
+
+#endif							/* VACUUM_H */