pg_ndistinct.c File Reference

#include "postgres.h"
#include "common/int.h"
#include "common/jsonapi.h"
#include "lib/stringinfo.h"
#include "mb/pg_wchar.h"
#include "nodes/miscnodes.h"
#include "statistics/extended_stats_internal.h"
#include "statistics/statistics_format.h"
#include "utils/builtins.h"
#include "utils/fmgrprotos.h"

Include dependency graph for pg_ndistinct.c:

Go to the source code of this file.

Data Structures
struct	NDistinctParseState

Enumerations
enum	NDistinctSemanticState {   NDIST_EXPECT_START = 0 , NDIST_EXPECT_ITEM , NDIST_EXPECT_KEY , NDIST_EXPECT_ATTNUM_LIST ,   NDIST_EXPECT_ATTNUM , NDIST_EXPECT_NDISTINCT , NDIST_EXPECT_COMPLETE }

Functions
static JsonParseErrorType	ndistinct_object_start (void *state)
static JsonParseErrorType	ndistinct_object_end (void *state)
static JsonParseErrorType	ndistinct_array_start (void *state)
static JsonParseErrorType	ndistinct_array_end (void *state)
static JsonParseErrorType	ndistinct_object_field_start (void *state, char *fname, bool isnull)
static JsonParseErrorType	ndistinct_array_element_start (void *state, bool isnull)
static bool	valid_subsequent_attnum (AttrNumber prev, AttrNumber cur)
static JsonParseErrorType	ndistinct_scalar (void *state, char *token, JsonTokenType tokentype)
static bool	item_attributes_eq (const MVNDistinctItem *a, const MVNDistinctItem *b)
static bool	item_has_attnum (const MVNDistinctItem *item, AttrNumber attnum)
static bool	item_is_attnum_subset (const MVNDistinctItem *item, const MVNDistinctItem *refitem)
static char *	item_attnum_list (const MVNDistinctItem *item)
static bytea *	build_mvndistinct (NDistinctParseState *parse, char *str)
Datum	pg_ndistinct_in (PG_FUNCTION_ARGS)
Datum	pg_ndistinct_out (PG_FUNCTION_ARGS)
Datum	pg_ndistinct_recv (PG_FUNCTION_ARGS)
Datum	pg_ndistinct_send (PG_FUNCTION_ARGS)

Enumeration Type Documentation

NDistinctSemanticState

enum NDistinctSemanticState

Enumerator
NDIST_EXPECT_START
NDIST_EXPECT_ITEM
NDIST_EXPECT_KEY
NDIST_EXPECT_ATTNUM_LIST
NDIST_EXPECT_ATTNUM
NDIST_EXPECT_NDISTINCT
NDIST_EXPECT_COMPLETE

Definition at line 28 of file pg_ndistinct.c.

{
    NDIST_EXPECT_START = 0,
    NDIST_EXPECT_ITEM,
    NDIST_EXPECT_KEY,
    NDIST_EXPECT_ATTNUM_LIST,
    NDIST_EXPECT_ATTNUM,
    NDIST_EXPECT_NDISTINCT,
    NDIST_EXPECT_COMPLETE,
} NDistinctSemanticState;

Function Documentation

build_mvndistinct()

static bytea * build_mvndistinct ( NDistinctParseState *  parse, char *  str  )

static

Definition at line 588 of file pg_ndistinct.c.

