parse_jsontable.c File Reference

#include "postgres.h"
#include "catalog/pg_type.h"
#include "nodes/makefuncs.h"
#include "nodes/nodeFuncs.h"
#include "optimizer/optimizer.h"
#include "parser/parse_clause.h"
#include "parser/parse_collate.h"
#include "parser/parse_expr.h"
#include "parser/parse_relation.h"
#include "parser/parse_type.h"
#include "utils/fmgrprotos.h"
#include "utils/json.h"
#include "utils/lsyscache.h"

Include dependency graph for parse_jsontable.c:

Go to the source code of this file.

Data Structures
struct	JsonTableParseContext

Typedefs
typedef struct JsonTableParseContext	JsonTableParseContext

Functions
static JsonTablePlan *	transformJsonTableColumns (JsonTableParseContext *cxt, JsonTablePlanSpec *planspec, List *columns, List *passingArgs, JsonTablePathSpec *pathspec)
static JsonTablePlan *	transformJsonTableNestedColumns (JsonTableParseContext *cxt, JsonTablePlanSpec *plan, List *passingArgs, List *columns)
static JsonFuncExpr *	transformJsonTableColumn (JsonTableColumn *jtc, Node *contextItemExpr, List *passingArgs)
static bool	isCompositeType (Oid typid)
static JsonTablePlan *	makeJsonTablePathScan (JsonTableParseContext *cxt, JsonTablePathSpec *pathspec, JsonTablePlanSpec *planspec, bool errorOnError, int colMin, int colMax, JsonTablePlan *childplan)
static void	CheckDuplicateColumnOrPathNames (JsonTableParseContext *cxt, List *columns)
static bool	LookupPathOrColumnName (JsonTableParseContext *cxt, char *name)
static char *	generateJsonTablePathName (JsonTableParseContext *cxt)
static void	validateJsonTableChildPlan (JsonTableParseContext *cxt, JsonTablePlanSpec *plan, List *columns)
static JsonTablePlan *	makeJsonTableSiblingJoin (bool cross, JsonTablePlan *lplan, JsonTablePlan *rplan)
static void	appendJsonTableColumns (JsonTableParseContext *cxt, List *columns, List *passingArgs)
ParseNamespaceItem *	transformJsonTable (ParseState *pstate, JsonTable *jt)
static JsonTableColumn *	findNestedJsonTableColumn (List *columns, const char *pathname)
static void	collectSiblingPathsInJsonTablePlan (JsonTablePlanSpec *plan, List **paths)

Typedef Documentation

JsonTableParseContext

typedef struct JsonTableParseContext JsonTableParseContext

Function Documentation

appendJsonTableColumns()

static void appendJsonTableColumns ( JsonTableParseContext *  cxt, List *  columns, List *  passingArgs  )

static

Definition at line 378 of file parse_jsontable.c.

