Adding upstream version 14.5.upstream/14.5upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 416 insertions, 0 deletions

diff --git a/src/backend/utils/adt/jsonbsubs.c b/src/backend/utils/adt/jsonbsubs.c
new file mode 100644
index 0000000..0d16025
--- /dev/null
+++ b/src/backend/utils/adt/jsonbsubs.c
@@ -0,0 +1,416 @@
+/*-------------------------------------------------------------------------
+ *
+ * jsonbsubs.c
+ *	  Subscripting support functions for jsonb.
+ *
+ * Portions Copyright (c) 1996-2021, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ *	  src/backend/utils/adt/jsonbsubs.c
+ *
+ *-------------------------------------------------------------------------
+ */
+#include "postgres.h"
+
+#include "executor/execExpr.h"
+#include "nodes/makefuncs.h"
+#include "nodes/nodeFuncs.h"
+#include "nodes/subscripting.h"
+#include "parser/parse_coerce.h"
+#include "parser/parse_expr.h"
+#include "utils/jsonb.h"
+#include "utils/jsonfuncs.h"
+#include "utils/builtins.h"
+#include "utils/lsyscache.h"
+
+
+/* SubscriptingRefState.workspace for jsonb subscripting execution */
+typedef struct JsonbSubWorkspace
+{
+	bool		expectArray;	/* jsonb root is expected to be an array */
+	Oid		   *indexOid;		/* OID of coerced subscript expression, could
+								 * be only integer or text */
+	Datum	   *index;			/* Subscript values in Datum format */
+} JsonbSubWorkspace;
+
+
+/*
+ * Finish parse analysis of a SubscriptingRef expression for a jsonb.
+ *
+ * Transform the subscript expressions, coerce them to text,
+ * and determine the result type of the SubscriptingRef node.
+ */
+static void
+jsonb_subscript_transform(SubscriptingRef *sbsref,
+						  List *indirection,
+						  ParseState *pstate,
+						  bool isSlice,
+						  bool isAssignment)
+{
+	List	   *upperIndexpr = NIL;
+	ListCell   *idx;
+
+	/*
+	 * Transform and convert the subscript expressions. Jsonb subscripting
+	 * does not support slices, look only and the upper index.
+	 */
+	foreach(idx, indirection)
+	{
+		A_Indices  *ai = lfirst_node(A_Indices, idx);
+		Node	   *subExpr;
+
+		if (isSlice)
+		{
+			Node	   *expr = ai->uidx ? ai->uidx : ai->lidx;
+
+			ereport(ERROR,
+					(errcode(ERRCODE_DATATYPE_MISMATCH),
+					 errmsg("jsonb subscript does not support slices"),
+					 parser_errposition(pstate, exprLocation(expr))));
+		}
+
+		if (ai->uidx)
+		{
+			Oid			subExprType = InvalidOid,
+						targetType = UNKNOWNOID;
+
+			subExpr = transformExpr(pstate, ai->uidx, pstate->p_expr_kind);
+			subExprType = exprType(subExpr);
+
+			if (subExprType != UNKNOWNOID)
+			{
+				Oid			targets[2] = {INT4OID, TEXTOID};
+
+				/*
+				 * Jsonb can handle multiple subscript types, but cases when a
+				 * subscript could be coerced to multiple target types must be
+				 * avoided, similar to overloaded functions. It could be
+				 * possibly extend with jsonpath in the future.
+				 */
+				for (int i = 0; i < 2; i++)
+				{
+					if (can_coerce_type(1, &subExprType, &targets[i], COERCION_IMPLICIT))
+					{
+						/*
+						 * One type has already succeeded, it means there are
+						 * two coercion targets possible, failure.
+						 */
+						if (targetType != UNKNOWNOID)
+							ereport(ERROR,
+									(errcode(ERRCODE_DATATYPE_MISMATCH),
+									 errmsg("subscript type %s is not supported", format_type_be(subExprType)),
+									 errhint("jsonb subscript must be coercible to only one type, integer or text."),
+									 parser_errposition(pstate, exprLocation(subExpr))));
+
+						targetType = targets[i];
+					}
+				}
+
+				/*
+				 * No suitable types were found, failure.
+				 */
+				if (targetType == UNKNOWNOID)
+					ereport(ERROR,
+							(errcode(ERRCODE_DATATYPE_MISMATCH),
+							 errmsg("subscript type %s is not supported", format_type_be(subExprType)),
+							 errhint("jsonb subscript must be coercible to either integer or text."),
+							 parser_errposition(pstate, exprLocation(subExpr))));
+			}
+			else
+				targetType = TEXTOID;
+
+			/*
+			 * We known from can_coerce_type that coercion will succeed, so
+			 * coerce_type could be used. Note the implicit coercion context,
+			 * which is required to handle subscripts of different types,
+			 * similar to overloaded functions.
+			 */
+			subExpr = coerce_type(pstate,
+								  subExpr, subExprType,
+								  targetType, -1,
+								  COERCION_IMPLICIT,
+								  COERCE_IMPLICIT_CAST,
+								  -1);
+			if (subExpr == NULL)
+				ereport(ERROR,
+						(errcode(ERRCODE_DATATYPE_MISMATCH),
+						 errmsg("jsonb subscript must have text type"),
+						 parser_errposition(pstate, exprLocation(subExpr))));
+		}
+		else
+		{
+			/*
+			 * Slice with omitted upper bound. Should not happen as we already
+			 * errored out on slice earlier, but handle this just in case.
+			 */
+			Assert(isSlice && ai->is_slice);
+			ereport(ERROR,
+					(errcode(ERRCODE_DATATYPE_MISMATCH),
+					 errmsg("jsonb subscript does not support slices"),
+					 parser_errposition(pstate, exprLocation(ai->uidx))));
+		}
+
+		upperIndexpr = lappend(upperIndexpr, subExpr);
+	}
+
+	/* store the transformed lists into the SubscriptRef node */
+	sbsref->refupperindexpr = upperIndexpr;
+	sbsref->reflowerindexpr = NIL;
+
+	/* Determine the result type of the subscripting operation; always jsonb */
+	sbsref->refrestype = JSONBOID;
+	sbsref->reftypmod = -1;
+}
+
+/*
+ * During execution, process the subscripts in a SubscriptingRef expression.
+ *
+ * The subscript expressions are already evaluated in Datum form in the
+ * SubscriptingRefState's arrays.  Check and convert them as necessary.
+ *
+ * If any subscript is NULL, we throw error in assignment cases, or in fetch
+ * cases set result to NULL and return false (instructing caller to skip the
+ * rest of the SubscriptingRef sequence).
+ */
+static bool
+jsonb_subscript_check_subscripts(ExprState *state,
+								 ExprEvalStep *op,
+								 ExprContext *econtext)
+{
+	SubscriptingRefState *sbsrefstate = op->d.sbsref_subscript.state;
+	JsonbSubWorkspace *workspace = (JsonbSubWorkspace *) sbsrefstate->workspace;
+
+	/*
+	 * In case if the first subscript is an integer, the source jsonb is
+	 * expected to be an array. This information is not used directly, all
+	 * such cases are handled within corresponding jsonb assign functions. But
+	 * if the source jsonb is NULL the expected type will be used to construct
+	 * an empty source.
+	 */
+	if (sbsrefstate->numupper > 0 && sbsrefstate->upperprovided[0] &&
+		!sbsrefstate->upperindexnull[0] && workspace->indexOid[0] == INT4OID)
+		workspace->expectArray = true;
+
+	/* Process upper subscripts */
+	for (int i = 0; i < sbsrefstate->numupper; i++)
+	{
+		if (sbsrefstate->upperprovided[i])
+		{
+			/* If any index expr yields NULL, result is NULL or error */
+			if (sbsrefstate->upperindexnull[i])
+			{
+				if (sbsrefstate->isassignment)
+					ereport(ERROR,
+							(errcode(ERRCODE_NULL_VALUE_NOT_ALLOWED),
+							 errmsg("jsonb subscript in assignment must not be null")));
+				*op->resnull = true;
+				return false;
+			}
+
+			/*
+			 * For jsonb fetch and assign functions we need to provide path in
+			 * text format. Convert if it's not already text.
+			 */
+			if (workspace->indexOid[i] == INT4OID)
+			{
+				Datum		datum = sbsrefstate->upperindex[i];
+				char	   *cs = DatumGetCString(DirectFunctionCall1(int4out, datum));
+
+				workspace->index[i] = CStringGetTextDatum(cs);
+			}
+			else
+				workspace->index[i] = sbsrefstate->upperindex[i];
+		}
+	}
+
+	return true;
+}
+
+/*
+ * Evaluate SubscriptingRef fetch for a jsonb element.
+ *
+ * Source container is in step's result variable (it's known not NULL, since
+ * we set fetch_strict to true).
+ */
+static void
+jsonb_subscript_fetch(ExprState *state,
+					  ExprEvalStep *op,
+					  ExprContext *econtext)
+{
+	SubscriptingRefState *sbsrefstate = op->d.sbsref.state;
+	JsonbSubWorkspace *workspace = (JsonbSubWorkspace *) sbsrefstate->workspace;
+	Jsonb	   *jsonbSource;
+
+	/* Should not get here if source jsonb (or any subscript) is null */
+	Assert(!(*op->resnull));
+
+	jsonbSource = DatumGetJsonbP(*op->resvalue);
+	*op->resvalue = jsonb_get_element(jsonbSource,
+									  workspace->index,
+									  sbsrefstate->numupper,
+									  op->resnull,
+									  false);
+}
+
+/*
+ * Evaluate SubscriptingRef assignment for a jsonb element assignment.
+ *
+ * Input container (possibly null) is in result area, replacement value is in
+ * SubscriptingRefState's replacevalue/replacenull.
+ */
+static void
+jsonb_subscript_assign(ExprState *state,
+					   ExprEvalStep *op,
+					   ExprContext *econtext)
+{
+	SubscriptingRefState *sbsrefstate = op->d.sbsref.state;
+	JsonbSubWorkspace *workspace = (JsonbSubWorkspace *) sbsrefstate->workspace;
+	Jsonb	   *jsonbSource;
+	JsonbValue	replacevalue;
+
+	if (sbsrefstate->replacenull)
+		replacevalue.type = jbvNull;
+	else
+		JsonbToJsonbValue(DatumGetJsonbP(sbsrefstate->replacevalue),
+						  &replacevalue);
+
+	/*
+	 * In case if the input container is null, set up an empty jsonb and
+	 * proceed with the assignment.
+	 */
+	if (*op->resnull)
+	{
+		JsonbValue	newSource;
+
+		/*
+		 * To avoid any surprising results, set up an empty jsonb array in
+		 * case of an array is expected (i.e. the first subscript is integer),
+		 * otherwise jsonb object.
+		 */
+		if (workspace->expectArray)
+		{
+			newSource.type = jbvArray;
+			newSource.val.array.nElems = 0;
+			newSource.val.array.rawScalar = false;
+		}
+		else
+		{
+			newSource.type = jbvObject;
+			newSource.val.object.nPairs = 0;
+		}
+
+		jsonbSource = JsonbValueToJsonb(&newSource);
+		*op->resnull = false;
+	}
+	else
+		jsonbSource = DatumGetJsonbP(*op->resvalue);
+
+	*op->resvalue = jsonb_set_element(jsonbSource,
+									  workspace->index,
+									  sbsrefstate->numupper,
+									  &replacevalue);
+	/* The result is never NULL, so no need to change *op->resnull */
+}
+
+/*
+ * Compute old jsonb element value for a SubscriptingRef assignment
+ * expression.  Will only be called if the new-value subexpression
+ * contains SubscriptingRef or FieldStore.  This is the same as the
+ * regular fetch case, except that we have to handle a null jsonb,
+ * and the value should be stored into the SubscriptingRefState's
+ * prevvalue/prevnull fields.
+ */
+static void
+jsonb_subscript_fetch_old(ExprState *state,
+						  ExprEvalStep *op,
+						  ExprContext *econtext)
+{
+	SubscriptingRefState *sbsrefstate = op->d.sbsref.state;
+
+	if (*op->resnull)
+	{
+		/* whole jsonb is null, so any element is too */
+		sbsrefstate->prevvalue = (Datum) 0;
+		sbsrefstate->prevnull = true;
+	}
+	else
+	{
+		Jsonb	   *jsonbSource = DatumGetJsonbP(*op->resvalue);
+
+		sbsrefstate->prevvalue = jsonb_get_element(jsonbSource,
+												   sbsrefstate->upperindex,
+												   sbsrefstate->numupper,
+												   &sbsrefstate->prevnull,
+												   false);
+	}
+}
+
+/*
+ * Set up execution state for a jsonb subscript operation. Opposite to the
+ * arrays subscription, there is no limit for number of subscripts as jsonb
+ * type itself doesn't have nesting limits.
+ */
+static void
+jsonb_exec_setup(const SubscriptingRef *sbsref,
+				 SubscriptingRefState *sbsrefstate,
+				 SubscriptExecSteps *methods)
+{
+	JsonbSubWorkspace *workspace;
+	ListCell   *lc;
+	int			nupper = sbsref->refupperindexpr->length;
+	char	   *ptr;
+
+	/* Allocate type-specific workspace with space for per-subscript data */
+	workspace = palloc0(MAXALIGN(sizeof(JsonbSubWorkspace)) +
+						nupper * (sizeof(Datum) + sizeof(Oid)));
+	workspace->expectArray = false;
+	ptr = ((char *) workspace) + MAXALIGN(sizeof(JsonbSubWorkspace));
+
+	/*
+	 * This coding assumes sizeof(Datum) >= sizeof(Oid), else we might
+	 * misalign the indexOid pointer
+	 */
+	workspace->index = (Datum *) ptr;
+	ptr += nupper * sizeof(Datum);
+	workspace->indexOid = (Oid *) ptr;
+
+	sbsrefstate->workspace = workspace;
+
+	/* Collect subscript data types necessary at execution time */
+	foreach(lc, sbsref->refupperindexpr)
+	{
+		Node	   *expr = lfirst(lc);
+		int			i = foreach_current_index(lc);
+
+		workspace->indexOid[i] = exprType(expr);
+	}
+
+	/*
+	 * Pass back pointers to appropriate step execution functions.
+	 */
+	methods->sbs_check_subscripts = jsonb_subscript_check_subscripts;
+	methods->sbs_fetch = jsonb_subscript_fetch;
+	methods->sbs_assign = jsonb_subscript_assign;
+	methods->sbs_fetch_old = jsonb_subscript_fetch_old;
+}
+
+/*
+ * jsonb_subscript_handler
+ *		Subscripting handler for jsonb.
+ *
+ */
+Datum
+jsonb_subscript_handler(PG_FUNCTION_ARGS)
+{
+	static const SubscriptRoutines sbsroutines = {
+		.transform = jsonb_subscript_transform,
+		.exec_setup = jsonb_exec_setup,
+		.fetch_strict = true,	/* fetch returns NULL for NULL inputs */
+		.fetch_leakproof = true,	/* fetch returns NULL for bad subscript */
+		.store_leakproof = false	/* ... but assignment throws error */
+	};
+
+	PG_RETURN_POINTER(&sbsroutines);
+}