def reference_term(reference: Reference, original_query: QueryBuilder,
ref_query: QueryBuilder):
"""
Part of query building. Given a reference, the original dataset query, and the ref query, creates the pypika for
the reference that should be selected in the reference container query.
:param reference:
:param original_query:
:param ref_query:
:return:
"""
def original_field(metric):
return original_query.field(utils.alias_selector(metric.alias))
def ref_field(metric):
return ref_query.field(utils.alias_selector(metric.alias))
if reference.delta:
if reference.delta_percent:
return lambda metric: (original_field(metric) - ref_field(metric)
) * (100 / fn.NullIf(ref_field(metric), 0))
return lambda metric: original_field(metric) - ref_field(metric)
return ref_field
def test_nullif(self):
q = Q.from_('abc').select(fn.NullIf(F('foo'), 0))
self.assertEqual('SELECT NULLIF(\"foo\",0) FROM \"abc\"', str(q))
def modifier(field, join_field):
return (field - join_field) / fn.NullIf(join_field, 0)
def test_nullif(self):
q = Q.from_("abc").select(fn.NullIf(F("foo"), 0))
self.assertEqual('SELECT NULLIF("foo",0) FROM "abc"', str(q))
def test_is_aggregate_True_for_aggregate_function_or_function_with_aggregate_functions(
self):
self.assertTrue(fn.Sum('a').is_aggregate)
self.assertTrue(fn.Coalesce(fn.Avg('a'), 0).is_aggregate)
self.assertTrue(fn.Coalesce(fn.NullIf(fn.Sum('a'), 0), 0).is_aggregate)
def test_is_aggregate_None_for_non_aggregate_function_or_function_with_no_aggregate_functions(
self):
self.assertIsNone(fn.Coalesce('a', 0).is_aggregate)
self.assertIsNone(fn.Coalesce(fn.NullIf('a', 0), 0).is_aggregate)
import pandas as pd
from pypika import Query, Interval, JoinType, functions as fn
logger = logging.Logger('fireant')
reference_dimension_mappers = {
'yoy': lambda join_key: join_key + Interval(weeks=52),
'qoq': lambda join_key: join_key + Interval(quarters=1),
'mom': lambda join_key: join_key + Interval(weeks=4),
'wow': lambda join_key: join_key + Interval(weeks=1),
}
reference_metric_mappers = {
'd': lambda field, join_field: (field - join_field),
'p': lambda field, join_field: ((field - join_field) / fn.NullIf(join_field, 0)),
}
class QueryManager(object):
def query_data(self, database, table, joins=None,
metrics=None, dimensions=None,
mfilters=None, dfilters=None,
references=None, rollup=None):
"""
Loads a pandas data frame given a table and a description of the request.
:param database:
The database interface to use to execute the connection
:param table:
