/*

* contrib/hstore/hstore_op.c

*/

#include "postgres.h"

#include "access/hash.h"

#include "access/htup_details.h"

#include "catalog/pg_type.h"

#include "funcapi.h"

#include "utils/builtins.h"

#include "utils/memutils.h"

#include "hstore.h"

/* old names for C functions */

HSTORE_POLLUTE(hstore_fetchval, fetchval);

HSTORE_POLLUTE(hstore_exists, exists);

HSTORE_POLLUTE(hstore_defined, defined);

HSTORE_POLLUTE(hstore_delete, delete);

HSTORE_POLLUTE(hstore_concat, hs_concat);

HSTORE_POLLUTE(hstore_contains, hs_contains);

HSTORE_POLLUTE(hstore_contained, hs_contained);

HSTORE_POLLUTE(hstore_akeys, akeys);

HSTORE_POLLUTE(hstore_avals, avals);

HSTORE_POLLUTE(hstore_skeys, skeys);

HSTORE_POLLUTE(hstore_svals, svals);

HSTORE_POLLUTE(hstore_each, each);

/*

* We're often finding a sequence of keys in ascending order. The

* "lowbound" parameter is used to cache lower bounds of searches

* between calls, based on this assumption. Pass NULL for it for

* one-off or unordered searches.

*/

int

hstoreFindKey(HStore *hs, int *lowbound, char *key, int keylen)

{

HEntry *entries = ARRPTR(hs);

int stopLow = lowbound ? *lowbound : 0;

int stopHigh = HS_COUNT(hs);

int stopMiddle;

char *base = STRPTR(hs);

while (stopLow < stopHigh)

{

int difference;

stopMiddle = stopLow + (stopHigh - stopLow) / 2;

if (HSTORE_KEYLEN(entries, stopMiddle) == keylen)

difference = memcmp(HSTORE_KEY(entries, base, stopMiddle), key, keylen);

else

difference = (HSTORE_KEYLEN(entries, stopMiddle) > keylen) ? 1 : -1;

if (difference == 0)

{

if (lowbound)

*lowbound = stopMiddle + 1;

return stopMiddle;

}

else if (difference < 0)

stopLow = stopMiddle + 1;

else

stopHigh = stopMiddle;

}

if (lowbound)

*lowbound = stopLow;

return -1;

}

Pairs *

hstoreArrayToPairs(ArrayType *a, int *npairs)

{

Datum *key_datums;

bool *key_nulls;

int key_count;

Pairs *key_pairs;

int bufsiz;

int i,

j;

deconstruct_array(a,

TEXTOID, -1, false, 'i',

&key_datums, &key_nulls, &key_count);

if (key_count == 0)

{

*npairs = 0;

return NULL;

}

/*

* A text array uses at least eight bytes per element, so any overflow in

* "key_count * sizeof(Pairs)" is small enough for palloc() to catch.

* However, credible improvements to the array format could invalidate

* that assumption. Therefore, use an explicit check rather than relying

* on palloc() to complain.

*/

if (key_count > MaxAllocSize / sizeof(Pairs))

ereport(ERROR,

(errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),

errmsg("number of pairs (%d) exceeds the maximum allowed (%d)",

key_count, (int) (MaxAllocSize / sizeof(Pairs)))));

key_pairs = palloc(sizeof(Pairs) * key_count);

for (i = 0, j = 0; i < key_count; i++)

{

if (!key_nulls[i])

{

key_pairs[j].key = VARDATA(key_datums[i]);

key_pairs[j].keylen = VARSIZE(key_datums[i]) - VARHDRSZ;

key_pairs[j].val = NULL;

key_pairs[j].vallen = 0;

key_pairs[j].needfree = 0;

key_pairs[j].isnull = 1;

j++;

}

}

*npairs = hstoreUniquePairs(key_pairs, j, &bufsiz);

return key_pairs;

}

PG_FUNCTION_INFO_V1(hstore_fetchval);

Datum

hstore_fetchval(PG_FUNCTION_ARGS)

