LCOV - code coverage report
Current view: top level - src/backend/utils/adt - pg_lsn.c (source / functions) Hit Total Coverage
Test: PostgreSQL 12beta2 Lines: 63 72 87.5 %
Date: 2019-06-18 07:06:57 Functions: 12 14 85.7 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /*-------------------------------------------------------------------------
       2             :  *
       3             :  * pg_lsn.c
       4             :  *    Operations for the pg_lsn datatype.
       5             :  *
       6             :  * Portions Copyright (c) 1996-2019, PostgreSQL Global Development Group
       7             :  * Portions Copyright (c) 1994, Regents of the University of California
       8             :  *
       9             :  * IDENTIFICATION
      10             :  *    src/backend/utils/adt/pg_lsn.c
      11             :  *
      12             :  *-------------------------------------------------------------------------
      13             :  */
      14             : #include "postgres.h"
      15             : 
      16             : #include "funcapi.h"
      17             : #include "libpq/pqformat.h"
      18             : #include "utils/builtins.h"
      19             : #include "utils/pg_lsn.h"
      20             : 
      21             : #define MAXPG_LSNLEN            17
      22             : #define MAXPG_LSNCOMPONENT  8
      23             : 
      24             : /*----------------------------------------------------------
      25             :  * Formatting and conversion routines.
      26             :  *---------------------------------------------------------*/
      27             : 
      28             : Datum
      29        2832 : pg_lsn_in(PG_FUNCTION_ARGS)
      30             : {
      31        2832 :     char       *str = PG_GETARG_CSTRING(0);
      32             :     int         len1,
      33             :                 len2;
      34             :     uint32      id,
      35             :                 off;
      36             :     XLogRecPtr  result;
      37             : 
      38             :     /* Sanity check input format. */
      39        2832 :     len1 = strspn(str, "0123456789abcdefABCDEF");
      40        2832 :     if (len1 < 1 || len1 > MAXPG_LSNCOMPONENT || str[len1] != '/')
      41          16 :         ereport(ERROR,
      42             :                 (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
      43             :                  errmsg("invalid input syntax for type %s: \"%s\"",
      44             :                         "pg_lsn", str)));
      45        2816 :     len2 = strspn(str + len1 + 1, "0123456789abcdefABCDEF");
      46        2816 :     if (len2 < 1 || len2 > MAXPG_LSNCOMPONENT || str[len1 + 1 + len2] != '\0')
      47           4 :         ereport(ERROR,
      48             :                 (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
      49             :                  errmsg("invalid input syntax for type %s: \"%s\"",
      50             :                         "pg_lsn", str)));
      51             : 
      52             :     /* Decode result. */
      53        2812 :     id = (uint32) strtoul(str, NULL, 16);
      54        2812 :     off = (uint32) strtoul(str + len1 + 1, NULL, 16);
      55        2812 :     result = ((uint64) id << 32) | off;
      56             : 
      57        2812 :     PG_RETURN_LSN(result);
      58             : }
      59             : 
      60             : Datum
      61        1042 : pg_lsn_out(PG_FUNCTION_ARGS)
      62             : {
      63        1042 :     XLogRecPtr  lsn = PG_GETARG_LSN(0);
      64             :     char        buf[MAXPG_LSNLEN + 1];
      65             :     char       *result;
      66             :     uint32      id,
      67             :                 off;
      68             : 
      69             :     /* Decode ID and offset */
      70        1042 :     id = (uint32) (lsn >> 32);
      71        1042 :     off = (uint32) lsn;
      72             : 
      73        1042 :     snprintf(buf, sizeof buf, "%X/%X", id, off);
      74        1042 :     result = pstrdup(buf);
      75        1042 :     PG_RETURN_CSTRING(result);
      76             : }
      77             : 
      78             : Datum
      79           0 : pg_lsn_recv(PG_FUNCTION_ARGS)
      80             : {
      81           0 :     StringInfo  buf = (StringInfo) PG_GETARG_POINTER(0);
      82             :     XLogRecPtr  result;
      83             : 
      84           0 :     result = pq_getmsgint64(buf);
      85           0 :     PG_RETURN_LSN(result);
      86             : }
      87             : 
      88             : Datum
      89           0 : pg_lsn_send(PG_FUNCTION_ARGS)
      90             : {
      91           0 :     XLogRecPtr  lsn = PG_GETARG_LSN(0);
      92             :     StringInfoData buf;
      93             : 
      94           0 :     pq_begintypsend(&buf);
      95           0 :     pq_sendint64(&buf, lsn);
      96           0 :     PG_RETURN_BYTEA_P(pq_endtypsend(&buf));
      97             : }
      98             : 
      99             : 
     100             : /*----------------------------------------------------------
     101             :  *  Operators for PostgreSQL LSNs
     102             :  *---------------------------------------------------------*/
     103             : 
     104             : Datum
     105        6246 : pg_lsn_eq(PG_FUNCTION_ARGS)
     106             : {
     107        6246 :     XLogRecPtr  lsn1 = PG_GETARG_LSN(0);
     108        6246 :     XLogRecPtr  lsn2 = PG_GETARG_LSN(1);
     109             : 
     110        6246 :     PG_RETURN_BOOL(lsn1 == lsn2);
     111             : }
     112             : 
     113             : Datum
     114           6 : pg_lsn_ne(PG_FUNCTION_ARGS)
     115             : {
     116           6 :     XLogRecPtr  lsn1 = PG_GETARG_LSN(0);
     117           6 :     XLogRecPtr  lsn2 = PG_GETARG_LSN(1);
     118             : 
     119           6 :     PG_RETURN_BOOL(lsn1 != lsn2);
     120             : }
     121             : 
     122             : Datum
     123        2052 : pg_lsn_lt(PG_FUNCTION_ARGS)
     124             : {
     125        2052 :     XLogRecPtr  lsn1 = PG_GETARG_LSN(0);
     126        2052 :     XLogRecPtr  lsn2 = PG_GETARG_LSN(1);
     127             : 
     128        2052 :     PG_RETURN_BOOL(lsn1 < lsn2);
     129             : }
     130             : 
     131             : Datum
     132        2052 : pg_lsn_gt(PG_FUNCTION_ARGS)
     133             : {
     134        2052 :     XLogRecPtr  lsn1 = PG_GETARG_LSN(0);
     135        2052 :     XLogRecPtr  lsn2 = PG_GETARG_LSN(1);
     136             : 
     137        2052 :     PG_RETURN_BOOL(lsn1 > lsn2);
     138             : }
     139             : 
     140             : Datum
     141        1762 : pg_lsn_le(PG_FUNCTION_ARGS)
     142             : {
     143        1762 :     XLogRecPtr  lsn1 = PG_GETARG_LSN(0);
     144        1762 :     XLogRecPtr  lsn2 = PG_GETARG_LSN(1);
     145             : 
     146        1762 :     PG_RETURN_BOOL(lsn1 <= lsn2);
     147             : }
     148             : 
     149             : Datum
     150        1320 : pg_lsn_ge(PG_FUNCTION_ARGS)
     151             : {
     152        1320 :     XLogRecPtr  lsn1 = PG_GETARG_LSN(0);
     153        1320 :     XLogRecPtr  lsn2 = PG_GETARG_LSN(1);
     154             : 
     155        1320 :     PG_RETURN_BOOL(lsn1 >= lsn2);
     156             : }
     157             : 
     158             : /* btree index opclass support */
     159             : Datum
     160        9620 : pg_lsn_cmp(PG_FUNCTION_ARGS)
     161             : {
     162        9620 :     XLogRecPtr  a = PG_GETARG_LSN(0);
     163        9620 :     XLogRecPtr  b = PG_GETARG_LSN(1);
     164             : 
     165        9620 :     if (a > b)
     166        4858 :         PG_RETURN_INT32(1);
     167        4762 :     else if (a == b)
     168          72 :         PG_RETURN_INT32(0);
     169             :     else
     170        4690 :         PG_RETURN_INT32(-1);
     171             : }
     172             : 
     173             : /* hash index opclass support */
     174             : Datum
     175        2088 : pg_lsn_hash(PG_FUNCTION_ARGS)
     176             : {
     177             :     /* We can use hashint8 directly */
     178        2088 :     return hashint8(fcinfo);
     179             : }
     180             : 
     181             : Datum
     182          40 : pg_lsn_hash_extended(PG_FUNCTION_ARGS)
     183             : {
     184          40 :     return hashint8extended(fcinfo);
     185             : }
     186             : 
     187             : 
     188             : /*----------------------------------------------------------
     189             :  *  Arithmetic operators on PostgreSQL LSNs.
     190             :  *---------------------------------------------------------*/
     191             : 
     192             : Datum
     193          42 : pg_lsn_mi(PG_FUNCTION_ARGS)
     194             : {
     195          42 :     XLogRecPtr  lsn1 = PG_GETARG_LSN(0);
     196          42 :     XLogRecPtr  lsn2 = PG_GETARG_LSN(1);
     197             :     char        buf[256];
     198             :     Datum       result;
     199             : 
     200             :     /* Output could be as large as plus or minus 2^63 - 1. */
     201          42 :     if (lsn1 < lsn2)
     202          34 :         snprintf(buf, sizeof buf, "-" UINT64_FORMAT, lsn2 - lsn1);
     203             :     else
     204           8 :         snprintf(buf, sizeof buf, UINT64_FORMAT, lsn1 - lsn2);
     205             : 
     206             :     /* Convert to numeric. */
     207          42 :     result = DirectFunctionCall3(numeric_in,
     208             :                                  CStringGetDatum(buf),
     209             :                                  ObjectIdGetDatum(0),
     210             :                                  Int32GetDatum(-1));
     211             : 
     212          42 :     return result;
     213             : }

Generated by: LCOV version 1.13