{
    MVNDistinct *ndistinct;
    int         nitems = list_length(parse->distinct_items);
    bytea      *bytes;
    int         item_most_attrs = 0;
    int         item_most_attrs_idx = 0;
 
    switch (parse->state)
    {
        case NDIST_EXPECT_COMPLETE:
 
            /*
             * Parsing has ended correctly and we should have a list of items.
             * If we don't, something has been done wrong in one of the
             * earlier parsing steps.
             */
            if (nitems == 0)
                elog(ERROR,
                     "cannot have empty item list after parsing success.");
            break;
 
        case NDIST_EXPECT_START:
            /* blank */
            errsave(parse->escontext,
                    errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
                    errmsg("malformed pg_ndistinct: \"%s\"", str),
                    errdetail("Value cannot be empty."));
            return NULL;
 
        default:
            /* Unexpected end-state. */
            errsave(parse->escontext,
                    errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
                    errmsg("malformed pg_ndistinct: \"%s\"", str),
                    errdetail("Unexpected end state has been found: %d.", parse->state));
            return NULL;
    }
 
    ndistinct = palloc(offsetof(MVNDistinct, items) +
                       nitems * sizeof(MVNDistinctItem));
 
    ndistinct->magic = STATS_NDISTINCT_MAGIC;
    ndistinct->type = STATS_NDISTINCT_TYPE_BASIC;
    ndistinct->nitems = nitems;
 
    for (int i = 0; i < nitems; i++)
    {
        MVNDistinctItem *item = list_nth(parse->distinct_items, i);
 
        /*
         * Ensure that this item does not duplicate the attributes of any
         * pre-existing item.
         */
        for (int j = 0; j < i; j++)
        {
            if (item_attributes_eq(item, &ndistinct->items[j]))
            {
                char       *s = item_attnum_list(item);
 
                errsave(parse->escontext,
                        errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
                        errmsg("malformed pg_ndistinct: \"%s\"", str),
                        errdetail("Duplicated \"%s\" array has been found: [%s].",
                                  PG_NDISTINCT_KEY_ATTRIBUTES, s));
                pfree(s);
                return NULL;
            }
        }
 
        ndistinct->items[i].ndistinct = item->ndistinct;
        ndistinct->items[i].nattributes = item->nattributes;
 
        /*
         * This transfers free-ing responsibility from the distinct_items list
         * to the ndistinct object.
         */
        ndistinct->items[i].attributes = item->attributes;
 
        /*
         * Keep track of the first longest attribute list. All other attribute
         * lists must be a subset of this list.
         */
        if (item->nattributes > item_most_attrs)
        {
            item_most_attrs = item->nattributes;
            item_most_attrs_idx = i;
        }
    }
 
    /*
     * Verify that all the sets of attribute numbers are a proper subset of
     * the longest set recorded.  This acts as an extra sanity check based on
     * the input given.  Note that this still needs to be cross-checked with
     * the extended statistics objects this would be assigned to, but it
     * provides one extra layer of protection.
     */
    for (int i = 0; i < nitems; i++)
    {
        if (i == item_most_attrs_idx)
            continue;
 
        if (!item_is_attnum_subset(&ndistinct->items[i],
                                   &ndistinct->items[item_most_attrs_idx]))
        {
            const MVNDistinctItem *item = &ndistinct->items[i];
            const MVNDistinctItem *refitem = &ndistinct->items[item_most_attrs_idx];
            char       *item_list = item_attnum_list(item);
            char       *refitem_list = item_attnum_list(refitem);
 
            errsave(parse->escontext,
                    errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
                    errmsg("malformed pg_ndistinct: \"%s\"", str),
                    errdetail("\"%s\" array [%s] must be a subset of array [%s].",
                              PG_NDISTINCT_KEY_ATTRIBUTES,
                              item_list, refitem_list));
            pfree(item_list);
            pfree(refitem_list);
            return NULL;
        }
    }
 
    bytes = statext_ndistinct_serialize(ndistinct);
 
    /*
     * Free the attribute lists, before the ndistinct itself.
     */
    for (int i = 0; i < nitems; i++)
        pfree(ndistinct->items[i].attributes);
    pfree(ndistinct);
 
    return bytes;
}

References MVNDistinctItem::attributes, elog, errcode(), errdetail(), errmsg(), ERROR, errsave, i, item_attnum_list(), item_attributes_eq(), item_is_attnum_subset(), MVNDistinct::items, items, j, list_length(), list_nth(), MVNDistinct::magic, MVNDistinctItem::nattributes, NDIST_EXPECT_COMPLETE, NDIST_EXPECT_START, MVNDistinctItem::ndistinct, MVNDistinct::nitems, nitems, palloc(), parse(), pfree(), PG_NDISTINCT_KEY_ATTRIBUTES, statext_ndistinct_serialize(), STATS_NDISTINCT_MAGIC, STATS_NDISTINCT_TYPE_BASIC, str, and MVNDistinct::type.

Referenced by pg_ndistinct_in().

item_attnum_list()

static char * item_attnum_list ( const MVNDistinctItem *  item )

