LCOV - differential code coverage report
Current view: top level - src/backend/storage/page - itemptr.c (source / functions) Coverage Total Hit UBC CBC
Current: Differential Code Coverage 16@8cea358b128 vs 17@8cea358b128 Lines: 97.6 % 41 40 1 40
Current Date: 2024-04-14 14:21:10 Functions: 100.0 % 4 4 4
Baseline: 16@8cea358b128 Branches: 95.0 % 20 19 1 19
Baseline Date: 2024-04-14 14:21:09 Line coverage date bins:
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed (240..) days: 97.6 % 41 40 1 40
Function coverage date bins:
(240..) days: 100.0 % 4 4 4
Branch coverage date bins:
(240..) days: 95.0 % 20 19 1 19

 Age         Owner                    Branch data    TLA  Line data    Source code
                                  1                 :                : /*-------------------------------------------------------------------------
                                  2                 :                :  *
                                  3                 :                :  * itemptr.c
                                  4                 :                :  *    POSTGRES disk item pointer code.
                                  5                 :                :  *
                                  6                 :                :  * Portions Copyright (c) 1996-2024, 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
10141 scrappy@hub.org            35                 :CBC    17897290 : ItemPointerEquals(ItemPointer pointer1, ItemPointer pointer2)
                                 36                 :                : {
 9716 bruce@momjian.us           37         [ +  + ]:       35794580 :     if (ItemPointerGetBlockNumber(pointer1) ==
                                 38         [ +  + ]:       30835249 :         ItemPointerGetBlockNumber(pointer2) &&
                                 39                 :       12937959 :         ItemPointerGetOffsetNumber(pointer1) ==
                                 40                 :       12937959 :         ItemPointerGetOffsetNumber(pointer2))
 9357                            41                 :       10951913 :         return true;
                                 42                 :                :     else
                                 43                 :        6945377 :         return false;
                                 44                 :                : }
                                 45                 :                : 
                                 46                 :                : /*
                                 47                 :                :  * ItemPointerCompare
                                 48                 :                :  *      Generic btree-style comparison for item pointers.
                                 49                 :                :  */
                                 50                 :                : int32
 6442 tgl@sss.pgh.pa.us          51                 :       20199494 : ItemPointerCompare(ItemPointer arg1, ItemPointer 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                 :                :      */
 2574 alvherre@alvh.no-ip.       57                 :       20199494 :     BlockNumber b1 = ItemPointerGetBlockNumberNoCheck(arg1);
                                 58                 :       20199494 :     BlockNumber b2 = ItemPointerGetBlockNumberNoCheck(arg2);
                                 59                 :                : 
 6442 tgl@sss.pgh.pa.us          60         [ +  + ]:       20199494 :     if (b1 < b2)
                                 61                 :         238498 :         return -1;
                                 62         [ +  + ]:       19960996 :     else if (b1 > b2)
                                 63                 :       11242061 :         return 1;
 2574 alvherre@alvh.no-ip.       64         [ +  + ]:       17437870 :     else if (ItemPointerGetOffsetNumberNoCheck(arg1) <
                                 65                 :        8718935 :              ItemPointerGetOffsetNumberNoCheck(arg2))
 6442 tgl@sss.pgh.pa.us          66                 :         425157 :         return -1;
 2574 alvherre@alvh.no-ip.       67         [ +  + ]:       16587556 :     else if (ItemPointerGetOffsetNumberNoCheck(arg1) >
                                 68                 :        8293778 :              ItemPointerGetOffsetNumberNoCheck(arg2))
 6442 tgl@sss.pgh.pa.us          69                 :        7581919 :         return 1;
                                 70                 :                :     else
                                 71                 :         711859 :         return 0;
                                 72                 :                : }
                                 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
 1142 drowley@postgresql.o       84                 :             23 : ItemPointerInc(ItemPointer pointer)
                                 85                 :                : {
                                 86                 :             23 :     BlockNumber blk = ItemPointerGetBlockNumberNoCheck(pointer);
                                 87                 :             23 :     OffsetNumber off = ItemPointerGetOffsetNumberNoCheck(pointer);
                                 88                 :                : 
                                 89         [ +  + ]:             23 :     if (off == PG_UINT16_MAX)
                                 90                 :                :     {
                                 91         [ +  + ]:              6 :         if (blk != InvalidBlockNumber)
                                 92                 :                :         {
                                 93                 :              3 :             off = 0;
                                 94                 :              3 :             blk++;
                                 95                 :                :         }
                                 96                 :                :     }
                                 97                 :                :     else
                                 98                 :             17 :         off++;
                                 99                 :                : 
                                100                 :             23 :     ItemPointerSet(pointer, blk, off);
                                101                 :             23 : }
                                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                 :             30 : ItemPointerDec(ItemPointer pointer)
                                115                 :                : {
                                116                 :             30 :     BlockNumber blk = ItemPointerGetBlockNumberNoCheck(pointer);
                                117                 :             30 :     OffsetNumber off = ItemPointerGetOffsetNumberNoCheck(pointer);
                                118                 :                : 
                                119         [ +  - ]:             30 :     if (off == 0)
                                120                 :                :     {
                                121         [ +  + ]:             30 :         if (blk != 0)
                                122                 :                :         {
                                123                 :             21 :             off = PG_UINT16_MAX;
                                124                 :             21 :             blk--;
                                125                 :                :         }
                                126                 :                :     }
                                127                 :                :     else
 1142 drowley@postgresql.o      128                 :UBC           0 :         off--;
                                129                 :                : 
 1142 drowley@postgresql.o      130                 :CBC          30 :     ItemPointerSet(pointer, blk, off);
                                131                 :             30 : }
        

Generated by: LCOV version 2.1-beta2-3-g6141622