Bugfix. AQO plan node must have reasonable set of serialization routines: it is used during plan transfer to parallel workers. Another options/extensions can require correct serialization too.

Author: danolivo

aqo.h

@@ -284,7 +284,6 @@ void aqo_ExecutorEnd(QueryDesc *queryDesc);
 extern void automatical_query_tuning(uint64 query_hash, struct StatEntry *stat);
 
 /* Utilities */
-extern int int64_compare(const void *a, const void *b);
 extern int int_cmp(const void *a, const void *b);
 extern int double_cmp(const void *a, const void *b);
 extern int *argsort(void *a, int n, size_t es,

cardinality_estimation.c

@@ -103,6 +103,7 @@ predict_for_relation(List *clauses, List *selectivities, List *relsigns,
 			result = OkNNr_predict(data, features);
 		}
 	}
+
 #ifdef AQO_DEBUG_PRINT
 	predict_debug_output(clauses, selectivities, relsigns, *fss, result);
 #endif

hash.c

@@ -33,7 +33,7 @@ static int	get_node_hash(Node *node);
 static int	get_unsorted_unsafe_int_array_hash(int *arr, int len);
 static int	get_unordered_int_list_hash(List *lst);
 
-static int64 get_relations_hash(List *relsigns);
+static int get_relations_hash(List *relsigns);
 static int get_fss_hash(int clauses_hash, int eclasses_hash,
 			 int relidslist_hash);
 
@@ -278,7 +278,7 @@ get_fss_for_object(List *relsigns, List *clauselist,
 
 	clauses_hash = get_int_array_hash(sorted_clauses, n - sh);
 	eclasses_hash = get_int_array_hash(eclass_hash, nargs);
-	relations_hash = (int) get_relations_hash(relsigns);
+	relations_hash = get_relations_hash(relsigns);
 	fss_hash = get_fss_hash(clauses_hash, eclasses_hash, relations_hash);
 
 	MemoryContextSwitchTo(old_ctx_m);
@@ -449,26 +449,26 @@ get_fss_hash(int clauses_hash, int eclasses_hash, int relidslist_hash)
  * Hash is supposed to be relations-order-insensitive.
  * Each element of a list must have a String type,
  */
-static int64
+static int
 get_relations_hash(List *relsigns)
 {
 	int			nhashes = 0;
-	int64	   *hashes = palloc(list_length(relsigns) * sizeof(uint64));
+	uint32	   *hashes = palloc(list_length(relsigns) * sizeof(uint32));
 	ListCell   *lc;
-	int64		result;
+	int			result;
 
 	foreach(lc, relsigns)
 	{
-		hashes[nhashes++] = *(int64 *) lfirst(lc);
+		hashes[nhashes++] = (uint32) lfirst_int(lc);
 	}
 
 	/* Sort the array to make query insensitive to input order of relations. */
-	qsort(hashes, nhashes, sizeof(int64), int64_compare);
+	qsort(hashes, nhashes, sizeof(uint32), int_cmp);
 
 	/* Make a final hash value */
 
-	result = DatumGetInt64(hash_any_extended((const unsigned char *) hashes,
-										   nhashes * sizeof(int64), 0));
+	result = DatumGetInt32(hash_any((const unsigned char *) hashes,
+									nhashes * sizeof(uint32)));
 
 	return result;
 }

path_utils.c

@@ -130,22 +130,22 @@ get_selectivities(PlannerInfo *root,
 /*
  * Based on the hashTupleDesc() routine
  */
-static uint64
+static uint32
 hashTempTupleDesc(TupleDesc desc)
 {
-	uint64		s;
+	uint32		s;
 	int			i;
 
 	s = hash_combine(0, hash_uint32(desc->natts));
 
 	for (i = 0; i < desc->natts; ++i)
 	{
 		const char *attname = NameStr(TupleDescAttr(desc, i)->attname);
-		uint64		s1;
+		uint32		s1;
 
-		s = hash_combine64(s, hash_uint32(TupleDescAttr(desc, i)->atttypid));
-		s1 = hash_bytes_extended((const unsigned char *) attname, strlen(attname), 0);
-		s = hash_combine64(s, s1);
+		s = hash_combine(s, hash_uint32(TupleDescAttr(desc, i)->atttypid));
+		s1 = hash_bytes((const unsigned char *) attname, strlen(attname));
+		s = hash_combine(s, s1);
 	}
 	return s;
 }
@@ -181,8 +181,8 @@ get_list_of_relids(PlannerInfo *root, Relids relids, RelSortOut *rels)
 
 		if (!OidIsValid(entry->relid))
 		{
-			/* Invalid oid */
-			hashes = lappend_uint64(hashes, (UINT64_MAX / 7));
+			/* TODO: Explain this logic. */
+			hashes = lappend_int(hashes, INT32_MAX / 3);
 			continue;
 		}
 
@@ -207,7 +207,7 @@ get_list_of_relids(PlannerInfo *root, Relids relids, RelSortOut *rels)
 			trel = relation_open(entry->relid, NoLock);
 			tdesc = RelationGetDescr(trel);
 			Assert(CheckRelationLockedByMe(trel, AccessShareLock, true));
-			hashes = lappend_uint64(hashes, hashTempTupleDesc(tdesc));
+			hashes = lappend_int(hashes, hashTempTupleDesc(tdesc));
 			relation_close(trel, NoLock);
 		}
 		else
@@ -217,9 +217,9 @@ get_list_of_relids(PlannerInfo *root, Relids relids, RelSortOut *rels)
 						get_namespace_name(get_rel_namespace(entry->relid)),
 							relrewrite ? get_rel_name(relrewrite) : relname);
 
