martyr 0.1.74.pre

data/lib/martyr/runtime/slices/data_slices/plain_dimension_data_slice.rb

@@ -0,0 +1,109 @@
+module Martyr
+  module Runtime
+    class PlainDimensionDataSlice
+      include Martyr::Runtime::HasScopedLevels
+
+      # @attribute levels [Hash<String => PlainDimensionLevelSliceDefinition>]
+      attr_reader :levels
+
+      attr_reader :dimension_definition
+      delegate :keys, to: :sorted_levels
+
+      def initialize(dimension_definition)
+        @dimension_definition = dimension_definition
+        @levels = {}
+      end
+
+      def sorted_levels
+        arr = scoped_levels.sort_by{|_level_id, slice| slice.level.to_i}
+        Hash[arr]
+      end
+
+      def to_hash
+        sorted_levels.values.inject({}) {|h, slice| h.merge! slice.to_hash}
+      end
+
+      def dimension_name
+        dimension_definition.name
+      end
+
+      # @param level [BaseLevelDefinition]
+      def set_slice(level, **options)
+        @levels[level.id] = PlainDimensionLevelSliceDefinition.new(level: level, **options)
+      end
+
+      # @return [PlainDimensionLevelSliceDefinition]
+      def get_slice(level_id)
+        scoped_levels[level_id]
+      end
+
+      # = Slicing the dimension
+
+      def add_to_dimension_scope(dimension_bus)
+        scoped_levels.keys.each do |level_id|
+          level_scope = dimension_bus.level_scope(level_id)
+          slice_definition = levels[level_id]
+
+          add_slice_to_dimension_level(level_scope, slice_definition)
+        end
+      end
+
+      def add_slice_to_dimension_level(level_scope, slice_definition)
+        return unless level_scope.sliceable?
+        if slice_definition.null?
+          level_scope.nullify
+        elsif slice_definition.with.present?
+          level_scope.slice_with(slice_definition.with)
+        end
+      end
+
+      # = Slicing the fact
+
+      def add_to_grain(grain)
+        scoped_levels.keys.each {|level_id| grain.add_granularity(level_id) }
+      end
+
+      # @param fact_scopes [Runtime::FactScopeCollection]
+      # @param dimension_bus [Runtime::QueryContext]
+      def add_to_where(fact_scopes, dimension_bus)
+        scoped_levels.keys.each do |level_id|
+          add_one_level_to_where(fact_scopes, level_id, dimension_bus)
+        end
+      end
+
+      private
+
+      # @return [FactScopeOperatorForDimension]
+      def add_one_level_to_where(fact_scopes, level_id, dimension_bus)
+        level_scope = dimension_bus.level_scope(level_id)
+        slice_definition = get_slice(level_id)
+
+        # Building operator used to slice the fact
+        fact_scopes.add_where_operator_for_dimension(level_scope.dimension_name, level_scope.name) do |operator|
+          if slice_definition.null?
+            operator.decorate_scope {|fact_scope| fact_scope.where('0=1')}
+            next
+          end
+
+          common_denominator_level = operator.common_denominator_level(level_scope.level_definition)
+          if common_denominator_level.name == level_scope.name
+            add_to_where_using_fact_strategy(level_scope, slice_definition, operator)
+          else
+            add_to_where_using_join_strategy(operator, dimension_bus.level_scope(common_denominator_level.id))
+          end
+        end
+      end
+
+      def add_to_where_using_fact_strategy(level_scope, slice_definition, operator)
+        return unless slice_definition.with.present?
+        level_key = operator.level_key_for_where(level_scope.id)
+        operator.add_where(level_key => slice_definition.with)
+      end
+
+      def add_to_where_using_join_strategy(operator, common_level_scope)
+        level_key = operator.level_key_for_where(common_level_scope.id)
+        operator.add_where(level_key => common_level_scope.keys)
+      end
+    end
+  end
+end

data/lib/martyr/runtime/slices/data_slices/time_dimension_data_slice.rb

@@ -0,0 +1,9 @@
+module Martyr
+  module Runtime
+    class TimeDimensionDataSlice
+
+      attr_accessor :before, :after
+
+    end
+  end
+end

data/lib/martyr/runtime/slices/has_scoped_levels.rb

