Don't cast between GinNullCategory and bool

petere · petere · commit 438036264a3b · 2018-01-02T12:20:56.000-05:00
The original idea was that we could use an isNull-style bool array
directly as a GinNullCategory array.  However, the existing code already
acknowledges that that doesn't really work, because of the possibility
that bool as currently defined can have arbitrary bit patterns for true
values.  So it has to loop through the nullFlags array to set each bool
value to an acceptable value.  But if we are looping through the whole
array anyway, we might as well build a proper GinNullCategory array
instead and abandon the type casting.  That makes the code much safer in
case bool is ever changed to something else.

Reviewed-by: Michael Paquier &lt;michael.paquier@gmail.com&gt;
diff --git a/src/backend/access/gin/ginscan.c b/src/backend/access/gin/ginscan.c
@@ -295,6 +295,7 @@ ginNewScanKey(IndexScanDesc scan)
 		bool	   *partial_matches = NULL;
 		Pointer    *extra_data = NULL;
 		bool	   *nullFlags = NULL;
+		GinNullCategory *categories;
 		int32		searchMode = GIN_SEARCH_MODE_DEFAULT;
 
 		/*
@@ -346,33 +347,29 @@ ginNewScanKey(IndexScanDesc scan)
 		}
 
 		/*
-		 * If the extractQueryFn didn't create a nullFlags array, create one,
-		 * assuming that everything's non-null.  Otherwise, run through the
-		 * array and make sure each value is exactly 0 or 1; this ensures
-		 * binary compatibility with the GinNullCategory representation. While
-		 * at it, detect whether any null keys are present.
+		 * Create GinNullCategory representation.  If the extractQueryFn
+		 * didn't create a nullFlags array, we assume everything is non-null.
+		 * While at it, detect whether any null keys are present.
 		 */
-		if (nullFlags == NULL)
-			nullFlags = (bool *) palloc0(nQueryValues * sizeof(bool));
-		else
+		categories = (GinNullCategory *) palloc0(nQueryValues * sizeof(GinNullCategory));
+		if (nullFlags)
 		{
 			int32		j;
 
 			for (j = 0; j < nQueryValues; j++)
 			{
 				if (nullFlags[j])
 				{
-					nullFlags[j] = true;	/* not any other nonzero value */
+					categories[j] = GIN_CAT_NULL_KEY;
 					hasNullQuery = true;
 				}
 			}
 		}
-		/* now we can use the nullFlags as category codes */
 
 		ginFillScanKey(so, skey->sk_attno,
 					   skey->sk_strategy, searchMode,
 					   skey->sk_argument, nQueryValues,
-					   queryValues, (GinNullCategory *) nullFlags,
+					   queryValues, categories,
 					   partial_matches, extra_data);
 	}
 
diff --git a/src/backend/access/gin/ginutil.c b/src/backend/access/gin/ginutil.c
@@ -529,19 +529,10 @@ ginExtractEntries(GinState *ginstate, OffsetNumber attnum,
 
 	/*
 	 * If the extractValueFn didn't create a nullFlags array, create one,
-	 * assuming that everything's non-null.  Otherwise, run through the array
-	 * and make sure each value is exactly 0 or 1; this ensures binary
-	 * compatibility with the GinNullCategory representation.
+	 * assuming that everything's non-null.
 	 */
 	if (nullFlags == NULL)
 		nullFlags = (bool *) palloc0(*nentries * sizeof(bool));
-	else
-	{
-		for (i = 0; i < *nentries; i++)
-			nullFlags[i] = (nullFlags[i] ? true : false);
-	}
-	/* now we can use the nullFlags as category codes */
-	*categories = (GinNullCategory *) nullFlags;
 
 	/*
 	 * If there's more than one key, sort and unique-ify.
@@ -600,6 +591,13 @@ ginExtractEntries(GinState *ginstate, OffsetNumber attnum,
 		pfree(keydata);
 	}
 
+	/*
+	 * Create GinNullCategory representation from nullFlags.
+	 */
+	*categories = (GinNullCategory *) palloc0(*nentries * sizeof(GinNullCategory));
+	for (i = 0; i < *nentries; i++)
+		(*categories)[i] = (nullFlags[i] ? GIN_CAT_NULL_KEY : GIN_CAT_NORM_KEY);
+
 	return entries;
 }
 
