diff --git a/fireant/formats.py b/fireant/formats.py
index 32258e5c..fef7d49d 100644
--- a/fireant/formats.py
+++ b/fireant/formats.py
@@ -6,11 +6,7 @@
     time,
 )
 
-from fireant.utils import (
-    MAX_NUMBER,
-    MAX_STRING,
-    MAX_TIMESTAMP,
-)
+from fireant.slicer.totals import TOTALS_MARKERS
 
 INF_VALUE = "Inf"
 NULL_VALUE = 'null'
@@ -68,7 +64,7 @@ def dimension_value(value):
         When True, dates and datetimes will be converted to ISO strings. The time is omitted for dates. When False, the
         datetime will be converted to a POSIX timestamp (millis-since-epoch).
     """
-    if value in {MAX_STRING, MAX_NUMBER, MAX_TIMESTAMP}:
+    if value in TOTALS_MARKERS:
         return 'Totals'
 
     if pd.isnull(value):
diff --git a/fireant/slicer/__init__.py b/fireant/slicer/__init__.py
index 6ae2cb41..4345c865 100644
--- a/fireant/slicer/__init__.py
+++ b/fireant/slicer/__init__.py
@@ -29,6 +29,7 @@
     CumSum,
     Operation,
     RollingMean,
+    Share,
 )
 from .references import (
     DayOverDay,
diff --git a/fireant/slicer/dimensions.py b/fireant/slicer/dimensions.py
index 8972fc10..70ffff1c 100644
--- a/fireant/slicer/dimensions.py
+++ b/fireant/slicer/dimensions.py
@@ -76,10 +76,11 @@ def is_(self, value: bool):
         :return:
             A slicer query filter used to filter a slicer query to results where this dimension is True or False.
         """
-        return BooleanFilter(self.definition, value)
+        return BooleanFilter(self.key, self.definition, value)
 
 
 class PatternFilterableMixin:
+    key = None
     definition = None
     pattern_definition_attribute = 'definition'
 
@@ -98,7 +99,7 @@ def like(self, pattern, *patterns):
             matches the pattern.
         """
         definition = getattr(self, self.pattern_definition_attribute)
-        return PatternFilter(definition, pattern, *patterns)
+        return PatternFilter(self.key, definition, pattern, *patterns)
 
     def not_like(self, pattern, *patterns):
         """
@@ -115,7 +116,7 @@ def not_like(self, pattern, *patterns):
             matches the pattern.
         """
         definition = getattr(self, self.pattern_definition_attribute)
-        return AntiPatternFilter(definition, pattern, *patterns)
+        return AntiPatternFilter(self.key, definition, pattern, *patterns)
 
 
 class CategoricalDimension(PatternFilterableMixin, Dimension):
@@ -142,7 +143,7 @@ def isin(self, values: Iterable):
             A slicer query filter used to filter a slicer query to results where this dimension is one of a set of
             values. Opposite of #notin.
         """
-        return ContainsFilter(self.definition, values)
+        return ContainsFilter(self.key, self.definition, values)
 
     def notin(self, values):
         """
@@ -155,7 +156,7 @@ def notin(self, values):
             A slicer query filter used to filter a slicer query to results where this dimension is *not* one of a set of
             values. Opposite of #isin.
         """
-        return ExcludesFilter(self.definition, values)
+        return ExcludesFilter(self.key, self.definition, values)
 
 
 class _UniqueDimensionBase(PatternFilterableMixin, Dimension):
@@ -170,7 +171,7 @@ def isin(self, values):
             A slicer query filter used to filter a slicer query to results where this dimension is one of a set of
             values. Opposite of #notin.
         """
-        return ContainsFilter(self.definition, values)
+        return ContainsFilter(self.key, self.definition, values)
 
     def notin(self, values):
         """
@@ -183,7 +184,7 @@ def notin(self, values):
             A slicer query filter used to filter a slicer query to results where this dimension is *not* one of a set of
             values. Opposite of #isin.
         """
-        return ExcludesFilter(self.definition, values)
+        return ExcludesFilter(self.key, self.definition, values)
 
 
 class UniqueDimension(_UniqueDimensionBase):
@@ -288,7 +289,7 @@ def between(self, start, stop):
             A slicer query filter used to filter a slicer query to results where this dimension is between the values
             start and stop.
         """
-        return RangeFilter(self.definition, start, stop)
+        return RangeFilter(self.key, self.definition, start, stop)
 
 
 class TotalsDimension(Dimension):
diff --git a/fireant/slicer/exceptions.py b/fireant/slicer/exceptions.py
index 71b28731..c7401d49 100644
--- a/fireant/slicer/exceptions.py
+++ b/fireant/slicer/exceptions.py
@@ -18,6 +18,10 @@ class RollupException(SlicerException):
     pass
 
 
+class MissingTotalsForShareException(Exception):
+    pass
+
+
 class MetricRequiredException(SlicerException):
     pass
 
diff --git a/fireant/slicer/filters.py b/fireant/slicer/filters.py
index 2199e679..7ad87428 100644
--- a/fireant/slicer/filters.py
+++ b/fireant/slicer/filters.py
@@ -15,11 +15,15 @@ def __repr__(self):
 
 
 class DimensionFilter(Filter):
-    pass
+    def __init__(self, dimension_key, definition):
+        super().__init__(definition)
+        self.dimension_key = dimension_key
 
 
 class MetricFilter(Filter):
-    pass
+    def __init__(self, metric_key, definition):
+        super().__init__(definition)
+        self.metric_key = metric_key
 
 
 class ComparatorFilter(MetricFilter):
@@ -31,36 +35,43 @@ class Operator(object):
         gte = 'gte'
         lte = 'lte'
 
-    def __init__(self, metric_definition, operator, value):
+    def __init__(self, metric_key, metric_definition, operator, value):
         definition = getattr(metric_definition, operator)(value)
-        super(ComparatorFilter, self).__init__(definition)
+        super(ComparatorFilter, self).__init__(metric_key, definition)
 
 
 class BooleanFilter(DimensionFilter):
-    def __init__(self, element_key, value):
-        definition = element_key if value else Not(element_key)
-        super(BooleanFilter, self).__init__(definition)
+    def __init__(self, dimension_key, dimension_definition, value):
+        definition = dimension_definition \
+            if value \
+            else Not(dimension_definition)
+
+        super(BooleanFilter, self).__init__(dimension_key, definition)
 
 
 class ContainsFilter(DimensionFilter):
-    def __init__(self, dimension_definition, values):
+    def __init__(self, dimension_key, dimension_definition, values):
         definition = dimension_definition.isin(values)
-        super(ContainsFilter, self).__init__(definition)
+        super(ContainsFilter, self).__init__(dimension_key, definition)
 
 
 class ExcludesFilter(DimensionFilter):
-    def __init__(self, dimension_definition, values):
+    def __init__(self, dimension_key, dimension_definition, values):
         definition = dimension_definition.notin(values)
-        super(ExcludesFilter, self).__init__(definition)
+        super(ExcludesFilter, self).__init__(dimension_key, definition)
 
 
 class RangeFilter(DimensionFilter):
-    def __init__(self, dimension_definition, start, stop):
+    def __init__(self, dimension_key, dimension_definition, start, stop):
         definition = dimension_definition[start:stop]
-        super(RangeFilter, self).__init__(definition)
+        super(RangeFilter, self).__init__(dimension_key, definition)
 
 
 class PatternFilter(DimensionFilter):
+    def __init__(self, dimension_key, dimension_definition, pattern, *patterns):
+        definition = self._apply(dimension_definition, (pattern,) + patterns)
+        super(PatternFilter, self).__init__(dimension_key, definition)
+
     def _apply(self, dimension_definition, patterns):
         definition = Lower(dimension_definition).like(Lower(patterns[0]))
 
@@ -69,10 +80,6 @@ def _apply(self, dimension_definition, patterns):
 
         return definition
 
-    def __init__(self, dimension_definition, pattern, *patterns):
-        definition = self._apply(dimension_definition, (pattern,) + patterns)
-        super(PatternFilter, self).__init__(definition)
-
 
 class AntiPatternFilter(PatternFilter):
     def _apply(self, dimension_definition, pattern):
diff --git a/fireant/slicer/metrics.py b/fireant/slicer/metrics.py
index 49d767c6..5c1dd30f 100644
--- a/fireant/slicer/metrics.py
+++ b/fireant/slicer/metrics.py
@@ -1,3 +1,6 @@
+from fireant.utils import (
+    immutable,
+)
 from .base import SlicerElement
 from .filters import ComparatorFilter
 
@@ -30,24 +33,37 @@ def __init__(self, key, definition, label=None, precision=None, prefix=None, suf
         self.precision = precision
         self.prefix = prefix
         self.suffix = suffix
+        self._share = False
 
     def __eq__(self, other):
-        return ComparatorFilter(self.definition, ComparatorFilter.Operator.eq, other)
+        return ComparatorFilter(self.key, self.definition, ComparatorFilter.Operator.eq, other)
 
     def __ne__(self, other):
-        return ComparatorFilter(self.definition, ComparatorFilter.Operator.ne, other)
+        return ComparatorFilter(self.key, self.definition, ComparatorFilter.Operator.ne, other)
 
     def __gt__(self, other):
-        return ComparatorFilter(self.definition, ComparatorFilter.Operator.gt, other)
+        return ComparatorFilter(self.key, self.definition, ComparatorFilter.Operator.gt, other)
 
     def __ge__(self, other):
-        return ComparatorFilter(self.definition, ComparatorFilter.Operator.gte, other)
+        return ComparatorFilter(self.key, self.definition, ComparatorFilter.Operator.gte, other)
 
     def __lt__(self, other):
-        return ComparatorFilter(self.definition, ComparatorFilter.Operator.lt, other)
+        return ComparatorFilter(self.key, self.definition, ComparatorFilter.Operator.lt, other)
 
     def __le__(self, other):
-        return ComparatorFilter(self.definition, ComparatorFilter.Operator.lte, other)
+        return ComparatorFilter(self.key, self.definition, ComparatorFilter.Operator.lte, other)
 
     def __repr__(self):
         return "slicer.metrics.{}".format(self.key)
+
+    @property
+    @immutable
+    def share(self):
+        self._share = True
+        return self
+
+    @property
+    @immutable
+    def share(self):
+        self._share = True
+        return self
diff --git a/fireant/slicer/operations.py b/fireant/slicer/operations.py
index cdae5a6b..52308741 100644
--- a/fireant/slicer/operations.py
+++ b/fireant/slicer/operations.py
@@ -1,8 +1,14 @@
 import numpy as np
 import pandas as pd
 
-from fireant.utils import format_metric_key
 from fireant.slicer.references import reference_key
+from fireant.slicer.totals import get_totals_marker_for_dtype
+from fireant.utils import (
+    format_dimension_key,
+    format_metric_key,
+    reduce_data_frame_levels,
+)
+from .dimensions import Dimension
 from .metrics import Metric
 
 
@@ -194,3 +200,61 @@ def apply(self, data_frame, reference):
                 .apply(self.rolling_mean)
 
         return self.rolling_mean(data_frame[df_key])
+
+
+class Share(_BaseOperation):
+    def __init__(self, metric: Metric, over: Dimension = None, precision=2):
+        super(Share, self).__init__(
+              key='share({},{})'.format(getattr(metric, 'key', metric),
+                                        getattr(over, 'key', over), ),
+              label='Share of {} over {}'.format(getattr(metric, 'label', metric),
+                                                 getattr(over, 'label', over)),
+              prefix=None,
+              suffix='%',
+              precision=precision,
+        )
+
+        self.metric = metric
+        self.over = over
+
+    @property
+    def metrics(self):
+        return [metric
+                for metric in [self.metric]
+                if isinstance(metric, Metric)]
+
+    @property
+    def operations(self):
+        return [op_and_children
+                for operation in [self.metric]
+                if isinstance(operation, Operation)
+                for op_and_children in [operation] + operation.operations]
+
+    def apply(self, data_frame, reference):
+        f_metric_key = format_metric_key(reference_key(self.metric, reference))
+
+        if self.over is None:
+            df = data_frame[f_metric_key]
+            return 100 * df / df
+
+        if not isinstance(data_frame.index, pd.MultiIndex):
+            marker = get_totals_marker_for_dtype(data_frame.index.dtype)
+            totals = data_frame.loc[marker, f_metric_key]
+            return 100 * data_frame[f_metric_key] / totals
+
+        f_over_key = format_dimension_key(self.over.key)
+        idx = data_frame.index.names.index(f_over_key)
+        group_levels = data_frame.index.names[idx:]
+        over_dim_value = get_totals_marker_for_dtype(data_frame.index.levels[idx].dtype)
+        totals_key = (slice(None),) * idx + (slice(over_dim_value, over_dim_value),)
+
+        totals = reduce_data_frame_levels(data_frame.loc[totals_key, f_metric_key], group_levels)
+
+        def apply_totals(df):
+            return 100 * reduce_data_frame_levels(df / totals, group_levels)
+
+        return data_frame[f_metric_key] \
+            .groupby(level=group_levels) \
+            .apply(apply_totals) \
+            .reorder_levels(order=data_frame.index.names) \
+            .sort_index()
diff --git a/fireant/slicer/queries/builder.py b/fireant/slicer/queries/builder.py
index fce01607..9ca01e6a 100644
--- a/fireant/slicer/queries/builder.py
+++ b/fireant/slicer/queries/builder.py
@@ -13,24 +13,26 @@
 )
 from pypika import Order
 from . import special_cases