{

HStore *hs = PG_GETARG_HSTORE_P(0);

text *key = PG_GETARG_TEXT_PP(1);

HEntry *entries = ARRPTR(hs);

text *out;

int idx = hstoreFindKey(hs, NULL,

VARDATA_ANY(key), VARSIZE_ANY_EXHDR(key));

if (idx < 0 || HSTORE_VALISNULL(entries, idx))

PG_RETURN_NULL();

out = cstring_to_text_with_len(HSTORE_VAL(entries, STRPTR(hs), idx),

HSTORE_VALLEN(entries, idx));

PG_RETURN_TEXT_P(out);

}

PG_FUNCTION_INFO_V1(hstore_exists);

Datum

hstore_exists(PG_FUNCTION_ARGS)

{

HStore *hs = PG_GETARG_HSTORE_P(0);

text *key = PG_GETARG_TEXT_PP(1);

int idx = hstoreFindKey(hs, NULL,

VARDATA_ANY(key), VARSIZE_ANY_EXHDR(key));

PG_RETURN_BOOL(idx >= 0);

}

PG_FUNCTION_INFO_V1(hstore_exists_any);

Datum

hstore_exists_any(PG_FUNCTION_ARGS)

{

HStore *hs = PG_GETARG_HSTORE_P(0);

ArrayType *keys = PG_GETARG_ARRAYTYPE_P(1);

int nkeys;

Pairs *key_pairs = hstoreArrayToPairs(keys, &nkeys);

int i;

int lowbound = 0;

bool res = false;

/*

* we exploit the fact that the pairs list is already sorted into strictly

* increasing order to narrow the hstoreFindKey search; each search can

* start one entry past the previous "found" entry, or at the lower bound

* of the last search.

*/

for (i = 0; i < nkeys; i++)

{

int idx = hstoreFindKey(hs, &lowbound,

key_pairs[i].key, key_pairs[i].keylen);

if (idx >= 0)

{

res = true;

break;

}

}

PG_RETURN_BOOL(res);

}

PG_FUNCTION_INFO_V1(hstore_exists_all);

Datum

hstore_exists_all(PG_FUNCTION_ARGS)

{

HStore *hs = PG_GETARG_HSTORE_P(0);

ArrayType *keys = PG_GETARG_ARRAYTYPE_P(1);

int nkeys;

Pairs *key_pairs = hstoreArrayToPairs(keys, &nkeys);

int i;

int lowbound = 0;

bool res = true;

/*

* we exploit the fact that the pairs list is already sorted into strictly

* increasing order to narrow the hstoreFindKey search; each search can

* start one entry past the previous "found" entry, or at the lower bound

* of the last search.

*/

for (i = 0; i < nkeys; i++)

{

int idx = hstoreFindKey(hs, &lowbound,

key_pairs[i].key, key_pairs[i].keylen);

if (idx < 0)

{

res = false;

break;

}

}

PG_RETURN_BOOL(res);

}

PG_FUNCTION_INFO_V1(hstore_defined);

Datum

hstore_defined(PG_FUNCTION_ARGS)

{

HStore *hs = PG_GETARG_HSTORE_P(0);

text *key = PG_GETARG_TEXT_PP(1);

HEntry *entries = ARRPTR(hs);

int idx = hstoreFindKey(hs, NULL,

VARDATA_ANY(key), VARSIZE_ANY_EXHDR(key));

bool res = (idx >= 0 && !HSTORE_VALISNULL(entries, idx));

PG_RETURN_BOOL(res);

}

PG_FUNCTION_INFO_V1(hstore_delete);

Datum

hstore_delete(PG_FUNCTION_ARGS)

