pg_dependencies.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/float.h"
#include "utils/fmgrprotos.h"

Include dependency graph for pg_dependencies.c:

Go to the source code of this file.

Data Structures
struct	DependenciesParseState

Enumerations
enum	DependenciesSemanticState {   DEPS_EXPECT_START = 0 , DEPS_EXPECT_ITEM , DEPS_EXPECT_KEY , DEPS_EXPECT_ATTNUM_LIST ,   DEPS_EXPECT_ATTNUM , DEPS_EXPECT_DEPENDENCY , DEPS_EXPECT_DEGREE , DEPS_PARSE_COMPLETE }

Functions
static JsonParseErrorType	dependencies_object_start (void *state)
static JsonParseErrorType	dependencies_object_end (void *state)
static JsonParseErrorType	dependencies_array_start (void *state)
static JsonParseErrorType	dependencies_array_end (void *state)
static JsonParseErrorType	dependencies_object_field_start (void *state, char *fname, bool isnull)
static JsonParseErrorType	dependencies_array_element_start (void *state, bool isnull)
static bool	valid_subsequent_attnum (const AttrNumber prev, const AttrNumber cur)
static JsonParseErrorType	dependencies_scalar (void *state, char *token, JsonTokenType tokentype)
static bool	dep_attributes_eq (const MVDependency *a, const MVDependency *b)
static char *	dep_attnum_list (const MVDependency *item)
static AttrNumber	dep_attnum_dependency (const MVDependency *item)
static bytea *	build_mvdependencies (DependenciesParseState *parse, char *str)
Datum	pg_dependencies_in (PG_FUNCTION_ARGS)
Datum	pg_dependencies_out (PG_FUNCTION_ARGS)
Datum	pg_dependencies_recv (PG_FUNCTION_ARGS)
Datum	pg_dependencies_send (PG_FUNCTION_ARGS)

Enumeration Type Documentation

DependenciesSemanticState

enum DependenciesSemanticState

Enumerator
DEPS_EXPECT_START
DEPS_EXPECT_ITEM
DEPS_EXPECT_KEY
DEPS_EXPECT_ATTNUM_LIST
DEPS_EXPECT_ATTNUM
DEPS_EXPECT_DEPENDENCY
DEPS_EXPECT_DEGREE
DEPS_PARSE_COMPLETE

Definition at line 28 of file pg_dependencies.c.

{
    DEPS_EXPECT_START = 0,
    DEPS_EXPECT_ITEM,
    DEPS_EXPECT_KEY,
    DEPS_EXPECT_ATTNUM_LIST,
    DEPS_EXPECT_ATTNUM,
    DEPS_EXPECT_DEPENDENCY,
    DEPS_EXPECT_DEGREE,
    DEPS_PARSE_COMPLETE,
} DependenciesSemanticState;

Function Documentation

build_mvdependencies()

static bytea * build_mvdependencies ( DependenciesParseState *  parse, char *  str  )

static

Definition at line 647 of file pg_dependencies.c.

