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.39 1998/11/27 19:33:31 vadim 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
  93 extern Datum nocachegetattr(HeapTuple tup, int attnum,
  94                            TupleDesc att, bool *isnull);
  95
  96 #if !defined(DISABLE_COMPLEX_MACRO)
  97
  98 #define fastgetattr(tup, attnum, tupleDesc, isnull) \
  99 ( \
 100         AssertMacro((attnum) > 0), \
 101         ((isnull) ? (*(isnull) = false) : (dummyret)NULL), \
 102         HeapTupleNoNulls(tup) ? \
 103         ( \
 104                 ((tupleDesc)->attrs[(attnum)-1]->attcacheoff != -1 || \
 105                  (attnum) == 1) ? \
 106                 ( \
 107                         (Datum)fetchatt(&((tupleDesc)->attrs[(attnum)-1]), \
 108                                 (char *) (tup)->t_data + (tup)->t_data->t_hoff + \
 109                                 ( \
 110                                         ((attnum) != 1) ? \
 111                                                 (tupleDesc)->attrs[(attnum)-1]->attcacheoff \
 112                                         : \
 113                                                 0 \
 114                                 ) \
 115                         ) \
 116                 ) \
 117                 : \
 118                         nocachegetattr((tup), (attnum), (tupleDesc), (isnull)) \
 119         ) \
 120         : \
 121         ( \
 122                 att_isnull((attnum)-1, (tup)->t_data->t_bits) ? \
 123                 ( \
 124                         ((isnull) ? (*(isnull) = true) : (dummyret)NULL), \
 125                         (Datum)NULL \
 126                 ) \
 127                 : \
 128                 ( \
 129                         nocachegetattr((tup), (attnum), (tupleDesc), (isnull)) \
 130                 ) \
 131         ) \
 132 )
 133
 134 #else                                                   /* !defined(DISABLE_COMPLEX_MACRO) */
 135
 136 static Datum
 137 fastgetattr(HeapTuple tup, int attnum, TupleDesc tupleDesc,
 138                         bool *isnull)
 139 {
 140         return (
 141                         (attnum) > 0 ?
 142                         (
 143                          ((isnull) ? (*(isnull) = false) : (dummyret) NULL),
 144                          HeapTupleNoNulls(tup) ?
 145                          (
 146                           ((tupleDesc)->attrs[(attnum) - 1]->attcacheoff != -1 ||
 147                            (attnum) == 1) ?
 148                           (
 149                            (Datum) fetchatt(&((tupleDesc)->attrs[(attnum) - 1]),
 150                                                                 (char *) (tup)->t_data + (tup)->t_data->t_hoff +
 151                                                                 (
 152                                                                  ((attnum) != 1) ?
 153                                                         (tupleDesc)->attrs[(attnum) - 1]->attcacheoff
 154                                                                  :
 155                                                                  0
 156                                                                  )
 157                                                                 )
 158                            )
 159                           :
 160                           nocachegetattr((tup), (attnum), (tupleDesc), (isnull))
 161                           )
 162                          :
 163                          (
 164                           att_isnull((attnum) - 1, (tup)->t_data->t_bits) ?
 165                           (
 166                            ((isnull) ? (*(isnull) = true) : (dummyret) NULL),
 167                            (Datum) NULL
 168                            )
 169                           :
 170                           (
 171                            nocachegetattr((tup), (attnum), (tupleDesc), (isnull))
 172                            )
 173                           )
 174                          )
 175                         :
 176                         (
 177                          (Datum) NULL
 178                          )
 179         );
 180 }
 181
 182 #endif
 183
 184 /* ----------------
 185  *              heap_getattr
 186  *
 187  *              Find a particular field in a row represented as a heap tuple.
 188  *              We return a pointer into that heap tuple, which points to the
 189  *              first byte of the value of the field in question.
 190  *
 191  *              If the field in question has a NULL value, we return a null
 192  *              pointer and return <*isnull> == true.  Otherwise, we return
 193  *              <*isnull> == false.
 194  *
 195  *              <tup> is the pointer to the heap tuple.  <attnum> is the attribute
 196  *              number of the column (field) caller wants.      <tupleDesc> is a
 197  *              pointer to the structure describing the row and all its fields.
 198  *
 199  *              Because this macro is often called with constants, it generates
 200  *              compiler warnings about 'left-hand comma expression has no effect.
 201  *
 202  * ----------------
 203  */
 204 #define heap_getattr(tup, attnum, tupleDesc, isnull) \
 205 ( \
 206         AssertMacro((tup) != NULL && \
 207                 (attnum) > FirstLowInvalidHeapAttributeNumber && \
 208                 (attnum) != 0), \
 209         ((attnum) > (int) (tup)->t_data->t_natts) ? \
 210         ( \
 211                 ((isnull) ? (*(isnull) = true) : (dummyret)NULL), \
 212                 (Datum)NULL \
 213         ) \
 214         : \
 215         ( \
 216                 ((attnum) > 0) ? \
 217                 ( \
 218                         fastgetattr((tup), (attnum), (tupleDesc), (isnull)) \
 219                 ) \
 220                 : \
 221                 ( \
 222                         ((isnull) ? (*(isnull) = false) : (dummyret)NULL), \
 223                         ((attnum) == SelfItemPointerAttributeNumber) ? \
 224                         ( \
 225                                 (Datum)((char *)&((tup)->t_self)) \
 226                         ) \
 227                         : \
 228                         ( \
 229                                 (Datum)*(unsigned int *) \
 230                                         ((char *)(tup)->t_data + 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
 246 extern Relation heap_open(Oid relationId);
 247 extern Relation heap_openr(char *relationName);
 248 extern void heap_close(Relation relation);
 249 extern HeapScanDesc heap_beginscan(Relation relation, int atend,
 250                            Snapshot snapshot, unsigned nkeys, ScanKey key);
 251 extern void heap_rescan(HeapScanDesc scan, bool scanFromEnd, ScanKey key);
 252 extern void heap_endscan(HeapScanDesc scan);
 253 extern HeapTuple heap_getnext(HeapScanDesc scandesc, int backw);
 254 extern void heap_fetch(Relation relation, Snapshot snapshot, HeapTuple tup, Buffer *userbuf);
 255 extern Oid      heap_insert(Relation relation, HeapTuple tup);
 256 extern int      heap_delete(Relation relation, ItemPointer tid);
 257 extern int heap_replace(Relation relation, ItemPointer otid,
 258                          HeapTuple tup);
 259 extern void heap_markpos(HeapScanDesc scan);
 260 extern void heap_restrpos(HeapScanDesc scan);
 261
 262 /* in common/heaptuple.c */
 263 extern Size ComputeDataSize(TupleDesc tupleDesc, Datum *value, char *nulls);
 264 extern void DataFill(char *data, TupleDesc tupleDesc,
 265                  Datum *value, char *nulls, uint16 *infomask,
 266                  bits8 *bit);
 267 extern int      heap_attisnull(HeapTuple tup, int attnum);
 268 extern int      heap_sysattrlen(AttrNumber attno);
 269 extern bool heap_sysattrbyval(AttrNumber attno);
 270 extern Datum nocachegetattr(HeapTuple tup, int attnum,
 271                            TupleDesc att, bool *isnull);
 272 extern HeapTuple heap_copytuple(HeapTuple tuple);
 273 extern void heap_copytuple_with_tuple(HeapTuple src, HeapTuple dest);
 274 extern HeapTuple heap_formtuple(TupleDesc tupleDescriptor,
 275                            Datum *value, char *nulls);
 276 extern HeapTuple heap_modifytuple(HeapTuple tuple,
 277                 Relation relation, Datum *replValue, char *replNull, char *repl);
 278 HeapTuple       heap_addheader(uint32 natts, int structlen, char *structure);
 279
 280 /* in common/heap/stats.c */
 281 extern void PrintHeapAccessStatistics(HeapAccessStatistics stats);
 282 extern void initam(void);
 283
 284 /* hio.c */
 285 extern void RelationPutHeapTuple(Relation relation, BlockNumber blockIndex,
 286                                          HeapTuple tuple);
 287 extern void RelationPutHeapTupleAtEnd(Relation relation, HeapTuple tuple);
 288
 289 #endif   /* HEAPAM_H */