hstore.h File Reference

#include "fmgr.h"
#include "utils/array.h"

Include dependency graph for hstore.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	HEntry
struct	HStore
struct	Pairs

Macros
#define	HENTRY_ISFIRST   0x80000000
#define	HENTRY_ISNULL   0x40000000
#define	HENTRY_POSMASK   0x3FFFFFFF
#define	HSE_ISFIRST(he_)   (((he_).entry & HENTRY_ISFIRST) != 0)
#define	HSE_ISNULL(he_)   (((he_).entry & HENTRY_ISNULL) != 0)
#define	HSE_ENDPOS(he_)   ((he_).entry & HENTRY_POSMASK)
#define	HSE_OFF(he_)   (HSE_ISFIRST(he_) ? 0 : HSE_ENDPOS((&(he_))[-1]))
#define	HSE_LEN(he_)
#define	HSTORE_MAX_KEY_LEN   0x3FFFFFFF
#define	HSTORE_MAX_VALUE_LEN   0x3FFFFFFF
#define	HS_FLAG_NEWVERSION   0x80000000
#define	HS_COUNT(hsp_)   ((hsp_)->size_ & 0x0FFFFFFF)
#define	HS_SETCOUNT(hsp_, c_)   ((hsp_)->size_ = (c_) | HS_FLAG_NEWVERSION)
#define	HSHRDSIZE   (sizeof(HStore))
#define	CALCDATASIZE(x, lenstr)   ( (x) * 2 * sizeof(HEntry) + HSHRDSIZE + (lenstr) )
#define	ARRPTR(x)   ( (HEntry*) ( (HStore*)(x) + 1 ) )
#define	STRPTR(x)   ( (char*)(ARRPTR(x) + HS_COUNT((HStore*)(x)) * 2) )
#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]))
#define	HS_COPYITEM(dent_, dbuf_, dptr_, sptr_, klen_, vlen_, vnull_)
#define	HS_ADDITEM(dent_, dbuf_, dptr_, pair_)
#define	HS_FINALIZE(hsp_, count_, buf_, ptr_)
#define	HS_FIXSIZE(hsp_, count_)
#define	DatumGetHStoreP(d)   hstoreUpgrade(d)
#define	PG_GETARG_HSTORE_P(x)   DatumGetHStoreP(PG_GETARG_DATUM(x))
#define	HStoreContainsStrategyNumber   7
#define	HStoreExistsStrategyNumber   9
#define	HStoreExistsAnyStrategyNumber   10
#define	HStoreExistsAllStrategyNumber   11
#define	HStoreOldContainsStrategyNumber   13 /* backwards compatibility */
#define	HSTORE_POLLUTE_NAMESPACE   1
#define	HSTORE_POLLUTE(newname_, oldname_)

Functions
PGDLLEXPORT HStore *	hstoreUpgrade (Datum orig)
PGDLLEXPORT int	hstoreUniquePairs (Pairs *a, int32 l, int32 *buflen)
PGDLLEXPORT HStore *	hstorePairs (Pairs *pairs, int32 pcount, int32 buflen)
PGDLLEXPORT size_t	hstoreCheckKeyLen (size_t len)
PGDLLEXPORT size_t	hstoreCheckValLen (size_t len)
PGDLLEXPORT int	hstoreFindKey (HStore *hs, int *lowbound, char *key, int keylen)
PGDLLEXPORT Pairs *	hstoreArrayToPairs (ArrayType *a, int *npairs)

Macro Definition Documentation

ARRPTR

#define ARRPTR

(

x

)

( (HEntry*) ( (HStore*)(x) + 1 ) )

Definition at line 75 of file hstore.h.

CALCDATASIZE

#define CALCDATASIZE	(		x,
			lenstr
	)		( (x) * 2 * sizeof(HEntry) + HSHRDSIZE + (lenstr) )

Definition at line 72 of file hstore.h.

DatumGetHStoreP

#define DatumGetHStoreP

(

d

)

hstoreUpgrade(d)

Definition at line 152 of file hstore.h.

HENTRY_ISFIRST

