Branch data     Line data    Source code

       1                 :             : /*-------------------------------------------------------------------------
       2                 :             :  *
       3                 :             :  * itemptr.c
       4                 :             :  *        POSTGRES disk item pointer code.
       5                 :             :  *
       6                 :             :  * Portions Copyright (c) 1996-2026, PostgreSQL Global Development Group
       7                 :             :  * Portions Copyright (c) 1994, Regents of the University of California
       8                 :             :  *
       9                 :             :  *
      10                 :             :  * IDENTIFICATION
      11                 :             :  *        src/backend/storage/page/itemptr.c
      12                 :             :  *
      13                 :             :  *-------------------------------------------------------------------------
      14                 :             :  */
      15                 :             : #include "postgres.h"
      16                 :             : 
      17                 :             : #include "storage/itemptr.h"
      18                 :             : 
      19                 :             : 
      20                 :             : /*
      21                 :             :  * We really want ItemPointerData to be exactly 6 bytes.
      22                 :             :  */
      23                 :             : StaticAssertDecl(sizeof(ItemPointerData) == 3 * sizeof(uint16),
      24                 :             :                                  "ItemPointerData struct is improperly padded");
      25                 :             : 
      26                 :             : /*
      27                 :             :  * ItemPointerEquals
      28                 :             :  *      Returns true if both item pointers point to the same item,
      29                 :             :  *       otherwise returns false.
      30                 :             :  *
      31                 :             :  * Note:
      32                 :             :  *      Asserts that the disk item pointers are both valid!
      33                 :             :  */
      34                 :             : bool
      35                 :     4881757 : ItemPointerEquals(const ItemPointerData *pointer1, const ItemPointerData *pointer2)
      36                 :             : {
      37                 :     9763514 :         if (ItemPointerGetBlockNumber(pointer1) ==
      38   [ +  +  +  +  :     9763514 :                 ItemPointerGetBlockNumber(pointer2) &&
                   +  + ]
      39                 :     5650702 :                 ItemPointerGetOffsetNumber(pointer1) ==
      40                 :     2825351 :                 ItemPointerGetOffsetNumber(pointer2))
      41                 :     2006295 :                 return true;
      42                 :             :         else
      43                 :     2875462 :                 return false;
      44                 :     4881757 : }
      45                 :             : 
      46                 :             : /*
      47                 :             :  * ItemPointerCompare
      48                 :             :  *              Generic btree-style comparison for item pointers.
      49                 :             :  */
      50                 :             : int32
      51                 :     5342257 : ItemPointerCompare(const ItemPointerData *arg1, const ItemPointerData *arg2)
      52                 :             : {
      53                 :             :         /*
      54                 :             :          * Use ItemPointerGet{Offset,Block}NumberNoCheck to avoid asserting
      55                 :             :          * ip_posid != 0, which may not be true for a user-supplied TID.
      56                 :             :          */
      57                 :     5342257 :         BlockNumber b1 = ItemPointerGetBlockNumberNoCheck(arg1);
      58                 :     5342257 :         BlockNumber b2 = ItemPointerGetBlockNumberNoCheck(arg2);
      59                 :             : 
      60         [ +  + ]:     5342257 :         if (b1 < b2)
      61                 :       56863 :                 return -1;
      62         [ +  + ]:     5285394 :         else if (b1 > b2)
      63                 :     3505205 :                 return 1;
      64   [ +  +  +  + ]:     3560378 :         else if (ItemPointerGetOffsetNumberNoCheck(arg1) <
      65                 :     1780189 :                          ItemPointerGetOffsetNumberNoCheck(arg2))
      66                 :      130161 :                 return -1;
      67   [ +  +  +  + ]:     3300056 :         else if (ItemPointerGetOffsetNumberNoCheck(arg1) >
      68                 :     1650028 :                          ItemPointerGetOffsetNumberNoCheck(arg2))
      69                 :     1558714 :                 return 1;
      70                 :             :         else
      71                 :       91314 :                 return 0;
      72                 :     5342257 : }
      73                 :             : 
      74                 :             : /*
      75                 :             :  * ItemPointerInc
      76                 :             :  *              Increment 'pointer' by 1 only paying attention to the ItemPointer's
      77                 :             :  *              type's range limits and not MaxOffsetNumber and FirstOffsetNumber.
      78                 :             :  *              This may result in 'pointer' becoming !OffsetNumberIsValid.
      79                 :             :  *
      80                 :             :  * If the pointer is already the maximum possible values permitted by the
      81                 :             :  * range of the ItemPointer's types, then do nothing.
      82                 :             :  */
      83                 :             : void
      84                 :          17 : ItemPointerInc(ItemPointer pointer)
      85                 :             : {
      86                 :          17 :         BlockNumber blk = ItemPointerGetBlockNumberNoCheck(pointer);
      87                 :          17 :         OffsetNumber off = ItemPointerGetOffsetNumberNoCheck(pointer);
      88                 :             : 
      89         [ +  + ]:          17 :         if (off == PG_UINT16_MAX)
      90                 :             :         {
      91         [ +  + ]:           2 :                 if (blk != InvalidBlockNumber)
      92                 :             :                 {
      93                 :           1 :                         off = 0;
      94                 :           1 :                         blk++;
      95                 :           1 :                 }
      96                 :           2 :         }
      97                 :             :         else
      98                 :          15 :                 off++;
      99                 :             : 
     100                 :          17 :         ItemPointerSet(pointer, blk, off);
     101                 :          17 : }
     102                 :             : 
     103                 :             : /*
     104                 :             :  * ItemPointerDec
     105                 :             :  *              Decrement 'pointer' by 1 only paying attention to the ItemPointer's
     106                 :             :  *              type's range limits and not MaxOffsetNumber and FirstOffsetNumber.
     107                 :             :  *              This may result in 'pointer' becoming !OffsetNumberIsValid.
     108                 :             :  *
     109                 :             :  * If the pointer is already the minimum possible values permitted by the
     110                 :             :  * range of the ItemPointer's types, then do nothing.  This does rely on
     111                 :             :  * FirstOffsetNumber being 1 rather than 0.
     112                 :             :  */
     113                 :             : void
     114                 :          25 : ItemPointerDec(ItemPointer pointer)
     115                 :             : {
     116                 :          25 :         BlockNumber blk = ItemPointerGetBlockNumberNoCheck(pointer);
     117                 :          25 :         OffsetNumber off = ItemPointerGetOffsetNumberNoCheck(pointer);
     118                 :             : 
     119         [ +  + ]:          25 :         if (off == 0)
     120                 :             :         {
     121         [ +  + ]:          15 :                 if (blk != 0)
     122                 :             :                 {
     123                 :          12 :                         off = PG_UINT16_MAX;
     124                 :          12 :                         blk--;
     125                 :          12 :                 }
     126                 :          15 :         }
     127                 :             :         else
     128                 :          10 :                 off--;
     129                 :             : 
     130                 :          25 :         ItemPointerSet(pointer, blk, off);
     131                 :          25 : }