static

Definition at line 566 of file pg_ndistinct.c.

{
    StringInfoData str;
 
    initStringInfo(&str);
 
    appendStringInfo(&str, "%d", item->attributes[0]);
 
    for (int i = 1; i < item->nattributes; i++)
        appendStringInfo(&str, ", %d", item->attributes[i]);
 
    return str.data;
}

References appendStringInfo(), MVNDistinctItem::attributes, i, initStringInfo(), MVNDistinctItem::nattributes, and str.

Referenced by build_mvndistinct().

item_attributes_eq()

static bool item_attributes_eq ( const MVNDistinctItem *  a, const MVNDistinctItem *  b  )

static

Definition at line 515 of file pg_ndistinct.c.

{
    if (a->nattributes != b->nattributes)
        return false;
 
    for (int i = 0; i < a->nattributes; i++)
    {
        if (a->attributes[i] != b->attributes[i])
            return false;
    }
 
    return true;
}

References a, b, and i.

Referenced by build_mvndistinct().

item_has_attnum()

static bool item_has_attnum ( const MVNDistinctItem *  item, AttrNumber  attnum  )

static

Definition at line 534 of file pg_ndistinct.c.

{
    for (int i = 0; i < item->nattributes; i++)
    {
        if (attnum == item->attributes[i])
            return true;
    }
    return false;
}

References attnum, MVNDistinctItem::attributes, i, and MVNDistinctItem::nattributes.

Referenced by item_is_attnum_subset().

item_is_attnum_subset()

static bool item_is_attnum_subset ( const MVNDistinctItem *  item, const MVNDistinctItem *  refitem  )

static

Definition at line 549 of file pg_ndistinct.c.

{
    for (int i = 0; i < item->nattributes; i++)
    {
        if (!item_has_attnum(refitem, item->attributes[i]))
            return false;
    }
    return true;
}

References MVNDistinctItem::attributes, i, item_has_attnum(), and MVNDistinctItem::nattributes.

Referenced by build_mvndistinct().

ndistinct_array_element_start()

static JsonParseErrorType ndistinct_array_element_start ( void *  state, bool  isnull  )

static

Definition at line 353 of file pg_ndistinct.c.

{
    const NDistinctParseState *parse = state;
 
    switch (parse->state)
    {
        case NDIST_EXPECT_ATTNUM:
            if (!isnull)
                return JSON_SUCCESS;
 
            errsave(parse->escontext,
                    errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
                    errmsg("malformed pg_ndistinct: \"%s\"", parse->str),
                    errdetail("Attribute number array cannot be null."));
            break;
 
        case NDIST_EXPECT_ITEM:
            if (!isnull)
                return JSON_SUCCESS;
 
            errsave(parse->escontext,
                    errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
                    errmsg("malformed pg_ndistinct: \"%s\"", parse->str),
                    errdetail("Item list elements cannot be null."));
 
            break;
 
        default:
            elog(ERROR,
                 "array element start of \"%s\" found in unexpected parse state: %d.",
                 "pg_ndistinct", (int) parse->state);
            break;
    }
 
    return JSON_SEM_ACTION_FAILED;
}

References elog, errcode(), errdetail(), errmsg(), ERROR, errsave, JSON_SEM_ACTION_FAILED, JSON_SUCCESS, NDIST_EXPECT_ATTNUM, NDIST_EXPECT_ITEM, and parse().

Referenced by pg_ndistinct_in().

ndistinct_array_end()

static JsonParseErrorType ndistinct_array_end ( void *  state )

static

Definition at line 240 of file pg_ndistinct.c.

