open-dsi
/
postgres
mirror of https://github.com/postgres/postgres
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Dodge a macro-name conflict with Perl.

Browse Source 
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.
pull/14/head^2
Tom Lane 10 years ago
parent db135e834a
commit 68c1d7d42e
8 changed files with 153 additions and 129 deletions
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Show Stats Download Patch File Download Diff File
  1. 10
      contrib/hstore/hstore.h
  2. 2
      contrib/hstore/hstore_compat.c
  3. 8
      contrib/hstore/hstore_gin.c
  4. 16
      contrib/hstore/hstore_gist.c
  5. 83
      contrib/hstore/hstore_io.c
  6. 148
      contrib/hstore/hstore_op.c
  7. 7
      contrib/hstore_plperl/hstore_plperl.c
  8. 8
      contrib/hstore_plpython/hstore_plpython.c

10
contrib/hstore/hstore.h
Unescape View File

@ -76,11 +76,11 @@ typedef struct
#define STRPTR(x) ( (char*)(ARRPTR(x) + HS_COUNT((HStore*)(x)) * 2) ) #define STRPTR(x) ( (char*)(ARRPTR(x) + HS_COUNT((HStore*)(x)) * 2) )
/* note multiple/non evaluations */ /* note multiple/non evaluations */
#define HS_KEY(arr_,str_,i_) ((str_) + HSE_OFF((arr_)[2*(i_)])) #define HSTORE_KEY(arr_,str_,i_) ((str_) + HSE_OFF((arr_)[2*(i_)]))
#define HS_VAL(arr_,str_,i_) ((str_) + HSE_OFF((arr_)[2*(i_)+1])) #define HSTORE_VAL(arr_,str_,i_) ((str_) + HSE_OFF((arr_)[2*(i_)+1]))
#define HS_KEYLEN(arr_,i_) (HSE_LEN((arr_)[2*(i_)])) #define HSTORE_KEYLEN(arr_,i_) (HSE_LEN((arr_)[2*(i_)]))
#define HS_VALLEN(arr_,i_) (HSE_LEN((arr_)[2*(i_)+1])) #define HSTORE_VALLEN(arr_,i_) (HSE_LEN((arr_)[2*(i_)+1]))
#define HS_VALISNULL(arr_,i_) (HSE_ISNULL((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 * currently, these following macros are the _only_ places that rely

2
contrib/hstore/hstore_compat.c
Unescape View File

@ -149,7 +149,7 @@ hstoreValidNewFormat(HStore *hs)
for (i = 1; i < count; ++i) 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; return 0;
if (HSE_ISNULL(entries[2 * i])) if (HSE_ISNULL(entries[2 * i]))
return 0; return 0;

8
contrib/hstore/hstore_gin.c
Unescape View File

@ -59,14 +59,16 @@ gin_extract_hstore(PG_FUNCTION_ARGS)
{ {
text *item; 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); KEYFLAG);
entries[2 * i] = PointerGetDatum(item); entries[2 * i] = PointerGetDatum(item);
if (HS_VALISNULL(hsent, i)) if (HSTORE_VALISNULL(hsent, i))
item = makeitem(NULL, 0, NULLFLAG); item = makeitem(NULL, 0, NULLFLAG);
else else
item = makeitem(HS_VAL(hsent, ptr, i), HS_VALLEN(hsent, i), item = makeitem(HSTORE_VAL(hsent, ptr, i),
HSTORE_VALLEN(hsent, i),
VALFLAG); VALFLAG);
entries[2 * i + 1] = PointerGetDatum(item); entries[2 * i + 1] = PointerGetDatum(item);
} }

16
contrib/hstore/hstore_gist.c
Unescape View File

@ -129,11 +129,13 @@ ghstore_compress(PG_FUNCTION_ARGS)
{ {
int h; 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); 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); HASH(GETSIGN(res), h);
} }
} }
@ -524,13 +526,15 @@ ghstore_consistent(PG_FUNCTION_ARGS)
for (i = 0; res && i < count; ++i) 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 (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))) if (!GETBIT(sign, HASHVAL(crc)))
res = false; res = false;
} }

83
contrib/hstore/hstore_io.c
Unescape View File

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

148
contrib/hstore/hstore_op.c
Unescape View File

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

7
contrib/hstore_plperl/hstore_plperl.c
Unescape View File

@ -27,8 +27,11 @@ hstore_to_plperl(PG_FUNCTION_ARGS)
const char *key; const char *key;
SV *value; SV *value;
key = pnstrdup(HS_KEY(entries, base, i), HS_KEYLEN(entries, i)); key = pnstrdup(HSTORE_KEY(entries, base, i),
value = HS_VALISNULL(entries, i) ? newSV(0) : cstr2sv(pnstrdup(HS_VAL(entries, base, i), HS_VALLEN(entries, 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); (void) hv_store(hv, key, strlen(key), value, 0);
} }

8
contrib/hstore_plpython/hstore_plpython.c
Unescape View File

@ -25,14 +25,16 @@ hstore_to_plpython(PG_FUNCTION_ARGS)
{ {
PyObject *key; PyObject *key;
key = PyString_FromStringAndSize(HS_KEY(entries, base, i), HS_KEYLEN(entries, i)); key = PyString_FromStringAndSize(HSTORE_KEY(entries, base, i),
if (HS_VALISNULL(entries, i)) HSTORE_KEYLEN(entries, i));
if (HSTORE_VALISNULL(entries, i))
PyDict_SetItem(dict, key, Py_None); PyDict_SetItem(dict, key, Py_None);
else else
{ {
PyObject *value; 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); PyDict_SetItem(dict, key, value);
Py_XDECREF(value); Py_XDECREF(value);
} }

Write Preview
Loading…
Cancel
Save