@@ -0,0 +1,29 @@
+module Martyr
+  module Runtime
+    module HasScopedLevels
+
+      def scope(supported_level_ids)
+        dup.scope!(supported_level_ids)
+      end
+
+      protected
+
+      def scope!(supported_level_ids)
+        @supported_level_ids = Array.wrap(supported_level_ids)
+        @scoped_levels = nil
+        self
+      end
+
+      private
+
+      def scoped_levels
+        return levels unless @supported_level_ids.present?
+        return @scoped_levels if @scoped_levels
+        unsupported_keys = levels.keys - @supported_level_ids
+        supported_keys = levels.keys - unsupported_keys
+        @scoped_levels = levels.slice(*supported_keys)
+      end
+
+    end
+  end
+end

data/lib/martyr/runtime/slices/memory_slices/TO_DELETE.md

@@ -0,0 +1,188 @@
+  # Memory slices are used for two aims:
+  #   1. Allow slicing a sub cube that was already built. The slice in this scenario runs on the +facts+.
+  #     So if the grain was on 'customers.city', fact records would like like this:
+  #           customers.city      customers.state     customers.country     amount_sold
+  #           San Francisco       CA                  USA                   100
+  #           New York            NY                  USA                   150
+  #
+  #     and we could apply a slice on any of the levels in the grain:
+  #     slice('customers.state', with: 'CA')
+  #
+  #
+  #     Rule 1: Memory slice on a dimension has to be supported by the sub cube grain
+  #     We wouldn't be able to slice on a level like 'media_types.name' because we don't have that info:
+  #     slice('media_types.name', with: 'MPEG')
+  #     # => Error
+  #
+  #     Now let's assume the sub cube has a slice on a level that is also in it's grain. Maybe like this:
+  #     sub_cube.slice('customers.state', with: 'CA').granulate('customers.city')
+  #           customers.city      customers.state     customers.country     amount_sold
+  #           San Francisco       CA                  USA                   100
+  #           Palo Alto           CA                  USA                   37
+  #
+  #     In this case:
+  #     slice('customers.city', with: 'Some City')
+  #     # => Is fine
+  #
+  #     slice('customers.state', with: 'NY')
+  #     # => Is fine, but empty
+  #
+  #
+  #     Rule 2: Memory slice on a metric can simply be merged with the sub cube:
+  #           Sub Cube Slice              Memory Slice                    Combined Slice
+  #           :amount_sold, gt: 100       :amount_sold, gt: 150           :amount_sold, gt: 150
+  #
+  #
+  #  2. Allow changing the current element for custom rollup calculations
+  #     Custom rollup naturally occurs within an element.
+  #
+  #     Elements has a +memory-grain+ which could be different than the sub cube grain.
+  #     That said, memory grains MUST be contained within the supported levels of the sub cube grain.
+  #
+  #     For example:
+  #     sub_cube.elements(levels: 'customers.country')
+  #     # => Every +element+ would have the 'customers.country' on the grain, which is different than the sub cube's
+  #     #    'customers.city' grain. The sub cube supports 'customers.country' because it is a higher level than the
+  #          'customers.city' level defined in the grain.
+  #
+  #     sub_cube.elements(levels: 'media_types.name')
+  #     # => Error. media types is not in the sub cube grain.
+  #
+  #     Every element has two types of slices:
+  #     - Endogenous: the current value of every level in the memory grain. E.g.: ['customers.country', with: 'USA']
+  #     - Exogenous: the sub cube slice on metrics or levels that are not in the memory grain.
+  #       E.g.: ['metrics.units_sold', gt: 100] or ['media_types.name', with: 'MPEG']
+  #
+  #     With custom rollups, we can do a few things:
+  #     (a) ask to override an endogenous level - this is "moving" to a different element within the same memory grain
+  #         slice('customers.city', with: 'Paris')
+  #         # => Before: {'customers.country' => 'USA', 'customers.city' => {with: 'Boston'} }
+  #              After:  {'customers.country' => 'France', 'customers.city' => {with: 'Paris'} }
+  #         # => Also note that the entire dimension is reevaluated
+  #
+  #     (b) ask to remove an endogenous level - this is similar to "bring parent"
+  #         reset('customers.city')
+  #         # => So if current element coordinates were: {'customers.country' => 'USA', 'customers.city' => {with: 'Boston'} }
+  #             we will get an element in a different grain, with coordinates: {'customers.country' => 'USA' }
+  #
+  #     (c) ask to add exogenous slice - this makes sense only if the slice is supported by the sub cube grain, of course
+  #         slice('genres.name', with: 'Rock')
+  #         # => Before: {'customers.country' => 'USA', 'customers.city' => {with: 'Boston'} }
+  #              After:  {'customers.country' => 'USA', 'customers.city' => {with: 'Boston'}, 'genres.name' => {with: 'Rock'}}
+  #
+  #
+  #       Consider this scenario:
+  #
+  #             Supported by    Sub cube
+  #               Sub cube       slice           Memory Grain
+  #       D1.1        *                              *
+  #       D1.2        *            *
+  #       D1.3        *                              *
+  #       D1.4        *
+  #       D2.1        *
+  #       D2.2
+  #
+  #       This means that the following scenarios are possible:
+  #       1. Override D1.1 - what happens to the current value of D1.3?
+  #           Answer:
+  #             The element coordinates really represent a slice on D1.3, not D1.1.
+  #             When memory slice override is requested on D1.1, it is really requested on D1, which has the effect
+  #             of resetting the current slice on this dimension - D1.3, and setting it to D1.1.
+  #
+  #             To summarize:
+  #               Grain:    [D1.3] => [D1.1]
+  #
+  #       2. Override D1.3 - what happens to the current value of D1.1?
+  #           Answer:
+  #              Grain does not change. The element coordinates are still [D1.3], but a new element is fetched based
+  #              on the requested value of D1.3. Of course, D1.1 moves together with D1.3.
+  #
+  #       3. Set slice on D1.2 - what happens to the current value of D1.3 and D1.1?
+  #           Answer:
+  #               Grain changes to [D1.2]. Any value for [D1.3] is reset. [D1.1] is changed with it.
+  #
+  #       4. Set slice on D1.4 - what happens to current values of D1?
+  #           Answer:
+  #               Grain changes to [D1.4]. Any value for [D1.3, D1.1] are moved based on the new value for [D1.4]
+  #
+  #       5. Remove slice [D1.3]
+  #               Grain changes to [D1.1]
+  #
+  #       6. Add slice on [D2.1]
+  #             Grain changes to [D1.3, D2.1].
+  #
+  #     Let's look again at scenarios a through c when a sub cube slice existed in addition on the same dimensions we
+  #     are compounding a memory slice on:
+  #
+  #      # (a) - Overriding element's endogenous slice
+  #
+  #      (a) Sub Cube grain:      ['customers.last_name']
+  #          Sub Cube Slice:      {'customers.country', with: 'USA'}
+  #          Memory Grain:        ['customers.city', 'customers.state']
+  #          Operation:           slice('customers.city', with: 'Paris')
+  #          Current coordinates: {'customers.city' => 'Boston', 'customers.country' => 'USA' }
+  #          New coordinates:     <Empty Cell>
+
+  #
+  #      (a) Sub Cube grain:      ['customers.last_name']
+  #          Sub Cube Slice:      {'customers.country', with: 'USA'}
+  #          Memory Grain:        ['customers.city', 'customers.state']
+  #          Operation:           slice('customers.city', with: 'San Francisco')
+  #          Current coordinates: {'customers.state' => 'MI', 'customers.city' => 'Boston', 'customers.country' => 'USA' }
+  #          New coordinates:     {'customers.state' => 'CA', 'customers.city' => 'San Francisco', 'customers.country' => 'USA' }
+  #
+  #      (a) Sub Cube grain:      ['customers.last_name']
+  #          Sub Cube Slice:      {'customers.city', with: 'San Francisco', 'Boston', 'New York'}
+  #          Memory Grain:        ['customers.city', 'customers.state']
+  #          Operation:           slice('customers.city', with: 'San Francisco')
+  #          Current coordinates: {'customers.state' => 'MI', 'customers.city' => 'Boston' }
+  #          New coordinates:     {'customers.state' => 'CA', 'customers.city' => 'San Francisco' }
+  #
+  #     # (b) - Removing endogenous slice
+  #
+  #      (b) Sub Cube grain:      ['customers.last_name']
+  #          Sub Cube Slice:      {'customers.state', with: 'CA'}
+  #          Memory Grain:        ['customers.city', 'customers.country', 'customers.state']
+  #          Operation:           reset('customers.city')
+  #          Current coordinates: {'customers.country' => 'USA', 'customers.city' => 'Boston', 'customers.state' => 'CA' }
+  #          New coordinates:     {'customers.country' => 'USA', 'customers.state' => 'CA' }
+  #
+  #      # NOTE that while the endogenous level is removed, the coordinates keep the exogenous slice!
+  #      (b) Sub Cube grain:      ['customers.last_name']
+  #          Sub Cube Slice:      {'customers.state', with: 'CA'}
+  #          Memory Grain:        ['customers.city', 'customers.country', 'customers.state']
+  #          Operation:           reset('customers.state')
+  #          Current coordinates: {'customers.country' => 'USA', 'customers.city' => 'Boston', 'customers.state' => 'CA' }
+  #          New coordinates:     {'customers.country' => 'USA', 'customers.state' => 'CA' }
+  #
+  #      # (c) - Adding exogenous slice
+  #
+  #       # When the exogenous slice is not part of the memory grain
+  #      (c) Sub Cube grain:      ['customers.last_name', 'media_types.name']
+  #          Sub Cube Slice:      {'customers.state', with: 'CA'}
+  #          Memory Grain:        ['customers.city', 'customers.country']
+  #          Operation:           slice('media_types.name', with: 'MPEG')
+  #          Current coordinates: {'customers.country' => 'USA', 'customers.city' => 'Boston', 'customers.state' => 'CA' }
+  #          New coordinates:     {'customers.country' => 'USA', 'customers.city' => 'Boston', 'customers.state' => 'CA', 'media_types.name' => 'MPEG' }
+  #
+  #      # When exogesnour
+  #      (c) Sub Cube grain:      ['customers.last_name']
+  #          Sub Cube Slice:      {'customers.city', with: 'San Francisco', 'Boston', 'New York'}
+  #          Memory Grain:        ['customers.state']
+  #          Operation:           slice('customers.city', with: 'San Francisco')
+  #          Current coordinates: {'customers.state' => 'MI' }
+  #          New coordinates:     <Empty Element>
+  #
+  #
+  #     q = Cube.slice('customers.state', with: ['CA', 'NY', 'YS', 'BC']).granulate('customers.last_name', 'media_types.name').build
+  #     all =    q.elements(levels: ['customers.country', 'customers.city'])
+  #     slice1 = q.slice('customers.state', with: 'NY').elements(levels: ['customers.country', 'customers.city'])
+  #         # => The merging of slices is simple - it's on the same level
+  #     slice2 = q.slice('customers.country', with: 'Canada').elements(levels: ['customers.country', 'customers.city'])
+  #         # => The merging of slices is hard - it needs to go to the dimension, similar to coordinates resolver
+  #     slice3 = q.slice('customers.city', with: 'Paris').elements(levels: ['customers.country', 'customers.city'])
+  #         # => The merging of slices is medium - it will either be null or Paris.
+  #
+  #   Memory slice and coordinate resolver are very similar! Coordinate resolver is basically applying a memory slice
+  #   on the current element values. The only exception is that for coordinate resolver, slice3 is easy - it is assumed
+  #   to exist.

