Method createJSONConcatExpr

transpiler/transform/operators.go:756–812

createJSONConcatExpr rewrites `a || b` (with a JSON-looking operand) to a CASE expression reproducing Postgres jsonb || semantics in DuckDB: object || object -> shallow merge, right side wins, explicit nulls are KEPT (unlike json_merge_patch, which deep-merges and

(left, right *pg_query.Node)

// duckgres_jsonb_concat(l, r)) at session/worker init and emit one call per
// ||, binding each operand exactly once.
func (t *OperatorTransform) createJSONConcatExpr(left, right *pg_query.Node) *pg_query.Node {
	if newLeft := t.transformExpression(left); newLeft != nil {
		left = newLeft
	}
	if newRight := t.transformExpression(right); newRight != nil {
		right = newRight
	}

	asObjectMap := func(operand *pg_query.Node) *pg_query.Node {
		return jsonFuncCall("json_transform", cloneNode(operand), strConst(`"MAP(VARCHAR, JSON)"`))
	}
	// CASE WHEN json_type(x) = 'ARRAY' THEN json_transform(x, '["JSON"]')
	// ELSE list_value(CAST(x AS JSON)) END — Postgres treats every non-array
	// operand of a non-object||object concat as a one-element array.
	asElementList := func(operand *pg_query.Node) *pg_query.Node {
		return &pg_query.Node{Node: &pg_query.Node_CaseExpr{CaseExpr: &pg_query.CaseExpr{
			Args: []*pg_query.Node{{Node: &pg_query.Node_CaseWhen{CaseWhen: &pg_query.CaseWhen{
				Expr:   jsonTypeEquals(operand, "ARRAY"),
				Result: jsonFuncCall("json_transform", cloneNode(operand), strConst(`["JSON"]`)),
			}}}},
			Defresult: jsonFuncCall("list_value", castToJSON(cloneNode(operand))),
		}}}
	}

	// The whole CASE is wrapped in an explicit CAST(... AS JSON). DuckDB's
	// to_json()/map_concat()/list_concat() result type is not reported as JSON
	// by every bundled DuckDB version — on some versions the wire layer then
	// sees the column as an untyped list and renders it with Go's %v
	// ("[1 2 3 4]") instead of routing it through the JSON re-serializer
	// ("[1,2,3,4]"). Forcing the column to JSON pins OID 114 so server's
	// encodeJSON path always produces valid JSON text. The cast is idempotent
	// on versions that already type it as JSON. (#716 regression.)
	return castToJSON(&pg_query.Node{Node: &pg_query.Node_CaseExpr{CaseExpr: &pg_query.CaseExpr{
		Args: []*pg_query.Node{
			// WHEN L IS NULL OR R IS NULL THEN NULL — Postgres jsonb || is
			// strict; without this guard the ELSE branch would wrap a SQL
			// NULL operand into [null, ...].
			{Node: &pg_query.Node_CaseWhen{CaseWhen: &pg_query.CaseWhen{
				Expr: &pg_query.Node{Node: &pg_query.Node_BoolExpr{BoolExpr: &pg_query.BoolExpr{
					Boolop: pg_query.BoolExprType_OR_EXPR,
					Args:   []*pg_query.Node{isNullTest(left), isNullTest(right)},
				}}},
				Result: nullConstNode(0),
			}}},
			// WHEN both objects THEN shallow merge, right side wins.
			{Node: &pg_query.Node_CaseWhen{CaseWhen: &pg_query.CaseWhen{
				Expr: &pg_query.Node{Node: &pg_query.Node_BoolExpr{BoolExpr: &pg_query.BoolExpr{
					Boolop: pg_query.BoolExprType_AND_EXPR,
					Args:   []*pg_query.Node{jsonTypeEquals(left, "OBJECT"), jsonTypeEquals(right, "OBJECT")},
				}}},
				Result: jsonFuncCall("to_json", jsonFuncCall("map_concat", asObjectMap(left), asObjectMap(right))),
			}}},
		},
		// ELSE array concatenation (with non-arrays wrapped as one element).
		Defresult: jsonFuncCall("to_json", jsonFuncCall("list_concat", asElementList(left), asElementList(right))),
	}}})
}