func (m *filterQLParser) parseFilterClause(depth int, negate bool) (*FilterExpr, error) {
fe := NewFilterExpr()
fe.Negate = negate
//u.Debugf("%d filterclause? negate?%v cur=%v", depth, negate, m.Cur())
switch m.Cur().T {
case lex.TokenInclude:
// embed/include a named filter
m.Next()
//u.Infof("type %v", m.Cur())
if m.Cur().T != lex.TokenIdentity && m.Cur().T != lex.TokenValue {
return nil, fmt.Errorf("Expected identity for Include but got %v", m.Cur())
}
fe.Include = m.Cur().V
m.Next()
case lex.TokenUdfExpr:
// we have a udf/functional expression filter
tree := expr.NewTree(m.filterTokenPager)
if err := m.parseNode(tree); err != nil {
u.Errorf("could not parse: %v", err)
return nil, err
}
fe.Expr = tree.Root
case lex.TokenIdentity, lex.TokenLike, lex.TokenExists, lex.TokenBetween,
lex.TokenIN, lex.TokenIntersects, lex.TokenValue, lex.TokenContains:
if m.Cur().T == lex.TokenIdentity {
if strings.ToLower(m.Cur().V) == "include" {
// TODO: this is a bug in lexer ...
// embed/include a named filter
m.Next()
if m.Cur().T != lex.TokenIdentity && m.Cur().T != lex.TokenValue {
return nil, fmt.Errorf("Expected identity for Include but got %v", m.Cur())
}
fe.Include = m.Cur().V
m.Next()
return fe, nil
}
}
tree := expr.NewTree(m.filterTokenPager)
if err := m.parseNode(tree); err != nil {
u.Errorf("could not parse: %v", err)
return nil, err
}
fe.Expr = tree.Root
if !m.fs.HasDateMath {
m.fs.HasDateMath = expr.HasDateMath(fe.Expr)
}
default:
return nil, fmt.Errorf("Expected clause but got %v", m.Cur())
}
return fe, nil
}
func (m *filterQLParser) parseWhereExpr(req *FilterSelect) error {
tree := expr.NewTree(m.filterTokenPager)
if err := m.parseNode(tree); err != nil {
u.Errorf("could not parse: %v", err)
return err
}
fe := FilterExpr{Expr: tree.Root}
filters := Filters{Op: lex.TokenAnd, Filters: []*FilterExpr{&fe}}
req.Filter = &filters
return nil
}