pg_query 2.2.0 → 6.1.0

data/ext/pg_query/include/replication/syncrep.h

@@ -1,115 +0,0 @@
-/*-------------------------------------------------------------------------
- *
- * syncrep.h
- *	  Exports from replication/syncrep.c.
- *
- * Portions Copyright (c) 2010-2020, PostgreSQL Global Development Group
- *
- * IDENTIFICATION
- *		src/include/replication/syncrep.h
- *
- *-------------------------------------------------------------------------
- */
-#ifndef _SYNCREP_H
-#define _SYNCREP_H
-
-#include "access/xlogdefs.h"
-#include "utils/guc.h"
-
-#define SyncRepRequested() \
-	(max_wal_senders > 0 && synchronous_commit > SYNCHRONOUS_COMMIT_LOCAL_FLUSH)
-
-/* SyncRepWaitMode */
-#define SYNC_REP_NO_WAIT		(-1)
-#define SYNC_REP_WAIT_WRITE		0
-#define SYNC_REP_WAIT_FLUSH		1
-#define SYNC_REP_WAIT_APPLY		2
-
-#define NUM_SYNC_REP_WAIT_MODE	3
-
-/* syncRepState */
-#define SYNC_REP_NOT_WAITING		0
-#define SYNC_REP_WAITING			1
-#define SYNC_REP_WAIT_COMPLETE		2
-
-/* syncrep_method of SyncRepConfigData */
-#define SYNC_REP_PRIORITY		0
-#define SYNC_REP_QUORUM		1
-
-/*
- * SyncRepGetCandidateStandbys returns an array of these structs,
- * one per candidate synchronous walsender.
- */
-typedef struct SyncRepStandbyData
-{
-	/* Copies of relevant fields from WalSnd shared-memory struct */
-	pid_t		pid;
-	XLogRecPtr	write;
-	XLogRecPtr	flush;
-	XLogRecPtr	apply;
-	int			sync_standby_priority;
-	/* Index of this walsender in the WalSnd shared-memory array */
-	int			walsnd_index;
-	/* This flag indicates whether this struct is about our own process */
-	bool		is_me;
-} SyncRepStandbyData;
-
-/*
- * Struct for the configuration of synchronous replication.
- *
- * Note: this must be a flat representation that can be held in a single
- * chunk of malloc'd memory, so that it can be stored as the "extra" data
- * for the synchronous_standby_names GUC.
- */
-typedef struct SyncRepConfigData
-{
-	int			config_size;	/* total size of this struct, in bytes */
-	int			num_sync;		/* number of sync standbys that we need to
-								 * wait for */
-	uint8		syncrep_method; /* method to choose sync standbys */
-	int			nmembers;		/* number of members in the following list */
-	/* member_names contains nmembers consecutive nul-terminated C strings */
-	char		member_names[FLEXIBLE_ARRAY_MEMBER];
-} SyncRepConfigData;
-
-extern SyncRepConfigData *SyncRepConfig;
-
-/* communication variables for parsing synchronous_standby_names GUC */
-extern SyncRepConfigData *syncrep_parse_result;
-extern char *syncrep_parse_error_msg;
-
-/* user-settable parameters for synchronous replication */
-extern char *SyncRepStandbyNames;
-
-/* called by user backend */
-extern void SyncRepWaitForLSN(XLogRecPtr lsn, bool commit);
-
-/* called at backend exit */
-extern void SyncRepCleanupAtProcExit(void);
-
-/* called by wal sender */
-extern void SyncRepInitConfig(void);
-extern void SyncRepReleaseWaiters(void);
-
-/* called by wal sender and user backend */
-extern int	SyncRepGetCandidateStandbys(SyncRepStandbyData **standbys);
-
-/* called by checkpointer */
-extern void SyncRepUpdateSyncStandbysDefined(void);
-
-/* GUC infrastructure */
-extern bool check_synchronous_standby_names(char **newval, void **extra, GucSource source);
-extern void assign_synchronous_standby_names(const char *newval, void *extra);
-extern void assign_synchronous_commit(int newval, void *extra);
-
-/*
- * Internal functions for parsing synchronous_standby_names grammar,
- * in syncrep_gram.y and syncrep_scanner.l
- */
-extern int	syncrep_yyparse(void);
-extern int	syncrep_yylex(void);
-extern void syncrep_yyerror(const char *str);
-extern void syncrep_scanner_init(const char *query_string);
-extern void syncrep_scanner_finish(void);
-
-#endif							/* _SYNCREP_H */

data/ext/pg_query/include/replication/walreceiver.h

@@ -1,340 +0,0 @@
-/*-------------------------------------------------------------------------
- *
- * walreceiver.h
- *	  Exports from replication/walreceiverfuncs.c.
- *
- * Portions Copyright (c) 2010-2020, PostgreSQL Global Development Group
- *
- * src/include/replication/walreceiver.h
- *
- *-------------------------------------------------------------------------
- */
-#ifndef _WALRECEIVER_H
-#define _WALRECEIVER_H
-
-#include "access/xlog.h"
-#include "access/xlogdefs.h"
-#include "getaddrinfo.h"		/* for NI_MAXHOST */
-#include "pgtime.h"
-#include "port/atomics.h"
-#include "replication/logicalproto.h"
-#include "replication/walsender.h"
-#include "storage/latch.h"
-#include "storage/spin.h"
-#include "utils/tuplestore.h"
-
-/* user-settable parameters */
-extern int	wal_receiver_status_interval;
-extern int	wal_receiver_timeout;
-extern bool hot_standby_feedback;
-
-/*
- * MAXCONNINFO: maximum size of a connection string.
- *
- * XXX: Should this move to pg_config_manual.h?
- */
-#define MAXCONNINFO		1024
-
-/* Can we allow the standby to accept replication connection from another standby? */
-#define AllowCascadeReplication() (EnableHotStandby && max_wal_senders > 0)
-
-/*
- * Values for WalRcv->walRcvState.
- */
-typedef enum
-{
-	WALRCV_STOPPED,				/* stopped and mustn't start up again */
-	WALRCV_STARTING,			/* launched, but the process hasn't
-								 * initialized yet */
-	WALRCV_STREAMING,			/* walreceiver is streaming */
-	WALRCV_WAITING,				/* stopped streaming, waiting for orders */
-	WALRCV_RESTARTING,			/* asked to restart streaming */
-	WALRCV_STOPPING				/* requested to stop, but still running */
-} WalRcvState;
-
-/* Shared memory area for management of walreceiver process */
-typedef struct
-{
-	/*
-	 * PID of currently active walreceiver process, its current state and
-	 * start time (actually, the time at which it was requested to be
-	 * started).
-	 */
-	pid_t		pid;
-	WalRcvState walRcvState;
-	pg_time_t	startTime;
-
-	/*
-	 * receiveStart and receiveStartTLI indicate the first byte position and
-	 * timeline that will be received. When startup process starts the
-	 * walreceiver, it sets these to the point where it wants the streaming to
-	 * begin.
-	 */
-	XLogRecPtr	receiveStart;
-	TimeLineID	receiveStartTLI;
-
-	/*
-	 * flushedUpto-1 is the last byte position that has already been received,
-	 * and receivedTLI is the timeline it came from.  At the first startup of
-	 * walreceiver, these are set to receiveStart and receiveStartTLI. After
-	 * that, walreceiver updates these whenever it flushes the received WAL to
-	 * disk.
-	 */
-	XLogRecPtr	flushedUpto;
-	TimeLineID	receivedTLI;
-
-	/*
-	 * latestChunkStart is the starting byte position of the current "batch"
-	 * of received WAL.  It's actually the same as the previous value of
-	 * flushedUpto before the last flush to disk.  Startup process can use
-	 * this to detect whether it's keeping up or not.
-	 */
-	XLogRecPtr	latestChunkStart;
-
-	/*
-	 * Time of send and receive of any message received.
-	 */
-	TimestampTz lastMsgSendTime;
-	TimestampTz lastMsgReceiptTime;
-
-	/*
-	 * Latest reported end of WAL on the sender
-	 */
-	XLogRecPtr	latestWalEnd;
-	TimestampTz latestWalEndTime;
-
-	/*
-	 * connection string; initially set to connect to the primary, and later
-	 * clobbered to hide security-sensitive fields.
-	 */
-	char		conninfo[MAXCONNINFO];
-
-	/*
-	 * Host name (this can be a host name, an IP address, or a directory path)
-	 * and port number of the active replication connection.
-	 */
-	char		sender_host[NI_MAXHOST];
-	int			sender_port;
-
-	/*
-	 * replication slot name; is also used for walreceiver to connect with the
-	 * primary
-	 */
-	char		slotname[NAMEDATALEN];
-
-	/*
-	 * If it's a temporary replication slot, it needs to be recreated when
-	 * connecting.
-	 */
-	bool		is_temp_slot;
-
-	/* set true once conninfo is ready to display (obfuscated pwds etc) */
-	bool		ready_to_display;
-
-	/*
-	 * Latch used by startup process to wake up walreceiver after telling it
-	 * where to start streaming (after setting receiveStart and
-	 * receiveStartTLI), and also to tell it to send apply feedback to the
-	 * primary whenever specially marked commit records are applied. This is
-	 * normally mapped to procLatch when walreceiver is running.
-	 */
-	Latch	   *latch;
-
-	slock_t		mutex;			/* locks shared variables shown above */
-
-	/*
-	 * Like flushedUpto, but advanced after writing and before flushing,
-	 * without the need to acquire the spin lock.  Data can be read by another
-	 * process up to this point, but shouldn't be used for data integrity
-	 * purposes.
-	 */
-	pg_atomic_uint64 writtenUpto;
-
-	/*
-	 * force walreceiver reply?  This doesn't need to be locked; memory
-	 * barriers for ordering are sufficient.  But we do need atomic fetch and
-	 * store semantics, so use sig_atomic_t.
-	 */
-	sig_atomic_t force_reply;	/* used as a bool */
-} WalRcvData;
-
-extern WalRcvData *WalRcv;
-
-typedef struct
-{
-	bool		logical;		/* True if this is logical replication stream,
-								 * false if physical stream.  */
-	char	   *slotname;		/* Name of the replication slot or NULL. */
-	XLogRecPtr	startpoint;		/* LSN of starting point. */
-
-	union
-	{
-		struct
-		{
-			TimeLineID	startpointTLI;	/* Starting timeline */
-		}			physical;
-		struct
-		{
-			uint32		proto_version;	/* Logical protocol version */
-			List	   *publication_names;	/* String list of publications */
-		}			logical;
-	}			proto;
-} WalRcvStreamOptions;
-
-struct WalReceiverConn;
-typedef struct WalReceiverConn WalReceiverConn;
-
-/*
- * Status of walreceiver query execution.
- *
- * We only define statuses that are currently used.
- */
-typedef enum
-{
-	WALRCV_ERROR,				/* There was error when executing the query. */
-	WALRCV_OK_COMMAND,			/* Query executed utility or replication
-								 * command. */
-	WALRCV_OK_TUPLES,			/* Query returned tuples. */
-	WALRCV_OK_COPY_IN,			/* Query started COPY FROM. */
-	WALRCV_OK_COPY_OUT,			/* Query started COPY TO. */
-	WALRCV_OK_COPY_BOTH			/* Query started COPY BOTH replication
-								 * protocol. */
-} WalRcvExecStatus;
-
-/*
- * Return value for walrcv_exec, returns the status of the execution and
- * tuples if any.
- */
-typedef struct WalRcvExecResult
-{
-	WalRcvExecStatus status;
-	char	   *err;
-	Tuplestorestate *tuplestore;
-	TupleDesc	tupledesc;
-} WalRcvExecResult;
-
-/* libpqwalreceiver hooks */
-typedef WalReceiverConn *(*walrcv_connect_fn) (const char *conninfo, bool logical,
-											   const char *appname,
-											   char **err);
-typedef void (*walrcv_check_conninfo_fn) (const char *conninfo);
-typedef char *(*walrcv_get_conninfo_fn) (WalReceiverConn *conn);
-typedef void (*walrcv_get_senderinfo_fn) (WalReceiverConn *conn,
-										  char **sender_host,
-										  int *sender_port);
-typedef char *(*walrcv_identify_system_fn) (WalReceiverConn *conn,
-											TimeLineID *primary_tli);
-typedef int (*walrcv_server_version_fn) (WalReceiverConn *conn);
-typedef void (*walrcv_readtimelinehistoryfile_fn) (WalReceiverConn *conn,
-												   TimeLineID tli,
-												   char **filename,
-												   char **content, int *size);
-typedef bool (*walrcv_startstreaming_fn) (WalReceiverConn *conn,
-										  const WalRcvStreamOptions *options);
-typedef void (*walrcv_endstreaming_fn) (WalReceiverConn *conn,
-										TimeLineID *next_tli);
-typedef int (*walrcv_receive_fn) (WalReceiverConn *conn, char **buffer,
-								  pgsocket *wait_fd);
-typedef void (*walrcv_send_fn) (WalReceiverConn *conn, const char *buffer,
-								int nbytes);
-typedef char *(*walrcv_create_slot_fn) (WalReceiverConn *conn,
-										const char *slotname, bool temporary,
-										CRSSnapshotAction snapshot_action,
-										XLogRecPtr *lsn);
-typedef pid_t (*walrcv_get_backend_pid_fn) (WalReceiverConn *conn);
-typedef WalRcvExecResult *(*walrcv_exec_fn) (WalReceiverConn *conn,
-											 const char *query,
-											 const int nRetTypes,
-											 const Oid *retTypes);
-typedef void (*walrcv_disconnect_fn) (WalReceiverConn *conn);
-
-typedef struct WalReceiverFunctionsType
-{
-	walrcv_connect_fn walrcv_connect;
-	walrcv_check_conninfo_fn walrcv_check_conninfo;
-	walrcv_get_conninfo_fn walrcv_get_conninfo;
-	walrcv_get_senderinfo_fn walrcv_get_senderinfo;
-	walrcv_identify_system_fn walrcv_identify_system;
-	walrcv_server_version_fn walrcv_server_version;
-	walrcv_readtimelinehistoryfile_fn walrcv_readtimelinehistoryfile;
-	walrcv_startstreaming_fn walrcv_startstreaming;
-	walrcv_endstreaming_fn walrcv_endstreaming;
-	walrcv_receive_fn walrcv_receive;
-	walrcv_send_fn walrcv_send;
-	walrcv_create_slot_fn walrcv_create_slot;
-	walrcv_get_backend_pid_fn walrcv_get_backend_pid;
-	walrcv_exec_fn walrcv_exec;
-	walrcv_disconnect_fn walrcv_disconnect;
-} WalReceiverFunctionsType;
-
-extern PGDLLIMPORT WalReceiverFunctionsType *WalReceiverFunctions;
-
-#define walrcv_connect(conninfo, logical, appname, err) \
-	WalReceiverFunctions->walrcv_connect(conninfo, logical, appname, err)
-#define walrcv_check_conninfo(conninfo) \
-	WalReceiverFunctions->walrcv_check_conninfo(conninfo)
-#define walrcv_get_conninfo(conn) \
-	WalReceiverFunctions->walrcv_get_conninfo(conn)
-#define walrcv_get_senderinfo(conn, sender_host, sender_port) \
-	WalReceiverFunctions->walrcv_get_senderinfo(conn, sender_host, sender_port)
-#define walrcv_identify_system(conn, primary_tli) \
-	WalReceiverFunctions->walrcv_identify_system(conn, primary_tli)
-#define walrcv_server_version(conn) \
-	WalReceiverFunctions->walrcv_server_version(conn)
-#define walrcv_readtimelinehistoryfile(conn, tli, filename, content, size) \
-	WalReceiverFunctions->walrcv_readtimelinehistoryfile(conn, tli, filename, content, size)
-#define walrcv_startstreaming(conn, options) \
-	WalReceiverFunctions->walrcv_startstreaming(conn, options)
-#define walrcv_endstreaming(conn, next_tli) \
-	WalReceiverFunctions->walrcv_endstreaming(conn, next_tli)
-#define walrcv_receive(conn, buffer, wait_fd) \
-	WalReceiverFunctions->walrcv_receive(conn, buffer, wait_fd)
-#define walrcv_send(conn, buffer, nbytes) \
-	WalReceiverFunctions->walrcv_send(conn, buffer, nbytes)
-#define walrcv_create_slot(conn, slotname, temporary, snapshot_action, lsn) \
-	WalReceiverFunctions->walrcv_create_slot(conn, slotname, temporary, snapshot_action, lsn)
-#define walrcv_get_backend_pid(conn) \
-	WalReceiverFunctions->walrcv_get_backend_pid(conn)
-#define walrcv_exec(conn, exec, nRetTypes, retTypes) \
-	WalReceiverFunctions->walrcv_exec(conn, exec, nRetTypes, retTypes)
-#define walrcv_disconnect(conn) \
-	WalReceiverFunctions->walrcv_disconnect(conn)
-
-static inline void
-walrcv_clear_result(WalRcvExecResult *walres)
-{
-	if (!walres)
-		return;
-
-	if (walres->err)
-		pfree(walres->err);
-
-	if (walres->tuplestore)
-		tuplestore_end(walres->tuplestore);
-
-	if (walres->tupledesc)
-		FreeTupleDesc(walres->tupledesc);
-
-	pfree(walres);
-}
-
-/* prototypes for functions in walreceiver.c */
-extern void WalReceiverMain(void) pg_attribute_noreturn();
-extern void ProcessWalRcvInterrupts(void);
-
-/* prototypes for functions in walreceiverfuncs.c */
-extern Size WalRcvShmemSize(void);
-extern void WalRcvShmemInit(void);
-extern void ShutdownWalRcv(void);
-extern bool WalRcvStreaming(void);
-extern bool WalRcvRunning(void);
-extern void RequestXLogStreaming(TimeLineID tli, XLogRecPtr recptr,
-								 const char *conninfo, const char *slotname,
-								 bool create_temp_slot);
-extern XLogRecPtr GetWalRcvFlushRecPtr(XLogRecPtr *latestChunkStart, TimeLineID *receiveTLI);
-extern XLogRecPtr GetWalRcvWriteRecPtr(void);
-extern int	GetReplicationApplyDelay(void);
-extern int	GetReplicationTransferLatency(void);
-extern void WalRcvForceReply(void);
-
-#endif							/* _WALRECEIVER_H */

