mirror of
https://github.com/grafana/grafana.git
synced 2025-07-31 03:22:14 +08:00
317 lines
8.3 KiB
Go
317 lines
8.3 KiB
Go
package models
|
|
|
|
import (
|
|
"fmt"
|
|
"regexp"
|
|
"strconv"
|
|
"strings"
|
|
"time"
|
|
"unicode/utf8"
|
|
|
|
"github.com/grafana/grafana-plugin-sdk-go/backend"
|
|
"github.com/grafana/grafana-plugin-sdk-go/backend/gtime"
|
|
)
|
|
|
|
var (
|
|
regexpOperatorPattern = regexp.MustCompile(`^\/.*\/$`)
|
|
regexpMeasurementPattern = regexp.MustCompile(`^\/.*\/$`)
|
|
regexMatcherWithStartEndPattern = regexp.MustCompile(`^/\^(.*)\$/$`)
|
|
regexpRawQueryWhere = regexp.MustCompile(`(?i)WHERE`)
|
|
)
|
|
|
|
func (query *Query) getRawQueryWithAdhocFilters() string {
|
|
if len(query.AdhocFilters) == 0 {
|
|
return query.RawQuery
|
|
}
|
|
|
|
// If there's no where to be found (get it?), just append.
|
|
whereIndexes := regexpRawQueryWhere.FindAllStringIndex(query.RawQuery, -1)
|
|
if len(whereIndexes) == 0 {
|
|
query.RawQuery += " WHERE "
|
|
query.RawQuery += strings.Join(query.renderAdhocFilters(), " ")
|
|
return query.RawQuery
|
|
}
|
|
|
|
// Walk through raw query and determine if the 'WHERE' strings
|
|
// we found above are quoted or not. We'll insert adhoc filters
|
|
// after the first unquoted 'WHERE' string we find. Influxql supports
|
|
// subqueries, so valid queries can have multiple where clauses,
|
|
// but this code does not attempt to support that.
|
|
byteIndex := 0
|
|
insideQuotes := false
|
|
var previousRuneValue rune
|
|
whereIndex, whereIndexes := whereIndexes[0], whereIndexes[1:]
|
|
for _, runeValue := range query.RawQuery {
|
|
if previousRuneValue != '\\' && (runeValue == '"' || runeValue == '\'') {
|
|
insideQuotes = !insideQuotes
|
|
}
|
|
previousRuneValue = runeValue
|
|
|
|
if byteIndex == whereIndex[0] {
|
|
if !insideQuotes {
|
|
alteredQuery := query.RawQuery[:whereIndex[1]]
|
|
alteredQuery += " "
|
|
alteredQuery += strings.Join(query.renderAdhocFilters(), " ")
|
|
alteredQuery += " AND"
|
|
alteredQuery += query.RawQuery[whereIndex[1]:]
|
|
return alteredQuery
|
|
}
|
|
if len(whereIndexes) == 0 {
|
|
query.RawQuery += " WHERE "
|
|
query.RawQuery += strings.Join(query.renderAdhocFilters(), " ")
|
|
return query.RawQuery
|
|
}
|
|
whereIndex, whereIndexes = whereIndexes[0], whereIndexes[1:]
|
|
}
|
|
byteIndex += utf8.RuneLen(runeValue)
|
|
}
|
|
return query.RawQuery
|
|
}
|
|
|
|
func (query *Query) Build(queryContext *backend.QueryDataRequest) (string, error) {
|
|
var res string
|
|
if query.UseRawQuery && query.RawQuery != "" {
|
|
res = query.getRawQueryWithAdhocFilters()
|
|
} else {
|
|
res = query.renderSelectors(queryContext)
|
|
res += query.renderMeasurement()
|
|
res += query.renderWhereClause()
|
|
res += query.renderTimeFilter(queryContext)
|
|
res += query.renderGroupBy(queryContext)
|
|
res += query.renderOrderByTime()
|
|
res += query.renderLimit()
|
|
res += query.renderSlimit()
|
|
res += query.renderTz()
|
|
}
|
|
|
|
intervalText := gtime.FormatInterval(query.Interval)
|
|
intervalMs := int64(query.Interval / time.Millisecond)
|
|
|
|
res = strings.ReplaceAll(res, "$timeFilter", query.renderTimeFilter(queryContext))
|
|
res = strings.ReplaceAll(res, "$interval", intervalText)
|
|
res = strings.ReplaceAll(res, "$__interval_ms", strconv.FormatInt(intervalMs, 10))
|
|
res = strings.ReplaceAll(res, "$__interval", intervalText)
|
|
|
|
return res, nil
|
|
}
|
|
|
|
func (query *Query) renderAdhocFilters() []string {
|
|
return renderTags(query.AdhocFilters)
|
|
}
|
|
|
|
func renderTags(tags []*Tag) []string {
|
|
res := make([]string, 0, len(tags))
|
|
for i, tag := range tags {
|
|
str := ""
|
|
|
|
if i > 0 {
|
|
if tag.Condition == "" {
|
|
str += "AND"
|
|
} else {
|
|
str += tag.Condition
|
|
}
|
|
str += " "
|
|
}
|
|
|
|
// If the operator is missing we fall back to sensible defaults
|
|
if tag.Operator == "" {
|
|
if regexpOperatorPattern.MatchString(tag.Value) {
|
|
tag.Operator = "=~"
|
|
} else {
|
|
tag.Operator = "="
|
|
}
|
|
}
|
|
|
|
isOperatorTypeHandler := func(tag *Tag) (string, string) {
|
|
// Attempt to identify the type of the supplied value
|
|
var lowerValue = strings.ToLower(tag.Value)
|
|
var r = regexp.MustCompile(`^(-?)[0-9\.]+$`)
|
|
var textValue string
|
|
var operator string
|
|
|
|
// Perform operator replacements
|
|
switch tag.Operator {
|
|
case "Is":
|
|
operator = "="
|
|
case "Is Not":
|
|
operator = "!="
|
|
default:
|
|
// This should never happen
|
|
operator = "="
|
|
}
|
|
|
|
// Always quote tag values
|
|
if strings.HasSuffix(tag.Key, "::tag") {
|
|
textValue = fmt.Sprintf("'%s'", strings.ReplaceAll(tag.Value, `\`, `\\`))
|
|
return textValue, operator
|
|
}
|
|
|
|
// Try and discern the type of fields
|
|
if lowerValue == "true" || lowerValue == "false" {
|
|
// boolean, don't quote, but make lowercase
|
|
textValue = lowerValue
|
|
} else if r.MatchString(tag.Value) {
|
|
// Integer or float, don't quote
|
|
textValue = tag.Value
|
|
} else {
|
|
// String (or unknown) - quote
|
|
textValue = fmt.Sprintf("'%s'", strings.ReplaceAll(tag.Value, `\`, `\\`))
|
|
}
|
|
|
|
return removeRegexWrappers(textValue, `'`), operator
|
|
}
|
|
|
|
// quote value unless regex or number
|
|
var textValue string
|
|
switch tag.Operator {
|
|
case "=~", "!~", "":
|
|
textValue = tag.Value
|
|
case "<", ">", ">=", "<=":
|
|
textValue = removeRegexWrappers(tag.Value, `'`)
|
|
case "Is", "Is Not":
|
|
textValue, tag.Operator = isOperatorTypeHandler(tag)
|
|
default:
|
|
textValue = fmt.Sprintf("'%s'", strings.ReplaceAll(removeRegexWrappers(tag.Value, ""), `\`, `\\`))
|
|
}
|
|
|
|
escapedKey := fmt.Sprintf(`"%s"`, tag.Key)
|
|
|
|
if strings.HasSuffix(tag.Key, "::tag") {
|
|
escapedKey = fmt.Sprintf(`"%s"::tag`, strings.TrimSuffix(tag.Key, "::tag"))
|
|
}
|
|
|
|
if strings.HasSuffix(tag.Key, "::field") {
|
|
escapedKey = fmt.Sprintf(`"%s"::field`, strings.TrimSuffix(tag.Key, "::field"))
|
|
}
|
|
|
|
res = append(res, fmt.Sprintf(`%s%s %s %s`, str, escapedKey, tag.Operator, textValue))
|
|
}
|
|
return res
|
|
}
|
|
|
|
func (query *Query) renderTags() []string {
|
|
return renderTags(query.Tags)
|
|
}
|
|
|
|
func (query *Query) renderTimeFilter(queryContext *backend.QueryDataRequest) string {
|
|
from, to := epochMStoInfluxTime(&queryContext.Queries[0].TimeRange)
|
|
return fmt.Sprintf("time >= %s and time <= %s", from, to)
|
|
}
|
|
|
|
func (query *Query) renderSelectors(queryContext *backend.QueryDataRequest) string {
|
|
res := "SELECT "
|
|
|
|
selectors := make([]string, 0, len(query.Selects))
|
|
for _, sel := range query.Selects {
|
|
stk := ""
|
|
for _, s := range *sel {
|
|
stk = s.Render(query, queryContext, stk)
|
|
}
|
|
selectors = append(selectors, stk)
|
|
}
|
|
|
|
return res + strings.Join(selectors, ", ")
|
|
}
|
|
|
|
func (query *Query) renderMeasurement() string {
|
|
var policy string
|
|
if query.Policy == "" || query.Policy == "default" {
|
|
policy = ""
|
|
} else {
|
|
policy = `"` + query.Policy + `".`
|
|
}
|
|
|
|
measurement := query.Measurement
|
|
|
|
if !regexpMeasurementPattern.MatchString(measurement) {
|
|
measurement = fmt.Sprintf(`"%s"`, measurement)
|
|
}
|
|
|
|
return fmt.Sprintf(` FROM %s%s`, policy, measurement)
|
|
}
|
|
|
|
func (query *Query) renderWhereClause() string {
|
|
res := " WHERE "
|
|
conditions := query.renderTags()
|
|
if len(conditions) > 0 {
|
|
if len(conditions) > 1 {
|
|
res += "(" + strings.Join(conditions, " ") + ")"
|
|
} else {
|
|
res += conditions[0]
|
|
}
|
|
res += " AND "
|
|
}
|
|
|
|
return res
|
|
}
|
|
|
|
func (query *Query) renderGroupBy(queryContext *backend.QueryDataRequest) string {
|
|
groupBy := ""
|
|
for i, group := range query.GroupBy {
|
|
if i == 0 {
|
|
groupBy += " GROUP BY"
|
|
}
|
|
|
|
if i > 0 && group.Type != "fill" {
|
|
groupBy += ", " // fill is so very special. fill is a creep, fill is a weirdo
|
|
} else {
|
|
groupBy += " "
|
|
}
|
|
|
|
groupBy += group.Render(query, queryContext, "")
|
|
}
|
|
|
|
return groupBy
|
|
}
|
|
|
|
func (query *Query) renderOrderByTime() string {
|
|
orderByTime := query.OrderByTime
|
|
if orderByTime == "" {
|
|
return ""
|
|
}
|
|
return fmt.Sprintf(" ORDER BY time %s", orderByTime)
|
|
}
|
|
|
|
func (query *Query) renderTz() string {
|
|
tz := query.Tz
|
|
if tz == "" {
|
|
return ""
|
|
}
|
|
return fmt.Sprintf(" tz('%s')", tz)
|
|
}
|
|
|
|
func (query *Query) renderLimit() string {
|
|
limit := query.Limit
|
|
if limit == "" {
|
|
return ""
|
|
}
|
|
return fmt.Sprintf(" limit %s", limit)
|
|
}
|
|
|
|
func (query *Query) renderSlimit() string {
|
|
slimit := query.Slimit
|
|
if slimit == "" {
|
|
return ""
|
|
}
|
|
return fmt.Sprintf(" slimit %s", slimit)
|
|
}
|
|
|
|
func epochMStoInfluxTime(tr *backend.TimeRange) (string, string) {
|
|
from := tr.From.UnixNano() / int64(time.Millisecond)
|
|
to := tr.To.UnixNano() / int64(time.Millisecond)
|
|
|
|
return fmt.Sprintf("%dms", from), fmt.Sprintf("%dms", to)
|
|
}
|
|
|
|
func removeRegexWrappers(wrappedValue string, wrapper string) string {
|
|
value := wrappedValue
|
|
// get the value only in between /^...$/
|
|
matches := regexMatcherWithStartEndPattern.FindStringSubmatch(wrappedValue)
|
|
if len(matches) > 1 {
|
|
// full match. the value is like /^value$/
|
|
value = wrapper + matches[1] + wrapper
|
|
}
|
|
|
|
return value
|
|
}
|