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 Filter(query *parser.SelectQuery, series *protocol.Series) (*protocol.Series, error) {
if query.GetWhereCondition() == nil {
return series, nil
}
columns := map[string]struct{}{}
if query.GetFromClause().Type == parser.FromClauseInnerJoin {
outer:
for t, cs := range query.GetResultColumns() {
for _, c := range cs {
// if this is a wildcard select, then drop all columns and
// just use '*'
if c == "*" {
columns = make(map[string]struct{}, 1)
columns[c] = struct{}{}
break outer
}
columns[t.Name+"."+c] = struct{}{}
}
}
} else {
for _, cs := range query.GetResultColumns() {
for _, c := range cs {
columns[c] = struct{}{}
}
}
}
points := series.Points
series.Points = nil
for _, point := range points {
ok, err := matches(query.GetWhereCondition(), series.Fields, point)
if err != nil {
return nil, err
}
if ok {
filterColumns(columns, series.Fields, point)
series.Points = append(series.Points, point)
}
}
if _, ok := columns["*"]; !ok {
newFields := []string{}
for _, f := range series.Fields {
if _, ok := columns[f]; !ok {
continue
}
newFields = append(newFields, f)
}
series.Fields = newFields
}
return series, nil
}
// Create and return a new JoinEngine given the shards that will be
// processed and the query
func NewJoinEngine(shards []uint32, query *parser.SelectQuery, next Processor) Processor {
tableNames := query.GetFromClause().Names
name := query.GetFromClause().GetString()
log4go.Debug("NewJoinEngine: shards=%v, query=%s, next=%s, tableNames=%v, name=%s",
shards, query.GetQueryString(), next.Name(), tableNames, name)
joinEngine := &JoinEngine{
next: next,
name: name,
tablesState: make([]joinEngineState, len(tableNames)),
tableIdx: make(map[string]int, len(tableNames)),
query: query,
pts: 0,
}
for i, tn := range tableNames {
alias := tn.GetAlias()
joinEngine.tablesState[i] = joinEngineState{}
joinEngine.tableIdx[alias] = i
}
mergeEngine := NewCommonMergeEngine(shards, false, query.Ascending, joinEngine)
return mergeEngine
}
