parse_jsontable.c

Go to the documentation of this file.

/*-------------------------------------------------------------------------
 *
 * parse_jsontable.c
 *    parsing of JSON_TABLE
 *
 * Portions Copyright (c) 1996-2025, PostgreSQL Global Development Group
 * Portions Copyright (c) 1994, Regents of the University of California
 *
 *
 * IDENTIFICATION
 *    src/backend/parser/parse_jsontable.c
 *
 *-------------------------------------------------------------------------
 */
 
#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"
 
/* Context for transformJsonTableColumns() */
typedef struct JsonTableParseContext
{
    ParseState *pstate;
    JsonTable  *jt;
    TableFunc  *tf;
    List       *pathNames;      /* list of all path and columns names */
    int         pathNameId;     /* path name id counter */
} JsonTableParseContext;
 
static JsonTablePlan *transformJsonTableColumns(JsonTableParseContext *cxt,
                                                List *columns,
                                                List *passingArgs,
                                                JsonTablePathSpec *pathspec);
static JsonTablePlan *transformJsonTableNestedColumns(JsonTableParseContext *cxt,
                                                      List *passingArgs,
                                                      List *columns);
static JsonFuncExpr *transformJsonTableColumn(JsonTableColumn *jtc,
                                              Node *contextItemExpr,
                                              List *passingArgs);
static bool isCompositeType(Oid typid);
static JsonTablePlan *makeJsonTablePathScan(JsonTablePathSpec *pathspec,
                                            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 JsonTablePlan *makeJsonTableSiblingJoin(JsonTablePlan *lplan,
                                               JsonTablePlan *rplan);
 
/*
 * transformJsonTable -
 *          Transform a raw JsonTable into TableFunc
 *
 * Mainly, this transforms the JSON_TABLE() document-generating expression
 * (jt->context_item) and the column-generating expressions (jt->columns) to
 * populate TableFunc.docexpr and TableFunc.colvalexprs, respectively. Also,
 * the PASSING values (jt->passing) are transformed and added into
 * TableFunc.passingvalexprs.
 */
ParseNamespaceItem *
transformJsonTable(ParseState *pstate, JsonTable *jt)
{
    TableFunc  *tf;
    JsonFuncExpr *jfe;
    JsonExpr   *je;
    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;
    if (rootPathSpec->name == NULL)
        rootPathSpec->name = generateJsonTablePathName(&cxt);
    cxt.pathNames = list_make1(rootPathSpec->name);
    CheckDuplicateColumnOrPathNames(&cxt, jt->columns);
 
    /*
     * 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, 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);
}
 
/*
 * Check if a column / path name is duplicated in the given shared list of
 * names.
 */
static void
CheckDuplicateColumnOrPathNames(JsonTableParseContext *cxt,
                                List *columns)
{
    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);
        }
    }
}
 
/*
 * Lookup a column/path name in the given name list, returning true if already
 * there.
 */
static bool
LookupPathOrColumnName(JsonTableParseContext *cxt, char *name)
{
    ListCell   *lc;
 
    foreach(lc, cxt->pathNames)
    {
        if (strcmp(name, (const char *) lfirst(lc)) == 0)
            return true;
    }
 
    return false;
}
 
/* Generate a new unique JSON_TABLE path name. */
static char *
generateJsonTablePathName(JsonTableParseContext *cxt)
{
    char        namebuf[32];
    char       *name = namebuf;
 
    snprintf(namebuf, sizeof(namebuf), "json_table_path_%d",
             cxt->pathNameId++);
 
    name = pstrdup(name);
    cxt->pathNames = lappend(cxt->pathNames, name);
 
    return name;
}
 
/*
 * Create a JsonTablePlan that will supply the source row for 'columns'
 * using 'pathspec' and append the columns' transformed JsonExpr nodes and
 * their type/collation information to cxt->tf.
 */