data/ext/pg_query/include/replication/walsender.h

@@ -1,74 +0,0 @@
-/*-------------------------------------------------------------------------
- *
- * walsender.h
- *	  Exports from replication/walsender.c.
- *
- * Portions Copyright (c) 2010-2020, PostgreSQL Global Development Group
- *
- * src/include/replication/walsender.h
- *
- *-------------------------------------------------------------------------
- */
-#ifndef _WALSENDER_H
-#define _WALSENDER_H
-
-#include <signal.h>
-
-/*
- * What to do with a snapshot in create replication slot command.
- */
-typedef enum
-{
-	CRS_EXPORT_SNAPSHOT,
-	CRS_NOEXPORT_SNAPSHOT,
-	CRS_USE_SNAPSHOT
-} CRSSnapshotAction;
-
-/* global state */
-extern bool am_walsender;
-extern bool am_cascading_walsender;
-extern bool am_db_walsender;
-extern bool wake_wal_senders;
-
-/* user-settable parameters */
-extern int	max_wal_senders;
-extern int	wal_sender_timeout;
-extern bool log_replication_commands;
-
-extern void InitWalSender(void);
-extern bool exec_replication_command(const char *query_string);
-extern void WalSndErrorCleanup(void);
-extern void WalSndResourceCleanup(bool isCommit);
-extern void WalSndSignals(void);
-extern Size WalSndShmemSize(void);
-extern void WalSndShmemInit(void);
-extern void WalSndWakeup(void);
-extern void WalSndInitStopping(void);
-extern void WalSndWaitStopping(void);
-extern void HandleWalSndInitStopping(void);
-extern void WalSndRqstFileReload(void);
-
-/*
- * Remember that we want to wakeup walsenders later
- *
- * This is separated from doing the actual wakeup because the writeout is done
- * while holding contended locks.
- */
-#define WalSndWakeupRequest() \
-	do { wake_wal_senders = true; } while (0)
-
-/*
- * wakeup walsenders if there is work to be done
- */
-#define WalSndWakeupProcessRequests()		\
-	do										\
-	{										\
-		if (wake_wal_senders)				\
-		{									\
-			wake_wal_senders = false;		\
-			if (max_wal_senders > 0)		\
-				WalSndWakeup();				\
-		}									\
-	} while (0)
-
-#endif							/* _WALSENDER_H */

