Speedup an array selectivity estimation.

Cache statistics during an array selectivity estimation due to repetative
Var op Const estimations. Reduce cycles to detoast and unpack statistics,
especially big ones like histogram  or MCV arrays.

Reuse memory allocated for array's element selectivity estimation.
Remember, we have a community's patch & thread about selectivity memory
context. But for now it is hard to say how quickly it can be pushed.
So, use simple hack now. It saves almost 50% of allocated memory in the case
labelled as 'SHRDM-3141'.

Author: danolivo

src/backend/utils/adt/selfuncs.c

@@ -1930,6 +1930,8 @@ scalararraysel(PlannerInfo *root,
 		Datum	   *elem_values;
 		bool	   *elem_nulls;
 		int			i;
+		List	   *args;
+		Const	   *c;
 
 		if (arrayisnull)		/* qual can't succeed if null array */
 			return (Selectivity) 0.0;
@@ -1957,48 +1959,56 @@ scalararraysel(PlannerInfo *root,
 		 */
 		s1 = s1disjoint = (useOr ? 0.0 : 1.0);
 
-		for (i = 0; i < num_elems; i++)
-		{
-			List	   *args;
-			Selectivity s2;
+		set_attstatsslot_cache_mode(true);
 
-			args = list_make2(leftop,
-							  makeConst(nominal_element_type,
-										-1,
-										nominal_element_collation,
-										elmlen,
-										elem_values[i],
-										elem_nulls[i],
-										elmbyval));
-			if (is_join_clause)
-				s2 = DatumGetFloat8(FunctionCall5Coll(&oprselproc,
-													  clause->inputcollid,
-													  PointerGetDatum(root),
-													  ObjectIdGetDatum(operator),
-													  PointerGetDatum(args),
-													  Int16GetDatum(jointype),
-													  PointerGetDatum(sjinfo)));
-			else
-				s2 = DatumGetFloat8(FunctionCall4Coll(&oprselproc,
-													  clause->inputcollid,
-													  PointerGetDatum(root),
-													  ObjectIdGetDatum(operator),
-													  PointerGetDatum(args),
-													  Int32GetDatum(varRelid)));
+		c = makeConst(nominal_element_type, -1, nominal_element_collation,
+					  elmlen, (Datum) 0, true, elmbyval);
+		args = list_make2(leftop, c);
 
-			if (useOr)
-			{
-				s1 = s1 + s2 - s1 * s2;
-				if (isEquality)
-					s1disjoint += s2;
-			}
-			else
+		PG_TRY();
+		{
+			for (i = 0; i < num_elems; i++)
 			{
-				s1 = s1 * s2;
-				if (isInequality)
-					s1disjoint += s2 - 1.0;
+				Selectivity s2;
+
+				c->constvalue = elem_values[i];
+				c->constisnull = elem_nulls[i];
+
+				if (is_join_clause)
+					s2 = DatumGetFloat8(FunctionCall5Coll(&oprselproc,
+														  clause->inputcollid,
+														  PointerGetDatum(root),
+														  ObjectIdGetDatum(operator),
+														  PointerGetDatum(args),
+														  Int16GetDatum(jointype),
+														  PointerGetDatum(sjinfo)));
+				else
+					s2 = DatumGetFloat8(FunctionCall4Coll(&oprselproc,
+														  clause->inputcollid,
+														  PointerGetDatum(root),
+														  ObjectIdGetDatum(operator),
+														  PointerGetDatum(args),
+														  Int32GetDatum(varRelid)));
+
+				if (useOr)
+				{
+					s1 = s1 + s2 - s1 * s2;
+					if (isEquality)
+						s1disjoint += s2;
+				}
+				else
+				{
+					s1 = s1 * s2;
+					if (isInequality)
+						s1disjoint += s2 - 1.0;
+				}
 			}
 		}
+		PG_FINALLY();
+		{
+			set_attstatsslot_cache_mode(false);
+		}
+		PG_END_TRY();
 
 		/* accept disjoint-probability estimate if in range */
 		if ((useOr ? isEquality : isInequality) &&
@@ -2053,6 +2063,8 @@ scalararraysel(PlannerInfo *root,
 													  PointerGetDatum(args),
 													  Int32GetDatum(varRelid)));
 
+			pfree(args);
+
 			if (useOr)
 			{
 				s1 = s1 + s2 - s1 * s2;

src/backend/utils/cache/lsyscache.c

@@ -44,6 +44,7 @@
 #include "utils/builtins.h"
 #include "utils/catcache.h"
 #include "utils/datum.h"
+#include "utils/inval.h"
 #include "utils/fmgroids.h"
 #include "utils/lsyscache.h"
 #include "utils/syscache.h"
@@ -3180,6 +3181,137 @@ get_attavgwidth(Oid relid, AttrNumber attnum)
 	return 0;
 }
 
+typedef struct AttStatSlotHashKey
+{
+	Oid relid;
+	int attnum;
+	int reqkind;
+	Oid reqop;
+	int flags;
+} AttStatSlotHashKey;
+
+typedef struct AttStatSlotHashEntry
+{
+	AttStatSlotHashKey	key;
+	AttStatsSlot	   sslot;
+} AttStatSlotHashEntry;
+
+static bool attstatsslot_needs_cache = false;
+static HTAB *slot_htab = NULL;
+
+void
+set_attstatsslot_cache_mode(bool need_cache)
+{
+	/* It should be a usage error or a bug */
+	Assert(!(need_cache && attstatsslot_needs_cache));
+
+	if (!attstatsslot_needs_cache && !need_cache)
+		/* Nothing to do */
+		return;
+
+	attstatsslot_needs_cache = need_cache;
+
+	if (!need_cache && slot_htab != NULL &&
+		hash_get_num_entries(slot_htab) > 0)
+	{
+		HASH_SEQ_STATUS	hash_seq;
+		AttStatSlotHashEntry *entry;
+
+		/*
+		 * It seems we have only few entries here. So, instead of removing the
+		 * whole table, just remove entries one-by-one.
+		 */
+
+		hash_seq_init(&hash_seq, slot_htab);
+		while ((entry = hash_seq_search(&hash_seq)) != NULL)
+		{
+			bool found;
+
+			free_attstatsslot(&entry->sslot);
+
+			(void) hash_search(slot_htab, &entry->key, HASH_REMOVE, &found);
+
+			if (!found)
+				elog(PANIC, "Hash table is corrupted");
+		}
+	}
+}
+
+static void
+cache_attstatslot(AttStatsSlot *sslot,
+				  Oid relid, int attnum, int reqkind, Oid reqop, int flags)
+{
+	AttStatSlotHashEntry *entry;
+	AttStatSlotHashKey key = {.relid = relid, .attnum = attnum,
+							  .reqkind = reqkind, .reqop = reqop,
+							  .flags = flags};
+	bool found;
+
+	entry = hash_search(slot_htab, &key, HASH_ENTER, &found);
+	Assert(!found);
+
+	memcpy(&entry->sslot, sslot, sizeof(AttStatsSlot));
+}
+
+static void
+AttStatSlotCacheCallback(Datum arg, int cacheid, uint32 hashvalue)
+{
+	HASH_SEQ_STATUS			status;
+	AttStatSlotHashEntry   *entry;
+
+	if (slot_htab == NULL)
+		return;
+
+	/* Currently we just flush all entries; hard to be smarter ... */
+	hash_seq_init(&status, slot_htab);
+
+	while ((entry = (AttStatSlotHashEntry *) hash_seq_search(&status)) != NULL)
+	{
+		free_attstatsslot(&entry->sslot);
+
+		if (hash_search(slot_htab,
+						&entry->key,
+						HASH_REMOVE, NULL) == NULL)
+			elog(ERROR, "hash table corrupted");
+	}
+}
+
+static bool
+get_cached_attstatslot(AttStatsSlot *sslot,
+					   Oid relid, int attnum, int reqkind, Oid reqop, int flags)
+{
+	AttStatSlotHashEntry *entry;
+	AttStatSlotHashKey key = {.relid = relid, .attnum = attnum,
+							  .reqkind = reqkind, .reqop = reqop,
+							  .flags = flags};
+	bool found;
+
+	if (slot_htab == NULL)
+	{
+		HASHCTL		ctl;
+
+		ctl.keysize = sizeof(AttStatSlotHashKey);
+		ctl.entrysize = sizeof(AttStatSlotHashEntry);
+
+		slot_htab = hash_create("AttStatSlot hash", 16, &ctl,
+								HASH_ELEM | HASH_BLOBS);
+
+		/* To stay consistent clear the cache on demand */
+		CacheRegisterSyscacheCallback(STATRELATTINH,
+									  AttStatSlotCacheCallback, (Datum) 0);
+	}
+
+	entry = hash_search(slot_htab, &key, HASH_FIND, &found);
+
+	if (found)
+	{
+		memcpy(sslot, &entry->sslot, sizeof(AttStatsSlot));
+		return true;
+	}
+
+	return false;
+}
+
 /*
  * get_attstatsslot
  *
@@ -3246,6 +3378,12 @@ get_attstatsslot(AttStatsSlot *sslot, HeapTuple statstuple,
 	/* initialize *sslot properly */
 	memset(sslot, 0, sizeof(AttStatsSlot));
 
+	/* Try to return cached statistics */
+	if (attstatsslot_needs_cache &&
+		get_cached_attstatslot(sslot, stats->starelid,
+							   stats->staattnum, reqkind, reqop, flags))
+		return true;
+
 	for (i = 0; i < STATISTIC_NUM_SLOTS; i++)
 	{
 		if ((&stats->stakind1)[i] == reqkind &&
@@ -3333,6 +3471,10 @@ get_attstatsslot(AttStatsSlot *sslot, HeapTuple statstuple,
 		sslot->numbers_arr = statarray;
 	}
 
+	if (attstatsslot_needs_cache)
+		cache_attstatslot(sslot, stats->starelid,
+						  stats->staattnum, reqkind, reqop, flags);
+
 	return true;
 }
 
@@ -3343,6 +3485,9 @@ get_attstatsslot(AttStatsSlot *sslot, HeapTuple statstuple,
 void
 free_attstatsslot(AttStatsSlot *sslot)
 {
+	if (attstatsslot_needs_cache)
+		return;
+
 	/* The values[] array was separately palloc'd by deconstruct_array */
 	if (sslot->values)
 		pfree(sslot->values);

src/include/utils/lsyscache.h

@@ -188,6 +188,7 @@ extern Oid	getBaseType(Oid typid);
 extern Oid	getBaseTypeAndTypmod(Oid typid, int32 *typmod);
 extern int32 get_typavgwidth(Oid typid, int32 typmod);
 extern int32 get_attavgwidth(Oid relid, AttrNumber attnum);
+extern void set_attstatsslot_cache_mode(bool need_cache);
 extern bool get_attstatsslot(AttStatsSlot *sslot, HeapTuple statstuple,
 							 int reqkind, Oid reqop, int flags);
 extern void free_attstatsslot(AttStatsSlot *sslot);