static JsonTablePlan *
transformJsonTableColumns(JsonTableParseContext *cxt, List *columns,
                          List *passingArgs,
                          JsonTablePathSpec *pathspec)
{
    ParseState *pstate = cxt->pstate;
    JsonTable  *jt = cxt->jt;
    TableFunc  *tf = cxt->tf;
    ListCell   *col;
    bool        ordinality_found = false;
    bool        errorOnError = jt->on_error &&
        jt->on_error->btype == JSON_BEHAVIOR_ERROR;
    Oid         contextItemTypid = exprType(tf->docexpr);
    int         colMin,
                colMax;
    JsonTablePlan *childplan;
 
    /* Start of column range */
    colMin = list_length(tf->colvalexprs);
 
    foreach(col, columns)
    {
        JsonTableColumn *rawc = castNode(JsonTableColumn, lfirst(col));
        Oid         typid;
        int32       typmod;
        Oid         typcoll = InvalidOid;
        Node       *colexpr;
 
        if (rawc->coltype != JTC_NESTED)
        {
            Assert(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;
 
                /* 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);
    }
 
    /* 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;
 
    /* Recursively transform nested columns */
    childplan = transformJsonTableNestedColumns(cxt, passingArgs, columns);
 
    /* Create a "parent" scan responsible for all columns handled above. */
    return makeJsonTablePathScan(pathspec, errorOnError, colMin, colMax,
                                 childplan);
}
 
/*
 * Check if the type is "composite" for the purpose of checking whether to use
 * JSON_VALUE() or JSON_QUERY() for a given JsonTableColumn.
 */
static bool
isCompositeType(Oid typid)
{
    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)));
}
 
/*
 * Transform JSON_TABLE column definition into a JsonFuncExpr
 * This turns:
 *   - regular column into JSON_VALUE()
 *   - FORMAT JSON column into JSON_QUERY()
 *   - EXISTS column into JSON_EXISTS()
 */
static JsonFuncExpr *
transformJsonTableColumn(JsonTableColumn *jtc, Node *contextItemExpr,
                         List *passingArgs)
{
    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;
}
 
/*
 * Recursively transform nested columns and create child plan(s) that will be
 * used to evaluate their row patterns.
 */
static JsonTablePlan *
transformJsonTableNestedColumns(JsonTableParseContext *cxt,
                                List *passingArgs,
                                List *columns)
{
    JsonTablePlan *plan = NULL;
    ListCell   *lc;
 
    /*
     * 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 *jtc = castNode(JsonTableColumn, lfirst(lc));
        JsonTablePlan *nested;
 
        if (jtc->coltype != JTC_NESTED)
            continue;
 
        if (jtc->pathspec->name == NULL)
            jtc->pathspec->name = generateJsonTablePathName(cxt);
 
        nested = transformJsonTableColumns(cxt, jtc->columns, passingArgs,
                                           jtc->pathspec);
 
        if (plan)
            plan = makeJsonTableSiblingJoin(plan, nested);
        else
            plan = nested;
    }
 
    return plan;
}
 
/*
 * Create a JsonTablePlan for given path and ON ERROR behavior.
 *
 * colMin and colMin give the range of columns computed by this scan in the
 * global flat list of column expressions that will be passed to the
 * JSON_TABLE's TableFunc.  Both are -1 when all of columns are nested and
 * thus computed by 'childplan'.
 */
static JsonTablePlan *
makeJsonTablePathScan(JsonTablePathSpec *pathspec, bool errorOnError,
                      int colMin, int colMax,
                      JsonTablePlan *childplan)
{
    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;
 
    return (JsonTablePlan *) scan;
}
 
/*
 * Create a JsonTablePlan that will perform a join of the rows coming from
 * 'lplan' and 'rplan'.
 *
 * The default way of "joining" the rows is to perform a UNION between the
 * sets of rows from 'lplan' and 'rplan'.
 */
static JsonTablePlan *
makeJsonTableSiblingJoin(JsonTablePlan *lplan, JsonTablePlan *rplan)
{
    JsonTableSiblingJoin *join = makeNode(JsonTableSiblingJoin);
 
    join->plan.type = T_JsonTableSiblingJoin;
    join->lplan = lplan;
    join->rplan = rplan;
 
    return (JsonTablePlan *) join;
}