Make hashjoin give the right answer with toasted input data.

diff --git a/src/backend/executor/nodeHash.c b/src/backend/executor/nodeHash.c
index b8cee44fbdf4d4630845b1ceb6d3b50ea87f0e89..f387e5a759fa3dda995660138b355ce7297b0745 100644 (file)
--- a/src/backend/executor/nodeHash.c
+++ b/src/backend/executor/nodeHash.c
@@ -7,7 +7,7 @@
  * Portions Copyright (c) 1994, Regents of the University of California
  *
  *
- *     $Id: nodeHash.c,v 1.58 2001/06/11 00:17:07 tgl Exp $
+ *     $Id: nodeHash.c,v 1.59 2001/08/13 19:50:11 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -533,19 +533,23 @@ ExecHashGetBucket(HashJoinTable hashtable,
        int                     bucketno;
        Datum           keyval;
        bool            isNull;
+       MemoryContext oldContext;
 
        /*
-        * Get the join attribute value of the tuple
-        *
-        * We reset the eval context each time to avoid any possibility of memory
-        * leaks in the hash function.
+        * We reset the eval context each time to reclaim any memory leaked
+        * in the hashkey expression or hashFunc itself.
         */
        ResetExprContext(econtext);
 
-       keyval = ExecEvalExprSwitchContext(hashkey, econtext, &isNull, NULL);
+       oldContext = MemoryContextSwitchTo(econtext->ecxt_per_tuple_memory);
 
        /*
-        * compute the hash function
+        * Get the join attribute value of the tuple
+        */
+       keyval = ExecEvalExpr(hashkey, econtext, &isNull, NULL);
+
+       /*
+        * Compute the hash function
         */
        if (isNull)
                bucketno = 0;
@@ -564,6 +568,8 @@ ExecHashGetBucket(HashJoinTable hashtable,
                printf("hash(%ld) = %d\n", (long) keyval, bucketno);
 #endif
 
+       MemoryContextSwitchTo(oldContext);
+
        return bucketno;
 }
 
@@ -624,17 +630,18 @@ ExecScanHashBucket(HashJoinState *hjstate,
  *             hashFunc
  *
  *             the hash function, copied from Margo
+ *
+ *             XXX this probably ought to be replaced with datatype-specific
+ *             hash functions, such as those already implemented for hash indexes.
  * ----------------------------------------------------------------
  */
 static int
 hashFunc(Datum key, int len, bool byVal)
 {
        unsigned int h = 0;
-       unsigned char *k;
 
        if (byVal)
        {
-
                /*
                 * If it's a by-value data type, use the 'len' least significant
                 * bytes of the Datum value.  This should do the right thing on
@@ -649,22 +656,29 @@ hashFunc(Datum key, int len, bool byVal)
        }
        else
        {
-
                /*
-                * If this is a variable length type, then 'k' points to a "struct
-                * varlena" and len == -1. NOTE: VARSIZE returns the "real" data
+                * If this is a variable length type, then 'key' points to a "struct
+                * varlena" and len == -1.  NOTE: VARSIZE returns the "real" data
                 * length plus the sizeof the "vl_len" attribute of varlena (the
-                * length information). 'k' points to the beginning of the varlena
+                * length information). 'key' points to the beginning of the varlena
                 * struct, so we have to use "VARDATA" to find the beginning of
-                * the "real" data.
+                * the "real" data.  Also, we have to be careful to detoast the
+                * datum if it's toasted.  (We don't worry about freeing the detoasted
+                * copy; that happens for free when the per-tuple memory context
+                * is reset in ExecHashGetBucket.)
                 */
-               if (len == -1)
+               unsigned char *k;
+
+               if (len < 0)
                {
-                       len = VARSIZE(key) - VARHDRSZ;
-                       k = (unsigned char *) VARDATA(key);
+                       struct varlena *vkey = PG_DETOAST_DATUM(key);
+
+                       len = VARSIZE(vkey) - VARHDRSZ;
+                       k = (unsigned char *) VARDATA(vkey);
                }
                else
-                       k = (unsigned char *) key;
+                       k = (unsigned char *) DatumGetPointer(key);
+
                while (len-- > 0)
                        h = (h * PRIME1) ^ (*k++);
        }