1 /*------------------------------------------------------------------------- 2 * 3 * tupmacs.h 4 * Tuple macros used by both index tuples and heap tuples. 5 * 6 * 7 * Portions Copyright (c) 1996-2021, PostgreSQL Global Development Group 8 * Portions Copyright (c) 1994, Regents of the University of California 9 * 10 * src/include/access/tupmacs.h 11 * 12 *------------------------------------------------------------------------- 13 */ 14 #ifndef TUPMACS_H 15 #define TUPMACS_H 16 17 #include "catalog/pg_type_d.h" /* for TYPALIGN macros */ 18 19 20 /* 21 * Check a tuple's null bitmap to determine whether the attribute is null. 22 * Note that a 0 in the null bitmap indicates a null, while 1 indicates 23 * non-null. 24 */ 25 #define att_isnull(ATT, BITS) (!((BITS)[(ATT) >> 3] & (1 << ((ATT) & 0x07)))) 26 27 /* 28 * Given a Form_pg_attribute and a pointer into a tuple's data area, 29 * return the correct value or pointer. 30 * 31 * We return a Datum value in all cases. If the attribute has "byval" false, 32 * we return the same pointer into the tuple data area that we're passed. 33 * Otherwise, we return the correct number of bytes fetched from the data 34 * area and extended to Datum form. 35 * 36 * On machines where Datum is 8 bytes, we support fetching 8-byte byval 37 * attributes; otherwise, only 1, 2, and 4-byte values are supported. 38 * 39 * Note that T must already be properly aligned for this to work correctly. 40 */ 41 #define fetchatt(A,T) fetch_att(T, (A)->attbyval, (A)->attlen) 42 43 /* 44 * Same, but work from byval/len parameters rather than Form_pg_attribute. 45 */ 46 #if SIZEOF_DATUM == 8 47 48 #define fetch_att(T,attbyval,attlen) \ 49 ( \ 50 (attbyval) ? \ 51 ( \ 52 (attlen) == (int) sizeof(Datum) ? \ 53 *((Datum *)(T)) \ 54 : \ 55 ( \ 56 (attlen) == (int) sizeof(int32) ? \ 57 Int32GetDatum(*((int32 *)(T))) \ 58 : \ 59 ( \ 60 (attlen) == (int) sizeof(int16) ? \ 61 Int16GetDatum(*((int16 *)(T))) \ 62 : \ 63 ( \ 64 AssertMacro((attlen) == 1), \ 65 CharGetDatum(*((char *)(T))) \ 66 ) \ 67 ) \ 68 ) \ 69 ) \ 70 : \ 71 PointerGetDatum((char *) (T)) \ 72 ) 73 #else /* SIZEOF_DATUM != 8 */ 74 75 #define fetch_att(T,attbyval,attlen) \ 76 ( \ 77 (attbyval) ? \ 78 ( \ 79 (attlen) == (int) sizeof(int32) ? \ 80 Int32GetDatum(*((int32 *)(T))) \ 81 : \ 82 ( \ 83 (attlen) == (int) sizeof(int16) ? \ 84 Int16GetDatum(*((int16 *)(T))) \ 85 : \ 86 ( \ 87 AssertMacro((attlen) == 1), \ 88 CharGetDatum(*((char *)(T))) \ 89 ) \ 90 ) \ 91 ) \ 92 : \ 93 PointerGetDatum((char *) (T)) \ 94 ) 95 #endif /* SIZEOF_DATUM == 8 */ 96 97 /* 98 * att_align_datum aligns the given offset as needed for a datum of alignment 99 * requirement attalign and typlen attlen. attdatum is the Datum variable 100 * we intend to pack into a tuple (it's only accessed if we are dealing with 101 * a varlena type). Note that this assumes the Datum will be stored as-is; 102 * callers that are intending to convert non-short varlena datums to short 103 * format have to account for that themselves. 104 */ 105 #define att_align_datum(cur_offset, attalign, attlen, attdatum) \ 106 ( \ 107 ((attlen) == -1 && VARATT_IS_SHORT(DatumGetPointer(attdatum))) ? \ 108 (uintptr_t) (cur_offset) : \ 109 att_align_nominal(cur_offset, attalign) \ 110 ) 111 112 /* 113 * att_align_pointer performs the same calculation as att_align_datum, 114 * but is used when walking a tuple. attptr is the current actual data 115 * pointer; when accessing a varlena field we have to "peek" to see if we 116 * are looking at a pad byte or the first byte of a 1-byte-header datum. 117 * (A zero byte must be either a pad byte, or the first byte of a correctly 118 * aligned 4-byte length word; in either case we can align safely. A non-zero 119 * byte must be either a 1-byte length word, or the first byte of a correctly 120 * aligned 4-byte length word; in either case we need not align.) 121 * 122 * Note: some callers pass a "char *" pointer for cur_offset. This is 123 * a bit of a hack but should work all right as long as uintptr_t is the 124 * correct width. 125 */ 126 #define att_align_pointer(cur_offset, attalign, attlen, attptr) \ 127 ( \ 128 ((attlen) == -1 && VARATT_NOT_PAD_BYTE(attptr)) ? \ 129 (uintptr_t) (cur_offset) : \ 130 att_align_nominal(cur_offset, attalign) \ 131 ) 132 133 /* 134 * att_align_nominal aligns the given offset as needed for a datum of alignment 135 * requirement attalign, ignoring any consideration of packed varlena datums. 136 * There are three main use cases for using this macro directly: 137 * * we know that the att in question is not varlena (attlen != -1); 138 * in this case it is cheaper than the above macros and just as good. 139 * * we need to estimate alignment padding cost abstractly, ie without 140 * reference to a real tuple. We must assume the worst case that 141 * all varlenas are aligned. 142 * * within arrays and multiranges, we unconditionally align varlenas (XXX this 143 * should be revisited, probably). 144 * 145 * The attalign cases are tested in what is hopefully something like their 146 * frequency of occurrence. 147 */ 148 #define att_align_nominal(cur_offset, attalign) \ 149 ( \ 150 ((attalign) == TYPALIGN_INT) ? INTALIGN(cur_offset) : \ 151 (((attalign) == TYPALIGN_CHAR) ? (uintptr_t) (cur_offset) : \ 152 (((attalign) == TYPALIGN_DOUBLE) ? DOUBLEALIGN(cur_offset) : \ 153 ( \ 154 AssertMacro((attalign) == TYPALIGN_SHORT), \ 155 SHORTALIGN(cur_offset) \ 156 ))) \ 157 ) 158 159 /* 160 * att_addlength_datum increments the given offset by the space needed for 161 * the given Datum variable. attdatum is only accessed if we are dealing 162 * with a variable-length attribute. 163 */ 164 #define att_addlength_datum(cur_offset, attlen, attdatum) \ 165 att_addlength_pointer(cur_offset, attlen, DatumGetPointer(attdatum)) 166 167 /* 168 * att_addlength_pointer performs the same calculation as att_addlength_datum, 169 * but is used when walking a tuple --- attptr is the pointer to the field 170 * within the tuple. 171 * 172 * Note: some callers pass a "char *" pointer for cur_offset. This is 173 * actually perfectly OK, but probably should be cleaned up along with 174 * the same practice for att_align_pointer. 175 */ 176 #define att_addlength_pointer(cur_offset, attlen, attptr) \ 177 ( \ 178 ((attlen) > 0) ? \ 179 ( \ 180 (cur_offset) + (attlen) \ 181 ) \ 182 : (((attlen) == -1) ? \ 183 ( \ 184 (cur_offset) + VARSIZE_ANY(attptr) \ 185 ) \ 186 : \ 187 ( \ 188 AssertMacro((attlen) == -2), \ 189 (cur_offset) + (strlen((char *) (attptr)) + 1) \ 190 )) \ 191 ) 192 193 /* 194 * store_att_byval is a partial inverse of fetch_att: store a given Datum 195 * value into a tuple data area at the specified address. However, it only 196 * handles the byval case, because in typical usage the caller needs to 197 * distinguish by-val and by-ref cases anyway, and so a do-it-all macro 198 * wouldn't be convenient. 199 */ 200 #if SIZEOF_DATUM == 8 201 202 #define store_att_byval(T,newdatum,attlen) \ 203 do { \ 204 switch (attlen) \ 205 { \ 206 case sizeof(char): \ 207 *(char *) (T) = DatumGetChar(newdatum); \ 208 break; \ 209 case sizeof(int16): \ 210 *(int16 *) (T) = DatumGetInt16(newdatum); \ 211 break; \ 212 case sizeof(int32): \ 213 *(int32 *) (T) = DatumGetInt32(newdatum); \ 214 break; \ 215 case sizeof(Datum): \ 216 *(Datum *) (T) = (newdatum); \ 217 break; \ 218 default: \ 219 elog(ERROR, "unsupported byval length: %d", \ 220 (int) (attlen)); \ 221 break; \ 222 } \ 223 } while (0) 224 #else /* SIZEOF_DATUM != 8 */ 225 226 #define store_att_byval(T,newdatum,attlen) \ 227 do { \ 228 switch (attlen) \ 229 { \ 230 case sizeof(char): \ 231 *(char *) (T) = DatumGetChar(newdatum); \ 232 break; \ 233 case sizeof(int16): \ 234 *(int16 *) (T) = DatumGetInt16(newdatum); \ 235 break; \ 236 case sizeof(int32): \ 237 *(int32 *) (T) = DatumGetInt32(newdatum); \ 238 break; \ 239 default: \ 240 elog(ERROR, "unsupported byval length: %d", \ 241 (int) (attlen)); \ 242 break; \ 243 } \ 244 } while (0) 245 #endif /* SIZEOF_DATUM == 8 */ 246 247 #endif 248