{
    NDistinctParseState *parse = state;
 
    switch (parse->state)
    {
        case NDIST_EXPECT_ATTNUM:
            if (list_length(parse->attnum_list) > 0)
            {
                /*
                 * The attribute number list is complete, look for more
                 * MVNDistinctItem keys.
                 */
                parse->state = NDIST_EXPECT_KEY;
                return JSON_SUCCESS;
            }
 
            errsave(parse->escontext,
                    errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
                    errmsg("malformed pg_ndistinct: \"%s\"", parse->str),
                    errdetail("The \"%s\" key must be a non-empty array.",
                              PG_NDISTINCT_KEY_ATTRIBUTES));
            break;
 
        case NDIST_EXPECT_ITEM:
            if (list_length(parse->distinct_items) > 0)
            {
                /* Item list is complete, we are done. */
                parse->state = NDIST_EXPECT_COMPLETE;
                return JSON_SUCCESS;
            }
 
            errsave(parse->escontext,
                    errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
                    errmsg("malformed pg_ndistinct: \"%s\"", parse->str),
                    errdetail("Item array cannot be empty."));
            break;
 
        default:
 
            /*
             * This can only happen if a case was missed in
             * ndistinct_array_start().
             */
            elog(ERROR,
                 "array end of \"%s\" found in unexpected parse state: %d.",
                 "pg_ndistinct", (int) parse->state);
            break;
    }
 
    return JSON_SEM_ACTION_FAILED;
}

References elog, errcode(), errdetail(), errmsg(), ERROR, errsave, JSON_SEM_ACTION_FAILED, JSON_SUCCESS, list_length(), NDIST_EXPECT_ATTNUM, NDIST_EXPECT_COMPLETE, NDIST_EXPECT_ITEM, NDIST_EXPECT_KEY, parse(), and PG_NDISTINCT_KEY_ATTRIBUTES.

Referenced by pg_ndistinct_in().

ndistinct_array_start()

static JsonParseErrorType ndistinct_array_start ( void *  state )

static

Definition at line 208 of file pg_ndistinct.c.

{
    NDistinctParseState *parse = state;
 
    switch (parse->state)
    {
        case NDIST_EXPECT_ATTNUM_LIST:
            parse->state = NDIST_EXPECT_ATTNUM;
            break;
 
        case NDIST_EXPECT_START:
            parse->state = NDIST_EXPECT_ITEM;
            break;
 
        default:
            errsave(parse->escontext,
                    errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
                    errmsg("malformed pg_ndistinct: \"%s\"", parse->str),
                    errdetail("Array has been found at an unexpected location."));
            return JSON_SEM_ACTION_FAILED;
    }
 
    return JSON_SUCCESS;
}

References errcode(), errdetail(), errmsg(), errsave, JSON_SEM_ACTION_FAILED, JSON_SUCCESS, NDIST_EXPECT_ATTNUM, NDIST_EXPECT_ATTNUM_LIST, NDIST_EXPECT_ITEM, NDIST_EXPECT_START, and parse().

Referenced by pg_ndistinct_in().

ndistinct_object_end()

static JsonParseErrorType ndistinct_object_end ( void *  state )

static

Definition at line 129 of file pg_ndistinct.c.

{
    NDistinctParseState *parse = state;
 
    int         natts = 0;
 
    MVNDistinctItem *item;
 
    if (parse->state != NDIST_EXPECT_KEY)
        elog(ERROR,
             "object end of \"%s\" found in unexpected parse state: %d.",
             "pg_ndistinct", (int) parse->state);
 
    if (!parse->found_attributes)
    {
        errsave(parse->escontext,
                errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
                errmsg("malformed pg_ndistinct: \"%s\"", parse->str),
                errdetail("Item must contain \"%s\" key.",
                          PG_NDISTINCT_KEY_ATTRIBUTES));
        return JSON_SEM_ACTION_FAILED;
    }
 
    if (!parse->found_ndistinct)
    {
        errsave(parse->escontext,
                errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
                errmsg("malformed pg_ndistinct: \"%s\"", parse->str),
                errdetail("Item must contain \"%s\" key.",
                          PG_NDISTINCT_KEY_NDISTINCT));
        return JSON_SEM_ACTION_FAILED;
    }
 
    /*
     * We need at least two attribute numbers for a ndistinct item, anything
     * less is malformed.
     */
    natts = list_length(parse->attnum_list);
    if ((natts < 2) || (natts > STATS_MAX_DIMENSIONS))
    {
        errsave(parse->escontext,
                errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
                errmsg("malformed pg_ndistinct: \"%s\"", parse->str),
                errdetail("The \"%s\" key must contain an array of at least %d and no more than %d attributes.",
                          PG_NDISTINCT_KEY_ATTRIBUTES, 2, STATS_MAX_DIMENSIONS));
        return JSON_SEM_ACTION_FAILED;
    }
 
    /* Create the MVNDistinctItem */
    item = palloc_object(MVNDistinctItem);
    item->nattributes = natts;
    item->attributes = palloc0(natts * sizeof(AttrNumber));
    item->ndistinct = (double) parse->ndistinct;
 
    for (int i = 0; i < natts; i++)
        item->attributes[i] = (AttrNumber) list_nth_int(parse->attnum_list, i);
 
    parse->distinct_items = lappend(parse->distinct_items, (void *) item);
 
    /* reset item state vars */
    list_free(parse->attnum_list);
    parse->attnum_list = NIL;
    parse->ndistinct = 0;
    parse->found_attributes = false;
    parse->found_ndistinct = false;
 
    /* Now we are looking for the next MVNDistinctItem */
    parse->state = NDIST_EXPECT_ITEM;
    return JSON_SUCCESS;
}