{
    ListCell   *col;
    ParseState *pstate = cxt->pstate;
    TableFunc  *tf = cxt->tf;
    bool        ordinality_found = false;
    Oid         contextItemTypid = exprType(tf->docexpr);
 
    foreach(col, columns)
    {
        JsonTableColumn *rawc = castNode(JsonTableColumn, lfirst(col));
        Oid         typid;
        int32       typmod;
        Oid         typcoll = InvalidOid;
        Node       *colexpr;
 
        if (rawc->name)
            tf->colnames = lappend(tf->colnames,
                                   makeString(pstrdup(rawc->name)));
 
        /*
         * Determine the type and typmod for the new column. FOR ORDINALITY
         * columns are INTEGER by standard; the others are user-specified.
         */
        switch (rawc->coltype)
        {
            case JTC_FOR_ORDINALITY:
                if (ordinality_found)
                    ereport(ERROR,
                            (errcode(ERRCODE_SYNTAX_ERROR),
                             errmsg("only one FOR ORDINALITY column is allowed"),
                             parser_errposition(pstate, rawc->location)));
                ordinality_found = true;
                colexpr = NULL;
                typid = INT4OID;
                typmod = -1;
                break;
 
            case JTC_REGULAR:
                typenameTypeIdAndMod(pstate, rawc->typeName, &typid, &typmod);
 
                /*
                 * Use JTC_FORMATTED so as to use JSON_QUERY for this column
                 * if the specified type is one that's better handled using
                 * JSON_QUERY() or if non-default WRAPPER or QUOTES behavior
                 * is specified.
                 */
                if (isCompositeType(typid) ||
                    rawc->quotes != JS_QUOTES_UNSPEC ||
                    rawc->wrapper != JSW_UNSPEC)
                    rawc->coltype = JTC_FORMATTED;
 
                pg_fallthrough;
            case JTC_FORMATTED:
            case JTC_EXISTS:
                {
                    JsonFuncExpr *jfe;
                    CaseTestExpr *param = makeNode(CaseTestExpr);
 
                    param->collation = InvalidOid;
                    param->typeId = contextItemTypid;
                    param->typeMod = -1;
 
                    jfe = transformJsonTableColumn(rawc, (Node *) param,
                                                   passingArgs);
 
                    colexpr = transformExpr(pstate, (Node *) jfe,
                                            EXPR_KIND_FROM_FUNCTION);
                    assign_expr_collations(pstate, colexpr);
 
                    typid = exprType(colexpr);
                    typmod = exprTypmod(colexpr);
                    typcoll = exprCollation(colexpr);
                    break;
                }
 
            case JTC_NESTED:
                continue;
 
            default:
                elog(ERROR, "unknown JSON_TABLE column type: %d", (int) rawc->coltype);
                break;
        }
 
        tf->coltypes = lappend_oid(tf->coltypes, typid);
        tf->coltypmods = lappend_int(tf->coltypmods, typmod);
        tf->colcollations = lappend_oid(tf->colcollations, typcoll);
        tf->colvalexprs = lappend(tf->colvalexprs, colexpr);
    }
}

References assign_expr_collations(), castNode, TableFunc::docexpr, elog, ereport, errcode(), errmsg, ERROR, EXPR_KIND_FROM_FUNCTION, exprCollation(), exprType(), exprTypmod(), fb(), InvalidOid, isCompositeType(), JS_QUOTES_UNSPEC, JSW_UNSPEC, JTC_EXISTS, JTC_FOR_ORDINALITY, JTC_FORMATTED, JTC_NESTED, JTC_REGULAR, lappend(), lappend_int(), lappend_oid(), lfirst, makeNode, makeString(), parser_errposition(), pg_fallthrough, JsonTableParseContext::pstate, pstrdup(), JsonTableParseContext::tf, transformExpr(), transformJsonTableColumn(), CaseTestExpr::typeId, and typenameTypeIdAndMod().

Referenced by transformJsonTableColumns().

CheckDuplicateColumnOrPathNames()

static void CheckDuplicateColumnOrPathNames ( JsonTableParseContext *  cxt, List *  columns  )

static

Definition at line 199 of file parse_jsontable.c.

{
    ListCell   *lc1;
 
    foreach(lc1, columns)
    {
        JsonTableColumn *jtc = castNode(JsonTableColumn, lfirst(lc1));
 
        if (jtc->coltype == JTC_NESTED)
        {
            if (jtc->pathspec->name)
            {
                if (LookupPathOrColumnName(cxt, jtc->pathspec->name))
                    ereport(ERROR,
                            errcode(ERRCODE_DUPLICATE_ALIAS),
                            errmsg("duplicate JSON_TABLE column or path name: %s",
                                   jtc->pathspec->name),
                            parser_errposition(cxt->pstate,
                                               jtc->pathspec->name_location));
                cxt->pathNames = lappend(cxt->pathNames, jtc->pathspec->name);
            }
 
            CheckDuplicateColumnOrPathNames(cxt, jtc->columns);
        }
        else
        {
            if (LookupPathOrColumnName(cxt, jtc->name))
                ereport(ERROR,
                        errcode(ERRCODE_DUPLICATE_ALIAS),
                        errmsg("duplicate JSON_TABLE column or path name: %s",
                               jtc->name),
                        parser_errposition(cxt->pstate, jtc->location));
            cxt->pathNames = lappend(cxt->pathNames, jtc->name);
        }
    }
}

References castNode, CheckDuplicateColumnOrPathNames(), ereport, errcode(), errmsg, ERROR, fb(), JTC_NESTED, lappend(), lfirst, LookupPathOrColumnName(), parser_errposition(), JsonTableParseContext::pathNames, and JsonTableParseContext::pstate.

Referenced by CheckDuplicateColumnOrPathNames(), and transformJsonTable().

