#include "postgres.h"
#include "catalog/pg_collation.h"
#include "catalog/pg_type.h"
#include "miscadmin.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/builtins.h"
#include "utils/json.h"
#include "utils/lsyscache.h"

Include dependency graph for parse_jsontable.c:

Data Structures
struct	JsonTableParseContext

Typedefs
typedef struct JsonTableParseContext	JsonTableParseContext

Functions
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)

ParseNamespaceItem *	transformJsonTable (ParseState pstate, JsonTable jt)

Typedef Documentation

◆ JsonTableParseContext

typedef struct JsonTableParseContext JsonTableParseContext

Function Documentation

◆ CheckDuplicateColumnOrPathNames()

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

static

Definition at line 173 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, JsonTableColumn::coltype, JsonTableColumn::columns, ereport, errcode(), errmsg(), ERROR, JTC_NESTED, lappend(), lfirst, JsonTableColumn::location, LookupPathOrColumnName(), JsonTablePathSpec::name, JsonTableColumn::name, JsonTablePathSpec::name_location, parser_errposition(), JsonTableParseContext::pathNames, JsonTableColumn::pathspec, and JsonTableParseContext::pstate.

Referenced by transformJsonTable().

◆ generateJsonTablePathName()

static char * generateJsonTablePathName ( JsonTableParseContext * cxt )

static

Definition at line 231 of file parse_jsontable.c.

 {
     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;
 }

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

Referenced by transformJsonTable(), and transformJsonTableNestedColumns().

◆ isCompositeType()

static bool isCompositeType ( Oid typid )

static

Definition at line 377 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 get_typtype(), getBaseType(), and type_is_array.

Referenced by AlterTypeNamespaceInternal(), and transformJsonTableColumns().

◆ LookupPathOrColumnName()

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

static

Definition at line 216 of file parse_jsontable.c.

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

References lfirst, name, and JsonTableParseContext::pathNames.

Referenced by CheckDuplicateColumnOrPathNames().

◆ makeJsonTablePathScan()

static JsonTablePlan * makeJsonTablePathScan	(	JsonTablePathSpec *	pathspec,
		bool	errorOnError,
		int	colMin,
		int	colMax,
		JsonTablePlan *	childplan
	)

static

Definition at line 499 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;
  
     return (JsonTablePlan *) scan;
 }

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

Referenced by transformJsonTableColumns().

◆ makeJsonTableSiblingJoin()

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

static

Definition at line 534 of file parse_jsontable.c.

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

References JsonTableSiblingJoin::lplan, makeNode, JsonTableSiblingJoin::plan, and JsonTableSiblingJoin::rplan.

Referenced by transformJsonTableNestedColumns().

◆ transformJsonTable()

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

Definition at line 76 of file parse_jsontable.c.

 {
     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 ON ERROR behavior"),
                 errdetail("Only EMPTY 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);
 }

References addRangeTableEntryForTableFunc(), JsonTable::alias, Assert, JsonBehavior::btype, castNode, CheckDuplicateColumnOrPathNames(), JsonTable::columns, contain_vars_of_level(), JsonFuncExpr::context_item, JsonTable::context_item, copyObject, TableFunc::docexpr, ereport, errcode(), errdetail(), errmsg(), ERROR, EXPR_KIND_FROM_FUNCTION, TableFunc::functype, generateJsonTablePathName(), IsA, JSON_BEHAVIOR_EMPTY, JSON_BEHAVIOR_EMPTY_ARRAY, JSON_BEHAVIOR_ERROR, JSON_TABLE_OP, JsonTableParseContext::jt, JsonTable::lateral, list_make1, JsonFuncExpr::location, JsonTable::location, TableFunc::location, JsonBehavior::location, makeNode, JsonTablePathSpec::name, JsonFuncExpr::on_empty, JsonFuncExpr::on_error, JsonTable::on_error, JsonFuncExpr::op, ParseState::p_lateral_active, parser_errposition(), JsonFuncExpr::passing, JsonTable::passing, JsonExpr::passing_values, JsonTableParseContext::pathNameId, JsonTableParseContext::pathNames, JsonFuncExpr::pathspec, JsonTable::pathspec, JsonTablePathSpec::string, 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 399 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, JsonTableColumn::coltype, JsonFuncExpr::column_name, JsonFuncExpr::context_item, escape_json(), initStringInfo(), JS_ENC_DEFAULT, JS_FORMAT_DEFAULT, JSON_EXISTS_OP, JSON_QUERY_OP, JSON_VALUE_OP, JTC_EXISTS, JTC_REGULAR, makeJsonFormat(), makeJsonValueExpr(), makeNode, makeStringConst(), JsonTableColumn::name, JsonFuncExpr::op, JsonTableColumn::pathspec, pstrdup(), and JsonTablePathSpec::string.

Referenced by transformJsonTableColumns().

◆ transformJsonTableColumns()

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

static

Definition at line 251 of file parse_jsontable.c.

 {
     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("cannot use more than one FOR ORDINALITY column"),
                              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);
 }

References Assert, assign_expr_collations(), JsonBehavior::btype, castNode, JsonTableColumn::coltype, TableFunc::docexpr, elog, ereport, errcode(), errmsg(), ERROR, EXPR_KIND_FROM_FUNCTION, exprCollation(), exprType(), exprTypmod(), InvalidOid, isCompositeType(), JS_QUOTES_UNSPEC, JSON_BEHAVIOR_ERROR, JSW_UNSPEC, JsonTableParseContext::jt, JTC_EXISTS, JTC_FOR_ORDINALITY, JTC_FORMATTED, JTC_NESTED, JTC_REGULAR, lappend(), lappend_int(), lappend_oid(), lfirst, list_length(), JsonTableColumn::location, makeJsonTablePathScan(), makeNode, makeString(), JsonTableColumn::name, JsonTable::on_error, parser_errposition(), JsonTableParseContext::pstate, pstrdup(), JsonTableColumn::quotes, JsonTableParseContext::tf, transformExpr(), transformJsonTableColumn(), transformJsonTableNestedColumns(), CaseTestExpr::typeId, JsonTableColumn::typeName, typenameTypeIdAndMod(), and JsonTableColumn::wrapper.

Referenced by transformJsonTable(), and transformJsonTableNestedColumns().

◆ transformJsonTableNestedColumns()

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

static

Definition at line 454 of file parse_jsontable.c.

 {
     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;
 }

References castNode, JsonTableColumn::coltype, JsonTableColumn::columns, generateJsonTablePathName(), JTC_NESTED, lfirst, makeJsonTableSiblingJoin(), JsonTablePathSpec::name, JsonTableColumn::pathspec, plan, and transformJsonTableColumns().

Referenced by transformJsonTableColumns().

Data Structures

Typedefs

Functions

Typedef Documentation

◆ JsonTableParseContext

Function Documentation

◆ CheckDuplicateColumnOrPathNames()

◆ generateJsonTablePathName()

◆ isCompositeType()

◆ LookupPathOrColumnName()

◆ makeJsonTablePathScan()

◆ makeJsonTableSiblingJoin()

◆ transformJsonTable()

◆ transformJsonTableColumn()

◆ transformJsonTableColumns()

◆ transformJsonTableNestedColumns()