#define HENTRY_ISFIRST   0x80000000

Definition at line 23 of file hstore.h.

HENTRY_ISNULL

#define HENTRY_ISNULL   0x40000000

Definition at line 24 of file hstore.h.

HENTRY_POSMASK

#define HENTRY_POSMASK   0x3FFFFFFF

Definition at line 25 of file hstore.h.

HS_ADDITEM

#define HS_ADDITEM	(		dent_,
			dbuf_,
			dptr_,
			pair_
	)

Value:

    do {                                                                \
		memcpy((dptr_), (pair_).key, (pair_).keylen);                 \
        (dptr_) += (pair_).keylen;                                      \
        (dent_)++->entry = ((dptr_) - (dbuf_)) & HENTRY_POSMASK;        \
		if ((pair_).isnull)                                               \
            (dent_)++->entry = ((((dptr_) - (dbuf_)) & HENTRY_POSMASK)  \
                                 | HENTRY_ISNULL);                      \
        else                                                            \
        {                                                               \
			memcpy((dptr_), (pair_).val, (pair_).vallen);                \
            (dptr_) += (pair_).vallen;                                  \
            (dent_)++->entry = ((dptr_) - (dbuf_)) & HENTRY_POSMASK;    \
        }                                                               \
    } while (0)

Definition at line 112 of file hstore.h.

       {                                                                \
		memcpy((dptr_), (pair_).key, (pair_).keylen);                 \
        (dptr_) += (pair_).keylen;                                      \
        (dent_)++->entry = ((dptr_) - (dbuf_)) & HENTRY_POSMASK;        \
		if ((pair_).isnull)                                               \
            (dent_)++->entry = ((((dptr_) - (dbuf_)) & HENTRY_POSMASK)  \
                                 | HENTRY_ISNULL);                      \
        else                                                            \
        {                                                               \
			memcpy((dptr_), (pair_).val, (pair_).vallen);                \
            (dptr_) += (pair_).vallen;                                  \
            (dent_)++->entry = ((dptr_) - (dbuf_)) & HENTRY_POSMASK;    \
        }                                                               \
    } while (0)

HS_COPYITEM

#define HS_COPYITEM	(		dent_,
			dbuf_,
			dptr_,
			sptr_,
			klen_,
			vlen_,
			vnull_
	)

Value:

    do {                                                                \
		memcpy((dptr_), (sptr_), (klen_)+(vlen_));                        \
        (dptr_) += (klen_)+(vlen_);                                     \
        (dent_)++->entry = ((dptr_) - (dbuf_) - (vlen_)) & HENTRY_POSMASK; \
        (dent_)++->entry = ((((dptr_) - (dbuf_)) & HENTRY_POSMASK)      \
                             | ((vnull_) ? HENTRY_ISNULL : 0));         \
    } while(0)

Definition at line 99 of file hstore.h.

       {                                                                \
		memcpy((dptr_), (sptr_), (klen_)+(vlen_));                        \
        (dptr_) += (klen_)+(vlen_);                                     \
        (dent_)++->entry = ((dptr_) - (dbuf_) - (vlen_)) & HENTRY_POSMASK; \
        (dent_)++->entry = ((((dptr_) - (dbuf_)) & HENTRY_POSMASK)      \
                             | ((vnull_) ? HENTRY_ISNULL : 0));         \
    } while(0)

HS_COUNT

#define HS_COUNT

(

hsp_

)

((hsp_)->size_ & 0x0FFFFFFF)

Definition at line 61 of file hstore.h.

HS_FINALIZE

#define HS_FINALIZE	(		hsp_,
			count_,
			buf_,
			ptr_
	)

Value:

    do {                                                            \
        int _buflen = (ptr_) - (buf_);                              \
		if ((count_))                                             \
			ARRPTR(hsp_)[0].entry |= HENTRY_ISFIRST;             \
		if ((count_) != HS_COUNT((hsp_)))                         \
        {                                                           \
			HS_SETCOUNT((hsp_),(count_));                            \
			memmove(STRPTR(hsp_), (buf_), _buflen);                  \
        }                                                           \
		SET_VARSIZE((hsp_), CALCDATASIZE((count_), _buflen));     \
    } while (0)

