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

Include dependency graph for hstore.h:

This graph shows which files directly or indirectly include 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.

◆ 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.

◆ 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.

◆ 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.

◆ 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_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.

◆ 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
	)

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

References a, deconstruct_array_builtin(), ereport, errcode(), errmsg(), ERROR, hstoreUniquePairs, i, Pairs::isnull, j, Pairs::key, Pairs::keylen, MaxAllocSize, Pairs::needfree, palloc(), Pairs::val, Pairs::vallen, 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 )

Definition at line 404 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, HSTORE_MAX_KEY_LEN, and len.

Referenced by hstore_from_array(), hstore_from_arrays(), hstore_from_record(), hstore_from_text(), and hstore_recv().

◆ hstoreCheckValLen()

PGDLLEXPORT size_t hstoreCheckValLen ( size_t len )

Definition at line 424 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, HSTORE_MAX_VALUE_LEN, and len.

Referenced by hstore_from_array(), hstore_from_arrays(), hstore_from_record(), hstore_from_text(), and hstore_recv().

◆ hstoreFindKey()

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

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(), HS_COUNT, HSTORE_KEY, HSTORE_KEYLEN, sort-test::key, 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
	)

Definition at line 445 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, HS_ADDITEM, HS_FINALIZE, HS_SETCOUNT, i, len, palloc(), SET_VARSIZE, and STRPTR.

Referenced by hstore_from_array(), hstore_from_arrays(), hstore_from_record(), hstore_from_text(), hstore_in(), and hstore_recv().

◆ hstoreUniquePairs()

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

Definition at line 356 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(), Pairs::key, Pairs::keylen, Pairs::needfree, pfree(), qsort, res, and Pairs::val.

Referenced by hstore_from_array(), hstore_from_arrays(), hstore_from_record(), hstore_in(), and hstore_recv().

◆ hstoreUpgrade()

PGDLLEXPORT HStore * hstoreUpgrade ( Datum orig )

Definition at line 236 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, HEntry::entry, ERROR, HENTRY_ISFIRST, HENTRY_ISNULL, HENTRY_POSMASK, HS_COUNT, HS_FIXSIZE, HS_FLAG_NEWVERSION, HS_SETCOUNT, HSE_ISFIRST, hstoreValidNewFormat(), hstoreValidOldFormat(), i, HOldEntry::keylen, PG_DETOAST_DATUM, PG_DETOAST_DATUM_COPY, HOldEntry::pos, HStore::size_, HOldEntry::valisnull, HOldEntry::vallen, VARSIZE, and WARNING.

Data Structures

Macros

Functions

Macro Definition Documentation

◆ ARRPTR

◆ CALCDATASIZE

◆ DatumGetHStoreP

◆ HENTRY_ISFIRST

◆ HENTRY_ISNULL

◆ HENTRY_POSMASK

◆ HS_ADDITEM

◆ HS_COPYITEM

◆ HS_COUNT

◆ HS_FINALIZE

◆ HS_FIXSIZE

◆ HS_FLAG_NEWVERSION

◆ HS_SETCOUNT

◆ HSE_ENDPOS

◆ HSE_ISFIRST

◆ HSE_ISNULL

◆ HSE_LEN

◆ HSE_OFF

◆ HSHRDSIZE

◆ HSTORE_KEY

◆ HSTORE_KEYLEN

◆ HSTORE_MAX_KEY_LEN

◆ HSTORE_MAX_VALUE_LEN

◆ HSTORE_POLLUTE

◆ HSTORE_POLLUTE_NAMESPACE

◆ HSTORE_VAL

◆ HSTORE_VALISNULL

◆ HSTORE_VALLEN

◆ HStoreContainsStrategyNumber

◆ HStoreExistsAllStrategyNumber

◆ HStoreExistsAnyStrategyNumber

◆ HStoreExistsStrategyNumber

◆ HStoreOldContainsStrategyNumber

◆ PG_GETARG_HSTORE_P

◆ STRPTR

Function Documentation

◆ hstoreArrayToPairs()

◆ hstoreCheckKeyLen()

◆ hstoreCheckValLen()

◆ hstoreFindKey()

◆ hstorePairs()

◆ hstoreUniquePairs()

◆ hstoreUpgrade()