/*
 * contrib/hstore/hstore.h
 */
#ifndef __HSTORE_H__
#define __HSTORE_H__

#include "fmgr.h"
#include "lib/stringinfo.h"
#include "utils/array.h"
#include "utils/numeric.h"

/*
 * HEntry: there is one of these for each key _and_ value in an hstore
 *
 * the position offset points to the _end_ so that we can get the length
 * by subtraction from the previous entry.	the ISFIRST flag lets us tell
 * whether there is a previous entry.
 */
typedef struct
{
	uint32		entry;
} HEntry;

#define HENTRY_ISFIRST		0x80000000
#define HENTRY_ISSTRING 	(0x00000000) /* keep binary compatibility */
#define HENTRY_ISNUMERIC	(0x10000000)
#define HENTRY_ISNEST		(0x20000000)
#define HENTRY_ISNULL		(0x40000000) /* keep binary compatibility */
#define HENTRY_ISBOOL		(0x10000000 | 0x20000000)
#define HENTRY_ISFALSE		HENTRY_ISBOOL
#define HENTRY_ISTRUE		(0x10000000 | 0x20000000 | 0x40000000)

/* HENTRY_ISHASH, HENTRY_ISARRAY and HENTRY_ISSCALAR is only used in send/recv */
#define HENTRY_ISHASH		(0x20000000)
#define HENTRY_ISARRAY		(0x20000000 | 0x40000000)
#define HENTRY_ISSCALAR		(0x10000000 | 0x40000000)

#define HENTRY_POSMASK 	0x0FFFFFFF
#define HENTRY_TYPEMASK	(~(HENTRY_POSMASK | HENTRY_ISFIRST))

/* note possible multiple evaluations, also access to prior array element */
#define HSE_ISFIRST(he_) 		(((he_).entry & HENTRY_ISFIRST) != 0)
#define HSE_ISSTRING(he_)		(((he_).entry & HENTRY_TYPEMASK) == \
								 			HENTRY_ISSTRING)
#define HSE_ISNUMERIC(he_) 		(((he_).entry & HENTRY_TYPEMASK) == \
								 			HENTRY_ISNUMERIC)
#define HSE_ISNEST(he_) 		(((he_).entry & HENTRY_TYPEMASK) == \
								 			HENTRY_ISNEST)
#define HSE_ISNULL(he_) 		(((he_).entry & HENTRY_TYPEMASK) == \
								 			HENTRY_ISNULL)
#define HSE_ISBOOL(he_) 		(((he_).entry & HENTRY_ISBOOL)   == \
								 			HENTRY_ISBOOL)
#define HSE_ISBOOL_TRUE(he_) 	(((he_).entry & HENTRY_TYPEMASK) == \
								 			HENTRY_ISTRUE)
#define HSE_ISBOOL_FALSE(he_) 	(HSE_ISBOOL(he_) && !HSE_ISBOOL_TRUE(he_))

#define HSE_ENDPOS(he_) ((he_).entry & HENTRY_POSMASK)
#define HSE_OFF(he_) (HSE_ISFIRST(he_) ? 0 : HSE_ENDPOS((&(he_))[-1]))
#define HSE_LEN(he_) (HSE_ISFIRST(he_)	\
					  ? HSE_ENDPOS(he_) \
					  : HSE_ENDPOS(he_) - HSE_ENDPOS((&(he_))[-1]))

/*
 * determined by the size of "endpos" (ie HENTRY_POSMASK)
 */
#define HSTORE_MAX_KEY_LEN 		HENTRY_POSMASK
#define HSTORE_MAX_VALUE_LEN 	HENTRY_POSMASK

typedef struct
{
	int32		vl_len_;		/* varlena header (do not touch directly!) */
	/* header of hash or array hstore type */
	/* array of HEntry follows */
} HStore;

