Add JSON_OBJECT and JSON_ARRAY function parsing support

- Add JsonKeyValue AST type for JSON_OBJECT key:value pairs
- Add JsonParameters and AbsentOrNullOnNull fields to FunctionCall
- Implement parseJsonObjectCall for JSON_OBJECT('key':value, ...) syntax
- Implement parseJsonArrayCall for JSON_ARRAY(value1, value2, ...) syntax
- Support NULL ON NULL and ABSENT ON NULL modifiers
- Fix GlobalVariableExpression handling in SELECT elements (@@spid)
- Enable Baselines160_JsonFunctionTests160 and JsonFunctionTests160 tests

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: kyleconroy

ast/function_call.go

@@ -59,6 +59,14 @@ type WithinGroupClause struct {
 
 func (*WithinGroupClause) node() {}
 
+// JsonKeyValue represents a key-value pair in JSON_OBJECT function
+type JsonKeyValue struct {
+	JsonKeyName ScalarExpression `json:"JsonKeyName,omitempty"`
+	JsonValue   ScalarExpression `json:"JsonValue,omitempty"`
+}
+
+func (*JsonKeyValue) node() {}
+
 // FunctionCall represents a function call.
 type FunctionCall struct {
 	CallTarget         CallTarget         `json:"CallTarget,omitempty"`
@@ -71,6 +79,8 @@ type FunctionCall struct {
 	WithArrayWrapper   bool               `json:"WithArrayWrapper,omitempty"`
 	TrimOptions        *Identifier        `json:"TrimOptions,omitempty"` // For TRIM(LEADING/TRAILING/BOTH chars FROM string)
 	Collation          *Identifier        `json:"Collation,omitempty"`
+	JsonParameters     []*JsonKeyValue    `json:"JsonParameters,omitempty"`  // For JSON_OBJECT function key:value pairs
+	AbsentOrNullOnNull []*Identifier      `json:"AbsentOrNullOnNull,omitempty"` // For JSON_OBJECT/JSON_ARRAY NULL ON NULL or ABSENT ON NULL
 }
 
 func (*FunctionCall) node()             {}

parser/marshal.go

@@ -1950,6 +1950,24 @@ func scalarExpressionToJSON(expr ast.ScalarExpression) jsonNode {
 		if e.Collation != nil {
 			node["Collation"] = identifierToJSON(e.Collation)
 		}
+		if len(e.JsonParameters) > 0 {
+			params := make([]jsonNode, len(e.JsonParameters))
+			for i, kv := range e.JsonParameters {
+				params[i] = jsonNode{
+					"$type":       "JsonKeyValue",
+					"JsonKeyName": scalarExpressionToJSON(kv.JsonKeyName),
+					"JsonValue":   scalarExpressionToJSON(kv.JsonValue),
+				}
+			}
+			node["JsonParameters"] = params
+		}
+		if len(e.AbsentOrNullOnNull) > 0 {
+			idents := make([]jsonNode, len(e.AbsentOrNullOnNull))
+			for i, ident := range e.AbsentOrNullOnNull {
+				idents[i] = identifierToJSON(ident)
+			}
+			node["AbsentOrNullOnNull"] = idents
+		}
 		return node
 	case *ast.PartitionFunctionCall:
 		node := jsonNode{

parser/parse_select.go

@@ -471,10 +471,15 @@ func (p *Parser) parseSelectElement() (ast.SelectElement, error) {
 		}
 
 		// Not an assignment, treat as regular scalar expression starting with variable
-		varRef := &ast.VariableReference{Name: varName}
+		var varExpr ast.ScalarExpression
+		if strings.HasPrefix(varName, "@@") {
+			varExpr = &ast.GlobalVariableExpression{Name: varName}
+		} else {
+			varExpr = &ast.VariableReference{Name: varName}
+		}
 
 		// Handle postfix operations (method calls, property access)
-		expr, err := p.handlePostfixOperations(varRef)
+		expr, err := p.handlePostfixOperations(varExpr)
 		if err != nil {
 			return nil, err
 		}
@@ -1899,6 +1904,10 @@ func (p *Parser) parseFunctionCallFromIdentifiers(identifiers []*ast.Identifier)
 			return p.parseParseCall(false)
 		case "TRY_PARSE":
 			return p.parseParseCall(true)
+		case "JSON_OBJECT":
+			return p.parseJsonObjectCall()
+		case "JSON_ARRAY":
+			return p.parseJsonArrayCall()
 		}
 	}
 
@@ -5866,6 +5875,149 @@ func (p *Parser) parseParseCall(isTry bool) (ast.ScalarExpression, error) {
 	}, nil
 }
 
+// parseJsonObjectCall parses JSON_OBJECT('key':value, 'key2':value2, ... [NULL|ABSENT ON NULL])
+func (p *Parser) parseJsonObjectCall() (*ast.FunctionCall, error) {
+	fc := &ast.FunctionCall{
+		FunctionName:     &ast.Identifier{Value: "JSON_OBJECT", QuoteType: "NotQuoted"},
+		UniqueRowFilter:  "NotSpecified",
+		WithArrayWrapper: false,
+	}
+
+	p.nextToken() // consume (
+
+	// Parse key-value pairs
+	for p.curTok.Type != TokenRParen && p.curTok.Type != TokenEOF {
+		// Check for NULL ON NULL or ABSENT ON NULL at start of loop
+		upperLit := strings.ToUpper(p.curTok.Literal)
+		if upperLit == "NULL" || upperLit == "ABSENT" {
+			// Look ahead to see if this is "NULL ON NULL" or "ABSENT ON NULL"
+			if p.peekIsOnNull() {
+				fc.AbsentOrNullOnNull = append(fc.AbsentOrNullOnNull, &ast.Identifier{Value: upperLit, QuoteType: "NotQuoted"})
+				p.nextToken() // consume NULL or ABSENT
+				p.nextToken() // consume ON
+				p.nextToken() // consume NULL
+				continue
+			}
+		}
+
+		// Parse key expression
+		keyExpr, err := p.parseScalarExpression()
+		if err != nil {
+			return nil, err
+		}
+
+		// Check for : (JSON key-value separator)
+		if p.curTok.Type == TokenColon {
+			p.nextToken() // consume :
+
+			// Parse value expression
+			valueExpr, err := p.parseScalarExpression()
+			if err != nil {
+				return nil, err
+			}
+
+			fc.JsonParameters = append(fc.JsonParameters, &ast.JsonKeyValue{
+				JsonKeyName: keyExpr,
+				JsonValue:   valueExpr,
+			})
+		} else {
+			// Just a regular parameter without colon (shouldn't happen for JSON_OBJECT)
+			fc.Parameters = append(fc.Parameters, keyExpr)
+		}
+
+		// After parsing a value, check for NULL ON NULL or ABSENT ON NULL
+		postValueLit := strings.ToUpper(p.curTok.Literal)
+		if postValueLit == "NULL" || postValueLit == "ABSENT" {
+			if p.peekIsOnNull() {
+				fc.AbsentOrNullOnNull = append(fc.AbsentOrNullOnNull, &ast.Identifier{Value: postValueLit, QuoteType: "NotQuoted"})
+				p.nextToken() // consume NULL or ABSENT
+				p.nextToken() // consume ON
+				p.nextToken() // consume NULL
+				// Continue to check for ) or comma
+			}
+		}
+
+		if p.curTok.Type == TokenComma {
+			p.nextToken() // consume ,
+		} else {
+			break
+		}
+	}
+
+	if p.curTok.Type != TokenRParen {
+		return nil, fmt.Errorf("expected ) in JSON_OBJECT, got %s", p.curTok.Literal)
+	}
+	p.nextToken() // consume )
+
+	return fc, nil
+}
+
+// parseJsonArrayCall parses JSON_ARRAY(value1, value2, ... [NULL|ABSENT ON NULL])
+func (p *Parser) parseJsonArrayCall() (*ast.FunctionCall, error) {
+	fc := &ast.FunctionCall{
+		FunctionName:     &ast.Identifier{Value: "JSON_ARRAY", QuoteType: "NotQuoted"},
+		UniqueRowFilter:  "NotSpecified",
+		WithArrayWrapper: false,
+	}
+
+	p.nextToken() // consume (
+
+	// Parse array elements
+	for p.curTok.Type != TokenRParen && p.curTok.Type != TokenEOF {
+		// Check for NULL ON NULL or ABSENT ON NULL at start of loop
+		upperLit := strings.ToUpper(p.curTok.Literal)
+		if upperLit == "NULL" || upperLit == "ABSENT" {
+			// Look ahead to see if this is "NULL ON NULL" or "ABSENT ON NULL"
+			if p.peekIsOnNull() {
+				fc.AbsentOrNullOnNull = append(fc.AbsentOrNullOnNull, &ast.Identifier{Value: upperLit, QuoteType: "NotQuoted"})
+				p.nextToken() // consume NULL or ABSENT
+				p.nextToken() // consume ON
+				p.nextToken() // consume NULL
+				continue
+			}
+		}
+
+		// Parse value expression
+		valueExpr, err := p.parseScalarExpression()
+		if err != nil {
+			return nil, err
+		}
+		fc.Parameters = append(fc.Parameters, valueExpr)
+
+		// After parsing a value, check for NULL ON NULL or ABSENT ON NULL
+		postValueLit := strings.ToUpper(p.curTok.Literal)
+		if postValueLit == "NULL" || postValueLit == "ABSENT" {
+			if p.peekIsOnNull() {
+				fc.AbsentOrNullOnNull = append(fc.AbsentOrNullOnNull, &ast.Identifier{Value: postValueLit, QuoteType: "NotQuoted"})
+				p.nextToken() // consume NULL or ABSENT
+				p.nextToken() // consume ON
+				p.nextToken() // consume NULL
+				// Continue to check for ) or comma
+			}
+		}
+
+		if p.curTok.Type == TokenComma {
+			p.nextToken() // consume ,
+		} else {
+			break
+		}
+	}
+
+	if p.curTok.Type != TokenRParen {
+		return nil, fmt.Errorf("expected ) in JSON_ARRAY, got %s", p.curTok.Literal)
+	}
+	p.nextToken() // consume )
+
+	return fc, nil
+}
+
+// peekIsOnNull checks if the next tokens are "ON NULL"
+func (p *Parser) peekIsOnNull() bool {
+	// Just check if the next token is ON
+	// The caller will verify the NULL after ON when consuming
+	return p.peekTok.Type == TokenOn
+}
+
 // parseChangeTableReference parses CHANGETABLE(CHANGES ...) or CHANGETABLE(VERSION ...)
 func (p *Parser) parseChangeTableReference() (ast.TableReference, error) {
 	p.nextToken() // consume CHANGETABLE

parser/testdata/Baselines160_JsonFunctionTests160/metadata.json

@@ -1 +1 @@
-{"todo": true}
+{}

parser/testdata/JsonFunctionTests160/metadata.json

@@ -1 +1 @@
-{"todo": true}
+{}