Method transformExpression

transpiler/transform/operators.go:369–603

transformExpression recursively transforms an expression, replacing regex operators with function calls. Returns the new node if transformed, nil otherwise.

(node *pg_query.Node)

// transformExpression recursively transforms an expression, replacing regex operators
// with function calls. Returns the new node if transformed, nil otherwise.
func (t *OperatorTransform) transformExpression(node *pg_query.Node) *pg_query.Node {
	if node == nil {
		return nil
	}

	// Check if this is an operator A_Expr that needs transformation
	if aexpr := node.GetAExpr(); aexpr != nil {
		opName := t.getOperatorName(aexpr)

		switch opName {
		// JSON operators - convert to function calls to avoid DuckDB precedence issues
		// DuckDB parses "a AND b -> 'key'" as "(a AND b) -> 'key'" instead of "a AND (b -> 'key')"
		case "->":
			return t.createJsonExtractFuncCall(aexpr.Lexpr, aexpr.Rexpr, false)
		case "->>":
			return t.createJsonExtractFuncCall(aexpr.Lexpr, aexpr.Rexpr, true)
		// jsonb || jsonb is concatenation in Postgres (object merge / array
		// concat), but DuckDB treats || as string concatenation, silently
		// producing invalid JSON. Rewrite to a json_type()-dispatching CASE
		// that reproduces Postgres semantics only when an operand is clearly
		// JSON; otherwise leave || alone (string/array concat is the safe
		// default).
		case "||":
			if looksJSON(aexpr.Lexpr) || looksJSON(aexpr.Rexpr) {
				return t.createJSONConcatExpr(aexpr.Lexpr, aexpr.Rexpr)
			}
		// jsonb @> jsonb is containment in Postgres; DuckDB has no @>(JSON,JSON) but does
		// have json_contains(). Only rewrite when an operand is clearly JSON — array @> array
		// is native in DuckDB and must be left alone.
		case "@>":
			if looksJSON(aexpr.Lexpr) || looksJSON(aexpr.Rexpr) {
				return t.createJSONContainsFuncCall(aexpr.Lexpr, aexpr.Rexpr)
			}
		// json #>> '{a,b}' extracts the value at a text[] path as text. DuckDB lacks #>> but
		// json_extract_string(j, '$."a"."b"') is equivalent. Only literal path arrays can be
		// converted at transpile time; a non-literal path is left as-is.
		case "#>>":
			if jsonPath := pgPathArrayToJSONPath(aexpr.Rexpr); jsonPath != "" {
				return t.createJsonExtractFuncCall(aexpr.Lexpr, stringConstNode(jsonPath), true)
			}
		// Regex operators — only match binary ~ (both operands present).
		// Unary ~ (bitwise NOT, e.g. ~id) has Lexpr=nil and must be left as-is;
		// DuckDB supports ~ as bitwise NOT natively. Passing nil into
		// createRegexFuncCall would create a nil AST node that crashes pg_query.Deparse.
		case "~":
			if aexpr.Lexpr != nil {
				return t.createRegexFuncCall(aexpr.Lexpr, aexpr.Rexpr, false, false)
			}
		case "~*":
			return t.createRegexFuncCall(aexpr.Lexpr, aexpr.Rexpr, true, false)
		case "!~":
			return t.createRegexFuncCall(aexpr.Lexpr, aexpr.Rexpr, false, true)
		case "!~*":
			return t.createRegexFuncCall(aexpr.Lexpr, aexpr.Rexpr, true, true)
		}

		// Recursively transform operands for other operators
		leftChanged := false