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 }