Method parseWithStatement

pkg/sql/parser/cte.go:29–107

WITH summary(region, total) AS (SELECT region, SUM(amount) FROM sales GROUP BY region) SELECT * FROM summary

()

// WITH summary(region, total) AS (SELECT region, SUM(amount) FROM sales GROUP BY region) SELECT * FROM summary
func (p *Parser) parseWithStatement() (ast.Statement, error) {
	withPos := p.currentLocation()
	// Consume WITH
	p.advance()

	// Check for RECURSIVE keyword
	recursive := false
	if p.isType(models.TokenTypeRecursive) {
		recursive = true
		p.advance()
	}

	// Parse Common Table Expressions
	ctes := []*ast.CommonTableExpr{}

	for {
		cte, err := p.parseCommonTableExpr()
		if err != nil {
			return nil, goerrors.InvalidCTEError(
				fmt.Sprintf("error parsing CTE definition: %v", err),
				p.currentLocation(),
				"",
			)
		}
		ctes = append(ctes, cte)

		// Check for more CTEs (comma-separated)
		if p.isType(models.TokenTypeComma) {
			p.advance() // Consume comma
			continue
		}
		break
	}

	// Create WITH clause
	withClause := &ast.WithClause{
		Recursive: recursive,
		CTEs:      ctes,
		Pos:       withPos,
	}

	// Parse the main statement that follows the WITH clause
	mainStmt, err := p.parseMainStatementAfterWith()
	if err != nil {
		return nil, goerrors.InvalidCTEError(
			fmt.Sprintf("error parsing statement after WITH clause: %v", err),
			p.currentLocation(),
			"",
		)
	}

	// Attach WITH clause to the main statement
	switch stmt := mainStmt.(type) {
	case *ast.SelectStatement:
		stmt.With = withClause
		return stmt, nil
	case *ast.SetOperation:
		// For set operations, attach WITH to the left statement if it's a SELECT