sqv-engine/sql/parser.go

package sql

import (
	"fmt"
	"io"
	"slices"
)

type Parser struct {
	s   *Lexer
	buf LexRes
}

type LexRes struct {
	pos   Position
	tok   Token
	lit   string
	avail bool
}

func NewParser(r io.Reader) *Parser {
	return &Parser{s: NewLexer(r)}
}

func (p *Parser) Parse() (Statement, error) {
	tok, ok := p.expectOne(CREATE, EOF)
	if !ok {
		return nil, p.unexpectedToken(CREATE, EOF)
	} else if tok == EOF {
		return nil, io.EOF
	}

	if !p.expectNext(TABLE) {
		return nil, p.unexpectedToken()
	}

	tok, ok = p.expectOne(IDENT, IF)
	if !ok {
		return nil, p.unexpectedToken(IDENT, IF)
	} else if tok == IF && !p.expectSequence(NOT, EXISTS, IDENT) {
		return nil, p.unexpectedToken()
	}
	_, _, lit := p.rescan()

	stmt := CreateTableStatement{
		TableName: lit,
		Columns:   make([]Column, 0),
	}

	if !p.expectNext(LPAREN) {
		return nil, p.unexpectedToken(LPAREN)
	}

	for {
		_, tok, _ := p.scan()

		switch tok {
		case RPAREN:
			if !p.expectNext(SEMI) {
				return nil, p.unexpectedToken(SEMI)
			}
			return &stmt, nil

		case IDENT:
			column, err := p.parseColumn()
			if err != nil {
				return nil, err
			}
			stmt.Columns = append(stmt.Columns, column)

		case FOREIGN:
			if !p.expectSequence(KEY, LPAREN, IDENT) {
				return nil, p.unexpectedToken()
			}
			_, _, columnName := p.rescan()

			if !p.expectSequence(RPAREN, REFERENCES) {
				return nil, p.unexpectedToken()
			}

			ref, err := p.references()
			if err != nil {
				return nil, err
			}

			column := slices.IndexFunc(stmt.Columns, func(c Column) bool {
				return c.Name == columnName
			})

			stmt.Columns[column].Extra = append(stmt.Columns[column].Extra, ref)

		case PRIMARY:
			if !p.expectSequence(KEY, LPAREN, IDENT) {
				return nil, p.unexpectedToken()
			}
			primaryKeyNames := make([]string, 0)
			_, _, columnName := p.rescan()
			primaryKeyNames = append(primaryKeyNames, columnName)

			for {
				tok, ok := p.expectOne(RPAREN, COMMA)
				if !ok {
					return nil, p.unexpectedToken()
				}
				if tok == RPAREN {
					break
				}

				if !p.expectNext(IDENT) {
					return nil, p.unexpectedToken()
				}

				_, _, columnName := p.rescan()
				primaryKeyNames = append(primaryKeyNames, columnName)
			}

			for _, pkName := range primaryKeyNames {
				column := slices.IndexFunc(stmt.Columns, func(c Column) bool {
					return c.Name == pkName
				})
				stmt.Columns[column].Extra = append(stmt.Columns[column].Extra, "PRIMARY_KEY")
			}

		case COMMA:
			continue

		default:
			return nil, p.unexpectedToken(IDENT, RPAREN, FOREIGN, COMMA)
		}
	}
}

func (p *Parser) parseColumn() (Column, error) {
	_, _, lit := p.rescan()
	column := Column{Name: lit, Extra: make([]string, 0)}

	if _, ok := p.expectOne(TEXT, INTEGER, REAL, BLOB); !ok {
		return Column{}, p.unexpectedToken(TEXT, INTEGER, REAL, BLOB)
	}
	_, _, column.Type = p.rescan()

	for {
		_, tok, lit := p.scan()
		switch tok {
		case COMMA:
			return column, nil
		case RPAREN:
			p.unscan()
			return column, nil

		case PRIMARY:
			fallthrough
		case NOT:
			if _, ok := p.expectOne(NULL, KEY); !ok {
				return Column{}, p.unexpectedToken(NULL, KEY)
			}
			_, _, rlit := p.rescan()
			column.Extra = append(column.Extra, fmt.Sprintf("%v_%v", lit, rlit))

		case REFERENCES:
			ref, err := p.references()
			if err != nil {
				return Column{}, err
			}
			column.Extra = append(column.Extra, ref)
			fmt.Println(ref)

		default:
			return Column{}, p.unexpectedToken(COMMA, RPAREN, PRIMARY, NOT, REFERENCES)
		}
	}
}

func (p *Parser) unexpectedToken(expected ...Token) error {
	l := len(expected)
	pos, tok, lit := p.rescan()
	if l <= 0 {
		return fmt.Errorf("Encountered unexpected token: %v lit: '%v' on pos: %v", tok, lit, pos)
	} else if l == 1 {
		return fmt.Errorf(
			"Encountered unexpected token: %v lit: '%v' on pos: %v, expected %v",
			tok,
			lit,
			pos,
			expected[0],
		)
	} else {
		return fmt.Errorf(
			"Encountered unexpected token: %v lit: '%v' on pos: %v, expected one of '%v'",
			tok,
			lit,
			pos,
			arrayToString(expected, ", "),
		)
	}
}

func (p *Parser) references() (string, error) {
	if !p.expectNext(IDENT) {
		return "", p.unexpectedToken(IDENT)
	}
	_, _, referenceTableName := p.rescan()

	if !p.expectSequence(LPAREN, IDENT) {
		return "", p.unexpectedToken()
	}

	_, _, referenceColumnName := p.rescan()

	if !p.expectNext(RPAREN) {
		return "", p.unexpectedToken(RPAREN)
	}

	return fmt.Sprintf("ref %v.%v", referenceTableName, referenceColumnName), nil
}

func (p *Parser) expectSequence(token ...Token) bool {
	for _, tok := range token {
		if !p.expectNext(tok) {
			return false
		}
	}

	return true
}

func (p *Parser) expectNext(token Token) bool {
	_, tok, _ := p.scan()
	return tok == token
}

func (p *Parser) expectOne(token ...Token) (Token, bool) {
	_, tok, _ := p.scan()
	ok := slices.ContainsFunc(token, func(t Token) bool {
		return tok == t
	})
	return tok, ok
}

func (p *Parser) scan() (Position, Token, string) {
	if p.buf.avail {
		p.buf.avail = false
		return p.buf.pos, p.buf.tok, p.buf.lit
	}

	pos, tok, lit := p.s.Lex()

	p.buf.pos, p.buf.tok, p.buf.lit = pos, tok, lit
	return pos, tok, lit
}

func (p *Parser) unscan() {
	p.buf.avail = true
}

func (p *Parser) rescan() (Position, Token, string) {
	p.unscan()
	return p.scan()
}