mirror of
https://git.postgresql.org/git/postgresql.git
synced 2024-09-04 00:57:20 +02:00
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.
This commit is contained in:
parent
04f5622b63
commit
8ee1a776a0
@ -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
|
||||
|
@ -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;
|
||||
|
@ -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);
|
||||
}
|
||||
|
@ -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;
|
||||
}
|
||||
|
@ -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);
|
||||
|
@ -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);
|
||||
int svallen = HSTORE_VALLEN(es, i);
|
||||
int snullval = HSTORE_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)))
|
||||
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);
|
||||
bool nullval = HSTORE_VALISNULL(te, i);
|
||||
int vallen = HSTORE_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))))
|
||||
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);
|
||||
}
|
||||
|
||||
|
@ -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);
|
||||
}
|
||||
|
@ -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);
|
||||
}
|
||||
|
Loading…
Reference in New Issue
Block a user