Dodge a macro-name conflict with Perl.

Some versions of Perl export a macro named HS_KEY.  This creates a
conflict in contrib/hstore_plperl against hstore's macro of the same
name.  The most future-proof solution seems to be to rename our macro;
I chose HSTORE_KEY.  For consistency, rename HS_VAL and related macros
similarly.

Back-patch to 9.5.  contrib/hstore_plperl doesn't exist before that
so there is no need to worry about the conflict in older releases.

Per reports from Marco Atzeri and Mike Blackwell.

diff --git a/contrib/hstore/hstore.h b/contrib/hstore/hstore.h
index f9088f8b1b6c43510e751b8341816e9c69352e99..6bab08b7de0b8028f416b1a38ff6a495d0b12a88 100644 (file)
--- a/contrib/hstore/hstore.h
+++ b/contrib/hstore/hstore.h
@@ -76,11 +76,11 @@ typedef struct
 #define STRPTR(x)      ( (char*)(ARRPTR(x) + HS_COUNT((HStore*)(x)) * 2) )
 
 /* note multiple/non evaluations */
-#define HS_KEY(arr_,str_,i_) ((str_) + HSE_OFF((arr_)[2*(i_)]))
-#define HS_VAL(arr_,str_,i_) ((str_) + HSE_OFF((arr_)[2*(i_)+1]))
-#define HS_KEYLEN(arr_,i_) (HSE_LEN((arr_)[2*(i_)]))
-#define HS_VALLEN(arr_,i_) (HSE_LEN((arr_)[2*(i_)+1]))
-#define HS_VALISNULL(arr_,i_) (HSE_ISNULL((arr_)[2*(i_)+1]))
+#define HSTORE_KEY(arr_,str_,i_)   ((str_) + HSE_OFF((arr_)[2*(i_)]))
+#define HSTORE_VAL(arr_,str_,i_)   ((str_) + HSE_OFF((arr_)[2*(i_)+1]))
+#define HSTORE_KEYLEN(arr_,i_)     (HSE_LEN((arr_)[2*(i_)]))
+#define HSTORE_VALLEN(arr_,i_)     (HSE_LEN((arr_)[2*(i_)+1]))
+#define HSTORE_VALISNULL(arr_,i_)  (HSE_ISNULL((arr_)[2*(i_)+1]))
 
 /*
  * currently, these following macros are the _only_ places that rely

diff --git a/contrib/hstore/hstore_compat.c b/contrib/hstore/hstore_compat.c
index 6364f032f98bac8bb8a2cabb20bf6c530ecc5183..b95ce9b4aaa8ab2bbaed137db1d3afe9945d1342 100644 (file)
--- a/contrib/hstore/hstore_compat.c
+++ b/contrib/hstore/hstore_compat.c
@@ -149,7 +149,7 @@ hstoreValidNewFormat(HStore *hs)
 
    for (i = 1; i < count; ++i)
    {
-       if (HS_KEYLEN(entries, i) < HS_KEYLEN(entries, i - 1))
+       if (HSTORE_KEYLEN(entries, i) < HSTORE_KEYLEN(entries, i - 1))
            return 0;
        if (HSE_ISNULL(entries[2 * i]))
            return 0;

diff --git a/contrib/hstore/hstore_gin.c b/contrib/hstore/hstore_gin.c
index 919181d375e40371b9f03615c79153bb311c6c62..d98fb3845833d280f56069b4dcbf11e78e79a002 100644 (file)
--- a/contrib/hstore/hstore_gin.c
+++ b/contrib/hstore/hstore_gin.c
@@ -59,14 +59,16 @@ gin_extract_hstore(PG_FUNCTION_ARGS)
    {
        text       *item;
 
-       item = makeitem(HS_KEY(hsent, ptr, i), HS_KEYLEN(hsent, i),
+       item = makeitem(HSTORE_KEY(hsent, ptr, i),
+                       HSTORE_KEYLEN(hsent, i),
                        KEYFLAG);
        entries[2 * i] = PointerGetDatum(item);
 
-       if (HS_VALISNULL(hsent, i))
+       if (HSTORE_VALISNULL(hsent, i))
            item = makeitem(NULL, 0, NULLFLAG);
        else
-           item = makeitem(HS_VAL(hsent, ptr, i), HS_VALLEN(hsent, i),
+           item = makeitem(HSTORE_VAL(hsent, ptr, i),
+                           HSTORE_VALLEN(hsent, i),
                            VALFLAG);
        entries[2 * i + 1] = PointerGetDatum(item);
    }

diff --git a/contrib/hstore/hstore_gist.c b/contrib/hstore/hstore_gist.c
index 0fb769de7da38c2e84dab89204170a0e5ebb1398..f8f5934e404e803eab2ac0aa1e82c984610b892e 100644 (file)
--- a/contrib/hstore/hstore_gist.c
+++ b/contrib/hstore/hstore_gist.c
@@ -129,11 +129,13 @@ ghstore_compress(PG_FUNCTION_ARGS)
        {
            int         h;
 
-           h = crc32_sz((char *) HS_KEY(hsent, ptr, i), HS_KEYLEN(hsent, i));
+           h = crc32_sz((char *) HSTORE_KEY(hsent, ptr, i),
+                        HSTORE_KEYLEN(hsent, i));
            HASH(GETSIGN(res), h);
-           if (!HS_VALISNULL(hsent, i))
+           if (!HSTORE_VALISNULL(hsent, i))
            {
-               h = crc32_sz((char *) HS_VAL(hsent, ptr, i), HS_VALLEN(hsent, i));
+               h = crc32_sz((char *) HSTORE_VAL(hsent, ptr, i),
+                            HSTORE_VALLEN(hsent, i));
                HASH(GETSIGN(res), h);
            }
        }
@@ -524,13 +526,15 @@ ghstore_consistent(PG_FUNCTION_ARGS)
 
        for (i = 0; res && i < count; ++i)
        {
-           int         crc = crc32_sz((char *) HS_KEY(qe, qv, i), HS_KEYLEN(qe, i));
+           int         crc = crc32_sz((char *) HSTORE_KEY(qe, qv, i),
+                                      HSTORE_KEYLEN(qe, i));
 
            if (GETBIT(sign, HASHVAL(crc)))
            {
-               if (!HS_VALISNULL(qe, i))
+               if (!HSTORE_VALISNULL(qe, i))
                {
-                   crc = crc32_sz((char *) HS_VAL(qe, qv, i), HS_VALLEN(qe, i));
+                   crc = crc32_sz((char *) HSTORE_VAL(qe, qv, i),
+                                  HSTORE_VALLEN(qe, i));
                    if (!GETBIT(sign, HASHVAL(crc)))
                        res = false;
                }

diff --git a/contrib/hstore/hstore_io.c b/contrib/hstore/hstore_io.c
index 7d8986708fd7aeb56058326ac7a4b25b09874adf..aa7b7e1b3ef1c7f5c1974ab572146458593ff976 100644 (file)
--- a/contrib/hstore/hstore_io.c
+++ b/contrib/hstore/hstore_io.c
@@ -1068,7 +1068,7 @@ hstore_populate_record(PG_FUNCTION_ARGS)
            column_info->column_type = column_type;
        }
 
-       if (idx < 0 || HS_VALISNULL(entries, idx))
+       if (idx < 0 || HSTORE_VALISNULL(entries, idx))
        {
            /*
             * need InputFunctionCall to happen even for nulls, so that domain
@@ -1081,9 +1081,9 @@ hstore_populate_record(PG_FUNCTION_ARGS)
        }
        else
        {
-           vallen = HS_VALLEN(entries, idx);
+           vallen = HSTORE_VALLEN(entries, idx);
            value = palloc(1 + vallen);
-           memcpy(value, HS_VAL(entries, ptr, idx), vallen);
+           memcpy(value, HSTORE_VAL(entries, ptr, idx), vallen);
            value[vallen] = 0;
 
            values[i] = InputFunctionCall(&column_info->proc, value,
@@ -1144,11 +1144,11 @@ hstore_out(PG_FUNCTION_ARGS)
    for (i = 0; i < count; i++)
    {
        /* include "" and => and comma-space */
