You've already forked pgbackrest
mirror of
https://github.com/pgbackrest/pgbackrest.git
synced 2025-07-05 00:28:52 +02:00
2376 lines
88 KiB
C
2376 lines
88 KiB
C
/***********************************************************************************************************************************
|
|
PostgreSQL Types That Vary By Version
|
|
|
|
Portions Copyright (c) 1996-2021, PostgreSQL Global Development Group
|
|
Portions Copyright (c) 1994, Regents of the University of California
|
|
|
|
For each supported release of PostgreSQL check the types in this file to see if they have changed. The easiest way to do this is to
|
|
copy and paste in place and check git to see if there are any diffs. Tabs should be copied as is to make this process easy even
|
|
though the pgBackRest project does not use tabs elsewhere.
|
|
|
|
New versions should always be added to the top of each type's #if block, underneath `PG_VERSION > PG_VERSION_MAX` to cause as little
|
|
churn as possible. This also ensures that new versions will not work until PG_VERSION_MAX and this file have been updated.
|
|
|
|
New data structures do not need to add #elif branches for old versions. See pg_time_t as an example.
|
|
|
|
Comments should be copied with the types they apply to, even if the comment has not changed. This does get repetitive, but has no
|
|
runtime cost and makes the rules a bit easier to follow.
|
|
|
|
If a comment has syntax only changes, then the new version of the comment can be applied to older versions of the type.
|
|
|
|
If a comment has changed in a way that implies a difference in the way the type is used, then a new version of the comment and type
|
|
should be created. See the CheckPoint type difference between 9.5 and 9.6 as an example.
|
|
***********************************************************************************************************************************/
|
|
#include "postgres/interface/static.vendor.h"
|
|
|
|
/***********************************************************************************************************************************
|
|
Types from src/include/c.h
|
|
***********************************************************************************************************************************/
|
|
|
|
// int64 type
|
|
// ---------------------------------------------------------------------------------------------------------------------------------
|
|
#if PG_VERSION > PG_VERSION_MAX
|
|
|
|
#elif PG_VERSION >= PG_VERSION_83
|
|
|
|
typedef int64_t int64;
|
|
|
|
#endif
|
|
|
|
// MultiXactId type
|
|
// ---------------------------------------------------------------------------------------------------------------------------------
|
|
#if PG_VERSION > PG_VERSION_MAX
|
|
|
|
#elif PG_VERSION >= PG_VERSION_83
|
|
|
|
/* MultiXactId must be equivalent to TransactionId, to fit in t_xmax */
|
|
typedef TransactionId MultiXactId;
|
|
|
|
#endif
|
|
|
|
// MultiXactOffset
|
|
// ---------------------------------------------------------------------------------------------------------------------------------
|
|
#if PG_VERSION > PG_VERSION_MAX
|
|
|
|
#elif PG_VERSION >= PG_VERSION_83
|
|
|
|
typedef uint32 MultiXactOffset;
|
|
|
|
#endif
|
|
|
|
/***********************************************************************************************************************************
|
|
Types from src/include/pgtime.h
|
|
***********************************************************************************************************************************/
|
|
|
|
// pg_time_t type
|
|
// ---------------------------------------------------------------------------------------------------------------------------------
|
|
#if PG_VERSION > PG_VERSION_MAX
|
|
|
|
#elif PG_VERSION >= PG_VERSION_84
|
|
|
|
/*
|
|
* The API of this library is generally similar to the corresponding
|
|
* C library functions, except that we use pg_time_t which (we hope) is
|
|
* 64 bits wide, and which is most definitely signed not unsigned.
|
|
*/
|
|
typedef int64 pg_time_t;
|
|
|
|
#endif
|
|
|
|
/***********************************************************************************************************************************
|
|
Types from src/include/postgres_ext.h
|
|
***********************************************************************************************************************************/
|
|
|
|
// Oid Type
|
|
// ---------------------------------------------------------------------------------------------------------------------------------
|
|
#if PG_VERSION > PG_VERSION_MAX
|
|
|
|
#elif PG_VERSION >= PG_VERSION_83
|
|
|
|
/*
|
|
* Object ID is a fundamental type in Postgres.
|
|
*/
|
|
typedef unsigned int Oid;
|
|
|
|
#endif
|
|
|
|
/***********************************************************************************************************************************
|
|
Types from src/include/port/pg_crc32.h
|
|
***********************************************************************************************************************************/
|
|
|
|
// pg_crc32/c type
|
|
// ---------------------------------------------------------------------------------------------------------------------------------
|
|
#if PG_VERSION > PG_VERSION_MAX
|
|
|
|
#elif PG_VERSION >= PG_VERSION_95
|
|
|
|
typedef uint32 pg_crc32c;
|
|
|
|
#elif PG_VERSION >= PG_VERSION_83
|
|
|
|
typedef uint32 pg_crc32;
|
|
|
|
#endif
|
|
|
|
/***********************************************************************************************************************************
|
|
Types from src/include/access/xlogdefs.h
|
|
***********************************************************************************************************************************/
|
|
|
|
// XLogRecPtr type
|
|
// ---------------------------------------------------------------------------------------------------------------------------------
|
|
#if PG_VERSION > PG_VERSION_MAX
|
|
|
|
#elif PG_VERSION >= PG_VERSION_93
|
|
|
|
/*
|
|
* Pointer to a location in the XLOG. These pointers are 64 bits wide,
|
|
* because we don't want them ever to overflow.
|
|
*/
|
|
typedef uint64 XLogRecPtr;
|
|
|
|
#elif PG_VERSION >= PG_VERSION_83
|
|
|
|
/*
|
|
* Pointer to a location in the XLOG. These pointers are 64 bits wide,
|
|
* because we don't want them ever to overflow.
|
|
*
|
|
* NOTE: xrecoff == 0 is used to indicate an invalid pointer. This is OK
|
|
* because we use page headers in the XLOG, so no XLOG record can start
|
|
* right at the beginning of a file.
|
|
*
|
|
* NOTE: the "log file number" is somewhat misnamed, since the actual files
|
|
* making up the XLOG are much smaller than 4Gb. Each actual file is an
|
|
* XLogSegSize-byte "segment" of a logical log file having the indicated
|
|
* xlogid. The log file number and segment number together identify a
|
|
* physical XLOG file. Segment number and offset within the physical file
|
|
* are computed from xrecoff div and mod XLogSegSize.
|
|
*/
|
|
typedef struct XLogRecPtr
|
|
{
|
|
uint32 xlogid; /* log file #, 0 based */
|
|
uint32 xrecoff; /* byte offset of location in log file */
|
|
} XLogRecPtr;
|
|
|
|
#endif
|
|
|
|
// TimeLineID type
|
|
// ---------------------------------------------------------------------------------------------------------------------------------
|
|
#if PG_VERSION > PG_VERSION_MAX
|
|
|
|
#elif PG_VERSION >= PG_VERSION_83
|
|
|
|
/*
|
|
* TimeLineID (TLI) - identifies different database histories to prevent
|
|
* confusion after restoring a prior state of a database installation.
|
|
* TLI does not change in a normal stop/restart of the database (including
|
|
* crash-and-recover cases); but we must assign a new TLI after doing
|
|
* a recovery to a prior state, a/k/a point-in-time recovery. This makes
|
|
* the new WAL logfile sequence we generate distinguishable from the
|
|
* sequence that was generated in the previous incarnation.
|
|
*/
|
|
typedef uint32 TimeLineID;
|
|
|
|
#endif
|
|
|
|
/***********************************************************************************************************************************
|
|
Types from src/include/catalog/catversion.h
|
|
***********************************************************************************************************************************/
|
|
|
|
// CATALOG_VERSION_NO define
|
|
//
|
|
// When PostgreSQL is in alpha/beta/rc the catalog version may change with each release. To prevent breakage during this period
|
|
// define CATATLOG_VERSION_NO_MAX. This will allow the catalog version to "float" through the end of the year. After the PostgreSQL
|
|
// release, remove CATALOG_VERSION_NO_MAX in the next pgBackRest release to lock down the catalog version. A side effect of this is
|
|
// that during the period when the catalog number is allowed to float pgBackRest may misidentify development versions of PostgreSQL
|
|
// for the next release as being an alpha/beta/rc for the current release. This seems a minor issue to prevent breakage.
|
|
// ---------------------------------------------------------------------------------------------------------------------------------
|
|
#if PG_VERSION > PG_VERSION_MAX
|
|
|
|
#elif PG_VERSION >= PG_VERSION_14
|
|
|
|
/*
|
|
* We could use anything we wanted for version numbers, but I recommend
|
|
* following the "YYYYMMDDN" style often used for DNS zone serial numbers.
|
|
* YYYYMMDD are the date of the change, and N is the number of the change
|
|
* on that day. (Hopefully we'll never commit ten independent sets of
|
|
* catalog changes on the same day...)
|
|
*/
|
|
|
|
/* yyyymmddN */
|
|
#define CATALOG_VERSION_NO 202107181
|
|
|
|
#elif PG_VERSION >= PG_VERSION_13
|
|
|
|
/*
|
|
* We could use anything we wanted for version numbers, but I recommend
|
|
* following the "YYYYMMDDN" style often used for DNS zone serial numbers.
|
|
* YYYYMMDD are the date of the change, and N is the number of the change
|
|
* on that day. (Hopefully we'll never commit ten independent sets of
|
|
* catalog changes on the same day...)
|
|
*/
|
|
|
|
/* yyyymmddN */
|
|
#define CATALOG_VERSION_NO 202007201
|
|
|
|
#elif PG_VERSION >= PG_VERSION_12
|
|
|
|
/*
|
|
* We could use anything we wanted for version numbers, but I recommend
|
|
* following the "YYYYMMDDN" style often used for DNS zone serial numbers.
|
|
* YYYYMMDD are the date of the change, and N is the number of the change
|
|
* on that day. (Hopefully we'll never commit ten independent sets of
|
|
* catalog changes on the same day...)
|
|
*/
|
|
|
|
/* yyyymmddN */
|
|
#define CATALOG_VERSION_NO 201909212
|
|
|
|
#elif PG_VERSION >= PG_VERSION_11
|
|
|
|
/*
|
|
* We could use anything we wanted for version numbers, but I recommend
|
|
* following the "YYYYMMDDN" style often used for DNS zone serial numbers.
|
|
* YYYYMMDD are the date of the change, and N is the number of the change
|
|
* on that day. (Hopefully we'll never commit ten independent sets of
|
|
* catalog changes on the same day...)
|
|
*/
|
|
|
|
/* yyyymmddN */
|
|
#define CATALOG_VERSION_NO 201809051
|
|
|
|
#elif PG_VERSION >= PG_VERSION_10
|
|
|
|
/*
|
|
* We could use anything we wanted for version numbers, but I recommend
|
|
* following the "YYYYMMDDN" style often used for DNS zone serial numbers.
|
|
* YYYYMMDD are the date of the change, and N is the number of the change
|
|
* on that day. (Hopefully we'll never commit ten independent sets of
|
|
* catalog changes on the same day...)
|
|
*/
|
|
|
|
/* yyyymmddN */
|
|
#define CATALOG_VERSION_NO 201707211
|
|
|
|
#elif PG_VERSION >= PG_VERSION_96
|
|
|
|
/*
|
|
* We could use anything we wanted for version numbers, but I recommend
|
|
* following the "YYYYMMDDN" style often used for DNS zone serial numbers.
|
|
* YYYYMMDD are the date of the change, and N is the number of the change
|
|
* on that day. (Hopefully we'll never commit ten independent sets of
|
|
* catalog changes on the same day...)
|
|
*/
|
|
|
|
/* yyyymmddN */
|
|
#define CATALOG_VERSION_NO 201608131
|
|
|
|
#elif PG_VERSION >= PG_VERSION_95
|
|
|
|
/*
|
|
* We could use anything we wanted for version numbers, but I recommend
|
|
* following the "YYYYMMDDN" style often used for DNS zone serial numbers.
|
|
* YYYYMMDD are the date of the change, and N is the number of the change
|
|
* on that day. (Hopefully we'll never commit ten independent sets of
|
|
* catalog changes on the same day...)
|
|
*/
|
|
|
|
/* yyyymmddN */
|
|
#define CATALOG_VERSION_NO 201510051
|
|
|
|
#elif PG_VERSION >= PG_VERSION_94
|
|
|
|
/*
|
|
* We could use anything we wanted for version numbers, but I recommend
|
|
* following the "YYYYMMDDN" style often used for DNS zone serial numbers.
|
|
* YYYYMMDD are the date of the change, and N is the number of the change
|
|
* on that day. (Hopefully we'll never commit ten independent sets of
|
|
* catalog changes on the same day...)
|
|
*/
|
|
|
|
/* yyyymmddN */
|
|
#define CATALOG_VERSION_NO 201409291
|
|
|
|
#elif PG_VERSION >= PG_VERSION_93
|
|
|
|
/*
|
|
* We could use anything we wanted for version numbers, but I recommend
|
|
* following the "YYYYMMDDN" style often used for DNS zone serial numbers.
|
|
* YYYYMMDD are the date of the change, and N is the number of the change
|
|
* on that day. (Hopefully we'll never commit ten independent sets of
|
|
* catalog changes on the same day...)
|
|
*/
|
|
|
|
/* yyyymmddN */
|
|
#define CATALOG_VERSION_NO 201306121
|
|
|
|
#elif PG_VERSION >= PG_VERSION_92
|
|
|
|
/*
|
|
* We could use anything we wanted for version numbers, but I recommend
|
|
* following the "YYYYMMDDN" style often used for DNS zone serial numbers.
|
|
* YYYYMMDD are the date of the change, and N is the number of the change
|
|
* on that day. (Hopefully we'll never commit ten independent sets of
|
|
* catalog changes on the same day...)
|
|
*/
|
|
|
|
/* yyyymmddN */
|
|
#define CATALOG_VERSION_NO 201204301
|
|
|
|
#elif PG_VERSION >= PG_VERSION_91
|
|
|
|
/*
|
|
* We could use anything we wanted for version numbers, but I recommend
|
|
* following the "YYYYMMDDN" style often used for DNS zone serial numbers.
|
|
* YYYYMMDD are the date of the change, and N is the number of the change
|
|
* on that day. (Hopefully we'll never commit ten independent sets of
|
|
* catalog changes on the same day...)
|
|
*/
|
|
|
|
/* yyyymmddN */
|
|
#define CATALOG_VERSION_NO 201105231
|
|
|
|
#elif PG_VERSION >= PG_VERSION_90
|
|
|
|
/*
|
|
* We could use anything we wanted for version numbers, but I recommend
|
|
* following the "YYYYMMDDN" style often used for DNS zone serial numbers.
|
|
* YYYYMMDD are the date of the change, and N is the number of the change
|
|
* on that day. (Hopefully we'll never commit ten independent sets of
|
|
* catalog changes on the same day...)
|
|
*/
|
|
|
|
/* yyyymmddN */
|
|
#define CATALOG_VERSION_NO 201008051
|
|
|
|
#elif PG_VERSION >= PG_VERSION_84
|
|
|
|
/*
|
|
* We could use anything we wanted for version numbers, but I recommend
|
|
* following the "YYYYMMDDN" style often used for DNS zone serial numbers.
|
|
* YYYYMMDD are the date of the change, and N is the number of the change
|
|
* on that day. (Hopefully we'll never commit ten independent sets of
|
|
* catalog changes on the same day...)
|
|
*/
|
|
|
|
/* yyyymmddN */
|
|
#define CATALOG_VERSION_NO 200904091
|
|
|
|
|
|
#elif PG_VERSION >= PG_VERSION_83
|
|
|
|
/*
|
|
* We could use anything we wanted for version numbers, but I recommend
|
|
* following the "YYYYMMDDN" style often used for DNS zone serial numbers.
|
|
* YYYYMMDD are the date of the change, and N is the number of the change
|
|
* on that day. (Hopefully we'll never commit ten independent sets of
|
|
* catalog changes on the same day...)
|
|
*/
|
|
|
|
/* yyyymmddN */
|
|
#define CATALOG_VERSION_NO 200711281
|
|
|
|
#endif
|
|
|
|
/***********************************************************************************************************************************
|
|
Types from src/include/access/transam.h
|
|
***********************************************************************************************************************************/
|
|
|
|
// FullTransactionId type
|
|
// ---------------------------------------------------------------------------------------------------------------------------------
|
|
#if PG_VERSION > PG_VERSION_MAX
|
|
|
|
#elif PG_VERSION >= PG_VERSION_12
|
|
|
|
/*
|
|
* A 64 bit value that contains an epoch and a TransactionId. This is
|
|
* wrapped in a struct to prevent implicit conversion to/from TransactionId.
|
|
* Not all values represent valid normal XIDs.
|
|
*/
|
|
typedef struct FullTransactionId
|
|
{
|
|
uint64 value;
|
|
} FullTransactionId;
|
|
|
|
#endif
|
|
|
|
/***********************************************************************************************************************************
|
|
Types from src/include/catalog/pg_control.h
|
|
***********************************************************************************************************************************/
|
|
|
|
// PG_CONTROL_VERSION define
|
|
// ---------------------------------------------------------------------------------------------------------------------------------
|
|
#if PG_VERSION > PG_VERSION_MAX
|
|
|
|
#elif PG_VERSION >= PG_VERSION_13
|
|
|
|
/* Version identifier for this pg_control format */
|
|
#define PG_CONTROL_VERSION 1300
|
|
|
|
#elif PG_VERSION >= PG_VERSION_12
|
|
|
|
/* Version identifier for this pg_control format */
|
|
#define PG_CONTROL_VERSION 1201
|
|
|
|
#elif PG_VERSION >= PG_VERSION_11
|
|
|
|
/* Version identifier for this pg_control format */
|
|
#define PG_CONTROL_VERSION 1100
|
|
|
|
#elif PG_VERSION >= PG_VERSION_10
|
|
|
|
/* Version identifier for this pg_control format */
|
|
#define PG_CONTROL_VERSION 1002
|
|
|
|
#elif PG_VERSION >= PG_VERSION_96
|
|
|
|
/* Version identifier for this pg_control format */
|
|
#define PG_CONTROL_VERSION 960
|
|
|
|
#elif PG_VERSION >= PG_VERSION_94
|
|
|
|
/* Version identifier for this pg_control format */
|
|
#define PG_CONTROL_VERSION 942
|
|
|
|
#elif PG_VERSION >= PG_VERSION_93
|
|
|
|
/* Version identifier for this pg_control format */
|
|
#define PG_CONTROL_VERSION 937
|
|
|
|
#elif PG_VERSION >= PG_VERSION_92
|
|
|
|
/* Version identifier for this pg_control format */
|
|
#define PG_CONTROL_VERSION 922
|
|
|
|
#elif PG_VERSION >= PG_VERSION_90
|
|
|
|
/* Version identifier for this pg_control format */
|
|
#define PG_CONTROL_VERSION 903
|
|
|
|
#elif PG_VERSION >= PG_VERSION_84
|
|
|
|
/* Version identifier for this pg_control format */
|
|
#define PG_CONTROL_VERSION 843
|
|
|
|
#elif PG_VERSION >= PG_VERSION_83
|
|
|
|
/* Version identifier for this pg_control format */
|
|
#define PG_CONTROL_VERSION 833
|
|
|
|
#endif
|
|
|
|
// MOCK_AUTH_NONCE_LEN define
|
|
// ---------------------------------------------------------------------------------------------------------------------------------
|
|
#if PG_VERSION > PG_VERSION_MAX
|
|
|
|
#elif PG_VERSION >= PG_VERSION_10
|
|
|
|
/* Nonce key length, see below */
|
|
#define MOCK_AUTH_NONCE_LEN 32
|
|
|
|
#endif
|
|
|
|
// CheckPoint Type
|
|
// ---------------------------------------------------------------------------------------------------------------------------------
|
|
#if PG_VERSION > PG_VERSION_MAX
|
|
|
|
#elif PG_VERSION >= PG_VERSION_14
|
|
|
|
/*
|
|
* Body of CheckPoint XLOG records. This is declared here because we keep
|
|
* a copy of the latest one in pg_control for possible disaster recovery.
|
|
* Changing this struct requires a PG_CONTROL_VERSION bump.
|
|
*/
|
|
typedef struct CheckPoint
|
|
{
|
|
XLogRecPtr redo; /* next RecPtr available when we began to
|
|
* create CheckPoint (i.e. REDO start point) */
|
|
TimeLineID ThisTimeLineID; /* current TLI */
|
|
TimeLineID PrevTimeLineID; /* previous TLI, if this record begins a new
|
|
* timeline (equals ThisTimeLineID otherwise) */
|
|
bool fullPageWrites; /* current full_page_writes */
|
|
FullTransactionId nextXid; /* next free transaction ID */
|
|
Oid nextOid; /* next free OID */
|
|
MultiXactId nextMulti; /* next free MultiXactId */
|
|
MultiXactOffset nextMultiOffset; /* next free MultiXact offset */
|
|
TransactionId oldestXid; /* cluster-wide minimum datfrozenxid */
|
|
Oid oldestXidDB; /* database with minimum datfrozenxid */
|
|
MultiXactId oldestMulti; /* cluster-wide minimum datminmxid */
|
|
Oid oldestMultiDB; /* database with minimum datminmxid */
|
|
pg_time_t time; /* time stamp of checkpoint */
|
|
TransactionId oldestCommitTsXid; /* oldest Xid with valid commit
|
|
* timestamp */
|
|
TransactionId newestCommitTsXid; /* newest Xid with valid commit
|
|
* timestamp */
|
|
|
|
/*
|
|
* Oldest XID still running. This is only needed to initialize hot standby
|
|
* mode from an online checkpoint, so we only bother calculating this for
|
|
* online checkpoints and only when wal_level is replica. Otherwise it's
|
|
* set to InvalidTransactionId.
|
|
*/
|
|
TransactionId oldestActiveXid;
|
|
} CheckPoint;
|
|
|
|
#elif PG_VERSION >= PG_VERSION_12
|
|
|
|
/*
|
|
* Body of CheckPoint XLOG records. This is declared here because we keep
|
|
* a copy of the latest one in pg_control for possible disaster recovery.
|
|
* Changing this struct requires a PG_CONTROL_VERSION bump.
|
|
*/
|
|
typedef struct CheckPoint
|
|
{
|
|
XLogRecPtr redo; /* next RecPtr available when we began to
|
|
* create CheckPoint (i.e. REDO start point) */
|
|
TimeLineID ThisTimeLineID; /* current TLI */
|
|
TimeLineID PrevTimeLineID; /* previous TLI, if this record begins a new
|
|
* timeline (equals ThisTimeLineID otherwise) */
|
|
bool fullPageWrites; /* current full_page_writes */
|
|
FullTransactionId nextFullXid; /* next free full transaction ID */
|
|
Oid nextOid; /* next free OID */
|
|
MultiXactId nextMulti; /* next free MultiXactId */
|
|
MultiXactOffset nextMultiOffset; /* next free MultiXact offset */
|
|
TransactionId oldestXid; /* cluster-wide minimum datfrozenxid */
|
|
Oid oldestXidDB; /* database with minimum datfrozenxid */
|
|
MultiXactId oldestMulti; /* cluster-wide minimum datminmxid */
|
|
Oid oldestMultiDB; /* database with minimum datminmxid */
|
|
pg_time_t time; /* time stamp of checkpoint */
|
|
TransactionId oldestCommitTsXid; /* oldest Xid with valid commit
|
|
* timestamp */
|
|
TransactionId newestCommitTsXid; /* newest Xid with valid commit
|
|
* timestamp */
|
|
|
|
/*
|
|
* Oldest XID still running. This is only needed to initialize hot standby
|
|
* mode from an online checkpoint, so we only bother calculating this for
|
|
* online checkpoints and only when wal_level is replica. Otherwise it's
|
|
* set to InvalidTransactionId.
|
|
*/
|
|
TransactionId oldestActiveXid;
|
|
} CheckPoint;
|
|
|
|
#elif PG_VERSION >= PG_VERSION_96
|
|
|
|
/*
|
|
* Body of CheckPoint XLOG records. This is declared here because we keep
|
|
* a copy of the latest one in pg_control for possible disaster recovery.
|
|
* Changing this struct requires a PG_CONTROL_VERSION bump.
|
|
*/
|
|
typedef struct CheckPoint
|
|
{
|
|
XLogRecPtr redo; /* next RecPtr available when we began to
|
|
* create CheckPoint (i.e. REDO start point) */
|
|
TimeLineID ThisTimeLineID; /* current TLI */
|
|
TimeLineID PrevTimeLineID; /* previous TLI, if this record begins a new
|
|
* timeline (equals ThisTimeLineID otherwise) */
|
|
bool fullPageWrites; /* current full_page_writes */
|
|
uint32 nextXidEpoch; /* higher-order bits of nextXid */
|
|
TransactionId nextXid; /* next free XID */
|
|
Oid nextOid; /* next free OID */
|
|
MultiXactId nextMulti; /* next free MultiXactId */
|
|
MultiXactOffset nextMultiOffset; /* next free MultiXact offset */
|
|
TransactionId oldestXid; /* cluster-wide minimum datfrozenxid */
|
|
Oid oldestXidDB; /* database with minimum datfrozenxid */
|
|
MultiXactId oldestMulti; /* cluster-wide minimum datminmxid */
|
|
Oid oldestMultiDB; /* database with minimum datminmxid */
|
|
pg_time_t time; /* time stamp of checkpoint */
|
|
TransactionId oldestCommitTsXid; /* oldest Xid with valid commit
|
|
* timestamp */
|
|
TransactionId newestCommitTsXid; /* newest Xid with valid commit
|
|
* timestamp */
|
|
|
|
/*
|
|
* Oldest XID still running. This is only needed to initialize hot standby
|
|
* mode from an online checkpoint, so we only bother calculating this for
|
|
* online checkpoints and only when wal_level is replica. Otherwise it's
|
|
* set to InvalidTransactionId.
|
|
*/
|
|
TransactionId oldestActiveXid;
|
|
} CheckPoint;
|
|
|
|
#elif PG_VERSION >= PG_VERSION_95
|
|
|
|
/*
|
|
* Body of CheckPoint XLOG records. This is declared here because we keep
|
|
* a copy of the latest one in pg_control for possible disaster recovery.
|
|
* Changing this struct requires a PG_CONTROL_VERSION bump.
|
|
*/
|
|
typedef struct CheckPoint
|
|
{
|
|
XLogRecPtr redo; /* next RecPtr available when we began to
|
|
* create CheckPoint (i.e. REDO start point) */
|
|
TimeLineID ThisTimeLineID; /* current TLI */
|
|
TimeLineID PrevTimeLineID; /* previous TLI, if this record begins a new
|
|
* timeline (equals ThisTimeLineID otherwise) */
|
|
bool fullPageWrites; /* current full_page_writes */
|
|
uint32 nextXidEpoch; /* higher-order bits of nextXid */
|
|
TransactionId nextXid; /* next free XID */
|
|
Oid nextOid; /* next free OID */
|
|
MultiXactId nextMulti; /* next free MultiXactId */
|
|
MultiXactOffset nextMultiOffset; /* next free MultiXact offset */
|
|
TransactionId oldestXid; /* cluster-wide minimum datfrozenxid */
|
|
Oid oldestXidDB; /* database with minimum datfrozenxid */
|
|
MultiXactId oldestMulti; /* cluster-wide minimum datminmxid */
|
|
Oid oldestMultiDB; /* database with minimum datminmxid */
|
|
pg_time_t time; /* time stamp of checkpoint */
|
|
TransactionId oldestCommitTsXid; /* oldest Xid with valid commit
|
|
* timestamp */
|
|
TransactionId newestCommitTsXid; /* newest Xid with valid commit
|
|
* timestamp */
|
|
|
|
/*
|
|
* Oldest XID still running. This is only needed to initialize hot standby
|
|
* mode from an online checkpoint, so we only bother calculating this for
|
|
* online checkpoints and only when wal_level is hot_standby. Otherwise
|
|
* it's set to InvalidTransactionId.
|
|
*/
|
|
TransactionId oldestActiveXid;
|
|
} CheckPoint;
|
|
|
|
#elif PG_VERSION >= PG_VERSION_93
|
|
|
|
/*
|
|
* Body of CheckPoint XLOG records. This is declared here because we keep
|
|
* a copy of the latest one in pg_control for possible disaster recovery.
|
|
* Changing this struct requires a PG_CONTROL_VERSION bump.
|
|
*/
|
|
typedef struct CheckPoint
|
|
{
|
|
XLogRecPtr redo; /* next RecPtr available when we began to
|
|
* create CheckPoint (i.e. REDO start point) */
|
|
TimeLineID ThisTimeLineID; /* current TLI */
|
|
TimeLineID PrevTimeLineID; /* previous TLI, if this record begins a new
|
|
* timeline (equals ThisTimeLineID otherwise) */
|
|
bool fullPageWrites; /* current full_page_writes */
|
|
uint32 nextXidEpoch; /* higher-order bits of nextXid */
|
|
TransactionId nextXid; /* next free XID */
|
|
Oid nextOid; /* next free OID */
|
|
MultiXactId nextMulti; /* next free MultiXactId */
|
|
MultiXactOffset nextMultiOffset; /* next free MultiXact offset */
|
|
TransactionId oldestXid; /* cluster-wide minimum datfrozenxid */
|
|
Oid oldestXidDB; /* database with minimum datfrozenxid */
|
|
MultiXactId oldestMulti; /* cluster-wide minimum datminmxid */
|
|
Oid oldestMultiDB; /* database with minimum datminmxid */
|
|
pg_time_t time; /* time stamp of checkpoint */
|
|
|
|
/*
|
|
* Oldest XID still running. This is only needed to initialize hot standby
|
|
* mode from an online checkpoint, so we only bother calculating this for
|
|
* online checkpoints and only when wal_level is hot_standby. Otherwise
|
|
* it's set to InvalidTransactionId.
|
|
*/
|
|
TransactionId oldestActiveXid;
|
|
} CheckPoint;
|
|
|
|
#elif PG_VERSION >= PG_VERSION_92
|
|
|
|
/*
|
|
* Body of CheckPoint XLOG records. This is declared here because we keep
|
|
* a copy of the latest one in pg_control for possible disaster recovery.
|
|
* Changing this struct requires a PG_CONTROL_VERSION bump.
|
|
*/
|
|
typedef struct CheckPoint
|
|
{
|
|
XLogRecPtr redo; /* next RecPtr available when we began to
|
|
* create CheckPoint (i.e. REDO start point) */
|
|
TimeLineID ThisTimeLineID; /* current TLI */
|
|
bool fullPageWrites; /* current full_page_writes */
|
|
uint32 nextXidEpoch; /* higher-order bits of nextXid */
|
|
TransactionId nextXid; /* next free XID */
|
|
Oid nextOid; /* next free OID */
|
|
MultiXactId nextMulti; /* next free MultiXactId */
|
|
MultiXactOffset nextMultiOffset; /* next free MultiXact offset */
|
|
TransactionId oldestXid; /* cluster-wide minimum datfrozenxid */
|
|
Oid oldestXidDB; /* database with minimum datfrozenxid */
|
|
pg_time_t time; /* time stamp of checkpoint */
|
|
|
|
/*
|
|
* Oldest XID still running. This is only needed to initialize hot standby
|
|
* mode from an online checkpoint, so we only bother calculating this for
|
|
* online checkpoints and only when wal_level is hot_standby. Otherwise
|
|
* it's set to InvalidTransactionId.
|
|
*/
|
|
TransactionId oldestActiveXid;
|
|
} CheckPoint;
|
|
|
|
#elif PG_VERSION >= PG_VERSION_90
|
|
|
|
/*
|
|
* Body of CheckPoint XLOG records. This is declared here because we keep
|
|
* a copy of the latest one in pg_control for possible disaster recovery.
|
|
* Changing this struct requires a PG_CONTROL_VERSION bump.
|
|
*/
|
|
typedef struct CheckPoint
|
|
{
|
|
XLogRecPtr redo; /* next RecPtr available when we began to
|
|
* create CheckPoint (i.e. REDO start point) */
|
|
TimeLineID ThisTimeLineID; /* current TLI */
|
|
uint32 nextXidEpoch; /* higher-order bits of nextXid */
|
|
TransactionId nextXid; /* next free XID */
|
|
Oid nextOid; /* next free OID */
|
|
MultiXactId nextMulti; /* next free MultiXactId */
|
|
MultiXactOffset nextMultiOffset; /* next free MultiXact offset */
|
|
TransactionId oldestXid; /* cluster-wide minimum datfrozenxid */
|
|
Oid oldestXidDB; /* database with minimum datfrozenxid */
|
|
pg_time_t time; /* time stamp of checkpoint */
|
|
|
|
/*
|
|
* Oldest XID still running. This is only needed to initialize hot standby
|
|
* mode from an online checkpoint, so we only bother calculating this for
|
|
* online checkpoints and only when wal_level is hot_standby. Otherwise
|
|
* it's set to InvalidTransactionId.
|
|
*/
|
|
TransactionId oldestActiveXid;
|
|
} CheckPoint;
|
|
|
|
#elif PG_VERSION >= PG_VERSION_84
|
|
|
|
/*
|
|
* Body of CheckPoint XLOG records. This is declared here because we keep
|
|
* a copy of the latest one in pg_control for possible disaster recovery.
|
|
*/
|
|
typedef struct CheckPoint
|
|
{
|
|
XLogRecPtr redo; /* next RecPtr available when we began to
|
|
* create CheckPoint (i.e. REDO start point) */
|
|
TimeLineID ThisTimeLineID; /* current TLI */
|
|
uint32 nextXidEpoch; /* higher-order bits of nextXid */
|
|
TransactionId nextXid; /* next free XID */
|
|
Oid nextOid; /* next free OID */
|
|
MultiXactId nextMulti; /* next free MultiXactId */
|
|
MultiXactOffset nextMultiOffset; /* next free MultiXact offset */
|
|
pg_time_t time; /* time stamp of checkpoint */
|
|
} CheckPoint;
|
|
|
|
#elif PG_VERSION >= PG_VERSION_83
|
|
|
|
/*
|
|
* Body of CheckPoint XLOG records. This is declared here because we keep
|
|
* a copy of the latest one in pg_control for possible disaster recovery.
|
|
*/
|
|
typedef struct CheckPoint
|
|
{
|
|
XLogRecPtr redo; /* next RecPtr available when we began to
|
|
* create CheckPoint (i.e. REDO start point) */
|
|
TimeLineID ThisTimeLineID; /* current TLI */
|
|
uint32 nextXidEpoch; /* higher-order bits of nextXid */
|
|
TransactionId nextXid; /* next free XID */
|
|
Oid nextOid; /* next free OID */
|
|
MultiXactId nextMulti; /* next free MultiXactId */
|
|
MultiXactOffset nextMultiOffset; /* next free MultiXact offset */
|
|
time_t time; /* time stamp of checkpoint */
|
|
} CheckPoint;
|
|
|
|
#endif
|
|
|
|
// DBState enum
|
|
// ---------------------------------------------------------------------------------------------------------------------------------
|
|
#if PG_VERSION > PG_VERSION_MAX
|
|
|
|
#elif PG_VERSION >= PG_VERSION_91
|
|
|
|
/*
|
|
* System status indicator. Note this is stored in pg_control; if you change
|
|
* it, you must bump PG_CONTROL_VERSION
|
|
*/
|
|
typedef enum DBState
|
|
{
|
|
DB_STARTUP = 0,
|
|
DB_SHUTDOWNED,
|
|
DB_SHUTDOWNED_IN_RECOVERY,
|
|
DB_SHUTDOWNING,
|
|
DB_IN_CRASH_RECOVERY,
|
|
DB_IN_ARCHIVE_RECOVERY,
|
|
DB_IN_PRODUCTION
|
|
} DBState;
|
|
|
|
#elif PG_VERSION >= PG_VERSION_83
|
|
|
|
/* System status indicator */
|
|
typedef enum DBState
|
|
{
|
|
DB_STARTUP = 0,
|
|
DB_SHUTDOWNED,
|
|
DB_SHUTDOWNING,
|
|
DB_IN_CRASH_RECOVERY,
|
|
DB_IN_ARCHIVE_RECOVERY,
|
|
DB_IN_PRODUCTION
|
|
} DBState;
|
|
|
|
#endif
|
|
|
|
// LOCALE_NAME_BUFLEN define
|
|
// ---------------------------------------------------------------------------------------------------------------------------------
|
|
#if PG_VERSION > PG_VERSION_MAX
|
|
|
|
#elif PG_VERSION >= PG_VERSION_84
|
|
|
|
#elif PG_VERSION >= PG_VERSION_83
|
|
|
|
#define LOCALE_NAME_BUFLEN 128
|
|
|
|
#endif
|
|
|
|
// ControlFileData type
|
|
// ---------------------------------------------------------------------------------------------------------------------------------
|
|
#if PG_VERSION > PG_VERSION_MAX
|
|
|
|
#elif PG_VERSION >= PG_VERSION_13
|
|
|
|
/*
|
|
* Contents of pg_control.
|
|
*/
|
|
typedef struct ControlFileData
|
|
{
|
|
/*
|
|
* Unique system identifier --- to ensure we match up xlog files with the
|
|
* installation that produced them.
|
|
*/
|
|
uint64 system_identifier;
|
|
|
|
/*
|
|
* Version identifier information. Keep these fields at the same offset,
|
|
* especially pg_control_version; they won't be real useful if they move
|
|
* around. (For historical reasons they must be 8 bytes into the file
|
|
* rather than immediately at the front.)
|
|
*
|
|
* pg_control_version identifies the format of pg_control itself.
|
|
* catalog_version_no identifies the format of the system catalogs.
|
|
*
|
|
* There are additional version identifiers in individual files; for
|
|
* example, WAL logs contain per-page magic numbers that can serve as
|
|
* version cues for the WAL log.
|
|
*/
|
|
uint32 pg_control_version; /* PG_CONTROL_VERSION */
|
|
uint32 catalog_version_no; /* see catversion.h */
|
|
|
|
/*
|
|
* System status data
|
|
*/
|
|
DBState state; /* see enum above */
|
|
pg_time_t time; /* time stamp of last pg_control update */
|
|
XLogRecPtr checkPoint; /* last check point record ptr */
|
|
|
|
CheckPoint checkPointCopy; /* copy of last check point record */
|
|
|
|
XLogRecPtr unloggedLSN; /* current fake LSN value, for unlogged rels */
|
|
|
|
/*
|
|
* These two values determine the minimum point we must recover up to
|
|
* before starting up:
|
|
*
|
|
* minRecoveryPoint is updated to the latest replayed LSN whenever we
|
|
* flush a data change during archive recovery. That guards against
|
|
* starting archive recovery, aborting it, and restarting with an earlier
|
|
* stop location. If we've already flushed data changes from WAL record X
|
|
* to disk, we mustn't start up until we reach X again. Zero when not
|
|
* doing archive recovery.
|
|
*
|
|
* backupStartPoint is the redo pointer of the backup start checkpoint, if
|
|
* we are recovering from an online backup and haven't reached the end of
|
|
* backup yet. It is reset to zero when the end of backup is reached, and
|
|
* we mustn't start up before that. A boolean would suffice otherwise, but
|
|
* we use the redo pointer as a cross-check when we see an end-of-backup
|
|
* record, to make sure the end-of-backup record corresponds the base
|
|
* backup we're recovering from.
|
|
*
|
|
* backupEndPoint is the backup end location, if we are recovering from an
|
|
* online backup which was taken from the standby and haven't reached the
|
|
* end of backup yet. It is initialized to the minimum recovery point in
|
|
* pg_control which was backed up last. It is reset to zero when the end
|
|
* of backup is reached, and we mustn't start up before that.
|
|
*
|
|
* If backupEndRequired is true, we know for sure that we're restoring
|
|
* from a backup, and must see a backup-end record before we can safely
|
|
* start up. If it's false, but backupStartPoint is set, a backup_label
|
|
* file was found at startup but it may have been a leftover from a stray
|
|
* pg_start_backup() call, not accompanied by pg_stop_backup().
|
|
*/
|
|
XLogRecPtr minRecoveryPoint;
|
|
TimeLineID minRecoveryPointTLI;
|
|
XLogRecPtr backupStartPoint;
|
|
XLogRecPtr backupEndPoint;
|
|
bool backupEndRequired;
|
|
|
|
/*
|
|
* Parameter settings that determine if the WAL can be used for archival
|
|
* or hot standby.
|
|
*/
|
|
int wal_level;
|
|
bool wal_log_hints;
|
|
int MaxConnections;
|
|
int max_worker_processes;
|
|
int max_wal_senders;
|
|
int max_prepared_xacts;
|
|
int max_locks_per_xact;
|
|
bool track_commit_timestamp;
|
|
|
|
/*
|
|
* This data is used to check for hardware-architecture compatibility of
|
|
* the database and the backend executable. We need not check endianness
|
|
* explicitly, since the pg_control version will surely look wrong to a
|
|
* machine of different endianness, but we do need to worry about MAXALIGN
|
|
* and floating-point format. (Note: storage layout nominally also
|
|
* depends on SHORTALIGN and INTALIGN, but in practice these are the same
|
|
* on all architectures of interest.)
|
|
*
|
|
* Testing just one double value is not a very bulletproof test for
|
|
* floating-point compatibility, but it will catch most cases.
|
|
*/
|
|
uint32 maxAlign; /* alignment requirement for tuples */
|
|
double floatFormat; /* constant 1234567.0 */
|
|
#define FLOATFORMAT_VALUE 1234567.0
|
|
|
|
/*
|
|
* This data is used to make sure that configuration of this database is
|
|
* compatible with the backend executable.
|
|
*/
|
|
uint32 blcksz; /* data block size for this DB */
|
|
uint32 relseg_size; /* blocks per segment of large relation */
|
|
|
|
uint32 xlog_blcksz; /* block size within WAL files */
|
|
uint32 xlog_seg_size; /* size of each WAL segment */
|
|
|
|
uint32 nameDataLen; /* catalog name field width */
|
|
uint32 indexMaxKeys; /* max number of columns in an index */
|
|
|
|
uint32 toast_max_chunk_size; /* chunk size in TOAST tables */
|
|
uint32 loblksize; /* chunk size in pg_largeobject */
|
|
|
|
bool float8ByVal; /* float8, int8, etc pass-by-value? */
|
|
|
|
/* Are data pages protected by checksums? Zero if no checksum version */
|
|
uint32 data_checksum_version;
|
|
|
|
/*
|
|
* Random nonce, used in authentication requests that need to proceed
|
|
* based on values that are cluster-unique, like a SASL exchange that
|
|
* failed at an early stage.
|
|
*/
|
|
char mock_authentication_nonce[MOCK_AUTH_NONCE_LEN];
|
|
|
|
/* CRC of all above ... MUST BE LAST! */
|
|
pg_crc32c crc;
|
|
} ControlFileData;
|
|
|
|
#elif PG_VERSION >= PG_VERSION_12
|
|
|
|
/*
|
|
* Contents of pg_control.
|
|
*/
|
|
typedef struct ControlFileData
|
|
{
|
|
/*
|
|
* Unique system identifier --- to ensure we match up xlog files with the
|
|
* installation that produced them.
|
|
*/
|
|
uint64 system_identifier;
|
|
|
|
/*
|
|
* Version identifier information. Keep these fields at the same offset,
|
|
* especially pg_control_version; they won't be real useful if they move
|
|
* around. (For historical reasons they must be 8 bytes into the file
|
|
* rather than immediately at the front.)
|
|
*
|
|
* pg_control_version identifies the format of pg_control itself.
|
|
* catalog_version_no identifies the format of the system catalogs.
|
|
*
|
|
* There are additional version identifiers in individual files; for
|
|
* example, WAL logs contain per-page magic numbers that can serve as
|
|
* version cues for the WAL log.
|
|
*/
|
|
uint32 pg_control_version; /* PG_CONTROL_VERSION */
|
|
uint32 catalog_version_no; /* see catversion.h */
|
|
|
|
/*
|
|
* System status data
|
|
*/
|
|
DBState state; /* see enum above */
|
|
pg_time_t time; /* time stamp of last pg_control update */
|
|
XLogRecPtr checkPoint; /* last check point record ptr */
|
|
|
|
CheckPoint checkPointCopy; /* copy of last check point record */
|
|
|
|
XLogRecPtr unloggedLSN; /* current fake LSN value, for unlogged rels */
|
|
|
|
/*
|
|
* These two values determine the minimum point we must recover up to
|
|
* before starting up:
|
|
*
|
|
* minRecoveryPoint is updated to the latest replayed LSN whenever we
|
|
* flush a data change during archive recovery. That guards against
|
|
* starting archive recovery, aborting it, and restarting with an earlier
|
|
* stop location. If we've already flushed data changes from WAL record X
|
|
* to disk, we mustn't start up until we reach X again. Zero when not
|
|
* doing archive recovery.
|
|
*
|
|
* backupStartPoint is the redo pointer of the backup start checkpoint, if
|
|
* we are recovering from an online backup and haven't reached the end of
|
|
* backup yet. It is reset to zero when the end of backup is reached, and
|
|
* we mustn't start up before that. A boolean would suffice otherwise, but
|
|
* we use the redo pointer as a cross-check when we see an end-of-backup
|
|
* record, to make sure the end-of-backup record corresponds the base
|
|
* backup we're recovering from.
|
|
*
|
|
* backupEndPoint is the backup end location, if we are recovering from an
|
|
* online backup which was taken from the standby and haven't reached the
|
|
* end of backup yet. It is initialized to the minimum recovery point in
|
|
* pg_control which was backed up last. It is reset to zero when the end
|
|
* of backup is reached, and we mustn't start up before that.
|
|
*
|
|
* If backupEndRequired is true, we know for sure that we're restoring
|
|
* from a backup, and must see a backup-end record before we can safely
|
|
* start up. If it's false, but backupStartPoint is set, a backup_label
|
|
* file was found at startup but it may have been a leftover from a stray
|
|
* pg_start_backup() call, not accompanied by pg_stop_backup().
|
|
*/
|
|
XLogRecPtr minRecoveryPoint;
|
|
TimeLineID minRecoveryPointTLI;
|
|
XLogRecPtr backupStartPoint;
|
|
XLogRecPtr backupEndPoint;
|
|
bool backupEndRequired;
|
|
|
|
/*
|
|
* Parameter settings that determine if the WAL can be used for archival
|
|
* or hot standby.
|
|
*/
|
|
int wal_level;
|
|
bool wal_log_hints;
|
|
int MaxConnections;
|
|
int max_worker_processes;
|
|
int max_wal_senders;
|
|
int max_prepared_xacts;
|
|
int max_locks_per_xact;
|
|
bool track_commit_timestamp;
|
|
|
|
/*
|
|
* This data is used to check for hardware-architecture compatibility of
|
|
* the database and the backend executable. We need not check endianness
|
|
* explicitly, since the pg_control version will surely look wrong to a
|
|
* machine of different endianness, but we do need to worry about MAXALIGN
|
|
* and floating-point format. (Note: storage layout nominally also
|
|
* depends on SHORTALIGN and INTALIGN, but in practice these are the same
|
|
* on all architectures of interest.)
|
|
*
|
|
* Testing just one double value is not a very bulletproof test for
|
|
* floating-point compatibility, but it will catch most cases.
|
|
*/
|
|
uint32 maxAlign; /* alignment requirement for tuples */
|
|
double floatFormat; /* constant 1234567.0 */
|
|
#define FLOATFORMAT_VALUE 1234567.0
|
|
|
|
/*
|
|
* This data is used to make sure that configuration of this database is
|
|
* compatible with the backend executable.
|
|
*/
|
|
uint32 blcksz; /* data block size for this DB */
|
|
uint32 relseg_size; /* blocks per segment of large relation */
|
|
|
|
uint32 xlog_blcksz; /* block size within WAL files */
|
|
uint32 xlog_seg_size; /* size of each WAL segment */
|
|
|
|
uint32 nameDataLen; /* catalog name field width */
|
|
uint32 indexMaxKeys; /* max number of columns in an index */
|
|
|
|
uint32 toast_max_chunk_size; /* chunk size in TOAST tables */
|
|
uint32 loblksize; /* chunk size in pg_largeobject */
|
|
|
|
/* flags indicating pass-by-value status of various types */
|
|
bool float4ByVal; /* float4 pass-by-value? */
|
|
bool float8ByVal; /* float8, int8, etc pass-by-value? */
|
|
|
|
/* Are data pages protected by checksums? Zero if no checksum version */
|
|
uint32 data_checksum_version;
|
|
|
|
/*
|
|
* Random nonce, used in authentication requests that need to proceed
|
|
* based on values that are cluster-unique, like a SASL exchange that
|
|
* failed at an early stage.
|
|
*/
|
|
char mock_authentication_nonce[MOCK_AUTH_NONCE_LEN];
|
|
|
|
/* CRC of all above ... MUST BE LAST! */
|
|
pg_crc32c crc;
|
|
} ControlFileData;
|
|
|
|
#elif PG_VERSION >= PG_VERSION_11
|
|
|
|
/*
|
|
* Contents of pg_control.
|
|
*/
|
|
typedef struct ControlFileData
|
|
{
|
|
/*
|
|
* Unique system identifier --- to ensure we match up xlog files with the
|
|
* installation that produced them.
|
|
*/
|
|
uint64 system_identifier;
|
|
|
|
/*
|
|
* Version identifier information. Keep these fields at the same offset,
|
|
* especially pg_control_version; they won't be real useful if they move
|
|
* around. (For historical reasons they must be 8 bytes into the file
|
|
* rather than immediately at the front.)
|
|
*
|
|
* pg_control_version identifies the format of pg_control itself.
|
|
* catalog_version_no identifies the format of the system catalogs.
|
|
*
|
|
* There are additional version identifiers in individual files; for
|
|
* example, WAL logs contain per-page magic numbers that can serve as
|
|
* version cues for the WAL log.
|
|
*/
|
|
uint32 pg_control_version; /* PG_CONTROL_VERSION */
|
|
uint32 catalog_version_no; /* see catversion.h */
|
|
|
|
/*
|
|
* System status data
|
|
*/
|
|
DBState state; /* see enum above */
|
|
pg_time_t time; /* time stamp of last pg_control update */
|
|
XLogRecPtr checkPoint; /* last check point record ptr */
|
|
|
|
CheckPoint checkPointCopy; /* copy of last check point record */
|
|
|
|
XLogRecPtr unloggedLSN; /* current fake LSN value, for unlogged rels */
|
|
|
|
/*
|
|
* These two values determine the minimum point we must recover up to
|
|
* before starting up:
|
|
*
|
|
* minRecoveryPoint is updated to the latest replayed LSN whenever we
|
|
* flush a data change during archive recovery. That guards against
|
|
* starting archive recovery, aborting it, and restarting with an earlier
|
|
* stop location. If we've already flushed data changes from WAL record X
|
|
* to disk, we mustn't start up until we reach X again. Zero when not
|
|
* doing archive recovery.
|
|
*
|
|
* backupStartPoint is the redo pointer of the backup start checkpoint, if
|
|
* we are recovering from an online backup and haven't reached the end of
|
|
* backup yet. It is reset to zero when the end of backup is reached, and
|
|
* we mustn't start up before that. A boolean would suffice otherwise, but
|
|
* we use the redo pointer as a cross-check when we see an end-of-backup
|
|
* record, to make sure the end-of-backup record corresponds the base
|
|
* backup we're recovering from.
|
|
*
|
|
* backupEndPoint is the backup end location, if we are recovering from an
|
|
* online backup which was taken from the standby and haven't reached the
|
|
* end of backup yet. It is initialized to the minimum recovery point in
|
|
* pg_control which was backed up last. It is reset to zero when the end
|
|
* of backup is reached, and we mustn't start up before that.
|
|
*
|
|
* If backupEndRequired is true, we know for sure that we're restoring
|
|
* from a backup, and must see a backup-end record before we can safely
|
|
* start up. If it's false, but backupStartPoint is set, a backup_label
|
|
* file was found at startup but it may have been a leftover from a stray
|
|
* pg_start_backup() call, not accompanied by pg_stop_backup().
|
|
*/
|
|
XLogRecPtr minRecoveryPoint;
|
|
TimeLineID minRecoveryPointTLI;
|
|
XLogRecPtr backupStartPoint;
|
|
XLogRecPtr backupEndPoint;
|
|
bool backupEndRequired;
|
|
|
|
/*
|
|
* Parameter settings that determine if the WAL can be used for archival
|
|
* or hot standby.
|
|
*/
|
|
int wal_level;
|
|
bool wal_log_hints;
|
|
int MaxConnections;
|
|
int max_worker_processes;
|
|
int max_prepared_xacts;
|
|
int max_locks_per_xact;
|
|
bool track_commit_timestamp;
|
|
|
|
/*
|
|
* This data is used to check for hardware-architecture compatibility of
|
|
* the database and the backend executable. We need not check endianness
|
|
* explicitly, since the pg_control version will surely look wrong to a
|
|
* machine of different endianness, but we do need to worry about MAXALIGN
|
|
* and floating-point format. (Note: storage layout nominally also
|
|
* depends on SHORTALIGN and INTALIGN, but in practice these are the same
|
|
* on all architectures of interest.)
|
|
*
|
|
* Testing just one double value is not a very bulletproof test for
|
|
* floating-point compatibility, but it will catch most cases.
|
|
*/
|
|
uint32 maxAlign; /* alignment requirement for tuples */
|
|
double floatFormat; /* constant 1234567.0 */
|
|
#define FLOATFORMAT_VALUE 1234567.0
|
|
|
|
/*
|
|
* This data is used to make sure that configuration of this database is
|
|
* compatible with the backend executable.
|
|
*/
|
|
uint32 blcksz; /* data block size for this DB */
|
|
uint32 relseg_size; /* blocks per segment of large relation */
|
|
|
|
uint32 xlog_blcksz; /* block size within WAL files */
|
|
uint32 xlog_seg_size; /* size of each WAL segment */
|
|
|
|
uint32 nameDataLen; /* catalog name field width */
|
|
uint32 indexMaxKeys; /* max number of columns in an index */
|
|
|
|
uint32 toast_max_chunk_size; /* chunk size in TOAST tables */
|
|
uint32 loblksize; /* chunk size in pg_largeobject */
|
|
|
|
/* flags indicating pass-by-value status of various types */
|
|
bool float4ByVal; /* float4 pass-by-value? */
|
|
bool float8ByVal; /* float8, int8, etc pass-by-value? */
|
|
|
|
/* Are data pages protected by checksums? Zero if no checksum version */
|
|
uint32 data_checksum_version;
|
|
|
|
/*
|
|
* Random nonce, used in authentication requests that need to proceed
|
|
* based on values that are cluster-unique, like a SASL exchange that
|
|
* failed at an early stage.
|
|
*/
|
|
char mock_authentication_nonce[MOCK_AUTH_NONCE_LEN];
|
|
|
|
/* CRC of all above ... MUST BE LAST! */
|
|
pg_crc32c crc;
|
|
} ControlFileData;
|
|
|
|
#elif PG_VERSION >= PG_VERSION_10
|
|
|
|
/*
|
|
* Contents of pg_control.
|
|
*/
|
|
typedef struct ControlFileData
|
|
{
|
|
/*
|
|
* Unique system identifier --- to ensure we match up xlog files with the
|
|
* installation that produced them.
|
|
*/
|
|
uint64 system_identifier;
|
|
|
|
/*
|
|
* Version identifier information. Keep these fields at the same offset,
|
|
* especially pg_control_version; they won't be real useful if they move
|
|
* around. (For historical reasons they must be 8 bytes into the file
|
|
* rather than immediately at the front.)
|
|
*
|
|
* pg_control_version identifies the format of pg_control itself.
|
|
* catalog_version_no identifies the format of the system catalogs.
|
|
*
|
|
* There are additional version identifiers in individual files; for
|
|
* example, WAL logs contain per-page magic numbers that can serve as
|
|
* version cues for the WAL log.
|
|
*/
|
|
uint32 pg_control_version; /* PG_CONTROL_VERSION */
|
|
uint32 catalog_version_no; /* see catversion.h */
|
|
|
|
/*
|
|
* System status data
|
|
*/
|
|
DBState state; /* see enum above */
|
|
pg_time_t time; /* time stamp of last pg_control update */
|
|
XLogRecPtr checkPoint; /* last check point record ptr */
|
|
XLogRecPtr prevCheckPoint; /* previous check point record ptr */
|
|
|
|
CheckPoint checkPointCopy; /* copy of last check point record */
|
|
|
|
XLogRecPtr unloggedLSN; /* current fake LSN value, for unlogged rels */
|
|
|
|
/*
|
|
* These two values determine the minimum point we must recover up to
|
|
* before starting up:
|
|
*
|
|
* minRecoveryPoint is updated to the latest replayed LSN whenever we
|
|
* flush a data change during archive recovery. That guards against
|
|
* starting archive recovery, aborting it, and restarting with an earlier
|
|
* stop location. If we've already flushed data changes from WAL record X
|
|
* to disk, we mustn't start up until we reach X again. Zero when not
|
|
* doing archive recovery.
|
|
*
|
|
* backupStartPoint is the redo pointer of the backup start checkpoint, if
|
|
* we are recovering from an online backup and haven't reached the end of
|
|
* backup yet. It is reset to zero when the end of backup is reached, and
|
|
* we mustn't start up before that. A boolean would suffice otherwise, but
|
|
* we use the redo pointer as a cross-check when we see an end-of-backup
|
|
* record, to make sure the end-of-backup record corresponds the base
|
|
* backup we're recovering from.
|
|
*
|
|
* backupEndPoint is the backup end location, if we are recovering from an
|
|
* online backup which was taken from the standby and haven't reached the
|
|
* end of backup yet. It is initialized to the minimum recovery point in
|
|
* pg_control which was backed up last. It is reset to zero when the end
|
|
* of backup is reached, and we mustn't start up before that.
|
|
*
|
|
* If backupEndRequired is true, we know for sure that we're restoring
|
|
* from a backup, and must see a backup-end record before we can safely
|
|
* start up. If it's false, but backupStartPoint is set, a backup_label
|
|
* file was found at startup but it may have been a leftover from a stray
|
|
* pg_start_backup() call, not accompanied by pg_stop_backup().
|
|
*/
|
|
XLogRecPtr minRecoveryPoint;
|
|
TimeLineID minRecoveryPointTLI;
|
|
XLogRecPtr backupStartPoint;
|
|
XLogRecPtr backupEndPoint;
|
|
bool backupEndRequired;
|
|
|
|
/*
|
|
* Parameter settings that determine if the WAL can be used for archival
|
|
* or hot standby.
|
|
*/
|
|
int wal_level;
|
|
bool wal_log_hints;
|
|
int MaxConnections;
|
|
int max_worker_processes;
|
|
int max_prepared_xacts;
|
|
int max_locks_per_xact;
|
|
bool track_commit_timestamp;
|
|
|
|
/*
|
|
* This data is used to check for hardware-architecture compatibility of
|
|
* the database and the backend executable. We need not check endianness
|
|
* explicitly, since the pg_control version will surely look wrong to a
|
|
* machine of different endianness, but we do need to worry about MAXALIGN
|
|
* and floating-point format. (Note: storage layout nominally also
|
|
* depends on SHORTALIGN and INTALIGN, but in practice these are the same
|
|
* on all architectures of interest.)
|
|
*
|
|
* Testing just one double value is not a very bulletproof test for
|
|
* floating-point compatibility, but it will catch most cases.
|
|
*/
|
|
uint32 maxAlign; /* alignment requirement for tuples */
|
|
double floatFormat; /* constant 1234567.0 */
|
|
#define FLOATFORMAT_VALUE 1234567.0
|
|
|
|
/*
|
|
* This data is used to make sure that configuration of this database is
|
|
* compatible with the backend executable.
|
|
*/
|
|
uint32 blcksz; /* data block size for this DB */
|
|
uint32 relseg_size; /* blocks per segment of large relation */
|
|
|
|
uint32 xlog_blcksz; /* block size within WAL files */
|
|
uint32 xlog_seg_size; /* size of each WAL segment */
|
|
|
|
uint32 nameDataLen; /* catalog name field width */
|
|
uint32 indexMaxKeys; /* max number of columns in an index */
|
|
|
|
uint32 toast_max_chunk_size; /* chunk size in TOAST tables */
|
|
uint32 loblksize; /* chunk size in pg_largeobject */
|
|
|
|
/* flags indicating pass-by-value status of various types */
|
|
bool float4ByVal; /* float4 pass-by-value? */
|
|
bool float8ByVal; /* float8, int8, etc pass-by-value? */
|
|
|
|
/* Are data pages protected by checksums? Zero if no checksum version */
|
|
uint32 data_checksum_version;
|
|
|
|
/*
|
|
* Random nonce, used in authentication requests that need to proceed
|
|
* based on values that are cluster-unique, like a SASL exchange that
|
|
* failed at an early stage.
|
|
*/
|
|
char mock_authentication_nonce[MOCK_AUTH_NONCE_LEN];
|
|
|
|
/* CRC of all above ... MUST BE LAST! */
|
|
pg_crc32c crc;
|
|
} ControlFileData;
|
|
|
|
#elif PG_VERSION >= PG_VERSION_95
|
|
|
|
/*
|
|
* Contents of pg_control.
|
|
*
|
|
* NOTE: try to keep this under 512 bytes so that it will fit on one physical
|
|
* sector of typical disk drives. This reduces the odds of corruption due to
|
|
* power failure midway through a write.
|
|
*/
|
|
typedef struct ControlFileData
|
|
{
|
|
/*
|
|
* Unique system identifier --- to ensure we match up xlog files with the
|
|
* installation that produced them.
|
|
*/
|
|
uint64 system_identifier;
|
|
|
|
/*
|
|
* Version identifier information. Keep these fields at the same offset,
|
|
* especially pg_control_version; they won't be real useful if they move
|
|
* around. (For historical reasons they must be 8 bytes into the file
|
|
* rather than immediately at the front.)
|
|
*
|
|
* pg_control_version identifies the format of pg_control itself.
|
|
* catalog_version_no identifies the format of the system catalogs.
|
|
*
|
|
* There are additional version identifiers in individual files; for
|
|
* example, WAL logs contain per-page magic numbers that can serve as
|
|
* version cues for the WAL log.
|
|
*/
|
|
uint32 pg_control_version; /* PG_CONTROL_VERSION */
|
|
uint32 catalog_version_no; /* see catversion.h */
|
|
|
|
/*
|
|
* System status data
|
|
*/
|
|
DBState state; /* see enum above */
|
|
pg_time_t time; /* time stamp of last pg_control update */
|
|
XLogRecPtr checkPoint; /* last check point record ptr */
|
|
XLogRecPtr prevCheckPoint; /* previous check point record ptr */
|
|
|
|
CheckPoint checkPointCopy; /* copy of last check point record */
|
|
|
|
XLogRecPtr unloggedLSN; /* current fake LSN value, for unlogged rels */
|
|
|
|
/*
|
|
* These two values determine the minimum point we must recover up to
|
|
* before starting up:
|
|
*
|
|
* minRecoveryPoint is updated to the latest replayed LSN whenever we
|
|
* flush a data change during archive recovery. That guards against
|
|
* starting archive recovery, aborting it, and restarting with an earlier
|
|
* stop location. If we've already flushed data changes from WAL record X
|
|
* to disk, we mustn't start up until we reach X again. Zero when not
|
|
* doing archive recovery.
|
|
*
|
|
* backupStartPoint is the redo pointer of the backup start checkpoint, if
|
|
* we are recovering from an online backup and haven't reached the end of
|
|
* backup yet. It is reset to zero when the end of backup is reached, and
|
|
* we mustn't start up before that. A boolean would suffice otherwise, but
|
|
* we use the redo pointer as a cross-check when we see an end-of-backup
|
|
* record, to make sure the end-of-backup record corresponds the base
|
|
* backup we're recovering from.
|
|
*
|
|
* backupEndPoint is the backup end location, if we are recovering from an
|
|
* online backup which was taken from the standby and haven't reached the
|
|
* end of backup yet. It is initialized to the minimum recovery point in
|
|
* pg_control which was backed up last. It is reset to zero when the end
|
|
* of backup is reached, and we mustn't start up before that.
|
|
*
|
|
* If backupEndRequired is true, we know for sure that we're restoring
|
|
* from a backup, and must see a backup-end record before we can safely
|
|
* start up. If it's false, but backupStartPoint is set, a backup_label
|
|
* file was found at startup but it may have been a leftover from a stray
|
|
* pg_start_backup() call, not accompanied by pg_stop_backup().
|
|
*/
|
|
XLogRecPtr minRecoveryPoint;
|
|
TimeLineID minRecoveryPointTLI;
|
|
XLogRecPtr backupStartPoint;
|
|
XLogRecPtr backupEndPoint;
|
|
bool backupEndRequired;
|
|
|
|
/*
|
|
* Parameter settings that determine if the WAL can be used for archival
|
|
* or hot standby.
|
|
*/
|
|
int wal_level;
|
|
bool wal_log_hints;
|
|
int MaxConnections;
|
|
int max_worker_processes;
|
|
int max_prepared_xacts;
|
|
int max_locks_per_xact;
|
|
bool track_commit_timestamp;
|
|
|
|
/*
|
|
* This data is used to check for hardware-architecture compatibility of
|
|
* the database and the backend executable. We need not check endianness
|
|
* explicitly, since the pg_control version will surely look wrong to a
|
|
* machine of different endianness, but we do need to worry about MAXALIGN
|
|
* and floating-point format. (Note: storage layout nominally also
|
|
* depends on SHORTALIGN and INTALIGN, but in practice these are the same
|
|
* on all architectures of interest.)
|
|
*
|
|
* Testing just one double value is not a very bulletproof test for
|
|
* floating-point compatibility, but it will catch most cases.
|
|
*/
|
|
uint32 maxAlign; /* alignment requirement for tuples */
|
|
double floatFormat; /* constant 1234567.0 */
|
|
#define FLOATFORMAT_VALUE 1234567.0
|
|
|
|
/*
|
|
* This data is used to make sure that configuration of this database is
|
|
* compatible with the backend executable.
|
|
*/
|
|
uint32 blcksz; /* data block size for this DB */
|
|
uint32 relseg_size; /* blocks per segment of large relation */
|
|
|
|
uint32 xlog_blcksz; /* block size within WAL files */
|
|
uint32 xlog_seg_size; /* size of each WAL segment */
|
|
|
|
uint32 nameDataLen; /* catalog name field width */
|
|
uint32 indexMaxKeys; /* max number of columns in an index */
|
|
|
|
uint32 toast_max_chunk_size; /* chunk size in TOAST tables */
|
|
uint32 loblksize; /* chunk size in pg_largeobject */
|
|
|
|
/* flag indicating internal format of timestamp, interval, time */
|
|
bool enableIntTimes; /* int64 storage enabled? */
|
|
|
|
/* flags indicating pass-by-value status of various types */
|
|
bool float4ByVal; /* float4 pass-by-value? */
|
|
bool float8ByVal; /* float8, int8, etc pass-by-value? */
|
|
|
|
/* Are data pages protected by checksums? Zero if no checksum version */
|
|
uint32 data_checksum_version;
|
|
|
|
/* CRC of all above ... MUST BE LAST! */
|
|
pg_crc32c crc;
|
|
} ControlFileData;
|
|
|
|
#elif PG_VERSION >= PG_VERSION_94
|
|
|
|
/*
|
|
* Contents of pg_control.
|
|
*
|
|
* NOTE: try to keep this under 512 bytes so that it will fit on one physical
|
|
* sector of typical disk drives. This reduces the odds of corruption due to
|
|
* power failure midway through a write.
|
|
*/
|
|
typedef struct ControlFileData
|
|
{
|
|
/*
|
|
* Unique system identifier --- to ensure we match up xlog files with the
|
|
* installation that produced them.
|
|
*/
|
|
uint64 system_identifier;
|
|
|
|
/*
|
|
* Version identifier information. Keep these fields at the same offset,
|
|
* especially pg_control_version; they won't be real useful if they move
|
|
* around. (For historical reasons they must be 8 bytes into the file
|
|
* rather than immediately at the front.)
|
|
*
|
|
* pg_control_version identifies the format of pg_control itself.
|
|
* catalog_version_no identifies the format of the system catalogs.
|
|
*
|
|
* There are additional version identifiers in individual files; for
|
|
* example, WAL logs contain per-page magic numbers that can serve as
|
|
* version cues for the WAL log.
|
|
*/
|
|
uint32 pg_control_version; /* PG_CONTROL_VERSION */
|
|
uint32 catalog_version_no; /* see catversion.h */
|
|
|
|
/*
|
|
* System status data
|
|
*/
|
|
DBState state; /* see enum above */
|
|
pg_time_t time; /* time stamp of last pg_control update */
|
|
XLogRecPtr checkPoint; /* last check point record ptr */
|
|
XLogRecPtr prevCheckPoint; /* previous check point record ptr */
|
|
|
|
CheckPoint checkPointCopy; /* copy of last check point record */
|
|
|
|
XLogRecPtr unloggedLSN; /* current fake LSN value, for unlogged rels */
|
|
|
|
/*
|
|
* These two values determine the minimum point we must recover up to
|
|
* before starting up:
|
|
*
|
|
* minRecoveryPoint is updated to the latest replayed LSN whenever we
|
|
* flush a data change during archive recovery. That guards against
|
|
* starting archive recovery, aborting it, and restarting with an earlier
|
|
* stop location. If we've already flushed data changes from WAL record X
|
|
* to disk, we mustn't start up until we reach X again. Zero when not
|
|
* doing archive recovery.
|
|
*
|
|
* backupStartPoint is the redo pointer of the backup start checkpoint, if
|
|
* we are recovering from an online backup and haven't reached the end of
|
|
* backup yet. It is reset to zero when the end of backup is reached, and
|
|
* we mustn't start up before that. A boolean would suffice otherwise, but
|
|
* we use the redo pointer as a cross-check when we see an end-of-backup
|
|
* record, to make sure the end-of-backup record corresponds the base
|
|
* backup we're recovering from.
|
|
*
|
|
* backupEndPoint is the backup end location, if we are recovering from an
|
|
* online backup which was taken from the standby and haven't reached the
|
|
* end of backup yet. It is initialized to the minimum recovery point in
|
|
* pg_control which was backed up last. It is reset to zero when the end
|
|
* of backup is reached, and we mustn't start up before that.
|
|
*
|
|
* If backupEndRequired is true, we know for sure that we're restoring
|
|
* from a backup, and must see a backup-end record before we can safely
|
|
* start up. If it's false, but backupStartPoint is set, a backup_label
|
|
* file was found at startup but it may have been a leftover from a stray
|
|
* pg_start_backup() call, not accompanied by pg_stop_backup().
|
|
*/
|
|
XLogRecPtr minRecoveryPoint;
|
|
TimeLineID minRecoveryPointTLI;
|
|
XLogRecPtr backupStartPoint;
|
|
XLogRecPtr backupEndPoint;
|
|
bool backupEndRequired;
|
|
|
|
/*
|
|
* Parameter settings that determine if the WAL can be used for archival
|
|
* or hot standby.
|
|
*/
|
|
int wal_level;
|
|
bool wal_log_hints;
|
|
int MaxConnections;
|
|
int max_worker_processes;
|
|
int max_prepared_xacts;
|
|
int max_locks_per_xact;
|
|
|
|
/*
|
|
* This data is used to check for hardware-architecture compatibility of
|
|
* the database and the backend executable. We need not check endianness
|
|
* explicitly, since the pg_control version will surely look wrong to a
|
|
* machine of different endianness, but we do need to worry about MAXALIGN
|
|
* and floating-point format. (Note: storage layout nominally also
|
|
* depends on SHORTALIGN and INTALIGN, but in practice these are the same
|
|
* on all architectures of interest.)
|
|
*
|
|
* Testing just one double value is not a very bulletproof test for
|
|
* floating-point compatibility, but it will catch most cases.
|
|
*/
|
|
uint32 maxAlign; /* alignment requirement for tuples */
|
|
double floatFormat; /* constant 1234567.0 */
|
|
#define FLOATFORMAT_VALUE 1234567.0
|
|
|
|
/*
|
|
* This data is used to make sure that configuration of this database is
|
|
* compatible with the backend executable.
|
|
*/
|
|
uint32 blcksz; /* data block size for this DB */
|
|
uint32 relseg_size; /* blocks per segment of large relation */
|
|
|
|
uint32 xlog_blcksz; /* block size within WAL files */
|
|
uint32 xlog_seg_size; /* size of each WAL segment */
|
|
|
|
uint32 nameDataLen; /* catalog name field width */
|
|
uint32 indexMaxKeys; /* max number of columns in an index */
|
|
|
|
uint32 toast_max_chunk_size; /* chunk size in TOAST tables */
|
|
uint32 loblksize; /* chunk size in pg_largeobject */
|
|
|
|
/* flag indicating internal format of timestamp, interval, time */
|
|
bool enableIntTimes; /* int64 storage enabled? */
|
|
|
|
/* flags indicating pass-by-value status of various types */
|
|
bool float4ByVal; /* float4 pass-by-value? */
|
|
bool float8ByVal; /* float8, int8, etc pass-by-value? */
|
|
|
|
/* Are data pages protected by checksums? Zero if no checksum version */
|
|
uint32 data_checksum_version;
|
|
|
|
/* CRC of all above ... MUST BE LAST! */
|
|
pg_crc32 crc;
|
|
} ControlFileData;
|
|
|
|
#elif PG_VERSION >= PG_VERSION_93
|
|
|
|
/*
|
|
* Contents of pg_control.
|
|
*
|
|
* NOTE: try to keep this under 512 bytes so that it will fit on one physical
|
|
* sector of typical disk drives. This reduces the odds of corruption due to
|
|
* power failure midway through a write.
|
|
*/
|
|
typedef struct ControlFileData
|
|
{
|
|
/*
|
|
* Unique system identifier --- to ensure we match up xlog files with the
|
|
* installation that produced them.
|
|
*/
|
|
uint64 system_identifier;
|
|
|
|
/*
|
|
* Version identifier information. Keep these fields at the same offset,
|
|
* especially pg_control_version; they won't be real useful if they move
|
|
* around. (For historical reasons they must be 8 bytes into the file
|
|
* rather than immediately at the front.)
|
|
*
|
|
* pg_control_version identifies the format of pg_control itself.
|
|
* catalog_version_no identifies the format of the system catalogs.
|
|
*
|
|
* There are additional version identifiers in individual files; for
|
|
* example, WAL logs contain per-page magic numbers that can serve as
|
|
* version cues for the WAL log.
|
|
*/
|
|
uint32 pg_control_version; /* PG_CONTROL_VERSION */
|
|
uint32 catalog_version_no; /* see catversion.h */
|
|
|
|
/*
|
|
* System status data
|
|
*/
|
|
DBState state; /* see enum above */
|
|
pg_time_t time; /* time stamp of last pg_control update */
|
|
XLogRecPtr checkPoint; /* last check point record ptr */
|
|
XLogRecPtr prevCheckPoint; /* previous check point record ptr */
|
|
|
|
CheckPoint checkPointCopy; /* copy of last check point record */
|
|
|
|
XLogRecPtr unloggedLSN; /* current fake LSN value, for unlogged rels */
|
|
|
|
/*
|
|
* These two values determine the minimum point we must recover up to
|
|
* before starting up:
|
|
*
|
|
* minRecoveryPoint is updated to the latest replayed LSN whenever we
|
|
* flush a data change during archive recovery. That guards against
|
|
* starting archive recovery, aborting it, and restarting with an earlier
|
|
* stop location. If we've already flushed data changes from WAL record X
|
|
* to disk, we mustn't start up until we reach X again. Zero when not
|
|
* doing archive recovery.
|
|
*
|
|
* backupStartPoint is the redo pointer of the backup start checkpoint, if
|
|
* we are recovering from an online backup and haven't reached the end of
|
|
* backup yet. It is reset to zero when the end of backup is reached, and
|
|
* we mustn't start up before that. A boolean would suffice otherwise, but
|
|
* we use the redo pointer as a cross-check when we see an end-of-backup
|
|
* record, to make sure the end-of-backup record corresponds the base
|
|
* backup we're recovering from.
|
|
*
|
|
* backupEndPoint is the backup end location, if we are recovering from an
|
|
* online backup which was taken from the standby and haven't reached the
|
|
* end of backup yet. It is initialized to the minimum recovery point in
|
|
* pg_control which was backed up last. It is reset to zero when the end
|
|
* of backup is reached, and we mustn't start up before that.
|
|
*
|
|
* If backupEndRequired is true, we know for sure that we're restoring
|
|
* from a backup, and must see a backup-end record before we can safely
|
|
* start up. If it's false, but backupStartPoint is set, a backup_label
|
|
* file was found at startup but it may have been a leftover from a stray
|
|
* pg_start_backup() call, not accompanied by pg_stop_backup().
|
|
*/
|
|
XLogRecPtr minRecoveryPoint;
|
|
TimeLineID minRecoveryPointTLI;
|
|
XLogRecPtr backupStartPoint;
|
|
XLogRecPtr backupEndPoint;
|
|
bool backupEndRequired;
|
|
|
|
/*
|
|
* Parameter settings that determine if the WAL can be used for archival
|
|
* or hot standby.
|
|
*/
|
|
int wal_level;
|
|
int MaxConnections;
|
|
int max_prepared_xacts;
|
|
int max_locks_per_xact;
|
|
|
|
/*
|
|
* This data is used to check for hardware-architecture compatibility of
|
|
* the database and the backend executable. We need not check endianness
|
|
* explicitly, since the pg_control version will surely look wrong to a
|
|
* machine of different endianness, but we do need to worry about MAXALIGN
|
|
* and floating-point format. (Note: storage layout nominally also
|
|
* depends on SHORTALIGN and INTALIGN, but in practice these are the same
|
|
* on all architectures of interest.)
|
|
*
|
|
* Testing just one double value is not a very bulletproof test for
|
|
* floating-point compatibility, but it will catch most cases.
|
|
*/
|
|
uint32 maxAlign; /* alignment requirement for tuples */
|
|
double floatFormat; /* constant 1234567.0 */
|
|
#define FLOATFORMAT_VALUE 1234567.0
|
|
|
|
/*
|
|
* This data is used to make sure that configuration of this database is
|
|
* compatible with the backend executable.
|
|
*/
|
|
uint32 blcksz; /* data block size for this DB */
|
|
uint32 relseg_size; /* blocks per segment of large relation */
|
|
|
|
uint32 xlog_blcksz; /* block size within WAL files */
|
|
uint32 xlog_seg_size; /* size of each WAL segment */
|
|
|
|
uint32 nameDataLen; /* catalog name field width */
|
|
uint32 indexMaxKeys; /* max number of columns in an index */
|
|
|
|
uint32 toast_max_chunk_size; /* chunk size in TOAST tables */
|
|
|
|
/* flag indicating internal format of timestamp, interval, time */
|
|
bool enableIntTimes; /* int64 storage enabled? */
|
|
|
|
/* flags indicating pass-by-value status of various types */
|
|
bool float4ByVal; /* float4 pass-by-value? */
|
|
bool float8ByVal; /* float8, int8, etc pass-by-value? */
|
|
|
|
/* Are data pages protected by checksums? Zero if no checksum version */
|
|
uint32 data_checksum_version;
|
|
|
|
/* CRC of all above ... MUST BE LAST! */
|
|
pg_crc32 crc;
|
|
} ControlFileData;
|
|
|
|
#elif PG_VERSION >= PG_VERSION_92
|
|
|
|
/*
|
|
* Contents of pg_control.
|
|
*
|
|
* NOTE: try to keep this under 512 bytes so that it will fit on one physical
|
|
* sector of typical disk drives. This reduces the odds of corruption due to
|
|
* power failure midway through a write.
|
|
*/
|
|
typedef struct ControlFileData
|
|
{
|
|
/*
|
|
* Unique system identifier --- to ensure we match up xlog files with the
|
|
* installation that produced them.
|
|
*/
|
|
uint64 system_identifier;
|
|
|
|
/*
|
|
* Version identifier information. Keep these fields at the same offset,
|
|
* especially pg_control_version; they won't be real useful if they move
|
|
* around. (For historical reasons they must be 8 bytes into the file
|
|
* rather than immediately at the front.)
|
|
*
|
|
* pg_control_version identifies the format of pg_control itself.
|
|
* catalog_version_no identifies the format of the system catalogs.
|
|
*
|
|
* There are additional version identifiers in individual files; for
|
|
* example, WAL logs contain per-page magic numbers that can serve as
|
|
* version cues for the WAL log.
|
|
*/
|
|
uint32 pg_control_version; /* PG_CONTROL_VERSION */
|
|
uint32 catalog_version_no; /* see catversion.h */
|
|
|
|
/*
|
|
* System status data
|
|
*/
|
|
DBState state; /* see enum above */
|
|
pg_time_t time; /* time stamp of last pg_control update */
|
|
XLogRecPtr checkPoint; /* last check point record ptr */
|
|
XLogRecPtr prevCheckPoint; /* previous check point record ptr */
|
|
|
|
CheckPoint checkPointCopy; /* copy of last check point record */
|
|
|
|
/*
|
|
* These two values determine the minimum point we must recover up to
|
|
* before starting up:
|
|
*
|
|
* minRecoveryPoint is updated to the latest replayed LSN whenever we
|
|
* flush a data change during archive recovery. That guards against
|
|
* starting archive recovery, aborting it, and restarting with an earlier
|
|
* stop location. If we've already flushed data changes from WAL record X
|
|
* to disk, we mustn't start up until we reach X again. Zero when not
|
|
* doing archive recovery.
|
|
*
|
|
* backupStartPoint is the redo pointer of the backup start checkpoint, if
|
|
* we are recovering from an online backup and haven't reached the end of
|
|
* backup yet. It is reset to zero when the end of backup is reached, and
|
|
* we mustn't start up before that. A boolean would suffice otherwise, but
|
|
* we use the redo pointer as a cross-check when we see an end-of-backup
|
|
* record, to make sure the end-of-backup record corresponds the base
|
|
* backup we're recovering from.
|
|
*
|
|
* backupEndPoint is the backup end location, if we are recovering from an
|
|
* online backup which was taken from the standby and haven't reached the
|
|
* end of backup yet. It is initialized to the minimum recovery point in
|
|
* pg_control which was backed up last. It is reset to zero when the end
|
|
* of backup is reached, and we mustn't start up before that.
|
|
*
|
|
* If backupEndRequired is true, we know for sure that we're restoring
|
|
* from a backup, and must see a backup-end record before we can safely
|
|
* start up. If it's false, but backupStartPoint is set, a backup_label
|
|
* file was found at startup but it may have been a leftover from a stray
|
|
* pg_start_backup() call, not accompanied by pg_stop_backup().
|
|
*/
|
|
XLogRecPtr minRecoveryPoint;
|
|
XLogRecPtr backupStartPoint;
|
|
XLogRecPtr backupEndPoint;
|
|
bool backupEndRequired;
|
|
|
|
/*
|
|
* Parameter settings that determine if the WAL can be used for archival
|
|
* or hot standby.
|
|
*/
|
|
int wal_level;
|
|
int MaxConnections;
|
|
int max_prepared_xacts;
|
|
int max_locks_per_xact;
|
|
|
|
/*
|
|
* This data is used to check for hardware-architecture compatibility of
|
|
* the database and the backend executable. We need not check endianness
|
|
* explicitly, since the pg_control version will surely look wrong to a
|
|
* machine of different endianness, but we do need to worry about MAXALIGN
|
|
* and floating-point format. (Note: storage layout nominally also
|
|
* depends on SHORTALIGN and INTALIGN, but in practice these are the same
|
|
* on all architectures of interest.)
|
|
*
|
|
* Testing just one double value is not a very bulletproof test for
|
|
* floating-point compatibility, but it will catch most cases.
|
|
*/
|
|
uint32 maxAlign; /* alignment requirement for tuples */
|
|
double floatFormat; /* constant 1234567.0 */
|
|
#define FLOATFORMAT_VALUE 1234567.0
|
|
|
|
/*
|
|
* This data is used to make sure that configuration of this database is
|
|
* compatible with the backend executable.
|
|
*/
|
|
uint32 blcksz; /* data block size for this DB */
|
|
uint32 relseg_size; /* blocks per segment of large relation */
|
|
|
|
uint32 xlog_blcksz; /* block size within WAL files */
|
|
uint32 xlog_seg_size; /* size of each WAL segment */
|
|
|
|
uint32 nameDataLen; /* catalog name field width */
|
|
uint32 indexMaxKeys; /* max number of columns in an index */
|
|
|
|
uint32 toast_max_chunk_size; /* chunk size in TOAST tables */
|
|
|
|
/* flag indicating internal format of timestamp, interval, time */
|
|
bool enableIntTimes; /* int64 storage enabled? */
|
|
|
|
/* flags indicating pass-by-value status of various types */
|
|
bool float4ByVal; /* float4 pass-by-value? */
|
|
bool float8ByVal; /* float8, int8, etc pass-by-value? */
|
|
|
|
/* CRC of all above ... MUST BE LAST! */
|
|
pg_crc32 crc;
|
|
} ControlFileData;
|
|
|
|
#elif PG_VERSION >= PG_VERSION_90
|
|
|
|
/*
|
|
* Contents of pg_control.
|
|
*
|
|
* NOTE: try to keep this under 512 bytes so that it will fit on one physical
|
|
* sector of typical disk drives. This reduces the odds of corruption due to
|
|
* power failure midway through a write.
|
|
*/
|
|
typedef struct ControlFileData
|
|
{
|
|
/*
|
|
* Unique system identifier --- to ensure we match up xlog files with the
|
|
* installation that produced them.
|
|
*/
|
|
uint64 system_identifier;
|
|
|
|
/*
|
|
* Version identifier information. Keep these fields at the same offset,
|
|
* especially pg_control_version; they won't be real useful if they move
|
|
* around. (For historical reasons they must be 8 bytes into the file
|
|
* rather than immediately at the front.)
|
|
*
|
|
* pg_control_version identifies the format of pg_control itself.
|
|
* catalog_version_no identifies the format of the system catalogs.
|
|
*
|
|
* There are additional version identifiers in individual files; for
|
|
* example, WAL logs contain per-page magic numbers that can serve as
|
|
* version cues for the WAL log.
|
|
*/
|
|
uint32 pg_control_version; /* PG_CONTROL_VERSION */
|
|
uint32 catalog_version_no; /* see catversion.h */
|
|
|
|
/*
|
|
* System status data
|
|
*/
|
|
DBState state; /* see enum above */
|
|
pg_time_t time; /* time stamp of last pg_control update */
|
|
XLogRecPtr checkPoint; /* last check point record ptr */
|
|
XLogRecPtr prevCheckPoint; /* previous check point record ptr */
|
|
|
|
CheckPoint checkPointCopy; /* copy of last check point record */
|
|
|
|
/*
|
|
* These two values determine the minimum point we must recover up to
|
|
* before starting up:
|
|
*
|
|
* minRecoveryPoint is updated to the latest replayed LSN whenever we
|
|
* flush a data change during archive recovery. That guards against
|
|
* starting archive recovery, aborting it, and restarting with an earlier
|
|
* stop location. If we've already flushed data changes from WAL record X
|
|
* to disk, we mustn't start up until we reach X again. Zero when not
|
|
* doing archive recovery.
|
|
*
|
|
* backupStartPoint is the redo pointer of the backup start checkpoint, if
|
|
* we are recovering from an online backup and haven't reached the end of
|
|
* backup yet. It is reset to zero when the end of backup is reached, and
|
|
* we mustn't start up before that. A boolean would suffice otherwise, but
|
|
* we use the redo pointer as a cross-check when we see an end-of-backup
|
|
* record, to make sure the end-of-backup record corresponds the base
|
|
* backup we're recovering from.
|
|
*/
|
|
XLogRecPtr minRecoveryPoint;
|
|
XLogRecPtr backupStartPoint;
|
|
|
|
/*
|
|
* Parameter settings that determine if the WAL can be used for archival
|
|
* or hot standby.
|
|
*/
|
|
int wal_level;
|
|
int MaxConnections;
|
|
int max_prepared_xacts;
|
|
int max_locks_per_xact;
|
|
|
|
/*
|
|
* This data is used to check for hardware-architecture compatibility of
|
|
* the database and the backend executable. We need not check endianness
|
|
* explicitly, since the pg_control version will surely look wrong to a
|
|
* machine of different endianness, but we do need to worry about MAXALIGN
|
|
* and floating-point format. (Note: storage layout nominally also
|
|
* depends on SHORTALIGN and INTALIGN, but in practice these are the same
|
|
* on all architectures of interest.)
|
|
*
|
|
* Testing just one double value is not a very bulletproof test for
|
|
* floating-point compatibility, but it will catch most cases.
|
|
*/
|
|
uint32 maxAlign; /* alignment requirement for tuples */
|
|
double floatFormat; /* constant 1234567.0 */
|
|
#define FLOATFORMAT_VALUE 1234567.0
|
|
|
|
/*
|
|
* This data is used to make sure that configuration of this database is
|
|
* compatible with the backend executable.
|
|
*/
|
|
uint32 blcksz; /* data block size for this DB */
|
|
uint32 relseg_size; /* blocks per segment of large relation */
|
|
|
|
uint32 xlog_blcksz; /* block size within WAL files */
|
|
uint32 xlog_seg_size; /* size of each WAL segment */
|
|
|
|
uint32 nameDataLen; /* catalog name field width */
|
|
uint32 indexMaxKeys; /* max number of columns in an index */
|
|
|
|
uint32 toast_max_chunk_size; /* chunk size in TOAST tables */
|
|
|
|
/* flag indicating internal format of timestamp, interval, time */
|
|
bool enableIntTimes; /* int64 storage enabled? */
|
|
|
|
/* flags indicating pass-by-value status of various types */
|
|
bool float4ByVal; /* float4 pass-by-value? */
|
|
bool float8ByVal; /* float8, int8, etc pass-by-value? */
|
|
|
|
/* CRC of all above ... MUST BE LAST! */
|
|
pg_crc32 crc;
|
|
} ControlFileData;
|
|
|
|
#elif PG_VERSION >= PG_VERSION_84
|
|
|
|
/*
|
|
* Contents of pg_control.
|
|
*
|
|
* NOTE: try to keep this under 512 bytes so that it will fit on one physical
|
|
* sector of typical disk drives. This reduces the odds of corruption due to
|
|
* power failure midway through a write.
|
|
*/
|
|
typedef struct ControlFileData
|
|
{
|
|
/*
|
|
* Unique system identifier --- to ensure we match up xlog files with the
|
|
* installation that produced them.
|
|
*/
|
|
uint64 system_identifier;
|
|
|
|
/*
|
|
* Version identifier information. Keep these fields at the same offset,
|
|
* especially pg_control_version; they won't be real useful if they move
|
|
* around. (For historical reasons they must be 8 bytes into the file
|
|
* rather than immediately at the front.)
|
|
*
|
|
* pg_control_version identifies the format of pg_control itself.
|
|
* catalog_version_no identifies the format of the system catalogs.
|
|
*
|
|
* There are additional version identifiers in individual files; for
|
|
* example, WAL logs contain per-page magic numbers that can serve as
|
|
* version cues for the WAL log.
|
|
*/
|
|
uint32 pg_control_version; /* PG_CONTROL_VERSION */
|
|
uint32 catalog_version_no; /* see catversion.h */
|
|
|
|
/*
|
|
* System status data
|
|
*/
|
|
DBState state; /* see enum above */
|
|
pg_time_t time; /* time stamp of last pg_control update */
|
|
XLogRecPtr checkPoint; /* last check point record ptr */
|
|
XLogRecPtr prevCheckPoint; /* previous check point record ptr */
|
|
|
|
CheckPoint checkPointCopy; /* copy of last check point record */
|
|
|
|
XLogRecPtr minRecoveryPoint; /* must replay xlog to here */
|
|
|
|
/*
|
|
* This data is used to check for hardware-architecture compatibility of
|
|
* the database and the backend executable. We need not check endianness
|
|
* explicitly, since the pg_control version will surely look wrong to a
|
|
* machine of different endianness, but we do need to worry about MAXALIGN
|
|
* and floating-point format. (Note: storage layout nominally also
|
|
* depends on SHORTALIGN and INTALIGN, but in practice these are the same
|
|
* on all architectures of interest.)
|
|
*
|
|
* Testing just one double value is not a very bulletproof test for
|
|
* floating-point compatibility, but it will catch most cases.
|
|
*/
|
|
uint32 maxAlign; /* alignment requirement for tuples */
|
|
double floatFormat; /* constant 1234567.0 */
|
|
#define FLOATFORMAT_VALUE 1234567.0
|
|
|
|
/*
|
|
* This data is used to make sure that configuration of this database is
|
|
* compatible with the backend executable.
|
|
*/
|
|
uint32 blcksz; /* data block size for this DB */
|
|
uint32 relseg_size; /* blocks per segment of large relation */
|
|
|
|
uint32 xlog_blcksz; /* block size within WAL files */
|
|
uint32 xlog_seg_size; /* size of each WAL segment */
|
|
|
|
uint32 nameDataLen; /* catalog name field width */
|
|
uint32 indexMaxKeys; /* max number of columns in an index */
|
|
|
|
uint32 toast_max_chunk_size; /* chunk size in TOAST tables */
|
|
|
|
/* flag indicating internal format of timestamp, interval, time */
|
|
bool enableIntTimes; /* int64 storage enabled? */
|
|
|
|
/* flags indicating pass-by-value status of various types */
|
|
bool float4ByVal; /* float4 pass-by-value? */
|
|
bool float8ByVal; /* float8, int8, etc pass-by-value? */
|
|
|
|
/* CRC of all above ... MUST BE LAST! */
|
|
pg_crc32 crc;
|
|
} ControlFileData;
|
|
|
|
#elif PG_VERSION >= PG_VERSION_83
|
|
|
|
/*
|
|
* Contents of pg_control.
|
|
*
|
|
* NOTE: try to keep this under 512 bytes so that it will fit on one physical
|
|
* sector of typical disk drives. This reduces the odds of corruption due to
|
|
* power failure midway through a write. Currently it fits comfortably,
|
|
* but we could probably reduce LOCALE_NAME_BUFLEN if things get tight.
|
|
*/
|
|
|
|
typedef struct ControlFileData
|
|
{
|
|
/*
|
|
* Unique system identifier --- to ensure we match up xlog files with the
|
|
* installation that produced them.
|
|
*/
|
|
uint64 system_identifier;
|
|
|
|
/*
|
|
* Version identifier information. Keep these fields at the same offset,
|
|
* especially pg_control_version; they won't be real useful if they move
|
|
* around. (For historical reasons they must be 8 bytes into the file
|
|
* rather than immediately at the front.)
|
|
*
|
|
* pg_control_version identifies the format of pg_control itself.
|
|
* catalog_version_no identifies the format of the system catalogs.
|
|
*
|
|
* There are additional version identifiers in individual files; for
|
|
* example, WAL logs contain per-page magic numbers that can serve as
|
|
* version cues for the WAL log.
|
|
*/
|
|
uint32 pg_control_version; /* PG_CONTROL_VERSION */
|
|
uint32 catalog_version_no; /* see catversion.h */
|
|
|
|
/*
|
|
* System status data
|
|
*/
|
|
DBState state; /* see enum above */
|
|
time_t time; /* time stamp of last pg_control update */
|
|
XLogRecPtr checkPoint; /* last check point record ptr */
|
|
XLogRecPtr prevCheckPoint; /* previous check point record ptr */
|
|
|
|
CheckPoint checkPointCopy; /* copy of last check point record */
|
|
|
|
XLogRecPtr minRecoveryPoint; /* must replay xlog to here */
|
|
|
|
/*
|
|
* This data is used to check for hardware-architecture compatibility of
|
|
* the database and the backend executable. We need not check endianness
|
|
* explicitly, since the pg_control version will surely look wrong to a
|
|
* machine of different endianness, but we do need to worry about MAXALIGN
|
|
* and floating-point format. (Note: storage layout nominally also
|
|
* depends on SHORTALIGN and INTALIGN, but in practice these are the same
|
|
* on all architectures of interest.)
|
|
*
|
|
* Testing just one double value is not a very bulletproof test for
|
|
* floating-point compatibility, but it will catch most cases.
|
|
*/
|
|
uint32 maxAlign; /* alignment requirement for tuples */
|
|
double floatFormat; /* constant 1234567.0 */
|
|
#define FLOATFORMAT_VALUE 1234567.0
|
|
|
|
/*
|
|
* This data is used to make sure that configuration of this database is
|
|
* compatible with the backend executable.
|
|
*/
|
|
uint32 blcksz; /* data block size for this DB */
|
|
uint32 relseg_size; /* blocks per segment of large relation */
|
|
|
|
uint32 xlog_blcksz; /* block size within WAL files */
|
|
uint32 xlog_seg_size; /* size of each WAL segment */
|
|
|
|
uint32 nameDataLen; /* catalog name field width */
|
|
uint32 indexMaxKeys; /* max number of columns in an index */
|
|
|
|
uint32 toast_max_chunk_size; /* chunk size in TOAST tables */
|
|
|
|
/* flag indicating internal format of timestamp, interval, time */
|
|
uint32 enableIntTimes; /* int64 storage enabled? */
|
|
|
|
/* active locales */
|
|
uint32 localeBuflen;
|
|
char lc_collate[LOCALE_NAME_BUFLEN];
|
|
char lc_ctype[LOCALE_NAME_BUFLEN];
|
|
|
|
/* CRC of all above ... MUST BE LAST! */
|
|
pg_crc32 crc;
|
|
} ControlFileData;
|
|
|
|
#endif
|
|
|
|
/***********************************************************************************************************************************
|
|
Types from src/include/access/xlog_internal.h
|
|
***********************************************************************************************************************************/
|
|
|
|
// XLOG_PAGE_MAGIC define
|
|
// ---------------------------------------------------------------------------------------------------------------------------------
|
|
#if PG_VERSION > PG_VERSION_MAX
|
|
|
|
#elif PG_VERSION >= PG_VERSION_14
|
|
|
|
#define XLOG_PAGE_MAGIC 0xD10D /* can be used as WAL version indicator */
|
|
|
|
#elif PG_VERSION >= PG_VERSION_13
|
|
|
|
#define XLOG_PAGE_MAGIC 0xD106 /* can be used as WAL version indicator */
|
|
|
|
#elif PG_VERSION >= PG_VERSION_12
|
|
|
|
#define XLOG_PAGE_MAGIC 0xD101 /* can be used as WAL version indicator */
|
|
|
|
#elif PG_VERSION >= PG_VERSION_11
|
|
|
|
#define XLOG_PAGE_MAGIC 0xD098 /* can be used as WAL version indicator */
|
|
|
|
#elif PG_VERSION >= PG_VERSION_10
|
|
|
|
#define XLOG_PAGE_MAGIC 0xD097 /* can be used as WAL version indicator */
|
|
|
|
#elif PG_VERSION >= PG_VERSION_96
|
|
|
|
#define XLOG_PAGE_MAGIC 0xD093 /* can be used as WAL version indicator */
|
|
|
|
#elif PG_VERSION >= PG_VERSION_95
|
|
|
|
#define XLOG_PAGE_MAGIC 0xD087 /* can be used as WAL version indicator */
|
|
|
|
#elif PG_VERSION >= PG_VERSION_94
|
|
|
|
#define XLOG_PAGE_MAGIC 0xD07E /* can be used as WAL version indicator */
|
|
|
|
#elif PG_VERSION >= PG_VERSION_93
|
|
|
|
#define XLOG_PAGE_MAGIC 0xD075 /* can be used as WAL version indicator */
|
|
|
|
#elif PG_VERSION >= PG_VERSION_92
|
|
|
|
#define XLOG_PAGE_MAGIC 0xD071 /* can be used as WAL version indicator */
|
|
|
|
#elif PG_VERSION >= PG_VERSION_91
|
|
|
|
#define XLOG_PAGE_MAGIC 0xD066 /* can be used as WAL version indicator */
|
|
|
|
#elif PG_VERSION >= PG_VERSION_90
|
|
|
|
#define XLOG_PAGE_MAGIC 0xD064 /* can be used as WAL version indicator */
|
|
|
|
#elif PG_VERSION >= PG_VERSION_84
|
|
|
|
#define XLOG_PAGE_MAGIC 0xD063 /* can be used as WAL version indicator */
|
|
|
|
#elif PG_VERSION >= PG_VERSION_83
|
|
|
|
#define XLOG_PAGE_MAGIC 0xD062 /* can be used as WAL version indicator */
|
|
|
|
#endif
|
|
|
|
// XLogPageHeaderData type
|
|
// ---------------------------------------------------------------------------------------------------------------------------------
|
|
#if PG_VERSION > PG_VERSION_MAX
|
|
|
|
#elif PG_VERSION >= PG_VERSION_14
|
|
|
|
/*
|
|
* Each page of XLOG file has a header like this:
|
|
*/
|
|
typedef struct XLogPageHeaderData
|
|
{
|
|
uint16 xlp_magic; /* magic value for correctness checks */
|
|
uint16 xlp_info; /* flag bits, see below */
|
|
TimeLineID xlp_tli; /* TimeLineID of first record on page */
|
|
XLogRecPtr xlp_pageaddr; /* XLOG address of this page */
|
|
|
|
/*
|
|
* When there is not enough space on current page for whole record, we
|
|
* continue on the next page. xlp_rem_len is the number of bytes
|
|
* remaining from a previous page; it tracks xl_tot_len in the initial
|
|
* header. Note that the continuation data isn't necessarily aligned.
|
|
*/
|
|
uint32 xlp_rem_len; /* total len of remaining data for record */
|
|
} XLogPageHeaderData;
|
|
|
|
#elif PG_VERSION >= PG_VERSION_93
|
|
|
|
/*
|
|
* Each page of XLOG file has a header like this:
|
|
*/
|
|
typedef struct XLogPageHeaderData
|
|
{
|
|
uint16 xlp_magic; /* magic value for correctness checks */
|
|
uint16 xlp_info; /* flag bits, see below */
|
|
TimeLineID xlp_tli; /* TimeLineID of first record on page */
|
|
XLogRecPtr xlp_pageaddr; /* XLOG address of this page */
|
|
|
|
/*
|
|
* When there is not enough space on current page for whole record, we
|
|
* continue on the next page. xlp_rem_len is the number of bytes
|
|
* remaining from a previous page.
|
|
*
|
|
* Note that xlp_rem_len includes backup-block data; that is, it tracks
|
|
* xl_tot_len not xl_len in the initial header. Also note that the
|
|
* continuation data isn't necessarily aligned.
|
|
*/
|
|
uint32 xlp_rem_len; /* total len of remaining data for record */
|
|
} XLogPageHeaderData;
|
|
|
|
#elif PG_VERSION >= PG_VERSION_83
|
|
|
|
/*
|
|
* Each page of XLOG file has a header like this:
|
|
*/
|
|
typedef struct XLogPageHeaderData
|
|
{
|
|
uint16 xlp_magic; /* magic value for correctness checks */
|
|
uint16 xlp_info; /* flag bits, see below */
|
|
TimeLineID xlp_tli; /* TimeLineID of first record on page */
|
|
XLogRecPtr xlp_pageaddr; /* XLOG address of this page */
|
|
} XLogPageHeaderData;
|
|
|
|
#endif
|
|
|
|
// XLogLongPageHeaderData type
|
|
// ---------------------------------------------------------------------------------------------------------------------------------
|
|
#if PG_VERSION > PG_VERSION_MAX
|
|
|
|
#elif PG_VERSION >= PG_VERSION_83
|
|
|
|
/*
|
|
* When the XLP_LONG_HEADER flag is set, we store additional fields in the
|
|
* page header. (This is ordinarily done just in the first page of an
|
|
* XLOG file.) The additional fields serve to identify the file accurately.
|
|
*/
|
|
typedef struct XLogLongPageHeaderData
|
|
{
|
|
XLogPageHeaderData std; /* standard header fields */
|
|
uint64 xlp_sysid; /* system identifier from pg_control */
|
|
uint32 xlp_seg_size; /* just as a cross-check */
|
|
uint32 xlp_xlog_blcksz; /* just as a cross-check */
|
|
} XLogLongPageHeaderData;
|
|
|
|
#endif
|
|
|
|
// XLP_LONG_HEADER define
|
|
// ---------------------------------------------------------------------------------------------------------------------------------
|
|
#if PG_VERSION > PG_VERSION_MAX
|
|
|
|
#elif PG_VERSION >= PG_VERSION_83
|
|
|
|
/* This flag indicates a "long" page header */
|
|
#define XLP_LONG_HEADER 0x0002
|
|
|
|
#endif
|