{
    int         ndeps = list_length(parse->dependency_list);
 
    MVDependencies *mvdeps;
    bytea      *bytes;
 
    switch (parse->state)
    {
        case DEPS_PARSE_COMPLETE:
 
            /*
             * Parse ended in the expected place.  We should have a list of
             * items, but if we do not there is an issue with one of the
             * earlier parse steps.
             */
            if (ndeps == 0)
                elog(ERROR,
                     "pg_dependencies parsing claims success with an empty item list.");
            break;
 
        case DEPS_EXPECT_START:
            /* blank */
            errsave(parse->escontext,
                    errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
                    errmsg("malformed pg_dependencies: \"%s\"", str),
                    errdetail("Value cannot be empty."));
            return NULL;
 
        default:
            /* Unexpected end-state. */
            errsave(parse->escontext,
                    errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
                    errmsg("malformed pg_dependencies: \"%s\"", str),
                    errdetail("Unexpected end state has been found: %d.", parse->state));
            return NULL;
    }
 
    mvdeps = palloc0(offsetof(MVDependencies, deps)
                     + (ndeps * sizeof(MVDependency *)));
    mvdeps->magic = STATS_DEPS_MAGIC;
    mvdeps->type = STATS_DEPS_TYPE_BASIC;
    mvdeps->ndeps = ndeps;
 
    for (int i = 0; i < ndeps; i++)
    {
        /*
         * Use the MVDependency objects in the dependency_list.
         *
         * Because we free the dependency_list after parsing is done, we
         * cannot free it here.
         */
        mvdeps->deps[i] = list_nth(parse->dependency_list, i);
 
        /*
         * Ensure that this item does not duplicate the attributes of any
         * pre-existing item.
         */
        for (int j = 0; j < i; j++)
        {
            if (dep_attributes_eq(mvdeps->deps[i], mvdeps->deps[j]))
            {
                MVDependency *dep = mvdeps->deps[i];
                char       *attnum_list = dep_attnum_list(dep);
                AttrNumber  attnum_dep = dep_attnum_dependency(dep);
 
                errsave(parse->escontext,
                        errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
                        errmsg("malformed pg_dependencies: \"%s\"", str),
                        errdetail("Duplicated \"%s\" array has been found: [%s] for key \"%s\" and value %d.",
                                  PG_DEPENDENCIES_KEY_ATTRIBUTES, attnum_list,
                                  PG_DEPENDENCIES_KEY_DEPENDENCY, attnum_dep));
                pfree(mvdeps);
                return NULL;
            }
        }
    }
 
    bytes = statext_dependencies_serialize(mvdeps);
 
    /*
     * No need to free the individual MVDependency objects, because they are
     * still in the dependency_list, and will be freed with that.
     */
    pfree(mvdeps);
 
    return bytes;
}

References dep_attnum_dependency(), dep_attnum_list(), dep_attributes_eq(), DEPS_EXPECT_START, DEPS_PARSE_COMPLETE, elog, errcode(), errdetail(), errmsg, ERROR, errsave, fb(), i, j, list_length(), list_nth(), palloc0(), parse(), pfree(), PG_DEPENDENCIES_KEY_ATTRIBUTES, PG_DEPENDENCIES_KEY_DEPENDENCY, statext_dependencies_serialize(), STATS_DEPS_MAGIC, STATS_DEPS_TYPE_BASIC, and str.

Referenced by pg_dependencies_in().

dep_attnum_dependency()

static AttrNumber dep_attnum_dependency ( const MVDependency *  item )

static

Definition at line 634 of file pg_dependencies.c.

{
    return item->attributes[item->nattributes - 1];
}

References MVDependency::attributes, and MVDependency::nattributes.

Referenced by build_mvdependencies().

dep_attnum_list()

static char * dep_attnum_list ( const MVDependency *  item )

static

Definition at line 616 of file pg_dependencies.c.

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

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

Referenced by build_mvdependencies().

dep_attributes_eq()

static bool dep_attributes_eq ( const MVDependency *  a, const MVDependency *  b  )

static

Definition at line 592 of file pg_dependencies.c.