collectSiblingPathsInJsonTablePlan()

static void collectSiblingPathsInJsonTablePlan ( JsonTablePlanSpec *  plan, List **  paths  )

static

Definition at line 729 of file parse_jsontable.c.

{
    if (plan->plan_type == JSTP_SIMPLE)
        *paths = lappend(*paths, plan->pathname);
    else if (plan->plan_type == JSTP_JOINED)
    {
        if (plan->join_type == JSTP_JOIN_INNER ||
            plan->join_type == JSTP_JOIN_OUTER)
        {
            Assert(plan->plan1->plan_type == JSTP_SIMPLE);
            *paths = lappend(*paths, plan->plan1->pathname);
        }
        else if (plan->join_type == JSTP_JOIN_CROSS ||
                 plan->join_type == JSTP_JOIN_UNION)
        {
            collectSiblingPathsInJsonTablePlan(plan->plan1, paths);
            collectSiblingPathsInJsonTablePlan(plan->plan2, paths);
        }
        else
            elog(ERROR, "invalid JSON_TABLE join type %d",
                 plan->join_type);
    }
}

References Assert, collectSiblingPathsInJsonTablePlan(), elog, ERROR, JSTP_JOIN_CROSS, JSTP_JOIN_INNER, JSTP_JOIN_OUTER, JSTP_JOIN_UNION, JSTP_JOINED, JSTP_SIMPLE, lappend(), and plan.

Referenced by collectSiblingPathsInJsonTablePlan(), and validateJsonTableChildPlan().

findNestedJsonTableColumn()

static JsonTableColumn * findNestedJsonTableColumn ( List *  columns, const char *  pathname  )

static

Definition at line 547 of file parse_jsontable.c.

{
    ListCell   *lc;
 
    foreach(lc, columns)
    {
        JsonTableColumn *jtc = castNode(JsonTableColumn, lfirst(lc));
 
        if (jtc->coltype == JTC_NESTED &&
            jtc->pathspec->name &&
            !strcmp(jtc->pathspec->name, pathname))
            return jtc;
    }
 
    return NULL;
}

References castNode, fb(), JTC_NESTED, and lfirst.

Referenced by transformJsonTableNestedColumns().

generateJsonTablePathName()

static char * generateJsonTablePathName ( JsonTableParseContext *  cxt )

static

Definition at line 257 of file parse_jsontable.c.

{
    char        namebuf[32];
    char       *name;
 
    /*
     * Bump the counter until we produce a name that is not already used as a
     * path or column name.  Otherwise a generated name could coincide with a
     * user-supplied one, which would confuse PLAN clause matching and could
     * silently drop a column.
     */
    do
    {
        snprintf(namebuf, sizeof(namebuf), "json_table_path_%d",
                 cxt->pathNameId++);
    } while (LookupPathOrColumnName(cxt, namebuf));
 
    name = pstrdup(namebuf);
    cxt->pathNames = lappend(cxt->pathNames, name);
 
    return name;
}

References fb(), lappend(), LookupPathOrColumnName(), name, JsonTableParseContext::pathNameId, JsonTableParseContext::pathNames, pstrdup(), and snprintf.

Referenced by transformJsonTable(), transformJsonTableNestedColumns(), and validateJsonTableChildPlan().

isCompositeType()

static bool isCompositeType ( Oid  typid )

static

Definition at line 474 of file parse_jsontable.c.

{
    char        typtype = get_typtype(typid);
 
    return typid == JSONOID ||
        typid == JSONBOID ||
        typid == RECORDOID ||
        type_is_array(typid) ||
        typtype == TYPTYPE_COMPOSITE ||
    /* domain over one of the above? */
        (typtype == TYPTYPE_DOMAIN &&
         isCompositeType(getBaseType(typid)));
}

References fb(), get_typtype(), getBaseType(), isCompositeType(), and type_is_array.

Referenced by AlterTypeNamespaceInternal(), appendJsonTableColumns(), and isCompositeType().

LookupPathOrColumnName()

static bool LookupPathOrColumnName ( JsonTableParseContext *  cxt, char *  name  )

static

Definition at line 242 of file parse_jsontable.c.

{
    ListCell   *lc;
 
    foreach(lc, cxt->pathNames)
    {
        if (strcmp(name, (const char *) lfirst(lc)) == 0)
            return true;
    }
 
    return false;
}

