def _build_annotations_query(
self,
measurement,
from_date=None,
to_date=None,
tags=None,
):
"""
Build queries according to requested time range
"""
# TODO sanitize inputs to avoid injection!
time_pred = _build_time_predicates(from_date, to_date)
must = time_pred
for key, val in tags.items():
if isinstance(val, bool):
val = str(val)
elif isinstance(val, int):
val = str(val)
val = "'{}'".format(escape_quotes(val))
must.append("\"{}\"={}".format(escape_doublequotes(key), val), )
must.append("\"{}\"={}".format("deleted", "false"))
where = " where {}".format(" and ".join(must)) if len(must) else ""
yield "select * from \"{}\".\"{}\".\"{}\"{} ;".format(
escape_doublequotes(self.annotation_db_name),
"autogen",
escape_doublequotes(measurement),
where,
)
def __init__(self, cfg):
cfg['type'] = 'influxdb'
super().__init__(cfg)
self._influxdb = None
self._annotationdb = None
self._from_prefix = ""
retention_policy = self.retention_policy
if retention_policy:
self._from_prefix = '"{}"."{}".'.format(
escape_doublequotes(self.db),
escape_doublequotes(retention_policy),
)
def _build_times_queries(
self,
bucket_interval,
features,
from_date=None,
to_date=None,
):
"""
Build queries according to requested features
"""
# TODO sanitize inputs to avoid injection!
time_pred = _build_time_predicates(from_date, to_date)
for feature in features:
must = time_pred + _build_tags_predicates(feature.match_all)
where = " where {}".format(" and ".join(must)) if len(must) else ""
yield "select {} from {}\"{}\"{} group by time({}ms);".format(
_build_agg(feature),
self._from_prefix,
escape_doublequotes(feature.measurement or self.measurement),
where,
int(bucket_interval * 1000),
)
def _build_tags_predicates(match_all=None):
"""
Build tags predicates for 'where' clause
"""
must = []
if match_all:
for condition in match_all:
quoted_tag = "\"{}\"".format(
escape_doublequotes(condition['tag'])
)
val = condition['value']
predicate = "{}='{}'".format(
quoted_tag,
escape_quotes(str(val)),
)
if isinstance(val, bool) or isinstance(val, int):
predicate = "({} OR {}={})".format(
predicate,
quoted_tag,
str(val)
)
must.append(predicate)
return must
def _build_key_predicate(tag, val=None):
"""
Build key predicate for 'where' clause
"""
must = []
if val:
must.append("\"{}\"='{}'".format(
escape_doublequotes(tag),
escape_quotes(format_bool(val)),
))
return must
def _build_agg(feature):
"""
Build requested aggregation
"""
global g_aggregators
aggregator = g_aggregators.get(feature.metric.lower())
if aggregator is None:
raise errors.UnsupportedMetric(
"unsupported aggregation '{}' in feature '{}'".format(
feature.metric, feature.name,
),
)
agg = aggregator(feature)
return "{} as \"{}\"".format(agg, escape_doublequotes(feature.name))
def test_escape_doublequotes(self):
self.assertEqual(escape_doublequotes('foo " "'), 'foo \\" \\"')
def _build_quad_queries(
self,
model,
agg,
from_date=None,
to_date=None,
key_val=None,
limit=0,
offset=0,
):
"""
Build aggregation query according to requested features
"""
# TODO sanitize inputs to avoid injection!
time_pred = _build_time_predicates(from_date, to_date)
must = time_pred + _build_tags_predicates(agg.match_all) \
+ _build_key_predicate(model.key, key_val)
where = " where {}".format(" and ".join(must)) if len(must) else ""
yield "select {} from {}\"{}\"{} group by {},time({}ms) fill(0) slimit {} soffset {};".format(
','.join(
list(
set([_build_agg(feature) for feature in agg.features] + [
_build_count_agg2(feature) for feature in agg.features
] + [_build_sum_agg2(feature)
for feature in agg.features]))),
self._from_prefix,
escape_doublequotes(agg.measurement),
where,
model.key,
int(model.bucket_interval * 1000),
limit,
offset,
)
sum_of_squares = []
for feature in agg.features:
if feature.metric == 'stddev':
sum_of_squares.append(feature)
if len(sum_of_squares) > 0:
yield "select {} from ( select \"{}\"*\"{}\" as \"squares_{}\" from \"{}\"{} ) where {} group by \"{}\",time({}ms) fill(0) slimit {} soffset {};".format(
','.join(
list(
set([
_sum_of_squares(feature)
for feature in sum_of_squares
]))),
escape_doublequotes(feature.field),
escape_doublequotes(feature.field),
escape_doublequotes(feature.field),
escape_doublequotes(agg.measurement),
where,
" and ".join(time_pred),
escape_doublequotes(model.key),
int(model.bucket_interval * 1000),
limit,
offset,
)