References MVNDistinctItem::attributes, elog, errcode(), errdetail(), errmsg(), ERROR, errsave, for(), i, JSON_SEM_ACTION_FAILED, JSON_SUCCESS, lappend(), list_free(), list_length(), list_nth_int(), MVNDistinctItem::nattributes, NDIST_EXPECT_ITEM, NDIST_EXPECT_KEY, MVNDistinctItem::ndistinct, NIL, palloc0(), palloc_object, parse(), PG_NDISTINCT_KEY_ATTRIBUTES, PG_NDISTINCT_KEY_NDISTINCT, and STATS_MAX_DIMENSIONS.

Referenced by pg_ndistinct_in().

ndistinct_object_field_start()

static JsonParseErrorType ndistinct_object_field_start ( void *  state, char *  fname, bool  isnull  )

static

Definition at line 301 of file pg_ndistinct.c.

{
    NDistinctParseState *parse = state;
 
    if (strcmp(fname, PG_NDISTINCT_KEY_ATTRIBUTES) == 0)
    {
        if (parse->found_attributes)
        {
            errsave(parse->escontext,
                    errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
                    errmsg("malformed pg_ndistinct: \"%s\"", parse->str),
                    errdetail("Multiple \"%s\" keys are not allowed.",
                              PG_NDISTINCT_KEY_ATTRIBUTES));
            return JSON_SEM_ACTION_FAILED;
        }
        parse->found_attributes = true;
        parse->state = NDIST_EXPECT_ATTNUM_LIST;
        return JSON_SUCCESS;
    }
 
    if (strcmp(fname, PG_NDISTINCT_KEY_NDISTINCT) == 0)
    {
        if (parse->found_ndistinct)
        {
            errsave(parse->escontext,
                    errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
                    errmsg("malformed pg_ndistinct: \"%s\"", parse->str),
                    errdetail("Multiple \"%s\" keys are not allowed.",
                              PG_NDISTINCT_KEY_NDISTINCT));
            return JSON_SEM_ACTION_FAILED;
        }
        parse->found_ndistinct = true;
        parse->state = NDIST_EXPECT_NDISTINCT;
        return JSON_SUCCESS;
    }
 
    errsave(parse->escontext,
            errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
            errmsg("malformed pg_ndistinct: \"%s\"", parse->str),
            errdetail("Only allowed keys are \"%s\" and \"%s\".",
                      PG_NDISTINCT_KEY_ATTRIBUTES,
                      PG_NDISTINCT_KEY_NDISTINCT));
    return JSON_SEM_ACTION_FAILED;
}

References errcode(), errdetail(), errmsg(), errsave, JSON_SEM_ACTION_FAILED, JSON_SUCCESS, NDIST_EXPECT_ATTNUM_LIST, NDIST_EXPECT_NDISTINCT, parse(), PG_NDISTINCT_KEY_ATTRIBUTES, and PG_NDISTINCT_KEY_NDISTINCT.

Referenced by pg_ndistinct_in().

ndistinct_object_start()

static JsonParseErrorType ndistinct_object_start ( void *  state )

static

Definition at line 60 of file pg_ndistinct.c.

