LCOV - differential code coverage report
Current view: top level - src/backend/access/common - scankey.c (source / functions) Coverage Total Hit CBC
Current: Differential Code Coverage HEAD vs 15 Lines: 100.0 % 30 30 30
Current Date: 2023-04-08 17:13:01 Functions: 100.0 % 3 3 3
Baseline: 15 Line coverage date bins:
Baseline Date: 2023-04-08 15:09:40 (240..) days: 100.0 % 30 30 30
Legend: Lines: hit not hit Function coverage date bins:
(240..) days: 100.0 % 3 3 3

 Age         Owner                  TLA  Line data    Source code
                                  1                 : /*-------------------------------------------------------------------------
                                  2                 :  *
                                  3                 :  * scankey.c
                                  4                 :  *    scan key support code
                                  5                 :  *
                                  6                 :  * Portions Copyright (c) 1996-2023, PostgreSQL Global Development Group
                                  7                 :  * Portions Copyright (c) 1994, Regents of the University of California
                                  8                 :  *
                                  9                 :  *
                                 10                 :  * IDENTIFICATION
                                 11                 :  *    src/backend/access/common/scankey.c
                                 12                 :  *
                                 13                 :  *-------------------------------------------------------------------------
                                 14                 :  */
                                 15                 : #include "postgres.h"
                                 16                 : 
                                 17                 : #include "access/skey.h"
                                 18                 : #include "catalog/pg_collation.h"
                                 19                 : 
                                 20                 : 
                                 21                 : /*
                                 22                 :  * ScanKeyEntryInitialize
                                 23                 :  *      Initializes a scan key entry given all the field values.
                                 24                 :  *      The target procedure is specified by OID (but can be invalid
                                 25                 :  *      if SK_SEARCHNULL or SK_SEARCHNOTNULL is set).
                                 26                 :  *
                                 27                 :  * Note: CurrentMemoryContext at call should be as long-lived as the ScanKey
                                 28                 :  * itself, because that's what will be used for any subsidiary info attached
                                 29                 :  * to the ScanKey's FmgrInfo record.
                                 30                 :  */
                                 31                 : void
 9770 scrappy                    32 CBC      140953 : ScanKeyEntryInitialize(ScanKey entry,
                                 33                 :                        int flags,
                                 34                 :                        AttrNumber attributeNumber,
                                 35                 :                        StrategyNumber strategy,
                                 36                 :                        Oid subtype,
                                 37                 :                        Oid collation,
                                 38                 :                        RegProcedure procedure,
                                 39                 :                        Datum argument)
                                 40                 : {
 9345 bruce                      41          140953 :     entry->sk_flags = flags;
                                 42          140953 :     entry->sk_attno = attributeNumber;
 7091 tgl                        43          140953 :     entry->sk_strategy = strategy;
 7088                            44          140953 :     entry->sk_subtype = subtype;
 4380                            45          140953 :     entry->sk_collation = collation;
 7088                            46          140953 :     entry->sk_argument = argument;
 5847                            47          140953 :     if (RegProcedureIsValid(procedure))
                                 48                 :     {
                                 49           94355 :         fmgr_info(procedure, &entry->sk_func);
                                 50                 :     }
                                 51                 :     else
                                 52                 :     {
 4846                            53           46598 :         Assert(flags & (SK_SEARCHNULL | SK_SEARCHNOTNULL));
 5847                            54          326186 :         MemSet(&entry->sk_func, 0, sizeof(entry->sk_func));
                                 55                 :     }
 7088                            56          140953 : }
                                 57                 : 
                                 58                 : /*
                                 59                 :  * ScanKeyInit
                                 60                 :  *      Shorthand version of ScanKeyEntryInitialize: flags and subtype
                                 61                 :  *      are assumed to be zero (the usual value), and collation is defaulted.
                                 62                 :  *
                                 63                 :  * This is the recommended version for hardwired lookups in system catalogs.
                                 64                 :  * It cannot handle NULL arguments, unary operators, or nondefault operators,
                                 65                 :  * but we need none of those features for most hardwired lookups.
                                 66                 :  *
                                 67                 :  * We set collation to C_COLLATION_OID always.  This is the correct value
                                 68                 :  * for all collation-aware columns in system catalogs, and it will be ignored
                                 69                 :  * for other column types, so it's not worth trying to be more finicky.
                                 70                 :  *
                                 71                 :  * Note: CurrentMemoryContext at call should be as long-lived as the ScanKey
                                 72                 :  * itself, because that's what will be used for any subsidiary info attached
                                 73                 :  * to the ScanKey's FmgrInfo record.
                                 74                 :  */
                                 75                 : void
                                 76         7051443 : ScanKeyInit(ScanKey entry,
                                 77                 :             AttrNumber attributeNumber,
                                 78                 :             StrategyNumber strategy,
                                 79                 :             RegProcedure procedure,
                                 80                 :             Datum argument)
                                 81                 : {
                                 82         7051443 :     entry->sk_flags = 0;
                                 83         7051443 :     entry->sk_attno = attributeNumber;
                                 84         7051443 :     entry->sk_strategy = strategy;
                                 85         7051443 :     entry->sk_subtype = InvalidOid;
 1573                            86         7051443 :     entry->sk_collation = C_COLLATION_OID;
 9345 bruce                      87         7051443 :     entry->sk_argument = argument;
 9215 webmaster                  88         7051443 :     fmgr_info(procedure, &entry->sk_func);
 9770 scrappy                    89         7051443 : }
                                 90                 : 
                                 91                 : /*
                                 92                 :  * ScanKeyEntryInitializeWithInfo
                                 93                 :  *      Initializes a scan key entry using an already-completed FmgrInfo
                                 94                 :  *      function lookup record.
                                 95                 :  *
                                 96                 :  * Note: CurrentMemoryContext at call should be as long-lived as the ScanKey
                                 97                 :  * itself, because that's what will be used for any subsidiary info attached
                                 98                 :  * to the ScanKey's FmgrInfo record.
                                 99                 :  */
                                100                 : void
 7855 tgl                       101        33856175 : ScanKeyEntryInitializeWithInfo(ScanKey entry,
                                102                 :                                int flags,
                                103                 :                                AttrNumber attributeNumber,
                                104                 :                                StrategyNumber strategy,
                                105                 :                                Oid subtype,
                                106                 :                                Oid collation,
                                107                 :                                FmgrInfo *finfo,
                                108                 :                                Datum argument)
                                109                 : {
                                110        33856175 :     entry->sk_flags = flags;
                                111        33856175 :     entry->sk_attno = attributeNumber;
 7091                           112        33856175 :     entry->sk_strategy = strategy;
 7088                           113        33856175 :     entry->sk_subtype = subtype;
 4380                           114        33856175 :     entry->sk_collation = collation;
 7855                           115        33856175 :     entry->sk_argument = argument;
 7091                           116        33856175 :     fmgr_info_copy(&entry->sk_func, finfo, CurrentMemoryContext);
 4443 peter_e                   117        33856175 : }
        

Generated by: LCOV version v1.16-55-g56c0a2a