Postgresql源码（58）元组拼接heap_form_tuple剖析

typedef struct HeapTupleData
{
	uint32		t_len;			/* length of *t_data */
	ItemPointerData t_self;		/* SelfItemPointer */
	Oid			t_tableOid;		/* table the tuple came from */
	HeapTupleHeader t_data;		/* -> tuple header and data */
} HeapTupleData;

drop table t21;
create table t21(i1 int, v10 varchar(10), n1 numeric, c2 char(2), t1 text);
insert into t21 values (1, 'mylen=7', 5.5, '22', 'hi12345');

HeapTuple
heap_form_tuple(TupleDesc tupleDescriptor, Datum *values, bool *isnull)

(gdb) p *tupleDescriptor
$9 = {natts = 5, tdtypeid = 2249, tdtypmod = -1, tdrefcount = -1, constr = 0x0, attrs = 0x199ce90}
(gdb) p values[0]
$11 = 1            ： int的值
(gdb) p values[1]
$12 = 27157600     ： datum数据指针
(gdb) p values[2]
$13 = 27153160     ： datum数据指针
(gdb) p values[3]
$14 = 27158432     ： datum数据指针
(gdb) p values[4]
$15 = 27154592     ： datum数据指针
(gdb) p isnull[0] 
$17 = false
(gdb) p isnull[1]
$18 = false
(gdb) p isnull[2]
$19 = false
(gdb) p isnull[3]
$20 = false
(gdb) p isnull[4]
$21 = false

heap_form_tuple
...
    len = offsetof(HeapTupleHeaderData, t_bits)        ： 计算出头的大小len = 23，t_bits是柔性数组指针
    hoff = len = MAXALIGN(len);                        ： 对齐hoff = len = 24
    data_len = heap_compute_data_size(...)             ： 计算出数据需要的长度见3.3，共data_len = 30字节
    len += data_len;                                   ： len = 24 + 30 = 54

    tuple = (HeapTuple) palloc0(HEAPTUPLESIZE + len)   ： 申请HeapTupleData + HeapTupleHeaderData + 数据30字节
    tuple->t_data = td = (HeapTupleHeader) ((char *) tuple + HEAPTUPLESIZE)
                                                       ： t_data指向的是HeapTupleData后，HeapTupleHeaderData头的位置
    ...
    // 配置tuple的值
    ...
    heap_fill_tuple                                    ： 根据数据类型开始添加数据，见3.4

drop table t21;
create table t21(i1 int, v10 varchar(10), n1 numeric, c2 char(2), t1 text);
insert into t21 values (1, 'mylen=7', 5.5, '22', 'hi12345');

		if (ATT_IS_PACKABLE(atti) &&
			VARATT_CAN_MAKE_SHORT(DatumGetPointer(val)))
		{
			/*
			 * we're anticipating converting to a short varlena header, so
			 * adjust length and don't count any alignment
			 */
			data_length += VARATT_CONVERTED_SHORT_SIZE(DatumGetPointer(val));
		}
		else if (atti->attlen == -1 &&
				 VARATT_IS_EXTERNAL_EXPANDED(DatumGetPointer(val)))
		{
			/*
			 * we want to flatten the expanded value so that the constructed
			 * tuple doesn't depend on it
			 */
			data_length = att_align_nominal(data_length, atti->attalign);
			data_length += EOH_get_flat_size(DatumGetEOHP(val));
		}
		else
		{
			data_length = att_align_datum(data_length, atti->attalign,
										  atti->attlen, val);
			data_length = att_addlength_datum(data_length, atti->attlen,
											  val);
		}

(gdb) p atti->attlen
$30 = 4
(gdb) p atti->attstorage
$31 = 112 'p'

// 第一步：对齐data_length=0，对齐后还是0
			data_length = att_align_datum(data_length, atti->attalign,
										  atti->attlen, val);
// 第二步：加上长度atti->attlen，data_length=4
			data_length = att_addlength_datum(data_length, atti->attlen,
											  val);

(gdb) p atti->attlen
$38 = -1
(gdb) p atti->attstorage
$39 = 120 'x'

// 能1B就能装下了， 后面会把4B转成1B头，这里按1B计算长度即可
data_length += VARATT_CONVERTED_SHORT_SIZE(DatumGetPointer(val))

heap_fill_tuple
  for (i = 0; i < numberOfAttributes; i++)
    fill_val(...)  

    if (att->attbyval)
	{
		/* pass-by-value */
		data = (char *) att_align_nominal(data, att->attalign);
		store_att_byval(data, datum, att->attlen);
		data_length = att->attlen;
	}
	else if (att->attlen == -1)
	{
		/* varlena */
		Pointer		val = DatumGetPointer(datum);

		*infomask |= HEAP_HASVARWIDTH;
		if (VARATT_IS_EXTERNAL(val))
		{
			if (VARATT_IS_EXTERNAL_EXPANDED(val))
			{
				/*
				 * we want to flatten the expanded value so that the
				 * constructed tuple doesn't depend on it
				 */
				ExpandedObjectHeader *eoh = DatumGetEOHP(datum);

				data = (char *) att_align_nominal(data,
												  att->attalign);
				data_length = EOH_get_flat_size(eoh);
				EOH_flatten_into(eoh, data, data_length);
			}
			else
			{
				*infomask |= HEAP_HASEXTERNAL;
				/* no alignment, since it's short by definition */
				data_length = VARSIZE_EXTERNAL(val);
				memcpy(data, val, data_length);
			}
		}
		else if (VARATT_IS_SHORT(val))
		{
			/* no alignment for short varlenas */
			data_length = VARSIZE_SHORT(val);
			memcpy(data, val, data_length);
		}
		else if (VARLENA_ATT_IS_PACKABLE(att) &&
				 VARATT_CAN_MAKE_SHORT(val))
		{
			/* convert to short varlena -- no alignment */
			data_length = VARATT_CONVERTED_SHORT_SIZE(val);
			SET_VARSIZE_SHORT(data, data_length);
			memcpy(data + 1, VARDATA(val), data_length - 1);
		}
		else
		{
			/* full 4-byte header varlena */
			data = (char *) att_align_nominal(data,
											  att->attalign);
			data_length = VARSIZE(val);
			memcpy(data, val, data_length);
		}
	}
	else if (att->attlen == -2)
	{
		/* cstring ... never needs alignment */
		*infomask |= HEAP_HASVARWIDTH;
		Assert(att->attalign == TYPALIGN_CHAR);
		data_length = strlen(DatumGetCString(datum)) + 1;
		memcpy(data, DatumGetPointer(datum), data_length);
	}
	else
	{
		/* fixed-length pass-by-reference */
		data = (char *) att_align_nominal(data, att->attalign);
		Assert(att->attlen > 0);
		data_length = att->attlen;
		memcpy(data, DatumGetPointer(datum), data_length);
	}