References fb(), lfirst, name, and JsonTableParseContext::pathNames.

Referenced by CheckDuplicateColumnOrPathNames(), and generateJsonTablePathName().

makeJsonTablePathScan()

static JsonTablePlan * makeJsonTablePathScan ( JsonTableParseContext *  cxt, JsonTablePathSpec *  pathspec, JsonTablePlanSpec *  planspec, bool  errorOnError, int  colMin, int  colMax, JsonTablePlan *  childplan  )

static

Definition at line 673 of file parse_jsontable.c.

{
    JsonTablePathScan *scan = makeNode(JsonTablePathScan);
    char       *pathstring;
    Const      *value;
 
    Assert(IsA(pathspec->string, A_Const));
    pathstring = castNode(A_Const, pathspec->string)->val.sval.sval;
    value = makeConst(JSONPATHOID, -1, InvalidOid, -1,
                      DirectFunctionCall1(jsonpath_in,
                                          CStringGetDatum(pathstring)),
                      false, false);
 
    scan->plan.type = T_JsonTablePathScan;
    scan->path = makeJsonTablePath(value, pathspec->name);
    scan->errorOnError = errorOnError;
 
    scan->child = childplan;
 
    scan->colMin = colMin;
    scan->colMax = colMax;
 
    if (scan->child)
        scan->outerJoin = planspec == NULL ||
            (planspec->join_type & JSTP_JOIN_OUTER);
    /* else: default plan case, no children found */
 
    return (JsonTablePlan *) scan;
}

References Assert, castNode, JsonTablePathScan::child, JsonTablePathScan::colMax, JsonTablePathScan::colMin, CStringGetDatum(), DirectFunctionCall1, JsonTablePathScan::errorOnError, fb(), InvalidOid, IsA, JsonTablePlanSpec::join_type, jsonpath_in(), JSTP_JOIN_OUTER, makeConst(), makeJsonTablePath(), makeNode, JsonTablePathSpec::name, JsonTablePathScan::outerJoin, JsonTablePathScan::path, JsonTablePathScan::plan, JsonTablePathSpec::string, and value.

Referenced by transformJsonTableColumns().

makeJsonTableSiblingJoin()

static JsonTablePlan * makeJsonTableSiblingJoin ( bool  cross, JsonTablePlan *  lplan, JsonTablePlan *  rplan  )

static

Definition at line 715 of file parse_jsontable.c.

{
    JsonTableSiblingJoin *join = makeNode(JsonTableSiblingJoin);
 
    join->plan.type = T_JsonTableSiblingJoin;
    join->lplan = lplan;
    join->rplan = rplan;
    join->cross = cross;
 
    return (JsonTablePlan *) join;
}

References JsonTableSiblingJoin::cross, fb(), JsonTableSiblingJoin::lplan, makeNode, JsonTableSiblingJoin::plan, and JsonTableSiblingJoin::rplan.

Referenced by transformJsonTableNestedColumns().

transformJsonTable()

ParseNamespaceItem * transformJsonTable	(	ParseState *	pstate,
		JsonTable *	jt
	)

Definition at line 84 of file parse_jsontable.c.

