embedded-postgres 18.6.0__py3-none-win_amd64.whl

embedded_postgres/pginstall/include/server/replication/walsender_private.h

@@ -0,0 +1,155 @@
+/*-------------------------------------------------------------------------
+ *
+ * walsender_private.h
+ *	  Private definitions from replication/walsender.c.
+ *
+ * Portions Copyright (c) 2010-2025, PostgreSQL Global Development Group
+ *
+ * src/include/replication/walsender_private.h
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef _WALSENDER_PRIVATE_H
+#define _WALSENDER_PRIVATE_H
+
+#include "access/xlog.h"
+#include "lib/ilist.h"
+#include "nodes/nodes.h"
+#include "nodes/replnodes.h"
+#include "replication/syncrep.h"
+#include "storage/condition_variable.h"
+#include "storage/shmem.h"
+#include "storage/spin.h"
+
+typedef enum WalSndState
+{
+	WALSNDSTATE_STARTUP = 0,
+	WALSNDSTATE_BACKUP,
+	WALSNDSTATE_CATCHUP,
+	WALSNDSTATE_STREAMING,
+	WALSNDSTATE_STOPPING,
+} WalSndState;
+
+/*
+ * Each walsender has a WalSnd struct in shared memory.
+ *
+ * This struct is protected by its 'mutex' spinlock field, except that some
+ * members are only written by the walsender process itself, and thus that
+ * process is free to read those members without holding spinlock.  pid and
+ * needreload always require the spinlock to be held for all accesses.
+ */
+typedef struct WalSnd
+{
+	pid_t		pid;			/* this walsender's PID, or 0 if not active */
+
+	WalSndState state;			/* this walsender's state */
+	XLogRecPtr	sentPtr;		/* WAL has been sent up to this point */
+	bool		needreload;		/* does currently-open file need to be
+								 * reloaded? */
+
+	/*
+	 * The xlog locations that have been written, flushed, and applied by
+	 * standby-side. These may be invalid if the standby-side has not offered
+	 * values yet.
+	 */
+	XLogRecPtr	write;
+	XLogRecPtr	flush;
+	XLogRecPtr	apply;
+
+	/* Measured lag times, or -1 for unknown/none. */
+	TimeOffset	writeLag;
+	TimeOffset	flushLag;
+	TimeOffset	applyLag;
+
+	/*
+	 * The priority order of the standby managed by this WALSender, as listed
+	 * in synchronous_standby_names, or 0 if not-listed.
+	 */
+	int			sync_standby_priority;
+
+	/* Protects shared variables in this structure. */
+	slock_t		mutex;
+
+	/*
+	 * Timestamp of the last message received from standby.
+	 */
+	TimestampTz replyTime;
+
+	ReplicationKind kind;
+} WalSnd;
+
+extern PGDLLIMPORT WalSnd *MyWalSnd;
+
+/* There is one WalSndCtl struct for the whole database cluster */
+typedef struct
+{
+	/*
+	 * Synchronous replication queue with one queue per request type.
+	 * Protected by SyncRepLock.
+	 */
+	dlist_head	SyncRepQueue[NUM_SYNC_REP_WAIT_MODE];
+
+	/*
+	 * Current location of the head of the queue. All waiters should have a
+	 * waitLSN that follows this value. Protected by SyncRepLock.
+	 */
+	XLogRecPtr	lsn[NUM_SYNC_REP_WAIT_MODE];
+
+	/*
+	 * Status of data related to the synchronous standbys.  Waiting backends
+	 * can't reload the config file safely, so checkpointer updates this value
+	 * as needed. Protected by SyncRepLock.
+	 */
+	bits8		sync_standbys_status;
+
+	/* used as a registry of physical / logical walsenders to wake */
+	ConditionVariable wal_flush_cv;
+	ConditionVariable wal_replay_cv;
+
+	/*
+	 * Used by physical walsenders holding slots specified in
+	 * synchronized_standby_slots to wake up logical walsenders holding
+	 * logical failover slots when a walreceiver confirms the receipt of LSN.
+	 */
+	ConditionVariable wal_confirm_rcv_cv;
+
+	WalSnd		walsnds[FLEXIBLE_ARRAY_MEMBER];
+} WalSndCtlData;
+
+/* Flags for WalSndCtlData->sync_standbys_status */
+
+/*
+ * Is the synchronous standby data initialized from the GUC?  This is set the
+ * first time synchronous_standby_names is processed by the checkpointer.
+ */
+#define SYNC_STANDBY_INIT			(1 << 0)
+
+/*
+ * Is the synchronous standby data defined?  This is set when
+ * synchronous_standby_names has some data, after being processed by the
+ * checkpointer.
+ */
+#define SYNC_STANDBY_DEFINED		(1 << 1)
+
+extern PGDLLIMPORT WalSndCtlData *WalSndCtl;
+
+
+extern void WalSndSetState(WalSndState state);
+
+/*
+ * Internal functions for parsing the replication grammar, in repl_gram.y and
+ * repl_scanner.l
+ */
+union YYSTYPE;
+#ifndef YY_TYPEDEF_YY_SCANNER_T
+#define YY_TYPEDEF_YY_SCANNER_T
+typedef void *yyscan_t;
+#endif
+extern int	replication_yyparse(Node **replication_parse_result_p, yyscan_t yyscanner);
+extern int	replication_yylex(union YYSTYPE *yylval_param, yyscan_t yyscanner);
+pg_noreturn extern void replication_yyerror(Node **replication_parse_result_p, yyscan_t yyscanner, const char *message);
+extern void replication_scanner_init(const char *str, yyscan_t *yyscannerp);
+extern void replication_scanner_finish(yyscan_t yyscanner);
+extern bool replication_scanner_is_replication_command(yyscan_t yyscanner);
+
+#endif							/* _WALSENDER_PRIVATE_H */