data/ext/pg_query/include/rewrite/prs2lock.h

@@ -1,46 +0,0 @@
-/*-------------------------------------------------------------------------
- *
- * prs2lock.h
- *	  data structures for POSTGRES Rule System II (rewrite rules only)
- *
- * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group
- * Portions Copyright (c) 1994, Regents of the University of California
- *
- * src/include/rewrite/prs2lock.h
- *
- *-------------------------------------------------------------------------
- */
-#ifndef PRS2LOCK_H
-#define PRS2LOCK_H
-
-#include "access/attnum.h"
-#include "nodes/pg_list.h"
-
-/*
- * RewriteRule -
- *	  holds an info for a rewrite rule
- *
- */
-typedef struct RewriteRule
-{
-	Oid			ruleId;
-	CmdType		event;
-	Node	   *qual;
-	List	   *actions;
-	char		enabled;
-	bool		isInstead;
-} RewriteRule;
-
-/*
- * RuleLock -
- *	  all rules that apply to a particular relation. Even though we only
- *	  have the rewrite rule system left and these are not really "locks",
- *	  the name is kept for historical reasons.
- */
-typedef struct RuleLock
-{
-	int			numLocks;
-	RewriteRule **rules;
-} RuleLock;
-
-#endif							/* PRS2LOCK_H */