data/lib/martyr/runtime/slices/memory_slices/memory_slice.rb

@@ -0,0 +1,84 @@
+module Martyr
+  module Runtime
+    class MemorySlice
+      include Martyr::Translations
+
+      attr_accessor :data_slice, :memory_slice_overrides
+      delegate :definition_resolver, :definition_object_for, to: :data_slice
+
+      def initialize(data_slice)
+        @data_slice = data_slice
+        @memory_slice_overrides = ScopeableSliceData.new
+      end
+
+      def inspect
+        to_hash.inspect
+      end
+
+      def override_values
+        memory_slice_overrides.values
+      end
+
+      def keys
+        (override_values.flat_map(&:keys) + data_slice.keys).uniq
+      end
+
+      def to_hash
+        overrides = override_values.inject({}) {|h, slice| h.merge! slice.to_hash}
+        data_slice.to_hash.merge!(overrides).slice(*keys)
+      end
+
+      # @param slice_on [String]
+      # @param slice_definition [Hash]
+      def slice(slice_on, slice_definition)
+        definition_resolver.validate_slice_on!(slice_on)
+        slice_on_object = definition_object_for(slice_on)
+        slice_id = slice_on_object.slice_id
+        memory_slice_overrides[slice_id] ||= slice_on_object.build_memory_slice(data_slice.slices[slice_id])
+        memory_slice_overrides[slice_id].set_slice(slice_on_object, **slice_definition.symbolize_keys)
+        self
+      end
+
+      # @see ElementLocator#locate. Currently only used for metrics slices.
+      def slice_hash(slice_hash)
+        slice_hash.each do |slice_on, slice_definition|
+          slice(slice_on, slice_definition)
+        end
+        self
+      end
+
+      # = Applying slices
+
+      # @param facts [Array<Fact>]
+      def apply_on(facts)
+        override_values.inject(facts.dup) do |selected_facts, memory_slice_override|
+          memory_slice_override.apply_on(selected_facts)
+        end
+      end
+
+      # @param sub_cube [SubCube]
+      # @return [MemorySlice] new object with new DataSlice and ScopeableDataSliceData objects, both set to be scoped
+      #   to the sub cube
+      def for_cube(sub_cube)
+        dup.for_cube!(sub_cube)
+      end
+
+      # @param sub_cube [SubCube]
+      # @return [MemorySlice] same object with new DataSlice and ScopeableDataSliceData objects, both set to be scoped
+      #   to the sub cube
+      def for_cube!(sub_cube)
+        self.data_slice = data_slice.for_cube(sub_cube)
+        self.memory_slice_overrides = memory_slice_overrides.scope(sub_cube)
+        self
+      end
+
+      def dup_internals
+        dup.instance_eval do
+          @memory_slice_overrides = memory_slice_overrides.data_dup
+          self
+        end
+      end
+
+    end
+  end
+end

