jsonb_gin.c File Reference

#include "postgres.h"
#include "access/gin.h"
#include "access/stratnum.h"
#include "catalog/pg_collation.h"
#include "catalog/pg_type.h"
#include "common/hashfn.h"
#include "miscadmin.h"
#include "utils/fmgrprotos.h"
#include "utils/jsonb.h"
#include "utils/jsonpath.h"
#include "utils/varlena.h"

Include dependency graph for jsonb_gin.c:

Go to the source code of this file.

Data Structures
struct	PathHashStack
struct	GinEntries
struct	JsonPathGinNode
struct	JsonPathGinPathItem
union	JsonPathGinPath
struct	JsonPathGinContext

Typedefs
typedef struct PathHashStack	PathHashStack
typedef struct GinEntries	GinEntries
typedef enum JsonPathGinNodeType	JsonPathGinNodeType
typedef struct JsonPathGinNode	JsonPathGinNode
typedef struct JsonPathGinPathItem	JsonPathGinPathItem
typedef union JsonPathGinPath	JsonPathGinPath
typedef struct JsonPathGinContext	JsonPathGinContext
typedef bool(*	JsonPathGinAddPathItemFunc) (JsonPathGinPath *path, JsonPathItem *jsp)
typedef List *(*	JsonPathGinExtractNodesFunc) (JsonPathGinContext *cxt, JsonPathGinPath path, JsonbValue *scalar, List *nodes)

Enumerations
enum	JsonPathGinNodeType { JSP_GIN_OR , JSP_GIN_AND , JSP_GIN_ENTRY }

Functions
static Datum	make_text_key (char flag, const char *str, int len)
static Datum	make_scalar_key (const JsonbValue *scalarVal, bool is_key)
static JsonPathGinNode *	extract_jsp_bool_expr (JsonPathGinContext *cxt, JsonPathGinPath path, JsonPathItem *jsp, bool not)
static void	init_gin_entries (GinEntries *entries, int preallocated)
static int	add_gin_entry (GinEntries *entries, Datum entry)
Datum	gin_compare_jsonb (PG_FUNCTION_ARGS)
Datum	gin_extract_jsonb (PG_FUNCTION_ARGS)
static bool	jsonb_ops__add_path_item (JsonPathGinPath *path, JsonPathItem *jsp)
static bool	jsonb_path_ops__add_path_item (JsonPathGinPath *path, JsonPathItem *jsp)
static JsonPathGinNode *	make_jsp_entry_node (Datum entry)
static JsonPathGinNode *	make_jsp_entry_node_scalar (JsonbValue *scalar, bool iskey)
static JsonPathGinNode *	make_jsp_expr_node (JsonPathGinNodeType type, int nargs)
static JsonPathGinNode *	make_jsp_expr_node_args (JsonPathGinNodeType type, List *args)
static JsonPathGinNode *	make_jsp_expr_node_binary (JsonPathGinNodeType type, JsonPathGinNode *arg1, JsonPathGinNode *arg2)
static List *	jsonb_ops__extract_nodes (JsonPathGinContext *cxt, JsonPathGinPath path, JsonbValue *scalar, List *nodes)
static List *	jsonb_path_ops__extract_nodes (JsonPathGinContext *cxt, JsonPathGinPath path, JsonbValue *scalar, List *nodes)
static List *	extract_jsp_path_expr_nodes (JsonPathGinContext *cxt, JsonPathGinPath path, JsonPathItem *jsp, JsonbValue *scalar)
static JsonPathGinNode *	extract_jsp_path_expr (JsonPathGinContext *cxt, JsonPathGinPath path, JsonPathItem *jsp, JsonbValue *scalar)
static void	emit_jsp_gin_entries (JsonPathGinNode *node, GinEntries *entries)
static Datum *	extract_jsp_query (JsonPath *jp, StrategyNumber strat, bool pathOps, int32 *nentries, Pointer **extra_data)
static GinTernaryValue	execute_jsp_gin_node (JsonPathGinNode *node, void *check, bool ternary)
Datum	gin_extract_jsonb_query (PG_FUNCTION_ARGS)
Datum	gin_consistent_jsonb (PG_FUNCTION_ARGS)
Datum	gin_triconsistent_jsonb (PG_FUNCTION_ARGS)
Datum	gin_extract_jsonb_path (PG_FUNCTION_ARGS)
Datum	gin_extract_jsonb_query_path (PG_FUNCTION_ARGS)
Datum	gin_consistent_jsonb_path (PG_FUNCTION_ARGS)
Datum	gin_triconsistent_jsonb_path (PG_FUNCTION_ARGS)

Typedef Documentation

GinEntries

typedef struct GinEntries GinEntries

JsonPathGinAddPathItemFunc

typedef bool(* JsonPathGinAddPathItemFunc) (JsonPathGinPath *path, JsonPathItem *jsp)

Definition at line 134 of file jsonb_gin.c.

JsonPathGinContext

typedef struct JsonPathGinContext JsonPathGinContext

Definition at line 131 of file jsonb_gin.c.

JsonPathGinExtractNodesFunc

typedef List *(* JsonPathGinExtractNodesFunc) (JsonPathGinContext *cxt, JsonPathGinPath path, JsonbValue *scalar, List *nodes)

Definition at line 141 of file jsonb_gin.c.

JsonPathGinNode

typedef struct JsonPathGinNode JsonPathGinNode

Definition at line 94 of file jsonb_gin.c.

JsonPathGinNodeType

typedef enum JsonPathGinNodeType JsonPathGinNodeType

JsonPathGinPath

typedef union JsonPathGinPath JsonPathGinPath

JsonPathGinPathItem

typedef struct JsonPathGinPathItem JsonPathGinPathItem

PathHashStack

typedef struct PathHashStack PathHashStack

Enumeration Type Documentation

JsonPathGinNodeType

enum JsonPathGinNodeType

Enumerator
JSP_GIN_OR
JSP_GIN_AND
JSP_GIN_ENTRY

Definition at line 87 of file jsonb_gin.c.

{
    JSP_GIN_OR,
    JSP_GIN_AND,
    JSP_GIN_ENTRY,
} JsonPathGinNodeType;

Function Documentation

add_gin_entry()

static int add_gin_entry ( GinEntries *  entries, Datum  entry  )

static

Definition at line 172 of file jsonb_gin.c.

{
    int         id = entries->count;
 
    if (entries->count >= entries->allocated)
    {
        if (entries->allocated)
        {
            entries->allocated *= 2;
            entries->buf = repalloc(entries->buf,
                                    sizeof(Datum) * entries->allocated);
        }
        else
        {
            entries->allocated = 8;
            entries->buf = palloc(sizeof(Datum) * entries->allocated);
        }
    }
 
    entries->buf[entries->count++] = entry;
 
    return id;
}

