pg_query 5.1.0 → 6.1.0

data/ext/pg_query/postgres_deparse.c

@@ -20,12 +20,7 @@ typedef enum DeparseNodeContext {
 	DEPARSE_NODE_CONTEXT_NONE,
 	// Parent node type (and sometimes field)
 	DEPARSE_NODE_CONTEXT_INSERT_RELATION,
-	DEPARSE_NODE_CONTEXT_INSERT_ON_CONFLICT,
-	DEPARSE_NODE_CONTEXT_UPDATE,
-	DEPARSE_NODE_CONTEXT_RETURNING,
 	DEPARSE_NODE_CONTEXT_A_EXPR,
-	DEPARSE_NODE_CONTEXT_XMLATTRIBUTES,
-	DEPARSE_NODE_CONTEXT_XMLNAMESPACES,
 	DEPARSE_NODE_CONTEXT_CREATE_TYPE,
 	DEPARSE_NODE_CONTEXT_ALTER_TYPE,
 	DEPARSE_NODE_CONTEXT_SET_STATEMENT,
@@ -186,9 +181,9 @@ static void deparseReplicaIdentityStmt(StringInfo str, ReplicaIdentityStmt *repl
 static void deparseRangeTableSample(StringInfo str, RangeTableSample *range_table_sample);
 static void deparseRangeTableFunc(StringInfo str, RangeTableFunc* range_table_func);
 static void deparseGroupingSet(StringInfo str, GroupingSet *grouping_set);
-static void deparseFuncCall(StringInfo str, FuncCall *func_call);
+static void deparseFuncCall(StringInfo str, FuncCall *func_call, DeparseNodeContext context);
 static void deparseMinMaxExpr(StringInfo str, MinMaxExpr *min_max_expr);
-static void deparseXmlExpr(StringInfo str, XmlExpr* xml_expr);
+static void deparseXmlExpr(StringInfo str, XmlExpr* xml_expr, DeparseNodeContext context);
 static void deparseXmlSerialize(StringInfo str, XmlSerialize *xml_serialize);
 static void deparseJsonIsPredicate(StringInfo str, JsonIsPredicate *json_is_predicate);
 static void deparseJsonObjectAgg(StringInfo str, JsonObjectAgg *json_object_agg);
@@ -196,6 +191,20 @@ static void deparseJsonArrayAgg(StringInfo str, JsonArrayAgg *json_array_agg);
 static void deparseJsonObjectConstructor(StringInfo str, JsonObjectConstructor *json_object_constructor);
 static void deparseJsonArrayConstructor(StringInfo str, JsonArrayConstructor *json_array_constructor);
 static void deparseJsonArrayQueryConstructor(StringInfo str, JsonArrayQueryConstructor *json_array_query_constructor);
+static void deparseJsonValueExpr(StringInfo str, JsonValueExpr *json_value_expr);
+static void deparseJsonOutput(StringInfo str, JsonOutput *json_output);
+static void deparseJsonParseExpr(StringInfo str, JsonParseExpr *json_parse_expr);
+static void deparseJsonScalarExpr(StringInfo str, JsonScalarExpr *json_scalar_expr);
+static void deparseJsonSerializeExpr(StringInfo str, JsonSerializeExpr *json_serialize_expr);
+static void deparseJsonTable(StringInfo str, JsonTable *json_table);
+static void deparseJsonTableColumn(StringInfo str, JsonTableColumn *json_table_column);
+static void deparseJsonTableColumns(StringInfo str, List *json_table_columns);
+static void deparseJsonTablePathSpec(StringInfo str, JsonTablePathSpec *json_table_path_spec);
+static void deparseJsonBehavior(StringInfo str, JsonBehavior *json_behavior);
+static void deparseJsonFuncExpr(StringInfo str, JsonFuncExpr *json_func_expr);
+static void deparseJsonQuotesClauseOpt(StringInfo str, JsonQuotes quotes);
+static void deparseJsonOnErrorClauseOpt(StringInfo str, JsonBehavior *behavior);
+static void deparseJsonOnEmptyClauseOpt(StringInfo str, JsonBehavior *behavior);
 static void deparseConstraint(StringInfo str, Constraint *constraint);
 static void deparseSchemaStmt(StringInfo str, Node *node);
 static void deparseExecuteStmt(StringInfo str, ExecuteStmt *execute_stmt);
@@ -252,12 +261,12 @@ static void deparseAnyNameSkipLast(StringInfo str, List *parts)
 }
 
 // "func_expr" in gram.y
-static void deparseFuncExpr(StringInfo str, Node *node)
+static void deparseFuncExpr(StringInfo str, Node *node, DeparseNodeContext context)
 {
 	switch (nodeTag(node))
 	{
 		case T_FuncCall:
-			deparseFuncCall(str, castNode(FuncCall, node));
+			deparseFuncCall(str, castNode(FuncCall, node), context);
 			break;
 		case T_SQLValueFunction:
 			deparseSQLValueFunction(str, castNode(SQLValueFunction, node));
@@ -269,7 +278,7 @@ static void deparseFuncExpr(StringInfo str, Node *node)
 			deparseCoalesceExpr(str, castNode(CoalesceExpr, node));
 			break;
 		case T_XmlExpr:
-			deparseXmlExpr(str, castNode(XmlExpr, node));
+			deparseXmlExpr(str, castNode(XmlExpr, node), context);
 			break;
 		case T_XmlSerialize:
 			deparseXmlSerialize(str, castNode(XmlSerialize, node));
@@ -299,7 +308,7 @@ static void deparseFuncExpr(StringInfo str, Node *node)
 static void deparseCExpr(StringInfo str, Node *node);
 
 // "a_expr" in gram.y
-static void deparseExpr(StringInfo str, Node *node)
+static void deparseExpr(StringInfo str, Node *node, DeparseNodeContext context)
 {
 	if (node == NULL)
 		return;
@@ -323,7 +332,7 @@ static void deparseExpr(StringInfo str, Node *node)
 			deparseCollateClause(str, castNode(CollateClause, node));
 			break;
 		case T_A_Expr:
-			deparseAExpr(str, castNode(A_Expr, node), DEPARSE_NODE_CONTEXT_NONE);
+			deparseAExpr(str, castNode(A_Expr, node), DEPARSE_NODE_CONTEXT_A_EXPR);
 			break;
 		case T_BoolExpr:
 			deparseBoolExpr(str, castNode(BoolExpr, node));
@@ -340,6 +349,21 @@ static void deparseExpr(StringInfo str, Node *node)
 		case T_SetToDefault:
 			deparseSetToDefault(str, castNode(SetToDefault, node));
 			break;
+		case T_MergeSupportFunc:
+			appendStringInfoString(str, "merge_action() ");
+			break;
+		case T_JsonParseExpr:
+			deparseJsonParseExpr(str, castNode(JsonParseExpr, node));
+			break;
+		case T_JsonScalarExpr:
+			deparseJsonScalarExpr(str, castNode(JsonScalarExpr, node));
+			break;
+		case T_JsonSerializeExpr:
+			deparseJsonSerializeExpr(str, castNode(JsonSerializeExpr, node));
+			break;
+		case T_JsonFuncExpr:
+			deparseJsonFuncExpr(str, castNode(JsonFuncExpr, node));
+			break;
 		case T_FuncCall:
 		case T_SQLValueFunction:
 		case T_MinMaxExpr:
@@ -351,7 +375,7 @@ static void deparseExpr(StringInfo str, Node *node)
 		case T_JsonObjectConstructor:
 		case T_JsonArrayConstructor:
 		case T_JsonArrayQueryConstructor:
-			deparseFuncExpr(str, node);
+			deparseFuncExpr(str, node, context);
 			break;
 		default:
 			// Note that this is also the fallthrough for deparseBExpr and deparseCExpr
@@ -365,7 +389,7 @@ static void deparseExpr(StringInfo str, Node *node)
 static void deparseBExpr(StringInfo str, Node *node)
 {
 	if (IsA(node, XmlExpr)) {
-		deparseXmlExpr(str, castNode(XmlExpr, node));
+		deparseXmlExpr(str, castNode(XmlExpr, node), DEPARSE_NODE_CONTEXT_NONE);
 		return;
 	}
 
@@ -389,6 +413,24 @@ static void deparseBExpr(StringInfo str, Node *node)
 	deparseCExpr(str, node);
 }
 
+// "AexprConst" in gram.y
+static void deparseAexprConst(StringInfo str, Node *node)
+{
+	switch (nodeTag(node))
+	{
+		case T_A_Const:
+			deparseAConst(str, castNode(A_Const, node));
+			break;
+		case T_TypeCast:
+			deparseTypeCast(str, castNode(TypeCast, node), DEPARSE_NODE_CONTEXT_NONE);
+			break;
+		default:
+			elog(ERROR, "deparse: unpermitted node type in AexprConst: %d",
+				 (int) nodeTag(node));
+			break;
+	}
+}
+
 // "c_expr" in gram.y
 static void deparseCExpr(StringInfo str, Node *node)
 {
@@ -432,11 +474,12 @@ static void deparseCExpr(StringInfo str, Node *node)
 		case T_JsonObjectConstructor:
 		case T_JsonArrayConstructor:
 		case T_JsonArrayQueryConstructor:
-			deparseFuncExpr(str, node);
+			deparseFuncExpr(str, node, DEPARSE_NODE_CONTEXT_NONE);
 			break;
 		default:
 			appendStringInfoChar(str, '(');
-			deparseExpr(str, node);
+			// Because we wrap this in parenthesis, the expression inside follows "a_expr" parser rules
+			deparseExpr(str, node, DEPARSE_NODE_CONTEXT_A_EXPR);
 			appendStringInfoChar(str, ')');
 			break;
 	}
@@ -448,7 +491,7 @@ static void deparseExprList(StringInfo str, List *exprs)
 	ListCell *lc;
 	foreach(lc, exprs)
 	{
-		deparseExpr(str, lfirst(lc));
+		deparseExpr(str, lfirst(lc), DEPARSE_NODE_CONTEXT_A_EXPR);
 		if (lnext(exprs, lc))
 			appendStringInfoString(str, ", ");
 	}
@@ -1554,7 +1597,7 @@ static void deparseTargetList(StringInfo str, List *l)
 		else if (IsA(res_target->val, ColumnRef))
 			deparseColumnRef(str, castNode(ColumnRef, res_target->val));
 		else
-			deparseExpr(str, res_target->val);
+			deparseExpr(str, res_target->val, DEPARSE_NODE_CONTEXT_A_EXPR);
 
 		if (res_target->name != NULL) {
 			appendStringInfoString(str, " AS ");
@@ -1592,7 +1635,7 @@ static void deparseXmlAttributeList(StringInfo str, List *l)
 		ResTarget *res_target = castNode(ResTarget, lfirst(lc));
 		Assert(res_target->val != NULL);
 
-		deparseExpr(str, res_target->val);
+		deparseExpr(str, res_target->val, DEPARSE_NODE_CONTEXT_A_EXPR);
 
 		if (res_target->name != NULL)
 		{
@@ -1618,7 +1661,7 @@ static void deparseXmlNamespaceList(StringInfo str, List *l)
 		if (res_target->name == NULL)
 			appendStringInfoString(str, "DEFAULT ");
 
-		deparseExpr(str, res_target->val);
+		deparseExpr(str, res_target->val, DEPARSE_NODE_CONTEXT_NONE /* b_expr */);
 
 		if (res_target->name != NULL)
 		{
@@ -1654,6 +1697,9 @@ static void deparseTableRef(StringInfo str, Node *node)
 		case T_JoinExpr:
 			deparseJoinExpr(str, castNode(JoinExpr, node));
 			break;
+		case T_JsonTable:
+			deparseJsonTable(str, castNode(JsonTable, node));
+			break;
 		default:
 			Assert(false);
 	}
@@ -1693,7 +1739,7 @@ static void deparseWhereClause(StringInfo str, Node *node)
 	if (node != NULL)
 	{
 		appendStringInfoString(str, "WHERE ");
-		deparseExpr(str, node);
+		deparseExpr(str, node, DEPARSE_NODE_CONTEXT_A_EXPR);
 		appendStringInfoChar(str, ' ');
 	}
 }
@@ -1713,7 +1759,7 @@ static void deparseWhereOrCurrentClause(StringInfo str, Node *node)
 		appendStringInfoString(str, "CURRENT OF ");
 		appendStringInfoString(str, quote_identifier(current_of_expr->cursor_name));
 	} else {
-		deparseExpr(str, node);
+		deparseExpr(str, node, DEPARSE_NODE_CONTEXT_A_EXPR);
 	}
 
 	appendStringInfoChar(str, ' ');
@@ -1729,7 +1775,7 @@ static void deparseGroupByList(StringInfo str, List *l)
 		if (IsA(lfirst(lc), GroupingSet))
 			deparseGroupingSet(str, castNode(GroupingSet, lfirst(lc)));
 		else
-			deparseExpr(str, lfirst(lc));
+			deparseExpr(str, lfirst(lc), DEPARSE_NODE_CONTEXT_A_EXPR);
 
 		if (lnext(l, lc))
 			appendStringInfoString(str, ", ");
@@ -1799,11 +1845,11 @@ static void deparseFuncArgExpr(StringInfo str, Node *node)
 		NamedArgExpr *named_arg_expr = castNode(NamedArgExpr, node);
 		appendStringInfoString(str, named_arg_expr->name);
 		appendStringInfoString(str, " := ");
-		deparseExpr(str, (Node *) named_arg_expr->arg);
+		deparseExpr(str, (Node *) named_arg_expr->arg, DEPARSE_NODE_CONTEXT_A_EXPR);
 	}
 	else
 	{
-		deparseExpr(str, node);
+		deparseExpr(str, node, DEPARSE_NODE_CONTEXT_A_EXPR);
 	}
 }
 
@@ -1843,14 +1889,14 @@ static void deparseSetClauseList(StringInfo str, List *target_list)
 					appendStringInfoString(str, ", ");
 			}
 			appendStringInfoString(str, ") = ");
-			deparseExpr(str, r->source);
+			deparseExpr(str, r->source, DEPARSE_NODE_CONTEXT_A_EXPR);
 			skip_next_n_elems = r->ncolumns - 1;
 		}
 		else
 		{
 			deparseSetTarget(str, res_target);
 			appendStringInfoString(str, " = ");
-			deparseExpr(str, res_target->val);
+			deparseExpr(str, res_target->val, DEPARSE_NODE_CONTEXT_A_EXPR);
 		}
 	}
 }
