mirror of
https://github.com/postgres/postgres.git
synced 2025-11-15 03:41:20 +03:00
c219d9b0a5
This reduces unnecessary exposure of other headers through htup.h, which is very widely included by many files. I have chosen to move the function prototypes to the new file as well, because that means htup.h no longer needs to include tupdesc.h. In itself this doesn't have much effect in indirect inclusion of tupdesc.h throughout the tree, because it's also required by execnodes.h; but it's something to explore in the future, and it seemed best to do the htup.h change now while I'm busy with it.
627 lines
16 KiB
C
627 lines
16 KiB
C
/*-------------------------------------------------------------------------
|
|
*
|
|
* xlogfuncs.c
|
|
*
|
|
* PostgreSQL transaction log manager user interface functions
|
|
*
|
|
* This file contains WAL control and information functions.
|
|
*
|
|
*
|
|
* Portions Copyright (c) 1996-2012, PostgreSQL Global Development Group
|
|
* Portions Copyright (c) 1994, Regents of the University of California
|
|
*
|
|
* src/backend/access/transam/xlogfuncs.c
|
|
*
|
|
*-------------------------------------------------------------------------
|
|
*/
|
|
#include "postgres.h"
|
|
|
|
#include "access/htup_details.h"
|
|
#include "access/xlog.h"
|
|
#include "access/xlog_internal.h"
|
|
#include "access/xlogutils.h"
|
|
#include "catalog/catalog.h"
|
|
#include "catalog/pg_type.h"
|
|
#include "funcapi.h"
|
|
#include "miscadmin.h"
|
|
#include "replication/walreceiver.h"
|
|
#include "storage/smgr.h"
|
|
#include "utils/builtins.h"
|
|
#include "utils/numeric.h"
|
|
#include "utils/guc.h"
|
|
#include "utils/timestamp.h"
|
|
#include "storage/fd.h"
|
|
|
|
static void validate_xlog_location(char *str);
|
|
|
|
|
|
/*
|
|
* pg_start_backup: set up for taking an on-line backup dump
|
|
*
|
|
* Essentially what this does is to create a backup label file in $PGDATA,
|
|
* where it will be archived as part of the backup dump. The label file
|
|
* contains the user-supplied label string (typically this would be used
|
|
* to tell where the backup dump will be stored) and the starting time and
|
|
* starting WAL location for the dump.
|
|
*/
|
|
Datum
|
|
pg_start_backup(PG_FUNCTION_ARGS)
|
|
{
|
|
text *backupid = PG_GETARG_TEXT_P(0);
|
|
bool fast = PG_GETARG_BOOL(1);
|
|
char *backupidstr;
|
|
XLogRecPtr startpoint;
|
|
char startxlogstr[MAXFNAMELEN];
|
|
|
|
backupidstr = text_to_cstring(backupid);
|
|
|
|
startpoint = do_pg_start_backup(backupidstr, fast, NULL);
|
|
|
|
snprintf(startxlogstr, sizeof(startxlogstr), "%X/%X",
|
|
(uint32) (startpoint >> 32), (uint32) startpoint);
|
|
PG_RETURN_TEXT_P(cstring_to_text(startxlogstr));
|
|
}
|
|
|
|
/*
|
|
* pg_stop_backup: finish taking an on-line backup dump
|
|
*
|
|
* We write an end-of-backup WAL record, and remove the backup label file
|
|
* created by pg_start_backup, creating a backup history file in pg_xlog
|
|
* instead (whence it will immediately be archived). The backup history file
|
|
* contains the same info found in the label file, plus the backup-end time
|
|
* and WAL location. Before 9.0, the backup-end time was read from the backup
|
|
* history file at the beginning of archive recovery, but we now use the WAL
|
|
* record for that and the file is for informational and debug purposes only.
|
|
*
|
|
* Note: different from CancelBackup which just cancels online backup mode.
|
|
*/
|
|
Datum
|
|
pg_stop_backup(PG_FUNCTION_ARGS)
|
|
{
|
|
XLogRecPtr stoppoint;
|
|
char stopxlogstr[MAXFNAMELEN];
|
|
|
|
stoppoint = do_pg_stop_backup(NULL, true);
|
|
|
|
snprintf(stopxlogstr, sizeof(stopxlogstr), "%X/%X",
|
|
(uint32) (stoppoint >> 32), (uint32) stoppoint);
|
|
PG_RETURN_TEXT_P(cstring_to_text(stopxlogstr));
|
|
}
|
|
|
|
/*
|
|
* pg_switch_xlog: switch to next xlog file
|
|
*/
|
|
Datum
|
|
pg_switch_xlog(PG_FUNCTION_ARGS)
|
|
{
|
|
XLogRecPtr switchpoint;
|
|
char location[MAXFNAMELEN];
|
|
|
|
if (!superuser())
|
|
ereport(ERROR,
|
|
(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
|
|
(errmsg("must be superuser to switch transaction log files"))));
|
|
|
|
if (RecoveryInProgress())
|
|
ereport(ERROR,
|
|
(errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
|
|
errmsg("recovery is in progress"),
|
|
errhint("WAL control functions cannot be executed during recovery.")));
|
|
|
|
switchpoint = RequestXLogSwitch();
|
|
|
|
/*
|
|
* As a convenience, return the WAL location of the switch record
|
|
*/
|
|
snprintf(location, sizeof(location), "%X/%X",
|
|
(uint32) (switchpoint >> 32), (uint32) switchpoint);
|
|
PG_RETURN_TEXT_P(cstring_to_text(location));
|
|
}
|
|
|
|
/*
|
|
* pg_create_restore_point: a named point for restore
|
|
*/
|
|
Datum
|
|
pg_create_restore_point(PG_FUNCTION_ARGS)
|
|
{
|
|
text *restore_name = PG_GETARG_TEXT_P(0);
|
|
char *restore_name_str;
|
|
XLogRecPtr restorepoint;
|
|
char location[MAXFNAMELEN];
|
|
|
|
if (!superuser())
|
|
ereport(ERROR,
|
|
(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
|
|
(errmsg("must be superuser to create a restore point"))));
|
|
|
|
if (RecoveryInProgress())
|
|
ereport(ERROR,
|
|
(errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
|
|
(errmsg("recovery is in progress"),
|
|
errhint("WAL control functions cannot be executed during recovery."))));
|
|
|
|
if (!XLogIsNeeded())
|
|
ereport(ERROR,
|
|
(errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
|
|
errmsg("WAL level not sufficient for creating a restore point"),
|
|
errhint("wal_level must be set to \"archive\" or \"hot_standby\" at server start.")));
|
|
|
|
restore_name_str = text_to_cstring(restore_name);
|
|
|
|
if (strlen(restore_name_str) >= MAXFNAMELEN)
|
|
ereport(ERROR,
|
|
(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
|
|
errmsg("value too long for restore point (maximum %d characters)", MAXFNAMELEN - 1)));
|
|
|
|
restorepoint = XLogRestorePoint(restore_name_str);
|
|
|
|
/*
|
|
* As a convenience, return the WAL location of the restore point record
|
|
*/
|
|
snprintf(location, sizeof(location), "%X/%X",
|
|
(uint32) (restorepoint >> 32), (uint32) restorepoint);
|
|
PG_RETURN_TEXT_P(cstring_to_text(location));
|
|
}
|
|
|
|
/*
|
|
* Report the current WAL write location (same format as pg_start_backup etc)
|
|
*
|
|
* This is useful for determining how much of WAL is visible to an external
|
|
* archiving process. Note that the data before this point is written out
|
|
* to the kernel, but is not necessarily synced to disk.
|
|
*/
|
|
Datum
|
|
pg_current_xlog_location(PG_FUNCTION_ARGS)
|
|
{
|
|
XLogRecPtr current_recptr;
|
|
char location[MAXFNAMELEN];
|
|
|
|
if (RecoveryInProgress())
|
|
ereport(ERROR,
|
|
(errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
|
|
errmsg("recovery is in progress"),
|
|
errhint("WAL control functions cannot be executed during recovery.")));
|
|
|
|
current_recptr = GetXLogWriteRecPtr();
|
|
|
|
snprintf(location, sizeof(location), "%X/%X",
|
|
(uint32) (current_recptr >> 32), (uint32) current_recptr);
|
|
PG_RETURN_TEXT_P(cstring_to_text(location));
|
|
}
|
|
|
|
/*
|
|
* Report the current WAL insert location (same format as pg_start_backup etc)
|
|
*
|
|
* This function is mostly for debugging purposes.
|
|
*/
|
|
Datum
|
|
pg_current_xlog_insert_location(PG_FUNCTION_ARGS)
|
|
{
|
|
XLogRecPtr current_recptr;
|
|
char location[MAXFNAMELEN];
|
|
|
|
if (RecoveryInProgress())
|
|
ereport(ERROR,
|
|
(errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
|
|
errmsg("recovery is in progress"),
|
|
errhint("WAL control functions cannot be executed during recovery.")));
|
|
|
|
current_recptr = GetXLogInsertRecPtr();
|
|
|
|
snprintf(location, sizeof(location), "%X/%X",
|
|
(uint32) (current_recptr >> 32), (uint32) current_recptr);
|
|
PG_RETURN_TEXT_P(cstring_to_text(location));
|
|
}
|
|
|
|
/*
|
|
* Report the last WAL receive location (same format as pg_start_backup etc)
|
|
*
|
|
* This is useful for determining how much of WAL is guaranteed to be received
|
|
* and synced to disk by walreceiver.
|
|
*/
|
|
Datum
|
|
pg_last_xlog_receive_location(PG_FUNCTION_ARGS)
|
|
{
|
|
XLogRecPtr recptr;
|
|
char location[MAXFNAMELEN];
|
|
|
|
recptr = GetWalRcvWriteRecPtr(NULL);
|
|
|
|
if (recptr == 0)
|
|
PG_RETURN_NULL();
|
|
|
|
snprintf(location, sizeof(location), "%X/%X",
|
|
(uint32) (recptr >> 32), (uint32) recptr);
|
|
PG_RETURN_TEXT_P(cstring_to_text(location));
|
|
}
|
|
|
|
/*
|
|
* Report the last WAL replay location (same format as pg_start_backup etc)
|
|
*
|
|
* This is useful for determining how much of WAL is visible to read-only
|
|
* connections during recovery.
|
|
*/
|
|
Datum
|
|
pg_last_xlog_replay_location(PG_FUNCTION_ARGS)
|
|
{
|
|
XLogRecPtr recptr;
|
|
char location[MAXFNAMELEN];
|
|
|
|
recptr = GetXLogReplayRecPtr(NULL);
|
|
|
|
if (recptr == 0)
|
|
PG_RETURN_NULL();
|
|
|
|
snprintf(location, sizeof(location), "%X/%X",
|
|
(uint32) (recptr >> 32), (uint32) recptr);
|
|
PG_RETURN_TEXT_P(cstring_to_text(location));
|
|
}
|
|
|
|
/*
|
|
* Compute an xlog file name and decimal byte offset given a WAL location,
|
|
* such as is returned by pg_stop_backup() or pg_xlog_switch().
|
|
*
|
|
* Note that a location exactly at a segment boundary is taken to be in
|
|
* the previous segment. This is usually the right thing, since the
|
|
* expected usage is to determine which xlog file(s) are ready to archive.
|
|
*/
|
|
Datum
|
|
pg_xlogfile_name_offset(PG_FUNCTION_ARGS)
|
|
{
|
|
text *location = PG_GETARG_TEXT_P(0);
|
|
char *locationstr;
|
|
uint32 hi,
|
|
lo;
|
|
XLogSegNo xlogsegno;
|
|
uint32 xrecoff;
|
|
XLogRecPtr locationpoint;
|
|
char xlogfilename[MAXFNAMELEN];
|
|
Datum values[2];
|
|
bool isnull[2];
|
|
TupleDesc resultTupleDesc;
|
|
HeapTuple resultHeapTuple;
|
|
Datum result;
|
|
|
|
if (RecoveryInProgress())
|
|
ereport(ERROR,
|
|
(errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
|
|
errmsg("recovery is in progress"),
|
|
errhint("pg_xlogfile_name_offset() cannot be executed during recovery.")));
|
|
|
|
/*
|
|
* Read input and parse
|
|
*/
|
|
locationstr = text_to_cstring(location);
|
|
|
|
validate_xlog_location(locationstr);
|
|
|
|
if (sscanf(locationstr, "%X/%X", &hi, &lo) != 2)
|
|
ereport(ERROR,
|
|
(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
|
|
errmsg("could not parse transaction log location \"%s\"",
|
|
locationstr)));
|
|
locationpoint = ((uint64) hi) << 32 | lo;
|
|
|
|
/*
|
|
* Construct a tuple descriptor for the result row. This must match this
|
|
* function's pg_proc entry!
|
|
*/
|
|
resultTupleDesc = CreateTemplateTupleDesc(2, false);
|
|
TupleDescInitEntry(resultTupleDesc, (AttrNumber) 1, "file_name",
|
|
TEXTOID, -1, 0);
|
|
TupleDescInitEntry(resultTupleDesc, (AttrNumber) 2, "file_offset",
|
|
INT4OID, -1, 0);
|
|
|
|
resultTupleDesc = BlessTupleDesc(resultTupleDesc);
|
|
|
|
/*
|
|
* xlogfilename
|
|
*/
|
|
XLByteToPrevSeg(locationpoint, xlogsegno);
|
|
XLogFileName(xlogfilename, ThisTimeLineID, xlogsegno);
|
|
|
|
values[0] = CStringGetTextDatum(xlogfilename);
|
|
isnull[0] = false;
|
|
|
|
/*
|
|
* offset
|
|
*/
|
|
xrecoff = locationpoint % XLogSegSize;
|
|
|
|
values[1] = UInt32GetDatum(xrecoff);
|
|
isnull[1] = false;
|
|
|
|
/*
|
|
* Tuple jam: Having first prepared your Datums, then squash together
|
|
*/
|
|
resultHeapTuple = heap_form_tuple(resultTupleDesc, values, isnull);
|
|
|
|
result = HeapTupleGetDatum(resultHeapTuple);
|
|
|
|
PG_RETURN_DATUM(result);
|
|
}
|
|
|
|
/*
|
|
* Compute an xlog file name given a WAL location,
|
|
* such as is returned by pg_stop_backup() or pg_xlog_switch().
|
|
*/
|
|
Datum
|
|
pg_xlogfile_name(PG_FUNCTION_ARGS)
|
|
{
|
|
text *location = PG_GETARG_TEXT_P(0);
|
|
char *locationstr;
|
|
uint32 hi,
|
|
lo;
|
|
XLogSegNo xlogsegno;
|
|
XLogRecPtr locationpoint;
|
|
char xlogfilename[MAXFNAMELEN];
|
|
|
|
if (RecoveryInProgress())
|
|
ereport(ERROR,
|
|
(errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
|
|
errmsg("recovery is in progress"),
|
|
errhint("pg_xlogfile_name() cannot be executed during recovery.")));
|
|
|
|
locationstr = text_to_cstring(location);
|
|
|
|
validate_xlog_location(locationstr);
|
|
|
|
if (sscanf(locationstr, "%X/%X", &hi, &lo) != 2)
|
|
ereport(ERROR,
|
|
(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
|
|
errmsg("could not parse transaction log location \"%s\"",
|
|
locationstr)));
|
|
locationpoint = ((uint64) hi) << 32 | lo;
|
|
|
|
XLByteToPrevSeg(locationpoint, xlogsegno);
|
|
XLogFileName(xlogfilename, ThisTimeLineID, xlogsegno);
|
|
|
|
PG_RETURN_TEXT_P(cstring_to_text(xlogfilename));
|
|
}
|
|
|
|
/*
|
|
* pg_xlog_replay_pause - pause recovery now
|
|
*/
|
|
Datum
|
|
pg_xlog_replay_pause(PG_FUNCTION_ARGS)
|
|
{
|
|
if (!superuser())
|
|
ereport(ERROR,
|
|
(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
|
|
(errmsg("must be superuser to control recovery"))));
|
|
|
|
if (!RecoveryInProgress())
|
|
ereport(ERROR,
|
|
(errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
|
|
errmsg("recovery is not in progress"),
|
|
errhint("Recovery control functions can only be executed during recovery.")));
|
|
|
|
SetRecoveryPause(true);
|
|
|
|
PG_RETURN_VOID();
|
|
}
|
|
|
|
/*
|
|
* pg_xlog_replay_resume - resume recovery now
|
|
*/
|
|
Datum
|
|
pg_xlog_replay_resume(PG_FUNCTION_ARGS)
|
|
{
|
|
if (!superuser())
|
|
ereport(ERROR,
|
|
(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
|
|
(errmsg("must be superuser to control recovery"))));
|
|
|
|
if (!RecoveryInProgress())
|
|
ereport(ERROR,
|
|
(errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
|
|
errmsg("recovery is not in progress"),
|
|
errhint("Recovery control functions can only be executed during recovery.")));
|
|
|
|
SetRecoveryPause(false);
|
|
|
|
PG_RETURN_VOID();
|
|
}
|
|
|
|
/*
|
|
* pg_is_xlog_replay_paused
|
|
*/
|
|
Datum
|
|
pg_is_xlog_replay_paused(PG_FUNCTION_ARGS)
|
|
{
|
|
if (!superuser())
|
|
ereport(ERROR,
|
|
(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
|
|
(errmsg("must be superuser to control recovery"))));
|
|
|
|
if (!RecoveryInProgress())
|
|
ereport(ERROR,
|
|
(errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
|
|
errmsg("recovery is not in progress"),
|
|
errhint("Recovery control functions can only be executed during recovery.")));
|
|
|
|
PG_RETURN_BOOL(RecoveryIsPaused());
|
|
}
|
|
|
|
/*
|
|
* Returns timestamp of latest processed commit/abort record.
|
|
*
|
|
* When the server has been started normally without recovery the function
|
|
* returns NULL.
|
|
*/
|
|
Datum
|
|
pg_last_xact_replay_timestamp(PG_FUNCTION_ARGS)
|
|
{
|
|
TimestampTz xtime;
|
|
|
|
xtime = GetLatestXTime();
|
|
if (xtime == 0)
|
|
PG_RETURN_NULL();
|
|
|
|
PG_RETURN_TIMESTAMPTZ(xtime);
|
|
}
|
|
|
|
/*
|
|
* Returns bool with current recovery mode, a global state.
|
|
*/
|
|
Datum
|
|
pg_is_in_recovery(PG_FUNCTION_ARGS)
|
|
{
|
|
PG_RETURN_BOOL(RecoveryInProgress());
|
|
}
|
|
|
|
/*
|
|
* Validate the text form of a transaction log location.
|
|
* (Just using sscanf() input allows incorrect values such as
|
|
* negatives, so we have to be a bit more careful about that).
|
|
*/
|
|
static void
|
|
validate_xlog_location(char *str)
|
|
{
|
|
#define MAXLSNCOMPONENT 8
|
|
|
|
int len1,
|
|
len2;
|
|
|
|
len1 = strspn(str, "0123456789abcdefABCDEF");
|
|
if (len1 < 1 || len1 > MAXLSNCOMPONENT || str[len1] != '/')
|
|
ereport(ERROR,
|
|
(errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
|
|
errmsg("invalid input syntax for transaction log location: \"%s\"", str)));
|
|
|
|
len2 = strspn(str + len1 + 1, "0123456789abcdefABCDEF");
|
|
if (len2 < 1 || len2 > MAXLSNCOMPONENT || str[len1 + 1 + len2] != '\0')
|
|
ereport(ERROR,
|
|
(errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
|
|
errmsg("invalid input syntax for transaction log location: \"%s\"", str)));
|
|
}
|
|
|
|
/*
|
|
* Compute the difference in bytes between two WAL locations.
|
|
*/
|
|
Datum
|
|
pg_xlog_location_diff(PG_FUNCTION_ARGS)
|
|
{
|
|
text *location1 = PG_GETARG_TEXT_P(0);
|
|
text *location2 = PG_GETARG_TEXT_P(1);
|
|
char *str1,
|
|
*str2;
|
|
XLogRecPtr loc1,
|
|
loc2;
|
|
Numeric result;
|
|
uint64 bytes1,
|
|
bytes2;
|
|
uint32 hi,
|
|
lo;
|
|
|
|
/*
|
|
* Read and parse input
|
|
*/
|
|
str1 = text_to_cstring(location1);
|
|
str2 = text_to_cstring(location2);
|
|
|
|
validate_xlog_location(str1);
|
|
validate_xlog_location(str2);
|
|
|
|
if (sscanf(str1, "%X/%X", &hi, &lo) != 2)
|
|
ereport(ERROR,
|
|
(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
|
|
errmsg("could not parse transaction log location \"%s\"", str1)));
|
|
loc1 = ((uint64) hi) << 32 | lo;
|
|
|
|
if (sscanf(str2, "%X/%X", &hi, &lo) != 2)
|
|
ereport(ERROR,
|
|
(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
|
|
errmsg("could not parse transaction log location \"%s\"", str2)));
|
|
loc2 = ((uint64) hi) << 32 | lo;
|
|
|
|
bytes1 = (uint64) loc1;
|
|
bytes2 = (uint64) loc2;
|
|
|
|
/*
|
|
* result = bytes1 - bytes2.
|
|
*
|
|
* XXX: this won't handle values higher than 2^63 correctly.
|
|
*/
|
|
result = DatumGetNumeric(DirectFunctionCall2(numeric_sub,
|
|
DirectFunctionCall1(int8_numeric, Int64GetDatum((int64) bytes1)),
|
|
DirectFunctionCall1(int8_numeric, Int64GetDatum((int64) bytes2))));
|
|
|
|
PG_RETURN_NUMERIC(result);
|
|
}
|
|
|
|
/*
|
|
* Returns bool with current on-line backup mode, a global state.
|
|
*/
|
|
Datum
|
|
pg_is_in_backup(PG_FUNCTION_ARGS)
|
|
{
|
|
PG_RETURN_BOOL(BackupInProgress());
|
|
}
|
|
|
|
/*
|
|
* Returns start time of an online exclusive backup.
|
|
*
|
|
* When there's no exclusive backup in progress, the function
|
|
* returns NULL.
|
|
*/
|
|
Datum
|
|
pg_backup_start_time(PG_FUNCTION_ARGS)
|
|
{
|
|
Datum xtime;
|
|
FILE *lfp;
|
|
char fline[MAXPGPATH];
|
|
char backup_start_time[30];
|
|
|
|
/*
|
|
* See if label file is present
|
|
*/
|
|
lfp = AllocateFile(BACKUP_LABEL_FILE, "r");
|
|
if (lfp == NULL)
|
|
{
|
|
if (errno != ENOENT)
|
|
ereport(ERROR,
|
|
(errcode_for_file_access(),
|
|
errmsg("could not read file \"%s\": %m",
|
|
BACKUP_LABEL_FILE)));
|
|
PG_RETURN_NULL();
|
|
}
|
|
|
|
/*
|
|
* Parse the file to find the the START TIME line.
|
|
*/
|
|
backup_start_time[0] = '\0';
|
|
while (fgets(fline, sizeof(fline), lfp) != NULL)
|
|
{
|
|
if (sscanf(fline, "START TIME: %25[^\n]\n", backup_start_time) == 1)
|
|
break;
|
|
}
|
|
|
|
/* Check for a read error. */
|
|
if (ferror(lfp))
|
|
ereport(ERROR,
|
|
(errcode_for_file_access(),
|
|
errmsg("could not read file \"%s\": %m", BACKUP_LABEL_FILE)));
|
|
|
|
/* Close the backup label file. */
|
|
if (FreeFile(lfp))
|
|
ereport(ERROR,
|
|
(errcode_for_file_access(),
|
|
errmsg("could not close file \"%s\": %m", BACKUP_LABEL_FILE)));
|
|
|
|
if (strlen(backup_start_time) == 0)
|
|
ereport(ERROR,
|
|
(errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
|
|
errmsg("invalid data in file \"%s\"", BACKUP_LABEL_FILE)));
|
|
|
|
/*
|
|
* Convert the time string read from file to TimestampTz form.
|
|
*/
|
|
xtime = DirectFunctionCall3(timestamptz_in,
|
|
CStringGetDatum(backup_start_time),
|
|
ObjectIdGetDatum(InvalidOid),
|
|
Int32GetDatum(-1));
|
|
|
|
PG_RETURN_DATUM(xtime);
|
|
}
|