#include "postgres.h"
#include "access/gin.h"
#include "access/stratnum.h"
#include "catalog/pg_type.h"
#include "hstore.h"

Include dependency graph for hstore_gin.c:

Macros
#define	KEYFLAG 'K'

#define	VALFLAG 'V'

#define	NULLFLAG 'N'

Functions
	PG_FUNCTION_INFO_V1 (gin_extract_hstore)

static text *	makeitem (char *str, int len, char flag)

Datum	gin_extract_hstore (PG_FUNCTION_ARGS)

	PG_FUNCTION_INFO_V1 (gin_extract_hstore_query)

Datum	gin_extract_hstore_query (PG_FUNCTION_ARGS)

	PG_FUNCTION_INFO_V1 (gin_consistent_hstore)

Datum	gin_consistent_hstore (PG_FUNCTION_ARGS)

Macro Definition Documentation

◆ KEYFLAG

#define KEYFLAG 'K'

Definition at line 20 of file hstore_gin.c.

◆ NULLFLAG

#define NULLFLAG 'N'

Definition at line 22 of file hstore_gin.c.

◆ VALFLAG

#define VALFLAG 'V'

Definition at line 21 of file hstore_gin.c.

Function Documentation

◆ gin_consistent_hstore()

Datum gin_consistent_hstore ( PG_FUNCTION_ARGS )

Definition at line 151 of file hstore_gin.c.

 {
     bool       *check = (bool *) PG_GETARG_POINTER(0);
     StrategyNumber strategy = PG_GETARG_UINT16(1);
  
     /* HStore      *query = PG_GETARG_HSTORE_P(2); */
     int32       nkeys = PG_GETARG_INT32(3);
  
     /* Pointer     *extra_data = (Pointer *) PG_GETARG_POINTER(4); */
     bool       *recheck = (bool *) PG_GETARG_POINTER(5);
     bool        res = true;
     int32       i;
  
     if (strategy == HStoreContainsStrategyNumber)
     {
         /*
          * Index doesn't have information about correspondence of keys and
          * values, so we need recheck.  However, if not all the keys are
          * present, we can fail at once.
          */
         *recheck = true;
         for (i = 0; i < nkeys; i++)
         {
             if (!check[i])
             {
                 res = false;
                 break;
             }
         }
     }
     else if (strategy == HStoreExistsStrategyNumber)
     {
         /* Existence of key is guaranteed in default search mode */
         *recheck = false;
         res = true;
     }
     else if (strategy == HStoreExistsAnyStrategyNumber)
     {
         /* Existence of key is guaranteed in default search mode */
         *recheck = false;
         res = true;
     }
     else if (strategy == HStoreExistsAllStrategyNumber)
     {
         /* Testing for all the keys being present gives an exact result */
         *recheck = false;
         for (i = 0; i < nkeys; i++)
         {
             if (!check[i])
             {
                 res = false;
                 break;
             }
         }
     }
     else
         elog(ERROR, "unrecognized strategy number: %d", strategy);
  
     PG_RETURN_BOOL(res);
 }

References elog, ERROR, HStoreContainsStrategyNumber, HStoreExistsAllStrategyNumber, HStoreExistsAnyStrategyNumber, HStoreExistsStrategyNumber, i, PG_GETARG_INT32, PG_GETARG_POINTER, PG_GETARG_UINT16, PG_RETURN_BOOL, and res.

◆ gin_extract_hstore()

Datum gin_extract_hstore ( PG_FUNCTION_ARGS )

Definition at line 44 of file hstore_gin.c.

 {
     HStore     *hs = PG_GETARG_HSTORE_P(0);
     int32      *nentries = (int32 *) PG_GETARG_POINTER(1);
     Datum      *entries = NULL;
     HEntry     *hsent = ARRPTR(hs);
     char       *ptr = STRPTR(hs);
     int         count = HS_COUNT(hs);
     int         i;
  
     *nentries = 2 * count;
     if (count)
         entries = (Datum *) palloc(sizeof(Datum) * 2 * count);
  
     for (i = 0; i < count; ++i)
     {
         text       *item;
  
         item = makeitem(HSTORE_KEY(hsent, ptr, i),
                         HSTORE_KEYLEN(hsent, i),
                         KEYFLAG);
         entries[2 * i] = PointerGetDatum(item);
  
         if (HSTORE_VALISNULL(hsent, i))
             item = makeitem(NULL, 0, NULLFLAG);
         else
             item = makeitem(HSTORE_VAL(hsent, ptr, i),
                             HSTORE_VALLEN(hsent, i),
                             VALFLAG);
         entries[2 * i + 1] = PointerGetDatum(item);
     }
  
     PG_RETURN_POINTER(entries);
 }

