Reconstruct query strings from the ast

src/common/helpers.go

@@ -6,13 +6,19 @@ import (
 	"os"
 	"protocol"
 	"strconv"
+	"strings"
 	"time"
 	"unicode"
 )
 
 // Returns the parsed duration in nanoseconds, support 'u', 's', 'm',
 // 'h', 'd' and 'w' suffixes.
 func ParseTimeDuration(value string) (int64, error) {
+	// shortcut for nanoseconds
+	if idx := strings.IndexFunc(value, func(r rune) bool { return !unicode.IsNumber(r) }); idx == -1 {
+		return strconv.ParseInt(value, 10, 64)
+	}
+
 	parsedFloat, err := strconv.ParseFloat(value[:len(value)-1], 64)
 	if err != nil {
 		return 0, err

src/coordinator/raft_server.go

@@ -477,7 +477,7 @@ func (s *RaftServer) runContinuousQuery(db string, query *parser.SelectQuery, st
 	clusterAdmin := s.clusterConfig.GetClusterAdmin(adminName)
 	intoClause := query.GetIntoClause()
 	targetName := intoClause.Target.Name
-	queryString := query.GetQueryStringForContinuousQuery(start, end)
+	queryString := query.GetQueryStringWithTimesAndNoIntoClause(start, end)
 
 	f := func(series *protocol.Series) error {
 		return s.coordinator.InterpolateValuesAndCommit(query.GetQueryString(), db, series, targetName, true)

src/parser/from_clause.go

@@ -0,0 +1,65 @@
+package parser
+
+// #include "query_types.h"
+// #include <stdlib.h>
+import "C"
+import (
+	"bytes"
+	"strings"
+)
+import "fmt"
+
+type FromClauseType int
+
+const (
+	FromClauseArray     FromClauseType = C.FROM_ARRAY
+	FromClauseMerge     FromClauseType = C.FROM_MERGE
+	FromClauseInnerJoin FromClauseType = C.FROM_INNER_JOIN
+)
+
+func (self *TableName) GetAlias() string {
+	if self.Alias != "" {
+		return self.Alias
+	}
+	return self.Name.Name
+}
+
+func (self *TableName) GetAliasString() string {
+	if self.Alias != "" {
+		return fmt.Sprintf(" as %s", self.Alias)
+	}
+	return ""
+}
+
+type TableName struct {
+	Name  *Value
+	Alias string
+}
+
+type FromClause struct {
+	Type  FromClauseType
+	Names []*TableName
+}
+
+func (self *FromClause) GetString() string {
+	buffer := bytes.NewBufferString("")
+	switch self.Type {
+	case FromClauseMerge:
+		fmt.Fprintf(buffer, "%s%s merge %s %s", self.Names[0].Name.GetString(), self.Names[1].GetAliasString(),
+			self.Names[1].Name.GetString(), self.Names[1].GetAliasString())
+	case FromClauseInnerJoin:
+		fmt.Fprintf(buffer, "%s%s inner join %s%s", self.Names[0].Name.GetString(), self.Names[0].GetAliasString(),
+			self.Names[1].Name.GetString(), self.Names[1].GetAliasString())
+	default:
+		names := make([]string, 0, len(self.Names))
+		for _, t := range self.Names {
+			alias := ""
+			if t.Alias != "" {
+				alias = fmt.Sprintf(" as %s", t.Alias)
+			}
+			names = append(names, fmt.Sprintf("%s%s", t.Name.GetString(), alias))
+		}
+		buffer.WriteString(strings.Join(names, ","))
+	}
+	return buffer.String()
+}

src/parser/group_by.go

@@ -0,0 +1,46 @@
+package parser
+
+import (
+	"bytes"
+	"common"
+	"fmt"
+	"time"
+)
+
+type GroupByClause struct {
+	FillWithZero bool
+	FillValue    *Value
+	Elems        []*Value
+}
+
+func (self GroupByClause) GetGroupByTime() (*time.Duration, error) {
+	for _, groupBy := range self.Elems {
+		if groupBy.IsFunctionCall() {
+			// TODO: check the number of arguments and return an error
+			if len(groupBy.Elems) != 1 {
+				return nil, common.NewQueryError(common.WrongNumberOfArguments, "time function only accepts one argument")
+			}
+			// TODO: check the function name
+			// TODO: error checking
+			arg := groupBy.Elems[0].Name
+			durationInt, err := common.ParseTimeDuration(arg)
+			if err != nil {
+				return nil, common.NewQueryError(common.InvalidArgument, fmt.Sprintf("invalid argument %s to the time function", arg))
+			}
+			duration := time.Duration(durationInt)
+			return &duration, nil
+		}
+	}
+	return nil, nil
+}
+
+func (self *GroupByClause) GetString() string {
+	buffer := bytes.NewBufferString("")
+
+	buffer.WriteString(Values(self.Elems).GetString())
+
+	if self.FillWithZero {
+		fmt.Fprintf(buffer, " fill(%s)", self.FillValue.GetString())
+	}
+	return buffer.String()
+}