2014-02-01 04:45:17 +01:00
|
|
|
/*-------------------------------------------------------------------------
|
|
|
|
* slot.h
|
|
|
|
* Replication slot management.
|
|
|
|
*
|
2015-01-06 17:43:47 +01:00
|
|
|
* Copyright (c) 2012-2015, PostgreSQL Global Development Group
|
2014-02-01 04:45:17 +01:00
|
|
|
*
|
|
|
|
*-------------------------------------------------------------------------
|
|
|
|
*/
|
|
|
|
#ifndef SLOT_H
|
|
|
|
#define SLOT_H
|
|
|
|
|
|
|
|
#include "fmgr.h"
|
|
|
|
#include "access/xlog.h"
|
|
|
|
#include "access/xlogreader.h"
|
|
|
|
#include "storage/lwlock.h"
|
|
|
|
#include "storage/shmem.h"
|
|
|
|
#include "storage/spin.h"
|
|
|
|
|
Introduce logical decoding.
This feature, building on previous commits, allows the write-ahead log
stream to be decoded into a series of logical changes; that is,
inserts, updates, and deletes and the transactions which contain them.
It is capable of handling decoding even across changes to the schema
of the effected tables. The output format is controlled by a
so-called "output plugin"; an example is included. To make use of
this in a real replication system, the output plugin will need to be
modified to produce output in the format appropriate to that system,
and to perform filtering.
Currently, information can be extracted from the logical decoding
system only via SQL; future commits will add the ability to stream
changes via walsender.
Andres Freund, with review and other contributions from many other
people, including Álvaro Herrera, Abhijit Menon-Sen, Peter Gheogegan,
Kevin Grittner, Robert Haas, Heikki Linnakangas, Fujii Masao, Abhijit
Menon-Sen, Michael Paquier, Simon Riggs, Craig Ringer, and Steve
Singer.
2014-03-03 22:32:18 +01:00
|
|
|
/*
|
|
|
|
* Behaviour of replication slots, upon release or crash.
|
|
|
|
*
|
|
|
|
* Slots marked as PERSISTENT are crashsafe and will not be dropped when
|
|
|
|
* released. Slots marked as EPHEMERAL will be dropped when released or after
|
|
|
|
* restarts.
|
|
|
|
*
|
|
|
|
* EPHEMERAL slots can be made PERSISTENT by calling ReplicationSlotPersist().
|
|
|
|
*/
|
|
|
|
typedef enum ReplicationSlotPersistency
|
|
|
|
{
|
|
|
|
RS_PERSISTENT,
|
|
|
|
RS_EPHEMERAL
|
|
|
|
} ReplicationSlotPersistency;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* On-Disk data of a replication slot, preserved across restarts.
|
|
|
|
*/
|
2014-02-01 04:45:17 +01:00
|
|
|
typedef struct ReplicationSlotPersistentData
|
|
|
|
{
|
|
|
|
/* The slot's identifier */
|
|
|
|
NameData name;
|
|
|
|
|
|
|
|
/* database the slot is active on */
|
|
|
|
Oid database;
|
|
|
|
|
Introduce logical decoding.
This feature, building on previous commits, allows the write-ahead log
stream to be decoded into a series of logical changes; that is,
inserts, updates, and deletes and the transactions which contain them.
It is capable of handling decoding even across changes to the schema
of the effected tables. The output format is controlled by a
so-called "output plugin"; an example is included. To make use of
this in a real replication system, the output plugin will need to be
modified to produce output in the format appropriate to that system,
and to perform filtering.
Currently, information can be extracted from the logical decoding
system only via SQL; future commits will add the ability to stream
changes via walsender.
Andres Freund, with review and other contributions from many other
people, including Álvaro Herrera, Abhijit Menon-Sen, Peter Gheogegan,
Kevin Grittner, Robert Haas, Heikki Linnakangas, Fujii Masao, Abhijit
Menon-Sen, Michael Paquier, Simon Riggs, Craig Ringer, and Steve
Singer.
2014-03-03 22:32:18 +01:00
|
|
|
/*
|
|
|
|
* The slot's behaviour when being dropped (or restored after a crash).
|
|
|
|
*/
|
|
|
|
ReplicationSlotPersistency persistency;
|
|
|
|
|
2014-02-01 04:45:17 +01:00
|
|
|
/*
|
|
|
|
* xmin horizon for data
|
|
|
|
*
|
|
|
|
* NB: This may represent a value that hasn't been written to disk yet;
|
|
|
|
* see notes for effective_xmin, below.
|
|
|
|
*/
|
|
|
|
TransactionId xmin;
|
|
|
|
|
Introduce logical decoding.
This feature, building on previous commits, allows the write-ahead log
stream to be decoded into a series of logical changes; that is,
inserts, updates, and deletes and the transactions which contain them.
It is capable of handling decoding even across changes to the schema
of the effected tables. The output format is controlled by a
so-called "output plugin"; an example is included. To make use of
this in a real replication system, the output plugin will need to be
modified to produce output in the format appropriate to that system,
and to perform filtering.
Currently, information can be extracted from the logical decoding
system only via SQL; future commits will add the ability to stream
changes via walsender.
Andres Freund, with review and other contributions from many other
people, including Álvaro Herrera, Abhijit Menon-Sen, Peter Gheogegan,
Kevin Grittner, Robert Haas, Heikki Linnakangas, Fujii Masao, Abhijit
Menon-Sen, Michael Paquier, Simon Riggs, Craig Ringer, and Steve
Singer.
2014-03-03 22:32:18 +01:00
|
|
|
/*
|
|
|
|
* xmin horizon for catalog tuples
|
|
|
|
*
|
|
|
|
* NB: This may represent a value that hasn't been written to disk yet;
|
|
|
|
* see notes for effective_xmin, below.
|
|
|
|
*/
|
|
|
|
TransactionId catalog_xmin;
|
|
|
|
|
2014-02-01 04:45:17 +01:00
|
|
|
/* oldest LSN that might be required by this replication slot */
|
|
|
|
XLogRecPtr restart_lsn;
|
|
|
|
|
Introduce logical decoding.
This feature, building on previous commits, allows the write-ahead log
stream to be decoded into a series of logical changes; that is,
inserts, updates, and deletes and the transactions which contain them.
It is capable of handling decoding even across changes to the schema
of the effected tables. The output format is controlled by a
so-called "output plugin"; an example is included. To make use of
this in a real replication system, the output plugin will need to be
modified to produce output in the format appropriate to that system,
and to perform filtering.
Currently, information can be extracted from the logical decoding
system only via SQL; future commits will add the ability to stream
changes via walsender.
Andres Freund, with review and other contributions from many other
people, including Álvaro Herrera, Abhijit Menon-Sen, Peter Gheogegan,
Kevin Grittner, Robert Haas, Heikki Linnakangas, Fujii Masao, Abhijit
Menon-Sen, Michael Paquier, Simon Riggs, Craig Ringer, and Steve
Singer.
2014-03-03 22:32:18 +01:00
|
|
|
/* oldest LSN that the client has acked receipt for */
|
|
|
|
XLogRecPtr confirmed_flush;
|
|
|
|
|
|
|
|
/* plugin name */
|
|
|
|
NameData plugin;
|
2014-02-01 04:45:17 +01:00
|
|
|
} ReplicationSlotPersistentData;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Shared memory state of a single replication slot.
|
|
|
|
*/
|
|
|
|
typedef struct ReplicationSlot
|
|
|
|
{
|
|
|
|
/* lock, on same cacheline as effective_xmin */
|
|
|
|
slock_t mutex;
|
|
|
|
|
|
|
|
/* is this slot defined */
|
|
|
|
bool in_use;
|
|
|
|
|
|
|
|
/* is somebody streaming out changes for this slot */
|
|
|
|
bool active;
|
|
|
|
|
|
|
|
/* any outstanding modifications? */
|
|
|
|
bool just_dirtied;
|
|
|
|
bool dirty;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* For logical decoding, it's extremely important that we never remove any
|
|
|
|
* data that's still needed for decoding purposes, even after a crash;
|
|
|
|
* otherwise, decoding will produce wrong answers. Ordinary streaming
|
|
|
|
* replication also needs to prevent old row versions from being removed
|
2014-05-06 18:12:18 +02:00
|
|
|
* too soon, but the worst consequence we might encounter there is
|
|
|
|
* unwanted query cancellations on the standby. Thus, for logical
|
|
|
|
* decoding, this value represents the latest xmin that has actually been
|
|
|
|
* written to disk, whereas for streaming replication, it's just the same
|
|
|
|
* as the persistent value (data.xmin).
|
2014-02-01 04:45:17 +01:00
|
|
|
*/
|
|
|
|
TransactionId effective_xmin;
|
Introduce logical decoding.
This feature, building on previous commits, allows the write-ahead log
stream to be decoded into a series of logical changes; that is,
inserts, updates, and deletes and the transactions which contain them.
It is capable of handling decoding even across changes to the schema
of the effected tables. The output format is controlled by a
so-called "output plugin"; an example is included. To make use of
this in a real replication system, the output plugin will need to be
modified to produce output in the format appropriate to that system,
and to perform filtering.
Currently, information can be extracted from the logical decoding
system only via SQL; future commits will add the ability to stream
changes via walsender.
Andres Freund, with review and other contributions from many other
people, including Álvaro Herrera, Abhijit Menon-Sen, Peter Gheogegan,
Kevin Grittner, Robert Haas, Heikki Linnakangas, Fujii Masao, Abhijit
Menon-Sen, Michael Paquier, Simon Riggs, Craig Ringer, and Steve
Singer.
2014-03-03 22:32:18 +01:00
|
|
|
TransactionId effective_catalog_xmin;
|
2014-02-01 04:45:17 +01:00
|
|
|
|
|
|
|
/* data surviving shutdowns and crashes */
|
|
|
|
ReplicationSlotPersistentData data;
|
|
|
|
|
|
|
|
/* is somebody performing io on this slot? */
|
|
|
|
LWLock *io_in_progress_lock;
|
Introduce logical decoding.
This feature, building on previous commits, allows the write-ahead log
stream to be decoded into a series of logical changes; that is,
inserts, updates, and deletes and the transactions which contain them.
It is capable of handling decoding even across changes to the schema
of the effected tables. The output format is controlled by a
so-called "output plugin"; an example is included. To make use of
this in a real replication system, the output plugin will need to be
modified to produce output in the format appropriate to that system,
and to perform filtering.
Currently, information can be extracted from the logical decoding
system only via SQL; future commits will add the ability to stream
changes via walsender.
Andres Freund, with review and other contributions from many other
people, including Álvaro Herrera, Abhijit Menon-Sen, Peter Gheogegan,
Kevin Grittner, Robert Haas, Heikki Linnakangas, Fujii Masao, Abhijit
Menon-Sen, Michael Paquier, Simon Riggs, Craig Ringer, and Steve
Singer.
2014-03-03 22:32:18 +01:00
|
|
|
|
|
|
|
/* all the remaining data is only used for logical slots */
|
|
|
|
|
|
|
|
/* ----
|
|
|
|
* When the client has confirmed flushes >= candidate_xmin_lsn we can
|
|
|
|
* advance the catalog xmin, when restart_valid has been passed,
|
|
|
|
* restart_lsn can be increased.
|
|
|
|
* ----
|
|
|
|
*/
|
|
|
|
TransactionId candidate_catalog_xmin;
|
|
|
|
XLogRecPtr candidate_xmin_lsn;
|
|
|
|
XLogRecPtr candidate_restart_valid;
|
|
|
|
XLogRecPtr candidate_restart_lsn;
|
2014-02-01 04:45:17 +01:00
|
|
|
} ReplicationSlot;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Shared memory control area for all of replication slots.
|
|
|
|
*/
|
|
|
|
typedef struct ReplicationSlotCtlData
|
|
|
|
{
|
2015-02-21 07:46:43 +01:00
|
|
|
/*
|
|
|
|
* This array should be declared [FLEXIBLE_ARRAY_MEMBER], but for some
|
|
|
|
* reason you can't do that in an otherwise-empty struct.
|
|
|
|
*/
|
2014-02-01 04:45:17 +01:00
|
|
|
ReplicationSlot replication_slots[1];
|
|
|
|
} ReplicationSlotCtlData;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Pointers to shared memory
|
|
|
|
*/
|
|
|
|
extern ReplicationSlotCtlData *ReplicationSlotCtl;
|
|
|
|
extern ReplicationSlot *MyReplicationSlot;
|
|
|
|
|
|
|
|
/* GUCs */
|
|
|
|
extern PGDLLIMPORT int max_replication_slots;
|
|
|
|
|
|
|
|
/* shmem initialization functions */
|
|
|
|
extern Size ReplicationSlotsShmemSize(void);
|
|
|
|
extern void ReplicationSlotsShmemInit(void);
|
|
|
|
|
|
|
|
/* management of individual slots */
|
Introduce logical decoding.
This feature, building on previous commits, allows the write-ahead log
stream to be decoded into a series of logical changes; that is,
inserts, updates, and deletes and the transactions which contain them.
It is capable of handling decoding even across changes to the schema
of the effected tables. The output format is controlled by a
so-called "output plugin"; an example is included. To make use of
this in a real replication system, the output plugin will need to be
modified to produce output in the format appropriate to that system,
and to perform filtering.
Currently, information can be extracted from the logical decoding
system only via SQL; future commits will add the ability to stream
changes via walsender.
Andres Freund, with review and other contributions from many other
people, including Álvaro Herrera, Abhijit Menon-Sen, Peter Gheogegan,
Kevin Grittner, Robert Haas, Heikki Linnakangas, Fujii Masao, Abhijit
Menon-Sen, Michael Paquier, Simon Riggs, Craig Ringer, and Steve
Singer.
2014-03-03 22:32:18 +01:00
|
|
|
extern void ReplicationSlotCreate(const char *name, bool db_specific,
|
2014-05-06 18:12:18 +02:00
|
|
|
ReplicationSlotPersistency p);
|
Introduce logical decoding.
This feature, building on previous commits, allows the write-ahead log
stream to be decoded into a series of logical changes; that is,
inserts, updates, and deletes and the transactions which contain them.
It is capable of handling decoding even across changes to the schema
of the effected tables. The output format is controlled by a
so-called "output plugin"; an example is included. To make use of
this in a real replication system, the output plugin will need to be
modified to produce output in the format appropriate to that system,
and to perform filtering.
Currently, information can be extracted from the logical decoding
system only via SQL; future commits will add the ability to stream
changes via walsender.
Andres Freund, with review and other contributions from many other
people, including Álvaro Herrera, Abhijit Menon-Sen, Peter Gheogegan,
Kevin Grittner, Robert Haas, Heikki Linnakangas, Fujii Masao, Abhijit
Menon-Sen, Michael Paquier, Simon Riggs, Craig Ringer, and Steve
Singer.
2014-03-03 22:32:18 +01:00
|
|
|
extern void ReplicationSlotPersist(void);
|
2014-02-01 04:45:17 +01:00
|
|
|
extern void ReplicationSlotDrop(const char *name);
|
Introduce logical decoding.
This feature, building on previous commits, allows the write-ahead log
stream to be decoded into a series of logical changes; that is,
inserts, updates, and deletes and the transactions which contain them.
It is capable of handling decoding even across changes to the schema
of the effected tables. The output format is controlled by a
so-called "output plugin"; an example is included. To make use of
this in a real replication system, the output plugin will need to be
modified to produce output in the format appropriate to that system,
and to perform filtering.
Currently, information can be extracted from the logical decoding
system only via SQL; future commits will add the ability to stream
changes via walsender.
Andres Freund, with review and other contributions from many other
people, including Álvaro Herrera, Abhijit Menon-Sen, Peter Gheogegan,
Kevin Grittner, Robert Haas, Heikki Linnakangas, Fujii Masao, Abhijit
Menon-Sen, Michael Paquier, Simon Riggs, Craig Ringer, and Steve
Singer.
2014-03-03 22:32:18 +01:00
|
|
|
|
2014-02-01 04:45:17 +01:00
|
|
|
extern void ReplicationSlotAcquire(const char *name);
|
|
|
|
extern void ReplicationSlotRelease(void);
|
|
|
|
extern void ReplicationSlotSave(void);
|
|
|
|
extern void ReplicationSlotMarkDirty(void);
|
|
|
|
|
|
|
|
/* misc stuff */
|
|
|
|
extern bool ReplicationSlotValidateName(const char *name, int elevel);
|
Introduce logical decoding.
This feature, building on previous commits, allows the write-ahead log
stream to be decoded into a series of logical changes; that is,
inserts, updates, and deletes and the transactions which contain them.
It is capable of handling decoding even across changes to the schema
of the effected tables. The output format is controlled by a
so-called "output plugin"; an example is included. To make use of
this in a real replication system, the output plugin will need to be
modified to produce output in the format appropriate to that system,
and to perform filtering.
Currently, information can be extracted from the logical decoding
system only via SQL; future commits will add the ability to stream
changes via walsender.
Andres Freund, with review and other contributions from many other
people, including Álvaro Herrera, Abhijit Menon-Sen, Peter Gheogegan,
Kevin Grittner, Robert Haas, Heikki Linnakangas, Fujii Masao, Abhijit
Menon-Sen, Michael Paquier, Simon Riggs, Craig Ringer, and Steve
Singer.
2014-03-03 22:32:18 +01:00
|
|
|
extern void ReplicationSlotsComputeRequiredXmin(bool already_locked);
|
2014-02-01 04:45:17 +01:00
|
|
|
extern void ReplicationSlotsComputeRequiredLSN(void);
|
Introduce logical decoding.
This feature, building on previous commits, allows the write-ahead log
stream to be decoded into a series of logical changes; that is,
inserts, updates, and deletes and the transactions which contain them.
It is capable of handling decoding even across changes to the schema
of the effected tables. The output format is controlled by a
so-called "output plugin"; an example is included. To make use of
this in a real replication system, the output plugin will need to be
modified to produce output in the format appropriate to that system,
and to perform filtering.
Currently, information can be extracted from the logical decoding
system only via SQL; future commits will add the ability to stream
changes via walsender.
Andres Freund, with review and other contributions from many other
people, including Álvaro Herrera, Abhijit Menon-Sen, Peter Gheogegan,
Kevin Grittner, Robert Haas, Heikki Linnakangas, Fujii Masao, Abhijit
Menon-Sen, Michael Paquier, Simon Riggs, Craig Ringer, and Steve
Singer.
2014-03-03 22:32:18 +01:00
|
|
|
extern XLogRecPtr ReplicationSlotsComputeLogicalRestartLSN(void);
|
|
|
|
extern bool ReplicationSlotsCountDBSlots(Oid dboid, int *nslots, int *nactive);
|
|
|
|
|
2014-06-12 13:23:46 +02:00
|
|
|
extern void StartupReplicationSlots(void);
|
2014-02-01 04:45:17 +01:00
|
|
|
extern void CheckPointReplicationSlots(void);
|
|
|
|
|
|
|
|
extern void CheckSlotRequirements(void);
|
|
|
|
|
|
|
|
/* SQL callable functions */
|
Introduce logical decoding.
This feature, building on previous commits, allows the write-ahead log
stream to be decoded into a series of logical changes; that is,
inserts, updates, and deletes and the transactions which contain them.
It is capable of handling decoding even across changes to the schema
of the effected tables. The output format is controlled by a
so-called "output plugin"; an example is included. To make use of
this in a real replication system, the output plugin will need to be
modified to produce output in the format appropriate to that system,
and to perform filtering.
Currently, information can be extracted from the logical decoding
system only via SQL; future commits will add the ability to stream
changes via walsender.
Andres Freund, with review and other contributions from many other
people, including Álvaro Herrera, Abhijit Menon-Sen, Peter Gheogegan,
Kevin Grittner, Robert Haas, Heikki Linnakangas, Fujii Masao, Abhijit
Menon-Sen, Michael Paquier, Simon Riggs, Craig Ringer, and Steve
Singer.
2014-03-03 22:32:18 +01:00
|
|
|
extern Datum pg_create_physical_replication_slot(PG_FUNCTION_ARGS);
|
|
|
|
extern Datum pg_create_logical_replication_slot(PG_FUNCTION_ARGS);
|
|
|
|
extern Datum pg_drop_replication_slot(PG_FUNCTION_ARGS);
|
2014-02-01 04:45:17 +01:00
|
|
|
extern Datum pg_get_replication_slots(PG_FUNCTION_ARGS);
|
|
|
|
|
2014-05-06 18:12:18 +02:00
|
|
|
#endif /* SLOT_H */
|