Add LEFT and RIGHT string function support

- Add LeftFunctionCall AST type for LEFT(string, count) function
- Add RightFunctionCall AST type for RIGHT(string, count) function
- Add parsing support in parsePrimaryExpression for TokenLeft/TokenRight
- Add parseLeftFunctionCall and parseRightFunctionCall functions
- Add JSON marshaling for both function call types

Note: ExpressionTests has additional parsing issues with nested UNION
subqueries that need separate implementation.

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

Author: kyleconroy

ast/left_function_call.go

@@ -0,0 +1,10 @@
+package ast
+
+// LeftFunctionCall represents the LEFT(string, count) function
+type LeftFunctionCall struct {
+	Parameters []ScalarExpression
+}
+
+func (*LeftFunctionCall) node()             {}
+func (*LeftFunctionCall) expression()       {}
+func (*LeftFunctionCall) scalarExpression() {}

ast/right_function_call.go

@@ -0,0 +1,10 @@
+package ast
+
+// RightFunctionCall represents the RIGHT(string, count) function
+type RightFunctionCall struct {
+	Parameters []ScalarExpression
+}
+
+func (*RightFunctionCall) node()             {}
+func (*RightFunctionCall) expression()       {}
+func (*RightFunctionCall) scalarExpression() {}

parser/marshal.go

@@ -2287,6 +2287,30 @@ func scalarExpressionToJSON(expr ast.ScalarExpression) jsonNode {
 			node["Increment"] = scalarExpressionToJSON(e.Increment)
 		}
 		return node
+	case *ast.LeftFunctionCall:
+		node := jsonNode{
+			"$type": "LeftFunctionCall",
+		}
+		if len(e.Parameters) > 0 {
+			params := make([]jsonNode, len(e.Parameters))
+			for i, p := range e.Parameters {
+				params[i] = scalarExpressionToJSON(p)
+			}
+			node["Parameters"] = params
+		}
+		return node
+	case *ast.RightFunctionCall:
+		node := jsonNode{
+			"$type": "RightFunctionCall",
+		}
+		if len(e.Parameters) > 0 {
+			params := make([]jsonNode, len(e.Parameters))
+			for i, p := range e.Parameters {
+				params[i] = scalarExpressionToJSON(p)
+			}
+			node["Parameters"] = params
+		}
+		return node
 	case *ast.AtTimeZoneCall:
 		node := jsonNode{
 			"$type": "AtTimeZoneCall",

parser/parse_select.go

@@ -1072,6 +1072,20 @@ func (p *Parser) parsePrimaryExpression() (ast.ScalarExpression, error) {
 			return &ast.UnaryExpression{UnaryExpressionType: "BitwiseNot", Expression: expr}, nil
 		}
 		return nil, fmt.Errorf("unexpected token in expression: %s", p.curTok.Literal)
+	case TokenLeft:
+		// LEFT can be a function name (string function)
+		if p.peekTok.Type == TokenLParen {
+			p.nextToken() // consume LEFT
+			return p.parseLeftFunctionCall()
+		}
+		return nil, fmt.Errorf("unexpected token in expression: %s", p.curTok.Literal)
+	case TokenRight:
+		// RIGHT can be a function name (string function)
+		if p.peekTok.Type == TokenLParen {
+			p.nextToken() // consume RIGHT
+			return p.parseRightFunctionCall()
+		}
+		return nil, fmt.Errorf("unexpected token in expression: %s", p.curTok.Literal)
 	case TokenIdent:
 		// Check if it's a global variable reference (starts with @@)
 		if strings.HasPrefix(p.curTok.Literal, "@@") {
@@ -5917,6 +5931,72 @@ func (p *Parser) parseIdentityFunctionCall() (ast.ScalarExpression, error) {
 	return identity, nil
 }
 
+// parseLeftFunctionCall parses LEFT(string, count)
+func (p *Parser) parseLeftFunctionCall() (ast.ScalarExpression, error) {
+	// Already consumed LEFT, now on (
+	if p.curTok.Type != TokenLParen {
+		return nil, fmt.Errorf("expected ( after LEFT, got %s", p.curTok.Literal)
+	}
+	p.nextToken() // consume (
+
+	var params []ast.ScalarExpression
+
+	// Parse parameters
+	for p.curTok.Type != TokenRParen && p.curTok.Type != TokenEOF {
+		param, err := p.parseScalarExpression()
+		if err != nil {
+			return nil, err
+		}
+		params = append(params, param)
+
+		if p.curTok.Type == TokenComma {
+			p.nextToken() // consume ,
+		} else {
+			break
+		}
+	}
+
+	if p.curTok.Type != TokenRParen {
+		return nil, fmt.Errorf("expected ) in LEFT function, got %s", p.curTok.Literal)
+	}
+	p.nextToken() // consume )
+
+	return &ast.LeftFunctionCall{Parameters: params}, nil
+}
+
+// parseRightFunctionCall parses RIGHT(string, count)
+func (p *Parser) parseRightFunctionCall() (ast.ScalarExpression, error) {
+	// Already consumed RIGHT, now on (
+	if p.curTok.Type != TokenLParen {
+		return nil, fmt.Errorf("expected ( after RIGHT, got %s", p.curTok.Literal)
+	}
+	p.nextToken() // consume (
+
+	var params []ast.ScalarExpression
+
+	// Parse parameters
+	for p.curTok.Type != TokenRParen && p.curTok.Type != TokenEOF {
+		param, err := p.parseScalarExpression()
+		if err != nil {
+			return nil, err
+		}
+		params = append(params, param)
+
+		if p.curTok.Type == TokenComma {
+			p.nextToken() // consume ,
+		} else {
+			break
+		}
+	}
+
+	if p.curTok.Type != TokenRParen {
+		return nil, fmt.Errorf("expected ) in RIGHT function, got %s", p.curTok.Literal)
+	}
+	p.nextToken() // consume )
+
+	return &ast.RightFunctionCall{Parameters: params}, nil
+}
+
 // parsePredictTableReference parses PREDICT(...) in FROM clause
 // PREDICT(MODEL = expression, DATA = table AS alias, RUNTIME=ident) WITH (columns) AS alias
 func (p *Parser) parsePredictTableReference() (*ast.PredictTableReference, error) {