text: /*-------------------------------------------------------------------------
   *
   * tupmacs.h
   *	  Tuple macros used by both index tuples and heap tuples.
   *
   *
   * Portions Copyright (c) 1996-2021, PostgreSQL Global Development Group
   * Portions Copyright (c) 1994, Regents of the University of California
   *
   * src/include/access/tupmacs.h
   *
   *-------------------------------------------------------------------------
   */
  #ifndef TUPMACS_H
  #define TUPMACS_H
  
  #include "catalog/pg_type_d.h"	/* for TYPALIGN macros */
  
  
  /*
   * Check a tuple's null bitmap to determine whether the attribute is null.
   * Note that a 0 in the null bitmap indicates a null, while 1 indicates
   * non-null.
   */
  #define att_isnull(ATT, BITS) (!((BITS)[(ATT) >> 3] & (1 << ((ATT) & 0x07))))
  
  /*
   * Given a Form_pg_attribute and a pointer into a tuple's data area,
   * return the correct value or pointer.
   *
   * We return a Datum value in all cases.  If the attribute has "byval" false,
   * we return the same pointer into the tuple data area that we're passed.
   * Otherwise, we return the correct number of bytes fetched from the data
   * area and extended to Datum form.
   *
   * On machines where Datum is 8 bytes, we support fetching 8-byte byval
   * attributes; otherwise, only 1, 2, and 4-byte values are supported.
   *
   * Note that T must already be properly aligned for this to work correctly.
   *
   * A 是 tupleDesc.
   */
  #define fetchatt(A,T) fetch_att(T, (A)->attbyval, (A)->attlen)
  
  /*
   * Same, but work from byval/len parameters rather than Form_pg_attribute.
   */
  #if SIZEOF_DATUM == 8
  
  //! 如果 attlen == sizeof(Datum), 返回一个内存 Datum.
  //! 否则, get i32/i16
  #define fetch_att(T,attbyval,attlen) \
  ( \
  	(attbyval) ? \
  	( \
  		(attlen) == (int) sizeof(Datum) ? \
  			*((Datum *)(T)) \
  		: \
  	  ( \
  		(attlen) == (int) sizeof(int32) ? \
  			Int32GetDatum(*((int32 *)(T))) \
  		: \
  		( \
  			(attlen) == (int) sizeof(int16) ? \
  				Int16GetDatum(*((int16 *)(T))) \
  			: \
  			( \
  				AssertMacro((attlen) == 1), \
  				CharGetDatum(*((char *)(T))) \
  			) \
  		) \
  	  ) \
  	) \
  	: \
  	PointerGetDatum((char *) (T)) \
  )
  #else							/* SIZEOF_DATUM != 8 */
  
  #define fetch_att(T,attbyval,attlen) \
  ( \
  	(attbyval) ? \
  	( \
  		(attlen) == (int) sizeof(int32) ? \
  			Int32GetDatum(*((int32 *)(T))) \
  		: \
  		( \
  			(attlen) == (int) sizeof(int16) ? \
  				Int16GetDatum(*((int16 *)(T))) \
  			: \
  			( \
  				AssertMacro((attlen) == 1), \
  				CharGetDatum(*((char *)(T))) \
  			) \
  		) \
  	) \
  	: \
  	PointerGetDatum((char *) (T)) \
  )
  #endif							/* SIZEOF_DATUM == 8 */
  
  /*
   * att_align_datum aligns the given offset as needed for a datum of alignment
   * requirement attalign and typlen attlen.  attdatum is the Datum variable
   * we intend to pack into a tuple (it's only accessed if we are dealing with
   * a varlena type).  Note that this assumes the Datum will be stored as-is;
   * callers that are intending to convert non-short varlena datums to short
   * format have to account for that themselves.
   */
  #define att_align_datum(cur_offset, attalign, attlen, attdatum) \
  ( \
  	((attlen) == -1 && VARATT_IS_SHORT(DatumGetPointer(attdatum))) ? \
  	(uintptr_t) (cur_offset) : \
  	att_align_nominal(cur_offset, attalign) \
  )
  
  /*
   * att_align_pointer performs the same calculation as att_align_datum,
   * but is used when walking a tuple.  attptr is the current actual data
   * pointer; when accessing a varlena field we have to "peek" to see if we
   * are looking at a pad byte or the first byte of a 1-byte-header datum.
   * (A zero byte must be either a pad byte, or the first byte of a correctly
   * aligned 4-byte length word; in either case we can align safely.  A non-zero
   * byte must be either a 1-byte length word, or the first byte of a correctly
   * aligned 4-byte length word; in either case we need not align.)
   *
   * Note: some callers pass a "char *" pointer for cur_offset.  This is
   * a bit of a hack but should work all right as long as uintptr_t is the
   * correct width.
   */
  #define att_align_pointer(cur_offset, attalign, attlen, attptr) \
  ( \
  	((attlen) == -1 && VARATT_NOT_PAD_BYTE(attptr)) ? \
  	(uintptr_t) (cur_offset) : \
  	att_align_nominal(cur_offset, attalign) \
  )
  
  /*
   * att_align_nominal aligns the given offset as needed for a datum of alignment
   * requirement attalign, ignoring any consideration of packed varlena datums.
   * There are three main use cases for using this macro directly:
   *	* we know that the att in question is not varlena (attlen != -1);
   *	  in this case it is cheaper than the above macros and just as good.
   *	* we need to estimate alignment padding cost abstractly, ie without
   *	  reference to a real tuple.  We must assume the worst case that
   *	  all varlenas are aligned.
   *	* within arrays and multiranges, we unconditionally align varlenas (XXX this
   *	  should be revisited, probably).
   *
   * The attalign cases are tested in what is hopefully something like their
   * frequency of occurrence.
   */
  #define att_align_nominal(cur_offset, attalign) \
  ( \
  	((attalign) == TYPALIGN_INT) ? INTALIGN(cur_offset) : \
  	 (((attalign) == TYPALIGN_CHAR) ? (uintptr_t) (cur_offset) : \
  	  (((attalign) == TYPALIGN_DOUBLE) ? DOUBLEALIGN(cur_offset) : \
  	   ( \
  			AssertMacro((attalign) == TYPALIGN_SHORT), \
  			SHORTALIGN(cur_offset) \
  	   ))) \
  )
  
  /*
   * att_addlength_datum increments the given offset by the space needed for
   * the given Datum variable.  attdatum is only accessed if we are dealing
   * with a variable-length attribute.
   */
  #define att_addlength_datum(cur_offset, attlen, attdatum) \
  	att_addlength_pointer(cur_offset, attlen, DatumGetPointer(attdatum))
  
  /*
   * att_addlength_pointer performs the same calculation as att_addlength_datum,
   * but is used when walking a tuple --- attptr is the pointer to the field
   * within the tuple.
   *
   * Note: some callers pass a "char *" pointer for cur_offset.  This is
   * actually perfectly OK, but probably should be cleaned up along with
   * the same practice for att_align_pointer.
   */
  #define att_addlength_pointer(cur_offset, attlen, attptr) \
  ( \
  	((attlen) > 0) ? \
  	( \
  		(cur_offset) + (attlen) \
  	) \
  	: (((attlen) == -1) ? \
  	( \
  		(cur_offset) + VARSIZE_ANY(attptr) \
  	) \
  	: \
  	( \
  		AssertMacro((attlen) == -2), \
  		(cur_offset) + (strlen((char *) (attptr)) + 1) \
  	)) \
  )
  
  /*
   * store_att_byval is a partial inverse of fetch_att: store a given Datum
   * value into a tuple data area at the specified address.  However, it only
   * handles the byval case, because in typical usage the caller needs to
   * distinguish by-val and by-ref cases anyway, and so a do-it-all macro
   * wouldn't be convenient.
   */
  #if SIZEOF_DATUM == 8
  
  #define store_att_byval(T,newdatum,attlen) \
  	do { \
  		switch (attlen) \
  		{ \
  			case sizeof(char): \
  				*(char *) (T) = DatumGetChar(newdatum); \
  				break; \
  			case sizeof(int16): \
  				*(int16 *) (T) = DatumGetInt16(newdatum); \
  				break; \
  			case sizeof(int32): \
  				*(int32 *) (T) = DatumGetInt32(newdatum); \
  				break; \
  			case sizeof(Datum): \
  				*(Datum *) (T) = (newdatum); \
  				break; \
  			default: \
  				elog(ERROR, "unsupported byval length: %d", \
  					 (int) (attlen)); \
  				break; \
  		} \
  	} while (0)
  #else							/* SIZEOF_DATUM != 8 */
  
  #define store_att_byval(T,newdatum,attlen) \
  	do { \
  		switch (attlen) \
  		{ \
  			case sizeof(char): \
  				*(char *) (T) = DatumGetChar(newdatum); \
  				break; \
  			case sizeof(int16): \
  				*(int16 *) (T) = DatumGetInt16(newdatum); \
  				break; \
  			case sizeof(int32): \
  				*(int32 *) (T) = DatumGetInt32(newdatum); \
  				break; \
  			default: \
  				elog(ERROR, "unsupported byval length: %d", \
  					 (int) (attlen)); \
  				break; \
  		} \
  	} while (0)
  #endif							/* SIZEOF_DATUM == 8 */
  
  #endif
  