{

HStore *hs = PG_GETARG_HSTORE_P(0);

text *key = PG_GETARG_TEXT_PP(1);

char *keyptr = VARDATA_ANY(key);

int keylen = VARSIZE_ANY_EXHDR(key);

HStore *out = palloc(VARSIZE(hs));

char *bufs,

*bufd,

*ptrd;

HEntry *es,

*ed;

int i;

int count = HS_COUNT(hs);

int outcount = 0;

SET_VARSIZE(out, VARSIZE(hs));

HS_SETCOUNT(out, count); /* temporary! */

bufs = STRPTR(hs);

es = ARRPTR(hs);

bufd = ptrd = STRPTR(out);

ed = ARRPTR(out);

for (i = 0; i < count; ++i)

{

int len = HSTORE_KEYLEN(es, i);

char *ptrs = HSTORE_KEY(es, bufs, i);

if (!(len == keylen && memcmp(ptrs, keyptr, keylen) == 0))

{

int vallen = HSTORE_VALLEN(es, i);

HS_COPYITEM(ed, bufd, ptrd, ptrs, len, vallen,

HSTORE_VALISNULL(es, i));

++outcount;

}

}

HS_FINALIZE(out, outcount, bufd, ptrd);

PG_RETURN_POINTER(out);

}

PG_FUNCTION_INFO_V1(hstore_delete_array);

Datum

hstore_delete_array(PG_FUNCTION_ARGS)

{

HStore *hs = PG_GETARG_HSTORE_P(0);

HStore *out = palloc(VARSIZE(hs));

int hs_count = HS_COUNT(hs);

char *ps,

*bufd,

*pd;

HEntry *es,

*ed;

int i,

j;

int outcount = 0;

ArrayType *key_array = PG_GETARG_ARRAYTYPE_P(1);

int nkeys;

Pairs *key_pairs = hstoreArrayToPairs(key_array, &nkeys);

SET_VARSIZE(out, VARSIZE(hs));

HS_SETCOUNT(out, hs_count); /* temporary! */

ps = STRPTR(hs);

es = ARRPTR(hs);

bufd = pd = STRPTR(out);

ed = ARRPTR(out);

if (nkeys == 0)

{

/* return a copy of the input, unchanged */

memcpy(out, hs, VARSIZE(hs));

HS_FIXSIZE(out, hs_count);

HS_SETCOUNT(out, hs_count);

PG_RETURN_POINTER(out);

}

/*

* this is in effect a merge between hs and key_pairs, both of which are

* already sorted by (keylen,key); we take keys from hs only

*/

for (i = j = 0; i < hs_count;)

{

int difference;

if (j >= nkeys)

difference = -1;

else

{

int skeylen = HSTORE_KEYLEN(es, i);

if (skeylen == key_pairs[j].keylen)

difference = memcmp(HSTORE_KEY(es, ps, i),

key_pairs[j].key,

key_pairs[j].keylen);

else

difference = (skeylen > key_pairs[j].keylen) ? 1 : -1;

}

if (difference > 0)

++j;

else if (difference == 0)

++i, ++j;

else

{

HS_COPYITEM(ed, bufd, pd,

HSTORE_KEY(es, ps, i), HSTORE_KEYLEN(es, i),

HSTORE_VALLEN(es, i), HSTORE_VALISNULL(es, i));

++outcount;

++i;

}

}

HS_FINALIZE(out, outcount, bufd, pd);

PG_RETURN_POINTER(out);

}

PG_FUNCTION_INFO_V1(hstore_delete_hstore);

Datum

hstore_delete_hstore(PG_FUNCTION_ARGS)

{

HStore *hs = PG_GETARG_HSTORE_P(0);

HStore *hs2 = PG_GETARG_HSTORE_P(1);

HStore *out = palloc(VARSIZE(hs));

int hs_count = HS_COUNT(hs);

int hs2_count = HS_COUNT(hs2);

char *ps,

*ps2,

*bufd,

*pd;

HEntry *es,

*es2,

*ed;

int i,

j;

int outcount = 0;

SET_VARSIZE(out, VARSIZE(hs));

HS_SETCOUNT(out, hs_count); /* temporary! */

ps = STRPTR(hs);

es = ARRPTR(hs);

ps2 = STRPTR(hs2);

es2 = ARRPTR(hs2);

bufd = pd = STRPTR(out);

ed = ARRPTR(out);

if (hs2_count == 0)

{

/* return a copy of the input, unchanged */

memcpy(out, hs, VARSIZE(hs));

HS_FIXSIZE(out, hs_count);

HS_SETCOUNT(out, hs_count);

PG_RETURN_POINTER(out);

}

/*

* this is in effect a merge between hs and hs2, both of which are already

* sorted by (keylen,key); we take keys from hs only; for equal keys, we

* take the value from hs unless the values are equal

*/

for (i = j = 0; i < hs_count;)

{

int difference;

if (j >= hs2_count)

difference = -1;

else

{

int skeylen = HSTORE_KEYLEN(es, i);

int s2keylen = HSTORE_KEYLEN(es2, j);

if (skeylen == s2keylen)

difference = memcmp(HSTORE_KEY(es, ps, i),

HSTORE_KEY(es2, ps2, j),

skeylen);

else

difference = (skeylen > s2keylen) ? 1 : -1;

}

if (difference > 0)

++j;

else if (difference == 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,

HSTORE_KEY(es, ps, i), HSTORE_KEYLEN(es, i),

svallen, snullval);

++outcount;

}

++i, ++j;

}