{
    NDistinctParseState *parse = state;
 
    switch (parse->state)
    {
        case NDIST_EXPECT_ITEM:
            /* Now we expect to see attributes/ndistinct keys */
            parse->state = NDIST_EXPECT_KEY;
            return JSON_SUCCESS;
 
        case NDIST_EXPECT_START:
            /* pg_ndistinct must begin with a '[' */
            errsave(parse->escontext,
                    errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
                    errmsg("malformed pg_ndistinct: \"%s\"", parse->str),
                    errdetail("Initial element must be an array."));
            break;
 
        case NDIST_EXPECT_KEY:
            /* In an object, expecting key */
            errsave(parse->escontext,
                    errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
                    errmsg("malformed pg_ndistinct: \"%s\"", parse->str),
                    errdetail("A key was expected."));
            break;
 
        case NDIST_EXPECT_ATTNUM_LIST:
            /* Just followed an "attributes" key */
            errsave(parse->escontext,
                    errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
                    errmsg("malformed pg_ndistinct: \"%s\"", parse->str),
                    errdetail("Value of \"%s\" must be an array of attribute numbers.",
                              PG_NDISTINCT_KEY_ATTRIBUTES));
            break;
 
        case NDIST_EXPECT_ATTNUM:
            /* In an attribute number list, expect only scalar integers */
            errsave(parse->escontext,
                    errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
                    errmsg("malformed pg_ndistinct: \"%s\"", parse->str),
                    errdetail("Attribute lists can only contain attribute numbers."));
            break;
 
        case NDIST_EXPECT_NDISTINCT:
            /* Just followed an "ndistinct" key */
            errsave(parse->escontext,
                    errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
                    errmsg("malformed pg_ndistinct: \"%s\"", parse->str),
                    errdetail("Value of \"%s\" must be an integer.",
                              PG_NDISTINCT_KEY_NDISTINCT));
            break;
 
        default:
            elog(ERROR,
                 "object start of \"%s\" found in unexpected parse state: %d.",
                 "pg_ndistinct", (int) parse->state);
            break;
    }
 
    return JSON_SEM_ACTION_FAILED;
}

References elog, errcode(), errdetail(), errmsg(), ERROR, errsave, JSON_SEM_ACTION_FAILED, JSON_SUCCESS, NDIST_EXPECT_ATTNUM, NDIST_EXPECT_ATTNUM_LIST, NDIST_EXPECT_ITEM, NDIST_EXPECT_KEY, NDIST_EXPECT_NDISTINCT, NDIST_EXPECT_START, parse(), PG_NDISTINCT_KEY_ATTRIBUTES, and PG_NDISTINCT_KEY_NDISTINCT.

Referenced by pg_ndistinct_in().

ndistinct_scalar()

static JsonParseErrorType ndistinct_scalar ( void *  state, char *  token, JsonTokenType  tokentype  )

static

Definition at line 420 of file pg_ndistinct.c.

{
    NDistinctParseState *parse = state;
    AttrNumber  attnum;
    ErrorSaveContext escontext = {T_ErrorSaveContext};
 
    switch (parse->state)
    {
        case NDIST_EXPECT_ATTNUM:
            attnum = pg_strtoint16_safe(token, (Node *) &escontext);
 
            if (escontext.error_occurred)
            {
                errsave(parse->escontext,
                        errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
                        errmsg("malformed pg_ndistinct: \"%s\"", parse->str),
                        errdetail("Key \"%s\" has an incorrect value.", PG_NDISTINCT_KEY_ATTRIBUTES));
                return JSON_SEM_ACTION_FAILED;
            }
 
            /*
             * The attribute number cannot be zero a negative number beyond
             * the number of the possible expressions.
             */
            if (attnum == 0 || attnum < (0 - STATS_MAX_DIMENSIONS))
            {
                errsave(parse->escontext,
                        errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
                        errmsg("malformed pg_ndistinct: \"%s\"", parse->str),
                        errdetail("Invalid \"%s\" element has been found: %d.",
                                  PG_NDISTINCT_KEY_ATTRIBUTES, attnum));
                return JSON_SEM_ACTION_FAILED;
            }
 
            if (list_length(parse->attnum_list) > 0)
            {
                const AttrNumber prev = llast_int(parse->attnum_list);
 
                if (!valid_subsequent_attnum(prev, attnum))
                {
                    errsave(parse->escontext,
                            errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
                            errmsg("malformed pg_ndistinct: \"%s\"", parse->str),
                            errdetail("Invalid \"%s\" element has been found: %d cannot follow %d.",
                                      PG_NDISTINCT_KEY_ATTRIBUTES, attnum, prev));
                    return JSON_SEM_ACTION_FAILED;
                }
            }
 
            parse->attnum_list = lappend_int(parse->attnum_list, (int) attnum);
            return JSON_SUCCESS;
 
        case NDIST_EXPECT_NDISTINCT:
 
            /*
             * While the structure dictates that ndistinct is a double
             * precision floating point, it has always been an integer in the
             * output generated.  Therefore, we parse it as an integer here.
             */
            parse->ndistinct = pg_strtoint32_safe(token, (Node *) &escontext);
 
            if (!escontext.error_occurred)
            {
                parse->state = NDIST_EXPECT_KEY;
                return JSON_SUCCESS;
            }
 
            errsave(parse->escontext,
                    errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
                    errmsg("malformed pg_ndistinct: \"%s\"", parse->str),
                    errdetail("Key \"%s\" has an incorrect value.",
                              PG_NDISTINCT_KEY_NDISTINCT));
            break;
 
        default:
            errsave(parse->escontext,
                    errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
                    errmsg("malformed pg_ndistinct: \"%s\"", parse->str),
                    errdetail("Unexpected scalar has been found."));
            break;
    }
 
    return JSON_SEM_ACTION_FAILED;
}