References GinEntries::allocated, GinEntries::buf, GinEntries::count, palloc(), and repalloc().

Referenced by emit_jsp_gin_entries(), gin_extract_jsonb(), and gin_extract_jsonb_path().

emit_jsp_gin_entries()

static void emit_jsp_gin_entries ( JsonPathGinNode *  node, GinEntries *  entries  )

static

Definition at line 719 of file jsonb_gin.c.

{
    check_stack_depth();
 
    switch (node->type)
    {
        case JSP_GIN_ENTRY:
            /* replace datum with its index in the array */
            node->val.entryIndex = add_gin_entry(entries, node->val.entryDatum);
            break;
 
        case JSP_GIN_OR:
        case JSP_GIN_AND:
            {
                int         i;
 
                for (i = 0; i < node->val.nargs; i++)
                    emit_jsp_gin_entries(node->args[i], entries);
 
                break;
            }
    }
}

References add_gin_entry(), JsonPathGinNode::args, check_stack_depth(), emit_jsp_gin_entries(), JsonPathGinNode::entryDatum, JsonPathGinNode::entryIndex, i, JSP_GIN_AND, JSP_GIN_ENTRY, JSP_GIN_OR, JsonPathGinNode::nargs, JsonPathGinNode::type, and JsonPathGinNode::val.

Referenced by emit_jsp_gin_entries(), and extract_jsp_query().

execute_jsp_gin_node()

static GinTernaryValue execute_jsp_gin_node ( JsonPathGinNode *  node, void *  check, bool  ternary  )

static

Definition at line 799 of file jsonb_gin.c.

{
    GinTernaryValue res;
    GinTernaryValue v;
    int         i;
 
    switch (node->type)
    {
        case JSP_GIN_AND:
            res = GIN_TRUE;
            for (i = 0; i < node->val.nargs; i++)
            {
                v = execute_jsp_gin_node(node->args[i], check, ternary);
                if (v == GIN_FALSE)
                    return GIN_FALSE;
                else if (v == GIN_MAYBE)
                    res = GIN_MAYBE;
            }
            return res;
 
        case JSP_GIN_OR:
            res = GIN_FALSE;
            for (i = 0; i < node->val.nargs; i++)
            {
                v = execute_jsp_gin_node(node->args[i], check, ternary);
                if (v == GIN_TRUE)
                    return GIN_TRUE;
                else if (v == GIN_MAYBE)
                    res = GIN_MAYBE;
            }
            return res;
 
        case JSP_GIN_ENTRY:
            {
                int         index = node->val.entryIndex;
 
                if (ternary)
                    return ((GinTernaryValue *) check)[index];
                else
                    return ((bool *) check)[index] ? GIN_TRUE : GIN_FALSE;
            }
 
        default:
            elog(ERROR, "invalid jsonpath gin node type: %d", node->type);
            return GIN_FALSE;   /* keep compiler quiet */
    }
}

References JsonPathGinNode::args, elog, JsonPathGinNode::entryIndex, ERROR, execute_jsp_gin_node(), GIN_FALSE, GIN_MAYBE, GIN_TRUE, i, JSP_GIN_AND, JSP_GIN_ENTRY, JSP_GIN_OR, JsonPathGinNode::nargs, JsonPathGinNode::type, and JsonPathGinNode::val.

Referenced by execute_jsp_gin_node(), gin_consistent_jsonb(), gin_consistent_jsonb_path(), gin_triconsistent_jsonb(), and gin_triconsistent_jsonb_path().

extract_jsp_bool_expr()

static JsonPathGinNode * extract_jsp_bool_expr ( JsonPathGinContext *  cxt, JsonPathGinPath  path, JsonPathItem *  jsp, bool  not  )

static

Definition at line 583 of file jsonb_gin.c.

{
    check_stack_depth();
 
    switch (jsp->type)
    {
        case jpiAnd:            /* expr && expr */
        case jpiOr:             /* expr || expr */
            {
                JsonPathItem arg;
                JsonPathGinNode *larg;
                JsonPathGinNode *rarg;
                JsonPathGinNodeType type;
 
                jspGetLeftArg(jsp, &arg);
                larg = extract_jsp_bool_expr(cxt, path, &arg, not);
 
                jspGetRightArg(jsp, &arg);
                rarg = extract_jsp_bool_expr(cxt, path, &arg, not);
 
                if (!larg || !rarg)
                {
                    if (jsp->type == jpiOr)
                        return NULL;
 
                    return larg ? larg : rarg;
                }
 
                type = not ^ (jsp->type == jpiAnd) ? JSP_GIN_AND : JSP_GIN_OR;
 
                return make_jsp_expr_node_binary(type, larg, rarg);
            }
 
        case jpiNot:            /* !expr  */
            {
                JsonPathItem arg;
 
                jspGetArg(jsp, &arg);
 
                /* extract child expression inverting 'not' flag */
                return extract_jsp_bool_expr(cxt, path, &arg, !not);
            }
 
        case jpiExists:         /* EXISTS(path) */
            {
                JsonPathItem arg;
 
                if (not)
                    return NULL;    /* NOT EXISTS is not supported */
 
                jspGetArg(jsp, &arg);
 
                return extract_jsp_path_expr(cxt, path, &arg, NULL);
            }
 
        case jpiNotEqual:
 
            /*
             * 'not' == true case is not supported here because '!(path !=
             * scalar)' is not equivalent to 'path == scalar' in the general
             * case because of sequence comparison semantics: 'path == scalar'
             * === 'EXISTS (path, @ == scalar)', '!(path != scalar)' ===
             * 'FOR_ALL(path, @ == scalar)'. So, we should translate '!(path
             * != scalar)' into GIN query 'path == scalar || EMPTY(path)', but
             * 'EMPTY(path)' queries are not supported by the both jsonb
             * opclasses.  However in strict mode we could omit 'EMPTY(path)'
             * part if the path can return exactly one item (it does not
             * contain wildcard accessors or item methods like .keyvalue()
             * etc.).
             */
            return NULL;
 
        case jpiEqual:          /* path == scalar */
            {
                JsonPathItem left_item;
                JsonPathItem right_item;
                JsonPathItem *path_item;
                JsonPathItem *scalar_item;
                JsonbValue  scalar;
 
                if (not)
                    return NULL;
 
                jspGetLeftArg(jsp, &left_item);
                jspGetRightArg(jsp, &right_item);
 
                if (jspIsScalar(left_item.type))
                {
                    scalar_item = &left_item;
                    path_item = &right_item;
                }
                else if (jspIsScalar(right_item.type))
                {
                    scalar_item = &right_item;
                    path_item = &left_item;
                }
                else
                    return NULL;    /* at least one operand should be a scalar */
 
                switch (scalar_item->type)
                {
                    case jpiNull:
                        scalar.type = jbvNull;
                        break;
                    case jpiBool:
                        scalar.type = jbvBool;
                        scalar.val.boolean = !!*scalar_item->content.value.data;
                        break;
                    case jpiNumeric:
                        scalar.type = jbvNumeric;
                        scalar.val.numeric =
                            (Numeric) scalar_item->content.value.data;
                        break;
                    case jpiString:
                        scalar.type = jbvString;
                        scalar.val.string.val = scalar_item->content.value.data;
                        scalar.val.string.len =
                            scalar_item->content.value.datalen;
                        break;
                    default:
                        elog(ERROR, "invalid scalar jsonpath item type: %d",
                             scalar_item->type);
                        return NULL;
                }
 
                return extract_jsp_path_expr(cxt, path, path_item, &scalar);
            }
 
        default:
            return NULL;        /* not a boolean expression */
    }
}

