func gTableParamsRest(fields *[]string, count int) ([]string, error) {
if lexical.T_COMMA == look_ahead {
var errorToken *lexical.TokenError
look_ahead, errorToken = lexical.Token()
if errorToken != nil {
return *fields, errorToken
}
if look_ahead != lexical.T_ID {
return *fields, throwSyntaxError(lexical.T_ID, look_ahead)
}
n := append(*fields, lexical.CurrentLexeme)
fields = &n
look_ahead, errorToken = lexical.Token()
if errorToken != nil {
return *fields, errorToken
}
n, errorSyntax := gTableParamsRest(fields, count+1)
fields = &n
if errorSyntax != nil {
return *fields, errorSyntax
}
}
return *fields, nil
}
func rValue() (NodeExpr, error) {
if look_ahead == lexical.T_PARENTH_L {
token, err := lexical.Token()
if err != nil {
return nil, err
}
look_ahead = token
conds, err2 := gWhereConds()
if err2 != nil {
return nil, err2
}
if look_ahead != lexical.T_PARENTH_R {
return nil, throwSyntaxError(lexical.T_PARENTH_R, look_ahead)
}
token2, err3 := lexical.Token()
if token2 != lexical.T_EOF && err3 != nil {
return nil, err3
}
look_ahead = token2
return conds, nil
}
if look_ahead == lexical.T_ID {
n := new(NodeId)
n.SetValue(lexical.CurrentLexeme)
token2, err := lexical.Token()
if token2 != lexical.T_EOF && err != nil {
return nil, err
}
look_ahead = token2
return n, nil
}
if look_ahead != lexical.T_LITERAL && look_ahead != lexical.T_NUMERIC {
return nil, throwSyntaxError(lexical.T_LITERAL, look_ahead)
}
lexeme := lexical.CurrentLexeme
if look_ahead != lexical.T_LITERAL {
return nil, throwSyntaxError(lexical.T_AND, look_ahead)
}
// @todo inserts IS NULL!
n := new(NodeLiteral)
n.SetValue(lexeme)
token2, err := lexical.Token()
if err != nil && token2 != lexical.T_EOF {
return nil, err
}
look_ahead = token2
return n, nil
}
func gSelect() (*NodeSelect, error) {
if look_ahead != lexical.T_SELECT {
return nil, throwSyntaxError(lexical.T_SELECT, look_ahead)
}
token, err := lexical.Token()
look_ahead = token
if err != nil {
return nil, err
}
s := new(NodeSelect)
// PARAMETERS
fields, err2 := gTableParams()
if err2 != nil {
return nil, err2
}
if len(fields) == 1 && fields[0] == "*" {
s.WildCard = true
}
s.Fields = fields
// TABLES
tables, err4 := gTableNames()
if err4 != nil {
return nil, err4
}
s.Tables = tables
// WHERE
where, err6 := gWhere()
if err6 != nil {
return nil, err6
}
s.Where = where
// ORDER BY
order, err6 := gOrder()
if err6 != nil {
return nil, err6
}
s.Order = order
// LIMIT
var err5 error
s.Limit, err5 = gLimit()
if s.Limit == -1 {
// @todo search default limit from file config
s.Limit = 10
}
if err5 != nil {
return nil, err5
}
return s, nil
}
func gLimit() (int, error) {
if look_ahead != lexical.T_LIMIT {
return -1, nil
}
token, err := lexical.Token()
if err != nil {
return 0, err
}
look_ahead = token
number, numberError := strconv.Atoi(lexical.CurrentLexeme)
if numberError != nil {
return 0, numberError
}
token2, err2 := lexical.Token()
if token2 != lexical.T_EOF && err2 != nil {
return 0, err2
}
look_ahead = token2
return number, nil
}
func gOrder() (*NodeOrder, error) {
if look_ahead == lexical.T_ORDER {
token, err := lexical.Token()
if err != nil {
return nil, err
}
if token != lexical.T_BY {
return nil, throwSyntaxError(lexical.T_BY, token)
}
order := new(NodeOrder)
token, err = lexical.Token()
if err != nil {
return nil, err
}
if token != lexical.T_ID {
return nil, throwSyntaxError(lexical.T_ID, token)
}
order.Field = lexical.CurrentLexeme
token, err = lexical.Token()
if err != nil {
return nil, err
}
if token != lexical.T_ASC && token != lexical.T_DESC {
return nil, throwSyntaxError(lexical.T_ASC, token)
}
order.Asc = (token == lexical.T_ASC)
token, err = lexical.Token()
if err != nil {
return nil, err
}
look_ahead = token
return order, nil
}
return nil, nil
}
func gWhere() (NodeExpr, error) {
if look_ahead != lexical.T_WHERE {
return nil, nil
}
token, err := lexical.Token()
if err != nil {
return nil, err
}
look_ahead = token
conds, err2 := gWhereConds()
return conds, err2
}
func gTableParams() ([]string, error) {
if look_ahead == lexical.T_WILD_CARD {
token, err := lexical.Token()
if err != nil {
return nil, err
}
look_ahead = token
return []string{"*"}, nil
}
var fields = []string{}
if look_ahead == lexical.T_ID {
fields := append(fields, lexical.CurrentLexeme)
token, err := lexical.Token()
if err != nil {
return nil, err
}
look_ahead = token
fields, errorSyntax := gTableParamsRest(&fields, 1)
return fields, errorSyntax
}
return nil, throwSyntaxError(lexical.T_ID, look_ahead)
}
func gTableNames() ([]string, error) {
if look_ahead != lexical.T_FROM {
return nil, throwSyntaxError(lexical.T_FROM, look_ahead)
}
token, error := lexical.Token()
if error != nil {
return nil, error
}
look_ahead = token
if look_ahead != lexical.T_ID {
return nil, throwSyntaxError(lexical.T_ID, look_ahead)
}
tables := make([]string, 1)
tables[0] = lexical.CurrentLexeme
token2, err2 := lexical.Token()
if err2 != nil && token2 != lexical.T_EOF {
return nil, err2
}
look_ahead = token2
return tables, nil
}
// where cond 'equal', 'in' and 'not equal'
func gWC4(eating bool) (NodeExpr, error) {
if eating {
token, err := lexical.Token()
if token != lexical.T_EOF && err != nil {
return nil, err
}
look_ahead = token
}
expr, err := gWC5(false)
if err != nil {
return nil, err
}
switch look_ahead {
case lexical.T_EQUAL:
op := new(NodeEqual)
op.SetLeftValue(expr)
expr2, err2 := gWC4(true)
if err2 != nil {
return nil, err2
}
op.SetRightValue(expr2)
return op, nil
case lexical.T_NOT_EQUAL:
op := new(NodeNotEqual)
op.SetLeftValue(expr)
expr2, err2 := gWC4(true)
if err2 != nil {
return nil, err2
}
op.SetRightValue(expr2)
return op, nil
case lexical.T_IN:
op := new(NodeIn)
op.SetLeftValue(expr)
expr2, err2 := gWC4(true)
if err2 != nil {
return nil, err2
}
op.SetRightValue(expr2)
return op, nil
}
return expr, nil
}
func gProgram() (NodeMain, error) {
token, err := lexical.Token()
look_ahead = token
if err != nil {
return nil, err
}
s, err2 := gSelect()
if s == nil {
return nil, err2
}
if look_ahead != lexical.T_EOF {
return nil, throwSyntaxError(lexical.T_EOF, look_ahead)
}
return s, nil
}
// where cond greater and lesser
func gWC5(eating bool) (NodeExpr, error) {
if eating {
token, err := lexical.Token()
if token != lexical.T_EOF && err != nil {
return nil, err
}
look_ahead = token
}
expr, err := rValue()
if err != nil {
return nil, err
}
switch look_ahead {
case lexical.T_GREATER, lexical.T_GREATER_OR_EQUAL:
op := new(NodeGreater)
op.Equal = (look_ahead == lexical.T_GREATER_OR_EQUAL)
op.SetLeftValue(expr)
expr2, err2 := gWC5(true)
if err2 != nil {
return nil, err2
}
op.SetRightValue(expr2)
return op, nil
case lexical.T_SMALLER, lexical.T_SMALLER_OR_EQUAL:
op := new(NodeSmaller)
op.Equal = (look_ahead == lexical.T_SMALLER_OR_EQUAL)
op.SetLeftValue(expr)
expr2, err2 := gWC5(true)
if err2 != nil {
return nil, err2
}
op.SetRightValue(expr2)
return op, nil
}
return expr, nil
}
// where cond AND
func gWC3(eating bool) (NodeExpr, error) {
if eating {
token, err := lexical.Token()
if token != lexical.T_EOF && err != nil {
return nil, err
}
look_ahead = token
}
expr, err := gWC4(false)
if err != nil {
return nil, err
}
if look_ahead == lexical.T_AND {
and := new(NodeAnd)
and.SetLeftValue(expr)
expr2, err2 := gWC3(true)
if err2 != nil {
return nil, err2
}
and.SetRightValue(expr2)
return and, nil
}
return expr, nil
}
// where cond OR
func gWC2(eating bool) (NodeExpr, error) {
if eating {
token, err := lexical.Token()
if token != lexical.T_EOF && err != nil {
return nil, err
}
look_ahead = token
}
expr, err := gWC3(false)
if err != nil {
return nil, err
}
if look_ahead == lexical.T_OR {
or := new(NodeOr)
or.SetLeftValue(expr)
expr2, err2 := gWC2(true)
if err2 != nil {
return nil, err2
}
or.SetRightValue(expr2)
return or, nil
}
return expr, nil
}
