Merge pull request #57 from runreveal/ej/claude-did-render

Render

Author: ejcx

parser/ast.go

@@ -578,6 +578,52 @@ func (stmt *LetStatement) Span() Span {
 	return unionSpans(stmt.Keyword, stmt.Name.Span(), stmt.Assign, xSpan)
 }
 
+// RenderOperator represents a `| render` operator in a [TabularExpr].
+// It implements [TabularOperator].
+type RenderOperator struct {
+	Pipe      Span
+	Keyword   Span
+	ChartType *Ident
+
+	// Optional properties
+	With   Span // Span for 'with' keyword if present
+	Lparen Span // Opening parenthesis for properties
+	Props  []*RenderProperty
+	Rparen Span // Closing parenthesis for properties
+}
+
+// RenderProperty represents a single property in the render operator's
+// with clause, like "title='My Chart'" or "kind=stacked"
+type RenderProperty struct {
+	Name   *Ident
+	Assign Span
+	Value  Expr
+}
+
+func (op *RenderProperty) Span() Span {
+	if op == nil {
+		return nullSpan()
+	}
+	return unionSpans(op.Name.Span(), op.Assign, nodeSpan(op.Value))
+}
+
+func (op *RenderOperator) tabularOperator() {}
+
+func (op *RenderOperator) Span() Span {
+	if op == nil {
+		return nullSpan()
+	}
+	return unionSpans(
+		op.Pipe,
+		op.Keyword,
+		op.ChartType.Span(),
+		op.With,
+		op.Lparen,
+		nodeSliceSpan(op.Props),
+		op.Rparen,
+	)
+}
+
 // Walk traverses an AST in depth-first order.
 // If the visit function returns true for a node,
 // the visit function will be called for its children.
@@ -720,6 +766,17 @@ func Walk(n Node, visit func(n Node) bool) {
 				stack = append(stack, n.X)
 				stack = append(stack, n.Name)
 			}
+		// Add to Walk function's switch statement:
+		case *RenderOperator:
+			if visit(n) {
+				stack = append(stack, n.ChartType)
+				for i := len(n.Props) - 1; i >= 0; i-- {
+					if n.Props[i].Value != nil {
+						stack = append(stack, n.Props[i].Value)
+					}
+					stack = append(stack, n.Props[i].Name)
+				}
+			}
 		default:
 			panic(fmt.Errorf("unknown Node type %T", n))
 		}

parser/parser.go

@@ -233,6 +233,13 @@ func (p *parser) tabularExpr() (*TabularExpr, error) {
 				expr.Operators = append(expr.Operators, op)
 			}
 			finalError = joinErrors(finalError, err)