References attnum, errcode(), errdetail(), errmsg(), errsave, JSON_SEM_ACTION_FAILED, JSON_SUCCESS, lappend_int(), list_length(), llast_int, NDIST_EXPECT_ATTNUM, NDIST_EXPECT_KEY, NDIST_EXPECT_NDISTINCT, parse(), PG_NDISTINCT_KEY_ATTRIBUTES, PG_NDISTINCT_KEY_NDISTINCT, pg_strtoint16_safe(), pg_strtoint32_safe(), STATS_MAX_DIMENSIONS, and valid_subsequent_attnum().

Referenced by pg_ndistinct_in().

pg_ndistinct_in()

Datum pg_ndistinct_in

(

PG_FUNCTION_ARGS

)

Definition at line 727 of file pg_ndistinct.c.

{
    char       *str = PG_GETARG_CSTRING(0);
    NDistinctParseState parse_state;
    JsonParseErrorType result;
    JsonLexContext *lex;
    JsonSemAction sem_action;
    bytea      *bytes = NULL;
 
    /* initialize semantic state */
    parse_state.str = str;
    parse_state.state = NDIST_EXPECT_START;
    parse_state.distinct_items = NIL;
    parse_state.escontext = fcinfo->context;
    parse_state.found_attributes = false;
    parse_state.found_ndistinct = false;
    parse_state.attnum_list = NIL;
    parse_state.ndistinct = 0;
 
    /* set callbacks */
    sem_action.semstate = (void *) &parse_state;
    sem_action.object_start = ndistinct_object_start;
    sem_action.object_end = ndistinct_object_end;
    sem_action.array_start = ndistinct_array_start;
    sem_action.array_end = ndistinct_array_end;
    sem_action.object_field_start = ndistinct_object_field_start;
    sem_action.object_field_end = NULL;
    sem_action.array_element_start = ndistinct_array_element_start;
    sem_action.array_element_end = NULL;
    sem_action.scalar = ndistinct_scalar;
 
    lex = makeJsonLexContextCstringLen(NULL, str, strlen(str),
                                       PG_UTF8, true);
    result = pg_parse_json(lex, &sem_action);
    freeJsonLexContext(lex);
 
    if (result == JSON_SUCCESS)
        bytes = build_mvndistinct(&parse_state, str);
 
    list_free(parse_state.attnum_list);
    list_free_deep(parse_state.distinct_items);
 
    if (bytes)
        PG_RETURN_BYTEA_P(bytes);
 
    /*
     * If escontext already set, just use that. Anything else is a generic
     * JSON parse error.
     */
    if (!SOFT_ERROR_OCCURRED(parse_state.escontext))
        errsave(parse_state.escontext,
                errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
                errmsg("malformed pg_ndistinct: \"%s\"", str),
                errdetail("Input data must be valid JSON."));
 
    PG_RETURN_NULL();
}