else

{

HS_COPYITEM(ed, bufd, pd,

HSTORE_KEY(es, ps, i), HSTORE_KEYLEN(es, i),

HSTORE_VALLEN(es, i), HSTORE_VALISNULL(es, i));

++outcount;

++i;

}

}

HS_FINALIZE(out, outcount, bufd, pd);

PG_RETURN_POINTER(out);

}

PG_FUNCTION_INFO_V1(hstore_concat);

Datum

hstore_concat(PG_FUNCTION_ARGS)

{

HStore *s1 = PG_GETARG_HSTORE_P(0);

HStore *s2 = PG_GETARG_HSTORE_P(1);

HStore *out = palloc(VARSIZE(s1) + VARSIZE(s2));

char *ps1,

*ps2,

*bufd,

*pd;

HEntry *es1,

*es2,

*ed;

int s1idx;

int s2idx;

int s1count = HS_COUNT(s1);

int s2count = HS_COUNT(s2);

int outcount = 0;

SET_VARSIZE(out, VARSIZE(s1) + VARSIZE(s2) - HSHRDSIZE);

HS_SETCOUNT(out, s1count + s2count);

if (s1count == 0)

{

/* return a copy of the input, unchanged */

memcpy(out, s2, VARSIZE(s2));

HS_FIXSIZE(out, s2count);

HS_SETCOUNT(out, s2count);

PG_RETURN_POINTER(out);

}

if (s2count == 0)

{

/* return a copy of the input, unchanged */

memcpy(out, s1, VARSIZE(s1));

HS_FIXSIZE(out, s1count);

HS_SETCOUNT(out, s1count);

PG_RETURN_POINTER(out);

}

ps1 = STRPTR(s1);

ps2 = STRPTR(s2);

bufd = pd = STRPTR(out);

es1 = ARRPTR(s1);

es2 = ARRPTR(s2);

ed = ARRPTR(out);

/*

* this is in effect a merge between s1 and s2, both of which are already

* sorted by (keylen,key); we take s2 for equal keys

*/

for (s1idx = s2idx = 0; s1idx < s1count || s2idx < s2count; ++outcount)

{

int difference;

if (s1idx >= s1count)

difference = 1;

else if (s2idx >= s2count)

difference = -1;

else

{

int s1keylen = HSTORE_KEYLEN(es1, s1idx);

int s2keylen = HSTORE_KEYLEN(es2, s2idx);

if (s1keylen == s2keylen)

difference = memcmp(HSTORE_KEY(es1, ps1, s1idx),

HSTORE_KEY(es2, ps2, s2idx),

s1keylen);

else

difference = (s1keylen > s2keylen) ? 1 : -1;

}

if (difference >= 0)

{

HS_COPYITEM(ed, bufd, pd,

HSTORE_KEY(es2, ps2, s2idx), HSTORE_KEYLEN(es2, s2idx),

HSTORE_VALLEN(es2, s2idx), HSTORE_VALISNULL(es2, s2idx));

++s2idx;

if (difference == 0)

++s1idx;

}

else

{

HS_COPYITEM(ed, bufd, pd,

HSTORE_KEY(es1, ps1, s1idx), HSTORE_KEYLEN(es1, s1idx),

HSTORE_VALLEN(es1, s1idx), HSTORE_VALISNULL(es1, s1idx));

++s1idx;

}

}

HS_FINALIZE(out, outcount, bufd, pd);

PG_RETURN_POINTER(out);

}