-			hashes = lappend_uint64(hashes, DatumGetInt64(hash_any_extended(
+			hashes = lappend_int(hashes, DatumGetInt32(hash_any(
 											(unsigned char *) relname,
-											strlen(relname), 0)));
+											strlen(relname))));
 
 			hrels = lappend_oid(hrels, entry->relid);
 		}
@@ -569,7 +569,7 @@ AQOnodeCopy(struct ExtensibleNode *enew, const struct ExtensibleNode *eold)
 	/* These lists couldn't contain AQO nodes. Use basic machinery */
 	new->rels = palloc(sizeof(RelSortOut));
 	new->rels->hrels = list_copy(old->rels->hrels);
-	new->rels->signatures = list_copy_uint64(old->rels->signatures);
+	new->rels->signatures = list_copy(old->rels->signatures);
 
 	new->clauses = copyObject(old->clauses);
 	new->grouping_exprs = copyObject(old->grouping_exprs);
@@ -604,21 +604,24 @@ AQOnodeEqual(const struct ExtensibleNode *a, const struct ExtensibleNode *b)
 #define WRITE_FLOAT_FIELD(fldname,format) \
 	appendStringInfo(str, " :" CppAsString(fldname) " " format, node->fldname)
 
+/*
+ * Serialize AQO plan node to a string.
+ *
+ * Right now we can't correctly serialize all fields of the node. Taking into
+ * account that this action needed when a plan moves into parallel workers or
+ * just during debugging, we serialize it only partially, just for debug
+ * purposes.
+ * Some extensions may manipulate by parts of serialized plan too.
+ */
 static void
 AQOnodeOut(struct StringInfoData *str, const struct ExtensibleNode *enode)
 {
 	AQOPlanNode *node = (AQOPlanNode *) enode;
 
-	Assert(0);
-	WRITE_BOOL_FIELD(had_path);
-	WRITE_NODE_FIELD(rels);
-	WRITE_NODE_FIELD(clauses);
-	WRITE_NODE_FIELD(selectivities);
-	WRITE_NODE_FIELD(grouping_exprs);
-
-	WRITE_ENUM_FIELD(jointype, JoinType);
-	WRITE_FLOAT_FIELD(parallel_divisor, "%.5f");
-	WRITE_BOOL_FIELD(was_parametrized);
+	node->had_path = false;
+	node->jointype = 0;
+	node->parallel_divisor = 1.0;
+	node->was_parametrized = false;
 
 	/* For Adaptive optimization DEBUG purposes */
 	WRITE_INT_FIELD(fss);
@@ -655,24 +658,28 @@ AQOnodeOut(struct StringInfoData *str, const struct ExtensibleNode *enode)
 	(void) token;				/* in case not used elsewhere */ \
 	local_node->fldname = nodeRead(NULL, 0)
 
+/*
+ * Deserialize AQO plan node from a string to internal representation.
+ *
+ * Should work in coherence with AQOnodeOut().
+ */
 static void
 AQOnodeRead(struct ExtensibleNode *enode)
 {
 	AQOPlanNode *local_node = (AQOPlanNode *) enode;
 	const char	*token;
 	int			length;
 
-	Assert(0);
 	READ_BOOL_FIELD(had_path);
-	READ_NODE_FIELD(rels);
-	READ_NODE_FIELD(clauses);
-	READ_NODE_FIELD(selectivities);
-	READ_NODE_FIELD(grouping_exprs);
-
 	READ_ENUM_FIELD(jointype, JoinType);
 	READ_FLOAT_FIELD(parallel_divisor);
 	READ_BOOL_FIELD(was_parametrized);
 
+	local_node->rels = palloc0(sizeof(RelSortOut));
+	local_node->clauses = NIL;
+	local_node->selectivities = NIL;
+	local_node->grouping_exprs = NIL;
+
 	/* For Adaptive optimization DEBUG purposes */
 	READ_INT_FIELD(fss);
 	READ_FLOAT_FIELD(prediction);

utils.c

@@ -28,18 +28,6 @@ static int	argsort_cmp(const void *a, const void *b);
  * qsort comparator functions
  */
 
-/* int64 comparator for pg_qsort. */
-int
-int64_compare(const void *va, const void *vb)
-{
-	int64 a = *((const int64 *) va);
-	int64 b = *((const int64 *) vb);
-
-	if (a == b)
-		return 0;
-	return (a > b) ? 1 : -1;
-}
-
 /*
  * Function for qsorting an integer arrays
  */