Definition at line 129 of file hstore.h.

       {                                                            \
        int _buflen = (ptr_) - (buf_);                              \
		if ((count_))                                             \
			ARRPTR(hsp_)[0].entry |= HENTRY_ISFIRST;             \
		if ((count_) != HS_COUNT((hsp_)))                         \
        {                                                           \
			HS_SETCOUNT((hsp_),(count_));                            \
			memmove(STRPTR(hsp_), (buf_), _buflen);                  \
        }                                                           \
		SET_VARSIZE((hsp_), CALCDATASIZE((count_), _buflen));     \
    } while (0)

HS_FIXSIZE

#define HS_FIXSIZE	(		hsp_,
			count_
	)

Value:

    do {                                                                \
        int bl = (count_) ? HSE_ENDPOS(ARRPTR(hsp_)[2*(count_)-1]) : 0; \
		SET_VARSIZE((hsp_), CALCDATASIZE((count_),bl));                   \
    } while (0)

Definition at line 143 of file hstore.h.

       {                                                                \
        int bl = (count_) ? HSE_ENDPOS(ARRPTR(hsp_)[2*(count_)-1]) : 0; \
		SET_VARSIZE((hsp_), CALCDATASIZE((count_),bl));                   \
    } while (0)

HS_FLAG_NEWVERSION

#define HS_FLAG_NEWVERSION   0x80000000

Definition at line 59 of file hstore.h.

HS_SETCOUNT

#define HS_SETCOUNT	(		hsp_,
			c_
	)		((hsp_)->size_ = (c_) | HS_FLAG_NEWVERSION)

Definition at line 62 of file hstore.h.

HSE_ENDPOS

#define HSE_ENDPOS

(

he_

)

((he_).entry & HENTRY_POSMASK)

Definition at line 30 of file hstore.h.

HSE_ISFIRST

#define HSE_ISFIRST

(

he_

)

(((he_).entry & HENTRY_ISFIRST) != 0)

Definition at line 28 of file hstore.h.

HSE_ISNULL

#define HSE_ISNULL

(

he_

)

(((he_).entry & HENTRY_ISNULL) != 0)

Definition at line 29 of file hstore.h.

HSE_LEN

#define HSE_LEN

(

he_

)

Value:

                      (HSE_ISFIRST(he_) \
                      ? HSE_ENDPOS(he_) \
                      : HSE_ENDPOS(he_) - HSE_ENDPOS((&(he_))[-1]))

Definition at line 32 of file hstore.h.

                      : HSE_ENDPOS(he_) - HSE_ENDPOS((&(he_))[-1]))

HSE_OFF

#define HSE_OFF

(

he_

)

(HSE_ISFIRST(he_) ? 0 : HSE_ENDPOS((&(he_))[-1]))

Definition at line 31 of file hstore.h.

HSHRDSIZE

#define HSHRDSIZE   (sizeof(HStore))

Definition at line 71 of file hstore.h.

HSTORE_KEY

#define HSTORE_KEY	(		arr_,
			str_,
			i_
	)		((str_) + HSE_OFF((arr_)[2*(i_)]))

Definition at line 79 of file hstore.h.

HSTORE_KEYLEN

#define HSTORE_KEYLEN	(		arr_,
			i_
	)		(HSE_LEN((arr_)[2*(i_)]))

Definition at line 81 of file hstore.h.

HSTORE_MAX_KEY_LEN

#define HSTORE_MAX_KEY_LEN   0x3FFFFFFF

Definition at line 41 of file hstore.h.

HSTORE_MAX_VALUE_LEN

#define HSTORE_MAX_VALUE_LEN   0x3FFFFFFF

Definition at line 42 of file hstore.h.

HSTORE_POLLUTE

#define HSTORE_POLLUTE	(		newname_,
			oldname_
	)

