Optimize operator expression construction

This commit aims to add a cache to avoid multiple calls to
GetDefaultOpClass. The call leads to s_lock to be called more than %70
with concurrent connections over 256. Caching is applied to
baseConstraint of partition columns on the tables.

prune_shard_list.c

@@ -39,6 +39,15 @@
 #include "utils/errcodes.h"
 #include "utils/lsyscache.h"
 #include "utils/typcache.h"
+#include "utils/memutils.h"
+
+
+/*
+ * BaseConstraintCache is used for caching base constraints for partition
+ * columns of distributed tables. It is initialized to empty list as
+ * there are no items in the cache.
+ */
+static List *BaseConstraintCache = NIL;
 
 
 /* local function forward declarations */
@@ -51,6 +60,7 @@ static Const * MakeInt4Constant(Datum constantValue);
 static OpExpr * MakeHashedOperatorExpression(OpExpr *operatorExpression);
 static OpExpr * MakeOpExpressionWithZeroConst(void);
 static List * BuildRestrictInfoList(List *qualList);
+static Node * LookupBaseConstraint(Var *column);
 static Node * BuildBaseConstraint(Var *column);
 static void UpdateConstraint(Node *baseConstraint, ShardInterval *shardInterval);
 
@@ -90,8 +100,8 @@ PruneShardList(Oid relationId, List *whereClauseList, List *shardIntervalList)
 		partitionColumn = MakeInt4Column();
 	}
 
-	/* build the base expression for constraint */
-	baseConstraint = BuildBaseConstraint(partitionColumn);
+	/* lookup the base expression for constraint */
+	baseConstraint = LookupBaseConstraint(partitionColumn);
 
 	/* walk over shard list and check if shards can be pruned */
 	foreach(shardIntervalCell, shardIntervalList)
@@ -144,6 +154,63 @@ BuildRestrictInfoList(List *qualList)
 }
 
 
+/*
+ * LookupBaseConstraint is wrapper around BuildBaseConstraint that uses a
+ * cache to avoid multiple times to create the base constraint within a single
+ * session. This function never returns NULL.
+ */
+static Node *
+LookupBaseConstraint(Var *partitionColumn)
+{
+	Oid partitionColumnVarType = partitionColumn->vartype;
+	BaseConstraintCacheEntry *matchingCacheEntry = NULL;
+	ListCell *cacheEntryCell = NULL;
+
+	/* search the cache */
+	foreach(cacheEntryCell, BaseConstraintCache)
+	{
+		BaseConstraintCacheEntry *cacheEntry = lfirst(cacheEntryCell);
+		if (cacheEntry->columnVarType == partitionColumnVarType)
+		{
+			matchingCacheEntry = cacheEntry;
+			break;
+		}
+	}
+
+	/* if not found in the cache, build the base constraint and put it in cache */
+	if (matchingCacheEntry == NULL)
+	{
+		Node *builtBaseConstraint = NULL;
+		MemoryContext oldContext = MemoryContextSwitchTo(CacheMemoryContext);
+
+		/*
+		 * Explicitly create partition column variable in CacheMemoryContext. It is
+		 * critical because partitionColumn variable is created in MessageContext
+		 * and will be freed when MessageContext is reseted. However, we need partition
+		 * column variable in a longer context, which is CacheMemoryContext.
+		 */
+		Var *partitionColumnInCacheMemory = makeVar(partitionColumn->varno,
+													partitionColumn->varattno,
+													partitionColumn->vartype,
+													partitionColumn->vartypmod,
+													partitionColumn->varcollid,
+													partitionColumn->varlevelsup);
+
+		builtBaseConstraint = BuildBaseConstraint(partitionColumnInCacheMemory);
+
+		matchingCacheEntry = palloc0(sizeof(BaseConstraintCacheEntry));
+		matchingCacheEntry->columnVarType = partitionColumnVarType;
+		matchingCacheEntry->baseConstraint = builtBaseConstraint;
+
+		BaseConstraintCache = lappend(BaseConstraintCache, matchingCacheEntry);
+
+		MemoryContextSwitchTo(oldContext);
+	}
+
+	return matchingCacheEntry->baseConstraint;
+}
+
+
 /*
  * BuildBaseConstraint builds and returns a base constraint. This constraint
  * implements an expression in the form of (column <= max && column >= min),

prune_shard_list.h

@@ -31,6 +31,17 @@
 #define RESERVED_HASHED_COLUMN_ID MaxAttrNumber
 
 
+/*
+ * BaseConstraintCacheEntry contains the information for a cache entry in
+ * base constraint cache.
+ */
+typedef struct BaseConstraintCacheEntry
+{
+	Oid columnVarType;	/* cache key */
+	Node *baseConstraint;
+} BaseConstraintCacheEntry;
+
+
 /* function declarations for shard pruning */
 extern List * PruneShardList(Oid relationId, List *whereClauseList,
 							 List *shardIntervalList);