src/include/access/heapam.h

   1 /*-------------------------------------------------------------------------
   2  *
   3  * heapam.h--
   4  *        POSTGRES heap access method definitions.
   5  *
   6  *
   7  * Copyright (c) 1994, Regents of the University of California
   8  *
   9  * $Id: heapam.h,v 1.37 1998/09/01 04:34:12 momjian Exp $
  10  *
  11  *-------------------------------------------------------------------------
  12  */
  13 #ifndef HEAPAM_H
  14 #define HEAPAM_H
  15
  16 #include <access/tupmacs.h>
  17 #include <access/htup.h>
  18 #include <access/relscan.h>
  19 #include <storage/block.h>
  20 #include <utils/rel.h>
  21 #include <utils/tqual.h>
  22
  23 /* ----------------------------------------------------------------
  24  *                              heap access method statistics
  25  * ----------------------------------------------------------------
  26  */
  27
  28 typedef struct HeapAccessStatisticsData
  29 {
  30         time_t          init_global_timestamp;  /* time global statistics started */
  31         time_t          local_reset_timestamp;  /* last time local reset was done */
  32         time_t          last_request_timestamp; /* last time stats were requested */
  33
  34         int                     global_open;
  35         int                     global_openr;
  36         int                     global_close;
  37         int                     global_beginscan;
  38         int                     global_rescan;
  39         int                     global_endscan;
  40         int                     global_getnext;
  41         int                     global_fetch;
  42         int                     global_insert;
  43         int                     global_delete;
  44         int                     global_replace;
  45         int                     global_markpos;
  46         int                     global_restrpos;
  47         int                     global_BufferGetRelation;
  48         int                     global_RelationIdGetRelation;
  49         int                     global_RelationIdGetRelation_Buf;
  50         int                     global_RelationNameGetRelation;
  51         int                     global_getreldesc;
  52         int                     global_heapgettup;
  53         int                     global_RelationPutHeapTuple;
  54         int                     global_RelationPutLongHeapTuple;
  55
  56         int                     local_open;
  57         int                     local_openr;
  58         int                     local_close;
  59         int                     local_beginscan;
  60         int                     local_rescan;
  61         int                     local_endscan;
  62         int                     local_getnext;
  63         int                     local_fetch;
  64         int                     local_insert;
  65         int                     local_delete;
  66         int                     local_replace;
  67         int                     local_markpos;
  68         int                     local_restrpos;
  69         int                     local_BufferGetRelation;
  70         int                     local_RelationIdGetRelation;
  71         int                     local_RelationIdGetRelation_Buf;
  72         int                     local_RelationNameGetRelation;
  73         int                     local_getreldesc;
  74         int                     local_heapgettup;
  75         int                     local_RelationPutHeapTuple;
  76         int                     local_RelationPutLongHeapTuple;
  77 } HeapAccessStatisticsData;
  78
  79 typedef HeapAccessStatisticsData *HeapAccessStatistics;
  80
  81 #define IncrHeapAccessStat(x) \
  82         (heap_access_stats == NULL ? 0 : (heap_access_stats->x)++)
  83
  84 /* ----------------
  85  *              fastgetattr
  86  *
  87  *              This gets called many times, so we macro the cacheable and NULL
  88  *              lookups, and call noncachegetattr() for the rest.
  89  *
  90  * ----------------
  91  */
  92 #if !defined(DISABLE_COMPLEX_MACRO)
  93
  94 #define fastgetattr(tup, attnum, tupleDesc, isnull) \
  95 ( \
  96         AssertMacro((attnum) > 0), \
  97         ((isnull) ? (*(isnull) = false) : (dummyret)NULL), \
  98         HeapTupleNoNulls(tup) ? \
  99         ( \
 100                 ((tupleDesc)->attrs[(attnum)-1]->attcacheoff != -1 || \
 101                  (attnum) == 1) ? \
 102                 ( \
 103                         (Datum)fetchatt(&((tupleDesc)->attrs[(attnum)-1]), \
 104                                 (char *) (tup) + (tup)->t_hoff + \
 105                                 ( \
 106                                         ((attnum) != 1) ? \
 107                                                 (tupleDesc)->attrs[(attnum)-1]->attcacheoff \
 108                                         : \
 109                                                 0 \
 110                                 ) \
 111                         ) \
 112                 ) \
 113                 : \
 114                         nocachegetattr((tup), (attnum), (tupleDesc), (isnull)) \
 115         ) \
 116         : \
 117         ( \
 118                 att_isnull((attnum)-1, (tup)->t_bits) ? \
 119                 ( \
 120                         ((isnull) ? (*(isnull) = true) : (dummyret)NULL), \
 121                         (Datum)NULL \
 122                 ) \
 123                 : \
 124                 ( \
 125                         nocachegetattr((tup), (attnum), (tupleDesc), (isnull)) \
 126                 ) \
 127         ) \
 128 )
 129
 130 #else                                                   /* !defined(DISABLE_COMPLEX_MACRO) */
 131
 132 extern Datum nocachegetattr(HeapTuple tup, int attnum,
 133                            TupleDesc att, bool *isnull);
 134
 135 static Datum
 136 fastgetattr(HeapTuple tup, int attnum, TupleDesc tupleDesc,
 137                         bool *isnull)
 138 {
 139         return (
 140                         (attnum) > 0 ?
 141                         (
 142                          ((isnull) ? (*(isnull) = false) : (dummyret) NULL),
 143                          HeapTupleNoNulls(tup) ?
 144                          (
 145                           ((tupleDesc)->attrs[(attnum) - 1]->attcacheoff != -1 ||
 146                            (attnum) == 1) ?
 147                           (
 148                            (Datum) fetchatt(&((tupleDesc)->attrs[(attnum) - 1]),
 149                                                                 (char *) (tup) + (tup)->t_hoff +
 150                                                                 (
 151                                                                  ((attnum) != 1) ?
 152                                                         (tupleDesc)->attrs[(attnum) - 1]->attcacheoff
 153                                                                  :
 154                                                                  0
 155                                                                  )
 156                                                                 )
 157                            )
 158                           :
 159                           nocachegetattr((tup), (attnum), (tupleDesc), (isnull))
 160                           )
 161                          :
 162                          (
 163                           att_isnull((attnum) - 1, (tup)->t_bits) ?
 164                           (
 165                            ((isnull) ? (*(isnull) = true) : (dummyret) NULL),
 166                            (Datum) NULL
 167                            )
 168                           :
 169                           (
 170                            nocachegetattr((tup), (attnum), (tupleDesc), (isnull))
 171                            )
 172                           )
 173                          )
 174                         :
 175                         (
 176                          (Datum) NULL
 177                          )
 178         );
 179 }
 180
 181 #endif
 182
 183 /* ----------------
 184  *              heap_getattr
 185  *
 186  *              Find a particular field in a row represented as a heap tuple.
 187  *              We return a pointer into that heap tuple, which points to the
 188  *              first byte of the value of the field in question.
 189  *
 190  *              If the field in question has a NULL value, we return a null
 191  *              pointer and return <*isnull> == true.  Otherwise, we return
 192  *              <*isnull> == false.
 193  *
 194  *              <tup> is the pointer to the heap tuple.  <attnum> is the attribute
 195  *              number of the column (field) caller wants.      <tupleDesc> is a
 196  *              pointer to the structure describing the row and all its fields.
 197  *
 198  *              Because this macro is often called with constants, it generates
 199  *              compiler warnings about 'left-hand comma expression has no effect.
 200  *
 201  * ----------------
 202  */
 203 #define heap_getattr(tup, attnum, tupleDesc, isnull) \
 204 ( \
 205         AssertMacro((tup) != NULL && \
 206                 (attnum) > FirstLowInvalidHeapAttributeNumber && \
 207                 (attnum) != 0), \
 208         ((attnum) > (int) (tup)->t_natts) ? \
 209         ( \
 210                 ((isnull) ? (*(isnull) = true) : (dummyret)NULL), \
 211                 (Datum)NULL \
 212         ) \
 213         : \
 214         ( \
 215                 ((attnum) > 0) ? \
 216                 ( \
 217                         fastgetattr((tup), (attnum), (tupleDesc), (isnull)) \
 218                 ) \
 219                 : \
 220                 ( \
 221                         ((isnull) ? (*(isnull) = false) : (dummyret)NULL), \
 222                         ((attnum) == SelfItemPointerAttributeNumber) ? \
 223                         ( \
 224                                 (Datum)((char *)(tup) + \
 225                                         heap_sysoffset[-SelfItemPointerAttributeNumber-1]) \
 226                         ) \
 227                         : \
 228                         ( \
 229                                 (Datum)*(unsigned int *) \
 230                                         ((char *)(tup) + heap_sysoffset[-(attnum)-1]) \
 231                         ) \
 232                 ) \
 233         ) \
 234 )
 235
 236 extern HeapAccessStatistics heap_access_stats;  /* in stats.c */
 237
 238 /* ----------------
 239  *              function prototypes for heap access method
 240  * ----------------
 241  */
 242 /* heap_create, heap_creatr, and heap_destroy are declared in catalog/heap.h */
 243
 244 /* heapam.c */
 245 extern void doinsert(Relation relation, HeapTuple tup);
 246
 247 extern Relation heap_open(Oid relationId);
 248 extern Relation heap_openr(char *relationName);
 249 extern void heap_close(Relation relation);
 250 extern HeapScanDesc heap_beginscan(Relation relation, int atend,
 251                            Snapshot snapshot, unsigned nkeys, ScanKey key);
 252 extern void heap_rescan(HeapScanDesc scan, bool scanFromEnd, ScanKey key);
 253 extern void heap_endscan(HeapScanDesc scan);
 254 extern HeapTuple heap_getnext(HeapScanDesc scandesc, int backw);
 255 extern HeapTuple heap_fetch(Relation relation, Snapshot snapshot, ItemPointer tid, Buffer *userbuf);
 256 extern Oid      heap_insert(Relation relation, HeapTuple tup);
 257 extern int      heap_delete(Relation relation, ItemPointer tid);
 258 extern int heap_replace(Relation relation, ItemPointer otid,
 259                          HeapTuple tup);
 260 extern void heap_markpos(HeapScanDesc scan);
 261 extern void heap_restrpos(HeapScanDesc scan);
 262
 263 /* in common/heaptuple.c */
 264 extern Size ComputeDataSize(TupleDesc tupleDesc, Datum *value, char *nulls);
 265 extern void DataFill(char *data, TupleDesc tupleDesc,
 266                  Datum *value, char *nulls, uint16 *infomask,
 267                  bits8 *bit);
 268 extern int      heap_attisnull(HeapTuple tup, int attnum);
 269 extern int      heap_sysattrlen(AttrNumber attno);
 270 extern bool heap_sysattrbyval(AttrNumber attno);
 271 extern Datum heap_getsysattr(HeapTuple tup, Buffer b, int attnum);
 272 extern Datum nocachegetattr(HeapTuple tup, int attnum,
 273                            TupleDesc att, bool *isnull);
 274 extern HeapTuple heap_copytuple(HeapTuple tuple);
 275 extern HeapTuple heap_formtuple(TupleDesc tupleDescriptor,
 276                            Datum *value, char *nulls);
 277 extern HeapTuple heap_modifytuple(HeapTuple tuple,
 278                 Relation relation, Datum *replValue, char *replNull, char *repl);
 279 HeapTuple       heap_addheader(uint32 natts, int structlen, char *structure);
 280
 281 /* in common/heap/stats.c */
 282 extern void PrintHeapAccessStatistics(HeapAccessStatistics stats);
 283 extern void initam(void);
 284
 285 /* hio.c */
 286 extern void RelationPutHeapTuple(Relation relation, BlockNumber blockIndex,
 287                                          HeapTuple tuple);
 288 extern void RelationPutHeapTupleAtEnd(Relation relation, HeapTuple tuple);
 289
 290 #endif   /* HEAPAM_H */