136 lines
4.2 KiB
Go
136 lines
4.2 KiB
Go
// Package database define database operation functions
|
|
package database
|
|
|
|
import (
|
|
"fmt"
|
|
"strings"
|
|
)
|
|
|
|
// InfluxDBQueryPara define struct of influxdb query parameters
|
|
type InfluxDBQueryPara struct {
|
|
Bucket string `json:"bucket"`
|
|
Measurement string `json:"measurement"`
|
|
Start string `json:"start"`
|
|
Stop string `json:"stop"`
|
|
Field string `json:"field"`
|
|
// Value float64 `json:"value"`
|
|
}
|
|
|
|
// QueryPara define influxdb query parameters interface
|
|
type QueryPara interface {
|
|
apply(string) string
|
|
}
|
|
|
|
// BucketQueryPara define influxdb bucket query parameter
|
|
type BucketQueryPara string
|
|
|
|
func (b BucketQueryPara) apply(query string) string {
|
|
template := " from(bucket:\"{bucketId}\") "
|
|
template = strings.Replace(template, "{bucketId}", string(b), -1)
|
|
return query + template
|
|
}
|
|
|
|
// WithBucket define func of set bucket parameter in query statment
|
|
func WithBucket(bucketID string) BucketQueryPara {
|
|
return BucketQueryPara(bucketID)
|
|
}
|
|
|
|
// MeasurementQueryPara define influxdb measurement query parameter
|
|
type MeasurementQueryPara string
|
|
|
|
func (m MeasurementQueryPara) apply(query string) string {
|
|
template := " |> filter(fn: (r) => r[\"_measurement\"] == \"{measurement}\") "
|
|
template = strings.Replace(template, "{measurement}", string(m), -1)
|
|
return query + template
|
|
}
|
|
|
|
// WithMeasurement define func of set measurement parameter in query statment
|
|
func WithMeasurement(measurement string) MeasurementQueryPara {
|
|
return MeasurementQueryPara(measurement)
|
|
}
|
|
|
|
// RangeTimeQueryPara define influxdb range query parameter
|
|
type RangeTimeQueryPara struct {
|
|
StartTime string
|
|
StopTime string
|
|
}
|
|
|
|
func (r RangeTimeQueryPara) apply(query string) string {
|
|
template := " |> range(start: {start}, stop: {stop}) "
|
|
template = strings.Replace(template, "{start}", r.StartTime, -1)
|
|
template = strings.Replace(template, "{stop}", r.StopTime, -1)
|
|
return query + template
|
|
}
|
|
|
|
// WithRangeTime define func of set range parameter in query statment
|
|
func WithRangeTime(startTime, stopTime string) RangeTimeQueryPara {
|
|
return RangeTimeQueryPara{StartTime: startTime, StopTime: stopTime}
|
|
}
|
|
|
|
// FieldQueryPara define influxdb field query parameter
|
|
type FieldQueryPara struct {
|
|
Fields []string
|
|
Operator string
|
|
}
|
|
|
|
func (f FieldQueryPara) apply(query string) string {
|
|
fieldTemplate := "r[\"_field\"] == \"{value}\""
|
|
filterTemplate := " |> filter(fn: (r) => {field_template}) "
|
|
fieldBuilder := strings.Builder{}
|
|
for index, field := range f.Fields {
|
|
if index > 0 {
|
|
operator := " " + f.Operator + " "
|
|
fieldBuilder.Write([]byte(operator))
|
|
}
|
|
filedContent := strings.Replace(fieldTemplate, "{value}", field, -1)
|
|
fieldBuilder.Write([]byte(filedContent))
|
|
}
|
|
filterTemplate = strings.Replace(filterTemplate, "{field_template}", fieldBuilder.String(), -1)
|
|
return query + filterTemplate
|
|
}
|
|
|
|
// WithField define func of set field parameter in query statment
|
|
func WithField(fields []string, operator string) FieldQueryPara {
|
|
return FieldQueryPara{Fields: fields, Operator: operator}
|
|
}
|
|
|
|
// TagQueryPara define influxdb tag query parameter
|
|
type TagQueryPara struct {
|
|
Tag []string
|
|
Value []string
|
|
Operator string
|
|
}
|
|
|
|
func (t TagQueryPara) apply(query string) string {
|
|
tagTemplate := "r[\"{tag}\"] == \"{value}\""
|
|
filterTemplate := " |> filter(fn: (r) => {tag_template}) "
|
|
tagBuilder := strings.Builder{}
|
|
for i := 0; i < len(t.Tag); i++ {
|
|
if i > 0 {
|
|
operator := " " + t.Operator + " "
|
|
tagBuilder.Write([]byte(operator))
|
|
}
|
|
tagContent := strings.Replace(tagTemplate, "{tag}", t.Tag[i], -1)
|
|
tagContent = strings.Replace(tagContent, "{value}", t.Value[i], -1)
|
|
fmt.Printf("tagContent:%v\n", tagContent)
|
|
tagBuilder.Write([]byte(tagContent))
|
|
}
|
|
|
|
filterTemplate = strings.Replace(filterTemplate, "{tag_template}", tagBuilder.String(), -1)
|
|
return query + filterTemplate
|
|
}
|
|
|
|
// WithTag define func of set tag parameter in query statment
|
|
func WithTag(tag []string, value []string, operator string) TagQueryPara {
|
|
return TagQueryPara{Tag: tag, Value: value, Operator: operator}
|
|
}
|
|
|
|
// InitQueryByPara define func of init influxdb query statment
|
|
func InitQueryByPara(paras ...QueryPara) (queryCmd string) {
|
|
for _, para := range paras {
|
|
queryCmd = para.apply(queryCmd)
|
|
}
|
|
fmt.Printf("queryCmd:%v\n", queryCmd)
|
|
return
|
|
}
|