data/ext/pg_query/include/rewrite/rewriteHandler.h

@@ -1,40 +0,0 @@
-/*-------------------------------------------------------------------------
- *
- * rewriteHandler.h
- *		External interface to query rewriter.
- *
- *
- * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group
- * Portions Copyright (c) 1994, Regents of the University of California
- *
- * src/include/rewrite/rewriteHandler.h
- *
- *-------------------------------------------------------------------------
- */
-#ifndef REWRITEHANDLER_H
-#define REWRITEHANDLER_H
-
-#include "nodes/parsenodes.h"
-#include "utils/relcache.h"
-
-extern List *QueryRewrite(Query *parsetree);
-extern void AcquireRewriteLocks(Query *parsetree,
-								bool forExecute,
-								bool forUpdatePushedDown);
-
-extern Node *build_column_default(Relation rel, int attrno);
-extern void rewriteTargetListUD(Query *parsetree, RangeTblEntry *target_rte,
-								Relation target_relation);
-
-extern void fill_extraUpdatedCols(RangeTblEntry *target_rte,
-								  Relation target_relation);
-
-extern Query *get_view_query(Relation view);
-extern const char *view_query_is_auto_updatable(Query *viewquery,
-												bool check_cols);
-extern int	relation_is_updatable(Oid reloid,
-								  List *outer_reloids,
-								  bool include_triggers,
-								  Bitmapset *include_cols);
-
-#endif							/* REWRITEHANDLER_H */