-from .database import fetch_data
+from .execution import fetch_data
 from .finders import (
     find_and_group_references_for_dimensions,
     find_and_replace_reference_dimensions,
     find_metrics_for_widgets,
     find_operations_for_widgets,
+    find_share_dimensions,
 )
-from .makers import (
+from .pagination import paginate
+from .sql_transformer import (
     make_latest_query,
     make_orders_for_dimensions,
     make_slicer_query,
-    make_slicer_query_with_rollup_and_references,
+    make_slicer_query_with_totals_and_references,
 )
-from .pagination import paginate
 from .. import QueryException
 from ..base import SlicerElement
 from ..dimensions import Dimension
 from ..references import reference_key
+from ..totals import scrub_totals_from_share_results
 
 
 def add_hints(queries, hint=None):
@@ -117,6 +119,13 @@ def __init__(self, slicer):
         super(SlicerQueryBuilder, self).__init__(slicer, slicer.table)
         self._widgets = []
         self._orders = []
+        self.filter_totals = True
+
+    @immutable
+    def __call__(self, **kwargs):
+        for setting in ('filter_totals',):
+            if setting in kwargs:
+                setattr(self, setting, kwargs[setting])
 
     @immutable
     def widget(self, *widgets):
@@ -165,6 +174,15 @@ def orderby(self, element: SlicerElement, orientation: Order = None):
 
         self._orders += [(element.definition.as_(format_key(element.key)), orientation)]
 
+    def _validate(self):
+        for widget in self._widgets:
+            if hasattr(widget, 'validate'):
+                widget.validate(self._dimensions)
+
+    @property
+    def reference_groups(self):
+        return list(find_and_group_references_for_dimensions(self._references).values())
+
     @property
     def queries(self):
         """
@@ -176,19 +194,18 @@ def queries(self):
         a query for each reference is joined based on the referenced dimension shifted.
         """
         # First run validation for the query on all widgets
-        for widget in self._widgets:
-            if hasattr(widget, 'validate'):
-                widget.validate(self._dimensions)
+        self._validate()
 
         # Optionally select all metrics for slicer to better utilize caching
         metrics = list(self.slicer.metrics) \
             if self.slicer.always_query_all_metrics \
             else find_metrics_for_widgets(self._widgets)
         operations = find_operations_for_widgets(self._widgets)
+        share_dimensions = find_share_dimensions(self._dimensions, operations)
         references = find_and_replace_reference_dimensions(self._references, self._dimensions)
         orders = (self._orders or make_orders_for_dimensions(self._dimensions))
 
-        return make_slicer_query_with_rollup_and_references(self.slicer.database,
+        return make_slicer_query_with_totals_and_references(self.slicer.database,
                                                             self.table,
                                                             self.slicer.joins,
                                                             self._dimensions,
@@ -196,7 +213,9 @@ def queries(self):
                                                             operations,
                                                             self._filters,
                                                             references,
-                                                            orders)
+                                                            orders,
+                                                            share_dimensions=share_dimensions,
+                                                            filter_totals=self.filter_totals)
 
     def fetch(self, hint=None) -> Iterable[Dict]:
         """
@@ -209,18 +228,23 @@ def fetch(self, hint=None) -> Iterable[Dict]:
         """
         queries = add_hints(self.queries, hint)
 
-        reference_groups = list(find_and_group_references_for_dimensions(self._references).values())
-        data_frame = fetch_data(self.slicer.database, queries, self._dimensions, reference_groups)
+        operations = find_operations_for_widgets(self._widgets)
+        share_dimensions = find_share_dimensions(self._dimensions, operations)
+
+        data_frame = fetch_data(self.slicer.database,
+                                queries,
+                                self._dimensions,
+                                share_dimensions,
+                                self.reference_groups)
 
         # Apply operations
-        operations = find_operations_for_widgets(self._widgets)
         for operation in operations:
             for reference in [None] + self._references:
                 df_key = format_metric_key(reference_key(operation, reference))
                 data_frame[df_key] = operation.apply(data_frame, reference)
 
+        data_frame = scrub_totals_from_share_results(data_frame, self._dimensions)
         data_frame = special_cases.apply_operations_to_data_frame(operations, data_frame)
-
         data_frame = paginate(data_frame,
                               self._widgets,
                               orders=self._orders,
@@ -356,7 +380,7 @@ def queries(self):
         return [query]
 
     def fetch(self, hint=None):
-        data = super().fetch(hint=hint).reset_index().ix[0]
+        data = super().fetch(hint=hint).reset_index().iloc[0]
         # Remove the row index as the name and trim the special dimension key characters from the dimension key
         data.name = None
         data.index = [key[3:] for key in data.index]
diff --git a/fireant/slicer/queries/database.py b/fireant/slicer/queries/execution.py
similarity index 84%
rename from fireant/slicer/queries/database.py
rename to fireant/slicer/queries/execution.py
index cf10fa6f..a047b432 100644
--- a/fireant/slicer/queries/database.py
+++ b/fireant/slicer/queries/execution.py
@@ -10,25 +10,26 @@
     Union,
 )
 
-import numpy as np
 import pandas as pd
 
 from fireant.database import Database
+from fireant.slicer.totals import get_totals_marker_for_dtype
 from fireant.utils import (
-    MAX_NUMBER,
-    MAX_STRING,
-    MAX_TIMESTAMP,
     chunks,
     format_dimension_key,
 )
-from .logger import (
+from .finders import find_totals_dimensions
+from .slow_query_logger import (
     query_logger,
     slow_query_logger,
 )
 from ..dimensions import Dimension
 
 
-def fetch_data(database: Database, queries: Union[Sized, Iterable], dimensions: Iterable[Dimension],
+def fetch_data(database: Database,
+               queries: Union[Sized, Iterable],
+               dimensions: Iterable[Dimension],
+               share_dimensions: Iterable[Dimension] = (),
                reference_groups=()):
     iterable = [(str(query.limit(int(database.max_result_set_size))), database)
                 for query in queries]
@@ -37,7 +38,7 @@ def fetch_data(database: Database, queries: Union[Sized, Iterable], dimensions:
         results = pool.map(_exec, iterable)
         pool.close()
 
-    return _reduce_result_set(results, reference_groups, dimensions)
+    return _reduce_result_set(results, reference_groups, dimensions, share_dimensions)
 
 
 def _exec(args):
@@ -92,7 +93,10 @@ def _do_fetch_data(query: str, database: Database):
         return pd.read_sql(query, connection, coerce_float=True, parse_dates=True)
 
 
-def _reduce_result_set(results: Iterable[pd.DataFrame], reference_groups, dimensions: Iterable[Dimension]):
+def _reduce_result_set(results: Iterable[pd.DataFrame],
+                       reference_groups,
+                       dimensions: Iterable[Dimension],
+                       share_dimensions: Dimension):
     """
     Reduces the result sets from individual queries into a single data frame. This effectively joins sets of references
     and concats the sets of totals.
@@ -108,10 +112,9 @@ def _reduce_result_set(results: Iterable[pd.DataFrame], reference_groups, dimens
 
     dimension_keys = [format_dimension_key(d.key)
                       for d in dimensions]
-    rollup_dimension_keys = [format_dimension_key(d.key)
-                             for d in dimensions
-                             if d.is_rollup]
-    rollup_dimension_dtypes = result_groups[0][0][rollup_dimension_keys].dtypes
+    totals_dimension_keys = [format_dimension_key(d.key)
+                             for d in find_totals_dimensions(dimensions, share_dimensions)]
+    dimension_dtypes = result_groups[0][0][dimension_keys].dtypes
 
     # Reduce each group to one data frame per rolled up dimension
     group_data_frames = []
@@ -132,8 +135,8 @@ def _reduce_result_set(results: Iterable[pd.DataFrame], reference_groups, dimens
         # marker to indicate totals.
         # The data frames will be ordered so that the first group will contain the data without any rolled up
         # dimensions, then followed by the groups with them, ordered by the last rollup dimension first.
-        if rollup_dimension_keys[:i]:
-            reduced = _replace_nans_for_rollup_values(reduced, rollup_dimension_dtypes[-i:])
+        if totals_dimension_keys[:i]:
+            reduced = _replace_nans_for_totals_values(reduced, dimension_dtypes[-i - 1:])
 
         group_data_frames.append(reduced)
 
@@ -141,19 +144,14 @@ def _reduce_result_set(results: Iterable[pd.DataFrame], reference_groups, dimens
         .sort_index(na_position='first')
 
 
-def _replace_nans_for_rollup_values(data_frame, dtypes):
-    replace = {
-        np.dtype('<M8[ns]'): MAX_TIMESTAMP,
-        np.dtype('int64'): MAX_NUMBER,
-    }
-
+def _replace_nans_for_totals_values(data_frame, dtypes):
     # some things are just easier to do without an index. Reset it temporarily to replaxe NaN values with the rollup
     # marker values
     index_names = data_frame.index.names
     data_frame.reset_index(inplace=True)
 
     for dimension_key, dtype in dtypes.items():
-        data_frame[dimension_key] = replace.get(dtype, MAX_STRING)
+        data_frame[dimension_key] = data_frame[dimension_key].fillna(get_totals_marker_for_dtype(dtype))
 
     return data_frame.set_index(index_names)
 
diff --git a/fireant/slicer/queries/finders.py b/fireant/slicer/queries/finders.py
index e15ce428..e7bae090 100644
--- a/fireant/slicer/queries/finders.py
+++ b/fireant/slicer/queries/finders.py
@@ -18,6 +18,7 @@
     CircularJoinsException,
     MissingTableJoinException,
 )
+from ..operations import Share
 
 ReferenceGroup = namedtuple('ReferenceGroup', ('dimension', 'time_unit', 'intervals'))
 
@@ -95,6 +96,27 @@ def find_metrics_for_widgets(widgets):
                                           for metric in widget.metrics])
 
 
+def find_share_dimensions(dimensions, operations):
+    """
+    Returns a subset list of dimensions from the list of dimensions that are used as the over-dimension in share
+    operations.
+
+    :param dimensions:
+    :param operations:
+    :return:
+    """
+    share_operations_over_dimensions = [operation.over
+                                        for operation in operations
+                                        if isinstance(operation, Share)
+                                        and operation.over is not None]
+
+    dimension_map = {dimension.key: dimension
+                     for dimension in dimensions}
+    
+    return [dimension_map[dimension.key]
+            for dimension in share_operations_over_dimensions]
+
+
 def find_operations_for_widgets(widgets):
     """
     :return:
@@ -105,10 +127,17 @@ def find_operations_for_widgets(widgets):
                                           for operation in widget.operations])
 
 
-def find_rolled_up_dimensions(dimensions):
+def find_totals_dimensions(dimensions, share_dimensions):
+    """
+    WRITEME
+
+    :param dimensions:
+    :param share_dimensions:
+    :return:
+    """
     return [dimension
             for dimension in dimensions
-            if dimension.is_rollup]
+            if dimension.is_rollup or dimension in share_dimensions]
 
 
 def find_and_replace_reference_dimensions(references, dimensions):
diff --git a/fireant/slicer/queries/references.py b/fireant/slicer/queries/reference_helper.py
similarity index 100%
rename from fireant/slicer/queries/references.py
rename to fireant/slicer/queries/reference_helper.py
diff --git a/fireant/slicer/queries/logger.py b/fireant/slicer/queries/slow_query_logger.py
similarity index 100%
rename from fireant/slicer/queries/logger.py
rename to fireant/slicer/queries/slow_query_logger.py
diff --git a/fireant/slicer/queries/special_cases.py b/fireant/slicer/queries/special_cases.py
index 2d8570e5..d1002c6c 100644
--- a/fireant/slicer/queries/special_cases.py
+++ b/fireant/slicer/queries/special_cases.py
@@ -98,8 +98,8 @@ def apply_to_query_args(database, table, joins, dimensions, metrics, operations,
 
 def apply_special_cases(f):
     @functools.wraps(f)
-    def wrapper(*args):
-        return f(*apply_to_query_args(*args))
+    def wrapper(*args, **kwargs):
+        return f(*apply_to_query_args(*args), **kwargs)
 
     return wrapper
 
diff --git a/fireant/slicer/queries/makers.py b/fireant/slicer/queries/sql_transformer.py
similarity index 82%
rename from fireant/slicer/queries/makers.py
rename to fireant/slicer/queries/sql_transformer.py
index 2aed3c20..7defa86f 100644
--- a/fireant/slicer/queries/makers.py
+++ b/fireant/slicer/queries/sql_transformer.py
@@ -9,13 +9,14 @@
     Table,
     functions as fn,
 )
+
 from .finders import (
     find_and_group_references_for_dimensions,
     find_joins_for_tables,
     find_required_tables_to_join,
-    find_rolled_up_dimensions,
+    find_totals_dimensions,
 )
-from .references import adapt_for_reference_query
+from .reference_helper import adapt_for_reference_query
 from .special_cases import apply_special_cases
 from ..dimensions import (
     Dimension,
@@ -30,19 +31,30 @@
 from ...database import Database
 
 
-def adapt_for_totals_query(totals_dimension, dimensions):
+def adapt_for_totals_query(totals_dimension, dimensions, filters, filter_totals):
+    apply_totals = totals_dimension is not None
+
     # Get an index to split the dimensions before and after the totals dimension
     index = dimensions.index(totals_dimension) \
-        if totals_dimension is not None \
+        if apply_totals \
         else len(dimensions)
 
     grouped_dims, totaled_dims = dimensions[:index], dimensions[index:]
-    return grouped_dims + [TotalsDimension(dimension)
-                           for dimension in totaled_dims]
+    totals_dims = grouped_dims + [TotalsDimension(dimension)
+                                  for dimension in totaled_dims]
+
+    # when filter_totals is False, remove all filters for the totals dimension
+    totals_filters = [f
+                      for f in filters
+                      if getattr(f, 'dimension_key', None) != totals_dimension.key] \
+        if apply_totals and not filter_totals \
+        else filters
+
+    return totals_dims, totals_filters
 
 
 @apply_special_cases
-def make_slicer_query_with_rollup_and_references(database,
+def make_slicer_query_with_totals_and_references(database,
                                                  table,
                                                  joins,
                                                  dimensions,
@@ -50,17 +62,21 @@ def make_slicer_query_with_rollup_and_references(database,
                                                  operations,
                                                  filters,
                                                  references,
-                                                 orders):
+                                                 orders,
+                                                 share_dimensions=(),
+                                                 filter_totals=True):
     """
     :param database:
     :param table:
     :param joins:
     :param dimensions:
     :param metrics:
+    :param operations:
     :param filters:
-    :param orders:
     :param references:
-    :param operations:
+    :param orders:
+    :param share_dimensions:
+    :param filter_totals:
     :return:
     """
 
@@ -79,15 +95,19 @@ def make_slicer_query_with_rollup_and_references(database,
         #test_build_query_with_totals_cat_dimension_with_references
     ```
     """
-    rollup_dimensions = find_rolled_up_dimensions(dimensions)
-    rollup_dimensions_and_none = [None] + rollup_dimensions[::-1]
+    totals_dimensions = find_totals_dimensions(dimensions, share_dimensions)
+    totals_dimensions_and_none = [None] + totals_dimensions[::-1]
 
     reference_groups = find_and_group_references_for_dimensions(references)
     reference_groups_and_none = [(None, None)] + list(reference_groups.items())
 
     queries = []
-    for rollup_dimension in rollup_dimensions_and_none:
-        query_dimensions = adapt_for_totals_query(rollup_dimension, dimensions)
+    for totals_dimension in totals_dimensions_and_none:
+        (query_dimensions,
+         query_filters) = adapt_for_totals_query(totals_dimension,
+                                                 dimensions,
+                                                 filters,
+                                                 filter_totals)
 
         for reference_parts, references in reference_groups_and_none:
             (ref_database,
@@ -97,7 +117,7 @@ def make_slicer_query_with_rollup_and_references(database,
                                                       database,
                                                       query_dimensions,
                                                       metrics,
-                                                      filters,
+                                                      query_filters,
                                                       references)
             query = make_slicer_query(ref_database,
                                       table,
@@ -107,8 +127,9 @@ def make_slicer_query_with_rollup_and_references(database,
                                       ref_filters,
                                       orders)
 
-            # Add this to the query instance so when the data frames are joined together, the correct references can be
-            # applied.
+            # Add these to the query instance so when the data frames are joined together, the correct references and
+            # totals can be applied when combining the separate result set from each query.
+            query._totals = totals_dimension
             query._references = references
 
             queries.append(query)
@@ -149,10 +170,10 @@ def make_slicer_query(database: Database,
         A collection of filters to apply to the query.
     :param orders:
         A collection of orders as tuples of the metric/dimension to order by and the direction to order in.
+
     :return:
     """
     query = database.query_cls.from_(base_table)
-
     elements = flatten([metrics, dimensions, filters])
 
     # Add joins
@@ -179,6 +200,7 @@ def make_slicer_query(database: Database,
     if terms:
         query = query.select(*terms)
 
+    # Get the aliases for selected elements so missing ones can be included in the query if they are used for sorting
     select_aliases = {el.alias for el in query._selects}
     for (term, orientation) in orders:
         query = query.orderby(term, order=orientation)
diff --git a/fireant/slicer/totals.py b/fireant/slicer/totals.py
new file mode 100644
index 00000000..5160f685
--- /dev/null
+++ b/fireant/slicer/totals.py
@@ -0,0 +1,91 @@
+import sys
+
+import numpy as np
+import pandas as pd
+
+MAX_TIMESTAMP = pd.Timestamp.max
+MAX_NUMBER = sys.maxsize
+MAX_STRING = '~~totals'
+
+TOTALS_MARKERS = {MAX_STRING, MAX_NUMBER, MAX_TIMESTAMP}
+
+
+def get_totals_marker_for_dtype(dtype):
+    """
+    For a given dtype, return the index value to use to indicate that the data frame row contains totals.
+
+    :param dtype:
+    :return:
+    """
+    return {
+        np.dtype('<M8[ns]'): MAX_TIMESTAMP,
+        np.dtype('int64'): MAX_NUMBER,
+        np.dtype('float64'): MAX_NUMBER,
+    }.get(dtype, MAX_STRING)
+
+
+def scrub_totals_from_share_results(data_frame, dimensions):
+    """
+    This function returns a data frame with the values for dimension totals filtered out if the corresponding dimension
+    was not queried with rollup. This comes into play when the share operation is used on metrics which requires the
+    totals across the values.
+
+    There are two different logical branches for this function that perform the same work, one on a single-level index
+    data frame and another for a multi-level index.
+
+    :param data_frame:
+        The result data set.
+    :param dimensions:
+        A list of dimensions that were queried for to produce the result data set.
+    :return:
+        The data frame with totals rows removed for dimensions that were not queried with rollup.
+    """
+    if isinstance(data_frame.index, pd.MultiIndex):
+        return _scrub_totals_for_multilevel_index_df(data_frame, dimensions)
+    return _scrub_totals_for_singlelevel_index_df(data_frame, dimensions)
+
+
+def _scrub_totals_for_singlelevel_index_df(data_frame, dimensions):
+    # For this function, there will only ever be zero or 1 dimensions in the list of dimensions.
+    # If there are zero dimensions or the only dimension is rolled up, then return the data frame as-is
+    is_rolled_up = dimensions and dimensions[0].is_rollup
+    if is_rolled_up:
+        return data_frame
+
+    # Otherwise, remove any rows where the index value equals the totals marker for its dtype.
+    marker = get_totals_marker_for_dtype(data_frame.index.dtype)
+    is_totals = data_frame.index == marker
+    return data_frame[~is_totals]
+
+
+def _scrub_totals_for_multilevel_index_df(data_frame, dimensions):
+    # Get the totals marker value for each index level
+    markers = np.array([get_totals_marker_for_dtype(level.dtype)
+                        for level in data_frame.index.levels])
+
+    # Create a boolean data frame indicating whether or not the index value equals the totals marker for the dtype
+    # corresponding to each index level
+    is_total_marker = pd.DataFrame([values == markers
+                                    for values in data_frame.index],
+                                   index=data_frame.index)
+
+    """
+    If a row in the data frame is for totals for one index level, all of the subsequent index levels will also use a 
+    totals marker. In order to avoid filtering the wrong rows, a new data frame is created similar to `is_totals_marker`
+    except a cell is only set to True if that value is a totals marker for the corresponding index level, the leaves of 
+    the dimension value tree.
+    
+    This is acheived by rolling an XOR function across each index level with the previous level.
+    """
+    first_column = is_total_marker.columns[0]
+    is_totals_marker_leaf = pd.DataFrame(is_total_marker[first_column])
+    for column, prev_column in zip(is_total_marker.columns[1:], list(is_total_marker.columns[:-1])):
+        is_totals_marker_leaf[column] = np.logical_xor(is_total_marker[column], is_total_marker[prev_column])
+
+    # Create a boolean vector for each dimension to mark if that dimension is rolled up
+    rollup_dimensions = np.array([dimension.is_rollup
+                                  for dimension in dimensions])
+
+    # Create a boolean pd.Series where False means to remove the row from the data frame.
+    mask = (~(~rollup_dimensions & is_totals_marker_leaf)).all(axis=1)
+    return data_frame.loc[mask]
diff --git a/fireant/slicer/widgets/datatables.py b/fireant/slicer/widgets/datatables.py
index 233490ca..2f25424c 100644
--- a/fireant/slicer/widgets/datatables.py
+++ b/fireant/slicer/widgets/datatables.py
@@ -8,10 +8,8 @@
     utils,
 )
 from fireant.formats import NULL_VALUE
+from fireant.slicer.totals import TOTALS_MARKERS
 from fireant.utils import (
-    MAX_NUMBER,
-    MAX_STRING,
-    MAX_TIMESTAMP,
     format_dimension_key,
     format_metric_key,
 )
@@ -44,7 +42,7 @@ def _render_dimension_cell(dimension_value: str, display_values: dict):
     dimension_cell = {'value': formats.dimension_value(dimension_value)}
 
     if display_values is not None:
-        if dimension_value in {MAX_STRING, MAX_NUMBER, MAX_TIMESTAMP}:
+        if dimension_value in TOTALS_MARKERS:
             dimension_cell['display'] = 'Totals'
         elif pd.isnull(dimension_value):
             dimension_cell['display'] = NULL_VALUE
diff --git a/fireant/slicer/widgets/helpers.py b/fireant/slicer/widgets/helpers.py
index e32be5d9..2639acb0 100644
--- a/fireant/slicer/widgets/helpers.py
+++ b/fireant/slicer/widgets/helpers.py
@@ -5,19 +5,9 @@
     INF_VALUE,
     NULL_VALUE,
 )
-from fireant.utils import (
-    MAX_NUMBER,
-    MAX_STRING,
-    MAX_TIMESTAMP,
-)
+from fireant.slicer.totals import TOTALS_MARKERS
 from ..references import reference_label
 
-TOTALS_MARKERS = {
-    MAX_NUMBER,
-    MAX_STRING,
-    MAX_TIMESTAMP,
-}
-
 
 def extract_display_values(dimensions, data_frame):
     """
diff --git a/fireant/slicer/widgets/highcharts.py b/fireant/slicer/widgets/highcharts.py
index 5a03cec3..74567307 100644
--- a/fireant/slicer/widgets/highcharts.py
+++ b/fireant/slicer/widgets/highcharts.py
@@ -148,7 +148,8 @@ def transform(self, data_frame, slicer, dimensions, references):
             "legend": {"useHTML": True},
         }
 
-    def _remove_date_totals(self, data_frame):
+    @staticmethod
+    def _remove_date_totals(data_frame):
         """
         This function filters the totals value for the date/time dimension from the result set. There is no way to
         represent this value on a chart so it is just removed.
diff --git a/fireant/slicer/widgets/reacttable.py b/fireant/slicer/widgets/reacttable.py
index 043f6402..245cd1b2 100644
--- a/fireant/slicer/widgets/reacttable.py
+++ b/fireant/slicer/widgets/reacttable.py
@@ -45,11 +45,14 @@
     annually: '%Y',
 }
 from fireant.utils import (
+    format_dimension_key,
+    wrap_list,
+)
+from fireant.slicer.totals import TOTALS_MARKERS
+from fireant.slicer.totals import (
     MAX_NUMBER,
     MAX_STRING,
     MAX_TIMESTAMP,
-    format_dimension_key,
-    wrap_list,
 )
 
 TOTALS_LABEL = 'Totals'
@@ -229,6 +232,7 @@ def format_data_frame(data_frame, dimensions):
             if isinstance(dimension, DatetimeDimension):
                 date_format = DATE_FORMATS.get(dimension.interval, DATE_FORMATS[daily])
 
+                # FIXME https://rollbar.com/KAYAK/Dashmore/items/4426/
                 def format_datetime(dt):
                     if MAX_TIMESTAMP == dt:
                         return TOTALS_LABEL
@@ -339,7 +343,7 @@ def _make_columns(columns_frame, previous_levels=()):
 
             columns = []
             for column_value, group in groups:
-                is_totals = column_value in {MAX_STRING, MAX_NUMBER, TOTALS_LABEL}
+                is_totals = column_value in TOTALS_MARKERS | {TOTALS_LABEL}
 
                 # All column definitions have a header
                 column = {'Header': get_header(column_value, f_dimension_key, is_totals)}
diff --git a/fireant/tests/slicer/mocks.py b/fireant/tests/slicer/mocks.py
index af4a4199..a9dd01f3 100644
--- a/fireant/tests/slicer/mocks.py
+++ b/fireant/tests/slicer/mocks.py
@@ -3,7 +3,6 @@
 )
 from unittest.mock import Mock
 
-import numpy as np
 import pandas as pd
 from datetime import (
     datetime,
@@ -11,10 +10,8 @@
 
 from fireant import *
 from fireant.slicer.references import ReferenceType
+from fireant.slicer.totals import get_totals_marker_for_dtype
 from fireant.utils import (
-    MAX_NUMBER,
-    MAX_STRING,
-    MAX_TIMESTAMP,
     format_dimension_key as fd,
     format_metric_key as fm,
 )
@@ -340,20 +337,11 @@ def ref_delta(ref_data_frame, columns):
 cont_uni_dim_ref_df = ref(cont_uni_dim_df, _columns)
 cont_uni_dim_ref_delta_df = ref_delta(cont_uni_dim_ref_df, _columns)
 
-totals_markers = {
-    np.dtype('<M8[ns]'): MAX_TIMESTAMP,
-    np.dtype('int64'): MAX_NUMBER,
-}
-
 
 def totals(data_frame, dimensions, columns):
     """
     Computes the totals across a dimension and adds the total as an extra row.
     """
-
-    def get_totals_marker_for_dtype(dtype):
-        return totals_markers.get(dtype, MAX_STRING)
-
     if not isinstance(data_frame.index, pd.MultiIndex):
         totals_marker = get_totals_marker_for_dtype(data_frame.index.dtype)
         totals_df = pd.DataFrame([data_frame.sum()],
diff --git a/fireant/tests/slicer/queries/__init__.py b/fireant/tests/slicer/operations/__init__.py
similarity index 100%
rename from fireant/tests/slicer/queries/__init__.py
rename to fireant/tests/slicer/operations/__init__.py
diff --git a/fireant/tests/slicer/test_operations.py b/fireant/tests/slicer/operations/test_cumulative.py
similarity index 75%
rename from fireant/tests/slicer/test_operations.py
rename to fireant/tests/slicer/operations/test_cumulative.py
index a480cfa8..3f5ce441 100644
--- a/fireant/tests/slicer/test_operations.py
+++ b/fireant/tests/slicer/operations/test_cumulative.py
@@ -1,21 +1,19 @@
 from unittest import TestCase
 
-import numpy as np
 import pandas as pd
 import pandas.testing
 
 from fireant import (
-    CumMean,
-    CumProd,
     CumSum,
-    RollingMean,
+    CumProd,
+    CumMean,
 )
 from fireant.tests.slicer.mocks import (
-    ElectionOverElection,
+    slicer,
     cont_dim_df,
     cont_uni_dim_df,
     cont_uni_dim_ref_df,
-    slicer,
+    ElectionOverElection,
 )
 
 
@@ -106,32 +104,3 @@ def test_apply_to_timeseries_with_uni_dim_and_ref(self):
                              name='$m$votes_eoe',
                              index=cont_uni_dim_ref_df.index)
         pandas.testing.assert_series_equal(expected, result)
-
-
-class RollingMeanTests(TestCase):
-    def test_apply_to_timeseries(self):
-        rolling_mean = RollingMean(slicer.metrics.wins, 3)
-        result = rolling_mean.apply(cont_dim_df, None)
-
-        expected = pd.Series([np.nan, np.nan, 2.0, 2.0, 2.0, 2.0],
-                             name='$m$wins',
-                             index=cont_dim_df.index)
-        pandas.testing.assert_series_equal(expected, result)
-
-    def test_apply_to_timeseries_with_uni_dim(self):
-        rolling_mean = RollingMean(slicer.metrics.wins, 3)
-        result = rolling_mean.apply(cont_uni_dim_df, None)
-
-        expected = pd.Series([np.nan, np.nan, np.nan, np.nan, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0],
-                             name='$m$wins',
-                             index=cont_uni_dim_df.index)
-        pandas.testing.assert_series_equal(expected, result)
-
-    def test_apply_to_timeseries_with_uni_dim_and_ref(self):
-        rolling_mean = RollingMean(slicer.metrics.wins, 3)
-        result = rolling_mean.apply(cont_uni_dim_ref_df, ElectionOverElection(slicer.dimensions.timestamp))
-
-        expected = pd.Series([np.nan, np.nan, np.nan, np.nan, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0],
-                             name='$m$wins_eoe',
-                             index=cont_uni_dim_ref_df.index)
-        pandas.testing.assert_series_equal(expected, result)
diff --git a/fireant/tests/slicer/operations/test_rolling.py b/fireant/tests/slicer/operations/test_rolling.py
new file mode 100644
index 00000000..bd0d018c
--- /dev/null
+++ b/fireant/tests/slicer/operations/test_rolling.py
@@ -0,0 +1,43 @@
+from unittest import TestCase
+
+import numpy as np
+import pandas as pd
+import pandas.testing
+
+from fireant import RollingMean
+from fireant.tests.slicer.mocks import (
+    slicer,
+    cont_dim_df,
+    cont_uni_dim_df,
+    cont_uni_dim_ref_df,
+    ElectionOverElection,
+)
+
+
+class RollingMeanTests(TestCase):
+    def test_apply_to_timeseries(self):
+        rolling_mean = RollingMean(slicer.metrics.wins, 3)
+        result = rolling_mean.apply(cont_dim_df, None)
+
+        expected = pd.Series([np.nan, np.nan, 2.0, 2.0, 2.0, 2.0],
+                             name='$m$wins',
+                             index=cont_dim_df.index)
+        pandas.testing.assert_series_equal(expected, result)
+
+    def test_apply_to_timeseries_with_uni_dim(self):
+        rolling_mean = RollingMean(slicer.metrics.wins, 3)
+        result = rolling_mean.apply(cont_uni_dim_df, None)
+
+        expected = pd.Series([np.nan, np.nan, np.nan, np.nan, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0],
+                             name='$m$wins',
+                             index=cont_uni_dim_df.index)
+        pandas.testing.assert_series_equal(expected, result)
+
+    def test_apply_to_timeseries_with_uni_dim_and_ref(self):
+        rolling_mean = RollingMean(slicer.metrics.wins, 3)
+        result = rolling_mean.apply(cont_uni_dim_ref_df, ElectionOverElection(slicer.dimensions.timestamp))
+
+        expected = pd.Series([np.nan, np.nan, np.nan, np.nan, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0],
+                             name='$m$wins_eoe',
+                             index=cont_uni_dim_ref_df.index)
+        pandas.testing.assert_series_equal(expected, result)
diff --git a/fireant/tests/slicer/operations/test_share.py b/fireant/tests/slicer/operations/test_share.py
new file mode 100644
index 00000000..8f50e126
--- /dev/null
+++ b/fireant/tests/slicer/operations/test_share.py
@@ -0,0 +1,120 @@
+from unittest import TestCase
+
+import pandas as pd
+import pandas.testing
+
+from fireant import Share
+from fireant.tests.slicer.mocks import (
+    cat_dim_df,
+    cat_dim_totals_df,
+    cont_uni_dim_all_totals_df,
+    cont_uni_dim_df,
+    cont_uni_dim_totals_df,
+    single_metric_df,
+    slicer,
+)
+from fireant.utils import format_metric_key
+
+
+class ShareTests(TestCase):
+    def test_apply_to_zero_dims(self):
+        share = Share(slicer.metrics.votes)
+        result = share.apply(single_metric_df, None)
+
+        f_metric_key = format_metric_key(slicer.metrics.votes.key)
+
+        expected = pd.Series([100.],
+                             name=f_metric_key)
+        pandas.testing.assert_series_equal(expected, result)
+
+    def test_apply_to_one_dim_over_first(self):
+        share = Share(slicer.metrics.votes, over=slicer.dimensions.political_party)
+        result = share.apply(cat_dim_totals_df, None)
+
+        f_metric_key = format_metric_key(slicer.metrics.votes.key)
+
+        expected = pd.Series([48.849, 0.964, 50.187, 100.0],
+                             name=f_metric_key,
+                             index=cat_dim_totals_df.index)
+        pandas.testing.assert_series_equal(expected, result, check_less_precise=True)
+
+    def test_apply_to_one_dim_over_none(self):
+        share = Share(slicer.metrics.votes)
+        result = share.apply(cat_dim_df, None)
+
+        f_metric_key = format_metric_key(slicer.metrics.votes.key)
+
+        expected = pd.Series([100.] * 3,
+                             name=f_metric_key,
+                             index=cat_dim_df.index)
+        pandas.testing.assert_series_equal(expected, result, check_less_precise=True)
+
+    def test_apply_to_two_dims_over_first(self):
+        share = Share(slicer.metrics.votes, over=slicer.dimensions.timestamp)
+        result = share.apply(cont_uni_dim_all_totals_df, None)
+
+        f_metric_key = format_metric_key(slicer.metrics.votes.key)
+
+        metric_series = cont_uni_dim_all_totals_df[f_metric_key]
+        expected = 100 * metric_series / metric_series.iloc[-1]
+        pandas.testing.assert_series_equal(expected, result, check_less_precise=True)
+
+    def test_apply_to_two_dims_over_second(self):
+        share = Share(slicer.metrics.votes, over=slicer.dimensions.state)
+        result = share.apply(cont_uni_dim_totals_df, None)
+
+        f_metric_key = format_metric_key(slicer.metrics.votes.key)
+
+        expected = pd.Series([36.624, 63.376, 100.,
+                              37.411, 62.589, 100.,
+                              37.521, 62.479, 100.,
+                              37.606, 62.394, 100.,
+                              38.294, 61.706, 100.,
+                              27.705, 72.295, 100.],
+                             name=f_metric_key,
+                             index=cont_uni_dim_totals_df.index)
+
+        pandas.testing.assert_series_equal(expected, result, check_less_precise=True)
+
+    def test_apply_to_two_dims_over_second_all_totals(self):
+        share = Share(slicer.metrics.votes, over=slicer.dimensions.state)
+        result = share.apply(cont_uni_dim_all_totals_df, None)
+
+        f_metric_key = format_metric_key(slicer.metrics.votes.key)
+
+        expected = pd.Series([36.624, 63.376, 100.,
+                              37.411, 62.589, 100.,
+                              37.521, 62.479, 100.,
+                              37.606, 62.394, 100.,
+                              38.294, 61.706, 100.,
+                              27.705, 72.295, 100.,
+                              100.],
+                             name=f_metric_key,
+                             index=cont_uni_dim_all_totals_df.index)
+
+        pandas.testing.assert_series_equal(expected, result, check_less_precise=True)
+
+    def test_apply_to_two_dims_over_second_with_one_row_per_group(self):
+        raw_df = cont_uni_dim_totals_df.iloc[[0, 2, 3, 5]]
+
+        share = Share(slicer.metrics.votes, over=slicer.dimensions.state)
+        result = share.apply(raw_df, None)
+
+        f_metric_key = format_metric_key(slicer.metrics.votes.key)
+
+        expected = pd.Series([36.624, 100., 37.411, 100.],
+                             name=f_metric_key,
+                             index=raw_df.index)
+
+        pandas.testing.assert_series_equal(expected, result, check_less_precise=True)
+
+    def test_apply_to_two_dims_over_none(self):
+        share = Share(slicer.metrics.votes)
+        result = share.apply(cont_uni_dim_df, None)
+
+        f_metric_key = format_metric_key(slicer.metrics.votes.key)
+
+        expected = pd.Series([100.] * 12,
+                             name=f_metric_key,
+                             index=cont_uni_dim_df.index)
+        pandas.testing.assert_series_equal(expected, result, check_less_precise=True)
diff --git a/fireant/tests/slicer/query_builder/__init__.py b/fireant/tests/slicer/query_builder/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/fireant/tests/slicer/queries/test_build_dimension_filters.py b/fireant/tests/slicer/query_builder/test_build_dimension_filters.py
similarity index 100%
rename from fireant/tests/slicer/queries/test_build_dimension_filters.py
rename to fireant/tests/slicer/query_builder/test_build_dimension_filters.py
diff --git a/fireant/tests/slicer/queries/test_build_dimensions.py b/fireant/tests/slicer/query_builder/test_build_dimensions.py
similarity index 100%
rename from fireant/tests/slicer/queries/test_build_dimensions.py
rename to fireant/tests/slicer/query_builder/test_build_dimensions.py
diff --git a/fireant/tests/slicer/queries/test_build_joins.py b/fireant/tests/slicer/query_builder/test_build_joins.py
similarity index 100%
rename from fireant/tests/slicer/queries/test_build_joins.py
rename to fireant/tests/slicer/query_builder/test_build_joins.py
diff --git a/fireant/tests/slicer/queries/test_build_metric_filters.py b/fireant/tests/slicer/query_builder/test_build_metric_filters.py
similarity index 100%
rename from fireant/tests/slicer/queries/test_build_metric_filters.py
rename to fireant/tests/slicer/query_builder/test_build_metric_filters.py
diff --git a/fireant/tests/slicer/queries/test_build_metrics.py b/fireant/tests/slicer/query_builder/test_build_metrics.py
similarity index 100%
rename from fireant/tests/slicer/queries/test_build_metrics.py
rename to fireant/tests/slicer/query_builder/test_build_metrics.py
diff --git a/fireant/tests/slicer/queries/test_build_operations.py b/fireant/tests/slicer/query_builder/test_build_operations.py
similarity index 100%
rename from fireant/tests/slicer/queries/test_build_operations.py
rename to fireant/tests/slicer/query_builder/test_build_operations.py
diff --git a/fireant/tests/slicer/queries/test_build_orderbys.py b/fireant/tests/slicer/query_builder/test_build_orderbys.py
similarity index 100%
rename from fireant/tests/slicer/queries/test_build_orderbys.py
rename to fireant/tests/slicer/query_builder/test_build_orderbys.py
diff --git a/fireant/tests/slicer/queries/test_build_pagination.py b/fireant/tests/slicer/query_builder/test_build_pagination.py
similarity index 100%
rename from fireant/tests/slicer/queries/test_build_pagination.py
rename to fireant/tests/slicer/query_builder/test_build_pagination.py
diff --git a/fireant/tests/slicer/queries/test_build_references.py b/fireant/tests/slicer/query_builder/test_build_references.py
similarity index 97%
rename from fireant/tests/slicer/queries/test_build_references.py
rename to fireant/tests/slicer/query_builder/test_build_references.py
index 45a28357..d2bc11f8 100644
--- a/fireant/tests/slicer/queries/test_build_references.py
+++ b/fireant/tests/slicer/query_builder/test_build_references.py
@@ -16,7 +16,7 @@ def test_single_reference_dod_with_no_dimension_uses_multiple_from_clauses_inste
             .reference(f.DayOverDay(slicer.dimensions.timestamp)) \
             .queries
 
-        self.assertEqual(len(queries), 2)
+        self.assertEqual(2, len(queries))
 
         with self.subTest('base query is same as without reference'):
             self.assertEqual('SELECT '
@@ -37,7 +37,7 @@ def test_single_reference_dod_with_dimension_but_not_reference_dimension_in_quer
             .filter(slicer.dimensions.timestamp.between(date(2000, 1, 1), date(2000, 3, 1))) \
             .queries
 
-        self.assertEqual(len(queries), 2)
+        self.assertEqual(2, len(queries))
 
         with self.subTest('base query is same as without reference'):
             self.assertEqual('SELECT '
@@ -65,7 +65,7 @@ def test_dimension_with_single_reference_dod(self):
             .reference(f.DayOverDay(slicer.dimensions.timestamp)) \
             .queries
 
-        self.assertEqual(len(queries), 2)
+        self.assertEqual(2, len(queries))
 
         with self.subTest('base query is same as without reference'):
             self.assertEqual('SELECT '
@@ -91,7 +91,7 @@ def test_dimension_with_single_reference_wow(self):
             .reference(f.WeekOverWeek(slicer.dimensions.timestamp)) \
             .queries
 
-        self.assertEqual(len(queries), 2)
+        self.assertEqual(2, len(queries))
 
         with self.subTest('base query is same as without reference'):
             self.assertEqual('SELECT '
@@ -117,7 +117,7 @@ def test_dimension_with_single_reference_mom(self):
             .reference(f.MonthOverMonth(slicer.dimensions.timestamp)) \
             .queries
 
-        self.assertEqual(len(queries), 2)
+        self.assertEqual(2, len(queries))
 
         with self.subTest('base query is same as without reference'):
             self.assertEqual('SELECT '
@@ -143,7 +143,7 @@ def test_dimension_with_single_reference_qoq(self):
             .reference(f.QuarterOverQuarter(slicer.dimensions.timestamp)) \
             .queries
 
-        self.assertEqual(len(queries), 2)
+        self.assertEqual(2, len(queries))
 
         with self.subTest('base query is same as without reference'):
             self.assertEqual('SELECT '
@@ -169,7 +169,7 @@ def test_dimension_with_single_reference_yoy(self):
             .reference(f.YearOverYear(slicer.dimensions.timestamp)) \
             .queries
 
-        self.assertEqual(len(queries), 2)
+        self.assertEqual(2, len(queries))
 
         with self.subTest('base query is same as without reference'):
             self.assertEqual('SELECT '
@@ -200,7 +200,7 @@ def test_dimension_with_single_reference_as_a_delta(self):
             .reference(f.DayOverDay(slicer.dimensions.timestamp, delta=True)) \
             .queries
 
-        self.assertEqual(len(queries), 2)
+        self.assertEqual(2, len(queries))
 
         with self.subTest('base query is same as without reference'):
             self.assertEqual('SELECT '
@@ -226,7 +226,7 @@ def test_dimension_with_single_reference_as_a_delta_percentage(self):
             .reference(f.DayOverDay(slicer.dimensions.timestamp, delta_percent=True)) \
             .queries
 
-        self.assertEqual(len(queries), 2)
+        self.assertEqual(2, len(queries))
 
         with self.subTest('base query is same as without reference'):
             self.assertEqual('SELECT '
@@ -258,7 +258,7 @@ def test_reference_on_dimension_with_weekly_interval(self):
             .reference(f.DayOverDay(weekly_timestamp)) \
             .queries
 
-        self.assertEqual(len(queries), 2)
+        self.assertEqual(2, len(queries))
 
         with self.subTest('base query is same as without reference'):
             self.assertEqual('SELECT '
@@ -284,7 +284,7 @@ def test_reference_on_dimension_with_weekly_interval_no_interval_on_reference(se
             .reference(f.DayOverDay(slicer.dimensions.timestamp)) \
             .queries
 
-        self.assertEqual(len(queries), 2)
+        self.assertEqual(2, len(queries))
 
         with self.subTest('base query is same as without reference'):
             self.assertEqual('SELECT '
@@ -310,7 +310,7 @@ def test_reference_on_dimension_with_monthly_interval(self):
             .reference(f.DayOverDay(slicer.dimensions.timestamp)) \
             .queries
 
-        self.assertEqual(len(queries), 2)
+        self.assertEqual(2, len(queries))
 
         with self.subTest('base query is same as without reference'):
             self.assertEqual('SELECT '
@@ -336,7 +336,7 @@ def test_reference_on_dimension_with_quarterly_interval(self):
             .reference(f.DayOverDay(slicer.dimensions.timestamp)) \
             .queries
 
-        self.assertEqual(len(queries), 2)
+        self.assertEqual(2, len(queries))
 
         with self.subTest('base query is same as without reference'):
             self.assertEqual('SELECT '
@@ -362,7 +362,7 @@ def test_reference_on_dimension_with_annual_interval(self):
             .reference(f.DayOverDay(slicer.dimensions.timestamp)) \
             .queries
 
-        self.assertEqual(len(queries), 2)
+        self.assertEqual(2, len(queries))
 
         with self.subTest('base query is same as without reference'):
             self.assertEqual('SELECT '
@@ -394,7 +394,7 @@ def test_dimension_with_multiple_references(self):
             .reference(f.YearOverYear(slicer.dimensions.timestamp, delta_percent=True)) \
             .queries
 
-        self.assertEqual(len(queries), 3)
+        self.assertEqual(3, len(queries))
 
         with self.subTest('base query is same as without reference'):
             self.assertEqual('SELECT '
@@ -429,7 +429,7 @@ def test_adding_duplicate_reference_does_not_join_more_queries(self):
                        f.DayOverDay(slicer.dimensions.timestamp)) \
             .queries
 
-        self.assertEqual(len(queries), 2)
+        self.assertEqual(2, len(queries))
 
         with self.subTest('base query is same as without reference'):
             self.assertEqual('SELECT '
@@ -457,7 +457,7 @@ def test_use_same_nested_query_for_joining_references_with_same_period_and_dimen
                        f.DayOverDay(slicer.dimensions.timestamp, delta_percent=True)) \
             .queries
 
-        self.assertEqual(len(queries), 2)
+        self.assertEqual(2, len(queries))
 
         with self.subTest('base query is same as without reference'):
             self.assertEqual('SELECT '
@@ -486,7 +486,7 @@ def test_use_same_nested_query_for_joining_references_with_same_period_and_dimen
                        f.YearOverYear(slicer.dimensions.timestamp, delta=True)) \
             .queries
 
-        self.assertEqual(len(queries), 3)
+        self.assertEqual(3, len(queries))
 
         with self.subTest('base query is same as without reference'):
             self.assertEqual('SELECT '
@@ -526,7 +526,7 @@ def test_reference_queries_with_multiple_dimensions_includes_all_dimensions(self
             .reference(f.YearOverYear(slicer.dimensions.timestamp)) \
             .queries
 
-        self.assertEqual(len(queries), 2)
+        self.assertEqual(2, len(queries))
 
         with self.subTest('base query is same as without reference'):
             self.assertEqual('SELECT '
@@ -555,7 +555,7 @@ def test_reference_with_dimension_using_display_definition_includes_it_in_all_qu
             .reference(f.YearOverYear(slicer.dimensions.timestamp)) \
             .queries
 
-        self.assertEqual(len(queries), 2)
+        self.assertEqual(2, len(queries))
 
         with self.subTest('base query is same as without reference'):
             self.assertEqual('SELECT '
@@ -587,7 +587,7 @@ def test_filters_on_reference_dimension_are_adapted_to_reference_interval(self):
                     .between(date(2018, 1, 1), date(2018, 1, 31))) \
             .queries
 
-        self.assertEqual(len(queries), 2)
+        self.assertEqual(2, len(queries))
 
         with self.subTest('base query is same as without reference'):
             self.assertEqual('SELECT '
@@ -619,7 +619,7 @@ def test_filters_on_other_dimensions_are_not_adapted(self):
                     .isin(['d'])) \
             .queries
 
-        self.assertEqual(len(queries), 2)
+        self.assertEqual(2, len(queries))
 
         with self.subTest('base query is same as without reference'):
             self.assertEqual('SELECT '
@@ -654,7 +654,7 @@ def test_adapt_dow_for_leap_year_for_yoy_reference(self):
             .reference(f.YearOverYear(slicer.dimensions.timestamp)) \
             .queries
 
-        self.assertEqual(len(queries), 2)
+        self.assertEqual(2, len(queries))
 
         with self.subTest('base query is same as without reference'):
             self.assertEqual('SELECT '
@@ -682,7 +682,7 @@ def test_adapt_dow_for_leap_year_for_yoy_reference_with_date_filter(self):
             .filter(slicer.dimensions.timestamp.between(date(2018, 1, 1), date(2018, 1, 31))) \
             .queries
 
-        self.assertEqual(len(queries), 2)
+        self.assertEqual(2, len(queries))
 
         with self.subTest('base query is same as without reference'):
             self.assertEqual('SELECT '
diff --git a/fireant/tests/slicer/queries/test_builder.py b/fireant/tests/slicer/query_builder/test_builder.py
similarity index 100%
rename from fireant/tests/slicer/queries/test_builder.py
rename to fireant/tests/slicer/query_builder/test_builder.py
diff --git a/fireant/tests/slicer/queries/test_database.py b/fireant/tests/slicer/query_builder/test_database.py
similarity index 91%
rename from fireant/tests/slicer/queries/test_database.py
rename to fireant/tests/slicer/query_builder/test_database.py
index cadf549b..62c05b43 100644
--- a/fireant/tests/slicer/queries/test_database.py
+++ b/fireant/tests/slicer/query_builder/test_database.py
@@ -8,7 +8,7 @@
 
 import pandas as pd
 
-from fireant.slicer.queries.database import _do_fetch_data
+from fireant.slicer.queries.execution import _do_fetch_data
 from fireant.tests.slicer.mocks import (
     cat_dim_df,
     cont_uni_dim_df,
@@ -35,7 +35,7 @@ def setUp(self):
         self.mock_dimensions[1].is_rollup = True
 
     def test_do_fetch_data_calls_database_fetch_data(self, ):
-        with patch('fireant.slicer.queries.database.pd.read_sql', return_value=self.mock_data_frame) as mock_read_sql:
+        with patch('fireant.slicer.queries.execution.pd.read_sql', return_value=self.mock_data_frame) as mock_read_sql:
             _do_fetch_data(self.mock_query, self.mock_database)
 
             mock_read_sql.assert_called_once_with(self.mock_query,
@@ -44,7 +44,7 @@ def test_do_fetch_data_calls_database_fetch_data(self, ):
                                                   parse_dates=True)
 
 
-@patch('fireant.slicer.queries.database.pd.read_sql')
+@patch('fireant.slicer.queries.execution.pd.read_sql')
 class FetchDataLoggingTests(TestCase):
     def setUp(self):
         self.mock_query = 'SELECT *'
@@ -62,21 +62,21 @@ def setUp(self):
         self.mock_dimensions[0].is_rollup = False
         self.mock_dimensions[1].is_rollup = False
 
-    @patch('fireant.slicer.queries.database.query_logger')
+    @patch('fireant.slicer.queries.execution.query_logger')
     def test_debug_query_log_called_with_query(self, mock_logger, *mocks):
         _do_fetch_data(self.mock_query, self.mock_database)
 
         mock_logger.debug.assert_called_once_with('SELECT *')
 
     @patch.object(time, 'time', return_value=1520520255.0)
-    @patch('fireant.slicer.queries.database.query_logger')
+    @patch('fireant.slicer.queries.execution.query_logger')
     def test_info_query_log_called_with_query_and_duration(self, mock_logger, *mocks):
         _do_fetch_data(self.mock_query, self.mock_database)
 
         mock_logger.info.assert_called_once_with('[0.0 seconds]: SELECT *')
 
     @patch.object(time, 'time')
-    @patch('fireant.slicer.queries.database.slow_query_logger')
+    @patch('fireant.slicer.queries.execution.slow_query_logger')
     def test_warning_slow_query_logger_called_with_duration_and_query_if_over_slow_query_limit(self,
                                                                                                mock_logger,
                                                                                                mock_time,
@@ -87,7 +87,7 @@ def test_warning_slow_query_logger_called_with_duration_and_query_if_over_slow_q
         mock_logger.warning.assert_called_once_with('[22.0 seconds]: SELECT *')
 
     @patch.object(time, 'time')
-    @patch('fireant.slicer.queries.database.slow_query_logger')
+    @patch('fireant.slicer.queries.execution.slow_query_logger')
     def test_warning_slow_query_logger_not_called_with_duration_and_query_if_not_over_slow_query_limit(self,
                                                                                                        mock_logger,
                                                                                                        mock_time,
diff --git a/fireant/tests/slicer/queries/test_dimension_choices.py b/fireant/tests/slicer/query_builder/test_dimension_choices.py
similarity index 100%
rename from fireant/tests/slicer/queries/test_dimension_choices.py
rename to fireant/tests/slicer/query_builder/test_dimension_choices.py
diff --git a/fireant/tests/slicer/queries/test_dimension_latest.py b/fireant/tests/slicer/query_builder/test_dimension_latest.py
similarity index 100%
rename from fireant/tests/slicer/queries/test_dimension_latest.py
rename to fireant/tests/slicer/query_builder/test_dimension_latest.py
diff --git a/fireant/tests/slicer/queries/test_build_render.py b/fireant/tests/slicer/query_builder/test_fetch_data.py
similarity index 71%
rename from fireant/tests/slicer/queries/test_build_render.py
rename to fireant/tests/slicer/query_builder/test_fetch_data.py
index 9a93973e..d50525c8 100644
--- a/fireant/tests/slicer/queries/test_build_render.py
+++ b/fireant/tests/slicer/query_builder/test_fetch_data.py
@@ -2,14 +2,11 @@
 from unittest.mock import (
     ANY,
     Mock,
-    call,
     patch,
 )
 
 import fireant as f
-from fireant.utils import (
-    format_metric_key,
-)
+from fireant import Share
 from pypika import (
     Order,
     functions as fn,
@@ -18,16 +15,75 @@
     DimensionMatcher,
     PypikaQueryMatcher,
 )
-from ..mocks import (
-    ElectionOverElection,
-    slicer,
-)
+from ..mocks import slicer
+
+
+# noinspection SqlDialectInspection,SqlNoDataSourceInspection
+@patch('fireant.slicer.queries.builder.paginate')
+@patch('fireant.slicer.queries.builder.fetch_data')
+class FindShareDimensionsTests(TestCase):
+    def test_find_no_share_dimensions_with_no_share_operation(self, mock_fetch_data: Mock, mock_paginate: Mock):
+        mock_widget = f.Widget(slicer.metrics.votes)
+        mock_widget.transform = Mock()
+
+        dimensions = slicer.dimensions.timestamp, slicer.dimensions.state, slicer.dimensions.political_party
+
+        slicer.data \
+            .widget(mock_widget) \
+            .dimension(*dimensions) \
+            .fetch()
+
+        mock_fetch_data.assert_called_once_with(ANY, ANY, ANY, [], ANY)
+
+    def test_find_share_dimensions_with_a_single_share_operation(self, mock_fetch_data: Mock, mock_paginate: Mock):
+        mock_widget = f.Widget(Share(slicer.metrics.votes, over=slicer.dimensions.state))
+        mock_widget.transform = Mock()
+
+        dimensions = slicer.dimensions.timestamp, slicer.dimensions.state, slicer.dimensions.political_party
+
+        slicer.data \
+            .widget(mock_widget) \
+            .dimension(*dimensions) \
+            .fetch()
+
+        mock_fetch_data.assert_called_once_with(ANY, ANY, ANY, DimensionMatcher(slicer.dimensions.state), ANY)
+
+    def test_find_share_dimensions_with_a_multiple_share_operations(self, mock_fetch_data: Mock, mock_paginate: Mock):
+        mock_widget = f.Widget(Share(slicer.metrics.votes, over=slicer.dimensions.state),
+                               Share(slicer.metrics.wins, over=slicer.dimensions.state))
+        mock_widget.transform = Mock()
+
+        dimensions = slicer.dimensions.timestamp, slicer.dimensions.state, slicer.dimensions.political_party
+
+        slicer.data \
+            .widget(mock_widget) \
+            .dimension(*dimensions) \
+            .fetch()
+
+        mock_fetch_data.assert_called_once_with(ANY, ANY, ANY, DimensionMatcher(slicer.dimensions.state), ANY)
+
+    def test_find_share_dimensions_with_a_multiple_share_operations_over_different_dimensions(self,
+                                                                                              mock_fetch_data: Mock,
+                                                                                              mock_paginate: Mock):
+        mock_widget = f.Widget(Share(slicer.metrics.votes, over=slicer.dimensions.state),
+                               Share(slicer.metrics.wins, over=slicer.dimensions.political_party))
+        mock_widget.transform = Mock()
+
+        dimensions = slicer.dimensions.timestamp, slicer.dimensions.state, slicer.dimensions.political_party
+
+        slicer.data \
+            .widget(mock_widget) \
+            .dimension(*dimensions) \
+            .fetch()
+
+        expected = DimensionMatcher(slicer.dimensions.state, slicer.dimensions.political_party)
+        mock_fetch_data.assert_called_once_with(ANY, ANY, ANY, expected, ANY)
 
 
 # noinspection SqlDialectInspection,SqlNoDataSourceInspection
 @patch('fireant.slicer.queries.builder.paginate')
 @patch('fireant.slicer.queries.builder.fetch_data')
-class QueryBuilderRenderTests(TestCase):
+class QueryBuilderFetchDataTests(TestCase):
     def test_pass_slicer_database_as_arg(self, mock_fetch_data: Mock, mock_paginate: Mock):
         mock_widget = f.Widget(slicer.metrics.votes)
         mock_widget.transform = Mock()
@@ -36,10 +92,7 @@ def test_pass_slicer_database_as_arg(self, mock_fetch_data: Mock, mock_paginate:
             .widget(mock_widget) \
             .fetch()
 
-        mock_fetch_data.assert_called_once_with(slicer.database,
-                                                ANY,
-                                                ANY,
-                                                ANY)
+        mock_fetch_data.assert_called_once_with(slicer.database, ANY, ANY, ANY, ANY)
 
     def test_pass_query_from_builder_as_arg(self, mock_fetch_data: Mock, mock_paginate: Mock):
         mock_widget = f.Widget(slicer.metrics.votes)
@@ -53,6 +106,7 @@ def test_pass_query_from_builder_as_arg(self, mock_fetch_data: Mock, mock_pagina
                                                 [PypikaQueryMatcher('SELECT SUM("votes") "$m$votes" '
                                                                     'FROM "politics"."politician"')],
                                                 ANY,
+                                                ANY,
                                                 ANY)
 
     def test_builder_dimensions_as_arg_with_zero_dimensions(self, mock_fetch_data: Mock, mock_paginate: Mock):
@@ -63,7 +117,7 @@ def test_builder_dimensions_as_arg_with_zero_dimensions(self, mock_fetch_data: M
             .widget(mock_widget) \
             .fetch()
 
-        mock_fetch_data.assert_called_once_with(ANY, ANY, [], ANY)
+        mock_fetch_data.assert_called_once_with(ANY, ANY, [], ANY, ANY)
 
     def test_builder_dimensions_as_arg_with_one_dimension(self, mock_fetch_data: Mock, mock_paginate: Mock):
         mock_widget = f.Widget(slicer.metrics.votes)
@@ -76,7 +130,7 @@ def test_builder_dimensions_as_arg_with_one_dimension(self, mock_fetch_data: Moc
             .dimension(*dimensions) \
             .fetch()
 
-        mock_fetch_data.assert_called_once_with(ANY, ANY, DimensionMatcher(*dimensions), ANY)
+        mock_fetch_data.assert_called_once_with(ANY, ANY, DimensionMatcher(*dimensions), ANY, ANY)
 
     def test_builder_dimensions_as_arg_with_multiple_dimensions(self, mock_fetch_data: Mock, mock_paginate: Mock):
         mock_widget = f.Widget(slicer.metrics.votes)
@@ -89,7 +143,7 @@ def test_builder_dimensions_as_arg_with_multiple_dimensions(self, mock_fetch_dat
             .dimension(*dimensions) \
             .fetch()
 
-        mock_fetch_data.assert_called_once_with(ANY, ANY, DimensionMatcher(*dimensions), ANY)
+        mock_fetch_data.assert_called_once_with(ANY, ANY, DimensionMatcher(*dimensions), ANY, ANY)
 
     def test_call_transform_on_widget(self, mock_fetch_data: Mock, mock_paginate: Mock):
         mock_widget = f.Widget(slicer.metrics.votes)
@@ -119,10 +173,11 @@ def test_returns_results_from_widget_transform(self, mock_fetch_data: Mock, mock
         self.assertListEqual(result, [mock_widget.transform.return_value])
 
 
+@patch('fireant.slicer.queries.builder.scrub_totals_from_share_results', side_effect=lambda *args: args[0])
 @patch('fireant.slicer.queries.builder.paginate')
 @patch('fireant.slicer.queries.builder.fetch_data')
 class QueryBuilderPaginationTests(TestCase):
-    def test_paginate_is_called(self, mock_fetch_data: Mock, mock_paginate: Mock):
+    def test_paginate_is_called(self, mock_fetch_data: Mock, mock_paginate: Mock, *mocks):
         mock_widget = f.Widget(slicer.metrics.votes)
         mock_widget.transform = Mock()
         # Need to keep widget the last call in the chain otherwise the object gets cloned and the assertion won't work
@@ -134,7 +189,7 @@ def test_paginate_is_called(self, mock_fetch_data: Mock, mock_paginate: Mock):
         mock_paginate.assert_called_once_with(mock_fetch_data.return_value, [mock_widget],
                                               limit=None, offset=None, orders=[])
 
-    def test_pagination_applied_with_limit(self, mock_fetch_data: Mock, mock_paginate: Mock):
+    def test_pagination_applied_with_limit(self, mock_fetch_data: Mock, mock_paginate: Mock, *mocks):
         mock_widget = f.Widget(slicer.metrics.votes)
         mock_widget.transform = Mock()
 
@@ -148,7 +203,7 @@ def test_pagination_applied_with_limit(self, mock_fetch_data: Mock, mock_paginat
         mock_paginate.assert_called_once_with(mock_fetch_data.return_value, [mock_widget],
                                               limit=15, offset=None, orders=[])
 
-    def test_pagination_applied_with_offset(self, mock_fetch_data: Mock, mock_paginate: Mock):
+    def test_pagination_applied_with_offset(self, mock_fetch_data: Mock, mock_paginate: Mock, *mocks):
         mock_widget = f.Widget(slicer.metrics.votes)
         mock_widget.transform = Mock()
 
@@ -163,7 +218,7 @@ def test_pagination_applied_with_offset(self, mock_fetch_data: Mock, mock_pagina
         mock_paginate.assert_called_once_with(mock_fetch_data.return_value, [mock_widget],
                                               limit=15, offset=20, orders=[])
 
-    def test_pagination_applied_with_orders(self, mock_fetch_data: Mock, mock_paginate: Mock):
+    def test_pagination_applied_with_orders(self, mock_fetch_data: Mock, mock_paginate: Mock, *mocks):
         mock_widget = f.Widget(slicer.metrics.votes)
         mock_widget.transform = Mock()
 
@@ -180,70 +235,3 @@ def test_pagination_applied_with_orders(self, mock_fetch_data: Mock, mock_pagina
                                               limit=None, offset=None, orders=orders)
 
 
-@patch('fireant.slicer.queries.builder.paginate')
-@patch('fireant.slicer.queries.builder.fetch_data')
-class QueryBuilderOperationsTests(TestCase):
-    def test_operations_evaluated(self, mock_fetch_data: Mock, mock_paginate: Mock):
-        mock_operation = Mock(name='mock_operation ', spec=f.Operation)
-        mock_operation.key, mock_operation.definition = 'mock_operation', slicer.table.abc
-        mock_operation.metrics = []
-
-        mock_widget = f.Widget(mock_operation)
-        mock_widget.transform = Mock()
-
-        mock_df = {}
-        mock_fetch_data.return_value = mock_df
-
-        # Need to keep widget the last call in the chain otherwise the object gets cloned and the assertion won't work
-        slicer.data \
-            .dimension(slicer.dimensions.timestamp) \
-            .widget(mock_widget) \
-            .fetch()
-
-        mock_operation.apply.assert_called_once_with(mock_df, None)
-
-    def test_operations_evaluated_for_each_reference(self, mock_fetch_data: Mock, mock_paginate: Mock):
-        eoe = ElectionOverElection(slicer.dimensions.timestamp)
-
-        mock_operation = Mock(name='mock_operation ', spec=f.Operation)
-        mock_operation.key, mock_operation.definition = 'mock_operation', slicer.table.abc
-        mock_operation.metrics = []
-
-        mock_widget = f.Widget(mock_operation)
-        mock_widget.transform = Mock()
-
-        mock_df = {}
-        mock_fetch_data.return_value = mock_df
-
-        # Need to keep widget the last call in the chain otherwise the object gets cloned and the assertion won't work
-        slicer.data \
-            .dimension(slicer.dimensions.timestamp) \
-            .reference(eoe) \
-            .widget(mock_widget) \
-            .fetch()
-
-        mock_operation.apply.assert_has_calls([
-            call(mock_df, None),
-            call(mock_df, eoe),
-        ])
-
-    def test_operations_results_stored_in_data_frame(self, mock_fetch_data: Mock, mock_paginate: Mock):
-        mock_operation = Mock(name='mock_operation ', spec=f.Operation)
-        mock_operation.key, mock_operation.definition = 'mock_operation', slicer.table.abc
-        mock_operation.metrics = []
-
-        mock_widget = f.Widget(mock_operation)
-        mock_widget.transform = Mock()
-
-        mock_df = {}
-        mock_fetch_data.return_value = mock_df
-
-        # Need to keep widget the last call in the chain otherwise the object gets cloned and the assertion won't work
-        slicer.data \
-            .dimension(slicer.dimensions.timestamp) \
-            .widget(mock_widget) \
-            .fetch()
-
-        f_op_key = format_metric_key(mock_operation.key)
-        self.assertIn(f_op_key, mock_df)
-        self.assertEqual(mock_df[f_op_key], mock_operation.apply.return_value)
diff --git a/fireant/tests/slicer/queries/test_latest_data.py b/fireant/tests/slicer/query_builder/test_latest_data.py
similarity index 100%
rename from fireant/tests/slicer/queries/test_latest_data.py
rename to fireant/tests/slicer/query_builder/test_latest_data.py
diff --git a/fireant/tests/slicer/query_builder/test_pagination.py b/fireant/tests/slicer/query_builder/test_pagination.py
new file mode 100644
index 00000000..5828bf56
--- /dev/null
+++ b/fireant/tests/slicer/query_builder/test_pagination.py
@@ -0,0 +1,83 @@
+from unittest import TestCase
+from unittest.mock import (
+    Mock,
+    call,
+    patch,
+)
+
+import fireant as f
+from fireant.tests.slicer.mocks import (
+    ElectionOverElection,
+    slicer,
+)
+from fireant.utils import format_metric_key
+
+
+@patch('fireant.slicer.queries.builder.scrub_totals_from_share_results', side_effect=lambda *args, **kwargs: args[0])
+@patch('fireant.slicer.queries.builder.paginate', side_effect=lambda *args, **kwargs: args[0])
+@patch('fireant.slicer.queries.builder.fetch_data')
+class QueryBuilderOperationsTests(TestCase):
+    def test_operations_evaluated(self, mock_fetch_data: Mock, *mocks):
+        mock_operation = Mock(name='mock_operation ', spec=f.Operation)
+        mock_operation.key, mock_operation.definition = 'mock_operation', slicer.table.abc
+        mock_operation.metrics = []
+
+        mock_widget = f.Widget(mock_operation)
+        mock_widget.transform = Mock()
+
+        mock_df = {}
+        mock_fetch_data.return_value = mock_df
+
+        # Need to keep widget the last call in the chain otherwise the object gets cloned and the assertion won't work
+        slicer.data \
+            .dimension(slicer.dimensions.timestamp) \
+            .widget(mock_widget) \
+            .fetch()
+
+        mock_operation.apply.assert_called_once_with(mock_df, None)
+
+    def test_operations_evaluated_for_each_reference(self, mock_fetch_data: Mock, *mocks):
+        eoe = ElectionOverElection(slicer.dimensions.timestamp)
+
+        mock_operation = Mock(name='mock_operation ', spec=f.Operation)
+        mock_operation.key, mock_operation.definition = 'mock_operation', slicer.table.abc
+        mock_operation.metrics = []
+
+        mock_widget = f.Widget(mock_operation)
+        mock_widget.transform = Mock()
+
+        mock_df = {}
+        mock_fetch_data.return_value = mock_df
+
+        # Need to keep widget the last call in the chain otherwise the object gets cloned and the assertion won't work
+        slicer.data \
+            .dimension(slicer.dimensions.timestamp) \
+            .reference(eoe) \
+            .widget(mock_widget) \
+            .fetch()
+
+        mock_operation.apply.assert_has_calls([
+            call(mock_df, None),
+            call(mock_df, eoe),
+        ])
+
+    def test_operations_results_stored_in_data_frame(self, mock_fetch_data: Mock, *mocks):
+        mock_operation = Mock(name='mock_operation ', spec=f.Operation)
+        mock_operation.key, mock_operation.definition = 'mock_operation', slicer.table.abc
+        mock_operation.metrics = []
+
+        mock_widget = f.Widget(mock_operation)
+        mock_widget.transform = Mock()
+
+        mock_df = {}
+        mock_fetch_data.return_value = mock_df
+
+        # Need to keep widget the last call in the chain otherwise the object gets cloned and the assertion won't work
+        slicer.data \
+            .dimension(slicer.dimensions.timestamp) \
+            .widget(mock_widget) \
+            .fetch()
+
+        f_op_key = format_metric_key(mock_operation.key)
+        self.assertIn(f_op_key, mock_df)
+        self.assertEqual(mock_df[f_op_key], mock_operation.apply.return_value)
diff --git a/fireant/tests/slicer/test_filter_totals_from_share_results.py b/fireant/tests/slicer/test_filter_totals_from_share_results.py
new file mode 100644
index 00000000..b6e1037a
--- /dev/null
+++ b/fireant/tests/slicer/test_filter_totals_from_share_results.py
@@ -0,0 +1,93 @@
+from unittest import TestCase
+
+import pandas as pd
+import pandas.testing
+from datetime import timedelta
+
+from fireant.slicer.totals import scrub_totals_from_share_results
+from fireant.tests.slicer.mocks import (
+    cat_dim_df,
+    cat_dim_totals_df,
+    cont_cat_dim_df,
+    cont_cat_dim_totals_df,
+    cont_uni_dim_all_totals_df,
+    cont_uni_dim_df,
+    multi_metric_df,
+    slicer,
+)
+
+TIMESTAMP_UPPERBOUND = pd.Timestamp.max - timedelta(seconds=1)
+
+
+class ScrubTotalsTests(TestCase):
+    def ignore_dimensionless_result_sets(self):
+        result = scrub_totals_from_share_results(multi_metric_df, [])
+
+        expected = multi_metric_df
+
+        pandas.testing.assert_frame_equal(result, expected)
+
+    def test_remove_totals_for_non_rollup_dimensions(self):
+        result = scrub_totals_from_share_results(cat_dim_totals_df, [slicer.dimensions.political_party])
+
+        expected = cat_dim_df
+
+        pandas.testing.assert_frame_equal(result, expected)
+
+    def test_remove_totals_for_non_rollup_dimensions_with_multiindex(self):
+        result = scrub_totals_from_share_results(cont_cat_dim_totals_df, [slicer.dimensions.timestamp,
+                                                                          slicer.dimensions.political_party])
+
+        expected = cont_cat_dim_df
+
+        pandas.testing.assert_frame_equal(result, expected)
+
+    def test_remove_totals_for_non_rollup_dimensions_with_multiindex_and_multiple_totals(self):
+        result = scrub_totals_from_share_results(cont_uni_dim_all_totals_df, [slicer.dimensions.timestamp,
+                                                                              slicer.dimensions.political_party])
+
+        expected = cont_uni_dim_df
+
+        pandas.testing.assert_frame_equal(result, expected)
+
+    def test_do_not_remove_totals_for_rollup_dimensions(self):
+        result = scrub_totals_from_share_results(cat_dim_totals_df, [slicer.dimensions.political_party.rollup()])
+
+        expected = cat_dim_totals_df
+
+        pandas.testing.assert_frame_equal(result, expected)
+
+    def test_do_not_remove_totals_for_rollup_dimensions_with_multiindex(self):
+        result = scrub_totals_from_share_results(cont_cat_dim_totals_df, [slicer.dimensions.timestamp,
+                                                                          slicer.dimensions.political_party.rollup()])
+
+        expected = cont_cat_dim_totals_df
+
+        pandas.testing.assert_frame_equal(result, expected)
+
+    def test_do_not_remove_totals_for_rollup_dimensions_with_multiindex_and_lower_dimension_totals(self):
+        result = scrub_totals_from_share_results(cont_uni_dim_all_totals_df,
+                                                 [slicer.dimensions.timestamp,
+                                                  slicer.dimensions.political_party.rollup()])
+
+        expected = cont_uni_dim_all_totals_df.loc[:TIMESTAMP_UPPERBOUND]
+
+        pandas.testing.assert_frame_equal(result, expected)
+
+    def test_do_not_remove_totals_for_rollup_dimensions_with_multiindex_and_higher_dimension_totals(self):
+        result = scrub_totals_from_share_results(cont_uni_dim_all_totals_df, [slicer.dimensions.timestamp.rollup(),
+                                                                              slicer.dimensions.political_party])
+
+        expected = cont_uni_dim_all_totals_df.loc[(slice(None), slice('1', '2')), :] \
+            .append(cont_uni_dim_all_totals_df.iloc[-1])
+
+        pandas.testing.assert_frame_equal(result, expected)
+
+    def test_do_not_remove_totals_for_rollup_dimensions_with_multiindex_and_all_rolled_up(self):
+        result = scrub_totals_from_share_results(cont_uni_dim_all_totals_df,
+                                                 [slicer.dimensions.timestamp.rollup(),
+                                                  slicer.dimensions.political_party.rollup()])
+
+        expected = cont_uni_dim_all_totals_df
+
+        pandas.testing.assert_frame_equal(result, expected)
diff --git a/fireant/tests/slicer/widgets/test_highcharts.py b/fireant/tests/slicer/widgets/test_highcharts.py
index 003d4a99..e6301b77 100644
--- a/fireant/tests/slicer/widgets/test_highcharts.py
+++ b/fireant/tests/slicer/widgets/test_highcharts.py
@@ -522,7 +522,7 @@ def test_multi_dim_with_totals_line_chart(self):
         result = HighCharts(title="Time Series with Unique Dimension and Multiple Metrics, Multi-Axis") \
             .axis(self.chart_class(slicer.metrics.votes)) \
             .axis(self.chart_class(slicer.metrics.wins)) \
-            .transform(cont_uni_dim_totals_df, slicer, [slicer.dimensions.timestamp.rollup(),
+            .transform(cont_uni_dim_totals_df, slicer, [slicer.dimensions.timestamp,
                                                         slicer.dimensions.state.rollup()], [])
 
         self.assertEqual({
diff --git a/fireant/tests/slicer/widgets/test_reacttable.py b/fireant/tests/slicer/widgets/test_reacttable.py
index df4917b2..7c5ef356 100644
--- a/fireant/tests/slicer/widgets/test_reacttable.py
+++ b/fireant/tests/slicer/widgets/test_reacttable.py
@@ -1,6 +1,7 @@
 import copy
 from unittest import TestCase
 
+from fireant.slicer.totals import MAX_STRING
 from fireant.slicer.widgets.reacttable import ReactTable
 from fireant.tests.slicer.mocks import (
     CumSum,
@@ -18,10 +19,7 @@
     slicer,
     uni_dim_df,
 )
-from fireant.utils import (
-    MAX_STRING,
-    format_dimension_key as fd,
-)
+from fireant.utils import format_dimension_key as fd
 
 
 class ReactTableTransformerTests(TestCase):
diff --git a/fireant/utils.py b/fireant/utils.py
index a69262d4..466be18e 100644
--- a/fireant/utils.py
+++ b/fireant/utils.py
@@ -1,12 +1,5 @@
-import sys
 from collections import OrderedDict
 
-import pandas as pd
-
-MAX_TIMESTAMP = pd.Timestamp.max
-MAX_NUMBER = sys.maxsize
-MAX_STRING = '~~totals'
-
 
 def wrap_list(value):
     return value if isinstance(value, (tuple, list)) else [value]
@@ -251,3 +244,10 @@ def repr_field_key(key):
     field_key = key[3:]
     field_type = {'m': 'metrics', 'd': 'dimensions'}[field_type_symbol]
     return 'slicer.{}.{}'.format(field_type, field_key)
+
+
+def reduce_data_frame_levels(data_frame, level):
+    reduced = data_frame.reset_index(level=level, drop=True)
+    if reduced.size == 1 and reduced.index.names == [None]:
+        return reduced.iloc[0]
+    return reduced