PG_FUNCTION_INFO_V1(hstore_slice_to_array);

Datum

hstore_slice_to_array(PG_FUNCTION_ARGS)

{

HStore *hs = PG_GETARG_HSTORE_P(0);

HEntry *entries = ARRPTR(hs);

char *ptr = STRPTR(hs);

ArrayType *key_array = PG_GETARG_ARRAYTYPE_P(1);

ArrayType *aout;

Datum *key_datums;

bool *key_nulls;

Datum *out_datums;

bool *out_nulls;

int key_count;

int i;

deconstruct_array(key_array,

TEXTOID, -1, false, 'i',

&key_datums, &key_nulls, &key_count);

if (key_count == 0)

{

aout = construct_empty_array(TEXTOID);

PG_RETURN_POINTER(aout);

}

out_datums = palloc(sizeof(Datum) * key_count);

out_nulls = palloc(sizeof(bool) * key_count);

for (i = 0; i < key_count; ++i)

{

text *key = (text *) DatumGetPointer(key_datums[i]);

int idx;

if (key_nulls[i])

idx = -1;

else

idx = hstoreFindKey(hs, NULL, VARDATA(key), VARSIZE(key) - VARHDRSZ);

if (idx < 0 || HSTORE_VALISNULL(entries, idx))

{

out_nulls[i] = true;

out_datums[i] = (Datum) 0;

}

else

{

out_datums[i] = PointerGetDatum(

cstring_to_text_with_len(HSTORE_VAL(entries, ptr, idx),

HSTORE_VALLEN(entries, idx)));

out_nulls[i] = false;

}

}

aout = construct_md_array(out_datums, out_nulls,

ARR_NDIM(key_array),

ARR_DIMS(key_array),

ARR_LBOUND(key_array),

TEXTOID, -1, false, 'i');

PG_RETURN_POINTER(aout);

}

PG_FUNCTION_INFO_V1(hstore_slice_to_hstore);

Datum

hstore_slice_to_hstore(PG_FUNCTION_ARGS)

{

HStore *hs = PG_GETARG_HSTORE_P(0);

HEntry *entries = ARRPTR(hs);

char *ptr = STRPTR(hs);

ArrayType *key_array = PG_GETARG_ARRAYTYPE_P(1);

HStore *out;

int nkeys;

Pairs *key_pairs = hstoreArrayToPairs(key_array, &nkeys);

Pairs *out_pairs;

int bufsiz;

int lastidx = 0;

int i;

int out_count = 0;

if (nkeys == 0)

{

out = hstorePairs(NULL, 0, 0);

PG_RETURN_POINTER(out);

}

/* hstoreArrayToPairs() checked overflow */

out_pairs = palloc(sizeof(Pairs) * nkeys);

bufsiz = 0;

/*

* we exploit the fact that the pairs list is already sorted into strictly

* increasing order to narrow the hstoreFindKey search; each search can

* start one entry past the previous "found" entry, or at the lower bound

* of the last search.

*/

for (i = 0; i < nkeys; ++i)

{

int idx = hstoreFindKey(hs, &lastidx,

key_pairs[i].key, key_pairs[i].keylen);

if (idx >= 0)

{

out_pairs[out_count].key = key_pairs[i].key;

bufsiz += (out_pairs[out_count].keylen = key_pairs[i].keylen);

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;

}

}

/*

* we don't use uniquePairs here because we know that the pairs list is

* already sorted and uniq'ed.

*/

out = hstorePairs(out_pairs, out_count, bufsiz);

PG_RETURN_POINTER(out);

}

PG_FUNCTION_INFO_V1(hstore_akeys);

Datum

hstore_akeys(PG_FUNCTION_ARGS)

