From c29aff959dc64f7321062e7f33d8c6ec23db53d3 Mon Sep 17 00:00:00 2001 From: Tom Lane Date: Thu, 23 Feb 2017 15:57:08 -0500 Subject: [PATCH] Consistently declare timestamp variables as TimestampTz. Twiddle the replication-related code so that its timestamp variables are declared TimestampTz, rather than the uninformative "int64" that was previously used for meant-to-be-always-integer timestamps. This resolves the int64-vs-TimestampTz declaration inconsistencies introduced by commit 7c030783a, though in the opposite direction to what was originally suggested. This required including datatype/timestamp.h in a couple more places than before. I decided it would be a good idea to slim down that header by not having it pull in etc, as those headers are no longer at all relevant to its purpose. Unsurprisingly, a small number of .c files turn out to have been depending on those inclusions, so add them back in the .c files as needed. Discussion: https://postgr.es/m/26788.1487455319@sss.pgh.pa.us Discussion: https://postgr.es/m/27694.1487456324@sss.pgh.pa.us --- contrib/auth_delay/auth_delay.c | 2 + contrib/btree_gist/btree_ts.c | 2 + src/backend/access/common/reloptions.c | 2 + src/backend/access/transam/xlog.c | 1 + src/backend/commands/prepare.c | 2 + src/backend/executor/nodeBitmapHeapscan.c | 2 + src/backend/replication/basebackup.c | 12 +++--- src/backend/replication/logical/worker.c | 14 +++---- src/backend/replication/walreceiver.c | 10 ++--- src/backend/replication/walsender.c | 9 +++-- src/backend/tcop/pquery.c | 2 + src/backend/utils/adt/nabstime.c | 1 + src/backend/utils/cache/inval.c | 2 + src/backend/utils/time/snapmgr.c | 45 ++++++++++++----------- src/bin/pg_basebackup/pg_recvlogical.c | 18 ++++----- src/bin/pg_basebackup/receivelog.c | 22 +++++------ src/bin/pg_basebackup/streamutil.c | 20 +++++----- src/bin/pg_basebackup/streamutil.h | 7 ++-- src/include/datatype/timestamp.h | 4 -- src/include/utils/snapmgr.h | 7 ++-- src/include/utils/snapshot.h | 3 +- src/include/utils/timestamp.h | 7 ---- 22 files changed, 100 insertions(+), 94 deletions(-) diff --git a/contrib/auth_delay/auth_delay.c b/contrib/auth_delay/auth_delay.c index 326ca79d73..e0604fb808 100644 --- a/contrib/auth_delay/auth_delay.c +++ b/contrib/auth_delay/auth_delay.c @@ -11,6 +11,8 @@ */ #include "postgres.h" +#include + #include "libpq/auth.h" #include "port.h" #include "utils/guc.h" diff --git a/contrib/btree_gist/btree_ts.c b/contrib/btree_gist/btree_ts.c index 68177d2784..97408f54d2 100644 --- a/contrib/btree_gist/btree_ts.c +++ b/contrib/btree_gist/btree_ts.c @@ -3,6 +3,8 @@ */ #include "postgres.h" +#include + #include "btree_gist.h" #include "btree_utils_num.h" #include "utils/builtins.h" diff --git a/src/backend/access/common/reloptions.c b/src/backend/access/common/reloptions.c index 816483ef8b..42b4ea410f 100644 --- a/src/backend/access/common/reloptions.c +++ b/src/backend/access/common/reloptions.c @@ -15,6 +15,8 @@ #include "postgres.h" +#include + #include "access/gist_private.h" #include "access/hash.h" #include "access/htup_details.h" diff --git a/src/backend/access/transam/xlog.c b/src/backend/access/transam/xlog.c index ebae9da0f8..50162739f8 100644 --- a/src/backend/access/transam/xlog.c +++ b/src/backend/access/transam/xlog.c @@ -15,6 +15,7 @@ #include "postgres.h" #include +#include #include #include #include diff --git a/src/backend/commands/prepare.c b/src/backend/commands/prepare.c index 7b61da3ef0..116ed67547 100644 --- a/src/backend/commands/prepare.c +++ b/src/backend/commands/prepare.c @@ -16,6 +16,8 @@ */ #include "postgres.h" +#include + #include "access/xact.h" #include "catalog/pg_type.h" #include "commands/createas.h" diff --git a/src/backend/executor/nodeBitmapHeapscan.c b/src/backend/executor/nodeBitmapHeapscan.c index f18827de0b..c871aa0348 100644 --- a/src/backend/executor/nodeBitmapHeapscan.c +++ b/src/backend/executor/nodeBitmapHeapscan.c @@ -35,6 +35,8 @@ */ #include "postgres.h" +#include + #include "access/relscan.h" #include "access/transam.h" #include "executor/execdebug.h" diff --git a/src/backend/replication/basebackup.c b/src/backend/replication/basebackup.c index 09ecc15365..643a17943a 100644 --- a/src/backend/replication/basebackup.c +++ b/src/backend/replication/basebackup.c @@ -92,10 +92,10 @@ static uint64 throttling_sample; static int64 throttling_counter; /* The minimum time required to transfer throttling_sample bytes. */ -static int64 elapsed_min_unit; +static TimeOffset elapsed_min_unit; /* The last check of the transfer rate. */ -static int64 throttled_last; +static TimestampTz throttled_last; /* * The contents of these directories are removed or recreated during server @@ -254,7 +254,7 @@ perform_base_backup(basebackup_options *opt, DIR *tblspcdir) throttling_counter = 0; /* The 'real data' starts now (header was ignored). */ - throttled_last = GetCurrentIntegerTimestamp(); + throttled_last = GetCurrentTimestamp(); } else { @@ -1333,7 +1333,7 @@ _tarWriteDir(const char *pathbuf, int basepathlen, struct stat *statbuf, static void throttle(size_t increment) { - int64 elapsed, + TimeOffset elapsed, elapsed_min, sleep; int wait_result; @@ -1346,7 +1346,7 @@ throttle(size_t increment) return; /* Time elapsed since the last measurement (and possible wake up). */ - elapsed = GetCurrentIntegerTimestamp() - throttled_last; + elapsed = GetCurrentTimestamp() - throttled_last; /* How much should have elapsed at minimum? */ elapsed_min = elapsed_min_unit * (throttling_counter / throttling_sample); sleep = elapsed_min - elapsed; @@ -1381,5 +1381,5 @@ throttle(size_t increment) * Time interval for the remaining amount and possible next increments * starts now. */ - throttled_last = GetCurrentIntegerTimestamp(); + throttled_last = GetCurrentTimestamp(); } diff --git a/src/backend/replication/logical/worker.c b/src/backend/replication/logical/worker.c index 563886b7b5..f73bdcd673 100644 --- a/src/backend/replication/logical/worker.c +++ b/src/backend/replication/logical/worker.c @@ -981,12 +981,11 @@ ApplyLoop(void) { XLogRecPtr start_lsn; XLogRecPtr end_lsn; - TimestampTz send_time; + TimestampTz send_time; start_lsn = pq_getmsgint64(&s); end_lsn = pq_getmsgint64(&s); - send_time = - IntegerTimestampToTimestampTz(pq_getmsgint64(&s)); + send_time = pq_getmsgint64(&s); if (last_received < start_lsn) last_received = start_lsn; @@ -1000,13 +999,12 @@ ApplyLoop(void) } else if (c == 'k') { - XLogRecPtr endpos; - TimestampTz timestamp; - bool reply_requested; + XLogRecPtr endpos; + TimestampTz timestamp; + bool reply_requested; endpos = pq_getmsgint64(&s); - timestamp = - IntegerTimestampToTimestampTz(pq_getmsgint64(&s)); + timestamp = pq_getmsgint64(&s); reply_requested = pq_getmsgbyte(&s); send_feedback(endpos, reply_requested, false); diff --git a/src/backend/replication/walreceiver.c b/src/backend/replication/walreceiver.c index 5c2e72ba9b..18d9d7e4ec 100644 --- a/src/backend/replication/walreceiver.c +++ b/src/backend/replication/walreceiver.c @@ -892,8 +892,7 @@ XLogWalRcvProcessMsg(unsigned char type, char *buf, Size len) /* read the fields */ dataStart = pq_getmsgint64(&incoming_message); walEnd = pq_getmsgint64(&incoming_message); - sendTime = IntegerTimestampToTimestampTz( - pq_getmsgint64(&incoming_message)); + sendTime = pq_getmsgint64(&incoming_message); ProcessWalSndrMessage(walEnd, sendTime); buf += hdrlen; @@ -913,8 +912,7 @@ XLogWalRcvProcessMsg(unsigned char type, char *buf, Size len) /* read the fields */ walEnd = pq_getmsgint64(&incoming_message); - sendTime = IntegerTimestampToTimestampTz( - pq_getmsgint64(&incoming_message)); + sendTime = pq_getmsgint64(&incoming_message); replyRequested = pq_getmsgbyte(&incoming_message); ProcessWalSndrMessage(walEnd, sendTime); @@ -1149,7 +1147,7 @@ XLogWalRcvSendReply(bool force, bool requestReply) pq_sendint64(&reply_message, writePtr); pq_sendint64(&reply_message, flushPtr); pq_sendint64(&reply_message, applyPtr); - pq_sendint64(&reply_message, GetCurrentIntegerTimestamp()); + pq_sendint64(&reply_message, GetCurrentTimestamp()); pq_sendbyte(&reply_message, requestReply ? 1 : 0); /* Send it */ @@ -1241,7 +1239,7 @@ XLogWalRcvSendHSFeedback(bool immed) /* Construct the message and send it. */ resetStringInfo(&reply_message); pq_sendbyte(&reply_message, 'h'); - pq_sendint64(&reply_message, GetCurrentIntegerTimestamp()); + pq_sendint64(&reply_message, GetCurrentTimestamp()); pq_sendint(&reply_message, xmin, 4); pq_sendint(&reply_message, nextEpoch, 4); walrcv_send(wrconn, reply_message.data, reply_message.len); diff --git a/src/backend/replication/walsender.c b/src/backend/replication/walsender.c index 7a40863384..9cf9eb0e4c 100644 --- a/src/backend/replication/walsender.c +++ b/src/backend/replication/walsender.c @@ -823,12 +823,13 @@ CreateReplicationSlot(CreateReplicationSlotCmd *cmd) dest = CreateDestReceiver(DestRemoteSimple); MemSet(nulls, false, sizeof(nulls)); - /* + /*---------- * Need a tuple descriptor representing four columns: * - first field: the slot name * - second field: LSN at which we became consistent * - third field: exported snapshot's name * - fourth field: output plugin + *---------- */ tupdesc = CreateTemplateTupleDesc(4, false); TupleDescInitBuiltinEntry(tupdesc, (AttrNumber) 1, "slot_name", @@ -1014,7 +1015,7 @@ WalSndWriteData(LogicalDecodingContext *ctx, XLogRecPtr lsn, TransactionId xid, * several releases by streaming physical replication. */ resetStringInfo(&tmpbuf); - pq_sendint64(&tmpbuf, GetCurrentIntegerTimestamp()); + pq_sendint64(&tmpbuf, GetCurrentTimestamp()); memcpy(&ctx->out->data[1 + sizeof(int64) + sizeof(int64)], tmpbuf.data, sizeof(int64)); @@ -2334,7 +2335,7 @@ XLogSendPhysical(void) * Fill the send timestamp last, so that it is taken as late as possible. */ resetStringInfo(&tmpbuf); - pq_sendint64(&tmpbuf, GetCurrentIntegerTimestamp()); + pq_sendint64(&tmpbuf, GetCurrentTimestamp()); memcpy(&output_message.data[1 + sizeof(int64) + sizeof(int64)], tmpbuf.data, sizeof(int64)); @@ -2842,7 +2843,7 @@ WalSndKeepalive(bool requestReply) resetStringInfo(&output_message); pq_sendbyte(&output_message, 'k'); pq_sendint64(&output_message, sentPtr); - pq_sendint64(&output_message, GetCurrentIntegerTimestamp()); + pq_sendint64(&output_message, GetCurrentTimestamp()); pq_sendbyte(&output_message, requestReply ? 1 : 0); /* ... and send it wrapped in CopyData */ diff --git a/src/backend/tcop/pquery.c b/src/backend/tcop/pquery.c index e64ea2ed76..371d7350b7 100644 --- a/src/backend/tcop/pquery.c +++ b/src/backend/tcop/pquery.c @@ -15,6 +15,8 @@ #include "postgres.h" +#include + #include "access/xact.h" #include "commands/prepare.h" #include "executor/tstoreReceiver.h" diff --git a/src/backend/utils/adt/nabstime.c b/src/backend/utils/adt/nabstime.c index 6da769e562..3f6a9d3b82 100644 --- a/src/backend/utils/adt/nabstime.c +++ b/src/backend/utils/adt/nabstime.c @@ -19,6 +19,7 @@ #include #include #include +#include #include #include diff --git a/src/backend/utils/cache/inval.c b/src/backend/utils/cache/inval.c index 11f9218f66..8159ab340d 100644 --- a/src/backend/utils/cache/inval.c +++ b/src/backend/utils/cache/inval.c @@ -95,6 +95,8 @@ */ #include "postgres.h" +#include + #include "access/htup_details.h" #include "access/xact.h" #include "catalog/catalog.h" diff --git a/src/backend/utils/time/snapmgr.c b/src/backend/utils/time/snapmgr.c index 92afc32509..f232c8448c 100644 --- a/src/backend/utils/time/snapmgr.c +++ b/src/backend/utils/time/snapmgr.c @@ -83,13 +83,13 @@ typedef struct OldSnapshotControlData * only allowed to move forward. */ slock_t mutex_current; /* protect current_timestamp */ - int64 current_timestamp; /* latest snapshot timestamp */ + TimestampTz current_timestamp; /* latest snapshot timestamp */ slock_t mutex_latest_xmin; /* protect latest_xmin and * next_map_update */ TransactionId latest_xmin; /* latest snapshot xmin */ - int64 next_map_update; /* latest snapshot valid up to */ + TimestampTz next_map_update; /* latest snapshot valid up to */ slock_t mutex_threshold; /* protect threshold fields */ - int64 threshold_timestamp; /* earlier snapshot is old */ + TimestampTz threshold_timestamp; /* earlier snapshot is old */ TransactionId threshold_xid; /* earlier xid may be gone */ /* @@ -121,7 +121,7 @@ typedef struct OldSnapshotControlData * Persistence is not needed. */ int head_offset; /* subscript of oldest tracked time */ - int64 head_timestamp; /* time corresponding to head xid */ + TimestampTz head_timestamp; /* time corresponding to head xid */ int count_used; /* how many slots are in use */ TransactionId xid_by_minute[FLEXIBLE_ARRAY_MEMBER]; } OldSnapshotControlData; @@ -219,7 +219,7 @@ static Snapshot FirstXactSnapshot = NULL; static List *exportedSnapshots = NIL; /* Prototypes for local functions */ -static int64 AlignTimestampToMinuteBoundary(int64 ts); +static TimestampTz AlignTimestampToMinuteBoundary(TimestampTz ts); static Snapshot CopySnapshot(Snapshot snapshot); static void FreeSnapshot(Snapshot snapshot); static void SnapshotResetXmin(void); @@ -239,7 +239,7 @@ typedef struct SerializedSnapshotData bool suboverflowed; bool takenDuringRecovery; CommandId curcid; - int64 whenTaken; + TimestampTz whenTaken; XLogRecPtr lsn; } SerializedSnapshotData; @@ -1611,26 +1611,29 @@ ThereAreNoPriorRegisteredSnapshots(void) /* - * Return an int64 timestamp which is exactly on a minute boundary. + * Return a timestamp that is exactly on a minute boundary. * * If the argument is already aligned, return that value, otherwise move to * the next minute boundary following the given time. */ -static int64 -AlignTimestampToMinuteBoundary(int64 ts) +static TimestampTz +AlignTimestampToMinuteBoundary(TimestampTz ts) { - int64 retval = ts + (USECS_PER_MINUTE - 1); + TimestampTz retval = ts + (USECS_PER_MINUTE - 1); return retval - (retval % USECS_PER_MINUTE); } /* - * Get current timestamp for snapshots as int64 that never moves backward. + * Get current timestamp for snapshots + * + * This is basically GetCurrentTimestamp(), but with a guarantee that + * the result never moves backward. */ -int64 +TimestampTz GetSnapshotCurrentTimestamp(void) { - int64 now = GetCurrentIntegerTimestamp(); + TimestampTz now = GetCurrentTimestamp(); /* * Don't let time move backward; if it hasn't advanced, use the old value. @@ -1652,10 +1655,10 @@ GetSnapshotCurrentTimestamp(void) * XXX: So far, we never trust that a 64-bit value can be read atomically; if * that ever changes, we could get rid of the spinlock here. */ -int64 +TimestampTz GetOldSnapshotThresholdTimestamp(void) { - int64 threshold_timestamp; + TimestampTz threshold_timestamp; SpinLockAcquire(&oldSnapshotControl->mutex_threshold); threshold_timestamp = oldSnapshotControl->threshold_timestamp; @@ -1665,7 +1668,7 @@ GetOldSnapshotThresholdTimestamp(void) } static void -SetOldSnapshotThresholdTimestamp(int64 ts, TransactionId xlimit) +SetOldSnapshotThresholdTimestamp(TimestampTz ts, TransactionId xlimit) { SpinLockAcquire(&oldSnapshotControl->mutex_threshold); oldSnapshotControl->threshold_timestamp = ts; @@ -1690,10 +1693,10 @@ TransactionIdLimitedForOldSnapshots(TransactionId recentXmin, && old_snapshot_threshold >= 0 && RelationAllowsEarlyPruning(relation)) { - int64 ts = GetSnapshotCurrentTimestamp(); + TimestampTz ts = GetSnapshotCurrentTimestamp(); TransactionId xlimit = recentXmin; TransactionId latest_xmin; - int64 update_ts; + TimestampTz update_ts; bool same_ts_as_threshold = false; SpinLockAcquire(&oldSnapshotControl->mutex_latest_xmin); @@ -1790,11 +1793,11 @@ TransactionIdLimitedForOldSnapshots(TransactionId recentXmin, * Take care of the circular buffer that maps time to xid. */ void -MaintainOldSnapshotTimeMapping(int64 whenTaken, TransactionId xmin) +MaintainOldSnapshotTimeMapping(TimestampTz whenTaken, TransactionId xmin) { - int64 ts; + TimestampTz ts; TransactionId latest_xmin; - int64 update_ts; + TimestampTz update_ts; bool map_update_required = false; /* Never call this function when old snapshot checking is disabled. */ diff --git a/src/bin/pg_basebackup/pg_recvlogical.c b/src/bin/pg_basebackup/pg_recvlogical.c index d16d08b664..6b081bd737 100644 --- a/src/bin/pg_basebackup/pg_recvlogical.c +++ b/src/bin/pg_basebackup/pg_recvlogical.c @@ -57,7 +57,7 @@ static int outfd = -1; static volatile sig_atomic_t time_to_abort = false; static volatile sig_atomic_t output_reopen = false; static bool output_isfile; -static int64 output_last_fsync = -1; +static TimestampTz output_last_fsync = -1; static bool output_needs_fsync = false; static XLogRecPtr output_written_lsn = InvalidXLogRecPtr; static XLogRecPtr output_fsync_lsn = InvalidXLogRecPtr; @@ -112,7 +112,7 @@ usage(void) * Send a Standby Status Update message to server. */ static bool -sendFeedback(PGconn *conn, int64 now, bool force, bool replyRequested) +sendFeedback(PGconn *conn, TimestampTz now, bool force, bool replyRequested) { static XLogRecPtr last_written_lsn = InvalidXLogRecPtr; static XLogRecPtr last_fsync_lsn = InvalidXLogRecPtr; @@ -175,7 +175,7 @@ disconnect_and_exit(int code) } static bool -OutputFsync(int64 now) +OutputFsync(TimestampTz now) { output_last_fsync = now; @@ -212,7 +212,7 @@ StreamLogicalLog(void) { PGresult *res; char *copybuf = NULL; - int64 last_status = -1; + TimestampTz last_status = -1; int i; PQExpBuffer query; @@ -285,7 +285,7 @@ StreamLogicalLog(void) int r; int bytes_left; int bytes_written; - int64 now; + TimestampTz now; int hdr_len; XLogRecPtr cur_record_lsn = InvalidXLogRecPtr; @@ -365,8 +365,8 @@ StreamLogicalLog(void) * response back to the client. */ fd_set input_mask; - int64 message_target = 0; - int64 fsync_target = 0; + TimestampTz message_target = 0; + TimestampTz fsync_target = 0; struct timeval timeout; struct timeval *timeoutptr = NULL; @@ -394,7 +394,7 @@ StreamLogicalLog(void) /* Now compute when to wakeup. */ if (message_target > 0 || fsync_target > 0) { - int64 targettime; + TimestampTz targettime; long secs; int usecs; @@ -622,7 +622,7 @@ StreamLogicalLog(void) if (outfd != -1 && strcmp(outfile, "-") != 0) { - int64 t = feGetCurrentTimestamp(); + TimestampTz t = feGetCurrentTimestamp(); /* no need to jump to error on failure here, we're finishing anyway */ OutputFsync(t); diff --git a/src/bin/pg_basebackup/receivelog.c b/src/bin/pg_basebackup/receivelog.c index 55612832a6..f415135172 100644 --- a/src/bin/pg_basebackup/receivelog.c +++ b/src/bin/pg_basebackup/receivelog.c @@ -42,15 +42,15 @@ static PGresult *HandleCopyStream(PGconn *conn, StreamCtl *stream, static int CopyStreamPoll(PGconn *conn, long timeout_ms); static int CopyStreamReceive(PGconn *conn, long timeout, char **buffer); static bool ProcessKeepaliveMsg(PGconn *conn, StreamCtl *stream, char *copybuf, - int len, XLogRecPtr blockpos, int64 *last_status); + int len, XLogRecPtr blockpos, TimestampTz *last_status); static bool ProcessXLogDataMsg(PGconn *conn, StreamCtl *stream, char *copybuf, int len, XLogRecPtr *blockpos); static PGresult *HandleEndOfCopyStream(PGconn *conn, StreamCtl *stream, char *copybuf, XLogRecPtr blockpos, XLogRecPtr *stoppos); static bool CheckCopyStreamStop(PGconn *conn, StreamCtl *stream, XLogRecPtr blockpos, XLogRecPtr *stoppos); -static long CalculateCopyStreamSleeptime(int64 now, int standby_message_timeout, - int64 last_status); +static long CalculateCopyStreamSleeptime(TimestampTz now, int standby_message_timeout, + TimestampTz last_status); static bool ReadEndOfStreamingResult(PGresult *res, XLogRecPtr *startpos, uint32 *timeline); @@ -319,7 +319,7 @@ writeTimeLineHistoryFile(StreamCtl *stream, char *filename, char *content) * Send a Standby Status Update message to server. */ static bool -sendFeedback(PGconn *conn, XLogRecPtr blockpos, int64 now, bool replyRequested) +sendFeedback(PGconn *conn, XLogRecPtr blockpos, TimestampTz now, bool replyRequested) { char replybuf[1 + 8 + 8 + 8 + 8 + 1]; int len = 0; @@ -761,7 +761,7 @@ HandleCopyStream(PGconn *conn, StreamCtl *stream, XLogRecPtr *stoppos) { char *copybuf = NULL; - int64 last_status = -1; + TimestampTz last_status = -1; XLogRecPtr blockpos = stream->startpos; still_sending = true; @@ -769,7 +769,7 @@ HandleCopyStream(PGconn *conn, StreamCtl *stream, while (1) { int r; - int64 now; + TimestampTz now; long sleeptime; /* @@ -994,11 +994,11 @@ CopyStreamReceive(PGconn *conn, long timeout, char **buffer) */ static bool ProcessKeepaliveMsg(PGconn *conn, StreamCtl *stream, char *copybuf, int len, - XLogRecPtr blockpos, int64 *last_status) + XLogRecPtr blockpos, TimestampTz *last_status) { int pos; bool replyRequested; - int64 now; + TimestampTz now; /* * Parse the keepalive message, enclosed in the CopyData message. We just @@ -1253,10 +1253,10 @@ CheckCopyStreamStop(PGconn *conn, StreamCtl *stream, XLogRecPtr blockpos, * Calculate how long send/receive loops should sleep */ static long -CalculateCopyStreamSleeptime(int64 now, int standby_message_timeout, - int64 last_status) +CalculateCopyStreamSleeptime(TimestampTz now, int standby_message_timeout, + TimestampTz last_status) { - int64 status_targettime = 0; + TimestampTz status_targettime = 0; long sleeptime; if (standby_message_timeout && still_sending) diff --git a/src/bin/pg_basebackup/streamutil.c b/src/bin/pg_basebackup/streamutil.c index 35143f5de7..90d93cbed1 100644 --- a/src/bin/pg_basebackup/streamutil.c +++ b/src/bin/pg_basebackup/streamutil.c @@ -433,20 +433,18 @@ DropReplicationSlot(PGconn *conn, const char *slot_name) /* * Frontend version of GetCurrentTimestamp(), since we are not linked with - * backend code. The replication protocol always uses integer timestamps, - * regardless of the server setting. + * backend code. */ -int64 +TimestampTz feGetCurrentTimestamp(void) { - int64 result; + TimestampTz result; struct timeval tp; gettimeofday(&tp, NULL); - result = (int64) tp.tv_sec - + result = (TimestampTz) tp.tv_sec - ((POSTGRES_EPOCH_JDATE - UNIX_EPOCH_JDATE) * SECS_PER_DAY); - result = (result * USECS_PER_SEC) + tp.tv_usec; return result; @@ -457,10 +455,10 @@ feGetCurrentTimestamp(void) * backend code. */ void -feTimestampDifference(int64 start_time, int64 stop_time, +feTimestampDifference(TimestampTz start_time, TimestampTz stop_time, long *secs, int *microsecs) { - int64 diff = stop_time - start_time; + TimestampTz diff = stop_time - start_time; if (diff <= 0) { @@ -479,11 +477,11 @@ feTimestampDifference(int64 start_time, int64 stop_time, * linked with backend code. */ bool -feTimestampDifferenceExceeds(int64 start_time, - int64 stop_time, +feTimestampDifferenceExceeds(TimestampTz start_time, + TimestampTz stop_time, int msec) { - int64 diff = stop_time - start_time; + TimestampTz diff = stop_time - start_time; return (diff >= msec * INT64CONST(1000)); } diff --git a/src/bin/pg_basebackup/streamutil.h b/src/bin/pg_basebackup/streamutil.h index 663bfac5cc..460dcb5267 100644 --- a/src/bin/pg_basebackup/streamutil.h +++ b/src/bin/pg_basebackup/streamutil.h @@ -15,6 +15,7 @@ #include "libpq-fe.h" #include "access/xlogdefs.h" +#include "datatype/timestamp.h" extern const char *progname; extern char *connection_string; @@ -38,11 +39,11 @@ extern bool RunIdentifySystem(PGconn *conn, char **sysid, TimeLineID *starttli, XLogRecPtr *startpos, char **db_name); -extern int64 feGetCurrentTimestamp(void); -extern void feTimestampDifference(int64 start_time, int64 stop_time, +extern TimestampTz feGetCurrentTimestamp(void); +extern void feTimestampDifference(TimestampTz start_time, TimestampTz stop_time, long *secs, int *microsecs); -extern bool feTimestampDifferenceExceeds(int64 start_time, int64 stop_time, +extern bool feTimestampDifferenceExceeds(TimestampTz start_time, TimestampTz stop_time, int msec); extern void fe_sendint64(int64 i, char *buf); extern int64 fe_recvint64(char *buf); diff --git a/src/include/datatype/timestamp.h b/src/include/datatype/timestamp.h index 60f431623b..16e1b4c44d 100644 --- a/src/include/datatype/timestamp.h +++ b/src/include/datatype/timestamp.h @@ -15,10 +15,6 @@ #ifndef DATATYPE_TIMESTAMP_H #define DATATYPE_TIMESTAMP_H -#include -#include -#include - /* * Timestamp represents absolute time. * diff --git a/src/include/utils/snapmgr.h b/src/include/utils/snapmgr.h index 2618cc4546..ab953669bf 100644 --- a/src/include/utils/snapmgr.h +++ b/src/include/utils/snapmgr.h @@ -51,8 +51,8 @@ extern PGDLLIMPORT int old_snapshot_threshold; extern Size SnapMgrShmemSize(void); extern void SnapMgrInit(void); -extern int64 GetSnapshotCurrentTimestamp(void); -extern int64 GetOldSnapshotThresholdTimestamp(void); +extern TimestampTz GetSnapshotCurrentTimestamp(void); +extern TimestampTz GetOldSnapshotThresholdTimestamp(void); extern bool FirstSnapshotSet; @@ -93,7 +93,8 @@ extern void DeleteAllExportedSnapshotFiles(void); extern bool ThereAreNoPriorRegisteredSnapshots(void); extern TransactionId TransactionIdLimitedForOldSnapshots(TransactionId recentXmin, Relation relation); -extern void MaintainOldSnapshotTimeMapping(int64 whenTaken, TransactionId xmin); +extern void MaintainOldSnapshotTimeMapping(TimestampTz whenTaken, + TransactionId xmin); extern char *ExportSnapshot(Snapshot snapshot); diff --git a/src/include/utils/snapshot.h b/src/include/utils/snapshot.h index ebd5d5a85c..2bcaa42277 100644 --- a/src/include/utils/snapshot.h +++ b/src/include/utils/snapshot.h @@ -15,6 +15,7 @@ #include "access/htup.h" #include "access/xlogdefs.h" +#include "datatype/timestamp.h" #include "lib/pairingheap.h" #include "storage/buf.h" @@ -107,7 +108,7 @@ typedef struct SnapshotData uint32 regd_count; /* refcount on RegisteredSnapshots */ pairingheap_node ph_node; /* link in the RegisteredSnapshots heap */ - int64 whenTaken; /* timestamp when snapshot was taken */ + TimestampTz whenTaken; /* timestamp when snapshot was taken */ XLogRecPtr lsn; /* position in the WAL stream when taken */ } SnapshotData; diff --git a/src/include/utils/timestamp.h b/src/include/utils/timestamp.h index d9098354a8..7fd1c7692f 100644 --- a/src/include/utils/timestamp.h +++ b/src/include/utils/timestamp.h @@ -76,13 +76,6 @@ extern bool TimestampDifferenceExceeds(TimestampTz start_time, TimestampTz stop_time, int msec); -/* - * Prototypes for functions to deal with integer timestamps, when the native - * format is float timestamps. - */ -#define GetCurrentIntegerTimestamp() GetCurrentTimestamp() -#define IntegerTimestampToTimestampTz(timestamp) (timestamp) - extern TimestampTz time_t_to_timestamptz(pg_time_t tm); extern pg_time_t timestamptz_to_time_t(TimestampTz t); -- 2.40.0