data/lib/martyr/runtime/slices/memory_slices/metric_memory_slice.rb

@@ -0,0 +1,59 @@
+module Martyr
+  module Runtime
+    class MetricMemorySlice
+      attr_reader :metric
+      delegate :to_hash, to: :get_slice
+      delegate :cube_name, to: :metric
+      delegate :id, to: :metric, prefix: true
+
+      # @param metric [BaseMetricDefinition]
+      # @option data_slice [MetricDataSlice, nil] data slice from sub cube if exists
+      def initialize(metric, data_slice = nil)
+        @metric = metric
+        @data_slice = data_slice
+      end
+
+      def keys
+        [metric_id]
+      end
+
+      def set_slice(_metric_definition, **options)
+        raise Martyr::Error.new('Internal error. Inconsistent metric received') unless _metric_definition.id == metric_id
+        new_slice_definition = MetricSliceDefinition.new(metric: metric, **options)
+        if @data_slice.blank?
+          if @slice_definition.blank?
+            @slice_definition = new_slice_definition
+          else
+            @slice_definition = new_slice_definition.merge(@slice_definition)
+          end
+        else
+          @slice_definition = new_slice_definition.merge(data_slice)
+        end
+      end
+
+      def get_slice(_metric_id = nil)
+        validate_consistency!(_metric_id || self.metric_id) and @slice_definition
+      end
+
+      # = Applying
+
+      def apply_on(facts)
+        get_slice.combined_statements.inject(facts) do |selected_facts, or_statement_group|
+          selected_facts.select do |fact|
+            or_statement_group.inject(false) do |logic_resolve, statement|
+              logic_resolve or fact.fetch(metric_id).send(statement[:memory_operator], statement[:value])
+            end
+          end
+        end
+      end
+
+      private
+
+      def validate_consistency!(metric_id)
+        raise Martyr::Error.new('Internal error. Inconsistent metric received') unless metric_id == self.metric_id
+        true
+      end
+
+    end
+  end
+end