data/ext/pg_query/include/rewrite/rewriteManip.h

@@ -1,87 +0,0 @@
-/*-------------------------------------------------------------------------
- *
- * rewriteManip.h
- *		Querytree manipulation subroutines for query rewriter.
- *
- *
- * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group
- * Portions Copyright (c) 1994, Regents of the University of California
- *
- * src/include/rewrite/rewriteManip.h
- *
- *-------------------------------------------------------------------------
- */
-#ifndef REWRITEMANIP_H
-#define REWRITEMANIP_H
-
-#include "nodes/parsenodes.h"
-
-struct AttrMap;					/* avoid including attmap.h here */
-
-
-typedef struct replace_rte_variables_context replace_rte_variables_context;
-
-typedef Node *(*replace_rte_variables_callback) (Var *var,
-												 replace_rte_variables_context *context);
-
-struct replace_rte_variables_context
-{
-	replace_rte_variables_callback callback;	/* callback function */
-	void	   *callback_arg;	/* context data for callback function */
-	int			target_varno;	/* RTE index to search for */
-	int			sublevels_up;	/* (current) nesting depth */
-	bool		inserted_sublink;	/* have we inserted a SubLink? */
-};
-
-typedef enum ReplaceVarsNoMatchOption
-{
-	REPLACEVARS_REPORT_ERROR,	/* throw error if no match */
-	REPLACEVARS_CHANGE_VARNO,	/* change the Var's varno, nothing else */
-	REPLACEVARS_SUBSTITUTE_NULL /* replace with a NULL Const */
-} ReplaceVarsNoMatchOption;
-
-
-extern void OffsetVarNodes(Node *node, int offset, int sublevels_up);
-extern void ChangeVarNodes(Node *node, int old_varno, int new_varno,
-						   int sublevels_up);
-extern void IncrementVarSublevelsUp(Node *node, int delta_sublevels_up,
-									int min_sublevels_up);
-extern void IncrementVarSublevelsUp_rtable(List *rtable,
-										   int delta_sublevels_up, int min_sublevels_up);
-
-extern bool rangeTableEntry_used(Node *node, int rt_index,
-								 int sublevels_up);
-
-extern Query *getInsertSelectQuery(Query *parsetree, Query ***subquery_ptr);
-
-extern void AddQual(Query *parsetree, Node *qual);
-extern void AddInvertedQual(Query *parsetree, Node *qual);
-
-extern bool contain_aggs_of_level(Node *node, int levelsup);
-extern int	locate_agg_of_level(Node *node, int levelsup);
-extern bool contain_windowfuncs(Node *node);
-extern int	locate_windowfunc(Node *node);
-extern bool checkExprHasSubLink(Node *node);
-
-extern Node *replace_rte_variables(Node *node,
-								   int target_varno, int sublevels_up,
-								   replace_rte_variables_callback callback,
-								   void *callback_arg,
-								   bool *outer_hasSubLinks);
-extern Node *replace_rte_variables_mutator(Node *node,
-										   replace_rte_variables_context *context);
-
-extern Node *map_variable_attnos(Node *node,
-								 int target_varno, int sublevels_up,
-								 const struct AttrMap *attno_map,
-								 Oid to_rowtype, bool *found_whole_row);
-
-extern Node *ReplaceVarsFromTargetList(Node *node,
-									   int target_varno, int sublevels_up,
-									   RangeTblEntry *target_rte,
-									   List *targetlist,
-									   ReplaceVarsNoMatchOption nomatch_option,
-									   int nomatch_varno,
-									   bool *outer_hasSubLinks);
-
-#endif							/* REWRITEMANIP_H */