Value:

    PG_FUNCTION_INFO_V1(oldname_);        \
    extern PGDLLEXPORT Datum newname_(PG_FUNCTION_ARGS);      \
    Datum oldname_(PG_FUNCTION_ARGS) { return newname_(fcinfo); } \
    extern int no_such_variable

Definition at line 195 of file hstore.h.

                                     { return newname_(fcinfo); } \
    extern int no_such_variable

HSTORE_POLLUTE_NAMESPACE

#define HSTORE_POLLUTE_NAMESPACE   1

Definition at line 191 of file hstore.h.

HSTORE_VAL

#define HSTORE_VAL	(		arr_,
			str_,
			i_
	)		((str_) + HSE_OFF((arr_)[2*(i_)+1]))

Definition at line 80 of file hstore.h.

HSTORE_VALISNULL

#define HSTORE_VALISNULL	(		arr_,
			i_
	)		(HSE_ISNULL((arr_)[2*(i_)+1]))

Definition at line 83 of file hstore.h.

HSTORE_VALLEN

#define HSTORE_VALLEN	(		arr_,
			i_
	)		(HSE_LEN((arr_)[2*(i_)+1]))

Definition at line 82 of file hstore.h.

HStoreContainsStrategyNumber

#define HStoreContainsStrategyNumber   7

Definition at line 180 of file hstore.h.

HStoreExistsAllStrategyNumber

#define HStoreExistsAllStrategyNumber   11

Definition at line 183 of file hstore.h.

HStoreExistsAnyStrategyNumber

#define HStoreExistsAnyStrategyNumber   10

Definition at line 182 of file hstore.h.

HStoreExistsStrategyNumber

#define HStoreExistsStrategyNumber   9

Definition at line 181 of file hstore.h.

HStoreOldContainsStrategyNumber

#define HStoreOldContainsStrategyNumber   13 /* backwards compatibility */

Definition at line 184 of file hstore.h.

PG_GETARG_HSTORE_P

#define PG_GETARG_HSTORE_P

(

x

)

DatumGetHStoreP(PG_GETARG_DATUM(x))

Definition at line 154 of file hstore.h.

STRPTR

#define STRPTR

(

x

)

( (char*)(ARRPTR(x) + HS_COUNT((HStore*)(x)) * 2) )

Definition at line 76 of file hstore.h.

Function Documentation

hstoreArrayToPairs()

PGDLLEXPORT Pairs * hstoreArrayToPairs ( ArrayType *  a, int *  npairs  )

extern

Definition at line 73 of file hstore_op.c.