References ARRPTR, HS_COUNT, HSTORE_KEY, HSTORE_KEYLEN, HSTORE_VAL, HSTORE_VALISNULL, HSTORE_VALLEN, i, KEYFLAG, makeitem(), NULLFLAG, palloc(), PG_GETARG_HSTORE_P, PG_GETARG_POINTER, PG_RETURN_POINTER, PointerGetDatum(), STRPTR, and VALFLAG.

Referenced by gin_extract_hstore_query().

◆ gin_extract_hstore_query()

Datum gin_extract_hstore_query ( PG_FUNCTION_ARGS )

Definition at line 82 of file hstore_gin.c.

 {
     int32      *nentries = (int32 *) PG_GETARG_POINTER(1);
     StrategyNumber strategy = PG_GETARG_UINT16(2);
     int32      *searchMode = (int32 *) PG_GETARG_POINTER(6);
     Datum      *entries;
  
     if (strategy == HStoreContainsStrategyNumber)
     {
         /* Query is an hstore, so just apply gin_extract_hstore... */
         entries = (Datum *)
             DatumGetPointer(DirectFunctionCall2(gin_extract_hstore,
                                                 PG_GETARG_DATUM(0),
                                                 PointerGetDatum(nentries)));
         /* ... except that "contains {}" requires a full index scan */
         if (entries == NULL)
             *searchMode = GIN_SEARCH_MODE_ALL;
     }
     else if (strategy == HStoreExistsStrategyNumber)
     {
         text       *query = PG_GETARG_TEXT_PP(0);
         text       *item;
  
         *nentries = 1;
         entries = (Datum *) palloc(sizeof(Datum));
         item = makeitem(VARDATA_ANY(query), VARSIZE_ANY_EXHDR(query), KEYFLAG);
         entries[0] = PointerGetDatum(item);
     }
     else if (strategy == HStoreExistsAnyStrategyNumber ||
              strategy == HStoreExistsAllStrategyNumber)
     {
         ArrayType  *query = PG_GETARG_ARRAYTYPE_P(0);
         Datum      *key_datums;
         bool       *key_nulls;
         int         key_count;
         int         i,
                     j;
         text       *item;
  
         deconstruct_array_builtin(query, TEXTOID, &key_datums, &key_nulls, &key_count);
  
         entries = (Datum *) palloc(sizeof(Datum) * key_count);
  
         for (i = 0, j = 0; i < key_count; ++i)
         {
             /* Nulls in the array are ignored, cf hstoreArrayToPairs */
             if (key_nulls[i])
                 continue;
             item = makeitem(VARDATA(key_datums[i]), VARSIZE(key_datums[i]) - VARHDRSZ, KEYFLAG);
             entries[j++] = PointerGetDatum(item);
         }
  
         *nentries = j;
         /* ExistsAll with no keys should match everything */
         if (j == 0 && strategy == HStoreExistsAllStrategyNumber)
             *searchMode = GIN_SEARCH_MODE_ALL;
     }
     else
     {
         elog(ERROR, "unrecognized strategy number: %d", strategy);
         entries = NULL;         /* keep compiler quiet */
     }
  
     PG_RETURN_POINTER(entries);
 }

References DatumGetPointer(), deconstruct_array_builtin(), DirectFunctionCall2, elog, ERROR, gin_extract_hstore(), GIN_SEARCH_MODE_ALL, HStoreContainsStrategyNumber, HStoreExistsAllStrategyNumber, HStoreExistsAnyStrategyNumber, HStoreExistsStrategyNumber, i, j, KEYFLAG, makeitem(), palloc(), PG_GETARG_ARRAYTYPE_P, PG_GETARG_DATUM, PG_GETARG_POINTER, PG_GETARG_TEXT_PP, PG_GETARG_UINT16, PG_RETURN_POINTER, PointerGetDatum(), VARDATA, VARDATA_ANY, VARHDRSZ, VARSIZE, and VARSIZE_ANY_EXHDR.

◆ makeitem()

static text* makeitem	(	char *	str,
		int	len,
		char	flag
	)

static

Definition at line 28 of file hstore_gin.c.

 {
     text       *item;
  
     item = (text *) palloc(VARHDRSZ + len + 1);
     SET_VARSIZE(item, VARHDRSZ + len + 1);
  
     *VARDATA(item) = flag;
  
     if (str && len > 0)
         memcpy(VARDATA(item) + 1, str, len);
  
     return item;
 }

References flag(), len, palloc(), SET_VARSIZE, str, VARDATA, and VARHDRSZ.

Referenced by gin_extract_hstore(), and gin_extract_hstore_query().

◆ PG_FUNCTION_INFO_V1() [1/3]

PG_FUNCTION_INFO_V1 ( gin_consistent_hstore )

◆ PG_FUNCTION_INFO_V1() [2/3]

PG_FUNCTION_INFO_V1 ( gin_extract_hstore )

◆ PG_FUNCTION_INFO_V1() [3/3]

PG_FUNCTION_INFO_V1 ( gin_extract_hstore_query )

Macros

Functions