Quelle  pg_lsn.c

/*-------------------------------------------------------------------------
 *
 * pg_lsn.c
 *   Operations for the pg_lsn datatype.
 *
 * Portions Copyright (c) 1996-2025, PostgreSQL Global Development Group
 * Portions Copyright (c) 1994, Regents of the University of California
 *
 * IDENTIFICATION
 *   src/backend/utils/adt/pg_lsn.c
 *
 *-------------------------------------------------------------------------
 */
#include "postgres.h"

#include "libpq/pqformat.h"
#include "utils/fmgrprotos.h"
#include "utils/numeric.h"
#include "utils/pg_lsn.h"

#define MAXPG_LSNLEN   17
#define MAXPG_LSNCOMPONENT 8

/*----------------------------------------------------------
 * Formatting and conversion routines.
 *---------------------------------------------------------*/

XLogRecPtr
pg_lsn_in_internal(const char *str, bool *have_error)
{
 int   len1,
    len2;
 uint32  id,
    off;
 XLogRecPtr result;

 Assert(have_error != NULL);
 *have_error = false;

 /* Sanity check input format. */
 len1 = strspn(str, "0123456789abcdefABCDEF");
 if (len1 < 1 || len1 > MAXPG_LSNCOMPONENT || str[len1] != '/')
 {
  *have_error = true;
  return InvalidXLogRecPtr;
 }
 len2 = strspn(str + len1 + 1, "0123456789abcdefABCDEF");
 if (len2 < 1 || len2 > MAXPG_LSNCOMPONENT || str[len1 + 1 + len2] != '\0')
 {
  *have_error = true;
  return InvalidXLogRecPtr;
 }

 /* Decode result. */
 id = (uint32) strtoul(str, NULL, 16);
 off = (uint32) strtoul(str + len1 + 1, NULL, 16);
 result = ((uint64) id << 32) | off;

 return result;
}

Datum
pg_lsn_in(PG_FUNCTION_ARGS)
{
 char    *str = PG_GETARG_CSTRING(0);
 XLogRecPtr result;
 bool  have_error = false;

 result = pg_lsn_in_internal(str, &have_error);
 if (have_error)
  ereturn(fcinfo->context, (Datum) 0,
    (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
     errmsg("invalid input syntax for type %s: \"%s\"",
      "pg_lsn", str)));

 PG_RETURN_LSN(result);
}

Datum
pg_lsn_out(PG_FUNCTION_ARGS)
{
 XLogRecPtr lsn = PG_GETARG_LSN(0);
 char  buf[MAXPG_LSNLEN + 1];
 char    *result;

 snprintf(buf, sizeof buf, "%X/%X", LSN_FORMAT_ARGS(lsn));
 result = pstrdup(buf);
 PG_RETURN_CSTRING(result);
}

Datum
pg_lsn_recv(PG_FUNCTION_ARGS)
{
 StringInfo buf = (StringInfo) PG_GETARG_POINTER(0);
 XLogRecPtr result;

 result = pq_getmsgint64(buf);
 PG_RETURN_LSN(result);
}

Datum
pg_lsn_send(PG_FUNCTION_ARGS)
{
 XLogRecPtr lsn = PG_GETARG_LSN(0);
 StringInfoData buf;

 pq_begintypsend(&buf);
 pq_sendint64(&buf, lsn);
 PG_RETURN_BYTEA_P(pq_endtypsend(&buf));
}


/*----------------------------------------------------------
 * Operators for PostgreSQL LSNs
 *---------------------------------------------------------*/

Datum
pg_lsn_eq(PG_FUNCTION_ARGS)
{
 XLogRecPtr lsn1 = PG_GETARG_LSN(0);
 XLogRecPtr lsn2 = PG_GETARG_LSN(1);

 PG_RETURN_BOOL(lsn1 == lsn2);
}

Datum
pg_lsn_ne(PG_FUNCTION_ARGS)
{
 XLogRecPtr lsn1 = PG_GETARG_LSN(0);
 XLogRecPtr lsn2 = PG_GETARG_LSN(1);

 PG_RETURN_BOOL(lsn1 != lsn2);
}

Datum
pg_lsn_lt(PG_FUNCTION_ARGS)
{
 XLogRecPtr lsn1 = PG_GETARG_LSN(0);
 XLogRecPtr lsn2 = PG_GETARG_LSN(1);

 PG_RETURN_BOOL(lsn1 < lsn2);
}

Datum
pg_lsn_gt(PG_FUNCTION_ARGS)
{
 XLogRecPtr lsn1 = PG_GETARG_LSN(0);
 XLogRecPtr lsn2 = PG_GETARG_LSN(1);

 PG_RETURN_BOOL(lsn1 > lsn2);
}

Datum
pg_lsn_le(PG_FUNCTION_ARGS)
{
 XLogRecPtr lsn1 = PG_GETARG_LSN(0);
 XLogRecPtr lsn2 = PG_GETARG_LSN(1);

 PG_RETURN_BOOL(lsn1 <= lsn2);
}