+		case "render":
+			op, err := opParser.renderOperator(pipeToken, operatorName)
+			if op != nil {
+				expr.Operators = append(expr.Operators, op)
+			}
+			finalError = joinErrors(finalError, err)
+
 		default:
 			finalError = joinErrors(finalError, &parseError{
 				source: opParser.source,
@@ -495,6 +502,110 @@ func (p *parser) extendOperator(pipe, keyword Token) (*ExtendOperator, error) {
 	}
 }
 
+func (p *parser) renderOperator(pipe, keyword Token) (*RenderOperator, error) {
+	op := &RenderOperator{
+		Pipe:    pipe.Span,
+		Keyword: keyword.Span,
+		With:    nullSpan(),
+		Lparen:  nullSpan(),
+		Rparen:  nullSpan(),
+	}
+
+	// Parse chart type (required)
+	chartType, err := p.ident()
+	if err != nil {
+		return op, &parseError{
+			source: p.source,
+			span:   keyword.Span,
+			err:    fmt.Errorf("expected chart type after render, got %v", err),
+		}
+	}
+	op.ChartType = chartType
+
+	// Look for optional "with" clause
+	tok, ok := p.next()
+	if !ok {
+		return op, nil
+	}
+
+	if tok.Kind != TokenIdentifier || tok.Value != "with" {
+		p.prev()
+		return op, nil
+	}
+	op.With = tok.Span
+
+	// Parse opening parenthesis
+	tok, _ = p.next()
+	if tok.Kind != TokenLParen {
+		return op, &parseError{
+			source: p.source,
+			span:   tok.Span,
+			err:    fmt.Errorf("expected '(' after with, got %s", formatToken(p.source, tok)),
+		}
+	}
+	op.Lparen = tok.Span
+
+	// Parse properties
+	for {
+		prop, err := p.renderProperty()
+		if err != nil {
+			return op, makeErrorOpaque(err)
+		}
+		if prop != nil {
+			op.Props = append(op.Props, prop)
+		}
+
+		// Check for comma or closing parenthesis
+		tok, _ = p.next()
+		if tok.Kind == TokenRParen {
+			op.Rparen = tok.Span
+			break
+		}
+		if tok.Kind != TokenComma {
+			return op, &parseError{
+				source: p.source,
+				span:   tok.Span,
+				err:    fmt.Errorf("expected ',' or ')', got %s", formatToken(p.source, tok)),
+			}
+		}
+	}
+
+	return op, nil
+}
+
+func (p *parser) renderProperty() (*RenderProperty, error) {
+	prop := &RenderProperty{
+		Assign: nullSpan(),
+	}
+
+	// Parse property name
+	name, err := p.ident()
+	if err != nil {
+		return nil, err
+	}
+	prop.Name = name
+
+	// Parse equals sign
+	tok, _ := p.next()
+	if tok.Kind != TokenAssign {
+		return nil, &parseError{
+			source: p.source,
+			span:   tok.Span,
+			err:    fmt.Errorf("expected '=' after property name, got %s", formatToken(p.source, tok)),
+		}
+	}
+	prop.Assign = tok.Span
+
+	// Parse property value
+	value, err := p.expr()
+	if err != nil {
+		return nil, err
+	}
+	prop.Value = value
+
+	return prop, nil
+}
+
 func (p *parser) extendColumn() (*ExtendColumn, error) {
 	restorePos := p.pos
 

pql.go

@@ -296,6 +296,8 @@ func canAttachSort(op parser.TabularOperator) bool {
 	switch op.(type) {
 	case *parser.ProjectOperator, *parser.SummarizeOperator, *parser.AsOperator:
 		return false
+	case *parser.RenderOperator:
+		return false
 	default:
 		return true
 	}
@@ -463,6 +465,33 @@ func (sub *subquery) write(ctx *exprContext, sb *strings.Builder) error {
 	case *parser.CountOperator:
 		sb.WriteString(`SELECT COUNT(*) AS "count()" FROM `)
 		sb.WriteString(sub.sourceSQL)
+	case *parser.RenderOperator:
+		// First, write the source data
+		sb.WriteString("SELECT *,\n")
+		// Then add our render-specific metadata columns
+		sb.WriteString("    '")
+		sb.WriteString(op.ChartType.Name)
+		sb.WriteString("' as \"render_type\"")
+
+		// Add render properties with standardized prefixes
+		for _, prop := range op.Props {
+			sb.WriteString(",\n    ")
+			// Quote all values as strings since they're instructions for the renderer
+			sb.WriteString("'")
+			if lit, ok := prop.Value.(*parser.BasicLit); ok {
+				// Use the literal value directly
+				sb.WriteString(lit.Value)
+			} else if id, ok := prop.Value.(*parser.QualifiedIdent); ok {
+				// Use the identifier name
+				sb.WriteString(id.Parts[0].Name)
+			}
+			sb.WriteString("' as \"render_prop_")
+			sb.WriteString(prop.Name.Name)
+			sb.WriteString("\"")
+		}
+
+		sb.WriteString("\nFROM ")
+		sb.WriteString(sub.sourceSQL)
 	default:
 		fmt.Fprintf(sb, "SELECT NULL /* unsupported operator %T */", op)
 		return nil

testdata/Goldens/Render/input.pql

@@ -0,0 +1,10 @@
+StormEvents 
+| project State, EventType, DamageProperty
+| summarize TotalDamage=sum(DamageProperty) by State
+| sort by TotalDamage desc 
+| limit 10
+| render barchart with (
+    title="Property Damage by State",
+    xtitle="State",
+    ytitle="Total Damage ($)"
+)

testdata/Goldens/Render/output.csv

@@ -0,0 +1,5 @@
+State,TotalDamage,render_type,render_prop_title,render_prop_xtitle,render_prop_ytitle
+FLORIDA,6200000,barchart,Property Damage by State,State,Total Damage ($)
+MISSISSIPPI,20000,barchart,Property Damage by State,State,Total Damage ($)
+GEORGIA,2000,barchart,Property Damage by State,State,Total Damage ($)
+ATLANTIC SOUTH,0,barchart,Property Damage by State,State,Total Damage ($)

testdata/Goldens/Render/output.sql

@@ -0,0 +1,9 @@
+WITH "__subquery0" AS (SELECT "State" AS "State", "EventType" AS "EventType", "DamageProperty" AS "DamageProperty" FROM "StormEvents"),
+     "__subquery1" AS (SELECT "State" AS "State", sum("DamageProperty") AS "TotalDamage" FROM "__subquery0" GROUP BY "State"),
+     "__subquery2" AS (SELECT * FROM "__subquery1" ORDER BY "TotalDamage" DESC NULLS LAST LIMIT 10)
+SELECT *,
+    'barchart' as "render_type",
+    'Property Damage by State' as "render_prop_title",
+    'State' as "render_prop_xtitle",
+    'Total Damage ($)' as "render_prop_ytitle"
+FROM "__subquery2";