data/lib/martyr/runtime/slices/memory_slices/plain_dimension_memory_slice.rb

@@ -0,0 +1,48 @@
+module Martyr
+  module Runtime
+    class PlainDimensionMemorySlice
+
+      include Martyr::Runtime::HasScopedLevels
+
+      attr_reader :dimension_definition, :data_slice, :levels
+      delegate :keys, to: :levels
+
+      # @param dimension_definition [PlainDimensionDefinition]
+      # @option data_slice [PlainDimensionDataSlice, nil] data slice from sub cube if exists
+      def initialize(dimension_definition, data_slice = nil)
+        @dimension_definition = dimension_definition
+        @data_slice = data_slice
+        @levels = {}
+      end
+
+      def to_hash
+        arr = scoped_levels.values.sort_by{|slice| slice.level.to_i}.inject({}){|h, slice| h.merge!(slice.to_hash) }
+        Hash[arr]
+      end
+
+      def set_slice(level, **options)
+        new_slice_definition = PlainDimensionLevelSliceDefinition.new(level: level, **options)
+        if data_slice.try(:get_slice, level.id).blank?
+          @levels[level.id] = new_slice_definition
+        else
+          @levels[level.id] = new_slice_definition.merge(data_slice.get_slice(level.id))
+        end
+      end
+
+      # @return [PlainDimensionLevelSliceDefinition]
+      def get_slice(level_id)
+        scoped_levels[level_id]
+      end
+
+      def apply_on(facts)
+        scoped_levels.keys.inject(facts) do |selected_facts, level_id|
+          whitelist_arr = get_slice(level_id).with.map(&:to_s)
+          selected_facts.select do |fact|
+            whitelist_arr.include? fact.fact_key_for(level_id).to_s
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/martyr/runtime/slices/scopeable_slice_data.rb

