src/backend/utils/adt/xid.c

   1 /*-------------------------------------------------------------------------
   2  *
   3  * xid.c
   4  *        POSTGRES transaction identifier and command identifier datatypes.
   5  *
   6  * Portions Copyright (c) 1996-2025, PostgreSQL Global Development Group
   7  * Portions Copyright (c) 1994, Regents of the University of California
   8  *
   9  *
  10  * IDENTIFICATION
  11  *        src/backend/utils/adt/xid.c
  12  *
  13  *-------------------------------------------------------------------------
  14  */
  15 #include "postgres.h"
  16
  17 #include <limits.h>
  18
  19 #include "access/multixact.h"
  20 #include "access/transam.h"
  21 #include "access/xact.h"
  22 #include "common/hashfn.h"
  23 #include "common/int.h"
  24 #include "libpq/pqformat.h"
  25 #include "utils/builtins.h"
  26 #include "utils/xid8.h"
  27
  28 #define PG_GETARG_COMMANDID(n)          DatumGetCommandId(PG_GETARG_DATUM(n))
  29 #define PG_RETURN_COMMANDID(x)          return CommandIdGetDatum(x)
  30
  31
  32 Datum
  33 xidin(PG_FUNCTION_ARGS)
  34 {
  35         char       *str = PG_GETARG_CSTRING(0);
  36         TransactionId result;
  37
  38         result = uint32in_subr(str, NULL, "xid", fcinfo->context);
  39         PG_RETURN_TRANSACTIONID(result);
  40 }
  41
  42 Datum
  43 xidout(PG_FUNCTION_ARGS)
  44 {
  45         TransactionId transactionId = PG_GETARG_TRANSACTIONID(0);
  46         char       *result = (char *) palloc(16);
  47
  48         snprintf(result, 16, "%lu", (unsigned long) transactionId);
  49         PG_RETURN_CSTRING(result);
  50 }
  51
  52 /*
  53  *              xidrecv                 - converts external binary format to xid
  54  */
  55 Datum
  56 xidrecv(PG_FUNCTION_ARGS)
  57 {
  58         StringInfo      buf = (StringInfo) PG_GETARG_POINTER(0);
  59
  60         PG_RETURN_TRANSACTIONID((TransactionId) pq_getmsgint(buf, sizeof(TransactionId)));
  61 }
  62
  63 /*
  64  *              xidsend                 - converts xid to binary format
  65  */
  66 Datum
  67 xidsend(PG_FUNCTION_ARGS)
  68 {
  69         TransactionId arg1 = PG_GETARG_TRANSACTIONID(0);
  70         StringInfoData buf;
  71
  72         pq_begintypsend(&buf);
  73         pq_sendint32(&buf, arg1);
  74         PG_RETURN_BYTEA_P(pq_endtypsend(&buf));
  75 }
  76
  77 /*
  78  *              xideq                   - are two xids equal?
  79  */
  80 Datum
  81 xideq(PG_FUNCTION_ARGS)
  82 {
  83         TransactionId xid1 = PG_GETARG_TRANSACTIONID(0);
  84         TransactionId xid2 = PG_GETARG_TRANSACTIONID(1);
  85
  86         PG_RETURN_BOOL(TransactionIdEquals(xid1, xid2));
  87 }
  88
  89 /*
  90  *              xidneq                  - are two xids different?
  91  */
  92 Datum
  93 xidneq(PG_FUNCTION_ARGS)
  94 {
  95         TransactionId xid1 = PG_GETARG_TRANSACTIONID(0);
  96         TransactionId xid2 = PG_GETARG_TRANSACTIONID(1);
  97
  98         PG_RETURN_BOOL(!TransactionIdEquals(xid1, xid2));
  99 }
 100
 101 Datum
 102 hashxid(PG_FUNCTION_ARGS)
 103 {
 104         return hash_uint32(PG_GETARG_TRANSACTIONID(0));
 105 }
 106
 107 Datum
 108 hashxidextended(PG_FUNCTION_ARGS)
 109 {
 110         return hash_uint32_extended(PG_GETARG_TRANSACTIONID(0), PG_GETARG_INT64(1));
 111 }
 112
 113 /*
 114  *              xid_age                 - compute age of an XID (relative to latest stable xid)
 115  */
 116 Datum
 117 xid_age(PG_FUNCTION_ARGS)
 118 {
 119         TransactionId xid = PG_GETARG_TRANSACTIONID(0);
 120         TransactionId now = GetStableLatestTransactionId();
 121
 122         /* Permanent XIDs are always infinitely old */
 123         if (!TransactionIdIsNormal(xid))
 124                 PG_RETURN_INT32(INT_MAX);
 125
 126         PG_RETURN_INT32((int32) (now - xid));
 127 }
 128
 129 /*
 130  *              mxid_age                        - compute age of a multi XID (relative to latest stable mxid)
 131  */
 132 Datum
 133 mxid_age(PG_FUNCTION_ARGS)
 134 {
 135         TransactionId xid = PG_GETARG_TRANSACTIONID(0);
 136         MultiXactId now = ReadNextMultiXactId();
 137
 138         if (!MultiXactIdIsValid(xid))
 139                 PG_RETURN_INT32(INT_MAX);
 140
 141         PG_RETURN_INT32((int32) (now - xid));
 142 }
 143
 144 /*
 145  * xidComparator
 146  *              qsort comparison function for XIDs
 147  *
 148  * We can't use wraparound comparison for XIDs because that does not respect
 149  * the triangle inequality!  Any old sort order will do.
 150  */
 151 int
 152 xidComparator(const void *arg1, const void *arg2)
 153 {
 154         TransactionId xid1 = *(const TransactionId *) arg1;
 155         TransactionId xid2 = *(const TransactionId *) arg2;
 156
 157         return pg_cmp_u32(xid1, xid2);
 158 }
 159
 160 /*
 161  * xidLogicalComparator
 162  *              qsort comparison function for XIDs
 163  *
 164  * This is used to compare only XIDs from the same epoch (e.g. for backends
 165  * running at the same time). So there must be only normal XIDs, so there's
 166  * no issue with triangle inequality.
 167  */
 168 int
 169 xidLogicalComparator(const void *arg1, const void *arg2)
 170 {
 171         TransactionId xid1 = *(const TransactionId *) arg1;
 172         TransactionId xid2 = *(const TransactionId *) arg2;
 173
 174         Assert(TransactionIdIsNormal(xid1));
 175         Assert(TransactionIdIsNormal(xid2));
 176
 177         if (TransactionIdPrecedes(xid1, xid2))
 178                 return -1;
 179
 180         if (TransactionIdPrecedes(xid2, xid1))
 181                 return 1;
 182
 183         return 0;
 184 }
 185
 186 Datum
 187 xid8toxid(PG_FUNCTION_ARGS)
 188 {
 189         FullTransactionId fxid = PG_GETARG_FULLTRANSACTIONID(0);
 190
 191         PG_RETURN_TRANSACTIONID(XidFromFullTransactionId(fxid));
 192 }
 193
 194 Datum
 195 xid8in(PG_FUNCTION_ARGS)
 196 {
 197         char       *str = PG_GETARG_CSTRING(0);
 198         uint64          result;
 199
 200         result = uint64in_subr(str, NULL, "xid8", fcinfo->context);
 201         PG_RETURN_FULLTRANSACTIONID(FullTransactionIdFromU64(result));
 202 }
 203
 204 Datum
 205 xid8out(PG_FUNCTION_ARGS)
 206 {
 207         FullTransactionId fxid = PG_GETARG_FULLTRANSACTIONID(0);
 208         char       *result = (char *) palloc(21);
 209
 210         snprintf(result, 21, UINT64_FORMAT, U64FromFullTransactionId(fxid));
 211         PG_RETURN_CSTRING(result);
 212 }
 213
 214 Datum
 215 xid8recv(PG_FUNCTION_ARGS)
 216 {
 217         StringInfo      buf = (StringInfo) PG_GETARG_POINTER(0);
 218         uint64          value;
 219
 220         value = (uint64) pq_getmsgint64(buf);
 221         PG_RETURN_FULLTRANSACTIONID(FullTransactionIdFromU64(value));
 222 }
 223
 224 Datum
 225 xid8send(PG_FUNCTION_ARGS)
 226 {
 227         FullTransactionId arg1 = PG_GETARG_FULLTRANSACTIONID(0);
 228         StringInfoData buf;
 229
 230         pq_begintypsend(&buf);
 231         pq_sendint64(&buf, (uint64) U64FromFullTransactionId(arg1));
 232         PG_RETURN_BYTEA_P(pq_endtypsend(&buf));
 233 }
 234
 235 Datum
 236 xid8eq(PG_FUNCTION_ARGS)
 237 {
 238         FullTransactionId fxid1 = PG_GETARG_FULLTRANSACTIONID(0);
 239         FullTransactionId fxid2 = PG_GETARG_FULLTRANSACTIONID(1);
 240
 241         PG_RETURN_BOOL(FullTransactionIdEquals(fxid1, fxid2));
 242 }
 243
 244 Datum
 245 xid8ne(PG_FUNCTION_ARGS)
 246 {
 247         FullTransactionId fxid1 = PG_GETARG_FULLTRANSACTIONID(0);
 248         FullTransactionId fxid2 = PG_GETARG_FULLTRANSACTIONID(1);
 249
 250         PG_RETURN_BOOL(!FullTransactionIdEquals(fxid1, fxid2));
 251 }
 252
 253 Datum
 254 xid8lt(PG_FUNCTION_ARGS)
 255 {
 256         FullTransactionId fxid1 = PG_GETARG_FULLTRANSACTIONID(0);
 257         FullTransactionId fxid2 = PG_GETARG_FULLTRANSACTIONID(1);
 258
 259         PG_RETURN_BOOL(FullTransactionIdPrecedes(fxid1, fxid2));
 260 }
 261
 262 Datum
 263 xid8gt(PG_FUNCTION_ARGS)
 264 {
 265         FullTransactionId fxid1 = PG_GETARG_FULLTRANSACTIONID(0);
 266         FullTransactionId fxid2 = PG_GETARG_FULLTRANSACTIONID(1);
 267
 268         PG_RETURN_BOOL(FullTransactionIdFollows(fxid1, fxid2));
 269 }
 270
 271 Datum
 272 xid8le(PG_FUNCTION_ARGS)
 273 {
 274         FullTransactionId fxid1 = PG_GETARG_FULLTRANSACTIONID(0);
 275         FullTransactionId fxid2 = PG_GETARG_FULLTRANSACTIONID(1);
 276
 277         PG_RETURN_BOOL(FullTransactionIdPrecedesOrEquals(fxid1, fxid2));
 278 }
 279
 280 Datum
 281 xid8ge(PG_FUNCTION_ARGS)
 282 {
 283         FullTransactionId fxid1 = PG_GETARG_FULLTRANSACTIONID(0);
 284         FullTransactionId fxid2 = PG_GETARG_FULLTRANSACTIONID(1);
 285
 286         PG_RETURN_BOOL(FullTransactionIdFollowsOrEquals(fxid1, fxid2));
 287 }
 288
 289 Datum
 290 xid8cmp(PG_FUNCTION_ARGS)
 291 {
 292         FullTransactionId fxid1 = PG_GETARG_FULLTRANSACTIONID(0);
 293         FullTransactionId fxid2 = PG_GETARG_FULLTRANSACTIONID(1);
 294
 295         if (FullTransactionIdFollows(fxid1, fxid2))
 296                 PG_RETURN_INT32(1);
 297         else if (FullTransactionIdEquals(fxid1, fxid2))
 298                 PG_RETURN_INT32(0);
 299         else
 300                 PG_RETURN_INT32(-1);
 301 }
 302
 303 Datum
 304 hashxid8(PG_FUNCTION_ARGS)
 305 {
 306         return hashint8(fcinfo);
 307 }
 308
 309 Datum
 310 hashxid8extended(PG_FUNCTION_ARGS)
 311 {
 312         return hashint8extended(fcinfo);
 313 }
 314
 315 Datum
 316 xid8_larger(PG_FUNCTION_ARGS)
 317 {
 318         FullTransactionId fxid1 = PG_GETARG_FULLTRANSACTIONID(0);
 319         FullTransactionId fxid2 = PG_GETARG_FULLTRANSACTIONID(1);
 320
 321         if (FullTransactionIdFollows(fxid1, fxid2))
 322                 PG_RETURN_FULLTRANSACTIONID(fxid1);
 323         else
 324                 PG_RETURN_FULLTRANSACTIONID(fxid2);
 325 }
 326
 327 Datum
 328 xid8_smaller(PG_FUNCTION_ARGS)
 329 {
 330         FullTransactionId fxid1 = PG_GETARG_FULLTRANSACTIONID(0);
 331         FullTransactionId fxid2 = PG_GETARG_FULLTRANSACTIONID(1);
 332
 333         if (FullTransactionIdPrecedes(fxid1, fxid2))
 334                 PG_RETURN_FULLTRANSACTIONID(fxid1);
 335         else
 336                 PG_RETURN_FULLTRANSACTIONID(fxid2);
 337 }
 338
 339 /*****************************************************************************
 340  *       COMMAND IDENTIFIER ROUTINES                                                                                     *
 341  *****************************************************************************/
 342
 343 /*
 344  *              cidin   - converts CommandId to internal representation.
 345  */
 346 Datum
 347 cidin(PG_FUNCTION_ARGS)
 348 {
 349         char       *str = PG_GETARG_CSTRING(0);
 350         CommandId       result;
 351
 352         result = uint32in_subr(str, NULL, "cid", fcinfo->context);
 353         PG_RETURN_COMMANDID(result);
 354 }
 355
 356 /*
 357  *              cidout  - converts a cid to external representation.
 358  */
 359 Datum
 360 cidout(PG_FUNCTION_ARGS)
 361 {
 362         CommandId       c = PG_GETARG_COMMANDID(0);
 363         char       *result = (char *) palloc(16);
 364
 365         snprintf(result, 16, "%lu", (unsigned long) c);
 366         PG_RETURN_CSTRING(result);
 367 }
 368
 369 /*
 370  *              cidrecv                 - converts external binary format to cid
 371  */
 372 Datum
 373 cidrecv(PG_FUNCTION_ARGS)
 374 {
 375         StringInfo      buf = (StringInfo) PG_GETARG_POINTER(0);
 376
 377         PG_RETURN_COMMANDID((CommandId) pq_getmsgint(buf, sizeof(CommandId)));
 378 }
 379
 380 /*
 381  *              cidsend                 - converts cid to binary format
 382  */
 383 Datum
 384 cidsend(PG_FUNCTION_ARGS)
 385 {
 386         CommandId       arg1 = PG_GETARG_COMMANDID(0);
 387         StringInfoData buf;
 388
 389         pq_begintypsend(&buf);
 390         pq_sendint32(&buf, arg1);
 391         PG_RETURN_BYTEA_P(pq_endtypsend(&buf));
 392 }
 393
 394 Datum
 395 cideq(PG_FUNCTION_ARGS)
 396 {
 397         CommandId       arg1 = PG_GETARG_COMMANDID(0);
 398         CommandId       arg2 = PG_GETARG_COMMANDID(1);
 399
 400         PG_RETURN_BOOL(arg1 == arg2);
 401 }
 402
 403 Datum
 404 hashcid(PG_FUNCTION_ARGS)
 405 {
 406         return hash_uint32(PG_GETARG_COMMANDID(0));
 407 }
 408
 409 Datum
 410 hashcidextended(PG_FUNCTION_ARGS)
 411 {
 412         return hash_uint32_extended(PG_GETARG_COMMANDID(0), PG_GETARG_INT64(1));
 413 }