func mustParseStatement(s string) influxql.Statement {
stmt, err := influxql.ParseStatement(s)
if err != nil {
panic(err)
}
return stmt
}
func main() {
args := os.Args
if len(args) != 2 && len(args) != 3 {
log.Fatalln("Usage: " + os.Args[0] + " NUM_PRODUCTIONS [PRODUCTION=statement]")
}
numProductions, err := strconv.Atoi(args[1])
if err != nil {
log.Fatalln(err)
}
production := "statement"
if len(args) == 3 {
production = args[2]
}
grammar, err := rebnf.Parse("influxql.ebnf", nil)
if err != nil {
log.Fatalln(err)
}
if _, ok := grammar[production]; !ok {
log.Fatalln(production + " is not a known production!")
}
maxRepetitions := 30
maxRecursionDepth := 15
padding := "???"
isDebug := false
ctx := rebnf.NewCtx(maxRepetitions, maxRecursionDepth, padding, isDebug)
for i := 0; i < numProductions; i++ {
buf := new(bytes.Buffer)
ctx.Random(buf, grammar, production)
line, _ := ioutil.ReadAll(buf)
fmt.Println("GENERATED: " + string(line))
if stmt, err := influxql.ParseStatement(string(line)); err != nil {
fmt.Fprintln(os.Stderr, "ERROR : "+err.Error())
} else {
sanitized := stmt.String()
fmt.Println("SANITIZED: " + sanitized)
resanitized := influxql.MustParseStatement(sanitized).String()
if resanitized != sanitized {
fmt.Println("IMPURE : " + resanitized)
}
}
fmt.Println()
}
}
func NewQuery(q string) (*Query, error) {
query := &Query{}
// Parse and validate query
stmt, err := influxql.ParseStatement(q)
if err != nil {
return nil, err
}
var ok bool
query.stmt, ok = stmt.(*influxql.SelectStatement)
if !ok {
return nil, fmt.Errorf("query is not a select statement %q", q)
}
// Add in time condition nodes
query.startTL = &influxql.TimeLiteral{}
startExpr := &influxql.BinaryExpr{
Op: influxql.GT,
LHS: &influxql.VarRef{Val: "time"},
RHS: query.startTL,
}
query.stopTL = &influxql.TimeLiteral{}
stopExpr := &influxql.BinaryExpr{
Op: influxql.LT,
LHS: &influxql.VarRef{Val: "time"},
RHS: query.stopTL,
}
if query.stmt.Condition != nil {
query.stmt.Condition = &influxql.BinaryExpr{
Op: influxql.AND,
LHS: query.stmt.Condition,
RHS: &influxql.BinaryExpr{
Op: influxql.AND,
LHS: startExpr,
RHS: stopExpr,
},
}
} else {
query.stmt.Condition = &influxql.BinaryExpr{
Op: influxql.AND,
LHS: startExpr,
RHS: stopExpr,
}
}
return query, nil
}
func (r *Service) doRecordQuery(rid uuid.UUID, q string, tt kapacitor.TaskType) error {
// Parse query to determine dbrp
var db, rp string
s, err := influxql.ParseStatement(q)
if err != nil {
return err
}
if slct, ok := s.(*influxql.SelectStatement); ok && len(slct.Sources) == 1 {
if m, ok := slct.Sources[0].(*influxql.Measurement); ok {
db = m.Database
rp = m.RetentionPolicy
}
}
if db == "" || rp == "" {
return errors.New("could not determine database and retention policy. Is the query fully qualified?")
}
// Query InfluxDB
con, err := r.InfluxDBService.NewClient()
if err != nil {
return err
}
query := client.Query{
Command: q,
}
resp, err := con.Query(query)
if err != nil {
return err
}
if resp.Err != nil {
return resp.Err
}
// Open appropriate writer
var w io.Writer
var c io.Closer
switch tt {
case kapacitor.StreamTask:
sw, err := r.newStreamWriter(rid)
if err != nil {
return err
}
w = sw
c = sw
case kapacitor.BatchTask:
archive, err := r.newBatchArchive(rid)
if err != nil {
return err
}
w, err = archive.Create(0)
if err != nil {
return err
}
c = archive
}
// Write results to writer
for _, res := range resp.Results {
batches, err := models.ResultToBatches(res)
if err != nil {
c.Close()
return err
}
for _, batch := range batches {
switch tt {
case kapacitor.StreamTask:
for _, bp := range batch.Points {
p := models.Point{
Name: batch.Name,
Database: db,
RetentionPolicy: rp,
Tags: bp.Tags,
Fields: bp.Fields,
Time: bp.Time,
}
kapacitor.WritePointForRecording(w, p, precision)
}
case kapacitor.BatchTask:
kapacitor.WriteBatchForRecording(w, batch)
}
}
}
return c.Close()
}