References arg, check_stack_depth(), JsonPathItem::content, JsonPathItem::data, JsonPathItem::datalen, elog, ERROR, extract_jsp_bool_expr(), extract_jsp_path_expr(), jbvBool, jbvNull, jbvNumeric, jbvString, jpiAnd, jpiBool, jpiEqual, jpiExists, jpiNot, jpiNotEqual, jpiNull, jpiNumeric, jpiOr, jpiString, JSP_GIN_AND, JSP_GIN_OR, jspGetArg(), jspGetLeftArg(), jspGetRightArg(), jspIsScalar, make_jsp_expr_node_binary(), type, JsonbValue::type, JsonPathItem::type, JsonbValue::val, and JsonPathItem::value.

Referenced by extract_jsp_bool_expr(), extract_jsp_path_expr_nodes(), and extract_jsp_query().

extract_jsp_path_expr()

static JsonPathGinNode * extract_jsp_path_expr ( JsonPathGinContext *  cxt, JsonPathGinPath  path, JsonPathItem *  jsp, JsonbValue *  scalar  )

static

Definition at line 564 of file jsonb_gin.c.

{
    /* extract a list of nodes to be AND-ed */
    List       *nodes = extract_jsp_path_expr_nodes(cxt, path, jsp, scalar);
 
    if (nodes == NIL)
        /* no nodes were extracted => full scan is needed for this path */
        return NULL;
 
    if (list_length(nodes) == 1)
        return linitial(nodes); /* avoid extra AND-node */
 
    /* construct AND-node for path with filters */
    return make_jsp_expr_node_args(JSP_GIN_AND, nodes);
}

References extract_jsp_path_expr_nodes(), JSP_GIN_AND, linitial, list_length(), make_jsp_expr_node_args(), and NIL.

Referenced by extract_jsp_bool_expr(), and extract_jsp_query().

extract_jsp_path_expr_nodes()

static List * extract_jsp_path_expr_nodes ( JsonPathGinContext *  cxt, JsonPathGinPath  path, JsonPathItem *  jsp, JsonbValue *  scalar  )

static

Definition at line 504 of file jsonb_gin.c.

{
    JsonPathItem next;
    List       *nodes = NIL;
 
    for (;;)
    {
        switch (jsp->type)
        {
            case jpiCurrent:
                break;
 
            case jpiFilter:
                {
                    JsonPathItem arg;
                    JsonPathGinNode *filter;
 
                    jspGetArg(jsp, &arg);
 
                    filter = extract_jsp_bool_expr(cxt, path, &arg, false);
 
                    if (filter)
                        nodes = lappend(nodes, filter);
 
                    break;
                }
 
            default:
                if (!cxt->add_path_item(&path, jsp))
 
                    /*
                     * Path is not supported by the index opclass, return only
                     * the extracted filter nodes.
                     */
                    return nodes;
                break;
        }
 
        if (!jspGetNext(jsp, &next))
            break;
 
        jsp = &next;
    }
 
    /*
     * Append nodes from the path expression itself to the already extracted
     * list of filter nodes.
     */
    return cxt->extract_nodes(cxt, path, scalar, nodes);
}

References JsonPathGinContext::add_path_item, arg, extract_jsp_bool_expr(), JsonPathGinContext::extract_nodes, jpiCurrent, jpiFilter, jspGetArg(), jspGetNext(), lappend(), next, NIL, and JsonPathItem::type.

Referenced by extract_jsp_path_expr().

extract_jsp_query()

static Datum * extract_jsp_query ( JsonPath *  jp, StrategyNumber  strat, bool  pathOps, int32 *  nentries, Pointer **  extra_data  )

static

Definition at line 748 of file jsonb_gin.c.

{
    JsonPathGinContext cxt;
    JsonPathItem root;
    JsonPathGinNode *node;
    JsonPathGinPath path = {0};
    GinEntries  entries = {0};
 
    cxt.lax = (jp->header & JSONPATH_LAX) != 0;
 
    if (pathOps)
    {
        cxt.add_path_item = jsonb_path_ops__add_path_item;
        cxt.extract_nodes = jsonb_path_ops__extract_nodes;
    }
    else
    {
        cxt.add_path_item = jsonb_ops__add_path_item;
        cxt.extract_nodes = jsonb_ops__extract_nodes;
    }
 
    jspInit(&root, jp);
 
    node = strat == JsonbJsonpathExistsStrategyNumber
        ? extract_jsp_path_expr(&cxt, path, &root, NULL)
        : extract_jsp_bool_expr(&cxt, path, &root, false);
 
    if (!node)
    {
        *nentries = 0;
        return NULL;
    }
 
    emit_jsp_gin_entries(node, &entries);
 
    *nentries = entries.count;
    if (!*nentries)
        return NULL;
 
    *extra_data = palloc0(sizeof(**extra_data) * entries.count);
    **extra_data = (Pointer) node;
 
    return entries.buf;
}

References JsonPathGinContext::add_path_item, GinEntries::buf, GinEntries::count, emit_jsp_gin_entries(), extract_jsp_bool_expr(), extract_jsp_path_expr(), JsonPathGinContext::extract_nodes, JsonPath::header, jsonb_ops__add_path_item(), jsonb_ops__extract_nodes(), jsonb_path_ops__add_path_item(), jsonb_path_ops__extract_nodes(), JsonbJsonpathExistsStrategyNumber, JSONPATH_LAX, jspInit(), JsonPathGinContext::lax, palloc0(), and root.

Referenced by gin_extract_jsonb_query(), and gin_extract_jsonb_query_path().

gin_compare_jsonb()

Datum gin_compare_jsonb

(

PG_FUNCTION_ARGS

)

Definition at line 203 of file jsonb_gin.c.

