Default Toaster using Custom TOAST Pointers

Default Toaster changed to use Custom TOAST Pointes instead of External
to make it fully compliant to TOAST API. Backward compatibility is preserved
by allowing Default Toaster to read old (External) TOAST Pointers, but save
TOASTed data as new Custom TOAST Pointer.

Author: Teodor Sigaev <teodor@sigaev.ru>
Author: Oleg Bartunov <obartunov@postgrespro.ru>
Author: Nikita Glukhov <n.gluhov@postgrespro.ru>
Author: Nikita Malakhov <n.malakhov@postgrespro.ru>

Author: Nikita Malakhov

src/backend/access/common/heaptuple.c

@@ -243,6 +243,9 @@ fill_val(Form_pg_attribute att,
 			{
 				*infomask |= HEAP_HASEXTERNAL;
 				/* no alignment, since it's short by definition */
+				if (VARATT_IS_CUSTOM(val))
+					data = (char *) att_align_nominal(data,
+													  att->attalign);
 				data_length = VARSIZE_EXTERNAL(val);
 				memcpy(data, val, data_length);
 			}

src/backend/access/common/toast_internals.c

@@ -19,6 +19,7 @@
 #include "access/heaptoast.h"
 #include "access/table.h"
 #include "access/toast_internals.h"
+#include "access/generic_toaster.h"
 #include "catalog/toasting.h"
 #include "access/xact.h"
 #include "catalog/catalog.h"
@@ -165,9 +166,22 @@ toast_save_datum_ext(Relation rel, Oid toasterid, Datum value,
 		{
 			struct varatt_external old_toast_pointer;
 
-			Assert(VARATT_IS_EXTERNAL_ONDISK(oldexternal));
+			/* New case - Generic TOAST working with Custom pointer */
+			if(VARATT_IS_CUSTOM(oldexternal))
+			{
+				ExternalToastData data;
+				VARATT_CUSTOM_GET_EXTERNAL_DATA(PointerGetDatum(oldexternal), data);
+				old_toast_pointer.va_toastrelid = get_uint32align16(&data.va_toastrelid);
+				old_toast_pointer.va_valueid = get_uint32align16(&data.va_valueid);
+			}
+			else
+			{
+				Assert(VARATT_IS_EXTERNAL_ONDISK(oldexternal));
+				VARATT_EXTERNAL_GET_POINTER(old_toast_pointer, oldexternal);
+			}
 			/* Must copy to access aligned fields */
-			VARATT_EXTERNAL_GET_POINTER(old_toast_pointer, oldexternal);
+			/* VARATT_EXTERNAL_GET_POINTER(old_toast_pointer, oldexternal); */
+			/* XXX if (old_toast_pointer.va_toastrelid == rel->rd_toastoid) */
 			if (old_toast_pointer.va_toastrelid == real_toastrelid)
 			{
 				/* This value came from the old toast table; reuse its OID */
@@ -265,17 +279,34 @@ toast_delete_datum(Datum value, bool is_speculative)
 	int			num_indexes;
 	int			validIndex;
 	SnapshotData SnapshotToast;
+	ExternalToastData data;
+	Oid va_toastrelid;
+	Oid va_valueid;
 
-	if (!VARATT_IS_EXTERNAL_ONDISK(attr))
+	if (!VARATT_IS_EXTERNAL_ONDISK(attr) && !VARATT_IS_CUSTOM(attr))
 		return;
 
 	/* Must copy to access aligned fields */
-	VARATT_EXTERNAL_GET_POINTER(toast_pointer, attr);
+	if(VARATT_IS_CUSTOM(attr))
+	{
+		/* process custom Toast Pointer */
+		VARATT_CUSTOM_GET_EXTERNAL_DATA(attr, data);
+
+		va_toastrelid = get_uint32align16(&data.va_toastrelid);
+		va_valueid = get_uint32align16(&data.va_valueid);
+	}
+	else
+	{
+		VARATT_EXTERNAL_GET_POINTER(toast_pointer, attr);
+
+		va_toastrelid = toast_pointer.va_toastrelid;
+		va_valueid = toast_pointer.va_valueid;
+	}
 
 	/*
 	 * Open the toast relation and its indexes
 	 */
-	toastrel = table_open(toast_pointer.va_toastrelid, RowExclusiveLock);
+	toastrel = table_open(va_toastrelid, RowExclusiveLock);
 
 	/* Fetch valid relation used for process */
 	validIndex = toast_open_indexes(toastrel,
@@ -289,7 +320,7 @@ toast_delete_datum(Datum value, bool is_speculative)
 	ScanKeyInit(&toastkey,
 				(AttrNumber) 1,
 				BTEqualStrategyNumber, F_OIDEQ,
-				ObjectIdGetDatum(toast_pointer.va_valueid));
+				ObjectIdGetDatum(va_valueid));
 
 	/*
 	 * Find all the chunks.  (We don't actually care whether we see them in
@@ -405,19 +436,43 @@ toast_fetch_datum(struct varlena *attr)
 	Relation	toastrel;
 	struct varlena *result;
 	struct varatt_external toast_pointer;
+	ExternalToastData data;
+	Oid va_toastrelid;
+	Oid va_valueid;
 	int32		attrsize;
+	bool		is_compressed = false;
 
-	if (!VARATT_IS_EXTERNAL_ONDISK(attr))
-		elog(ERROR, "toast_fetch_datum shouldn't be called for non-ondisk datums");
+	if (!VARATT_IS_EXTERNAL_ONDISK(attr) && !VARATT_IS_CUSTOM(attr))
+		elog(ERROR, "toast_fetch_datum_slice shouldn't be called for non-ondisk or non-custom datums");
 
 	/* Must copy to access aligned fields */
-	VARATT_EXTERNAL_GET_POINTER(toast_pointer, attr);
+	if(VARATT_IS_CUSTOM(attr))
+	{
+		/* process custom Toast Pointer */
+		VARATT_CUSTOM_GET_EXTERNAL_DATA(attr, data);
+
+		attrsize = get_uint32align16(&data.va_extinfo);
+		va_toastrelid = get_uint32align16(&data.va_toastrelid);
+		va_valueid = get_uint32align16(&data.va_valueid);
+
+		if (VARATT_CUSTOM_EXTERNAL_IS_COMPRESSED(attr, attrsize))
+			is_compressed = true;
+	}
+	else
+	{
+		VARATT_EXTERNAL_GET_POINTER(toast_pointer, attr);
 
-	attrsize = VARATT_EXTERNAL_GET_EXTSIZE(toast_pointer);
+		va_toastrelid = toast_pointer.va_toastrelid;
+		va_valueid = toast_pointer.va_valueid;
+
+		attrsize = VARATT_EXTERNAL_GET_EXTSIZE(toast_pointer);
+		if (VARATT_EXTERNAL_IS_COMPRESSED(toast_pointer))
+			is_compressed = true;
+	}
 
 	result = (struct varlena *) palloc(attrsize + VARHDRSZ);
 
-	if (VARATT_EXTERNAL_IS_COMPRESSED(toast_pointer))
+	if (is_compressed)
 		SET_VARSIZE_COMPRESSED(result, attrsize + VARHDRSZ);
 	else
 		SET_VARSIZE(result, attrsize + VARHDRSZ);
@@ -429,10 +484,10 @@ toast_fetch_datum(struct varlena *attr)
 	/*
 	 * Open the toast relation and its indexes
 	 */
-	toastrel = table_open(toast_pointer.va_toastrelid, AccessShareLock);
+	toastrel = table_open(va_toastrelid, AccessShareLock);
 
 	/* Fetch all chunks */
-	toast_fetch_toast_slice(toastrel, toast_pointer.va_valueid,
+	toast_fetch_toast_slice(toastrel, va_valueid,
 							attr, attrsize, 0, attrsize, result, 0,
 							NULL, NULL);
 
@@ -460,22 +515,47 @@ toast_fetch_datum_slice(struct varlena *attr, int32 sliceoffset,
 	Relation	toastrel;
 	struct varlena *result;
 	struct varatt_external toast_pointer;
+	ExternalToastData data;
+	Oid va_toastrelid;
+	Oid va_valueid;
 	int32		attrsize;
+	bool		is_compressed = false;
 
-	if (!VARATT_IS_EXTERNAL_ONDISK(attr))
-		elog(ERROR, "toast_fetch_datum_slice shouldn't be called for non-ondisk datums");
+	if (!(VARATT_IS_EXTERNAL_ONDISK(attr) || VARATT_IS_CUSTOM(attr)))
+		elog(ERROR, "toast_fetch_datum_slice shouldn't be called for non-ondisk or non-custom datums");
 
 	/* Must copy to access aligned fields */
-	VARATT_EXTERNAL_GET_POINTER(toast_pointer, attr);
+	if(VARATT_IS_CUSTOM(attr))
+	{
+		/* process custom Toast Pointer */
+		VARATT_CUSTOM_GET_EXTERNAL_DATA(attr, data);
 
-	/*
-	 * It's nonsense to fetch slices of a compressed datum unless when it's a
-	 * prefix -- this isn't lo_* we can't return a compressed datum which is
-	 * meaningful to toast later.
-	 */
-	Assert(!VARATT_EXTERNAL_IS_COMPRESSED(toast_pointer) || 0 == sliceoffset);
+		attrsize = get_uint32align16(&data.va_extinfo);
+		va_toastrelid = get_uint32align16(&data.va_toastrelid);
+		va_valueid = get_uint32align16(&data.va_valueid);
+
+		if (VARATT_CUSTOM_EXTERNAL_IS_COMPRESSED(attr, attrsize) && slicelength > 0)
+			is_compressed = true;
+	}
+	else
+	{
+		VARATT_EXTERNAL_GET_POINTER(toast_pointer, attr);
+
+		va_toastrelid = toast_pointer.va_toastrelid;
+		va_valueid = toast_pointer.va_valueid;
+
+		/*
+		 * It's nonsense to fetch slices of a compressed datum unless when it's a
+	 	 * prefix -- this isn't lo_* we can't return a compressed datum which is
+	 	 * meaningful to toast later.
+	 	 */
+		Assert(!VARATT_EXTERNAL_IS_COMPRESSED(toast_pointer) || 0 == sliceoffset);
+
+		attrsize = VARATT_EXTERNAL_GET_EXTSIZE(toast_pointer);
+		if (VARATT_EXTERNAL_IS_COMPRESSED(toast_pointer) && slicelength > 0)
+			is_compressed = true;
+	}
 
-	attrsize = VARATT_EXTERNAL_GET_EXTSIZE(toast_pointer);
 
 	if (sliceoffset >= attrsize)
 	{
@@ -488,7 +568,8 @@ toast_fetch_datum_slice(struct varlena *attr, int32 sliceoffset,
 	 * space required by va_tcinfo, which is stored at the beginning as an
 	 * int32 value.
 	 */
-	if (VARATT_EXTERNAL_IS_COMPRESSED(toast_pointer) && slicelength > 0)
+	/* if (VARATT_EXTERNAL_IS_COMPRESSED(toast_pointer) && slicelength > 0) */
+	if(is_compressed)
 		slicelength = slicelength + sizeof(int32);
 
 	/*
@@ -501,7 +582,7 @@ toast_fetch_datum_slice(struct varlena *attr, int32 sliceoffset,
 
 	result = (struct varlena *) palloc(slicelength + VARHDRSZ);
 
-	if (VARATT_EXTERNAL_IS_COMPRESSED(toast_pointer))
+	if(is_compressed)
 		SET_VARSIZE_COMPRESSED(result, slicelength + VARHDRSZ);
 	else
 		SET_VARSIZE(result, slicelength + VARHDRSZ);
@@ -510,10 +591,10 @@ toast_fetch_datum_slice(struct varlena *attr, int32 sliceoffset,
 		return result;			/* Can save a lot of work at this point! */
 
 	/* Open the toast relation */
-	toastrel = table_open(toast_pointer.va_toastrelid, AccessShareLock);
+	toastrel = table_open(va_toastrelid, AccessShareLock);
 
 	/* Fetch all chunks */
-	toast_fetch_toast_slice(toastrel, toast_pointer.va_valueid,
+	toast_fetch_toast_slice(toastrel, va_valueid,
 							attr, attrsize, sliceoffset, slicelength,
 							result, 0, NULL, NULL);
 

src/backend/access/toast/generic_toaster.c

@@ -50,13 +50,40 @@
 #include "access/genam.h"
 #include "access/toast_helper.h"
 #include "utils/fmgroids.h"
+#include "utils/memutils.h"
 #include "access/generic_toaster.h"
 #include "access/toast_compression.h"
 #include "replication/reorderbuffer.h"
 
 /*
  * Callback function signatures --- see toaster.sgml for more info.
  */
+static struct varlena *
+generic_toast_make_pointer(Oid toasterid, struct varatt_external *ptr)
+{
+	Size		size = VARATT_CUSTOM_EXTERNAL_SIZE;
+	struct varlena *result = palloc(size);
+	ExternalToastData result_data;
+
+	SET_VARTAG_EXTERNAL(result, VARTAG_CUSTOM);
+
+	if (ptr->va_rawsize > MaxAllocSize)
+		ereport(ERROR,
+				(errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
+				 errmsg("atribute length too large")));
+
+	VARATT_CUSTOM_SET_TOASTERID(result, toasterid);
+	VARATT_CUSTOM_SET_DATA_RAW_SIZE(result, ptr->va_rawsize);
+	VARATT_CUSTOM_SET_DATA_SIZE(result, VARATT_CUSTOM_EXTERNAL_HDRSZ);
+
+	set_uint32align16(&result_data.va_extinfo, VARATT_EXTERNAL_GET_EXTSIZE(*ptr)); //->va_extinfo);
+	set_uint32align16(&result_data.va_toastrelid, ptr->va_toastrelid);
+	set_uint32align16(&result_data.va_valueid, ptr->va_valueid);
+
+	memcpy(VARATT_CUSTOM_GET_DATA(result), &result_data, VARATT_CUSTOM_EXTERNAL_HDRSZ);
+
+	return result;
+}
 
 /*
  * Init function. Creates Toast table for Toasted data storage
@@ -78,14 +105,25 @@ static Datum
 generic_toast(Relation toast_rel, Oid toasterid, Datum value, Datum oldvalue,
 			 int max_inline_size, int options)
 {
-	Datum result;
+	Datum		detoasted_newval;
+	Datum		toasted_newval;
+	struct varatt_external toast_ptr;
 
 	Assert(toast_rel != NULL);
+	detoasted_newval = PointerGetDatum(detoast_attr((struct varlena *) value));
+	toasted_newval = toast_save_datum_ext(toast_rel, toasterid, detoasted_newval,
+					  (struct varlena *) DatumGetPointer(oldvalue), options,
+					  NULL, 0);
 
-	result = toast_save_datum(toast_rel, toasterid, value,
-				 (struct varlena *) DatumGetPointer(oldvalue),
-				 options);
-	return result;
+	/*
+	 * Custom Toast Pointers differ from regular, this assertion will fail for Custom
+	 * Assert(VARATT_IS_EXTERNAL_ONDISK(toasted_newval));
+	 */
+	VARATT_EXTERNAL_GET_POINTER(toast_ptr, DatumGetPointer(toasted_newval));
+
+	pfree(DatumGetPointer(toasted_newval));
+
+	return PointerGetDatum(generic_toast_make_pointer(toasterid, &toast_ptr));
 }
 
 /*
@@ -96,21 +134,31 @@ static Datum
 generic_detoast(Datum toast_ptr, int offset, int length)
 {
 	struct varlena *result = 0;
-	struct varlena *tvalue = (struct varlena*)DatumGetPointer(toast_ptr);
 	struct varatt_external toast_pointer;
+	ExternalToastData data;
+	int32			toasted_size;
+	struct varlena *tvalue = (struct varlena*)DatumGetPointer(toast_ptr);;
 
-	VARATT_EXTERNAL_GET_POINTER(toast_pointer, tvalue);
+	if( VARATT_IS_CUSTOM( tvalue ) )
+	{
+		VARATT_CUSTOM_GET_EXTERNAL_DATA(toast_ptr, data);
+		toasted_size = get_uint32align16(&data.va_extinfo);
+	}
+	else
+	{
+		VARATT_EXTERNAL_GET_POINTER(toast_pointer, tvalue);
+		toasted_size = VARATT_EXTERNAL_GET_EXTSIZE(toast_pointer);
+	}
 	if(offset == 0
-	   && (length < 0 || length >= VARATT_EXTERNAL_GET_EXTSIZE(toast_pointer)))
+   	   && (length < 0 || length >= toasted_size))
 	{
 		result = toast_fetch_datum(tvalue);
 	}
 	else
 	{
 		result = toast_fetch_datum_slice(tvalue,
-						offset, length);
+			 offset, length);
 	}
-
 	return PointerGetDatum(result);
 }
 
@@ -163,11 +211,22 @@ DetoastIterator
 create_detoast_iterator(struct varlena *attr)
 {
 	struct varatt_external toast_pointer;
+	ExternalToastData data;
 	DetoastIterator iter;
-	if (VARATT_IS_EXTERNAL_ONDISK(attr))
+
+	if (VARATT_IS_EXTERNAL_ONDISK(attr) || VARATT_IS_CUSTOM( attr ))
 	{
 		FetchDatumIterator fetch_iter;
 
+		if(VARATT_IS_CUSTOM( attr ))
+		{
+			VARATT_CUSTOM_GET_EXTERNAL_DATA(PointerGetDatum(attr), data);
+			toast_pointer.va_extinfo = get_uint32align16(&data.va_extinfo);
+			toast_pointer.va_toastrelid = get_uint32align16(&data.va_toastrelid);
+			toast_pointer.va_valueid = get_uint32align16(&data.va_valueid);
+			toast_pointer.va_rawsize = get_uint32align16(&data.va_extinfo) + VARATT_CUSTOM_EXTERNAL_HDRSZ;
+		}
+
 		iter = (DetoastIterator) palloc0(sizeof(DetoastIteratorData));
 		iter->done = false;
 		iter->nrefs = 1;
@@ -176,7 +235,7 @@ create_detoast_iterator(struct varlena *attr)
 		/* This is an externally stored datum --- initialize fetch datum iterator */
 		iter->fetch_datum_iterator = fetch_iter = create_fetch_datum_iterator(attr);
 		VARATT_EXTERNAL_GET_POINTER(toast_pointer, attr);
-		if (VARATT_EXTERNAL_IS_COMPRESSED(toast_pointer))
+		if (!VARATT_IS_CUSTOM( attr ) && VARATT_EXTERNAL_IS_COMPRESSED(toast_pointer))
 		{
 			iter->compressed = true;
 			iter->compression_method = VARATT_EXTERNAL_GET_COMPRESS_METHOD(toast_pointer);
@@ -619,7 +678,7 @@ generic_toaster_vtable(Datum toast_ptr)
 
 struct varlena *
 generic_toaster_reconstruct(Relation toastrel, struct varlena *varlena,
-                                HTAB *toast_hash)
+                            HTAB *toast_hash)
 {
        struct varatt_external toast_pointer;
        struct varlena *reconstructed;