func isAggregateQuery(query *parser.Query) bool {
for _, column := range query.GetColumnNames() {
if column.IsFunctionCall() {
return true
}
}
return false
}
func Filter(query *parser.Query, series *protocol.Series) (*protocol.Series, error) {
if query.GetWhereCondition() == nil {
return series, nil
}
columns := map[string]bool{}
getColumns(query.GetColumnNames(), columns)
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 !columns["*"] {
newFields := []string{}
for _, f := range series.Fields {
if _, ok := columns[f]; !ok {
continue
}
newFields = append(newFields, f)
}
series.Fields = newFields
}
return series, nil
}
func (self *QueryEngine) executeCountQueryWithGroupBy(user common.User, database string, query *parser.Query,
yield func(*protocol.Series) error) error {
duration, err := query.GetGroupByClause().GetGroupByTime()
if err != nil {
return err
}
aggregators := []Aggregator{}
for _, value := range query.GetColumnNames() {
if value.IsFunctionCall() {
lowerCaseName := strings.ToLower(value.Name)
initializer := registeredAggregators[lowerCaseName]
if initializer == nil {
return common.NewQueryError(common.InvalidArgument, fmt.Sprintf("Unknown function %s", value.Name))
}
aggregator, err := initializer(query, value)
if err != nil {
return err
}
aggregators = append(aggregators, aggregator)
}
}
timestampAggregator, err := NewTimestampAggregator(query, nil)
if err != nil {
return err
}
groups := make(map[string]map[interface{}]bool)
groupBy := query.GetGroupByClause()
var inverse InverseMapper
err = self.distributeQuery(user, database, query, func(series *protocol.Series) error {
var mapper Mapper
mapper, inverse, err = createValuesToInterface(groupBy, series.Fields)
if err != nil {
return err
}
for _, aggregator := range aggregators {
if err := aggregator.InitializeFieldsMetadata(series); err != nil {
return err
}
}
for _, point := range series.Points {
value := mapper(point)
for _, aggregator := range aggregators {
aggregator.AggregatePoint(*series.Name, value, point)
}
timestampAggregator.AggregatePoint(*series.Name, value, point)
seriesGroups := groups[*series.Name]
if seriesGroups == nil {
seriesGroups = make(map[interface{}]bool)
groups[*series.Name] = seriesGroups
}
seriesGroups[value] = true
}
return nil
})
if err != nil {
return err
}
var sequenceNumber uint32 = 1
fields := []string{}
for _, aggregator := range aggregators {
columnName := aggregator.ColumnName()
fields = append(fields, columnName)
}
for _, value := range groupBy {
if value.IsFunctionCall() {
continue
}
tempName := value.Name
fields = append(fields, tempName)
}
for table, tableGroups := range groups {
tempTable := table
points := []*protocol.Point{}
for groupId, _ := range tableGroups {
timestamp := *timestampAggregator.GetValue(table, groupId)[0].Int64Value
values := [][]*protocol.FieldValue{}
for _, aggregator := range aggregators {
values = append(values, aggregator.GetValue(table, groupId))
}
// do cross product of all the values
values = crossProduct(values)
for _, v := range values {
/* groupPoints := []*protocol.Point{} */
point := &protocol.Point{
SequenceNumber: &sequenceNumber,
Values: v,
}
point.SetTimestampInMicroseconds(timestamp)
// FIXME: this should be looking at the fields slice not the group by clause
// FIXME: we should check whether the selected columns are in the group by clause
for idx, _ := range groupBy {
if duration != nil && idx == 0 {
continue
}
value := inverse(groupId, idx)
switch x := value.(type) {
case string:
point.Values = append(point.Values, &protocol.FieldValue{StringValue: &x})
case bool:
point.Values = append(point.Values, &protocol.FieldValue{BoolValue: &x})
case float64:
point.Values = append(point.Values, &protocol.FieldValue{DoubleValue: &x})
case int64:
point.Values = append(point.Values, &protocol.FieldValue{Int64Value: &x})
}
}
points = append(points, point)
}
}
expectedData := &protocol.Series{
Name: &tempTable,
Fields: fields,
Points: points,
}
yield(expectedData)
}
return nil
}