{
    text       *arg1 = PG_GETARG_TEXT_PP(0);
    text       *arg2 = PG_GETARG_TEXT_PP(1);
    int32       result;
    char       *a1p,
               *a2p;
    int         len1,
                len2;
 
    a1p = VARDATA_ANY(arg1);
    a2p = VARDATA_ANY(arg2);
 
    len1 = VARSIZE_ANY_EXHDR(arg1);
    len2 = VARSIZE_ANY_EXHDR(arg2);
 
    /* Compare text as bttextcmp does, but always using C collation */
    result = varstr_cmp(a1p, len1, a2p, len2, C_COLLATION_OID);
 
    PG_FREE_IF_COPY(arg1, 0);
    PG_FREE_IF_COPY(arg2, 1);
 
    PG_RETURN_INT32(result);
}

References PG_FREE_IF_COPY, PG_GETARG_TEXT_PP, PG_RETURN_INT32, VARDATA_ANY(), VARSIZE_ANY_EXHDR(), and varstr_cmp().

gin_consistent_jsonb()

Datum gin_consistent_jsonb

(

PG_FUNCTION_ARGS

)

Definition at line 929 of file jsonb_gin.c.

{
    bool       *check = (bool *) PG_GETARG_POINTER(0);
    StrategyNumber strategy = PG_GETARG_UINT16(1);
 
    /* Jsonb       *query = PG_GETARG_JSONB_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 == JsonbContainsStrategyNumber)
    {
        /*
         * We must always recheck, since we can't tell from the index whether
         * the positions of the matched items match the structure of the query
         * object.  (Even if we could, we'd also have to worry about hashed
         * keys and the index's failure to distinguish keys from string array
         * elements.)  However, the tuple certainly doesn't match unless it
         * contains all the query keys.
         */
        *recheck = true;
        for (i = 0; i < nkeys; i++)
        {
            if (!check[i])
            {
                res = false;
                break;
            }
        }
    }
    else if (strategy == JsonbExistsStrategyNumber)
    {
        /*
         * Although the key is certainly present in the index, we must recheck
         * because (1) the key might be hashed, and (2) the index match might
         * be for a key that's not at top level of the JSON object.  For (1),
         * we could look at the query key to see if it's hashed and not
         * recheck if not, but the index lacks enough info to tell about (2).
         */
        *recheck = true;
        res = true;
    }
    else if (strategy == JsonbExistsAnyStrategyNumber)
    {
        /* As for plain exists, we must recheck */
        *recheck = true;
        res = true;
    }
    else if (strategy == JsonbExistsAllStrategyNumber)
    {
        /* As for plain exists, we must recheck */
        *recheck = true;
        /* ... but unless all the keys are present, we can say "false" */
        for (i = 0; i < nkeys; i++)
        {
            if (!check[i])
            {
                res = false;
                break;
            }
        }
    }
    else if (strategy == JsonbJsonpathPredicateStrategyNumber ||
             strategy == JsonbJsonpathExistsStrategyNumber)
    {
        *recheck = true;
 
        if (nkeys > 0)
        {
            Assert(extra_data && extra_data[0]);
            res = execute_jsp_gin_node(extra_data[0], check, false) != GIN_FALSE;
        }
    }
    else
        elog(ERROR, "unrecognized strategy number: %d", strategy);
 
    PG_RETURN_BOOL(res);
}

References Assert(), elog, ERROR, execute_jsp_gin_node(), GIN_FALSE, i, JsonbContainsStrategyNumber, JsonbExistsAllStrategyNumber, JsonbExistsAnyStrategyNumber, JsonbExistsStrategyNumber, JsonbJsonpathExistsStrategyNumber, JsonbJsonpathPredicateStrategyNumber, PG_GETARG_INT32, PG_GETARG_POINTER, PG_GETARG_UINT16, and PG_RETURN_BOOL.

gin_consistent_jsonb_path()

Datum gin_consistent_jsonb_path

(

PG_FUNCTION_ARGS

)

Definition at line 1218 of file jsonb_gin.c.

{
    bool       *check = (bool *) PG_GETARG_POINTER(0);
    StrategyNumber strategy = PG_GETARG_UINT16(1);
 
    /* Jsonb       *query = PG_GETARG_JSONB_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 == JsonbContainsStrategyNumber)
    {
        /*
         * jsonb_path_ops is necessarily lossy, not only because of hash
         * collisions but also because it doesn't preserve complete
         * information about the structure of the JSON object.  Besides, there
         * are some special rules around the containment of raw scalars in
         * arrays that are not handled here.  So we must always recheck a
         * match.  However, if not all of the keys are present, the tuple
         * certainly doesn't match.
         */
        *recheck = true;
        for (i = 0; i < nkeys; i++)
        {
            if (!check[i])
            {
                res = false;
                break;
            }
        }
    }
    else if (strategy == JsonbJsonpathPredicateStrategyNumber ||
             strategy == JsonbJsonpathExistsStrategyNumber)
    {
        *recheck = true;
 
        if (nkeys > 0)
        {
            Assert(extra_data && extra_data[0]);
            res = execute_jsp_gin_node(extra_data[0], check, false) != GIN_FALSE;
        }
    }
    else
        elog(ERROR, "unrecognized strategy number: %d", strategy);
 
    PG_RETURN_BOOL(res);
}

References Assert(), elog, ERROR, execute_jsp_gin_node(), GIN_FALSE, i, JsonbContainsStrategyNumber, JsonbJsonpathExistsStrategyNumber, JsonbJsonpathPredicateStrategyNumber, PG_GETARG_INT32, PG_GETARG_POINTER, PG_GETARG_UINT16, and PG_RETURN_BOOL.

gin_extract_jsonb()

Datum gin_extract_jsonb

(

PG_FUNCTION_ARGS

)

Definition at line 229 of file jsonb_gin.c.

{
    Jsonb      *jb = (Jsonb *) PG_GETARG_JSONB_P(0);
    int32      *nentries = (int32 *) PG_GETARG_POINTER(1);
    int         total = JB_ROOT_COUNT(jb);
    JsonbIterator *it;
    JsonbValue  v;
    JsonbIteratorToken r;
    GinEntries  entries;
 
    /* If the root level is empty, we certainly have no keys */
    if (total == 0)
    {
        *nentries = 0;
        PG_RETURN_POINTER(NULL);
    }
 
    /* Otherwise, use 2 * root count as initial estimate of result size */
    init_gin_entries(&entries, 2 * total);
 
    it = JsonbIteratorInit(&jb->root);
 
    while ((r = JsonbIteratorNext(&it, &v, false)) != WJB_DONE)
    {
        switch (r)
        {
            case WJB_KEY:
                add_gin_entry(&entries, make_scalar_key(&v, true));
                break;
            case WJB_ELEM:
                /* Pretend string array elements are keys, see jsonb.h */
                add_gin_entry(&entries, make_scalar_key(&v, v.type == jbvString));
                break;
            case WJB_VALUE:
                add_gin_entry(&entries, make_scalar_key(&v, false));
                break;
            default:
                /* we can ignore structural items */
                break;
        }
    }
 
    *nentries = entries.count;
 
    PG_RETURN_POINTER(entries.buf);
}