embedded_postgres/pginstall/include/server/replication/worker_internal.h

@@ -0,0 +1,354 @@
+/*-------------------------------------------------------------------------
+ *
+ * worker_internal.h
+ *	  Internal headers shared by logical replication workers.
+ *
+ * Portions Copyright (c) 2016-2025, PostgreSQL Global Development Group
+ *
+ * src/include/replication/worker_internal.h
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef WORKER_INTERNAL_H
+#define WORKER_INTERNAL_H
+
+#include "access/xlogdefs.h"
+#include "catalog/pg_subscription.h"
+#include "datatype/timestamp.h"
+#include "miscadmin.h"
+#include "replication/logicalrelation.h"
+#include "replication/walreceiver.h"
+#include "storage/buffile.h"
+#include "storage/fileset.h"
+#include "storage/lock.h"
+#include "storage/shm_mq.h"
+#include "storage/shm_toc.h"
+#include "storage/spin.h"
+
+/* Different types of worker */
+typedef enum LogicalRepWorkerType
+{
+	WORKERTYPE_UNKNOWN = 0,
+	WORKERTYPE_TABLESYNC,
+	WORKERTYPE_APPLY,
+	WORKERTYPE_PARALLEL_APPLY,
+} LogicalRepWorkerType;
+
+typedef struct LogicalRepWorker
+{
+	/* What type of worker is this? */
+	LogicalRepWorkerType type;
+
+	/* Time at which this worker was launched. */
+	TimestampTz launch_time;
+
+	/* Indicates if this slot is used or free. */
+	bool		in_use;
+
+	/* Increased every time the slot is taken by new worker. */
+	uint16		generation;
+
+	/* Pointer to proc array. NULL if not running. */
+	PGPROC	   *proc;
+
+	/* Database id to connect to. */
+	Oid			dbid;
+
+	/* User to use for connection (will be same as owner of subscription). */
+	Oid			userid;
+
+	/* Subscription id for the worker. */
+	Oid			subid;
+
+	/* Used for initial table synchronization. */
+	Oid			relid;
+	char		relstate;
+	XLogRecPtr	relstate_lsn;
+	slock_t		relmutex;
+
+	/*
+	 * Used to create the changes and subxact files for the streaming
+	 * transactions.  Upon the arrival of the first streaming transaction or
+	 * when the first-time leader apply worker times out while sending changes
+	 * to the parallel apply worker, the fileset will be initialized, and it
+	 * will be deleted when the worker exits.  Under this, separate buffiles
+	 * would be created for each transaction which will be deleted after the
+	 * transaction is finished.
+	 */
+	FileSet    *stream_fileset;
+
+	/*
+	 * PID of leader apply worker if this slot is used for a parallel apply
+	 * worker, InvalidPid otherwise.
+	 */
+	pid_t		leader_pid;
+
+	/* Indicates whether apply can be performed in parallel. */
+	bool		parallel_apply;
+
+	/* Stats. */
+	XLogRecPtr	last_lsn;
+	TimestampTz last_send_time;
+	TimestampTz last_recv_time;
+	XLogRecPtr	reply_lsn;
+	TimestampTz reply_time;
+} LogicalRepWorker;
+
+/*
+ * State of the transaction in parallel apply worker.
+ *
+ * The enum values must have the same order as the transaction state
+ * transitions.
+ */
+typedef enum ParallelTransState
+{
+	PARALLEL_TRANS_UNKNOWN,
+	PARALLEL_TRANS_STARTED,
+	PARALLEL_TRANS_FINISHED,
+} ParallelTransState;
+
+/*
+ * State of fileset used to communicate changes from leader to parallel
+ * apply worker.
+ *
+ * FS_EMPTY indicates an initial state where the leader doesn't need to use
+ * the file to communicate with the parallel apply worker.
+ *
+ * FS_SERIALIZE_IN_PROGRESS indicates that the leader is serializing changes
+ * to the file.
+ *
+ * FS_SERIALIZE_DONE indicates that the leader has serialized all changes to
+ * the file.
+ *
+ * FS_READY indicates that it is now ok for a parallel apply worker to
+ * read the file.
+ */
+typedef enum PartialFileSetState
+{
+	FS_EMPTY,
+	FS_SERIALIZE_IN_PROGRESS,
+	FS_SERIALIZE_DONE,
+	FS_READY,
+} PartialFileSetState;
+
+/*
+ * Struct for sharing information between leader apply worker and parallel
+ * apply workers.
+ */
+typedef struct ParallelApplyWorkerShared
+{
+	slock_t		mutex;
+
+	TransactionId xid;
+
+	/*
+	 * State used to ensure commit ordering.
+	 *
+	 * The parallel apply worker will set it to PARALLEL_TRANS_FINISHED after
+	 * handling the transaction finish commands while the apply leader will
+	 * wait for it to become PARALLEL_TRANS_FINISHED before proceeding in
+	 * transaction finish commands (e.g. STREAM_COMMIT/STREAM_PREPARE/
+	 * STREAM_ABORT).
+	 */
+	ParallelTransState xact_state;
+
+	/* Information from the corresponding LogicalRepWorker slot. */
+	uint16		logicalrep_worker_generation;
+	int			logicalrep_worker_slot_no;
+
+	/*
+	 * Indicates whether there are pending streaming blocks in the queue. The
+	 * parallel apply worker will check it before starting to wait.
+	 */
+	pg_atomic_uint32 pending_stream_count;
+
+	/*
+	 * XactLastCommitEnd from the parallel apply worker. This is required by
+	 * the leader worker so it can update the lsn_mappings.
+	 */
+	XLogRecPtr	last_commit_end;
+
+	/*
+	 * After entering PARTIAL_SERIALIZE mode, the leader apply worker will
+	 * serialize changes to the file, and share the fileset with the parallel
+	 * apply worker when processing the transaction finish command. Then the
+	 * parallel apply worker will apply all the spooled messages.
+	 *
+	 * FileSet is used here instead of SharedFileSet because we need it to
+	 * survive after releasing the shared memory so that the leader apply
+	 * worker can re-use the same fileset for the next streaming transaction.
+	 */
+	PartialFileSetState fileset_state;
+	FileSet		fileset;
+} ParallelApplyWorkerShared;
+
+/*
+ * Information which is used to manage the parallel apply worker.
+ */
+typedef struct ParallelApplyWorkerInfo
+{
+	/*
+	 * This queue is used to send changes from the leader apply worker to the
+	 * parallel apply worker.
+	 */
+	shm_mq_handle *mq_handle;
+
+	/*
+	 * This queue is used to transfer error messages from the parallel apply
+	 * worker to the leader apply worker.
+	 */
+	shm_mq_handle *error_mq_handle;
+
+	dsm_segment *dsm_seg;
+
+	/*
+	 * Indicates whether the leader apply worker needs to serialize the
+	 * remaining changes to a file due to timeout when attempting to send data
+	 * to the parallel apply worker via shared memory.
+	 */
+	bool		serialize_changes;
+
+	/*
+	 * True if the worker is being used to process a parallel apply
+	 * transaction. False indicates this worker is available for re-use.
+	 */
+	bool		in_use;
+
+	ParallelApplyWorkerShared *shared;
+} ParallelApplyWorkerInfo;
+
+/* Main memory context for apply worker. Permanent during worker lifetime. */
+extern PGDLLIMPORT MemoryContext ApplyContext;
+
+extern PGDLLIMPORT MemoryContext ApplyMessageContext;
+
+extern PGDLLIMPORT ErrorContextCallback *apply_error_context_stack;
+
+extern PGDLLIMPORT ParallelApplyWorkerShared *MyParallelShared;
+
+/* libpqreceiver connection */
+extern PGDLLIMPORT struct WalReceiverConn *LogRepWorkerWalRcvConn;
+
+/* Worker and subscription objects. */
+extern PGDLLIMPORT Subscription *MySubscription;
+extern PGDLLIMPORT LogicalRepWorker *MyLogicalRepWorker;
+
+extern PGDLLIMPORT bool in_remote_transaction;
+
+extern PGDLLIMPORT bool InitializingApplyWorker;
+
+extern void logicalrep_worker_attach(int slot);
+extern LogicalRepWorker *logicalrep_worker_find(Oid subid, Oid relid,
+												bool only_running);
+extern List *logicalrep_workers_find(Oid subid, bool only_running,
+									 bool acquire_lock);
+extern bool logicalrep_worker_launch(LogicalRepWorkerType wtype,
+									 Oid dbid, Oid subid, const char *subname,
+									 Oid userid, Oid relid,
+									 dsm_handle subworker_dsm);
+extern void logicalrep_worker_stop(Oid subid, Oid relid);
+extern void logicalrep_pa_worker_stop(ParallelApplyWorkerInfo *winfo);
+extern void logicalrep_worker_wakeup(Oid subid, Oid relid);
+extern void logicalrep_worker_wakeup_ptr(LogicalRepWorker *worker);
+
+extern int	logicalrep_sync_worker_count(Oid subid);
+
+extern void ReplicationOriginNameForLogicalRep(Oid suboid, Oid relid,
+											   char *originname, Size szoriginname);
+
+extern bool AllTablesyncsReady(void);
+extern void UpdateTwoPhaseState(Oid suboid, char new_state);
+
+extern void process_syncing_tables(XLogRecPtr current_lsn);
+extern void invalidate_syncing_table_states(Datum arg, int cacheid,
+											uint32 hashvalue);
+
+extern void stream_start_internal(TransactionId xid, bool first_segment);
+extern void stream_stop_internal(TransactionId xid);
+
+/* Common streaming function to apply all the spooled messages */
+extern void apply_spooled_messages(FileSet *stream_fileset, TransactionId xid,
+								   XLogRecPtr lsn);
+
+extern void apply_dispatch(StringInfo s);
+
+extern void maybe_reread_subscription(void);
+
+extern void stream_cleanup_files(Oid subid, TransactionId xid);
+
+extern void set_stream_options(WalRcvStreamOptions *options,
+							   char *slotname,
+							   XLogRecPtr *origin_startpos);
+
+extern void start_apply(XLogRecPtr origin_startpos);
+
+extern void InitializeLogRepWorker(void);
+
+extern void SetupApplyOrSyncWorker(int worker_slot);
+
+extern void DisableSubscriptionAndExit(void);
+
+extern void store_flush_position(XLogRecPtr remote_lsn, XLogRecPtr local_lsn);
+
+/* Function for apply error callback */
+extern void apply_error_callback(void *arg);
+extern void set_apply_error_context_origin(char *originname);
+
+/* Parallel apply worker setup and interactions */
+extern void pa_allocate_worker(TransactionId xid);
+extern ParallelApplyWorkerInfo *pa_find_worker(TransactionId xid);
+extern void pa_detach_all_error_mq(void);
+
+extern bool pa_send_data(ParallelApplyWorkerInfo *winfo, Size nbytes,
+						 const void *data);
+extern void pa_switch_to_partial_serialize(ParallelApplyWorkerInfo *winfo,
+										   bool stream_locked);
+
+extern void pa_set_xact_state(ParallelApplyWorkerShared *wshared,
+							  ParallelTransState xact_state);
+extern void pa_set_stream_apply_worker(ParallelApplyWorkerInfo *winfo);
+
+extern void pa_start_subtrans(TransactionId current_xid,
+							  TransactionId top_xid);
+extern void pa_reset_subtrans(void);
+extern void pa_stream_abort(LogicalRepStreamAbortData *abort_data);
+extern void pa_set_fileset_state(ParallelApplyWorkerShared *wshared,
+								 PartialFileSetState fileset_state);
+
+extern void pa_lock_stream(TransactionId xid, LOCKMODE lockmode);
+extern void pa_unlock_stream(TransactionId xid, LOCKMODE lockmode);
+
+extern void pa_lock_transaction(TransactionId xid, LOCKMODE lockmode);
+extern void pa_unlock_transaction(TransactionId xid, LOCKMODE lockmode);
+
+extern void pa_decr_and_wait_stream_block(void);
+
+extern void pa_xact_finish(ParallelApplyWorkerInfo *winfo,
+						   XLogRecPtr remote_lsn);
+
+#define isParallelApplyWorker(worker) ((worker)->in_use && \
+									   (worker)->type == WORKERTYPE_PARALLEL_APPLY)
+#define isTablesyncWorker(worker) ((worker)->in_use && \
+								   (worker)->type == WORKERTYPE_TABLESYNC)
+
+static inline bool
+am_tablesync_worker(void)
+{
+	return isTablesyncWorker(MyLogicalRepWorker);
+}
+
+static inline bool
+am_leader_apply_worker(void)
+{
+	Assert(MyLogicalRepWorker->in_use);
+	return (MyLogicalRepWorker->type == WORKERTYPE_APPLY);
+}
+
+static inline bool
+am_parallel_apply_worker(void)
+{
+	Assert(MyLogicalRepWorker->in_use);
+	return isParallelApplyWorker(MyLogicalRepWorker);
+}
+
+#endif							/* WORKER_INTERNAL_H */