diff --git a/src/include/access/ginblock.h b/src/include/access/ginblock.h
@@ -188,8 +188,11 @@ typedef struct
 
 /*
  * Category codes to distinguish placeholder nulls from ordinary NULL keys.
- * Note that the datatype size and the first two code values are chosen to be
- * compatible with the usual usage of bool isNull flags.
+ *
+ * The first two code values were chosen to be compatible with the usual usage
+ * of bool isNull flags.  However, casting between bool and GinNullCategory is
+ * risky because of the possibility of different bit patterns and type sizes,
+ * so it is no longer done.
  *
  * GIN_CAT_EMPTY_QUERY is never stored in the index; and notice that it is
  * chosen to sort before not after regular key values.

Original file line number	Diff line number	Diff line change
`@@ -295,6 +295,7 @@ ginNewScanKey(IndexScanDesc scan)`
`295`	`295`	`bool *partial_matches = NULL;`
`296`	`296`	`Pointer *extra_data = NULL;`
`297`	`297`	`bool *nullFlags = NULL;`
	`298`	`+ GinNullCategory *categories;`
`298`	`299`	`int32 searchMode = GIN_SEARCH_MODE_DEFAULT;`
`299`	`300`
`300`	`301`	`/*`
`@@ -346,33 +347,29 @@ ginNewScanKey(IndexScanDesc scan)`
`346`	`347`	`}`
`347`	`348`
`348`	`349`	`/*`
`349`		`- * If the extractQueryFn didn't create a nullFlags array, create one,`
`350`		`- * assuming that everything's non-null. Otherwise, run through the`
`351`		`- * array and make sure each value is exactly 0 or 1; this ensures`
`352`		`- * binary compatibility with the GinNullCategory representation. While`
`353`		`- * at it, detect whether any null keys are present.`
	`350`	`+ * Create GinNullCategory representation. If the extractQueryFn`
	`351`	`+ * didn't create a nullFlags array, we assume everything is non-null.`
	`352`	`+ * While at it, detect whether any null keys are present.`
`354`	`353`	`*/`
`355`		`- if (nullFlags == NULL)`
`356`		`- nullFlags = (bool ) palloc0(nQueryValues sizeof(bool));`
`357`		`- else`
	`354`	`+ categories = (GinNullCategory ) palloc0(nQueryValues sizeof(GinNullCategory));`
	`355`	`+ if (nullFlags)`
`358`	`356`	`{`
`359`	`357`	`int32 j;`
`360`	`358`
`361`	`359`	`for (j = 0; j < nQueryValues; j++)`
`362`	`360`	`{`
`363`	`361`	`if (nullFlags[j])`
`364`	`362`	`{`
`365`		`- nullFlags[j] = true; /* not any other nonzero value */`
	`363`	`+ categories[j] = GIN_CAT_NULL_KEY;`
`366`	`364`	`hasNullQuery = true;`
`367`	`365`	`}`
`368`	`366`	`}`
`369`	`367`	`}`
`370`		`- /* now we can use the nullFlags as category codes */`
`371`	`368`
`372`	`369`	`ginFillScanKey(so, skey->sk_attno,`
`373`	`370`	`skey->sk_strategy, searchMode,`
`374`	`371`	`skey->sk_argument, nQueryValues,`
`375`		`- queryValues, (GinNullCategory *) nullFlags,`
	`372`	`+ queryValues, categories,`
`376`	`373`	`partial_matches, extra_data);`
`377`	`374`	`}`
`378`	`375`