References add_gin_entry(), GinEntries::buf, GinEntries::count, init_gin_entries(), JB_ROOT_COUNT, jbvString, JsonbIteratorInit(), JsonbIteratorNext(), make_scalar_key(), PG_GETARG_JSONB_P, PG_GETARG_POINTER, PG_RETURN_POINTER, Jsonb::root, JsonbValue::type, WJB_DONE, WJB_ELEM, WJB_KEY, and WJB_VALUE.

Referenced by gin_extract_jsonb_query().

gin_extract_jsonb_path()

Datum gin_extract_jsonb_path

(

PG_FUNCTION_ARGS

)

Definition at line 1088 of file jsonb_gin.c.

{
    Jsonb      *jb = PG_GETARG_JSONB_P(0);
    int32      *nentries = (int32 *) PG_GETARG_POINTER(1);
    int         total = JB_ROOT_COUNT(jb);
    JsonbIterator *it;
    JsonbValue  v;
    JsonbIteratorToken r;
    PathHashStack tail;
    PathHashStack *stack;
    GinEntries  entries;
 
    /* If the root level is empty, we certainly have no keys */
    if (total == 0)
    {
        *nentries = 0;
        PG_RETURN_POINTER(NULL);
    }
 
    /* Otherwise, use 2 * root count as initial estimate of result size */
    init_gin_entries(&entries, 2 * total);
 
    /* We keep a stack of partial hashes corresponding to parent key levels */
    tail.parent = NULL;
    tail.hash = 0;
    stack = &tail;
 
    it = JsonbIteratorInit(&jb->root);
 
    while ((r = JsonbIteratorNext(&it, &v, false)) != WJB_DONE)
    {
        PathHashStack *parent;
 
        switch (r)
        {
            case WJB_BEGIN_ARRAY:
            case WJB_BEGIN_OBJECT:
                /* Push a stack level for this object */
                parent = stack;
                stack = (PathHashStack *) palloc(sizeof(PathHashStack));
 
                /*
                 * We pass forward hashes from outer nesting levels so that
                 * the hashes for nested values will include outer keys as
                 * well as their own keys.
                 *
                 * Nesting an array within another array will not alter
                 * innermost scalar element hash values, but that seems
                 * inconsequential.
                 */
                stack->hash = parent->hash;
                stack->parent = parent;
                break;
            case WJB_KEY:
                /* mix this key into the current outer hash */
                JsonbHashScalarValue(&v, &stack->hash);
                /* hash is now ready to incorporate the value */
                break;
            case WJB_ELEM:
            case WJB_VALUE:
                /* mix the element or value's hash into the prepared hash */
                JsonbHashScalarValue(&v, &stack->hash);
                /* and emit an index entry */
                add_gin_entry(&entries, UInt32GetDatum(stack->hash));
                /* reset hash for next key, value, or sub-object */
                stack->hash = stack->parent->hash;
                break;
            case WJB_END_ARRAY:
            case WJB_END_OBJECT:
                /* Pop the stack */
                parent = stack->parent;
                pfree(stack);
                stack = parent;
                /* reset hash for next key, value, or sub-object */
                if (stack->parent)
                    stack->hash = stack->parent->hash;
                else
                    stack->hash = 0;
                break;
            default:
                elog(ERROR, "invalid JsonbIteratorNext rc: %d", (int) r);
        }
    }
 
    *nentries = entries.count;
 
    PG_RETURN_POINTER(entries.buf);
}

References add_gin_entry(), GinEntries::buf, GinEntries::count, elog, ERROR, PathHashStack::hash, init_gin_entries(), JB_ROOT_COUNT, JsonbHashScalarValue(), JsonbIteratorInit(), JsonbIteratorNext(), palloc(), PathHashStack::parent, pfree(), PG_GETARG_JSONB_P, PG_GETARG_POINTER, PG_RETURN_POINTER, Jsonb::root, UInt32GetDatum(), WJB_BEGIN_ARRAY, WJB_BEGIN_OBJECT, WJB_DONE, WJB_ELEM, WJB_END_ARRAY, WJB_END_OBJECT, WJB_KEY, and WJB_VALUE.

Referenced by gin_extract_jsonb_query_path().

gin_extract_jsonb_query()

Datum gin_extract_jsonb_query

(

PG_FUNCTION_ARGS

)

Definition at line 848 of file jsonb_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 == JsonbContainsStrategyNumber)
    {
        /* Query is a jsonb, so just apply gin_extract_jsonb... */
        entries = (Datum *)
            DatumGetPointer(DirectFunctionCall2(gin_extract_jsonb,
                                                PG_GETARG_DATUM(0),
                                                PointerGetDatum(nentries)));
        /* ...although "contains {}" requires a full index scan */
        if (*nentries == 0)
            *searchMode = GIN_SEARCH_MODE_ALL;
    }
    else if (strategy == JsonbExistsStrategyNumber)
    {
        /* Query is a text string, which we treat as a key */
        text       *query = PG_GETARG_TEXT_PP(0);
 
        *nentries = 1;
        entries = (Datum *) palloc(sizeof(Datum));
        entries[0] = make_text_key(JGINFLAG_KEY,
                                   VARDATA_ANY(query),
                                   VARSIZE_ANY_EXHDR(query));
    }
    else if (strategy == JsonbExistsAnyStrategyNumber ||
             strategy == JsonbExistsAllStrategyNumber)
    {
        /* Query is a text array; each element is treated as a key */
        ArrayType  *query = PG_GETARG_ARRAYTYPE_P(0);
        Datum      *key_datums;
        bool       *key_nulls;
        int         key_count;
        int         i,
                    j;
 
        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 */
            if (key_nulls[i])
                continue;
            /* We rely on the array elements not being toasted */
            entries[j++] = make_text_key(JGINFLAG_KEY,
                                         VARDATA_ANY(DatumGetPointer(key_datums[i])),
                                         VARSIZE_ANY_EXHDR(DatumGetPointer(key_datums[i])));
        }
 
        *nentries = j;
        /* ExistsAll with no keys should match everything */
        if (j == 0 && strategy == JsonbExistsAllStrategyNumber)
            *searchMode = GIN_SEARCH_MODE_ALL;
    }
    else if (strategy == JsonbJsonpathPredicateStrategyNumber ||
             strategy == JsonbJsonpathExistsStrategyNumber)
    {
        JsonPath   *jp = PG_GETARG_JSONPATH_P(0);
        Pointer   **extra_data = (Pointer **) PG_GETARG_POINTER(4);
 
        entries = extract_jsp_query(jp, strategy, false, nentries, extra_data);
 
        if (!entries)
            *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, extract_jsp_query(), gin_extract_jsonb(), GIN_SEARCH_MODE_ALL, i, j, JGINFLAG_KEY, JsonbContainsStrategyNumber, JsonbExistsAllStrategyNumber, JsonbExistsAnyStrategyNumber, JsonbExistsStrategyNumber, JsonbJsonpathExistsStrategyNumber, JsonbJsonpathPredicateStrategyNumber, make_text_key(), palloc(), PG_GETARG_ARRAYTYPE_P, PG_GETARG_DATUM, PG_GETARG_JSONPATH_P, PG_GETARG_POINTER, PG_GETARG_TEXT_PP, PG_GETARG_UINT16, PG_RETURN_POINTER, PointerGetDatum(), VARDATA_ANY(), and VARSIZE_ANY_EXHDR().

gin_extract_jsonb_query_path()

Datum gin_extract_jsonb_query_path

(

PG_FUNCTION_ARGS

)

Definition at line 1178 of file jsonb_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 == JsonbContainsStrategyNumber)
    {
        /* Query is a jsonb, so just apply gin_extract_jsonb_path ... */
        entries = (Datum *)
            DatumGetPointer(DirectFunctionCall2(gin_extract_jsonb_path,
                                                PG_GETARG_DATUM(0),
                                                PointerGetDatum(nentries)));
 
        /* ... although "contains {}" requires a full index scan */
        if (*nentries == 0)
            *searchMode = GIN_SEARCH_MODE_ALL;
    }
    else if (strategy == JsonbJsonpathPredicateStrategyNumber ||
             strategy == JsonbJsonpathExistsStrategyNumber)
    {
        JsonPath   *jp = PG_GETARG_JSONPATH_P(0);
        Pointer   **extra_data = (Pointer **) PG_GETARG_POINTER(4);
 
        entries = extract_jsp_query(jp, strategy, true, nentries, extra_data);
 
        if (!entries)
            *searchMode = GIN_SEARCH_MODE_ALL;
    }
    else
    {
        elog(ERROR, "unrecognized strategy number: %d", strategy);
        entries = NULL;
    }
 
    PG_RETURN_POINTER(entries);
}

