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, )