@@ -0,0 +1,73 @@
+module Martyr
+  module Runtime
+    class ScopeableSliceData
+
+      # Scoping applies on #keys, #values, #to_hash.
+
+      delegate :[], :[]=, :select!, :reject!, to: :@data
+      delegate :keys, :values, to: :to_hash
+
+      def initialize(data = {})
+        @data = data
+      end
+
+      # @return [ScopeableDataSliceData] new instance scoped to cube
+      def scope(sub_cube)
+        dup.scope!(sub_cube)
+      end
+
+      def scope!(sub_cube)
+        @sub_cube = sub_cube
+        self
+      end
+
+      def to_hash
+        scoped_data
+      end
+
+      def select(&block)
+        obj = data_dup
+        obj.select!(&block)
+        obj
+      end
+
+      def reject(&block)
+        obj = data_dup
+        obj.reject!(&block)
+        obj
+      end
+
+      def data_dup
+        self.class.new(@data.dup)
+      end
+
+      private
+
+      def scoped_data
+        return @data unless @sub_cube
+        return @scoped_data if @scoped_data
+
+        cube_name = @sub_cube.cube_name
+        metrics_hash = @data.select do |_key, object|
+          object.respond_to?(:cube_name) and object.cube_name == cube_name
+        end
+
+        # We go through the cube so that ScopeableSliceData is the same regardless if we're dealing with data slice
+        # (can always perform WHERE clause) or memory slice (can only be applied on levels in the grain). The downside
+        # is that for memory slices the scoped_data may contain levels that cannot be sliced
+        supported_level_ids = @sub_cube.cube.supported_level_ids
+        supported_dimension_names = @sub_cube.dimension_definitions.keys
+        dimensions_arr = @data.select do |key, object|
+          !object.respond_to?(:cube_name) and
+            supported_dimension_names.include?(key) and
+            (object.keys - (object.keys - supported_level_ids)).present?
+        end.map do |key, object|
+          [key, object.scope(supported_level_ids)]
+        end
+
+        @scoped_data = metrics_hash.merge! Hash[dimensions_arr]
+      end
+
+    end
+  end
+end

data/lib/martyr/runtime/slices/slice_definitions/base_slice_definition.rb

@@ -0,0 +1,30 @@
+module Martyr
+  class BaseSliceDefinition
+    include ActiveModel::Model
+
+    def initialize(*)
+      super
+      compile_operators
+    end
+
+    def null?
+      !!@null
+    end
+
+    def self.null
+      obj = new
+      obj.send(:set_null) and return obj
+    end
+
+    protected
+
+    def set_null
+      @null = true
+    end
+
+    def compile_operators
+      raise NotImplementedError
+    end
+
+  end
+end