@@ -1861,7 +1907,7 @@ static void deparseFuncExprWindowless(StringInfo str, Node* node)
 	switch (nodeTag(node))
 	{
 		case T_FuncCall:
-			deparseFuncCall(str, castNode(FuncCall, node));
+			deparseFuncCall(str, castNode(FuncCall, node), DEPARSE_NODE_CONTEXT_NONE /* we don't know which kind of expression */);
 			break;
 		case T_SQLValueFunction:
 			deparseSQLValueFunction(str, castNode(SQLValueFunction, node));
@@ -1876,7 +1922,7 @@ static void deparseFuncExprWindowless(StringInfo str, Node* node)
 			deparseMinMaxExpr(str, castNode(MinMaxExpr, node));
 			break;
 		case T_XmlExpr:
-			deparseXmlExpr(str, castNode(XmlExpr, node));
+			deparseXmlExpr(str, castNode(XmlExpr, node), DEPARSE_NODE_CONTEXT_NONE /* we don't know which kind of expression */);
 			break;
 		case T_XmlSerialize:
 			deparseXmlSerialize(str, castNode(XmlSerialize, node));
@@ -1923,7 +1969,7 @@ static void deparseIndexElem(StringInfo str, IndexElem* index_elem)
 				break;
 			default:
 				appendStringInfoChar(str, '(');
-				deparseExpr(str, index_elem->expr);
+				deparseExpr(str, index_elem->expr, DEPARSE_NODE_CONTEXT_A_EXPR);
 				appendStringInfoString(str, ") ");
 		}
 	}
@@ -2273,7 +2319,7 @@ static void deparseSelectStmt(StringInfo str, SelectStmt *stmt)
 			if (stmt->havingClause != NULL)
 			{
 				appendStringInfoString(str, "HAVING ");
-				deparseExpr(str, stmt->havingClause);
+				deparseExpr(str, stmt->havingClause, DEPARSE_NODE_CONTEXT_A_EXPR);
 				appendStringInfoChar(str, ' ');
 			}
 
@@ -2356,7 +2402,7 @@ static void deparseSelectStmt(StringInfo str, SelectStmt *stmt)
 		else if (stmt->limitOption == LIMIT_OPTION_WITH_TIES)
 			deparseCExpr(str, stmt->limitCount);
 		else
-			deparseExpr(str, stmt->limitCount);
+			deparseExpr(str, stmt->limitCount, DEPARSE_NODE_CONTEXT_NONE /* c_expr */);
 
 		appendStringInfoChar(str, ' ');
 
@@ -2367,7 +2413,7 @@ static void deparseSelectStmt(StringInfo str, SelectStmt *stmt)
 	if (stmt->limitOffset != NULL)
 	{
 		appendStringInfoString(str, "OFFSET ");
-		deparseExpr(str, stmt->limitOffset);
+		deparseExpr(str, stmt->limitOffset, DEPARSE_NODE_CONTEXT_A_EXPR);
 		appendStringInfoChar(str, ' ');
 	}
 
@@ -2493,7 +2539,7 @@ static void deparseAConst(StringInfo str, A_Const *a_const)
 	deparseValue(str, val, DEPARSE_NODE_CONTEXT_CONSTANT);
 }
 