{
    TableFunc  *tf;
    JsonFuncExpr *jfe;
    JsonExpr   *je;
    JsonTablePlanSpec *plan = jt->planspec;
    JsonTablePathSpec *rootPathSpec = jt->pathspec;
    bool        is_lateral;
    JsonTableParseContext cxt = {pstate};
 
    Assert(IsA(rootPathSpec->string, A_Const) &&
           castNode(A_Const, rootPathSpec->string)->val.node.type == T_String);
 
    if (jt->on_error &&
        jt->on_error->btype != JSON_BEHAVIOR_ERROR &&
        jt->on_error->btype != JSON_BEHAVIOR_EMPTY &&
        jt->on_error->btype != JSON_BEHAVIOR_EMPTY_ARRAY)
        ereport(ERROR,
                errcode(ERRCODE_SYNTAX_ERROR),
                errmsg("invalid %s behavior", "ON ERROR"),
                errdetail("Only EMPTY [ ARRAY ] or ERROR is allowed in the top-level ON ERROR clause."),
                parser_errposition(pstate, jt->on_error->location));
 
    cxt.pathNameId = 0;
 
    /*
     * Collect the user-supplied path and column names, checking that they are
     * distinct.  If the row pattern path has an explicit name, it shares this
     * namespace, so seed the list with it.
     */
    if (rootPathSpec->name != NULL)
        cxt.pathNames = list_make1(rootPathSpec->name);
    CheckDuplicateColumnOrPathNames(&cxt, jt->columns);
 
    /*
     * Generate a name for the row pattern path if it was not given one.  Path
     * names are optional for every path, including when a PLAN clause is
     * present; a specific PLAN() can only reference named paths, so an
     * unnamed path that the plan must mention is caught later as a path name
     * mismatch or a path not covered by the plan.  We generate the name only
     * after collecting the user-supplied names above, so that it cannot
     * collide with any of them.
     */
    if (rootPathSpec->name == NULL)
        rootPathSpec->name = generateJsonTablePathName(&cxt);
 
    /*
     * We make lateral_only names of this level visible, whether or not the
     * RangeTableFunc is explicitly marked LATERAL.  This is needed for SQL
     * spec compliance and seems useful on convenience grounds for all
     * functions in FROM.
     *
     * (LATERAL can't nest within a single pstate level, so we don't need
     * save/restore logic here.)
     */
    Assert(!pstate->p_lateral_active);
    pstate->p_lateral_active = true;
 
    tf = makeNode(TableFunc);
    tf->functype = TFT_JSON_TABLE;
 
    /*
     * Transform JsonFuncExpr representing the top JSON_TABLE context_item and
     * pathspec into a dummy JSON_TABLE_OP JsonExpr.
     */
    jfe = makeNode(JsonFuncExpr);
    jfe->op = JSON_TABLE_OP;
    jfe->context_item = jt->context_item;
    jfe->pathspec = (Node *) rootPathSpec->string;
    jfe->passing = jt->passing;
    jfe->on_empty = NULL;
    jfe->on_error = jt->on_error;
    jfe->location = jt->location;
    tf->docexpr = transformExpr(pstate, (Node *) jfe, EXPR_KIND_FROM_FUNCTION);
 
    /*
     * Create a JsonTablePlan that will generate row pattern that becomes
     * source data for JSON path expressions in jt->columns.  This also adds
     * the columns' transformed JsonExpr nodes into tf->colvalexprs.
     */
    cxt.jt = jt;
    cxt.tf = tf;
    tf->plan = (Node *) transformJsonTableColumns(&cxt, plan, jt->columns,
                                                  jt->passing,
                                                  rootPathSpec);
 
    /*
     * Copy the transformed PASSING arguments into the TableFunc node, because
     * they are evaluated separately from the JsonExpr that we just put in
     * TableFunc.docexpr.  JsonExpr.passing_values is still kept around for
     * get_json_table().
     */
    je = (JsonExpr *) tf->docexpr;
    tf->passingvalexprs = copyObject(je->passing_values);
 
    tf->ordinalitycol = -1;     /* undefine ordinality column number */
    tf->location = jt->location;
 
    pstate->p_lateral_active = false;
 
    /*
     * Mark the RTE as LATERAL if the user said LATERAL explicitly, or if
     * there are any lateral cross-references in it.
     */
    is_lateral = jt->lateral || contain_vars_of_level((Node *) tf, 0);
 
    return addRangeTableEntryForTableFunc(pstate,
                                          tf, jt->alias, is_lateral, true);
}

References addRangeTableEntryForTableFunc(), JsonTable::alias, Assert, JsonBehavior::btype, castNode, CheckDuplicateColumnOrPathNames(), JsonTable::columns, contain_vars_of_level(), JsonTable::context_item, copyObject, TableFunc::docexpr, ereport, errcode(), errdetail(), errmsg, ERROR, EXPR_KIND_FROM_FUNCTION, fb(), TableFunc::functype, generateJsonTablePathName(), IsA, JSON_BEHAVIOR_EMPTY, JSON_BEHAVIOR_EMPTY_ARRAY, JSON_BEHAVIOR_ERROR, JSON_TABLE_OP, JsonTableParseContext::jt, JsonTable::lateral, list_make1, JsonTable::location, TableFunc::location, JsonBehavior::location, makeNode, JsonTable::on_error, ParseState::p_lateral_active, parser_errposition(), JsonTable::passing, JsonTableParseContext::pathNameId, JsonTableParseContext::pathNames, JsonTable::pathspec, plan, JsonTable::planspec, JsonTableParseContext::tf, TFT_JSON_TABLE, transformExpr(), and transformJsonTableColumns().

