Method parseWithRecovery

pkg/sql/parser/recovery.go:179–229

parseWithRecovery is the internal implementation shared by both public APIs. It expects a preprocessed []models.TokenWithSpan (output of preprocessTokens).

(tokens []models.TokenWithSpan)

// parseWithRecovery is the internal implementation shared by both public APIs.
// It expects a preprocessed []models.TokenWithSpan (output of preprocessTokens).
func (p *Parser) parseWithRecovery(tokens []models.TokenWithSpan) ([]ast.Statement, []error) {
	p.tokens = tokens
	p.currentPos = 0
	if len(tokens) > 0 {
		p.currentToken = tokens[0]
	}

	statements := make([]ast.Statement, 0, 8)
	errors := make([]error, 0, 4)

	for p.currentPos < len(tokens) && !p.isType(models.TokenTypeEOF) {
		// Skip semicolons between statements
		if p.isType(models.TokenTypeSemicolon) {
			p.advance()
			continue
		}

		stmtStartPos := p.currentPos
		stmt, err := p.parseStatement()
		if err != nil {
			// Create a ParseError with position info, preserving original error
			loc := p.currentLocation()
			pe := &ParseError{
				Msg:      err.Error(),
				TokenIdx: stmtStartPos,
				Line:     loc.Line,
				Column:   loc.Column,
				Cause:    err,
			}
			if stmtStartPos < len(tokens) {
				pe.TokenType = tokens[stmtStartPos].Token.Type.String()
				pe.Literal = tokens[stmtStartPos].Token.Value
			}
			errors = append(errors, pe)
			// If parseStatement didn't advance (e.g., unrecognized keyword),
			// advance at least one token to avoid infinite loops.
			if p.currentPos == stmtStartPos {
				p.advance()
			}
			p.synchronize()
		} else {
			statements = append(statements, stmt)
			// Optionally consume semicolon after statement
			if p.isType(models.TokenTypeSemicolon) {
				p.advance()
			}
		}
	}

	return statements, errors
}