Method ParseSequence

parser/parser.go:908–1028

ParseSequence - Return ast.Sequence (sequence of commands) created from client input after tokenization Parse tokens returned by lexer to structures defines in ast package, and it's responsible for syntax validation.

()

//
// Parse tokens returned by lexer to structures defines in ast package, and it's responsible for syntax validation.
func (parser *Parser) ParseSequence() (*ast.Sequence, error) {
	// Create variable holding sequence/commands
	sequence := &ast.Sequence{}

	for parser.currentToken.Type != token.EOF {
		var command ast.Command
		var err error
		switch parser.currentToken.Type {
		case token.CREATE:
			command, err = parser.parseCreateCommand()
		case token.INSERT:
			command, err = parser.parseInsertCommand()
		case token.UPDATE:
			command, err = parser.parseUpdateCommand()
		case token.SELECT:
			command, err = parser.parseSelectCommand()
		case token.DELETE:
			command, err = parser.parseDeleteCommand()
		case token.DROP:
			command, err = parser.parseDropCommand()
		case token.WHERE:
			lastCommand, parserError := parser.getLastCommand(sequence, token.WHERE)
			if parserError != nil {
				return nil, parserError
			}

			if lastCommand.TokenLiteral() == token.SELECT {
				newCommand, err := parser.parseWhereCommand()
				if err != nil {
					return nil, err
				}
				lastCommand.(*ast.SelectCommand).WhereCommand = newCommand.(*ast.WhereCommand)
			} else if lastCommand.TokenLiteral() == token.DELETE {
				newCommand, err := parser.parseWhereCommand()
				if err != nil {
					return nil, err
				}
				lastCommand.(*ast.DeleteCommand).WhereCommand = newCommand.(*ast.WhereCommand)
			} else if lastCommand.TokenLiteral() == token.UPDATE {
				newCommand, err := parser.parseWhereCommand()
				if err != nil {
					return nil, err
				}
				lastCommand.(*ast.UpdateCommand).WhereCommand = newCommand.(*ast.WhereCommand)
			} else {
				return nil, &SyntaxCommandExpectedError{command: "WHERE", neededCommands: []string{"SELECT", "DELETE", "UPDATE"}}
			}
		case token.ORDER:
			lastCommand, parserError := parser.getLastCommand(sequence, token.ORDER)
			if parserError != nil {
				return nil, parserError
			}

			if lastCommand.TokenLiteral() != token.SELECT {
				return nil, &SyntaxCommandExpectedError{command: "ORDER BY", neededCommands: []string{"SELECT"}}
			}

			selectCommand := lastCommand.(*ast.SelectCommand)