Datum
pg_lsn_ge(PG_FUNCTION_ARGS)
{
 XLogRecPtr lsn1 = PG_GETARG_LSN(0);
 XLogRecPtr lsn2 = PG_GETARG_LSN(1);

 PG_RETURN_BOOL(lsn1 >= lsn2);
}

Datum
pg_lsn_larger(PG_FUNCTION_ARGS)
{
 XLogRecPtr lsn1 = PG_GETARG_LSN(0);
 XLogRecPtr lsn2 = PG_GETARG_LSN(1);

 PG_RETURN_LSN((lsn1 > lsn2) ? lsn1 : lsn2);
}

Datum
pg_lsn_smaller(PG_FUNCTION_ARGS)
{
 XLogRecPtr lsn1 = PG_GETARG_LSN(0);
 XLogRecPtr lsn2 = PG_GETARG_LSN(1);

 PG_RETURN_LSN((lsn1 < lsn2) ? lsn1 : lsn2);
}

/* btree index opclass support */
Datum
pg_lsn_cmp(PG_FUNCTION_ARGS)
{
 XLogRecPtr a = PG_GETARG_LSN(0);
 XLogRecPtr b = PG_GETARG_LSN(1);

 if (a > b)
  PG_RETURN_INT32(1);
 else if (a == b)
  PG_RETURN_INT32(0);
 else
  PG_RETURN_INT32(-1);
}

/* hash index opclass support */
Datum
pg_lsn_hash(PG_FUNCTION_ARGS)
{
 /* We can use hashint8 directly */
 return hashint8(fcinfo);
}

Datum
pg_lsn_hash_extended(PG_FUNCTION_ARGS)
{
 return hashint8extended(fcinfo);
}


/*----------------------------------------------------------
 * Arithmetic operators on PostgreSQL LSNs.
 *---------------------------------------------------------*/

Datum
pg_lsn_mi(PG_FUNCTION_ARGS)
{
 XLogRecPtr lsn1 = PG_GETARG_LSN(0);
 XLogRecPtr lsn2 = PG_GETARG_LSN(1);
 char  buf[256];
 Datum  result;

 /* Output could be as large as plus or minus 2^63 - 1. */
 if (lsn1 < lsn2)
  snprintf(buf, sizeof buf, "-" UINT64_FORMAT, lsn2 - lsn1);
 else
  snprintf(buf, sizeof buf, UINT64_FORMAT, lsn1 - lsn2);

 /* Convert to numeric. */
 result = DirectFunctionCall3(numeric_in,
         CStringGetDatum(buf),
         ObjectIdGetDatum(0),
         Int32GetDatum(-1));

 return result;
}

/*
 * Add the number of bytes to pg_lsn, giving a new pg_lsn.
 * Must handle both positive and negative numbers of bytes.
 */
Datum
pg_lsn_pli(PG_FUNCTION_ARGS)
{
 XLogRecPtr lsn = PG_GETARG_LSN(0);
 Numeric  nbytes = PG_GETARG_NUMERIC(1);
 Datum  num;
 Datum  res;
 char  buf[32];

 if (numeric_is_nan(nbytes))
  ereport(ERROR,
    (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
     errmsg("cannot add NaN to pg_lsn")));

 /* Convert to numeric */
 snprintf(buf, sizeof(buf), UINT64_FORMAT, lsn);
 num = DirectFunctionCall3(numeric_in,
         CStringGetDatum(buf),
         ObjectIdGetDatum(0),
         Int32GetDatum(-1));

 /* Add two numerics */
 res = DirectFunctionCall2(numeric_add,
         num,
         NumericGetDatum(nbytes));

 /* Convert to pg_lsn */
 return DirectFunctionCall1(numeric_pg_lsn, res);
}

/*
 * Subtract the number of bytes from pg_lsn, giving a new pg_lsn.
 * Must handle both positive and negative numbers of bytes.
 */
Datum
pg_lsn_mii(PG_FUNCTION_ARGS)
{
 XLogRecPtr lsn = PG_GETARG_LSN(0);
 Numeric  nbytes = PG_GETARG_NUMERIC(1);
 Datum  num;
 Datum  res;
 char  buf[32];

 if (numeric_is_nan(nbytes))
  ereport(ERROR,
    (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
     errmsg("cannot subtract NaN from pg_lsn")));

 /* Convert to numeric */
 snprintf(buf, sizeof(buf), UINT64_FORMAT, lsn);
 num = DirectFunctionCall3(numeric_in,
         CStringGetDatum(buf),
         ObjectIdGetDatum(0),
         Int32GetDatum(-1));

 /* Subtract two numerics */
 res = DirectFunctionCall2(numeric_sub,
         num,
         NumericGetDatum(nbytes));

 /* Convert to pg_lsn */
 return DirectFunctionCall1(numeric_pg_lsn, res);
}