embedded_postgres/pginstall/include/server/rewrite/prs2lock.h

@@ -0,0 +1,46 @@
+/*-------------------------------------------------------------------------
+ *
+ * prs2lock.h
+ *	  data structures for POSTGRES Rule System II (rewrite rules only)
+ *
+ * Portions Copyright (c) 1996-2025, 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 */

embedded_postgres/pginstall/include/server/rewrite/rewriteDefine.h

@@ -0,0 +1,44 @@
+/*-------------------------------------------------------------------------
+ *
+ * rewriteDefine.h
+ *
+ *
+ *
+ * Portions Copyright (c) 1996-2025, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/rewrite/rewriteDefine.h
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef REWRITEDEFINE_H
+#define REWRITEDEFINE_H
+
+#include "catalog/objectaddress.h"
+#include "nodes/parsenodes.h"
+#include "utils/relcache.h"
+
+#define RULE_FIRES_ON_ORIGIN	'O'
+#define RULE_FIRES_ALWAYS		'A'
+#define RULE_FIRES_ON_REPLICA	'R'
+#define RULE_DISABLED			'D'
+
+extern ObjectAddress DefineRule(RuleStmt *stmt, const char *queryString);
+
+extern ObjectAddress DefineQueryRewrite(const char *rulename,
+										Oid event_relid,
+										Node *event_qual,
+										CmdType event_type,
+										bool is_instead,
+										bool replace,
+										List *action);
+
+extern ObjectAddress RenameRewriteRule(RangeVar *relation, const char *oldName,
+									   const char *newName);
+
+extern void setRuleCheckAsUser(Node *node, Oid userid);
+
+extern void EnableDisableRule(Relation rel, const char *rulename,
+							  char fires_when);
+
+#endif							/* REWRITEDEFINE_H */

embedded_postgres/pginstall/include/server/rewrite/rewriteHandler.h

@@ -0,0 +1,44 @@
+/*-------------------------------------------------------------------------
+ *
+ * rewriteHandler.h
+ *		External interface to query rewriter.
+ *
+ *
+ * Portions Copyright (c) 1996-2025, 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 Query *get_view_query(Relation view);
+extern bool view_has_instead_trigger(Relation view, CmdType event,
+									 List *mergeActionList);
+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);
+extern void error_view_not_updatable(Relation view,
+									 CmdType command,
+									 List *mergeActionList,
+									 const char *detail);
+
+extern Node *expand_generated_columns_in_expr(Node *node, Relation rel, int rt_index);
+extern Node *build_generation_expression(Relation rel, int attrno);
+
+#endif							/* REWRITEHANDLER_H */