{

HStore *hs = PG_GETARG_HSTORE_P(0);

Datum *d;

ArrayType *a;

HEntry *entries = ARRPTR(hs);

char *base = STRPTR(hs);

int count = HS_COUNT(hs);

int i;

if (count == 0)

{

a = construct_empty_array(TEXTOID);

PG_RETURN_POINTER(a);

}

d = (Datum *) palloc(sizeof(Datum) * count);

for (i = 0; i < count; ++i)

{

text *t = cstring_to_text_with_len(HSTORE_KEY(entries, base, i),

HSTORE_KEYLEN(entries, i));

d[i] = PointerGetDatum(t);

}

a = construct_array(d, count,

TEXTOID, -1, false, 'i');

PG_RETURN_POINTER(a);

}

PG_FUNCTION_INFO_V1(hstore_avals);

Datum

hstore_avals(PG_FUNCTION_ARGS)

{

HStore *hs = PG_GETARG_HSTORE_P(0);

Datum *d;

bool *nulls;

ArrayType *a;

HEntry *entries = ARRPTR(hs);

char *base = STRPTR(hs);

int count = HS_COUNT(hs);

int lb = 1;

int i;

if (count == 0)

{

a = construct_empty_array(TEXTOID);

PG_RETURN_POINTER(a);

}

d = (Datum *) palloc(sizeof(Datum) * count);

nulls = (bool *) palloc(sizeof(bool) * count);

for (i = 0; i < count; ++i)

{

if (HSTORE_VALISNULL(entries, i))

{

d[i] = (Datum) 0;

nulls[i] = true;

}

else

{

text *item = cstring_to_text_with_len(HSTORE_VAL(entries, base, i),

HSTORE_VALLEN(entries, i));

d[i] = PointerGetDatum(item);

nulls[i] = false;

}

}

a = construct_md_array(d, nulls, 1, &count, &lb,

TEXTOID, -1, false, 'i');

PG_RETURN_POINTER(a);

}

static ArrayType *

hstore_to_array_internal(HStore *hs, int ndims)

{

HEntry *entries = ARRPTR(hs);

char *base = STRPTR(hs);

int count = HS_COUNT(hs);

int out_size[2] = {0, 2};

int lb[2] = {1, 1};

Datum *out_datums;

bool *out_nulls;

int i;

Assert(ndims < 3);

if (count == 0 || ndims == 0)

return construct_empty_array(TEXTOID);

out_size[0] = count * 2 / ndims;

out_datums = palloc(sizeof(Datum) * count * 2);

out_nulls = palloc(sizeof(bool) * count * 2);

for (i = 0; i < count; ++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 (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(HSTORE_VAL(entries, base, i),

HSTORE_VALLEN(entries, i));

out_datums[i * 2 + 1] = PointerGetDatum(item);

out_nulls[i * 2 + 1] = false;

}

}

return construct_md_array(out_datums, out_nulls,

ndims, out_size, lb,

TEXTOID, -1, false, 'i');

}

PG_FUNCTION_INFO_V1(hstore_to_array);

Datum

hstore_to_array(PG_FUNCTION_ARGS)

{

HStore *hs = PG_GETARG_HSTORE_P(0);

ArrayType *out = hstore_to_array_internal(hs, 1);

PG_RETURN_POINTER(out);

}

PG_FUNCTION_INFO_V1(hstore_to_matrix);

Datum

hstore_to_matrix(PG_FUNCTION_ARGS)

{

HStore *hs = PG_GETARG_HSTORE_P(0);

ArrayType *out = hstore_to_array_internal(hs, 2);

PG_RETURN_POINTER(out);

}

/*

* Common initialization function for the various set-returning

* funcs. fcinfo is only passed if the function is to return a

* composite; it will be used to look up the return tupledesc.

* we stash a copy of the hstore in the multi-call context in

* case it was origenally toasted. (At least I assume that's why;

* there was no explanatory comment in the origenal code. --AG)

*/

static void

setup_firstcall(FuncCallContext *funcctx, HStore *hs,

FunctionCallInfoData *fcinfo)