Referenced by transformFromClauseItem().

transformJsonTableColumn()

static JsonFuncExpr * transformJsonTableColumn ( JsonTableColumn *  jtc, Node *  contextItemExpr, List *  passingArgs  )

static

Definition at line 496 of file parse_jsontable.c.

{
    Node       *pathspec;
    JsonFuncExpr *jfexpr = makeNode(JsonFuncExpr);
 
    if (jtc->coltype == JTC_REGULAR)
        jfexpr->op = JSON_VALUE_OP;
    else if (jtc->coltype == JTC_EXISTS)
        jfexpr->op = JSON_EXISTS_OP;
    else
        jfexpr->op = JSON_QUERY_OP;
 
    /* Pass the column name so any runtime JsonExpr errors can print it. */
    Assert(jtc->name != NULL);
    jfexpr->column_name = pstrdup(jtc->name);
 
    jfexpr->context_item = makeJsonValueExpr((Expr *) contextItemExpr, NULL,
                                             makeJsonFormat(JS_FORMAT_DEFAULT,
                                                            JS_ENC_DEFAULT,
                                                            -1));
    if (jtc->pathspec)
        pathspec = (Node *) jtc->pathspec->string;
    else
    {
        /* Construct default path as '$."column_name"' */
        StringInfoData path;
 
        initStringInfo(&path);
 
        appendStringInfoString(&path, "$.");
        escape_json(&path, jtc->name);
 
        pathspec = makeStringConst(path.data, -1);
    }
    jfexpr->pathspec = pathspec;
    jfexpr->passing = passingArgs;
    jfexpr->output = makeNode(JsonOutput);
    jfexpr->output->typeName = jtc->typeName;
    jfexpr->output->returning = makeNode(JsonReturning);
    jfexpr->output->returning->format = jtc->format;
    jfexpr->on_empty = jtc->on_empty;
    jfexpr->on_error = jtc->on_error;
    jfexpr->quotes = jtc->quotes;
    jfexpr->wrapper = jtc->wrapper;
    jfexpr->location = jtc->location;
 
    return jfexpr;
}

References appendStringInfoString(), Assert, StringInfoData::data, escape_json(), fb(), initStringInfo(), JS_ENC_DEFAULT, JS_FORMAT_DEFAULT, JSON_EXISTS_OP, JSON_QUERY_OP, JSON_VALUE_OP, JTC_EXISTS, JTC_REGULAR, makeJsonFormat(), makeJsonValueExpr(), makeNode, makeStringConst(), and pstrdup().

Referenced by appendJsonTableColumns().

transformJsonTableColumns()

static JsonTablePlan * transformJsonTableColumns ( JsonTableParseContext *  cxt, JsonTablePlanSpec *  planspec, List *  columns, List *  passingArgs, JsonTablePathSpec *  pathspec  )

static

Definition at line 286 of file parse_jsontable.c.