-static void deparseFuncCall(StringInfo str, FuncCall *func_call)
+static void deparseFuncCall(StringInfo str, FuncCall *func_call, DeparseNodeContext context)
 {
 	const ListCell *lc = NULL;
 
@@ -2509,13 +2555,13 @@ static void deparseFuncCall(StringInfo str, FuncCall *func_call)
 		 * keyword parameter style when its called as a keyword, not as a regular function (i.e. pg_catalog.overlay)
 		 */
 		appendStringInfoString(str, "OVERLAY(");
-		deparseExpr(str, linitial(func_call->args));
+		deparseExpr(str, linitial(func_call->args), DEPARSE_NODE_CONTEXT_A_EXPR);
 		appendStringInfoString(str, " PLACING ");
-		deparseExpr(str, lsecond(func_call->args));
+		deparseExpr(str, lsecond(func_call->args), DEPARSE_NODE_CONTEXT_A_EXPR);
 		appendStringInfoString(str, " FROM ");
-		deparseExpr(str, lthird(func_call->args));
+		deparseExpr(str, lthird(func_call->args), DEPARSE_NODE_CONTEXT_A_EXPR);
 		appendStringInfoString(str, " FOR ");
-		deparseExpr(str, lfourth(func_call->args));
+		deparseExpr(str, lfourth(func_call->args), DEPARSE_NODE_CONTEXT_A_EXPR);
 		appendStringInfoChar(str, ')');
 		return;
 	} else if (func_call->funcformat == COERCE_SQL_SYNTAX &&
@@ -2529,13 +2575,13 @@ static void deparseFuncCall(StringInfo str, FuncCall *func_call)
 		 */
 		Assert(list_length(func_call->args) == 2 || list_length(func_call->args) == 3);
 		appendStringInfoString(str, "SUBSTRING(");
-		deparseExpr(str, linitial(func_call->args));
+		deparseExpr(str, linitial(func_call->args), DEPARSE_NODE_CONTEXT_A_EXPR);
 		appendStringInfoString(str, " FROM ");
-		deparseExpr(str, lsecond(func_call->args));
+		deparseExpr(str, lsecond(func_call->args), DEPARSE_NODE_CONTEXT_A_EXPR);
 		if (list_length(func_call->args) == 3)
 		{
 			appendStringInfoString(str, " FOR ");
-			deparseExpr(str, lthird(func_call->args));
+			deparseExpr(str, lthird(func_call->args), DEPARSE_NODE_CONTEXT_A_EXPR);
 		}
 		appendStringInfoChar(str, ')');
 		return;
@@ -2567,11 +2613,11 @@ static void deparseFuncCall(StringInfo str, FuncCall *func_call)
 		 * keyword parameter style when its called as a keyword, not as a regular function (i.e. pg_catalog.overlay)
 		 */
 		appendStringInfoString(str, "overlay(");
-		deparseExpr(str, linitial(func_call->args));
+		deparseExpr(str, linitial(func_call->args), DEPARSE_NODE_CONTEXT_A_EXPR);
 		appendStringInfoString(str, " placing ");
-		deparseExpr(str, lsecond(func_call->args));
+		deparseExpr(str, lsecond(func_call->args), DEPARSE_NODE_CONTEXT_A_EXPR);
 		appendStringInfoString(str, " from ");
-		deparseExpr(str, lthird(func_call->args));
+		deparseExpr(str, lthird(func_call->args), DEPARSE_NODE_CONTEXT_A_EXPR);
 		appendStringInfoChar(str, ')');
 		return;
 	} else if (func_call->funcformat == COERCE_SQL_SYNTAX &&
@@ -2585,7 +2631,7 @@ static void deparseFuncCall(StringInfo str, FuncCall *func_call)
 		 * keyword parameter style when its called as a keyword, not as a regular function (i.e. pg_catalog.overlay)
 		 */
 		appendStringInfoString(str, "collation for (");
-		deparseExpr(str, linitial(func_call->args));
+		deparseExpr(str, linitial(func_call->args), DEPARSE_NODE_CONTEXT_A_EXPR);
 		appendStringInfoChar(str, ')');
 		return;
 	} else if (func_call->funcformat == COERCE_SQL_SYNTAX &&
@@ -2599,9 +2645,9 @@ static void deparseFuncCall(StringInfo str, FuncCall *func_call)
 		 * keyword parameter style when its called as a keyword, not as a regular function (i.e. pg_catalog.extract)
 		 */
 		appendStringInfoString(str, "extract (");
-		deparseExpr(str, linitial(func_call->args));
+		deparseExpr(str, linitial(func_call->args), DEPARSE_NODE_CONTEXT_A_EXPR);
 		appendStringInfoString(str, " FROM ");
-		deparseExpr(str, lsecond(func_call->args));
+		deparseExpr(str, lsecond(func_call->args), DEPARSE_NODE_CONTEXT_A_EXPR);
 		appendStringInfoChar(str, ')');
 		return;
 	} else if (func_call->funcformat == COERCE_SQL_SYNTAX &&
@@ -2616,16 +2662,16 @@ static void deparseFuncCall(StringInfo str, FuncCall *func_call)
 		 * format: (start_1, end_1) overlaps (start_2, end_2)
 		 */
 		appendStringInfoChar(str, '(');
-		deparseExpr(str, linitial(func_call->args));
+		deparseExpr(str, linitial(func_call->args), DEPARSE_NODE_CONTEXT_A_EXPR);
 		appendStringInfoString(str, ", ");
-		deparseExpr(str, lsecond(func_call->args));
+		deparseExpr(str, lsecond(func_call->args), DEPARSE_NODE_CONTEXT_A_EXPR);
 		appendStringInfoString(str, ") ");
 
 		appendStringInfoString(str, "overlaps ");
 		appendStringInfoChar(str, '(');
-		deparseExpr(str, lthird(func_call->args));
+		deparseExpr(str, lthird(func_call->args), DEPARSE_NODE_CONTEXT_A_EXPR);
 		appendStringInfoString(str, ", ");
-		deparseExpr(str, lfourth(func_call->args));
+		deparseExpr(str, lfourth(func_call->args), DEPARSE_NODE_CONTEXT_A_EXPR);
 		appendStringInfoString(str, ") ");
 		return;
 	} else if (func_call->funcformat == COERCE_SQL_SYNTAX &&
@@ -2652,36 +2698,57 @@ static void deparseFuncCall(StringInfo str, FuncCall *func_call)
 			appendStringInfoString(str, "TRAILING ");
 
 		if (list_length(func_call->args) == 2)
-			deparseExpr(str, lsecond(func_call->args));
+			deparseExpr(str, lsecond(func_call->args), DEPARSE_NODE_CONTEXT_A_EXPR);
 		appendStringInfoString(str, " FROM ");
-		deparseExpr(str, linitial(func_call->args));
+		deparseExpr(str, linitial(func_call->args), DEPARSE_NODE_CONTEXT_A_EXPR);
 		appendStringInfoChar(str, ')');
 		return;
 	} else if (func_call->funcformat == COERCE_SQL_SYNTAX &&
 		list_length(func_call->funcname) == 2 &&
 		strcmp(strVal(linitial(func_call->funcname)), "pg_catalog") == 0 &&
 		strcmp(strVal(lsecond(func_call->funcname)), "timezone") == 0 &&
-		list_length(func_call->args) == 2)
+		list_length(func_call->args) > 0 &&
+		list_length(func_call->args) <= 2)
 	{
 		/*
 		 * "AT TIME ZONE" is a keyword on its own merit, and only accepts the
 		 * keyword parameter style when its called as a keyword, not as a regular function (i.e. pg_catalog.timezone)
 		 * Note that the arguments are swapped in this case
 		 */
-		Expr* e = lsecond(func_call->args);
+		Expr* e;
+		bool isLocal = list_length(func_call->args) == 1;
+
+		if (isLocal)
+			e = linitial(func_call->args);
+		else
+			e = lsecond(func_call->args);
+
+		// If we're not inside an a_expr context, we must add wrapping parenthesis around the AT ... syntax
+		if (context != DEPARSE_NODE_CONTEXT_A_EXPR) {
+			appendStringInfoChar(str, '(');
+		}
 
 		if (IsA(e, A_Expr)) {
 			appendStringInfoChar(str, '(');
 		}
 
-		deparseExpr(str, (Node*) e);
+		deparseExpr(str, (Node*) e, DEPARSE_NODE_CONTEXT_A_EXPR);
 
 		if (IsA(e, A_Expr)) {
 			appendStringInfoChar(str, ')');
 		}
 
-		appendStringInfoString(str, " AT TIME ZONE ");
-		deparseExpr(str, linitial(func_call->args));
+		if (isLocal)
+			appendStringInfoString(str, " AT LOCAL");
+		else {
+			appendStringInfoString(str, " AT TIME ZONE ");
+			deparseExpr(str, linitial(func_call->args), DEPARSE_NODE_CONTEXT_A_EXPR);
+		}
+
+		if (context != DEPARSE_NODE_CONTEXT_A_EXPR) {
+			appendStringInfoChar(str, ')');
+		}
+
 		return;
 	} else if (func_call->funcformat == COERCE_SQL_SYNTAX &&
 		list_length(func_call->funcname) == 2 &&
@@ -2695,7 +2762,7 @@ static void deparseFuncCall(StringInfo str, FuncCall *func_call)
 		Assert(list_length(func_call->args) == 1 || list_length(func_call->args) == 2);
 		appendStringInfoString(str, "normalize (");
 
-		deparseExpr(str, linitial(func_call->args));
+		deparseExpr(str, linitial(func_call->args), DEPARSE_NODE_CONTEXT_A_EXPR);
 		if (list_length(func_call->args) == 2)
 		{
 			appendStringInfoString(str, ", ");
@@ -2716,7 +2783,7 @@ static void deparseFuncCall(StringInfo str, FuncCall *func_call)
 		 */
 		Assert(list_length(func_call->args) == 1 || list_length(func_call->args) == 2);
 
-		deparseExpr(str, linitial(func_call->args));
+		deparseExpr(str, linitial(func_call->args), DEPARSE_NODE_CONTEXT_A_EXPR);
 		appendStringInfoString(str, " IS ");
 		if (list_length(func_call->args) == 2)
 		{
@@ -2733,9 +2800,9 @@ static void deparseFuncCall(StringInfo str, FuncCall *func_call)
 		list_length(func_call->args) == 2)
 	{
 		appendStringInfoString(str, "xmlexists (");
-		deparseExpr(str, linitial(func_call->args));
+		deparseExpr(str, linitial(func_call->args), DEPARSE_NODE_CONTEXT_NONE /* c_expr */);
 		appendStringInfoString(str, " PASSING ");
-		deparseExpr(str, lsecond(func_call->args));
+		deparseExpr(str, lsecond(func_call->args), DEPARSE_NODE_CONTEXT_NONE /* c_expr */);
 		appendStringInfoChar(str, ')');
 		return;
 	} else if (func_call->funcformat == COERCE_SQL_SYNTAX &&
@@ -2789,7 +2856,7 @@ static void deparseFuncCall(StringInfo str, FuncCall *func_call)
 	if (func_call->agg_filter)
 	{
 		appendStringInfoString(str, "FILTER (WHERE ");
-		deparseExpr(str, func_call->agg_filter);
+		deparseExpr(str, func_call->agg_filter, DEPARSE_NODE_CONTEXT_A_EXPR);
 		appendStringInfoString(str, ") ");
 	}
 
@@ -2856,13 +2923,13 @@ static void deparseWindowDef(StringInfo str, WindowDef* window_def)
 		else if (window_def->frameOptions & FRAMEOPTION_START_OFFSET_PRECEDING)
 		{
 			Assert(window_def->startOffset != NULL);
-			deparseExpr(str, window_def->startOffset);
+			deparseExpr(str, window_def->startOffset, DEPARSE_NODE_CONTEXT_A_EXPR);
 			appendStringInfoString(str, " PRECEDING ");
 		}
 		else if (window_def->frameOptions & FRAMEOPTION_START_OFFSET_FOLLOWING)
 		{
 			Assert(window_def->startOffset != NULL);
-			deparseExpr(str, window_def->startOffset);
+			deparseExpr(str, window_def->startOffset, DEPARSE_NODE_CONTEXT_A_EXPR);
 			appendStringInfoString(str, " FOLLOWING ");
 		}
 
@@ -2886,13 +2953,13 @@ static void deparseWindowDef(StringInfo str, WindowDef* window_def)
 			else if (window_def->frameOptions & FRAMEOPTION_END_OFFSET_PRECEDING)
 			{
 				Assert(window_def->endOffset != NULL);
-				deparseExpr(str, window_def->endOffset);
+				deparseExpr(str, window_def->endOffset, DEPARSE_NODE_CONTEXT_A_EXPR);
 				appendStringInfoString(str, " PRECEDING ");
 			}
 			else if (window_def->frameOptions & FRAMEOPTION_END_OFFSET_FOLLOWING)
 			{
 				Assert(window_def->endOffset != NULL);
-				deparseExpr(str, window_def->endOffset);
+				deparseExpr(str, window_def->endOffset, DEPARSE_NODE_CONTEXT_A_EXPR);
 				appendStringInfoString(str, " FOLLOWING ");
 			}
 		}
@@ -2930,7 +2997,7 @@ static void deparseSubLink(StringInfo str, SubLink* sub_link)
 			appendStringInfoChar(str, ')');
 			return;
 		case ALL_SUBLINK:
-			deparseExpr(str, sub_link->testexpr);
+			deparseExpr(str, sub_link->testexpr, DEPARSE_NODE_CONTEXT_A_EXPR);
 			appendStringInfoChar(str, ' ');
 			deparseSubqueryOp(str, sub_link->operName);
 			appendStringInfoString(str, " ALL (");
@@ -2938,7 +3005,7 @@ static void deparseSubLink(StringInfo str, SubLink* sub_link)
 			appendStringInfoChar(str, ')');
 			return;
 		case ANY_SUBLINK:
-			deparseExpr(str, sub_link->testexpr);
+			deparseExpr(str, sub_link->testexpr, DEPARSE_NODE_CONTEXT_A_EXPR);
 			if (list_length(sub_link->operName) > 0)
 			{
 				appendStringInfoChar(str, ' ');
@@ -2978,6 +3045,7 @@ static void deparseSubLink(StringInfo str, SubLink* sub_link)
 	}
 }
 
+// This handles "A_Expr" parse tree objects, which are a subset of the rules in "a_expr" (handled by deparseExpr)
 static void deparseAExpr(StringInfo str, A_Expr* a_expr, DeparseNodeContext context)
 {
 	ListCell *lc;
@@ -2989,15 +3057,11 @@ static void deparseAExpr(StringInfo str, A_Expr* a_expr, DeparseNodeContext cont
 	switch (a_expr->kind) {
 		case AEXPR_OP: /* normal operator */
 			{
-				bool need_outer_parens = context == DEPARSE_NODE_CONTEXT_A_EXPR;
-
-				if (need_outer_parens)
-					appendStringInfoChar(str, '(');
 				if (a_expr->lexpr != NULL)
 				{
 					if (need_lexpr_parens)
 						appendStringInfoChar(str, '(');
-					deparseExpr(str, a_expr->lexpr);
+					deparseExpr(str, a_expr->lexpr, context);
 					if (need_lexpr_parens)
 						appendStringInfoChar(str, ')');
 					appendStringInfoChar(str, ' ');
@@ -3008,29 +3072,26 @@ static void deparseAExpr(StringInfo str, A_Expr* a_expr, DeparseNodeContext cont
 					appendStringInfoChar(str, ' ');
 					if (need_rexpr_parens)
 						appendStringInfoChar(str, '(');
-					deparseExpr(str, a_expr->rexpr);
+					deparseExpr(str, a_expr->rexpr, context);
 					if (need_rexpr_parens)
 						appendStringInfoChar(str, ')');
 				}
-
-				if (need_outer_parens)
-					appendStringInfoChar(str, ')');
 			}
 			return;
 		case AEXPR_OP_ANY: /* scalar op ANY (array) */
-			deparseExpr(str, a_expr->lexpr);
+			deparseExpr(str, a_expr->lexpr, context);
 			appendStringInfoChar(str, ' ');
 			deparseSubqueryOp(str, a_expr->name);
 			appendStringInfoString(str, " ANY(");
-			deparseExpr(str, a_expr->rexpr);
+			deparseExpr(str, a_expr->rexpr, context);
 			appendStringInfoChar(str, ')');
 			return;
 		case AEXPR_OP_ALL: /* scalar op ALL (array) */
-			deparseExpr(str, a_expr->lexpr);
+			deparseExpr(str, a_expr->lexpr, context);
 			appendStringInfoChar(str, ' ');
 			deparseSubqueryOp(str, a_expr->name);
 			appendStringInfoString(str, " ALL(");
-			deparseExpr(str, a_expr->rexpr);
+			deparseExpr(str, a_expr->rexpr, context);
 			appendStringInfoChar(str, ')');
 			return;
 		case AEXPR_DISTINCT: /* IS DISTINCT FROM - name must be "=" */
@@ -3040,13 +3101,13 @@ static void deparseAExpr(StringInfo str, A_Expr* a_expr, DeparseNodeContext cont
 
 			if (need_lexpr_parens)
 				appendStringInfoChar(str, '(');
-			deparseExpr(str, a_expr->lexpr);
+			deparseExpr(str, a_expr->lexpr, context);
 			if (need_lexpr_parens)
 				appendStringInfoChar(str, ')');
 			appendStringInfoString(str, " IS DISTINCT FROM ");
 			if (need_rexpr_parens)
 				appendStringInfoChar(str, '(');
-			deparseExpr(str, a_expr->rexpr);
+			deparseExpr(str, a_expr->rexpr, context);
 			if (need_rexpr_parens)
 				appendStringInfoChar(str, ')');
 			return;
@@ -3055,9 +3116,9 @@ static void deparseAExpr(StringInfo str, A_Expr* a_expr, DeparseNodeContext cont
 			Assert(IsA(linitial(a_expr->name), String));
 			Assert(strcmp(strVal(linitial(a_expr->name)), "=") == 0);
 
-			deparseExpr(str, a_expr->lexpr);
+			deparseExpr(str, a_expr->lexpr, context);
 			appendStringInfoString(str, " IS NOT DISTINCT FROM ");
-			deparseExpr(str, a_expr->rexpr);
+			deparseExpr(str, a_expr->rexpr, context);
 			return;
 		case AEXPR_NULLIF: /* NULLIF - name must be "=" */
 			Assert(list_length(a_expr->name) == 1);
@@ -3065,16 +3126,16 @@ static void deparseAExpr(StringInfo str, A_Expr* a_expr, DeparseNodeContext cont
 			Assert(strcmp(strVal(linitial(a_expr->name)), "=") == 0);
 
 			appendStringInfoString(str, "NULLIF(");
-			deparseExpr(str, a_expr->lexpr);
+			deparseExpr(str, a_expr->lexpr, context);
 			appendStringInfoString(str, ", ");
-			deparseExpr(str, a_expr->rexpr);
+			deparseExpr(str, a_expr->rexpr, context);
 			appendStringInfoChar(str, ')');
 			return;
 		case AEXPR_IN: /* [NOT] IN - name must be "=" or "<>" */
 			Assert(list_length(a_expr->name) == 1);
 			Assert(IsA(linitial(a_expr->name), String));
 			Assert(IsA(a_expr->rexpr, List));
-			deparseExpr(str, a_expr->lexpr);
+			deparseExpr(str, a_expr->lexpr, context);
 			appendStringInfoChar(str, ' ');
 			name = ((union ValUnion *) linitial(a_expr->name))->sval.sval;
 			if (strcmp(name, "=") == 0) {
@@ -3094,7 +3155,7 @@ static void deparseAExpr(StringInfo str, A_Expr* a_expr, DeparseNodeContext cont
 		case AEXPR_LIKE: /* [NOT] LIKE - name must be "~~" or "!~~" */
 			Assert(list_length(a_expr->name) == 1);
 			Assert(IsA(linitial(a_expr->name), String));
-			deparseExpr(str, a_expr->lexpr);
+			deparseExpr(str, a_expr->lexpr, context);
 			appendStringInfoChar(str, ' ');
 
 			name = ((union ValUnion *) linitial(a_expr->name))->sval.sval;
@@ -3106,12 +3167,12 @@ static void deparseAExpr(StringInfo str, A_Expr* a_expr, DeparseNodeContext cont
 				Assert(false);
 			}
 
-			deparseExpr(str, a_expr->rexpr);
+			deparseExpr(str, a_expr->rexpr, context);
 			return;
 		case AEXPR_ILIKE: /* [NOT] ILIKE - name must be "~~*" or "!~~*" */
 			Assert(list_length(a_expr->name) == 1);
 			Assert(IsA(linitial(a_expr->name), String));
-			deparseExpr(str, a_expr->lexpr);
+			deparseExpr(str, a_expr->lexpr, context);
 			appendStringInfoChar(str, ' ');
 
 			name = ((union ValUnion *) linitial(a_expr->name))->sval.sval;
@@ -3123,12 +3184,12 @@ static void deparseAExpr(StringInfo str, A_Expr* a_expr, DeparseNodeContext cont
 				Assert(false);
 			}
 
-			deparseExpr(str, a_expr->rexpr);
+			deparseExpr(str, a_expr->rexpr, context);
 			return;
 		case AEXPR_SIMILAR: /* [NOT] SIMILAR - name must be "~" or "!~" */
 			Assert(list_length(a_expr->name) == 1);
 			Assert(IsA(linitial(a_expr->name), String));
-			deparseExpr(str, a_expr->lexpr);
+			deparseExpr(str, a_expr->lexpr, context);
 			appendStringInfoChar(str, ' ');
 
 			name = ((union ValUnion *) linitial(a_expr->name))->sval.sval;
@@ -3146,11 +3207,11 @@ static void deparseAExpr(StringInfo str, A_Expr* a_expr, DeparseNodeContext cont
 			Assert(strcmp(strVal(lsecond(n->funcname)), "similar_to_escape") == 0);
 			Assert(list_length(n->args) == 1 || list_length(n->args) == 2);
 
-			deparseExpr(str, linitial(n->args));
+			deparseExpr(str, linitial(n->args), context);
 			if (list_length(n->args) == 2)
 			{
 				appendStringInfoString(str, " ESCAPE ");
-				deparseExpr(str, lsecond(n->args));
+				deparseExpr(str, lsecond(n->args), context);
 			}
 
 			return;
@@ -3162,13 +3223,13 @@ static void deparseAExpr(StringInfo str, A_Expr* a_expr, DeparseNodeContext cont
 			Assert(IsA(linitial(a_expr->name), String));
 			Assert(IsA(a_expr->rexpr, List));
 
-			deparseExpr(str, a_expr->lexpr);
+			deparseExpr(str, a_expr->lexpr, context);
 			appendStringInfoChar(str, ' ');
 			appendStringInfoString(str, strVal(linitial(a_expr->name)));
 			appendStringInfoChar(str, ' ');
 
 			foreach(lc, castNode(List, a_expr->rexpr)) {
-				deparseExpr(str, lfirst(lc));
+				deparseExpr(str, lfirst(lc), context);
 				if (lnext(castNode(List, a_expr->rexpr), lc))
 					appendStringInfoString(str, " AND ");
 			}
@@ -3190,7 +3251,7 @@ static void deparseBoolExpr(StringInfo str, BoolExpr *bool_expr)
 				if (need_parens)
 					appendStringInfoChar(str, '(');
 
-				deparseExpr(str, lfirst(lc));
+				deparseExpr(str, lfirst(lc), DEPARSE_NODE_CONTEXT_A_EXPR);
 
 				if (need_parens)
 					appendStringInfoChar(str, ')');
@@ -3208,7 +3269,7 @@ static void deparseBoolExpr(StringInfo str, BoolExpr *bool_expr)
 				if (need_parens)
 					appendStringInfoChar(str, '(');
 
-				deparseExpr(str, lfirst(lc));
+				deparseExpr(str, lfirst(lc), DEPARSE_NODE_CONTEXT_A_EXPR);
 
 				if (need_parens)
 					appendStringInfoChar(str, ')');
@@ -3223,7 +3284,7 @@ static void deparseBoolExpr(StringInfo str, BoolExpr *bool_expr)
 			appendStringInfoString(str, "NOT ");
 			if (need_parens)
 				appendStringInfoChar(str, '(');
-			deparseExpr(str, linitial(bool_expr->args));
+			deparseExpr(str, linitial(bool_expr->args), DEPARSE_NODE_CONTEXT_A_EXPR);
 			if (need_parens)
 				appendStringInfoChar(str, ')');
 			return;
@@ -3243,7 +3304,7 @@ static void deparseCollateClause(StringInfo str, CollateClause* collate_clause)
 		bool need_parens = IsA(collate_clause->arg, A_Expr);
 		if (need_parens)
 			appendStringInfoChar(str, '(');
-		deparseExpr(str, collate_clause->arg);
+		deparseExpr(str, collate_clause->arg, DEPARSE_NODE_CONTEXT_A_EXPR);
 		if (need_parens)
 			appendStringInfoChar(str, ')');
 		appendStringInfoChar(str, ' ');
@@ -3252,9 +3313,10 @@ static void deparseCollateClause(StringInfo str, CollateClause* collate_clause)
 	deparseAnyName(str, collate_clause->collname);
 }
 
+// "sortby" in gram.y
 static void deparseSortBy(StringInfo str, SortBy* sort_by)
 {
-	deparseExpr(str, sort_by->node);
+	deparseExpr(str, sort_by->node, DEPARSE_NODE_CONTEXT_A_EXPR);
 	appendStringInfoChar(str, ' ');
 
 	switch (sort_by->sortby_dir)
@@ -3371,6 +3433,7 @@ static void deparseWithClause(StringInfo str, WithClause *with_clause)
 	removeTrailingSpace(str);
 }
 
+// "joined_table" in gram.y
 static void deparseJoinExpr(StringInfo str, JoinExpr *join_expr)
 {
 	ListCell *lc;
@@ -3424,7 +3487,7 @@ static void deparseJoinExpr(StringInfo str, JoinExpr *join_expr)
 	if (join_expr->quals != NULL)
 	{
 		appendStringInfoString(str, "ON ");
-		deparseExpr(str, join_expr->quals);
+		deparseExpr(str, join_expr->quals, DEPARSE_NODE_CONTEXT_A_EXPR);
 		appendStringInfoChar(str, ' ');
 	}
 
@@ -3467,6 +3530,7 @@ static void deparseCTESearchClause(StringInfo str, CTESearchClause *search_claus
 	appendStringInfoString(str, quote_identifier(search_clause->search_seq_column));
 }
 
+// "opt_cycle_clause" in gram.y
 static void deparseCTECycleClause(StringInfo str, CTECycleClause *cycle_clause)
 {
 	appendStringInfoString(str, " CYCLE ");
@@ -3480,15 +3544,15 @@ static void deparseCTECycleClause(StringInfo str, CTECycleClause *cycle_clause)
 	if (cycle_clause->cycle_mark_value)
 	{
 		appendStringInfoString(str, " TO ");
-		deparseExpr(str, cycle_clause->cycle_mark_value);
+		deparseAexprConst(str, cycle_clause->cycle_mark_value);
 	}
-	
+
 	if (cycle_clause->cycle_mark_default)
 	{
 		appendStringInfoString(str, " DEFAULT ");
-		deparseExpr(str, cycle_clause->cycle_mark_default);
+		deparseAexprConst(str, cycle_clause->cycle_mark_default);
 	}
-	
+
 	appendStringInfoString(str, " USING ");
 	appendStringInfoString(str, quote_identifier(cycle_clause->cycle_path_column));
 }
@@ -3653,7 +3717,7 @@ static void deparseTypeCast(StringInfo str, TypeCast *type_cast, DeparseNodeCont
 	if (IsA(type_cast->arg, A_Expr) || context == DEPARSE_NODE_CONTEXT_FUNC_EXPR)
 	{
 		appendStringInfoString(str, "CAST(");
-		deparseExpr(str, type_cast->arg);
+		deparseExpr(str, type_cast->arg, DEPARSE_NODE_CONTEXT_A_EXPR);
 		appendStringInfoString(str, " AS ");
 		deparseTypeName(str, type_cast->typeName);
 		appendStringInfoChar(str, ')');
@@ -3720,7 +3784,7 @@ static void deparseTypeCast(StringInfo str, TypeCast *type_cast, DeparseNodeCont
 
 	if (need_parens)
 		appendStringInfoChar(str, '(');
-	deparseExpr(str, type_cast->arg);
+	deparseExpr(str, type_cast->arg, DEPARSE_NODE_CONTEXT_NONE /* could be either a_expr or b_expr (we could pass this down, but that'd require two kinds of contexts most likely) */);
 	if (need_parens)
 		appendStringInfoChar(str, ')');
 
@@ -3949,7 +4013,7 @@ static void deparseNullTest(StringInfo str, NullTest *null_test)
 	// argisrow is always false in raw parser output
 	Assert(null_test->argisrow == false);
 
-	deparseExpr(str, (Node *) null_test->arg);
+	deparseExpr(str, (Node *) null_test->arg, DEPARSE_NODE_CONTEXT_A_EXPR);
 	switch (null_test->nulltesttype)
 	{
 		case IS_NULL:
@@ -3961,6 +4025,7 @@ static void deparseNullTest(StringInfo str, NullTest *null_test)
 	}
 }
 
+// "case_expr" in gram.y
 static void deparseCaseExpr(StringInfo str, CaseExpr *case_expr)
 {
 	ListCell *lc;
@@ -3969,7 +4034,7 @@ static void deparseCaseExpr(StringInfo str, CaseExpr *case_expr)
 
 	if (case_expr->arg != NULL)
 	{
-		deparseExpr(str, (Node *) case_expr->arg);
+		deparseExpr(str, (Node *) case_expr->arg, DEPARSE_NODE_CONTEXT_A_EXPR);
 		appendStringInfoChar(str, ' ');
 	}
 
@@ -3982,19 +4047,20 @@ static void deparseCaseExpr(StringInfo str, CaseExpr *case_expr)
 	if (case_expr->defresult != NULL)
 	{
 		appendStringInfoString(str, "ELSE ");
-		deparseExpr(str, (Node *) case_expr->defresult);
+		deparseExpr(str, (Node *) case_expr->defresult, DEPARSE_NODE_CONTEXT_A_EXPR);
 		appendStringInfoChar(str, ' ');
 	}
 
 	appendStringInfoString(str, "END");
 }
 
+// "when_clause" in gram.y
 static void deparseCaseWhen(StringInfo str, CaseWhen *case_when)
 {
 	appendStringInfoString(str, "WHEN ");
-	deparseExpr(str, (Node *) case_when->expr);
+	deparseExpr(str, (Node *) case_when->expr, DEPARSE_NODE_CONTEXT_A_EXPR);
 	appendStringInfoString(str, " THEN ");
-	deparseExpr(str, (Node *) case_when->result);
+	deparseExpr(str, (Node *) case_when->result, DEPARSE_NODE_CONTEXT_A_EXPR);
 }
 
 static void deparseAIndirection(StringInfo str, A_Indirection *a_indirection)
@@ -4006,12 +4072,13 @@ static void deparseAIndirection(StringInfo str, A_Indirection *a_indirection)
 		IsA(a_indirection->arg, A_Expr) ||
 		IsA(a_indirection->arg, TypeCast) ||
 		IsA(a_indirection->arg, RowExpr) ||
-		(IsA(a_indirection->arg, ColumnRef) && !IsA(linitial(a_indirection->indirection), A_Indices));
+		(IsA(a_indirection->arg, ColumnRef) && !IsA(linitial(a_indirection->indirection), A_Indices)) ||
+		IsA(a_indirection->arg, JsonFuncExpr);
 
 	if (need_parens)
 		appendStringInfoChar(str, '(');
 
-	deparseExpr(str, a_indirection->arg);
+	deparseExpr(str, a_indirection->arg, need_parens ? DEPARSE_NODE_CONTEXT_A_EXPR : DEPARSE_NODE_CONTEXT_NONE);
 
 	if (need_parens)
 		appendStringInfoChar(str, ')');
@@ -4023,11 +4090,11 @@ static void deparseAIndices(StringInfo str, A_Indices *a_indices)
 {
 	appendStringInfoChar(str, '[');
 	if (a_indices->lidx != NULL)
-		deparseExpr(str, a_indices->lidx);
+		deparseExpr(str, a_indices->lidx, DEPARSE_NODE_CONTEXT_A_EXPR);
 	if (a_indices->is_slice)
 		appendStringInfoChar(str, ':');
 	if (a_indices->uidx != NULL)
-		deparseExpr(str, a_indices->uidx);
+		deparseExpr(str, a_indices->uidx, DEPARSE_NODE_CONTEXT_A_EXPR);
 	appendStringInfoChar(str, ']');
 }
 
@@ -4060,7 +4127,7 @@ static void deparseBooleanTest(StringInfo str, BooleanTest *boolean_test)
 	if (need_parens)
 		appendStringInfoChar(str, '(');
 
-	deparseExpr(str, (Node *) boolean_test->arg);
+	deparseExpr(str, (Node *) boolean_test->arg, DEPARSE_NODE_CONTEXT_A_EXPR);
 
 	if (need_parens)
 		appendStringInfoChar(str, ')');
@@ -4090,6 +4157,7 @@ static void deparseBooleanTest(StringInfo str, BooleanTest *boolean_test)
 	}
 }
 
+// "columnDef" and "alter_table_cmd" in gram.y
 static void deparseColumnDef(StringInfo str, ColumnDef *column_def)
 {
 	ListCell *lc;
@@ -4116,7 +4184,7 @@ static void deparseColumnDef(StringInfo str, ColumnDef *column_def)
 	if (column_def->raw_default != NULL)
 	{
 		appendStringInfoString(str, "USING ");
-		deparseExpr(str, column_def->raw_default);
+		deparseExpr(str, column_def->raw_default, DEPARSE_NODE_CONTEXT_A_EXPR);
 		appendStringInfoChar(str, ' ');
 	}
 
@@ -4312,6 +4380,7 @@ static void deparseUpdateStmt(StringInfo str, UpdateStmt *update_stmt)
 	removeTrailingSpace(str);
 }
 
+// "MergeStmt" in gram.y
 static void deparseMergeStmt(StringInfo str, MergeStmt *merge_stmt)
 {
 	if (merge_stmt->withClause != NULL)
@@ -4329,27 +4398,33 @@ static void deparseMergeStmt(StringInfo str, MergeStmt *merge_stmt)
 	appendStringInfoChar(str, ' ');
 
 	appendStringInfoString(str, "ON ");
-	deparseExpr(str, merge_stmt->joinCondition);
+	deparseExpr(str, merge_stmt->joinCondition, DEPARSE_NODE_CONTEXT_A_EXPR);
 	appendStringInfoChar(str, ' ');
 
-	ListCell *lc, *lc2;
+	ListCell *lc;
 	foreach (lc, merge_stmt->mergeWhenClauses)
 	{
 		MergeWhenClause *clause = castNode(MergeWhenClause, lfirst(lc));
 
 		appendStringInfoString(str, "WHEN ");
 
-		if (!clause->matched)
+		switch (clause->matchKind)
 		{
-			appendStringInfoString(str, "NOT ");
+			case MERGE_WHEN_MATCHED:
+				appendStringInfoString(str, "MATCHED ");
+				break;
+			case MERGE_WHEN_NOT_MATCHED_BY_SOURCE:
+				appendStringInfoString(str, "NOT MATCHED BY SOURCE ");
+				break;
+			case MERGE_WHEN_NOT_MATCHED_BY_TARGET:
+				appendStringInfoString(str, "NOT MATCHED ");
+				break;
 		}
 
-		appendStringInfoString(str, "MATCHED ");
-
 		if (clause->condition)
 		{
 			appendStringInfoString(str, "AND ");
-			deparseExpr(str, clause->condition);
+			deparseExpr(str, clause->condition, DEPARSE_NODE_CONTEXT_A_EXPR);
 			appendStringInfoChar(str, ' ');
 		}
 
@@ -4394,6 +4469,12 @@ static void deparseMergeStmt(StringInfo str, MergeStmt *merge_stmt)
 		if (lfirst(lc) != llast(merge_stmt->mergeWhenClauses))
 			appendStringInfoChar(str, ' ');
 	}
+
+	if (merge_stmt->returningList)
+	{
+		appendStringInfoString(str, " RETURNING ");
+		deparseTargetList(str, merge_stmt->returningList);
+	}
 }
 
 static void deparseDeleteStmt(StringInfo str, DeleteStmt *delete_stmt)
@@ -4719,6 +4800,7 @@ static void deparseCreateExtensionStmt(StringInfo str, CreateExtensionStmt *crea
 	removeTrailingSpace(str);
 }
 
+// "ColConstraintElem" and "ConstraintElem" in gram.y
 static void deparseConstraint(StringInfo str, Constraint *constraint)
 {
 	ListCell *lc;
@@ -4760,12 +4842,12 @@ static void deparseConstraint(StringInfo str, Constraint *constraint)
 		case CONSTR_GENERATED:
 			Assert(constraint->generated_when == ATTRIBUTE_IDENTITY_ALWAYS);
 			appendStringInfoString(str, "GENERATED ALWAYS AS (");
-			deparseExpr(str, constraint->raw_expr);
+			deparseExpr(str, constraint->raw_expr, DEPARSE_NODE_CONTEXT_A_EXPR);
 			appendStringInfoString(str, ") STORED ");
 			break;
 		case CONSTR_CHECK:
 			appendStringInfoString(str, "CHECK (");
-			deparseExpr(str, constraint->raw_expr);
+			deparseExpr(str, constraint->raw_expr, DEPARSE_NODE_CONTEXT_A_EXPR);
 			appendStringInfoString(str, ") ");
 			break;
 		case CONSTR_PRIMARY:
@@ -4799,7 +4881,7 @@ static void deparseConstraint(StringInfo str, Constraint *constraint)
 			if (constraint->where_clause != NULL)
 			{
 				appendStringInfoString(str, "WHERE (");
-				deparseExpr(str, constraint->where_clause);
+				deparseExpr(str, constraint->where_clause, DEPARSE_NODE_CONTEXT_A_EXPR);
 				appendStringInfoString(str, ") ");
 			}
 			break;
@@ -4823,9 +4905,18 @@ static void deparseConstraint(StringInfo str, Constraint *constraint)
 
 	if (list_length(constraint->keys) > 0)
 	{
-		appendStringInfoChar(str, '(');
-		deparseColumnList(str, constraint->keys);
-		appendStringInfoString(str, ") ");
+		bool valueOnly = false;
+
+		if (list_length(constraint->keys) == 1) {
+			Node* firstKey = constraint->keys->elements[0].ptr_value;
+			valueOnly = IsA(firstKey, String) && !strcmp("value", ((String*)firstKey)->sval);
+		}
+
+		if (!valueOnly) {
+			appendStringInfoChar(str, '(');
+			deparseColumnList(str, constraint->keys);
+			appendStringInfoString(str, ") ");
+		}
 	}
 
 	if (list_length(constraint->fk_attrs) > 0)
@@ -4962,10 +5053,11 @@ static void deparseConstraint(StringInfo str, Constraint *constraint)
 	removeTrailingSpace(str);
 }
 
+// "ReturnStmt" in gram.y
 static void deparseReturnStmt(StringInfo str, ReturnStmt *return_stmt)
 {
 	appendStringInfoString(str, "RETURN ");
-	deparseExpr(str, return_stmt->returnval);
+	deparseExpr(str, return_stmt->returnval, DEPARSE_NODE_CONTEXT_A_EXPR);
 }
 
 static void deparseCreateFunctionStmt(StringInfo str, CreateFunctionStmt *create_function_stmt)
@@ -5064,6 +5156,7 @@ static void deparseCreateFunctionStmt(StringInfo str, CreateFunctionStmt *create
 	removeTrailingSpace(str);
 }
 
+// "func_arg", "func_arg_with_default" and other places in gram.y
 static void deparseFunctionParameter(StringInfo str, FunctionParameter *function_parameter)
 {
 	switch (function_parameter->mode)
@@ -5104,7 +5197,7 @@ static void deparseFunctionParameter(StringInfo str, FunctionParameter *function
 	if (function_parameter->defexpr != NULL)
 	{
 		appendStringInfoString(str, "= ");
-		deparseExpr(str, function_parameter->defexpr);
+		deparseExpr(str, function_parameter->defexpr, DEPARSE_NODE_CONTEXT_A_EXPR);
 	}
 
 	removeTrailingSpace(str);
@@ -5225,7 +5318,7 @@ static void deparsePartitionElem(StringInfo str, PartitionElem *partition_elem)
 	else if (partition_elem->expr != NULL)
 	{
 		appendStringInfoChar(str, '(');
-		deparseExpr(str, partition_elem->expr);
+		deparseExpr(str, partition_elem->expr, DEPARSE_NODE_CONTEXT_A_EXPR);
 		appendStringInfoString(str, ") ");
 	}
 
@@ -6287,6 +6380,7 @@ static void deparseAlterObjectSchemaStmt(StringInfo str, AlterObjectSchemaStmt *
 	appendStringInfoString(str, quote_identifier(alter_object_schema_stmt->newschema));
 }
 
+// "alter_table_cmd" in gram.y
 static void deparseAlterTableCmd(StringInfo str, AlterTableCmd *alter_table_cmd, DeparseNodeContext context)
 {
 	ListCell *lc = NULL;
@@ -6525,6 +6619,9 @@ static void deparseAlterTableCmd(StringInfo str, AlterTableCmd *alter_table_cmd,
 			options = "DROP IDENTITY";
 			trailing_missing_ok = true;
 			break;
+		case AT_SetExpression:
+			appendStringInfoString(str, "ALTER COLUMN ");
+			break;
 	}
 
 	if (alter_table_cmd->missing_ok && !trailing_missing_ok)
@@ -6539,6 +6636,9 @@ static void deparseAlterTableCmd(StringInfo str, AlterTableCmd *alter_table_cmd,
 	{
 		appendStringInfoString(str, quote_identifier(alter_table_cmd->name));
 		appendStringInfoChar(str, ' ');
+	} else if (alter_table_cmd->subtype == AT_SetAccessMethod)
+	{
+		appendStringInfoString(str, " DEFAULT");
 	}
 
 	if (alter_table_cmd->num > 0)
@@ -6572,7 +6672,7 @@ static void deparseAlterTableCmd(StringInfo str, AlterTableCmd *alter_table_cmd,
 		case AT_ColumnDefault:
 			if (alter_table_cmd->def != NULL)
 			{
-				deparseExpr(str, alter_table_cmd->def);
+				deparseExpr(str, alter_table_cmd->def, DEPARSE_NODE_CONTEXT_A_EXPR);
 				appendStringInfoChar(str, ' ');
 			}
 			break;
@@ -6626,6 +6726,11 @@ static void deparseAlterTableCmd(StringInfo str, AlterTableCmd *alter_table_cmd,
 			deparseReplicaIdentityStmt(str, castNode(ReplicaIdentityStmt, alter_table_cmd->def));
 			appendStringInfoChar(str, ' ');
 			break;
+		case AT_SetExpression:
+			appendStringInfoString(str, "SET EXPRESSION AS (");
+			deparseExpr(str, alter_table_cmd->def, DEPARSE_NODE_CONTEXT_A_EXPR);
+			appendStringInfoChar(str, ')');
+			break;
 		default:
 			Assert(alter_table_cmd->def == NULL);
 			break;
@@ -6731,6 +6836,7 @@ static void deparseAlterTableSpaceOptionsStmt(StringInfo str, AlterTableSpaceOpt
 	deparseRelOptions(str, alter_table_space_options_stmt->options);
 }
 
+// "AlterDomainStmt" in gram.y
 static void deparseAlterDomainStmt(StringInfo str, AlterDomainStmt *alter_domain_stmt)
 {
 	appendStringInfoString(str, "ALTER DOMAIN ");
@@ -6743,7 +6849,7 @@ static void deparseAlterDomainStmt(StringInfo str, AlterDomainStmt *alter_domain
 			if (alter_domain_stmt->def != NULL)
 			{
 				appendStringInfoString(str, "SET DEFAULT ");
-				deparseExpr(str, alter_domain_stmt->def);
+				deparseExpr(str, alter_domain_stmt->def, DEPARSE_NODE_CONTEXT_A_EXPR);
 			}
 			else
 			{
@@ -7509,15 +7615,29 @@ static void deparseCopyStmt(StringInfo str, CopyStmt *copy_stmt)
 				}
 				else if (strcmp(def_elem->defname, "force_not_null") == 0)
 				{
-					appendStringInfoString(str, "FORCE_NOT_NULL (");
-					deparseColumnList(str, castNode(List, def_elem->arg));
-					appendStringInfoChar(str, ')');
+					appendStringInfoString(str, "FORCE_NOT_NULL ");
+
+					if (IsA(def_elem->arg, A_Star))
+						deparseAStar(str, castNode(A_Star, def_elem->arg));
+					else
+					{
+						appendStringInfoChar(str, '(');
+						deparseColumnList(str, castNode(List, def_elem->arg));
+						appendStringInfoChar(str, ')');
+					}
 				}
 				else if (strcmp(def_elem->defname, "force_null") == 0)
 				{
-					appendStringInfoString(str, "FORCE_NULL (");
-					deparseColumnList(str, castNode(List, def_elem->arg));
-					appendStringInfoChar(str, ')');
+					appendStringInfoString(str, "FORCE_NULL ");
+
+					if (IsA(def_elem->arg, A_Star))
+						deparseAStar(str, castNode(A_Star, def_elem->arg));
+					else
+					{
+						appendStringInfoChar(str, '(');
+						deparseColumnList(str, castNode(List, def_elem->arg));
+						appendStringInfoChar(str, ')');
+					}
 				}
 				else if (strcmp(def_elem->defname, "encoding") == 0)
 				{
@@ -8617,7 +8737,7 @@ static void deparseFetchStmt(StringInfo str, FetchStmt *fetch_stmt)
 			appendStringInfo(str, "RELATIVE %ld ", fetch_stmt->howMany);
 	}
 
-	appendStringInfoString(str, fetch_stmt->portalname);
+	appendStringInfoString(str, quote_identifier(fetch_stmt->portalname));
 }
 
 static void deparseAlterDefaultPrivilegesStmt(StringInfo str, AlterDefaultPrivilegesStmt *alter_default_privileges_stmt)
@@ -8955,6 +9075,7 @@ static void deparseReplicaIdentityStmt(StringInfo str, ReplicaIdentityStmt *repl
 	}
 }
 
+// "CreatePolicyStmt" in gram.y
 static void deparseCreatePolicyStmt(StringInfo str, CreatePolicyStmt *create_policy_stmt)
 {
 	ListCell *lc = NULL;
@@ -8988,18 +9109,19 @@ static void deparseCreatePolicyStmt(StringInfo str, CreatePolicyStmt *create_pol
 	if (create_policy_stmt->qual != NULL)
 	{
 		appendStringInfoString(str, "USING (");
-		deparseExpr(str, create_policy_stmt->qual);
+		deparseExpr(str, create_policy_stmt->qual, DEPARSE_NODE_CONTEXT_A_EXPR);
 		appendStringInfoString(str, ") ");
 	}
 
 	if (create_policy_stmt->with_check != NULL)
 	{
 		appendStringInfoString(str, "WITH CHECK (");
-		deparseExpr(str, create_policy_stmt->with_check);
+		deparseExpr(str, create_policy_stmt->with_check, DEPARSE_NODE_CONTEXT_A_EXPR);
 		appendStringInfoString(str, ") ");
 	}
 }
 
+// "AlterPolicyStmt" in gram.y
 static void deparseAlterPolicyStmt(StringInfo str, AlterPolicyStmt *alter_policy_stmt)
 {
 	appendStringInfoString(str, "ALTER POLICY ");
@@ -9018,14 +9140,14 @@ static void deparseAlterPolicyStmt(StringInfo str, AlterPolicyStmt *alter_policy
 	if (alter_policy_stmt->qual != NULL)
 	{
 		appendStringInfoString(str, "USING (");
-		deparseExpr(str, alter_policy_stmt->qual);
+		deparseExpr(str, alter_policy_stmt->qual, DEPARSE_NODE_CONTEXT_A_EXPR);
 		appendStringInfoString(str, ") ");
 	}
 
 	if (alter_policy_stmt->with_check != NULL)
 	{
 		appendStringInfoString(str, "WITH CHECK (");
-		deparseExpr(str, alter_policy_stmt->with_check);
+		deparseExpr(str, alter_policy_stmt->with_check, DEPARSE_NODE_CONTEXT_A_EXPR);
 		appendStringInfoString(str, ") ");
 	}
 }
@@ -9112,6 +9234,7 @@ static void deparseCreateAmStmt(StringInfo str, CreateAmStmt *create_am_stmt)
 	deparseHandlerName(str, create_am_stmt->handler_name);
 }
 
+// "pub_obj_list" in gram.y
 static void deparsePublicationObjectList(StringInfo str, List *pubobjects) {
 	const ListCell *lc;
 	foreach(lc, pubobjects) {
@@ -9132,7 +9255,7 @@ static void deparsePublicationObjectList(StringInfo str, List *pubobjects) {
 				if (obj->pubtable->whereClause)
 				{
 					appendStringInfoString(str, " WHERE (");
-					deparseExpr(str, obj->pubtable->whereClause);
+					deparseExpr(str, obj->pubtable->whereClause, DEPARSE_NODE_CONTEXT_A_EXPR);
 					appendStringInfoString(str, ")");
 				}
 
@@ -9481,6 +9604,7 @@ static void deparseCommentStmt(StringInfo str, CommentStmt *comment_stmt)
 		appendStringInfoString(str, "NULL");
 }
 
+// "stats_param" in gram.y
 static void deparseStatsElem(StringInfo str, StatsElem *stats_elem)
 {
 	// only one of stats_elem->name or stats_elem->expr can be non-null
@@ -9489,7 +9613,7 @@ static void deparseStatsElem(StringInfo str, StatsElem *stats_elem)
 	else if (stats_elem->expr)
 	{
 		appendStringInfoChar(str, '(');
-		deparseExpr(str, stats_elem->expr);
+		deparseExpr(str, stats_elem->expr, DEPARSE_NODE_CONTEXT_A_EXPR);
 		appendStringInfoChar(str, ')');
 	}
 }
@@ -9559,7 +9683,10 @@ static void deparseAlterStatsStmt(StringInfo str, AlterStatsStmt *alter_stats_st
 	deparseAnyName(str, alter_stats_stmt->defnames);
 	appendStringInfoChar(str, ' ');
 
-	appendStringInfo(str, "SET STATISTICS %d", alter_stats_stmt->stxstattarget);
+	if (alter_stats_stmt->stxstattarget)
+		appendStringInfo(str, "SET STATISTICS %d", castNode(Integer, alter_stats_stmt->stxstattarget)->ival);
+	else
+		appendStringInfo(str, "SET STATISTICS DEFAULT");
 }
 
 static void deparseAlterTSDictionaryStmt(StringInfo str, AlterTSDictionaryStmt *alter_ts_dictionary_stmt)
@@ -9634,6 +9761,7 @@ static void deparseVariableShowStmt(StringInfo str, VariableShowStmt *variable_s
 		appendStringInfoString(str, quote_identifier(variable_show_stmt->name));
 }
 
+// "tablesample_clause" in gram.y
 static void deparseRangeTableSample(StringInfo str, RangeTableSample *range_table_sample)
 {
 	deparseRangeVar(str, castNode(RangeVar, range_table_sample->relation), DEPARSE_NODE_CONTEXT_NONE);
@@ -9648,7 +9776,7 @@ static void deparseRangeTableSample(StringInfo str, RangeTableSample *range_tabl
 	if (range_table_sample->repeatable != NULL)
 	{
 		appendStringInfoString(str, "REPEATABLE (");
-		deparseExpr(str, range_table_sample->repeatable);
+		deparseExpr(str, range_table_sample->repeatable, DEPARSE_NODE_CONTEXT_A_EXPR);
 		appendStringInfoString(str, ") ");
 	}
 
@@ -9773,7 +9901,7 @@ static void deparseDropSubscriptionStmt(StringInfo str, DropSubscriptionStmt *dr
 static void deparseCallStmt(StringInfo str, CallStmt *call_stmt)
 {
 	appendStringInfoString(str, "CALL ");
-	deparseFuncCall(str, call_stmt->funccall);
+	deparseFuncCall(str, call_stmt->funccall, DEPARSE_NODE_CONTEXT_NONE);
 }
 
 static void deparseAlterOwnerStmt(StringInfo str, AlterOwnerStmt *alter_owner_stmt)
@@ -9965,6 +10093,7 @@ static void deparseClosePortalStmt(StringInfo str, ClosePortalStmt *close_portal
 	}
 }
 
+// "CreateTrigStmt" in gram.y
 static void deparseCreateTrigStmt(StringInfo str, CreateTrigStmt *create_trig_stmt)
 {
 	ListCell *lc;
@@ -10060,7 +10189,7 @@ static void deparseCreateTrigStmt(StringInfo str, CreateTrigStmt *create_trig_st
 	if (create_trig_stmt->whenClause)
 	{
 		appendStringInfoString(str, "WHEN (");
-		deparseExpr(str, create_trig_stmt->whenClause);
+		deparseExpr(str, create_trig_stmt->whenClause, DEPARSE_NODE_CONTEXT_A_EXPR);
 		appendStringInfoString(str, ") ");
 	}
 
@@ -10091,7 +10220,7 @@ static void deparseTriggerTransition(StringInfo str, TriggerTransition *trigger_
 	appendStringInfoString(str, quote_identifier(trigger_transition->name));
 }
 
-static void deparseXmlExpr(StringInfo str, XmlExpr* xml_expr)
+static void deparseXmlExpr(StringInfo str, XmlExpr* xml_expr, DeparseNodeContext context)
 {
 	switch (xml_expr->op)
 	{
@@ -10135,7 +10264,7 @@ static void deparseXmlExpr(StringInfo str, XmlExpr* xml_expr)
 				default:
 					Assert(false);
 			}
-			deparseExpr(str, linitial(xml_expr->args));
+			deparseExpr(str, linitial(xml_expr->args), DEPARSE_NODE_CONTEXT_A_EXPR);
 			appendStringInfoChar(str, ')');
 			break;
 		case IS_XMLPI: /* XMLPI(name [, args]) */
@@ -10144,18 +10273,18 @@ static void deparseXmlExpr(StringInfo str, XmlExpr* xml_expr)
 			if (xml_expr->args != NULL)
 			{
 				appendStringInfoString(str, ", ");
-				deparseExpr(str, linitial(xml_expr->args));
+				deparseExpr(str, linitial(xml_expr->args), DEPARSE_NODE_CONTEXT_A_EXPR);
 			}
 			appendStringInfoChar(str, ')');
 			break;
 		case IS_XMLROOT: /* XMLROOT(xml, version, standalone) */
 			appendStringInfoString(str, "xmlroot(");
-			deparseExpr(str, linitial(xml_expr->args));
+			deparseExpr(str, linitial(xml_expr->args), DEPARSE_NODE_CONTEXT_A_EXPR);
 			appendStringInfoString(str, ", version ");
 			if (castNode(A_Const, lsecond(xml_expr->args))->isnull)
 				appendStringInfoString(str, "NO VALUE");
 			else
-				deparseExpr(str, lsecond(xml_expr->args));
+				deparseExpr(str, lsecond(xml_expr->args), DEPARSE_NODE_CONTEXT_A_EXPR);
 			if (intVal(&castNode(A_Const, lthird(xml_expr->args))->val) == XML_STANDALONE_YES)
 				appendStringInfoString(str, ", STANDALONE YES");
 			else if (intVal(&castNode(A_Const, lthird(xml_expr->args))->val) == XML_STANDALONE_NO)
@@ -10170,12 +10299,13 @@ static void deparseXmlExpr(StringInfo str, XmlExpr* xml_expr)
 			break;
 		case IS_DOCUMENT: /* xmlval IS DOCUMENT */
 			Assert(list_length(xml_expr->args) == 1);
-			deparseExpr(str, linitial(xml_expr->args));
+			deparseExpr(str, linitial(xml_expr->args), context);
 			appendStringInfoString(str, " IS DOCUMENT");
 			break;
 	}
 }
 
+// "xmltable_column_el" in gram.y
 static void deparseRangeTableFuncCol(StringInfo str, RangeTableFuncCol* range_table_func_col)
 {
 	appendStringInfoString(str, quote_identifier(range_table_func_col->colname));
@@ -10193,14 +10323,14 @@ static void deparseRangeTableFuncCol(StringInfo str, RangeTableFuncCol* range_ta
 		if (range_table_func_col->colexpr)
 		{
 			appendStringInfoString(str, "PATH ");
-			deparseExpr(str, range_table_func_col->colexpr);
+			deparseExpr(str, range_table_func_col->colexpr, DEPARSE_NODE_CONTEXT_NONE /* b_expr */);
 			appendStringInfoChar(str, ' ');
 		}
 
 		if (range_table_func_col->coldefexpr)
 		{
 			appendStringInfoString(str, "DEFAULT ");
-			deparseExpr(str, range_table_func_col->coldefexpr);
+			deparseExpr(str, range_table_func_col->coldefexpr, DEPARSE_NODE_CONTEXT_NONE /* b_expr */);
 			appendStringInfoChar(str, ' ');
 		}
 
@@ -10211,6 +10341,7 @@ static void deparseRangeTableFuncCol(StringInfo str, RangeTableFuncCol* range_ta
 	removeTrailingSpace(str);
 }
 
+// "table_ref" and "xmltable" in gram.y
 static void deparseRangeTableFunc(StringInfo str, RangeTableFunc* range_table_func)
 {
 	ListCell *lc;
@@ -10227,11 +10358,11 @@ static void deparseRangeTableFunc(StringInfo str, RangeTableFunc* range_table_fu
 	}
 
 	appendStringInfoChar(str, '(');
-	deparseExpr(str, range_table_func->rowexpr);
+	deparseExpr(str, range_table_func->rowexpr, DEPARSE_NODE_CONTEXT_NONE /* c_expr */);
 	appendStringInfoChar(str, ')');
 
 	appendStringInfoString(str, " PASSING ");
-	deparseExpr(str, range_table_func->docexpr);
+	deparseExpr(str, range_table_func->docexpr, DEPARSE_NODE_CONTEXT_NONE /* c_expr */);
 
 	appendStringInfoString(str, " COLUMNS ");
 	foreach(lc, range_table_func->columns)
@@ -10266,7 +10397,7 @@ static void deparseXmlSerialize(StringInfo str, XmlSerialize *xml_serialize)
 		default:
 			Assert(false);
 	}
-	deparseExpr(str, xml_serialize->expr);
+	deparseExpr(str, xml_serialize->expr, DEPARSE_NODE_CONTEXT_A_EXPR);
 	appendStringInfoString(str, " AS ");
 	deparseTypeName(str, xml_serialize->typeName);
 
@@ -10303,7 +10434,7 @@ static void deparseJsonFormat(StringInfo str, JsonFormat *json_format)
 
 static void deparseJsonIsPredicate(StringInfo str, JsonIsPredicate *j)
 {
-	deparseExpr(str, j->expr);
+	deparseExpr(str, j->expr, DEPARSE_NODE_CONTEXT_A_EXPR);
 	appendStringInfoChar(str, ' ');
 
 	deparseJsonFormat(str, castNode(JsonFormat, j->format));
@@ -10335,7 +10466,7 @@ static void deparseJsonIsPredicate(StringInfo str, JsonIsPredicate *j)
 // "json_value_expr" in gram.y
 static void deparseJsonValueExpr(StringInfo str, JsonValueExpr *json_value_expr)
 {
-	deparseExpr(str, (Node *) json_value_expr->raw_expr);
+	deparseExpr(str, (Node *) json_value_expr->raw_expr, DEPARSE_NODE_CONTEXT_A_EXPR);
 	appendStringInfoChar(str, ' ');
 	deparseJsonFormat(str, json_value_expr->format);
 }
@@ -10357,7 +10488,7 @@ static void deparseJsonValueExprList(StringInfo str, List *exprs)
 // "json_name_and_value" in gram.y
 static void deparseJsonKeyValue(StringInfo str, JsonKeyValue *json_key_value)
 {
-	deparseExpr(str, (Node *) json_key_value->key);
+	deparseExpr(str, (Node *) json_key_value->key, DEPARSE_NODE_CONTEXT_A_EXPR);
 	appendStringInfoString(str, ": ");
 	deparseJsonValueExpr(str, json_key_value->value);
 }
@@ -10389,6 +10520,7 @@ static void deparseJsonOutput(StringInfo str, JsonOutput *json_output)
 	deparseJsonFormat(str, json_output->returning->format);
 }
 
+// "json_aggregate_func" and "func_expr" in gram.y
 static void deparseJsonObjectAgg(StringInfo str, JsonObjectAgg *json_object_agg)
 {
 	Assert(json_object_agg->constructor != NULL);
@@ -10410,7 +10542,7 @@ static void deparseJsonObjectAgg(StringInfo str, JsonObjectAgg *json_object_agg)
 	if (json_object_agg->constructor->agg_filter)
 	{
 		appendStringInfoString(str, "FILTER (WHERE ");
-		deparseExpr(str, json_object_agg->constructor->agg_filter);
+		deparseExpr(str, json_object_agg->constructor->agg_filter, DEPARSE_NODE_CONTEXT_A_EXPR);
 		appendStringInfoString(str, ") ");
 	}
 
@@ -10427,6 +10559,7 @@ static void deparseJsonObjectAgg(StringInfo str, JsonObjectAgg *json_object_agg)
 	removeTrailingSpace(str);
 }
 
+// "json_aggregate_func" and "func_expr" in gram.y
 static void deparseJsonArrayAgg(StringInfo str, JsonArrayAgg *json_array_agg)
 {
 	Assert(json_array_agg->constructor != NULL);
@@ -10446,7 +10579,7 @@ static void deparseJsonArrayAgg(StringInfo str, JsonArrayAgg *json_array_agg)
 	if (json_array_agg->constructor->agg_filter)
 	{
 		appendStringInfoString(str, "FILTER (WHERE ");
-		deparseExpr(str, json_array_agg->constructor->agg_filter);
+		deparseExpr(str, json_array_agg->constructor->agg_filter, DEPARSE_NODE_CONTEXT_A_EXPR);
 		appendStringInfoString(str, ") ");
 	}
 
@@ -10506,6 +10639,302 @@ static void deparseJsonArrayQueryConstructor(StringInfo str, JsonArrayQueryConst
 	appendStringInfoChar(str, ')');
 }
 
+static void deparseJsonParseExpr(StringInfo str, JsonParseExpr *json_parse_expr)
+{
+	appendStringInfoString(str, "JSON(");
+
+	deparseJsonValueExpr(str, json_parse_expr->expr);
+
+	if (json_parse_expr->unique_keys)
+		appendStringInfoString(str, " WITH UNIQUE KEYS");
+
+	appendStringInfoString(str, ")");
+}
+
+static void deparseJsonScalarExpr(StringInfo str, JsonScalarExpr *json_scalar_expr)
+{
+	appendStringInfoString(str, "JSON_SCALAR(");
+	deparseExpr(str, (Node*) json_scalar_expr->expr, DEPARSE_NODE_CONTEXT_A_EXPR);
+	appendStringInfoString(str, ")");
+}
+
+static void deparseJsonSerializeExpr(StringInfo str, JsonSerializeExpr *json_serialize_expr)
+{
+	appendStringInfoString(str, "JSON_SERIALIZE(");
+
+	deparseJsonValueExpr(str, json_serialize_expr->expr);
+
+	if (json_serialize_expr->output)
+		deparseJsonOutput(str, json_serialize_expr->output);
+
+	appendStringInfoString(str, ")");
+}
+
+static void deparseJsonQuotesClauseOpt(StringInfo str, JsonQuotes quotes)
+{
+	switch (quotes)
+	{
+		case JS_QUOTES_UNSPEC:
+			break;
+		case JS_QUOTES_KEEP:
+			appendStringInfoString(str, " KEEP QUOTES");
+			break;
+		case JS_QUOTES_OMIT:
+			appendStringInfoString(str, " OMIT QUOTES");
+			break;
+	}
+}
+
+static void deparseJsonOnErrorClauseOpt(StringInfo str, JsonBehavior *behavior)
+{
+	if (!behavior)
+		return;
+
+	appendStringInfoChar(str, ' ');
+	deparseJsonBehavior(str, behavior);
+	appendStringInfoString(str, " ON ERROR");
+}
+
+static void deparseJsonOnEmptyClauseOpt(StringInfo str, JsonBehavior *behavior)
+{
+	if (behavior)
+	{
+		appendStringInfoChar(str, ' ');
+		deparseJsonBehavior(str, behavior);
+		appendStringInfoString(str, " ON EMPTY");
+	}
+}
+
+static void deparseJsonFuncExpr(StringInfo str, JsonFuncExpr *json_func_expr)
+{
+	switch (json_func_expr->op)
+	{
+		case JSON_EXISTS_OP:
+			appendStringInfoString(str, "JSON_EXISTS(");
+			break;
+		case JSON_QUERY_OP:
+			appendStringInfoString(str, "JSON_QUERY(");
+			break;
+		case JSON_VALUE_OP:
+			appendStringInfoString(str, "JSON_VALUE(");
+			break;
+		case JSON_TABLE_OP:
+			appendStringInfoString(str, "JSON_TABLE(");
+			break;
+	}
+
+	deparseJsonValueExpr(str, json_func_expr->context_item);
+	appendStringInfoString(str, ", ");
+	deparseExpr(str, json_func_expr->pathspec, DEPARSE_NODE_CONTEXT_A_EXPR);
+
+	if (json_func_expr->passing)
+		appendStringInfoString(str, " PASSING ");
+
+	ListCell *lc = NULL;
+	foreach (lc, json_func_expr->passing)
+	{
+		JsonArgument *json_argument = castNode(JsonArgument, lfirst(lc));
+		deparseJsonValueExpr(str, json_argument->val);
+		appendStringInfoString(str, " AS ");
+		deparseColLabel(str, json_argument->name);
+
+		if (lnext(json_func_expr->passing, lc))
+			appendStringInfoString(str, ", ");
+	}
+
+	if (json_func_expr->output)
+	{
+		appendStringInfoChar(str, ' ');
+		deparseJsonOutput(str, json_func_expr->output);
+	}
+
+	switch (json_func_expr->wrapper)
+	{
+		case JSW_UNSPEC:
+			break;
+		case JSW_NONE:
+			appendStringInfoString(str, " WITHOUT WRAPPER");
+			break;
+		case JSW_CONDITIONAL:
+			appendStringInfoString(str, " WITH CONDITIONAL WRAPPER");
+			break;
+		case JSW_UNCONDITIONAL:
+			appendStringInfoString(str, " WITH UNCONDITIONAL WRAPPER");
+			break;
+	}
+
+	deparseJsonQuotesClauseOpt(str, json_func_expr->quotes);
+	deparseJsonOnEmptyClauseOpt(str, json_func_expr->on_empty);
+	deparseJsonOnErrorClauseOpt(str, json_func_expr->on_error);
+
+	appendStringInfoChar(str, ')');
+}
+
+static void deparseJsonTablePathSpec(StringInfo str, JsonTablePathSpec *json_table_path_spec)
+{
+	deparseStringLiteral(str, castNode(A_Const, json_table_path_spec->string)->val.sval.sval);
+
+	if (json_table_path_spec->name)
+	{
+		appendStringInfoString(str, " AS ");
+		deparseColLabel(str, json_table_path_spec->name);
+	}
+}
+
+// "json_behavior" in gram.y
+static void deparseJsonBehavior(StringInfo str, JsonBehavior *json_behavior)
+{
+	switch (json_behavior->btype)
+	{
+		case JSON_BEHAVIOR_NULL:
+			appendStringInfoString(str, "NULL");
+			break;
+		case JSON_BEHAVIOR_ERROR:
+			appendStringInfoString(str, "ERROR");
+			break;
+		case JSON_BEHAVIOR_EMPTY:
+			appendStringInfoString(str, "EMPTY");
+			break;
+		case JSON_BEHAVIOR_TRUE:
+			appendStringInfoString(str, "TRUE");
+			break;
+		case JSON_BEHAVIOR_FALSE:
+			appendStringInfoString(str, "FALSE");
+			break;
+		case JSON_BEHAVIOR_EMPTY_ARRAY:
+			appendStringInfoString(str, "EMPTY ARRAY");
+			break;
+		case JSON_BEHAVIOR_EMPTY_OBJECT:
+			appendStringInfoString(str, "EMPTY OBJECT");
+			break;
+		case JSON_BEHAVIOR_DEFAULT:
+			appendStringInfoString(str, "DEFAULT ");
+			deparseExpr(str, (Node*) json_behavior->expr, DEPARSE_NODE_CONTEXT_A_EXPR);
+			break;
+		case JSON_BEHAVIOR_UNKNOWN:
+			appendStringInfoString(str, "UNKNOWN");
+			break;
+	}
+}
+
+static void deparseJsonTableColumn(StringInfo str, JsonTableColumn *json_table_column)
+{
+	if (json_table_column->coltype == JTC_NESTED)
+	{
+		appendStringInfoString(str, "NESTED PATH ");
+		deparseJsonTablePathSpec(str, json_table_column->pathspec);
+		deparseJsonTableColumns(str, json_table_column->columns);
+		return;
+	}
+
+	deparseColLabel(str, json_table_column->name);
+	appendStringInfoChar(str, ' ');
+
+	switch (json_table_column->coltype)
+	{
+		case JTC_FOR_ORDINALITY:
+			appendStringInfoString(str, " FOR ORDINALITY");
+			break;
+		case JTC_EXISTS:
+		case JTC_FORMATTED:
+		case JTC_REGULAR:
+			deparseTypeName(str, json_table_column->typeName);
+
+			if (json_table_column->coltype == JTC_EXISTS)
+				appendStringInfoString(str, " EXISTS ");
+			else
+				appendStringInfoChar(str, ' ');
+
+			if (json_table_column->format)
+				deparseJsonFormat(str, json_table_column->format);
+
+			if (json_table_column->pathspec)
+			{
+				appendStringInfoString(str, "PATH ");
+				deparseJsonTablePathSpec(str, json_table_column->pathspec);
+			}
+			break;
+		case JTC_NESTED:
+			Assert(false);
+	}
+
+	switch (json_table_column->wrapper)
+	{
+		case JSW_UNSPEC:
+			break;
+		case JSW_NONE:
+			if (json_table_column->coltype == JTC_REGULAR || json_table_column->coltype == JTC_FORMATTED)
+				appendStringInfoString(str, " WITHOUT WRAPPER");
+			break;
+		case JSW_CONDITIONAL:
+			appendStringInfoString(str, " WITH CONDITIONAL WRAPPER");
+			break;
+		case JSW_UNCONDITIONAL:
+			appendStringInfoString(str, " WITH UNCONDITIONAL WRAPPER");
+			break;
+	}
+
+	deparseJsonQuotesClauseOpt(str, json_table_column->quotes);
+	deparseJsonOnEmptyClauseOpt(str, json_table_column->on_empty);
+	deparseJsonOnErrorClauseOpt(str, json_table_column->on_error);
+}
+
+static void deparseJsonTableColumns(StringInfo str, List *json_table_columns)
+{
+	appendStringInfoString(str, " COLUMNS (");
+
+	ListCell *lc = NULL;
+	foreach(lc, json_table_columns)
+	{
+		deparseJsonTableColumn(str, castNode(JsonTableColumn, lfirst(lc)));
+
+		if (lnext(json_table_columns, lc))
+			appendStringInfoString(str, ", ");
+	}
+
+	appendStringInfoChar(str, ')');
+}
+
+static void deparseJsonTable(StringInfo str, JsonTable *json_table)
+{
+	appendStringInfoString(str, "JSON_TABLE(");
+
+	deparseJsonValueExpr(str, json_table->context_item);
+	appendStringInfoString(str, ", ");
+	deparseJsonTablePathSpec(str, json_table->pathspec);
+
+	if (json_table->passing)
+		appendStringInfoString(str, " PASSING ");
+
+	ListCell *lc = NULL;
+	foreach (lc, json_table->passing)
+	{
+		JsonArgument *json_argument = castNode(JsonArgument, lfirst(lc));
+		deparseJsonValueExpr(str, json_argument->val);
+		appendStringInfoString(str, " AS ");
+		deparseColLabel(str, json_argument->name);
+
+		if (lnext(json_table->passing, lc))
+			appendStringInfoString(str, ", ");
+	}
+
+	deparseJsonTableColumns(str, json_table->columns);
+
+	if (json_table->on_error)
+	{
+		deparseJsonBehavior(str, json_table->on_error);
+		appendStringInfoString(str, " ON ERROR");
+	}
+
+	appendStringInfoChar(str, ')');
+
+	if (json_table->alias)
+	{
+		appendStringInfoChar(str, ' ');
+		deparseAlias(str, json_table->alias);
+	}
+}
+
 static void deparseGroupingFunc(StringInfo str, GroupingFunc *grouping_func)
 {
 	appendStringInfoString(str, "GROUPING(");