/*
 * It's not possible to get more than 2^28 items into an hstore, so we reserve
 * the top few bits of the size field.  See hstore_compat.c for one reason
 * why.  Some bits are left for future use here.  MaxAllocSize makes the
 * practical count limit slightly more than 2^28 / 3, or INT_MAX / 24, the
 * limit for an hstore full of 4-byte keys and null values.  Therefore, we
 * don't explicitly check the format-imposed limit.
 */
#define HS_FLAG_NEWVERSION 		0x80000000
#define HS_FLAG_ARRAY			0x40000000
#define HS_FLAG_HSTORE			0x20000000
#define HS_FLAG_SCALAR			0x10000000

#define HS_COUNT_MASK			0x0FFFFFFF

#define HS_ISEMPTY(hsp_)		(VARSIZE(hsp_) <= VARHDRSZ)
#define HS_ROOT_COUNT(hsp_) 	(HS_ISEMPTY(hsp_) ? 0 : \
								 ( *(uint32*)VARDATA(hsp_) & HS_COUNT_MASK))
#define HS_ROOT_IS_HASH(hsp_) 	(HS_ISEMPTY(hsp_) ? 0 : \
								 ( *(uint32*)VARDATA(hsp_) & HS_FLAG_HSTORE))
#define HS_ROOT_IS_ARRAY(hsp_) 	(HS_ISEMPTY(hsp_) ? 0 : \
								 ( *(uint32*)VARDATA(hsp_) & HS_FLAG_ARRAY))
#define HS_ROOT_IS_SCALAR(hsp_) (HS_ISEMPTY(hsp_) ? 0 : \
								 ( *(uint32*)VARDATA(hsp_) & HS_FLAG_SCALAR))

/* DatumGetHStoreP includes support for reading old-format hstore values */
extern HStore *hstoreUpgrade(Datum orig);

#define DatumGetHStoreP(d) hstoreUpgrade(d)

#define PG_GETARG_HS(x) DatumGetHStoreP(PG_GETARG_DATUM(x))

typedef struct HStorePair HStorePair;
typedef struct HStoreValue HStoreValue;

struct HStoreValue {
	enum {
		hsvNull,
		hsvString,
		hsvNumeric,
		hsvBool,
		hsvArray,
		hsvHash,
		hsvBinary  /* binary form of hsvArray/hsvHash */
	} type;

	uint32		size; /* estimation size of node (including subnodes) */

	union {
		Numeric			numeric;
		bool			boolean;
		struct {
			uint32		len;
			char 		*val; /* could be not null-terminated */
		} string;

		struct {
			int			nelems;
			HStoreValue	*elems;
			/*
			 * scalar actually shares representation with array
			 */
			bool		scalar;
		} array;

		struct {
			int			npairs;
			HStorePair 	*pairs;
		} hash;

		struct {
			uint32		len;
			char		*data;
		} binary;
	};

};

struct HStorePair {
	HStoreValue	key;
	HStoreValue	value;
	uint32		order; /* to keep order of pairs with equal key */
};


extern HStoreValue* parseHStore(const char *str, int len, bool json);

/*
 * hstore support functios
 */

#define WHS_KEY         	(0x001)
#define WHS_VALUE       	(0x002)
#define WHS_ELEM       		(0x004)
#define WHS_BEGIN_ARRAY 	(0x008)
#define WHS_END_ARRAY   	(0x010)
#define WHS_BEGIN_HASH	    (0x020)
#define WHS_END_HASH        (0x040)

typedef void (*walk_hstore_cb)(void* /*arg*/, HStoreValue* /* value */,
											uint32 /* flags */, uint32 /* level */);
extern void walkUncompressedHStore(HStoreValue *v,
								   walk_hstore_cb cb, void *cb_arg);

extern int compareHStoreStringValue(const void *a, const void *b, void *arg);
extern int compareHStorePair(const void *a, const void *b, void *arg);

extern int compareHStoreBinaryValue(char *a, char *b);
extern int compareHStoreValue(HStoreValue *a, HStoreValue *b);