{
    JsonTable  *jt = cxt->jt;
    TableFunc  *tf = cxt->tf;
    JsonTablePathScan *scan;
    JsonTablePlanSpec *childPlanSpec;
    bool        defaultPlan = planspec == NULL ||
        planspec->plan_type == JSTP_DEFAULT;
    bool        errorOnError = jt->on_error &&
        jt->on_error->btype == JSON_BEHAVIOR_ERROR;
    int         colMin,
                colMax;
    JsonTablePlan *childplan = NULL;
 
    /* Start of column range */
    colMin = list_length(tf->colvalexprs);
 
    if (defaultPlan)
        childPlanSpec = planspec;
    else
    {
        /* validate parent and child plans */
        JsonTablePlanSpec *parentPlanSpec;
 
        if (planspec->plan_type == JSTP_JOINED)
        {
            if (planspec->join_type != JSTP_JOIN_INNER &&
                planspec->join_type != JSTP_JOIN_OUTER)
                ereport(ERROR,
                        (errcode(ERRCODE_SYNTAX_ERROR),
                         errmsg("invalid JSON_TABLE plan clause"),
                         errdetail("Expected INNER or OUTER."),
                         parser_errposition(cxt->pstate, planspec->location)));
 
            parentPlanSpec = planspec->plan1;
            childPlanSpec = planspec->plan2;
 
            Assert(parentPlanSpec->plan_type != JSTP_JOINED);
            Assert(parentPlanSpec->pathname);
        }
        else
        {
            parentPlanSpec = planspec;
            childPlanSpec = NULL;
        }
 
        if (strcmp(parentPlanSpec->pathname, pathspec->name) != 0)
            ereport(ERROR,
                    (errcode(ERRCODE_SYNTAX_ERROR),
                     errmsg("invalid JSON_TABLE plan"),
                     errdetail("PATH name mismatch: expected %s but %s is given.",
                               pathspec->name, parentPlanSpec->pathname),
                     parser_errposition(cxt->pstate, planspec->location)));
 
        validateJsonTableChildPlan(cxt, childPlanSpec, columns);
    }
 
    appendJsonTableColumns(cxt, columns, passingArgs);
 
    /* End of column range. */
    if (list_length(tf->colvalexprs) == colMin)
    {
        /* No columns in this Scan beside the nested ones. */
        colMax = colMin = -1;
    }
    else
        colMax = list_length(tf->colvalexprs) - 1;
 
    if (childPlanSpec || defaultPlan)
    {
        /* transform recursively nested columns */
        childplan = transformJsonTableNestedColumns(cxt, childPlanSpec,
                                                    columns, passingArgs);
    }
 
    /* transform only non-nested columns */
    scan = (JsonTablePathScan *) makeJsonTablePathScan(cxt, pathspec,
                                                       planspec,
                                                       errorOnError,
                                                       colMin,
                                                       colMax,
                                                       childplan);
 
    return (JsonTablePlan *) scan;
}

References appendJsonTableColumns(), Assert, JsonBehavior::btype, ereport, errcode(), errdetail(), errmsg, ERROR, fb(), JsonTablePlanSpec::join_type, JSON_BEHAVIOR_ERROR, JSTP_DEFAULT, JSTP_JOIN_INNER, JSTP_JOIN_OUTER, JSTP_JOINED, JsonTableParseContext::jt, list_length(), JsonTablePlanSpec::location, makeJsonTablePathScan(), JsonTablePathSpec::name, JsonTable::on_error, parser_errposition(), JsonTablePlanSpec::plan1, JsonTablePlanSpec::plan2, JsonTablePlanSpec::plan_type, JsonTableParseContext::pstate, JsonTableParseContext::tf, transformJsonTableNestedColumns(), and validateJsonTableChildPlan().

Referenced by transformJsonTable(), and transformJsonTableNestedColumns().

transformJsonTableNestedColumns()

static JsonTablePlan * transformJsonTableNestedColumns ( JsonTableParseContext *  cxt, JsonTablePlanSpec *  plan, List *  passingArgs, List *  columns  )

static

Definition at line 574 of file parse_jsontable.c.

{
    JsonTableColumn *jtc = NULL;
 
    if (!planspec || planspec->plan_type == JSTP_DEFAULT)
    {
        /* unspecified or default plan */
        JsonTablePlan *plan = NULL;
        ListCell   *lc;
        bool        cross = planspec && (planspec->join_type & JSTP_JOIN_CROSS);
 
        /*
         * If there are multiple NESTED COLUMNS clauses in 'columns', their
         * respective plans will be combined using a "sibling join" plan,
         * which effectively does a UNION of the sets of rows coming from each
         * nested plan.
         */
        foreach(lc, columns)
        {
            JsonTableColumn *col = castNode(JsonTableColumn, lfirst(lc));
            JsonTablePlan *nested;
 
            if (col->coltype != JTC_NESTED)
                continue;
 
            if (col->pathspec->name == NULL)
            {
                col->pathspec->name = generateJsonTablePathName(cxt);
            }
 
            nested = transformJsonTableColumns(cxt, planspec, col->columns,
                                               passingArgs,
                                               col->pathspec);
 
            /* Join nested plan with previous sibling nested plans. */
            if (plan)
                plan = makeJsonTableSiblingJoin(cross, plan, nested);
            else
                plan = nested;
        }
 
        return plan;
    }
    else if (planspec->plan_type == JSTP_SIMPLE)
    {
        jtc = findNestedJsonTableColumn(columns, planspec->pathname);
    }
    else if (planspec->plan_type == JSTP_JOINED)
    {
        if (planspec->join_type == JSTP_JOIN_INNER ||
            planspec->join_type == JSTP_JOIN_OUTER)
        {
            Assert(planspec->plan1->plan_type == JSTP_SIMPLE);
            jtc = findNestedJsonTableColumn(columns, planspec->plan1->pathname);
        }
        else
        {
            JsonTablePlan *lplan = transformJsonTableNestedColumns(cxt,
                                                                   planspec->plan1,
                                                                   columns,
                                                                   passingArgs);
            JsonTablePlan *rplan = transformJsonTableNestedColumns(cxt,
                                                                   planspec->plan2,
                                                                   columns,
                                                                   passingArgs);
 
            return makeJsonTableSiblingJoin(planspec->join_type == JSTP_JOIN_CROSS,
                                            lplan, rplan);
        }
    }
    else
        elog(ERROR, "invalid JSON_TABLE plan type %d", planspec->plan_type);
 
    /*
     * The plan's path names were already matched one-to-one against the
     * nested columns by validateJsonTableChildPlan(), so a nested column with
     * this path name must exist.
     */
    Assert(jtc != NULL);
 
    return transformJsonTableColumns(cxt, planspec, jtc->columns,
                                     passingArgs,
                                     jtc->pathspec);
}