{
    Datum      *key_datums;
    bool       *key_nulls;
    int         key_count;
    Pairs      *key_pairs;
    int         bufsiz;
    int         i,
                j;
 
    deconstruct_array_builtin(a, TEXTOID, &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(DatumGetPointer(key_datums[i]));
            key_pairs[j].keylen = VARSIZE(DatumGetPointer(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;
}

References a, DatumGetPointer(), deconstruct_array_builtin(), ereport, errcode(), errmsg(), ERROR, fb(), hstoreUniquePairs, i, j, MaxAllocSize, palloc(), VARDATA(), VARHDRSZ, and VARSIZE().

Referenced by hstore_delete_array(), hstore_exists_all(), hstore_exists_any(), and hstore_slice_to_hstore().

hstoreCheckKeyLen()

PGDLLEXPORT size_t hstoreCheckKeyLen ( size_t  len )

extern

Definition at line 407 of file hstore_io.c.

{
    if (len > HSTORE_MAX_KEY_LEN)
        ereport(ERROR,
                (errcode(ERRCODE_STRING_DATA_RIGHT_TRUNCATION),
                 errmsg("string too long for hstore key")));
    return len;
}

References ereport, errcode(), errmsg(), ERROR, fb(), HSTORE_MAX_KEY_LEN, and len.

hstoreCheckValLen()

PGDLLEXPORT size_t hstoreCheckValLen ( size_t  len )

extern

Definition at line 427 of file hstore_io.c.

{
    if (len > HSTORE_MAX_VALUE_LEN)
        ereport(ERROR,
                (errcode(ERRCODE_STRING_DATA_RIGHT_TRUNCATION),
                 errmsg("string too long for hstore value")));
    return len;
}

References ereport, errcode(), errmsg(), ERROR, fb(), HSTORE_MAX_VALUE_LEN, and len.

hstoreFindKey()

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

extern

Definition at line 36 of file hstore_op.c.

{
    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;
}

References ARRPTR, difference(), fb(), HS_COUNT, HSTORE_KEY, HSTORE_KEYLEN, and STRPTR.

Referenced by hstore_contains(), hstore_defined(), hstore_exists(), hstore_exists_all(), hstore_exists_any(), hstore_fetchval(), hstore_populate_record(), hstore_slice_to_array(), hstore_slice_to_hstore(), and hstore_subscript_fetch().

hstorePairs()

PGDLLEXPORT HStore * hstorePairs ( Pairs *  pairs, int32  pcount, int32  buflen  )

extern

Definition at line 448 of file hstore_io.c.

{
    HStore     *out;
    HEntry     *entry;
    char       *ptr;
    char       *buf;
    int32       len;
    int32       i;
 
    len = CALCDATASIZE(pcount, buflen);
    out = palloc(len);
    SET_VARSIZE(out, len);
    HS_SETCOUNT(out, pcount);
 
    if (pcount == 0)
        return out;
 
    entry = ARRPTR(out);
    buf = ptr = STRPTR(out);
 
    for (i = 0; i < pcount; i++)
        HS_ADDITEM(entry, buf, ptr, pairs[i]);
 
    HS_FINALIZE(out, pcount, buf, ptr);
 
    return out;
}

References ARRPTR, buf, CALCDATASIZE, fb(), HS_ADDITEM, HS_FINALIZE, HS_SETCOUNT, i, len, palloc(), SET_VARSIZE(), and STRPTR.

hstoreUniquePairs()

PGDLLEXPORT int hstoreUniquePairs ( Pairs *  a, int32  l, int32 *  buflen  )

extern

Definition at line 359 of file hstore_io.c.

{
    Pairs      *ptr,
               *res;
 
    *buflen = 0;
    if (l < 2)
    {
        if (l == 1)
            *buflen = a->keylen + ((a->isnull) ? 0 : a->vallen);
        return l;
    }
 
    qsort(a, l, sizeof(Pairs), comparePairs);
 
    /*
     * We can't use qunique here because we have some clean-up code to run on
     * removed elements.
     */
    ptr = a + 1;
    res = a;
    while (ptr - a < l)
    {
        if (ptr->keylen == res->keylen &&
            memcmp(ptr->key, res->key, res->keylen) == 0)
        {
            if (ptr->needfree)
            {
                pfree(ptr->key);
                pfree(ptr->val);
            }
        }
        else
        {
            *buflen += res->keylen + ((res->isnull) ? 0 : res->vallen);
            res++;
            if (res != ptr)
                memcpy(res, ptr, sizeof(Pairs));
        }
 
        ptr++;
    }
 
    *buflen += res->keylen + ((res->isnull) ? 0 : res->vallen);
    return res + 1 - a;
}

References a, comparePairs(), fb(), Pairs::isnull, Pairs::key, Pairs::keylen, Pairs::needfree, pfree(), qsort, Pairs::val, and Pairs::vallen.

hstoreUpgrade()

PGDLLEXPORT HStore * hstoreUpgrade ( Datum  orig )

extern

Definition at line 235 of file hstore_compat.c.

{
    HStore     *hs = (HStore *) PG_DETOAST_DATUM(orig);
    int         valid_new;
    int         valid_old;
 
    /* Return immediately if no conversion needed */
    if (hs->size_ & HS_FLAG_NEWVERSION)
        return hs;
 
    /* Do we have a writable copy? If not, make one. */
    if ((void *) hs == (void *) DatumGetPointer(orig))
        hs = (HStore *) PG_DETOAST_DATUM_COPY(orig);
 
    if (hs->size_ == 0 ||
        (VARSIZE(hs) < 32768 && HSE_ISFIRST((ARRPTR(hs)[0]))))
    {
        HS_SETCOUNT(hs, HS_COUNT(hs));
        HS_FIXSIZE(hs, HS_COUNT(hs));
        return hs;
    }
 
    valid_new = hstoreValidNewFormat(hs);
    valid_old = hstoreValidOldFormat(hs);
 
    if (!valid_old || hs->size_ == 0)
    {
        if (valid_new)
        {
            /*
             * force the "new version" flag and the correct varlena length.
             */
            HS_SETCOUNT(hs, HS_COUNT(hs));
            HS_FIXSIZE(hs, HS_COUNT(hs));
            return hs;
        }
        else
        {
            elog(ERROR, "invalid hstore value found");
        }
    }
 
    /*
     * this is the tricky edge case. It is only possible in some quite extreme
     * cases (the hstore must have had a lot of wasted padding space at the
     * end). But the only way a "new" hstore value could get here is if we're
     * upgrading in place from a pre-release version of hstore-new (NOT
     * contrib/hstore), so we work off the following assumptions: 1. If you're
     * moving from old contrib/hstore to hstore-new, you're required to fix up
     * any potential conflicts first, e.g. by running ALTER TABLE ... USING
     * col::text::hstore; on all hstore columns before upgrading. 2. If you're
     * moving from old contrib/hstore to new contrib/hstore, then "new" values
     * are impossible here 3. If you're moving from pre-release hstore-new to
     * hstore-new, then "old" values are impossible here 4. If you're moving
     * from pre-release hstore-new to new contrib/hstore, you're not doing so
     * as an in-place upgrade, so there is no issue So the upshot of all this
     * is that we can treat all the edge cases as "new" if we're being built
     * as hstore-new, and "old" if we're being built as contrib/hstore.
     *
     * XXX the WARNING can probably be downgraded to DEBUG1 once this has been
     * beta-tested. But for now, it would be very useful to know if anyone can
     * actually reach this case in a non-contrived setting.
     */
 
    if (valid_new)
    {
#ifdef HSTORE_IS_HSTORE_NEW
        elog(WARNING, "ambiguous hstore value resolved as hstore-new");
 
        /*
         * force the "new version" flag and the correct varlena length.
         */
        HS_SETCOUNT(hs, HS_COUNT(hs));
        HS_FIXSIZE(hs, HS_COUNT(hs));
        return hs;
#else
        elog(WARNING, "ambiguous hstore value resolved as hstore-old");
#endif
    }
 
    /*
     * must have an old-style value. Overwrite it in place as a new-style one.
     */
    {
        int         count = hs->size_;
        HEntry     *new_entries = ARRPTR(hs);
        HOldEntry  *old_entries = (HOldEntry *) ARRPTR(hs);
        int         i;
 
        for (i = 0; i < count; ++i)
        {
            uint32      pos = old_entries[i].pos;
            uint32      keylen = old_entries[i].keylen;
            uint32      vallen = old_entries[i].vallen;
            bool        isnull = old_entries[i].valisnull;
 
            if (isnull)
                vallen = 0;
 
            new_entries[2 * i].entry = (pos + keylen) & HENTRY_POSMASK;
            new_entries[2 * i + 1].entry = (((pos + keylen + vallen) & HENTRY_POSMASK)
                                            | ((isnull) ? HENTRY_ISNULL : 0));
        }
 
        if (count)
            new_entries[0].entry |= HENTRY_ISFIRST;
        HS_SETCOUNT(hs, count);
        HS_FIXSIZE(hs, count);
    }
 
    return hs;
}

References ARRPTR, DatumGetPointer(), elog, ERROR, fb(), HENTRY_ISFIRST, HENTRY_ISNULL, HENTRY_POSMASK, HS_COUNT, HS_FIXSIZE, HS_FLAG_NEWVERSION, HS_SETCOUNT, HSE_ISFIRST, hstoreValidNewFormat(), hstoreValidOldFormat(), i, PG_DETOAST_DATUM, PG_DETOAST_DATUM_COPY, HOldEntry::pos, VARSIZE(), and WARNING.