References JsonSemAction::array_element_end, JsonSemAction::array_element_start, JsonSemAction::array_end, JsonSemAction::array_start, NDistinctParseState::attnum_list, build_mvndistinct(), NDistinctParseState::distinct_items, errcode(), errdetail(), errmsg(), errsave, NDistinctParseState::escontext, NDistinctParseState::found_attributes, NDistinctParseState::found_ndistinct, freeJsonLexContext(), JSON_SUCCESS, list_free(), list_free_deep(), makeJsonLexContextCstringLen(), NDIST_EXPECT_START, NDistinctParseState::ndistinct, ndistinct_array_element_start(), ndistinct_array_end(), ndistinct_array_start(), ndistinct_object_end(), ndistinct_object_field_start(), ndistinct_object_start(), ndistinct_scalar(), NIL, JsonSemAction::object_end, JsonSemAction::object_field_end, JsonSemAction::object_field_start, JsonSemAction::object_start, PG_GETARG_CSTRING, pg_parse_json(), PG_RETURN_BYTEA_P, PG_RETURN_NULL, PG_UTF8, JsonSemAction::scalar, JsonSemAction::semstate, SOFT_ERROR_OCCURRED, NDistinctParseState::state, NDistinctParseState::str, and str.

pg_ndistinct_out()

Datum pg_ndistinct_out

(

PG_FUNCTION_ARGS

)

Definition at line 792 of file pg_ndistinct.c.

{
    bytea      *data = PG_GETARG_BYTEA_PP(0);
    MVNDistinct *ndist = statext_ndistinct_deserialize(data);
    int         i;
    StringInfoData str;
 
    initStringInfo(&str);
    appendStringInfoChar(&str, '[');
 
    for (i = 0; i < ndist->nitems; i++)
    {
        MVNDistinctItem item = ndist->items[i];
 
        if (i > 0)
            appendStringInfoString(&str, ", ");
 
        if (item.nattributes <= 0)
            elog(ERROR, "invalid zero-length attribute array in MVNDistinct");
 
        appendStringInfo(&str, "{\"" PG_NDISTINCT_KEY_ATTRIBUTES "\": [%d",
                         item.attributes[0]);
 
        for (int j = 1; j < item.nattributes; j++)
            appendStringInfo(&str, ", %d", item.attributes[j]);
 
        appendStringInfo(&str, "], \"" PG_NDISTINCT_KEY_NDISTINCT "\": %d}",
                         (int) item.ndistinct);
    }
 
    appendStringInfoChar(&str, ']');
 
    PG_RETURN_CSTRING(str.data);
}

References appendStringInfo(), appendStringInfoChar(), appendStringInfoString(), MVNDistinctItem::attributes, data, elog, ERROR, i, initStringInfo(), MVNDistinct::items, j, MVNDistinctItem::nattributes, MVNDistinctItem::ndistinct, MVNDistinct::nitems, PG_GETARG_BYTEA_PP, PG_NDISTINCT_KEY_ATTRIBUTES, PG_NDISTINCT_KEY_NDISTINCT, PG_RETURN_CSTRING, statext_ndistinct_deserialize(), and str.

pg_ndistinct_recv()

Datum pg_ndistinct_recv

(

PG_FUNCTION_ARGS

)

Definition at line 832 of file pg_ndistinct.c.

{
    ereport(ERROR,
            (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
             errmsg("cannot accept a value of type %s", "pg_ndistinct")));
 
    PG_RETURN_VOID();           /* keep compiler quiet */
}

References ereport, errcode(), errmsg(), ERROR, and PG_RETURN_VOID.

pg_ndistinct_send()

Datum pg_ndistinct_send

(

PG_FUNCTION_ARGS

)

Definition at line 848 of file pg_ndistinct.c.

{
    return byteasend(fcinfo);
}

References byteasend().

valid_subsequent_attnum()

static bool valid_subsequent_attnum ( AttrNumber  prev, AttrNumber  cur  )

static

Definition at line 403 of file pg_ndistinct.c.

{
    Assert(prev != 0);
 
    if (prev > 0)
        return ((cur > prev) || (cur < 0));
 
    return (cur < prev);
}

References Assert(), and cur.

Referenced by ndistinct_scalar().