References DatumGetPointer(), DirectFunctionCall2, elog, ERROR, extract_jsp_query(), gin_extract_jsonb_path(), GIN_SEARCH_MODE_ALL, JsonbContainsStrategyNumber, JsonbJsonpathExistsStrategyNumber, JsonbJsonpathPredicateStrategyNumber, PG_GETARG_DATUM, PG_GETARG_JSONPATH_P, PG_GETARG_POINTER, PG_GETARG_UINT16, PG_RETURN_POINTER, and PointerGetDatum().

gin_triconsistent_jsonb()

Datum gin_triconsistent_jsonb

(

PG_FUNCTION_ARGS

)

Definition at line 1012 of file jsonb_gin.c.

{
    GinTernaryValue *check = (GinTernaryValue *) PG_GETARG_POINTER(0);
    StrategyNumber strategy = PG_GETARG_UINT16(1);
 
    /* Jsonb       *query = PG_GETARG_JSONB_P(2); */
    int32       nkeys = PG_GETARG_INT32(3);
    Pointer    *extra_data = (Pointer *) PG_GETARG_POINTER(4);
    GinTernaryValue res = GIN_MAYBE;
    int32       i;
 
    /*
     * Note that we never return GIN_TRUE, only GIN_MAYBE or GIN_FALSE; this
     * corresponds to always forcing recheck in the regular consistent
     * function, for the reasons listed there.
     */
    if (strategy == JsonbContainsStrategyNumber ||
        strategy == JsonbExistsAllStrategyNumber)
    {
        /* All extracted keys must be present */
        for (i = 0; i < nkeys; i++)
        {
            if (check[i] == GIN_FALSE)
            {
                res = GIN_FALSE;
                break;
            }
        }
    }
    else if (strategy == JsonbExistsStrategyNumber ||
             strategy == JsonbExistsAnyStrategyNumber)
    {
        /* At least one extracted key must be present */
        res = GIN_FALSE;
        for (i = 0; i < nkeys; i++)
        {
            if (check[i] == GIN_TRUE ||
                check[i] == GIN_MAYBE)
            {
                res = GIN_MAYBE;
                break;
            }
        }
    }
    else if (strategy == JsonbJsonpathPredicateStrategyNumber ||
             strategy == JsonbJsonpathExistsStrategyNumber)
    {
        if (nkeys > 0)
        {
            Assert(extra_data && extra_data[0]);
            res = execute_jsp_gin_node(extra_data[0], check, true);
 
            /* Should always recheck the result */
            if (res == GIN_TRUE)
                res = GIN_MAYBE;
        }
    }
    else
        elog(ERROR, "unrecognized strategy number: %d", strategy);
 
    PG_RETURN_GIN_TERNARY_VALUE(res);
}

References Assert(), elog, ERROR, execute_jsp_gin_node(), GIN_FALSE, GIN_MAYBE, GIN_TRUE, i, JsonbContainsStrategyNumber, JsonbExistsAllStrategyNumber, JsonbExistsAnyStrategyNumber, JsonbExistsStrategyNumber, JsonbJsonpathExistsStrategyNumber, JsonbJsonpathPredicateStrategyNumber, PG_GETARG_INT32, PG_GETARG_POINTER, PG_GETARG_UINT16, and PG_RETURN_GIN_TERNARY_VALUE.

gin_triconsistent_jsonb_path()

Datum gin_triconsistent_jsonb_path

(

PG_FUNCTION_ARGS

)

Definition at line 1269 of file jsonb_gin.c.

{
    GinTernaryValue *check = (GinTernaryValue *) PG_GETARG_POINTER(0);
    StrategyNumber strategy = PG_GETARG_UINT16(1);
 
    /* Jsonb       *query = PG_GETARG_JSONB_P(2); */
    int32       nkeys = PG_GETARG_INT32(3);
    Pointer    *extra_data = (Pointer *) PG_GETARG_POINTER(4);
    GinTernaryValue res = GIN_MAYBE;
    int32       i;
 
    if (strategy == JsonbContainsStrategyNumber)
    {
        /*
         * Note that we never return GIN_TRUE, only GIN_MAYBE or GIN_FALSE;
         * this corresponds to always forcing recheck in the regular
         * consistent function, for the reasons listed there.
         */
        for (i = 0; i < nkeys; i++)
        {
            if (check[i] == GIN_FALSE)
            {
                res = GIN_FALSE;
                break;
            }
        }
    }
    else if (strategy == JsonbJsonpathPredicateStrategyNumber ||
             strategy == JsonbJsonpathExistsStrategyNumber)
    {
        if (nkeys > 0)
        {
            Assert(extra_data && extra_data[0]);
            res = execute_jsp_gin_node(extra_data[0], check, true);
 
            /* Should always recheck the result */
            if (res == GIN_TRUE)
                res = GIN_MAYBE;
        }
    }
    else
        elog(ERROR, "unrecognized strategy number: %d", strategy);
 
    PG_RETURN_GIN_TERNARY_VALUE(res);
}