-       buflen += 6 + 2 * HS_KEYLEN(entries, i);
+       buflen += 6 + 2 * HSTORE_KEYLEN(entries, i);
        /* include "" only if nonnull */
-       buflen += 2 + (HS_VALISNULL(entries, i)
+       buflen += 2 + (HSTORE_VALISNULL(entries, i)
                       ? 2
-                      : 2 * HS_VALLEN(entries, i));
+                      : 2 * HSTORE_VALLEN(entries, i));
    }
 
    out = ptr = palloc(buflen);
@@ -1156,11 +1156,11 @@ hstore_out(PG_FUNCTION_ARGS)
    for (i = 0; i < count; i++)
    {
        *ptr++ = '"';
-       ptr = cpw(ptr, HS_KEY(entries, base, i), HS_KEYLEN(entries, i));
+       ptr = cpw(ptr, HSTORE_KEY(entries, base, i), HSTORE_KEYLEN(entries, i));
        *ptr++ = '"';
        *ptr++ = '=';
        *ptr++ = '>';
-       if (HS_VALISNULL(entries, i))
+       if (HSTORE_VALISNULL(entries, i))
        {
            *ptr++ = 'N';
            *ptr++ = 'U';
@@ -1170,7 +1170,7 @@ hstore_out(PG_FUNCTION_ARGS)
        else
        {
            *ptr++ = '"';
-           ptr = cpw(ptr, HS_VAL(entries, base, i), HS_VALLEN(entries, i));
+           ptr = cpw(ptr, HSTORE_VAL(entries, base, i), HSTORE_VALLEN(entries, i));
            *ptr++ = '"';
        }
 
@@ -1203,20 +1203,20 @@ hstore_send(PG_FUNCTION_ARGS)
 
    for (i = 0; i < count; i++)
    {
-       int32       keylen = HS_KEYLEN(entries, i);
+       int32       keylen = HSTORE_KEYLEN(entries, i);
 
        pq_sendint(&buf, keylen, 4);
-       pq_sendtext(&buf, HS_KEY(entries, base, i), keylen);
-       if (HS_VALISNULL(entries, i))
+       pq_sendtext(&buf, HSTORE_KEY(entries, base, i), keylen);
+       if (HSTORE_VALISNULL(entries, i))
        {
            pq_sendint(&buf, -1, 4);
        }
        else
        {
-           int32       vallen = HS_VALLEN(entries, i);
+           int32       vallen = HSTORE_VALLEN(entries, i);
 
            pq_sendint(&buf, vallen, 4);
-           pq_sendtext(&buf, HS_VAL(entries, base, i), vallen);
+           pq_sendtext(&buf, HSTORE_VAL(entries, base, i), vallen);
        }
    }
 
@@ -1255,20 +1255,24 @@ hstore_to_json_loose(PG_FUNCTION_ARGS)
    for (i = 0; i < count; i++)
    {
        resetStringInfo(&tmp);
-       appendBinaryStringInfo(&tmp, HS_KEY(entries, base, i), HS_KEYLEN(entries, i));
+       appendBinaryStringInfo(&tmp, HSTORE_KEY(entries, base, i),
+                              HSTORE_KEYLEN(entries, i));
        escape_json(&dst, tmp.data);
        appendStringInfoString(&dst, ": ");
-       if (HS_VALISNULL(entries, i))
+       if (HSTORE_VALISNULL(entries, i))
            appendStringInfoString(&dst, "null");
        /* guess that values of 't' or 'f' are booleans */
-       else if (HS_VALLEN(entries, i) == 1 && *(HS_VAL(entries, base, i)) == 't')
+       else if (HSTORE_VALLEN(entries, i) == 1 &&
+                *(HSTORE_VAL(entries, base, i)) == 't')
            appendStringInfoString(&dst, "true");
-       else if (HS_VALLEN(entries, i) == 1 && *(HS_VAL(entries, base, i)) == 'f')
+       else if (HSTORE_VALLEN(entries, i) == 1 &&
+                *(HSTORE_VAL(entries, base, i)) == 'f')
            appendStringInfoString(&dst, "false");
        else
        {
            resetStringInfo(&tmp);
-           appendBinaryStringInfo(&tmp, HS_VAL(entries, base, i), HS_VALLEN(entries, i));
+           appendBinaryStringInfo(&tmp, HSTORE_VAL(entries, base, i),
+                                  HSTORE_VALLEN(entries, i));
            if (IsValidJsonNumber(tmp.data, tmp.len))
                appendBinaryStringInfo(&dst, tmp.data, tmp.len);
            else
@@ -1306,15 +1310,17 @@ hstore_to_json(PG_FUNCTION_ARGS)
    for (i = 0; i < count; i++)
    {
        resetStringInfo(&tmp);
-       appendBinaryStringInfo(&tmp, HS_KEY(entries, base, i), HS_KEYLEN(entries, i));
+       appendBinaryStringInfo(&tmp, HSTORE_KEY(entries, base, i),
+                              HSTORE_KEYLEN(entries, i));
        escape_json(&dst, tmp.data);
        appendStringInfoString(&dst, ": ");
-       if (HS_VALISNULL(entries, i))
+       if (HSTORE_VALISNULL(entries, i))
            appendStringInfoString(&dst, "null");
        else
        {
            resetStringInfo(&tmp);
-           appendBinaryStringInfo(&tmp, HS_VAL(entries, base, i), HS_VALLEN(entries, i));
+           appendBinaryStringInfo(&tmp, HSTORE_VAL(entries, base, i),
+                                  HSTORE_VALLEN(entries, i));
            escape_json(&dst, tmp.data);
        }
 
@@ -1346,20 +1352,20 @@ hstore_to_jsonb(PG_FUNCTION_ARGS)
                    val;
 
        key.type = jbvString;
-       key.val.string.len = HS_KEYLEN(entries, i);
-       key.val.string.val = HS_KEY(entries, base, i);
+       key.val.string.len = HSTORE_KEYLEN(entries, i);
+       key.val.string.val = HSTORE_KEY(entries, base, i);
 
        (void) pushJsonbValue(&state, WJB_KEY, &key);
 
-       if (HS_VALISNULL(entries, i))
+       if (HSTORE_VALISNULL(entries, i))
        {
            val.type = jbvNull;
        }
        else
        {
            val.type = jbvString;
-           val.val.string.len = HS_VALLEN(entries, i);
-           val.val.string.val = HS_VAL(entries, base, i);
+           val.val.string.len = HSTORE_VALLEN(entries, i);
+           val.val.string.val = HSTORE_VAL(entries, base, i);
        }
        (void) pushJsonbValue(&state, WJB_VALUE, &val);
    }
@@ -1393,22 +1399,24 @@ hstore_to_jsonb_loose(PG_FUNCTION_ARGS)
                    val;
 
        key.type = jbvString;
-       key.val.string.len = HS_KEYLEN(entries, i);
-       key.val.string.val = HS_KEY(entries, base, i);
+       key.val.string.len = HSTORE_KEYLEN(entries, i);
+       key.val.string.val = HSTORE_KEY(entries, base, i);
 
        (void) pushJsonbValue(&state, WJB_KEY, &key);
 
-       if (HS_VALISNULL(entries, i))
+       if (HSTORE_VALISNULL(entries, i))
        {
            val.type = jbvNull;
        }
        /* guess that values of 't' or 'f' are booleans */
-       else if (HS_VALLEN(entries, i) == 1 && *(HS_VAL(entries, base, i)) == 't')
+       else if (HSTORE_VALLEN(entries, i) == 1 &&
+                *(HSTORE_VAL(entries, base, i)) == 't')
        {
            val.type = jbvBool;
            val.val.boolean = true;
        }
-       else if (HS_VALLEN(entries, i) == 1 && *(HS_VAL(entries, base, i)) == 'f')
+       else if (HSTORE_VALLEN(entries, i) == 1 &&
+                *(HSTORE_VAL(entries, base, i)) == 'f')
        {
            val.type = jbvBool;
            val.val.boolean = false;
@@ -1418,7 +1426,8 @@ hstore_to_jsonb_loose(PG_FUNCTION_ARGS)
            is_number = false;
            resetStringInfo(&tmp);
 
-           appendBinaryStringInfo(&tmp, HS_VAL(entries, base, i), HS_VALLEN(entries, i));
+           appendBinaryStringInfo(&tmp, HSTORE_VAL(entries, base, i),
+                                  HSTORE_VALLEN(entries, i));
 
            /*
             * don't treat something with a leading zero followed by another
@@ -1461,14 +1470,14 @@ hstore_to_jsonb_loose(PG_FUNCTION_ARGS)
            {
                val.type = jbvNumeric;
                val.val.numeric = DatumGetNumeric(
-                                                 DirectFunctionCall3(numeric_in, CStringGetDatum(tmp.data), 0, -1));
-
+                                             DirectFunctionCall3(numeric_in,
+                                         CStringGetDatum(tmp.data), 0, -1));
            }
            else
            {
                val.type = jbvString;
-               val.val.string.len = HS_VALLEN(entries, i);
-               val.val.string.val = HS_VAL(entries, base, i);
+               val.val.string.len = HSTORE_VALLEN(entries, i);
+               val.val.string.val = HSTORE_VAL(entries, base, i);
            }
        }
        (void) pushJsonbValue(&state, WJB_VALUE, &val);

diff --git a/contrib/hstore/hstore_op.c b/contrib/hstore/hstore_op.c
index 9e18a2b5128b416cdbabcc2cf03092afb90f0817..1e2dc881c14e1b6f02b955d6327c07a35a4ddbad 100644 (file)
--- a/contrib/hstore/hstore_op.c
+++ b/contrib/hstore/hstore_op.c
@@ -48,10 +48,10 @@ hstoreFindKey(HStore *hs, int *lowbound, char *key, int keylen)
 
        stopMiddle = stopLow + (stopHigh - stopLow) / 2;
 
-       if (HS_KEYLEN(entries, stopMiddle) == keylen)
-           difference = memcmp(HS_KEY(entries, base, stopMiddle), key, keylen);
+       if (HSTORE_KEYLEN(entries, stopMiddle) == keylen)
+           difference = memcmp(HSTORE_KEY(entries, base, stopMiddle), key, keylen);
        else
-           difference = (HS_KEYLEN(entries, stopMiddle) > keylen) ? 1 : -1;
+           difference = (HSTORE_KEYLEN(entries, stopMiddle) > keylen) ? 1 : -1;
 
        if (difference == 0)
        {
@@ -137,11 +137,11 @@ hstore_fetchval(PG_FUNCTION_ARGS)
    int         idx = hstoreFindKey(hs, NULL,
                                    VARDATA_ANY(key), VARSIZE_ANY_EXHDR(key));
 
-   if (idx < 0 || HS_VALISNULL(entries, idx))
+   if (idx < 0 || HSTORE_VALISNULL(entries, idx))
        PG_RETURN_NULL();
 
-   out = cstring_to_text_with_len(HS_VAL(entries, STRPTR(hs), idx),
-                                  HS_VALLEN(entries, idx));
+   out = cstring_to_text_with_len(HSTORE_VAL(entries, STRPTR(hs), idx),
+                                  HSTORE_VALLEN(entries, idx));
 
    PG_RETURN_TEXT_P(out);
 }
@@ -237,7 +237,7 @@ hstore_defined(PG_FUNCTION_ARGS)
    HEntry     *entries = ARRPTR(hs);
    int         idx = hstoreFindKey(hs, NULL,
                                    VARDATA_ANY(key), VARSIZE_ANY_EXHDR(key));
-   bool        res = (idx >= 0 && !HS_VALISNULL(entries, idx));
+   bool        res = (idx >= 0 && !HSTORE_VALISNULL(entries, idx));
 
    PG_RETURN_BOOL(res);
 }
@@ -271,14 +271,15 @@ hstore_delete(PG_FUNCTION_ARGS)
 
    for (i = 0; i < count; ++i)
    {
-       int         len = HS_KEYLEN(es, i);
-       char       *ptrs = HS_KEY(es, bufs, i);
+       int         len = HSTORE_KEYLEN(es, i);
+       char       *ptrs = HSTORE_KEY(es, bufs, i);
 
        if (!(len == keylen && memcmp(ptrs, keyptr, keylen) == 0))
        {
-           int         vallen = HS_VALLEN(es, i);
+           int         vallen = HSTORE_VALLEN(es, i);
 
-           HS_COPYITEM(ed, bufd, ptrd, ptrs, len, vallen, HS_VALISNULL(es, i));
+           HS_COPYITEM(ed, bufd, ptrd, ptrs, len, vallen,
+                       HSTORE_VALISNULL(es, i));
            ++outcount;
        }
    }
@@ -338,10 +339,10 @@ hstore_delete_array(PG_FUNCTION_ARGS)
            difference = -1;
        else
        {
-           int         skeylen = HS_KEYLEN(es, i);
+           int         skeylen = HSTORE_KEYLEN(es, i);
 
            if (skeylen == key_pairs[j].keylen)
-               difference = memcmp(HS_KEY(es, ps, i),
+               difference = memcmp(HSTORE_KEY(es, ps, i),
                                    key_pairs[j].key,
                                    key_pairs[j].keylen);
            else
@@ -355,8 +356,8 @@ hstore_delete_array(PG_FUNCTION_ARGS)
        else
        {
            HS_COPYITEM(ed, bufd, pd,
-                       HS_KEY(es, ps, i), HS_KEYLEN(es, i),
-                       HS_VALLEN(es, i), HS_VALISNULL(es, i));
+                       HSTORE_KEY(es, ps, i), HSTORE_KEYLEN(es, i),
+                       HSTORE_VALLEN(es, i), HSTORE_VALISNULL(es, i));
            ++outcount;
            ++i;
        }
@@ -421,12 +422,12 @@ hstore_delete_hstore(PG_FUNCTION_ARGS)
            difference = -1;
        else
        {
-           int         skeylen = HS_KEYLEN(es, i);
-           int         s2keylen = HS_KEYLEN(es2, j);
+           int         skeylen = HSTORE_KEYLEN(es, i);
+           int         s2keylen = HSTORE_KEYLEN(es2, j);
 
            if (skeylen == s2keylen)
-               difference = memcmp(HS_KEY(es, ps, i),
-                                   HS_KEY(es2, ps2, j),
+               difference = memcmp(HSTORE_KEY(es, ps, i),
+                                   HSTORE_KEY(es2, ps2, j),
                                    skeylen);
            else
                difference = (skeylen > s2keylen) ? 1 : -1;
@@ -436,16 +437,17 @@ hstore_delete_hstore(PG_FUNCTION_ARGS)
            ++j;
        else if (difference == 0)
        {
-           int         svallen = HS_VALLEN(es, i);
-           int         snullval = HS_VALISNULL(es, i);
-
-           if (snullval != HS_VALISNULL(es2, j)
-               || (!snullval
-                   && (svallen != HS_VALLEN(es2, j)
-           || memcmp(HS_VAL(es, ps, i), HS_VAL(es2, ps2, j), svallen) != 0)))
+           int         svallen = HSTORE_VALLEN(es, i);
+           int         snullval = HSTORE_VALISNULL(es, i);
+
+           if (snullval != HSTORE_VALISNULL(es2, j) ||
+               (!snullval && (svallen != HSTORE_VALLEN(es2, j) ||
+                              memcmp(HSTORE_VAL(es, ps, i),
+                                     HSTORE_VAL(es2, ps2, j),
+                                     svallen) != 0)))
            {
                HS_COPYITEM(ed, bufd, pd,
-                           HS_KEY(es, ps, i), HS_KEYLEN(es, i),
+                           HSTORE_KEY(es, ps, i), HSTORE_KEYLEN(es, i),
                            svallen, snullval);
                ++outcount;
            }
@@ -454,8 +456,8 @@ hstore_delete_hstore(PG_FUNCTION_ARGS)
        else
        {
            HS_COPYITEM(ed, bufd, pd,
-                       HS_KEY(es, ps, i), HS_KEYLEN(es, i),
-                       HS_VALLEN(es, i), HS_VALISNULL(es, i));
+                       HSTORE_KEY(es, ps, i), HSTORE_KEYLEN(es, i),
+                       HSTORE_VALLEN(es, i), HSTORE_VALISNULL(es, i));
            ++outcount;
            ++i;
        }
@@ -530,12 +532,12 @@ hstore_concat(PG_FUNCTION_ARGS)
            difference = -1;
        else
        {
-           int         s1keylen = HS_KEYLEN(es1, s1idx);
-           int         s2keylen = HS_KEYLEN(es2, s2idx);
+           int         s1keylen = HSTORE_KEYLEN(es1, s1idx);
+           int         s2keylen = HSTORE_KEYLEN(es2, s2idx);
 
            if (s1keylen == s2keylen)
-               difference = memcmp(HS_KEY(es1, ps1, s1idx),
-                                   HS_KEY(es2, ps2, s2idx),
+               difference = memcmp(HSTORE_KEY(es1, ps1, s1idx),
+                                   HSTORE_KEY(es2, ps2, s2idx),
                                    s1keylen);
            else
                difference = (s1keylen > s2keylen) ? 1 : -1;
@@ -544,8 +546,8 @@ hstore_concat(PG_FUNCTION_ARGS)
        if (difference >= 0)
        {
            HS_COPYITEM(ed, bufd, pd,
-                       HS_KEY(es2, ps2, s2idx), HS_KEYLEN(es2, s2idx),
-                       HS_VALLEN(es2, s2idx), HS_VALISNULL(es2, s2idx));
+                     HSTORE_KEY(es2, ps2, s2idx), HSTORE_KEYLEN(es2, s2idx),
+                   HSTORE_VALLEN(es2, s2idx), HSTORE_VALISNULL(es2, s2idx));
            ++s2idx;
            if (difference == 0)
                ++s1idx;
@@ -553,8 +555,8 @@ hstore_concat(PG_FUNCTION_ARGS)
        else
        {
            HS_COPYITEM(ed, bufd, pd,
-                       HS_KEY(es1, ps1, s1idx), HS_KEYLEN(es1, s1idx),
-                       HS_VALLEN(es1, s1idx), HS_VALISNULL(es1, s1idx));
+                     HSTORE_KEY(es1, ps1, s1idx), HSTORE_KEYLEN(es1, s1idx),
+                   HSTORE_VALLEN(es1, s1idx), HSTORE_VALISNULL(es1, s1idx));
            ++s1idx;
        }
    }
@@ -604,7 +606,7 @@ hstore_slice_to_array(PG_FUNCTION_ARGS)
        else
            idx = hstoreFindKey(hs, NULL, VARDATA(key), VARSIZE(key) - VARHDRSZ);
 
-       if (idx < 0 || HS_VALISNULL(entries, idx))
+       if (idx < 0 || HSTORE_VALISNULL(entries, idx))
        {
            out_nulls[i] = true;
            out_datums[i] = (Datum) 0;
@@ -612,8 +614,8 @@ hstore_slice_to_array(PG_FUNCTION_ARGS)
        else
        {
            out_datums[i] = PointerGetDatum(
-                         cstring_to_text_with_len(HS_VAL(entries, ptr, idx),
-                                                  HS_VALLEN(entries, idx)));
+                     cstring_to_text_with_len(HSTORE_VAL(entries, ptr, idx),
+                                              HSTORE_VALLEN(entries, idx)));
            out_nulls[i] = false;
        }
    }
@@ -671,9 +673,9 @@ hstore_slice_to_hstore(PG_FUNCTION_ARGS)
        {
            out_pairs[out_count].key = key_pairs[i].key;
            bufsiz += (out_pairs[out_count].keylen = key_pairs[i].keylen);
-           out_pairs[out_count].val = HS_VAL(entries, ptr, idx);
-           bufsiz += (out_pairs[out_count].vallen = HS_VALLEN(entries, idx));
-           out_pairs[out_count].isnull = HS_VALISNULL(entries, idx);
+           out_pairs[out_count].val = HSTORE_VAL(entries, ptr, idx);
+           bufsiz += (out_pairs[out_count].vallen = HSTORE_VALLEN(entries, idx));
+           out_pairs[out_count].isnull = HSTORE_VALISNULL(entries, idx);
            out_pairs[out_count].needfree = false;
            ++out_count;
        }
@@ -712,10 +714,10 @@ hstore_akeys(PG_FUNCTION_ARGS)
 
    for (i = 0; i < count; ++i)
    {
-       text       *item = cstring_to_text_with_len(HS_KEY(entries, base, i),
-                                                   HS_KEYLEN(entries, i));
+       text       *t = cstring_to_text_with_len(HSTORE_KEY(entries, base, i),
+                                                HSTORE_KEYLEN(entries, i));
 
-       d[i] = PointerGetDatum(item);
+       d[i] = PointerGetDatum(t);
    }
 
    a = construct_array(d, count,
@@ -750,15 +752,15 @@ hstore_avals(PG_FUNCTION_ARGS)
 
    for (i = 0; i < count; ++i)
    {
-       if (HS_VALISNULL(entries, i))
+       if (HSTORE_VALISNULL(entries, i))
        {
            d[i] = (Datum) 0;
            nulls[i] = true;
        }
        else
        {
-           text       *item = cstring_to_text_with_len(HS_VAL(entries, base, i),
-                                                     HS_VALLEN(entries, i));
+           text       *item = cstring_to_text_with_len(HSTORE_VAL(entries, base, i),
+                                                 HSTORE_VALLEN(entries, i));
 
            d[i] = PointerGetDatum(item);
            nulls[i] = false;
@@ -795,21 +797,21 @@ hstore_to_array_internal(HStore *hs, int ndims)
 
    for (i = 0; i < count; ++i)
    {
-       text       *key = cstring_to_text_with_len(HS_KEY(entries, base, i),
-                                                  HS_KEYLEN(entries, i));
+       text       *key = cstring_to_text_with_len(HSTORE_KEY(entries, base, i),
+                                                  HSTORE_KEYLEN(entries, i));
 
        out_datums[i * 2] = PointerGetDatum(key);
        out_nulls[i * 2] = false;
 
-       if (HS_VALISNULL(entries, i))
+       if (HSTORE_VALISNULL(entries, i))
        {
            out_datums[i * 2 + 1] = (Datum) 0;
            out_nulls[i * 2 + 1] = true;
        }
        else
        {
-           text       *item = cstring_to_text_with_len(HS_VAL(entries, base, i),
-                                                     HS_VALLEN(entries, i));
+           text       *item = cstring_to_text_with_len(HSTORE_VAL(entries, base, i),
+                                                 HSTORE_VALLEN(entries, i));
 
            out_datums[i * 2 + 1] = PointerGetDatum(item);
            out_nulls[i * 2 + 1] = false;
@@ -903,8 +905,8 @@ hstore_skeys(PG_FUNCTION_ARGS)
        HEntry     *entries = ARRPTR(hs);
        text       *item;
 
-       item = cstring_to_text_with_len(HS_KEY(entries, STRPTR(hs), i),
-                                       HS_KEYLEN(entries, i));
+       item = cstring_to_text_with_len(HSTORE_KEY(entries, STRPTR(hs), i),
+                                       HSTORE_KEYLEN(entries, i));
 
        SRF_RETURN_NEXT(funcctx, PointerGetDatum(item));
    }
@@ -936,7 +938,7 @@ hstore_svals(PG_FUNCTION_ARGS)
    {
        HEntry     *entries = ARRPTR(hs);
 
-       if (HS_VALISNULL(entries, i))
+       if (HSTORE_VALISNULL(entries, i))
        {
            ReturnSetInfo *rsi;
 
@@ -950,8 +952,8 @@ hstore_svals(PG_FUNCTION_ARGS)
        {
            text       *item;
 
-           item = cstring_to_text_with_len(HS_VAL(entries, STRPTR(hs), i),
-                                           HS_VALLEN(entries, i));
+           item = cstring_to_text_with_len(HSTORE_VAL(entries, STRPTR(hs), i),
+                                           HSTORE_VALLEN(entries, i));
 
            SRF_RETURN_NEXT(funcctx, PointerGetDatum(item));
        }
@@ -986,17 +988,19 @@ hstore_contains(PG_FUNCTION_ARGS)
    for (i = 0; res && i < tcount; ++i)
    {
        int         idx = hstoreFindKey(val, &lastidx,
-                                     HS_KEY(te, tstr, i), HS_KEYLEN(te, i));
+                                       HSTORE_KEY(te, tstr, i),
+                                       HSTORE_KEYLEN(te, i));
 
        if (idx >= 0)
        {
-           bool        nullval = HS_VALISNULL(te, i);
-           int         vallen = HS_VALLEN(te, i);
-
-           if (nullval != HS_VALISNULL(ve, idx)
-               || (!nullval
-                   && (vallen != HS_VALLEN(ve, idx)
-            || memcmp(HS_VAL(te, tstr, i), HS_VAL(ve, vstr, idx), vallen))))
+           bool        nullval = HSTORE_VALISNULL(te, i);
+           int         vallen = HSTORE_VALLEN(te, i);
+
+           if (nullval != HSTORE_VALISNULL(ve, idx) ||
+               (!nullval && (vallen != HSTORE_VALLEN(ve, idx) ||
+                             memcmp(HSTORE_VAL(te, tstr, i),
+                                    HSTORE_VAL(ve, vstr, idx),
+                                    vallen) != 0)))
                res = false;
        }
        else
@@ -1047,19 +1051,19 @@ hstore_each(PG_FUNCTION_ARGS)
        text       *item;
        HeapTuple   tuple;
 
-       item = cstring_to_text_with_len(HS_KEY(entries, ptr, i),
-                                       HS_KEYLEN(entries, i));
+       item = cstring_to_text_with_len(HSTORE_KEY(entries, ptr, i),
+                                       HSTORE_KEYLEN(entries, i));
        dvalues[0] = PointerGetDatum(item);
 
-       if (HS_VALISNULL(entries, i))
+       if (HSTORE_VALISNULL(entries, i))
        {
            dvalues[1] = (Datum) 0;
            nulls[1] = true;
        }
        else
        {
-           item = cstring_to_text_with_len(HS_VAL(entries, ptr, i),
-                                           HS_VALLEN(entries, i));
+           item = cstring_to_text_with_len(HSTORE_VAL(entries, ptr, i),
+                                           HSTORE_VALLEN(entries, i));
            dvalues[1] = PointerGetDatum(item);
        }
 

diff --git a/contrib/hstore_plperl/hstore_plperl.c b/contrib/hstore_plperl/hstore_plperl.c
index fbbb4c8e762ab494337f325f371b890e7458d243..d40a792730779c4b443ef0c0b356f3daf315c01f 100644 (file)
--- a/contrib/hstore_plperl/hstore_plperl.c
+++ b/contrib/hstore_plperl/hstore_plperl.c
@@ -27,8 +27,11 @@ hstore_to_plperl(PG_FUNCTION_ARGS)
        const char *key;
        SV         *value;
 
-       key = pnstrdup(HS_KEY(entries, base, i), HS_KEYLEN(entries, i));
-       value = HS_VALISNULL(entries, i) ? newSV(0) : cstr2sv(pnstrdup(HS_VAL(entries, base, i), HS_VALLEN(entries, i)));
+       key = pnstrdup(HSTORE_KEY(entries, base, i),
+                      HSTORE_KEYLEN(entries, i));
+       value = HSTORE_VALISNULL(entries, i) ? newSV(0) :
+           cstr2sv(pnstrdup(HSTORE_VAL(entries, base, i),
+                            HSTORE_VALLEN(entries, i)));
 
        (void) hv_store(hv, key, strlen(key), value, 0);
    }

diff --git a/contrib/hstore_plpython/hstore_plpython.c b/contrib/hstore_plpython/hstore_plpython.c
index a3316dd9eb1a5f3de40089b8ef0abe8b5e579840..6f2751a8df44905a74a2645966edb2e15d60d31a 100644 (file)
--- a/contrib/hstore_plpython/hstore_plpython.c
+++ b/contrib/hstore_plpython/hstore_plpython.c
@@ -25,14 +25,16 @@ hstore_to_plpython(PG_FUNCTION_ARGS)
    {
        PyObject   *key;
 
-       key = PyString_FromStringAndSize(HS_KEY(entries, base, i), HS_KEYLEN(entries, i));
-       if (HS_VALISNULL(entries, i))
+       key = PyString_FromStringAndSize(HSTORE_KEY(entries, base, i),
+                                        HSTORE_KEYLEN(entries, i));
+       if (HSTORE_VALISNULL(entries, i))
            PyDict_SetItem(dict, key, Py_None);
        else
        {
            PyObject   *value;
 
-           value = PyString_FromStringAndSize(HS_VAL(entries, base, i), HS_VALLEN(entries, i));
+           value = PyString_FromStringAndSize(HSTORE_VAL(entries, base, i),
+                                              HSTORE_VALLEN(entries, i));
            PyDict_SetItem(dict, key, value);
            Py_XDECREF(value);
        }