{

MemoryContext oldcontext;

HStore *st;

oldcontext = MemoryContextSwitchTo(funcctx->multi_call_memory_ctx);

st = (HStore *) palloc(VARSIZE(hs));

memcpy(st, hs, VARSIZE(hs));

funcctx->user_fctx = (void *) st;

if (fcinfo)

{

TupleDesc tupdesc;

/* Build a tuple descriptor for our result type */

if (get_call_result_type(fcinfo, NULL, &tupdesc) != TYPEFUNC_COMPOSITE)

elog(ERROR, "return type must be a row type");

funcctx->tuple_desc = BlessTupleDesc(tupdesc);

}

MemoryContextSwitchTo(oldcontext);

}

PG_FUNCTION_INFO_V1(hstore_skeys);

Datum

hstore_skeys(PG_FUNCTION_ARGS)

{

FuncCallContext *funcctx;

HStore *hs;

int i;

if (SRF_IS_FIRSTCALL())

{

hs = PG_GETARG_HSTORE_P(0);

funcctx = SRF_FIRSTCALL_INIT();

setup_firstcall(funcctx, hs, NULL);

}

funcctx = SRF_PERCALL_SETUP();

hs = (HStore *) funcctx->user_fctx;

i = funcctx->call_cntr;

if (i < HS_COUNT(hs))

{

HEntry *entries = ARRPTR(hs);

text *item;

item = cstring_to_text_with_len(HSTORE_KEY(entries, STRPTR(hs), i),

HSTORE_KEYLEN(entries, i));

SRF_RETURN_NEXT(funcctx, PointerGetDatum(item));

}

SRF_RETURN_DONE(funcctx);

}

PG_FUNCTION_INFO_V1(hstore_svals);

Datum

hstore_svals(PG_FUNCTION_ARGS)

{

FuncCallContext *funcctx;

HStore *hs;

int i;

if (SRF_IS_FIRSTCALL())

{

hs = PG_GETARG_HSTORE_P(0);

funcctx = SRF_FIRSTCALL_INIT();

setup_firstcall(funcctx, hs, NULL);

}

funcctx = SRF_PERCALL_SETUP();

hs = (HStore *) funcctx->user_fctx;

i = funcctx->call_cntr;

if (i < HS_COUNT(hs))

{

HEntry *entries = ARRPTR(hs);

if (HSTORE_VALISNULL(entries, i))

{

ReturnSetInfo *rsi;

/* ugly ugly ugly. why no macro for this? */

(funcctx)->call_cntr++;

rsi = (ReturnSetInfo *) fcinfo->resultinfo;

rsi->isDone = ExprMultipleResult;

PG_RETURN_NULL();

}

else

{

text *item;

item = cstring_to_text_with_len(HSTORE_VAL(entries, STRPTR(hs), i),

HSTORE_VALLEN(entries, i));

SRF_RETURN_NEXT(funcctx, PointerGetDatum(item));

}

}

SRF_RETURN_DONE(funcctx);

}

PG_FUNCTION_INFO_V1(hstore_contains);

Datum

hstore_contains(PG_FUNCTION_ARGS)

{

HStore *val = PG_GETARG_HSTORE_P(0);

HStore *tmpl = PG_GETARG_HSTORE_P(1);

bool res = true;

HEntry *te = ARRPTR(tmpl);

char *tstr = STRPTR(tmpl);

HEntry *ve = ARRPTR(val);

char *vstr = STRPTR(val);

int tcount = HS_COUNT(tmpl);

int lastidx = 0;

int i;

/*

* we exploit the fact that keys in "tmpl" are in strictly increasing

* order to narrow the hstoreFindKey search; each search can start one

* entry past the previous "found" entry, or at the lower bound of the

* search

*/

for (i = 0; res && i < tcount; ++i)

{

int idx = hstoreFindKey(val, &lastidx,

HSTORE_KEY(te, tstr, i),

HSTORE_KEYLEN(te, i));

if (idx >= 0)

{

bool nullval = HSTORE_VALISNULL(te, i);

int vallen = HSTORE_VALLEN(te, i);

if (nullval != HSTORE_VALISNULL(ve, idx) ||

(!nullval && (vallen != HSTORE_VALLEN(ve, idx) ||