References Assert(), elog, ERROR, execute_jsp_gin_node(), GIN_FALSE, GIN_MAYBE, GIN_TRUE, i, JsonbContainsStrategyNumber, JsonbJsonpathExistsStrategyNumber, JsonbJsonpathPredicateStrategyNumber, PG_GETARG_INT32, PG_GETARG_POINTER, PG_GETARG_UINT16, and PG_RETURN_GIN_TERNARY_VALUE.

init_gin_entries()

static void init_gin_entries ( GinEntries *  entries, int  preallocated  )

static

Definition at line 163 of file jsonb_gin.c.

{
    entries->allocated = preallocated;
    entries->buf = preallocated ? palloc(sizeof(Datum) * preallocated) : NULL;
    entries->count = 0;
}

References GinEntries::allocated, GinEntries::buf, GinEntries::count, and palloc().

Referenced by gin_extract_jsonb(), and gin_extract_jsonb_path().

jsonb_ops__add_path_item()

static bool jsonb_ops__add_path_item ( JsonPathGinPath *  path, JsonPathItem *  jsp  )

static

Definition at line 278 of file jsonb_gin.c.

{
    JsonPathGinPathItem *pentry;
    Datum       keyName;
 
    switch (jsp->type)
    {
        case jpiRoot:
            path->items = NULL; /* reset path */
            return true;
 
        case jpiKey:
            {
                int         len;
                char       *key = jspGetString(jsp, &len);
 
                keyName = make_text_key(JGINFLAG_KEY, key, len);
                break;
            }
 
        case jpiAny:
        case jpiAnyKey:
        case jpiAnyArray:
        case jpiIndexArray:
            keyName = PointerGetDatum(NULL);
            break;
 
        default:
            /* other path items like item methods are not supported */
            return false;
    }
 
    pentry = palloc(sizeof(*pentry));
 
    pentry->type = jsp->type;
    pentry->keyName = keyName;
    pentry->parent = path->items;
 
    path->items = pentry;
 
    return true;
}

References JsonPathGinPath::items, JGINFLAG_KEY, jpiAny, jpiAnyArray, jpiAnyKey, jpiIndexArray, jpiKey, jpiRoot, jspGetString(), sort-test::key, JsonPathGinPathItem::keyName, len, make_text_key(), palloc(), JsonPathGinPathItem::parent, PointerGetDatum(), JsonPathGinPathItem::type, and JsonPathItem::type.

Referenced by extract_jsp_query().

jsonb_ops__extract_nodes()

static List * jsonb_ops__extract_nodes ( JsonPathGinContext *  cxt, JsonPathGinPath  path, JsonbValue *  scalar, List *  nodes  )

static

Definition at line 408 of file jsonb_gin.c.

{
    JsonPathGinPathItem *pentry;
 
    if (scalar)
    {
        JsonPathGinNode *node;
 
        /*
         * Append path entry nodes only if scalar is provided.  See header
         * comment for details.
         */
        for (pentry = path.items; pentry; pentry = pentry->parent)
        {
            if (pentry->type == jpiKey) /* only keys are indexed */
                nodes = lappend(nodes, make_jsp_entry_node(pentry->keyName));
        }
 
        /* Append scalar node for equality queries. */
        if (scalar->type == jbvString)
        {
            JsonPathGinPathItem *last = path.items;
            GinTernaryValue key_entry;
 
            /*
             * Assuming that jsonb_ops interprets string array elements as
             * keys, we may extract key or non-key entry or even both.  In the
             * latter case we create OR-node.  It is possible in lax mode
             * where arrays are automatically unwrapped, or in strict mode for
             * jpiAny items.
             */
 
            if (cxt->lax)
                key_entry = GIN_MAYBE;
            else if (!last)     /* root ($) */
                key_entry = GIN_FALSE;
            else if (last->type == jpiAnyArray || last->type == jpiIndexArray)
                key_entry = GIN_TRUE;
            else if (last->type == jpiAny)
                key_entry = GIN_MAYBE;
            else
                key_entry = GIN_FALSE;
 
            if (key_entry == GIN_MAYBE)
            {
                JsonPathGinNode *n1 = make_jsp_entry_node_scalar(scalar, true);
                JsonPathGinNode *n2 = make_jsp_entry_node_scalar(scalar, false);
 
                node = make_jsp_expr_node_binary(JSP_GIN_OR, n1, n2);
            }
            else
            {
                node = make_jsp_entry_node_scalar(scalar,
                                                  key_entry == GIN_TRUE);
            }
        }
        else
        {
            node = make_jsp_entry_node_scalar(scalar, false);
        }
 
        nodes = lappend(nodes, node);
    }
 
    return nodes;
}

References GIN_FALSE, GIN_MAYBE, GIN_TRUE, JsonPathGinPath::items, jbvString, jpiAny, jpiAnyArray, jpiIndexArray, jpiKey, JSP_GIN_OR, JsonPathGinPathItem::keyName, lappend(), JsonPathGinContext::lax, make_jsp_entry_node(), make_jsp_entry_node_scalar(), make_jsp_expr_node_binary(), JsonPathGinPathItem::parent, JsonPathGinPathItem::type, and JsonbValue::type.

Referenced by extract_jsp_query().

jsonb_path_ops__add_path_item()

static bool jsonb_path_ops__add_path_item ( JsonPathGinPath *  path, JsonPathItem *  jsp  )

static

Definition at line 323 of file jsonb_gin.c.

{
    switch (jsp->type)
    {
        case jpiRoot:
            path->hash = 0;     /* reset path hash */
            return true;
 
        case jpiKey:
            {
                JsonbValue  jbv;
 
                jbv.type = jbvString;
                jbv.val.string.val = jspGetString(jsp, &jbv.val.string.len);
 
                JsonbHashScalarValue(&jbv, &path->hash);
                return true;
            }
 
        case jpiIndexArray:
        case jpiAnyArray:
            return true;        /* path hash is unchanged */
 
        default:
            /* other items (wildcard paths, item methods) are not supported */
            return false;
    }
}

References JsonPathGinPath::hash, jbvString, jpiAnyArray, jpiIndexArray, jpiKey, jpiRoot, JsonbHashScalarValue(), jspGetString(), JsonbValue::type, JsonPathItem::type, and JsonbValue::val.

Referenced by extract_jsp_query().

jsonb_path_ops__extract_nodes()

static List * jsonb_path_ops__extract_nodes ( JsonPathGinContext *  cxt, JsonPathGinPath  path, JsonbValue *  scalar, List *  nodes  )

static

Definition at line 478 of file jsonb_gin.c.