References Assert, castNode, elog, ERROR, fb(), findNestedJsonTableColumn(), generateJsonTablePathName(), JsonTablePlanSpec::join_type, JSTP_DEFAULT, JSTP_JOIN_CROSS, JSTP_JOIN_INNER, JSTP_JOIN_OUTER, JSTP_JOINED, JSTP_SIMPLE, JTC_NESTED, lfirst, makeJsonTableSiblingJoin(), JsonTablePlanSpec::pathname, plan, JsonTablePlanSpec::plan1, JsonTablePlanSpec::plan2, JsonTablePlanSpec::plan_type, transformJsonTableColumns(), and transformJsonTableNestedColumns().

Referenced by transformJsonTableColumns(), and transformJsonTableNestedColumns().

validateJsonTableChildPlan()

static void validateJsonTableChildPlan ( JsonTableParseContext *  cxt, JsonTablePlanSpec *  plan, List *  columns  )

static

Definition at line 760 of file parse_jsontable.c.

{
    ParseState *pstate = cxt->pstate;
    ListCell   *lc1;
    List       *siblings = NIL;
    int         nchildren = 0;
 
    if (plan)
        collectSiblingPathsInJsonTablePlan(plan, &siblings);
 
    foreach(lc1, columns)
    {
        JsonTableColumn *jtc = castNode(JsonTableColumn, lfirst(lc1));
 
        if (jtc->coltype == JTC_NESTED)
        {
            ListCell   *lc2;
            bool        found = false;
 
            /*
             * A NESTED path need not be named; generate a name if it was left
             * unnamed.  A generated name cannot be referenced by a specific
             * PLAN(), so such a path is reported just below as a nested path
             * not covered by the plan.
             */
            if (jtc->pathspec->name == NULL)
                jtc->pathspec->name = generateJsonTablePathName(cxt);
 
            /* find nested path name in the list of sibling path names */
            foreach(lc2, siblings)
            {
                if ((found = !strcmp(jtc->pathspec->name, lfirst(lc2))))
                    break;
            }
 
            if (!found)
                ereport(ERROR,
                        errcode(ERRCODE_SYNTAX_ERROR),
                        errmsg("invalid JSON_TABLE specification"),
                        errdetail("PLAN clause for nested path %s was not found.",
                                  jtc->pathspec->name),
                        parser_errposition(pstate, jtc->location));
 
            nchildren++;
        }
    }
 
    if (list_length(siblings) > nchildren)
        ereport(ERROR,
                errcode(ERRCODE_SYNTAX_ERROR),
                errmsg("invalid JSON_TABLE plan clause"),
                errdetail("PLAN clause contains some extra or duplicate sibling nodes."),
                parser_errposition(pstate, plan ? plan->location : -1));
}

References castNode, collectSiblingPathsInJsonTablePlan(), ereport, errcode(), errdetail(), errmsg, ERROR, fb(), generateJsonTablePathName(), JTC_NESTED, lfirst, list_length(), NIL, parser_errposition(), plan, and JsonTableParseContext::pstate.

Referenced by transformJsonTableColumns().