func NewQueryEngine(next Processor, query *parser.SelectQuery, shards []uint32) (Processor, error) { limit := query.Limit var engine Processor = NewPassthroughEngineWithLimit(next, 1, limit) var err error if query.HasAggregates() { engine, err = NewAggregatorEngine(query, engine) } else if query.ContainsArithmeticOperators() { engine, err = NewArithmeticEngine(query, engine) } fromClause := query.GetFromClause() switch fromClause.Type { case parser.FromClauseInnerJoin: engine = NewJoinEngine(shards, query, engine) case parser.FromClauseMerge: tables := make([]string, len(fromClause.Names)) for i, name := range fromClause.Names { tables[i] = name.Name.Name } engine = NewMergeEngine(shards, query.Ascending, engine) case parser.FromClauseMergeRegex: // At this point the regex should be expanded to the list of // tables that will be queries panic("QueryEngine cannot be called with merge function") } if err != nil { return nil, err } return engine, nil }
func NewQueryEngine(query *parser.SelectQuery, responseChan chan *protocol.Response) (*QueryEngine, error) { limit := query.Limit queryEngine := &QueryEngine{ query: query, where: query.GetWhereCondition(), limiter: NewLimiter(limit), responseChan: responseChan, seriesToPoints: make(map[string]*protocol.Series), // stats stuff explain: query.IsExplainQuery(), runStartTime: 0, runEndTime: 0, pointsRead: 0, pointsWritten: 0, shardId: 0, shardLocal: false, //that really doesn't matter if it is not EXPLAIN query duration: nil, seriesStates: make(map[string]*SeriesState), } if queryEngine.explain { queryEngine.runStartTime = float64(time.Now().UnixNano()) / float64(time.Millisecond) } yield := func(series *protocol.Series) error { var response *protocol.Response queryEngine.limiter.calculateLimitAndSlicePoints(series) if len(series.Points) == 0 { return nil } if queryEngine.explain { //TODO: We may not have to send points, just count them queryEngine.pointsWritten += int64(len(series.Points)) } response = &protocol.Response{Type: &queryResponse, Series: series} responseChan <- response return nil } var err error if query.HasAggregates() { err = queryEngine.executeCountQueryWithGroupBy(query, yield) } else if containsArithmeticOperators(query) { err = queryEngine.executeArithmeticQuery(query, yield) } else { err = queryEngine.distributeQuery(query, yield) } if err != nil { return nil, err } return queryEngine, nil }
func NewQueryEngine(next Processor, query *parser.SelectQuery) (Processor, error) { limit := query.Limit var engine Processor = NewPassthroughEngineWithLimit(next, 1, limit) var err error if query.HasAggregates() { engine, err = NewAggregatorEngine(query, engine) } else if query.ContainsArithmeticOperators() { engine, err = NewArithmeticEngine(query, engine) } fromClause := query.GetFromClause() if fromClause.Type == parser.FromClauseMerge { engine = NewMergeEngine(fromClause.Names[0].Name.Name, fromClause.Names[1].Name.Name, query.Ascending, engine) } else if fromClause.Type == parser.FromClauseInnerJoin { engine = NewJoinEngine(query, engine) } if err != nil { return nil, err } return engine, nil }