extern HStoreValue* findUncompressedHStoreValueByValue(char *buffer,
													   uint32 flags,
													   uint32 *lowbound,
													   HStoreValue* key);
extern HStoreValue* findUncompressedHStoreValue(char *buffer, uint32 flags,
												uint32 *lowbound,
												char *key, uint32 keylen);

extern HStoreValue* getHStoreValue(char *buffer, uint32 flags, int32 i);

extern bool stringIsNumber(char *string, int len, bool jsonNumber);

typedef enum HStoreOutputKind {
	JsonOutput = 0x01,
	LooseOutput = 0x02,
	ArrayCurlyBraces = 0x04,
	RootHashDecorated = 0x08,
	PrettyPrint = 0x10
} HStoreOutputKind;

extern char* hstoreToCString(StringInfo out, char *in,
							 int len /* just estimation */,
							 HStoreOutputKind kind);
extern text* HStoreValueToText(HStoreValue *v);

typedef struct ToHStoreState
{
	HStoreValue             v;
	uint32                  size;
	struct ToHStoreState    *next;
} ToHStoreState;

extern HStoreValue* pushHStoreValue(ToHStoreState **state,
									int r /* WHS_* */, HStoreValue *v);
extern void uniqueHStoreValue(HStoreValue *v);
extern uint32 compressHStore(HStoreValue *v, char *buffer);


typedef struct HStoreIterator
{
	uint32					type;
	uint32					nelems;
	HEntry					*array;
	bool					isScalar;
	char					*data;
	char					*buffer; /* unparsed buffer */

	int						i;

	/*
	 * enum members should be freely OR'ed with HS_FLAG_ARRAY/HS_FLAG_HSTORE
	 * with possiblity of decoding. See optimization in HStoreIteratorGet()
	 */
	enum {
		hsi_start 	= 0x00,
		hsi_key		= 0x01,
		hsi_value	= 0x02,
		hsi_elem	= 0x04
	} state;

	struct HStoreIterator	*next;
} HStoreIterator;

extern 	HStoreIterator*	HStoreIteratorInit(char *buffer);
extern	int /* WHS_* */	HStoreIteratorGet(HStoreIterator **it, HStoreValue *v,
										  bool skipNested);

#define HStoreContainsStrategyNumber	7
#define HStoreExistsStrategyNumber	9
#define HStoreExistsAnyStrategyNumber	10
#define HStoreExistsAllStrategyNumber	11
#define HStoreOldContainsStrategyNumber 13		/* backwards compatibility */

/*
 * defining HSTORE_POLLUTE_NAMESPACE=0 will prevent use of old function names;
 * for now, we default to on for the benefit of people restoring old dumps
 */
#ifndef HSTORE_POLLUTE_NAMESPACE
#define HSTORE_POLLUTE_NAMESPACE 1
#endif

#if HSTORE_POLLUTE_NAMESPACE
#define HSTORE_POLLUTE(newname_,oldname_) \
	PG_FUNCTION_INFO_V1(oldname_);		  \
	Datum oldname_(PG_FUNCTION_ARGS);	  \
	Datum newname_(PG_FUNCTION_ARGS);	  \
	Datum oldname_(PG_FUNCTION_ARGS) { return newname_(fcinfo); } \
	extern int no_such_variable
#else
#define HSTORE_POLLUTE(newname_,oldname_) \
	extern int no_such_variable
#endif

/*
 * When using a GIN/GiST index for hstore, we choose to index both keys and values.
 * The storage format is "text" values, with K, V, E or N prepended to the string
 * to indicate key, value, element or null values.  (As of 9.1 it might be better to
 * store null values as nulls, but we'll keep it this way for on-disk
 * compatibility.) Before nested hstore GIN indexes used KV notation, so there is 
 * no problem with upgrade, but GiST indexes should be rebuilded.
 */
#define ELEMFLAG    'E'
#define KEYFLAG     'K'
#define VALFLAG     'V'
#define NULLFLAG    'N'

#endif   /* __HSTORE_H__ */