{
    if (scalar)
    {
        /* append path hash node for equality queries */
        uint32      hash = path.hash;
 
        JsonbHashScalarValue(scalar, &hash);
 
        return lappend(nodes,
                       make_jsp_entry_node(UInt32GetDatum(hash)));
    }
    else
    {
        /* jsonb_path_ops doesn't support EXISTS queries => nothing to append */
        return nodes;
    }
}

References hash(), JsonPathGinPath::hash, JsonbHashScalarValue(), lappend(), make_jsp_entry_node(), and UInt32GetDatum().

Referenced by extract_jsp_query().

make_jsp_entry_node()

static JsonPathGinNode * make_jsp_entry_node ( Datum  entry )

static

Definition at line 353 of file jsonb_gin.c.

{
    JsonPathGinNode *node = palloc(offsetof(JsonPathGinNode, args));
 
    node->type = JSP_GIN_ENTRY;
    node->val.entryDatum = entry;
 
    return node;
}

References generate_unaccent_rules::args, JsonPathGinNode::entryDatum, JSP_GIN_ENTRY, palloc(), JsonPathGinNode::type, and JsonPathGinNode::val.

Referenced by jsonb_ops__extract_nodes(), jsonb_path_ops__extract_nodes(), and make_jsp_entry_node_scalar().

make_jsp_entry_node_scalar()

static JsonPathGinNode * make_jsp_entry_node_scalar ( JsonbValue *  scalar, bool  iskey  )

static

Definition at line 364 of file jsonb_gin.c.

{
    return make_jsp_entry_node(make_scalar_key(scalar, iskey));
}

References make_jsp_entry_node(), and make_scalar_key().

Referenced by jsonb_ops__extract_nodes().

make_jsp_expr_node()

static JsonPathGinNode * make_jsp_expr_node ( JsonPathGinNodeType  type, int  nargs  )

static

Definition at line 370 of file jsonb_gin.c.

{
    JsonPathGinNode *node = palloc(offsetof(JsonPathGinNode, args) +
                                   sizeof(node->args[0]) * nargs);
 
    node->type = type;
    node->val.nargs = nargs;
 
    return node;
}

References generate_unaccent_rules::args, JsonPathGinNode::args, JsonPathGinNode::nargs, palloc(), type, JsonPathGinNode::type, and JsonPathGinNode::val.

Referenced by make_jsp_expr_node_args(), and make_jsp_expr_node_binary().

make_jsp_expr_node_args()

static JsonPathGinNode * make_jsp_expr_node_args ( JsonPathGinNodeType  type, List *  args  )

static

Definition at line 382 of file jsonb_gin.c.

{
    JsonPathGinNode *node = make_jsp_expr_node(type, list_length(args));
    ListCell   *lc;
    int         i = 0;
 
    foreach(lc, args)
        node->args[i++] = lfirst(lc);
 
    return node;
}

References generate_unaccent_rules::args, JsonPathGinNode::args, i, lfirst, list_length(), make_jsp_expr_node(), and type.

Referenced by extract_jsp_path_expr().

make_jsp_expr_node_binary()

static JsonPathGinNode * make_jsp_expr_node_binary ( JsonPathGinNodeType  type, JsonPathGinNode *  arg1, JsonPathGinNode *  arg2  )

static

Definition at line 395 of file jsonb_gin.c.

{
    JsonPathGinNode *node = make_jsp_expr_node(type, 2);
 
    node->args[0] = arg1;
    node->args[1] = arg2;
 
    return node;
}

References JsonPathGinNode::args, make_jsp_expr_node(), and type.

Referenced by extract_jsp_bool_expr(), and jsonb_ops__extract_nodes().

make_scalar_key()

static Datum make_scalar_key ( const JsonbValue *  scalarVal, bool  is_key  )

static

Definition at line 1360 of file jsonb_gin.c.

{
    Datum       item;
    char       *cstr;
 
    switch (scalarVal->type)
    {
        case jbvNull:
            Assert(!is_key);
            item = make_text_key(JGINFLAG_NULL, "", 0);
            break;
        case jbvBool:
            Assert(!is_key);
            item = make_text_key(JGINFLAG_BOOL,
                                 scalarVal->val.boolean ? "t" : "f", 1);
            break;
        case jbvNumeric:
            Assert(!is_key);
 
            /*
             * A normalized textual representation, free of trailing zeroes,
             * is required so that numerically equal values will produce equal
             * strings.
             *
             * It isn't ideal that numerics are stored in a relatively bulky
             * textual format.  However, it's a notationally convenient way of
             * storing a "union" type in the GIN B-Tree, and indexing Jsonb
             * strings takes precedence.
             */
            cstr = numeric_normalize(scalarVal->val.numeric);
            item = make_text_key(JGINFLAG_NUM, cstr, strlen(cstr));
            pfree(cstr);
            break;
        case jbvString:
            item = make_text_key(is_key ? JGINFLAG_KEY : JGINFLAG_STR,
                                 scalarVal->val.string.val,
                                 scalarVal->val.string.len);
            break;
        default:
            elog(ERROR, "unrecognized jsonb scalar type: %d", scalarVal->type);
            item = 0;           /* keep compiler quiet */
            break;
    }
 
    return item;
}

References Assert(), elog, ERROR, jbvBool, jbvNull, jbvNumeric, jbvString, JGINFLAG_BOOL, JGINFLAG_KEY, JGINFLAG_NULL, JGINFLAG_NUM, JGINFLAG_STR, make_text_key(), numeric_normalize(), pfree(), JsonbValue::type, and JsonbValue::val.

Referenced by gin_extract_jsonb(), and make_jsp_entry_node_scalar().

make_text_key()

static Datum make_text_key ( char  flag, const char *  str, int  len  )

static

Definition at line 1322 of file jsonb_gin.c.

{
    text       *item;
    char        hashbuf[10];
 
    if (len > JGIN_MAXLENGTH)
    {
        uint32      hashval;
 
        hashval = DatumGetUInt32(hash_any((const unsigned char *) str, len));
        snprintf(hashbuf, sizeof(hashbuf), "%08x", hashval);
        str = hashbuf;
        len = 8;
        flag |= JGINFLAG_HASHED;
    }
 
    /*
     * Now build the text Datum.  For simplicity we build a 4-byte-header
     * varlena text Datum here, but we expect it will get converted to short
     * header format when stored in the index.
     */
    item = (text *) palloc(VARHDRSZ + len + 1);
    SET_VARSIZE(item, VARHDRSZ + len + 1);
 
    *VARDATA(item) = flag;
 
    memcpy(VARDATA(item) + 1, str, len);
 
    return PointerGetDatum(item);
}

References DatumGetUInt32(), flag(), hash_any(), JGIN_MAXLENGTH, JGINFLAG_HASHED, len, palloc(), PointerGetDatum(), SET_VARSIZE(), snprintf, str, VARDATA(), and VARHDRSZ.

Referenced by gin_extract_jsonb_query(), jsonb_ops__add_path_item(), and make_scalar_key().