{
    int         i;
 
    if (a->nattributes != b->nattributes)
        return false;
 
    for (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_mvdependencies().

dependencies_array_element_start()

static JsonParseErrorType dependencies_array_element_start ( void *  state, bool  isnull  )

static

Definition at line 412 of file pg_dependencies.c.

{
    DependenciesParseState *parse = state;
 
    switch (parse->state)
    {
        case DEPS_EXPECT_ATTNUM:
            if (!isnull)
                return JSON_SUCCESS;
 
            errsave(parse->escontext,
                    errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
                    errmsg("malformed pg_dependencies: \"%s\"", parse->str),
                    errdetail("Attribute number array cannot be null."));
            break;
 
        case DEPS_EXPECT_ITEM:
            if (!isnull)
                return JSON_SUCCESS;
 
            errsave(parse->escontext,
                    errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
                    errmsg("malformed pg_dependencies: \"%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_dependencies", (int) parse->state);
            break;
    }
 
    return JSON_SEM_ACTION_FAILED;
}

References DEPS_EXPECT_ATTNUM, DEPS_EXPECT_ITEM, elog, errcode(), errdetail(), errmsg, ERROR, errsave, fb(), JSON_SEM_ACTION_FAILED, JSON_SUCCESS, and parse().

Referenced by pg_dependencies_in().

dependencies_array_end()

static JsonParseErrorType dependencies_array_end ( void *  state )

static

Definition at line 284 of file pg_dependencies.c.

{
    DependenciesParseState *parse = state;
 
    switch (parse->state)
    {
        case DEPS_EXPECT_ATTNUM:
            if (list_length(parse->attnum_list) > 0)
            {
                parse->state = DEPS_EXPECT_KEY;
                return JSON_SUCCESS;
            }
 
            errsave(parse->escontext,
                    errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
                    errmsg("malformed pg_dependencies: \"%s\"", parse->str),
                    errdetail("The \"%s\" key must be a non-empty array.",
                              PG_DEPENDENCIES_KEY_ATTRIBUTES));
            break;
 
        case DEPS_EXPECT_ITEM:
            if (list_length(parse->dependency_list) > 0)
            {
                parse->state = DEPS_PARSE_COMPLETE;
                return JSON_SUCCESS;
            }
 
            errsave(parse->escontext,
                    errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
                    errmsg("malformed pg_dependencies: \"%s\"", parse->str),
                    errdetail("Item array cannot be empty."));
            break;
 
        default:
 
            /*
             * This can only happen if a case was missed in
             * dependencies_array_start().
             */
            elog(ERROR,
                 "array end of \"%s\" found in unexpected parse state: %d.",
                 "pg_dependencies", (int) parse->state);
            break;
    }
    return JSON_SEM_ACTION_FAILED;
}

References DEPS_EXPECT_ATTNUM, DEPS_EXPECT_ITEM, DEPS_EXPECT_KEY, DEPS_PARSE_COMPLETE, elog, errcode(), errdetail(), errmsg, ERROR, errsave, fb(), JSON_SEM_ACTION_FAILED, JSON_SUCCESS, list_length(), parse(), and PG_DEPENDENCIES_KEY_ATTRIBUTES.

Referenced by pg_dependencies_in().

dependencies_array_start()

static JsonParseErrorType dependencies_array_start ( void *  state )

static

Definition at line 255 of file pg_dependencies.c.

{
    DependenciesParseState *parse = state;
 
    switch (parse->state)
    {
        case DEPS_EXPECT_ATTNUM_LIST:
            parse->state = DEPS_EXPECT_ATTNUM;
            break;
        case DEPS_EXPECT_START:
            parse->state = DEPS_EXPECT_ITEM;
            break;
        default:
            errsave(parse->escontext,
                    errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
                    errmsg("malformed pg_dependencies: \"%s\"", parse->str),
                    errdetail("Array has been found at an unexpected location."));
            return JSON_SEM_ACTION_FAILED;
    }
 
    return JSON_SUCCESS;
}

References DEPS_EXPECT_ATTNUM, DEPS_EXPECT_ATTNUM_LIST, DEPS_EXPECT_ITEM, DEPS_EXPECT_START, errcode(), errdetail(), errmsg, errsave, fb(), JSON_SEM_ACTION_FAILED, JSON_SUCCESS, and parse().

Referenced by pg_dependencies_in().

dependencies_object_end()

static JsonParseErrorType dependencies_object_end ( void *  state )

static

Definition at line 142 of file pg_dependencies.c.

{
    DependenciesParseState *parse = state;
 
    MVDependency *dep;
 
    int         natts = 0;
 
    if (parse->state != DEPS_EXPECT_KEY)
        elog(ERROR,
             "object end of \"%s\" found in unexpected parse state: %d.",
             "pg_dependencies", (int) parse->state);
 
    if (!parse->found_attributes)
    {
        errsave(parse->escontext,
                errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
                errmsg("malformed pg_dependencies: \"%s\"", parse->str),
                errdetail("Item must contain \"%s\" key.",
                          PG_DEPENDENCIES_KEY_ATTRIBUTES));
        return JSON_SEM_ACTION_FAILED;
    }
 
    if (!parse->found_dependency)
    {
        errsave(parse->escontext,
                errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
                errmsg("malformed pg_dependencies: \"%s\"", parse->str),
                errdetail("Item must contain \"%s\" key.",
                          PG_DEPENDENCIES_KEY_DEPENDENCY));
        return JSON_SEM_ACTION_FAILED;
    }
 
    if (!parse->found_degree)
    {
        errsave(parse->escontext,
                errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
                errmsg("malformed pg_dependencies: \"%s\"", parse->str),
                errdetail("Item must contain \"%s\" key.",
                          PG_DEPENDENCIES_KEY_DEGREE));
        return JSON_SEM_ACTION_FAILED;
    }
 
    /*
     * We need at least one attribute number in a dependencies item, anything
     * less is malformed.
     */
    natts = list_length(parse->attnum_list);
    if ((natts < 1) || (natts > (STATS_MAX_DIMENSIONS - 1)))
    {
        errsave(parse->escontext,
                errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
                errmsg("malformed pg_dependencies: \"%s\"", parse->str),
                errdetail("The \"%s\" key must contain an array of at least %d and no more than %d elements.",
                          PG_DEPENDENCIES_KEY_ATTRIBUTES, 1,
                          STATS_MAX_DIMENSIONS - 1));
        return JSON_SEM_ACTION_FAILED;
    }
 
    /*
     * Allocate enough space for the dependency, the attribute numbers in the
     * list and the final attribute number for the dependency.
     */
    dep = palloc0(offsetof(MVDependency, attributes) + ((natts + 1) * sizeof(AttrNumber)));
    dep->nattributes = natts + 1;
 
    dep->attributes[natts] = parse->dependency;
    dep->degree = parse->degree;
 
    /*
     * Assign attribute numbers to the attributes array, comparing each one
     * against the dependency attribute to ensure that there are no matches.
     */
    for (int i = 0; i < natts; i++)
    {
        dep->attributes[i] = (AttrNumber) list_nth_int(parse->attnum_list, i);
        if (dep->attributes[i] == parse->dependency)
        {
            errsave(parse->escontext,
                    errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
                    errmsg("malformed pg_dependencies: \"%s\"", parse->str),
                    errdetail("Item \"%s\" with value %d has been found in the \"%s\" list.",
                              PG_DEPENDENCIES_KEY_DEPENDENCY, parse->dependency,
                              PG_DEPENDENCIES_KEY_ATTRIBUTES));
            return JSON_SEM_ACTION_FAILED;
        }
    }
 
    parse->dependency_list = lappend(parse->dependency_list, (void *) dep);
 
    /*
     * Reset dependency item state variables to look for the next
     * MVDependency.
     */
    list_free(parse->attnum_list);
    parse->attnum_list = NIL;
    parse->dependency = 0;
    parse->degree = 0.0;
    parse->found_attributes = false;
    parse->found_dependency = false;
    parse->found_degree = false;
    parse->state = DEPS_EXPECT_ITEM;
 
    return JSON_SUCCESS;
}

References DEPS_EXPECT_ITEM, DEPS_EXPECT_KEY, elog, errcode(), errdetail(), errmsg, ERROR, errsave, fb(), i, JSON_SEM_ACTION_FAILED, JSON_SUCCESS, lappend(), list_free(), list_length(), list_nth_int(), NIL, palloc0(), parse(), PG_DEPENDENCIES_KEY_ATTRIBUTES, PG_DEPENDENCIES_KEY_DEGREE, PG_DEPENDENCIES_KEY_DEPENDENCY, and STATS_MAX_DIMENSIONS.

Referenced by pg_dependencies_in().

dependencies_object_field_start()

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

static

Definition at line 340 of file pg_dependencies.c.

{
    DependenciesParseState *parse = state;
 
    if (strcmp(fname, PG_DEPENDENCIES_KEY_ATTRIBUTES) == 0)
    {
        if (parse->found_attributes)
        {
            errsave(parse->escontext,
                    errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
                    errmsg("malformed pg_dependencies: \"%s\"", parse->str),
                    errdetail("Multiple \"%s\" keys are not allowed.",
                              PG_DEPENDENCIES_KEY_ATTRIBUTES));
            return JSON_SEM_ACTION_FAILED;
        }
 
        parse->found_attributes = true;
        parse->state = DEPS_EXPECT_ATTNUM_LIST;
        return JSON_SUCCESS;
    }
 
    if (strcmp(fname, PG_DEPENDENCIES_KEY_DEPENDENCY) == 0)
    {
        if (parse->found_dependency)
        {
            errsave(parse->escontext,
                    errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
                    errmsg("malformed pg_dependencies: \"%s\"", parse->str),
                    errdetail("Multiple \"%s\" keys are not allowed.",
                              PG_DEPENDENCIES_KEY_DEPENDENCY));
            return JSON_SEM_ACTION_FAILED;
        }
 
        parse->found_dependency = true;
        parse->state = DEPS_EXPECT_DEPENDENCY;
        return JSON_SUCCESS;
    }
 
    if (strcmp(fname, PG_DEPENDENCIES_KEY_DEGREE) == 0)
    {
        if (parse->found_degree)
        {
            errsave(parse->escontext,
                    errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
                    errmsg("malformed pg_dependencies: \"%s\"", parse->str),
                    errdetail("Multiple \"%s\" keys are not allowed.",
                              PG_DEPENDENCIES_KEY_DEGREE));
            return JSON_SEM_ACTION_FAILED;
        }
 
        parse->found_degree = true;
        parse->state = DEPS_EXPECT_DEGREE;
        return JSON_SUCCESS;
    }
 
    errsave(parse->escontext,
            errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
            errmsg("malformed pg_dependencies: \"%s\"", parse->str),
            errdetail("Only allowed keys are \"%s\", \"%s\", and \"%s\".",
                      PG_DEPENDENCIES_KEY_ATTRIBUTES,
                      PG_DEPENDENCIES_KEY_DEPENDENCY,
                      PG_DEPENDENCIES_KEY_DEGREE));
    return JSON_SEM_ACTION_FAILED;
}

References DEPS_EXPECT_ATTNUM_LIST, DEPS_EXPECT_DEGREE, DEPS_EXPECT_DEPENDENCY, errcode(), errdetail(), errmsg, errsave, fb(), JSON_SEM_ACTION_FAILED, JSON_SUCCESS, parse(), PG_DEPENDENCIES_KEY_ATTRIBUTES, PG_DEPENDENCIES_KEY_DEGREE, and PG_DEPENDENCIES_KEY_DEPENDENCY.

Referenced by pg_dependencies_in().

dependencies_object_start()

static JsonParseErrorType dependencies_object_start ( void *  state )

static

Definition at line 64 of file pg_dependencies.c.

{
    DependenciesParseState *parse = state;
 
    switch (parse->state)
    {
        case DEPS_EXPECT_ITEM:
            /* Now we expect to see attributes/dependency/degree keys */
            parse->state = DEPS_EXPECT_KEY;
            return JSON_SUCCESS;
 
        case DEPS_EXPECT_START:
            /* pg_dependencies must begin with a '[' */
            errsave(parse->escontext,
                    errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
                    errmsg("malformed pg_dependencies: \"%s\"", parse->str),
                    errdetail("Initial element must be an array."));
            break;
 
        case DEPS_EXPECT_KEY:
            /* In an object, expecting key */
            errsave(parse->escontext,
                    errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
                    errmsg("malformed pg_dependencies: \"%s\"", parse->str),
                    errdetail("A key was expected."));
            break;
 
        case DEPS_EXPECT_ATTNUM_LIST:
            /* Just followed an "attributes": key */
            errsave(parse->escontext,
                    errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
                    errmsg("malformed pg_dependencies: \"%s\"", parse->str),
                    errdetail("Value of \"%s\" must be an array of attribute numbers.",
                              PG_DEPENDENCIES_KEY_ATTRIBUTES));
            break;
 
        case DEPS_EXPECT_ATTNUM:
            /* In an attribute number list, expect only scalar integers */
            errsave(parse->escontext,
                    errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
                    errmsg("malformed pg_dependencies: \"%s\"", parse->str),
                    errdetail("Attribute lists can only contain attribute numbers."));
            break;
 
        case DEPS_EXPECT_DEPENDENCY:
            /* Just followed a "dependency" key */
            errsave(parse->escontext,
                    errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
                    errmsg("malformed pg_dependencies: \"%s\"", parse->str),
                    errdetail("Value of \"%s\" must be an integer.",
                              PG_DEPENDENCIES_KEY_DEPENDENCY));
            break;
 
        case DEPS_EXPECT_DEGREE:
            /* Just followed a "degree" key */
            errsave(parse->escontext,
                    errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
                    errmsg("malformed pg_dependencies: \"%s\"", parse->str),
                    errdetail("Value of \"%s\" must be an integer.",
                              PG_DEPENDENCIES_KEY_DEGREE));
            break;
 
        default:
            elog(ERROR,
                 "object start of \"%s\" found in unexpected parse state: %d.",
                 "pg_dependencies", (int) parse->state);
            break;
    }
 
    return JSON_SEM_ACTION_FAILED;
}

References DEPS_EXPECT_ATTNUM, DEPS_EXPECT_ATTNUM_LIST, DEPS_EXPECT_DEGREE, DEPS_EXPECT_DEPENDENCY, DEPS_EXPECT_ITEM, DEPS_EXPECT_KEY, DEPS_EXPECT_START, elog, errcode(), errdetail(), errmsg, ERROR, errsave, fb(), JSON_SEM_ACTION_FAILED, JSON_SUCCESS, parse(), PG_DEPENDENCIES_KEY_ATTRIBUTES, PG_DEPENDENCIES_KEY_DEGREE, and PG_DEPENDENCIES_KEY_DEPENDENCY.

Referenced by pg_dependencies_in().

dependencies_scalar()

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

static

Definition at line 478 of file pg_dependencies.c.

{
    DependenciesParseState *parse = state;
    AttrNumber  attnum;
    ErrorSaveContext escontext = {T_ErrorSaveContext};
 
    switch (parse->state)
    {
        case DEPS_EXPECT_ATTNUM:
            attnum = pg_strtoint16_safe(token, (Node *) &escontext);
 
            if (escontext.error_occurred)
            {
                errsave(parse->escontext,
                        errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
                        errmsg("malformed pg_dependencies: \"%s\"", parse->str),
                        errdetail("Key \"%s\" has an incorrect value.", PG_DEPENDENCIES_KEY_ATTRIBUTES));
                return JSON_SEM_ACTION_FAILED;
            }
 
            /*
             * An attribute number cannot be zero or 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_dependencies: \"%s\"", parse->str),
                        errdetail("Invalid \"%s\" element has been found: %d.",
                                  PG_DEPENDENCIES_KEY_ATTRIBUTES, attnum));
                return JSON_SEM_ACTION_FAILED;
            }
 
            if (parse->attnum_list != NIL)
            {
                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_dependencies: \"%s\"", parse->str),
                            errdetail("Invalid \"%s\" element has been found: %d cannot follow %d.",
                                      PG_DEPENDENCIES_KEY_ATTRIBUTES, attnum, prev));
                    return JSON_SEM_ACTION_FAILED;
                }
            }
 
            parse->attnum_list = lappend_int(parse->attnum_list, (int) attnum);
            return JSON_SUCCESS;
 
        case DEPS_EXPECT_DEPENDENCY:
            parse->dependency = (AttrNumber)
                pg_strtoint16_safe(token, (Node *) &escontext);
 
            if (escontext.error_occurred)
            {
                errsave(parse->escontext,
                        errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
                        errmsg("malformed pg_dependencies: \"%s\"", parse->str),
                        errdetail("Key \"%s\" has an incorrect value.", PG_DEPENDENCIES_KEY_DEPENDENCY));
                return JSON_SEM_ACTION_FAILED;
            }
 
            /*
             * The dependency attribute number cannot be zero or a negative
             * number beyond the number of the possible expressions.
             */
            if (parse->dependency == 0 || parse->dependency < (0 - STATS_MAX_DIMENSIONS))
            {
                errsave(parse->escontext,
                        errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
                        errmsg("malformed pg_dependencies: \"%s\"", parse->str),
                        errdetail("Key \"%s\" has an incorrect value: %d.",
                                  PG_DEPENDENCIES_KEY_DEPENDENCY, parse->dependency));
                return JSON_SEM_ACTION_FAILED;
            }
 
            parse->state = DEPS_EXPECT_KEY;
            return JSON_SUCCESS;
 
        case DEPS_EXPECT_DEGREE:
            parse->degree = float8in_internal(token, NULL, "double",
                                              token, (Node *) &escontext);
 
            if (escontext.error_occurred)
            {
                errsave(parse->escontext,
                        errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
                        errmsg("malformed pg_dependencies: \"%s\"", parse->str),
                        errdetail("Key \"%s\" has an incorrect value.", PG_DEPENDENCIES_KEY_DEGREE));
                return JSON_SEM_ACTION_FAILED;
            }
 
            parse->state = DEPS_EXPECT_KEY;
            return JSON_SUCCESS;
 
        default:
            errsave(parse->escontext,
                    errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
                    errmsg("malformed pg_dependencies: \"%s\"", parse->str),
                    errdetail("Unexpected scalar has been found."));
            break;
    }
 
    return JSON_SEM_ACTION_FAILED;
}

References attnum, DEPS_EXPECT_ATTNUM, DEPS_EXPECT_DEGREE, DEPS_EXPECT_DEPENDENCY, DEPS_EXPECT_KEY, errcode(), errdetail(), errmsg, errsave, fb(), float8in_internal(), JSON_SEM_ACTION_FAILED, JSON_SUCCESS, lappend_int(), llast_int, NIL, parse(), PG_DEPENDENCIES_KEY_ATTRIBUTES, PG_DEPENDENCIES_KEY_DEGREE, PG_DEPENDENCIES_KEY_DEPENDENCY, pg_strtoint16_safe(), STATS_MAX_DIMENSIONS, and valid_subsequent_attnum().

Referenced by pg_dependencies_in().

pg_dependencies_in()

Datum pg_dependencies_in

(

PG_FUNCTION_ARGS

)

Definition at line 747 of file pg_dependencies.c.

{
    char       *str = PG_GETARG_CSTRING(0);
    bytea      *bytes = NULL;
 
    DependenciesParseState parse_state;
    JsonParseErrorType result;
    JsonLexContext *lex;
    JsonSemAction sem_action;
 
    /* initialize the semantic state */
    parse_state.str = str;
    parse_state.state = DEPS_EXPECT_START;
    parse_state.dependency_list = NIL;
    parse_state.attnum_list = NIL;
    parse_state.dependency = 0;
    parse_state.degree = 0.0;
    parse_state.found_attributes = false;
    parse_state.found_dependency = false;
    parse_state.found_degree = false;
    parse_state.escontext = fcinfo->context;
 
    /* set callbacks */
    sem_action.semstate = (void *) &parse_state;
    sem_action.object_start = dependencies_object_start;
    sem_action.object_end = dependencies_object_end;
    sem_action.array_start = dependencies_array_start;
    sem_action.array_end = dependencies_array_end;
    sem_action.array_element_start = dependencies_array_element_start;
    sem_action.array_element_end = NULL;
    sem_action.object_field_start = dependencies_object_field_start;
    sem_action.object_field_end = NULL;
    sem_action.scalar = dependencies_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_mvdependencies(&parse_state, str);
 
    list_free_deep(parse_state.dependency_list);
    list_free(parse_state.attnum_list);
 
    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_dependencies: \"%s\"", str),
                errdetail("Input data must be valid JSON."));
 
    PG_RETURN_NULL();
}

References build_mvdependencies(), dependencies_array_element_start(), dependencies_array_end(), dependencies_array_start(), dependencies_object_end(), dependencies_object_field_start(), dependencies_object_start(), dependencies_scalar(), DEPS_EXPECT_START, errcode(), errdetail(), errmsg, errsave, fb(), freeJsonLexContext(), JSON_SUCCESS, list_free(), list_free_deep(), makeJsonLexContextCstringLen(), NIL, PG_GETARG_CSTRING, pg_parse_json(), PG_RETURN_BYTEA_P, PG_RETURN_NULL, PG_UTF8, result, JsonSemAction::semstate, SOFT_ERROR_OCCURRED, and str.

pg_dependencies_out()

Datum pg_dependencies_out

(

PG_FUNCTION_ARGS

)

Definition at line 813 of file pg_dependencies.c.

{
    bytea      *data = PG_GETARG_BYTEA_PP(0);
    MVDependencies *dependencies = statext_dependencies_deserialize(data);
    StringInfoData str;
 
    initStringInfo(&str);
    appendStringInfoChar(&str, '[');
 
    for (int i = 0; i < dependencies->ndeps; i++)
    {
        MVDependency *dependency = dependencies->deps[i];
 
        if (i > 0)
            appendStringInfoString(&str, ", ");
 
        if (dependency->nattributes <= 1)
            elog(ERROR, "invalid zero-length nattributes array in MVDependencies");
 
        appendStringInfo(&str, "{\"" PG_DEPENDENCIES_KEY_ATTRIBUTES "\": [%d",
                         dependency->attributes[0]);
 
        for (int j = 1; j < dependency->nattributes - 1; j++)
            appendStringInfo(&str, ", %d", dependency->attributes[j]);
 
        appendStringInfo(&str, "], \"" PG_DEPENDENCIES_KEY_DEPENDENCY "\": %d, "
                         "\"" PG_DEPENDENCIES_KEY_DEGREE "\": %f}",
                         dependency->attributes[dependency->nattributes - 1],
                         dependency->degree);
    }
 
    appendStringInfoChar(&str, ']');
 
    PG_RETURN_CSTRING(str.data);
}

References appendStringInfo(), appendStringInfoChar(), appendStringInfoString(), MVDependency::attributes, data, MVDependency::degree, MVDependencies::deps, elog, ERROR, i, initStringInfo(), j, MVDependency::nattributes, MVDependencies::ndeps, PG_DEPENDENCIES_KEY_ATTRIBUTES, PG_DEPENDENCIES_KEY_DEGREE, PG_DEPENDENCIES_KEY_DEPENDENCY, PG_GETARG_BYTEA_PP, PG_RETURN_CSTRING, statext_dependencies_deserialize(), and str.

pg_dependencies_recv()

Datum pg_dependencies_recv

(

PG_FUNCTION_ARGS

)

Definition at line 853 of file pg_dependencies.c.

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

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

pg_dependencies_send()

Datum pg_dependencies_send

(

PG_FUNCTION_ARGS

)

Definition at line 869 of file pg_dependencies.c.

{
    return byteasend(fcinfo);
}

References byteasend().

valid_subsequent_attnum()

static bool valid_subsequent_attnum ( const AttrNumber  prev, const AttrNumber  cur  )

static

Definition at line 461 of file pg_dependencies.c.

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

References Assert, and cur.

Referenced by dependencies_scalar().