martyr 0.1.74.pre

data/lib/martyr/runtime/data_set/virtual_element.rb

@@ -0,0 +1,131 @@
+module Martyr
+  module Runtime
+
+    # A virtual element is an element that does not really exist, because its grain is comprised of multiple cubes
+    # that do not make sense together.
+    #
+    # It is only useful in the context of relaxing some dimensions in the process of building totals.
+    #
+    # Example:
+    #
+    #     Cube 1
+    #       genres.name     media_types.name    playlists.name      tracks_count
+    #       Rock            CD                  My playlist         10
+    #
+    #     Cube 2
+    #        genres.name    media_types.name    customers.country   units_sold
+    #        Rock           CD                  France              95
+    #
+    #     Virtual elements
+    #        genres.name    media_types.name    playlists.name    customers.country       tracks_count    units_sold
+    #        Rock           CD                  My playlist
+    #
+
+    class VirtualElement
+      include Martyr::Runtime::ElementCommon
+
+      attr_reader :grain_hash, :locators, :real_elements, :memory_slice, :future_virtual_metrics_hash
+      delegate :inspect, :has_key?, to: :to_hash
+      delegate :store, to: :future_virtual_metrics_hash
+
+      def to_hash
+        grains_and_virtual_metrics = grain_hash.merge(future_virtual_metrics_hash)
+        real_elements.inject(grains_and_virtual_metrics) {|h, element| h.merge element.to_hash}
+      end
+
+      # @param memory_slice [MemorySlice] cross cubes memory slice
+      # @option real_elements [Array<Element>] note that an empty array is a valid input, representing an empty virtual
+      #   element.
+      def initialize(grain_hash, memory_slice, locators, real_elements = nil)
+        @grain_hash = grain_hash
+        @memory_slice = memory_slice
+        @locators = locators
+        @real_elements = real_elements || find_real_elements(:get)
+        @future_virtual_metrics_hash = {}
+      end
+
+      def empty?
+        real_elements.empty?
+      end
+
+      def coordinates
+        coordinates_object.to_hash
+      end
+
+      def coordinates_object
+        representative.coordinates_object
+      end
+
+      def facts(cube_name = nil)
+        facts = Hash[real_elements.map {|x| [x.cube_name, x.facts]}]
+        cube_name ? facts[cube_name] : facts
+      end
+
+      def fetch(key)
+        send(:[], key)
+      end
+
+      def [](key)
+        value = to_hash[key]
+        value.is_a?(FutureMetric) ? value.value : value
+      end
+
+      def locate(*args)
+        new_real_elements = find_real_elements(:locate, *args)
+        VirtualElement.new(representative(*args).grain_hash, memory_slice, locators, new_real_elements)
+      end
+
+      def key_for(level_id)
+        representative.key_for(level_id)
+      end
+
+      def record_for(level_id)
+        representative.record_for(level_id)
+      end
+
+      def grain_level_ids
+        grain_hash.keys
+      end
+
+      def has_metric_id?(metric_id)
+        metric_ids.include?(metric_id)
+      end
+
+      def warnings
+        arr = real_elements.flat_map do |elm|
+          elm.metrics.map{|metric| [metric.id, warning(metric.id)]}
+        end
+        Hash[arr]
+      end
+
+      def warning(metric_id)
+        unsupported_keys_in_memory_slice = memory_slice.keys - coordinates(metric_id).keys
+        return [] if unsupported_keys_in_memory_slice.blank?
+        "Metric `#{metric_id}` does not support slice on: `#{unsupported_keys_in_memory_slice.join('`, `')}`"
+      end
+
+      def load
+        real_elements.try(:each, &:load)
+        future_virtual_metrics_hash.values.each(&:value)
+        self
+      end
+
+      private
+
+      # @param method_name [:get, :locate]
+      # @param args [Array] args for locate
+      def find_real_elements(method_name, *args)
+        locators.map do |locator|
+          locator.send(method_name, grain_hash, *args)
+        end.reject(&:empty?).compact
+      end
+
+      # Allows falling back to an empty real element if no real elements are found to calculate the new grain hash
+      # @return [Element] could be empty element
+      def representative(*locate_args)
+        real_elements.first || locators.first.locate(grain_hash, *locate_args)
+      end
+
+    end
+  end
+end

data/lib/martyr/runtime/data_set/virtual_elements_builder.rb

@@ -0,0 +1,202 @@
+module Martyr
+  module Runtime
+    class VirtualElementsBuilder
+      include Martyr::Translations
+
+      def initialize(memory_slice, unsliced_level_ids_in_grain:, virtual_metrics:)
+        @entries = []
+        @unsliced_level_ids_in_grain = unsliced_level_ids_in_grain
+        @memory_slice = memory_slice
+        @lookups_by_level_id = {}
+        @virtual_metrics = virtual_metrics
+      end
+
+      # @param elements [Array<Element>]
+      # @param sliced [Boolean] true if cube has at least one sliced level or metric
+      def add(elements, sliced:)
+        return unless elements.present?
+        @entries << ElementsFromSubCube.new(elements, sliced, @lookups_by_level_id, @unsliced_level_ids_in_grain)
+      end
+
+      # Let's take 3 cubes:
+      #
+      #       Schools:
+      #         Country
+      #         City
+      #         Name
+      #
+      #       Courses:
+      #         Topic
+      #         Course name
+      #
+      #       Students:
+      #         Country
+      #         City
+      #         Name
+      #
+      # Cube 1 - city budgets for schools
+      #   (D) schools.country
+      #   (D) schools.city
+      #   (M) budget
+      #
+      # Cube 2 - Student performance
+      #   (D) schools.country
+      #   (D) schools.city
+      #   (D) schools.name
+      #   (D) students.country
+      #   (D) students.city
+      #   (D) students.name
+      #   (D) courses.topic
+      #   (D) courses.name
+      #   (M) grade
+      #
+      # Cube 3 - International statistics
+      #   (D) courses.topic
+      #   (M) importance_factor
+      #
+      # Cube 4 = National statistics
+      #   (D) schools.country
+      #   (D) courses.topic
+      #   (M) national_importance_factor
+      #
+      # = Reports
+      #
+      # City budget vs. average grade
+      #   schools.country   schools.city      courses.topic     budget      average grade
+      #   USA               Boston             (total)           1500         8.3
+      #   USA               Boston             Math                           7.5
+      #   USA               Boston             Literature                     9.2
+      #
+      # Cube 3:
+      # Budgets for cities that have schools with courses of high international importance factor
+      # => NOT SUPPORTED. Cube 3 cannot be added because it shares no grain level
+      #   schools.country   schools.city      budget
+      #   USA               Boston            1500
+      #
+      # Alternative via Cube 4:
+      # Budgets for cities whose countries have schools with courses of high national importance factor
+      #
+      # Slices on cubes 1 and 3 get applied on cube 2:
+      #   Cube3.importance_factor = high    (courses with high importance factor)
+      #   Cube1.budget > 1000               (countries with at least one city budget bigger than 1000)
+      #   schools.country = [USA, France, ...]
+      #
+      #   schools.country    courses.topic   grade
+      #
+      #
+      # The algorithm is as follows:
+      #   Go over every "sliced cube" - a cube that has at least one sliced level or metric.
+      #   Take every dependent level and restrict its values
+      #   Apply the restricted on every cube, including the dependent ones
+      #
+      # A cube that has no grain and no metric doesn't matter - it can't help with the dependent elements.
+      #
+      #   USA
+      #   schools.city
+      #
+      #
+      #               Authors        Posts            Comments     Reactions
+      #           Country  City   Genre   Name     Type   Rating     Rating
+      #
+      #  Cube 1:    L1.1   L1.2   L2.1    L2.2     L3.1    L3.2
+      #  Cube 2:                  L2.1    L2.2     L3.1
+      #  Cube 3:                                   L3.1    L3.2      L4.1
+      #
+      # Scenarios:
+      #             L1.1   L1.2   L2.1    L2.2     L3.1    L3.2      L4.1
+      #  1-Slice            x                                         x
+      #  1-Grain                           x        x
+      #  #=> Show comment count by post name and comment type for all posts made by authors from Boston with a positive reaction.
+      #
+      #  2-Slice                           x
+      #  2-Grain                           x                x
+      #  #=> Show comment count by post name and comment rating for the post named 'My Thoughts'
+      #
+      #
+      # When we are in #build, the memory slice already occurred, meaning it restricted the elements from cube 1
+      # to include only the relevant (L2.2, L3.1) combinations and elements from cube 3 to include only relevant
+      # (L3.1) elements.
+      # #build then looks at the +intersection+ of L2.2 values and L3.1 values across all cubes.
+      #
+      def build
+        return @entries.first.elements if @entries.length == 1
+        @entries.each(&:restrict)
+
+        @entries.flat_map do |entry|
+          entry.restricted_elements.map do |element|
+            next if (level_ids_in_grain - element.grain_level_ids).present?
+            element.grain_hash
+          end.compact
+        end.uniq.map do |grain_hash|
+          elm = VirtualElement.new grain_hash, @memory_slice, @entries.map(&:element_locator)
+          elm.rollup(*@virtual_metrics)
+        end
+      end
+
+      def level_ids_in_grain
+        @level_ids_in_grain ||= @entries.map(&:level_ids).flatten.uniq.sort_by{|x| first_element_from_id(x)}
+      end
+
+      def grain_hash_with_nils
+        Hash[level_ids_in_grain.map{|level_id| [level_id, nil]}]
+      end
+
+      class ElementsFromSubCube
+        include ActiveModel::Model
+
+        attr_accessor :element_locator, :elements, :sliced
+        attr_reader :lookups_by_level_id, :unsliced_level_ids_in_grain, :level_ids
+
+        def initialize(elements, sliced, lookups_by_level_id, unsliced_level_ids_in_grain)
+          @elements = elements
+          @sliced = sliced
+          @lookups_by_level_id = lookups_by_level_id
+
+          representative = @elements.first
+          @element_locator = representative.element_locator
+          @level_ids = representative.grain_level_ids
+          @unsliced_level_ids_in_grain = @level_ids - (@level_ids - unsliced_level_ids_in_grain)
+        end
+
+        def restrict
+          return unless sliced
+          unsliced_level_ids_in_grain.each do |level_id|
+            restrict_one_level(level_id)
+          end
+        end
+
+        # @return [Array<Element>] elements whose non-sliced levels are restricted to the
+        #   intersection of all participating cubes
+        def restricted_elements
+          unsliced_level_ids_in_grain.inject(elements) do |selected_elements, level_id|
+            selected_elements.select do |element|
+              restricted_values = lookups_by_level_id[level_id]
+              next(true) unless restricted_values.present?
+
+              value_in_element_for_level = element[level_id]
+              restricted_values[value_in_element_for_level]
+            end
+          end
+        end
+
+        private
+
+        def restrict_one_level(level_id)
+          if lookups_by_level_id.has_key?(level_id)
+            # Restrict if the level already exists
+            lookups_by_level_id[level_id].slice! *(lookups_by_level_id[level_id].keys & values_for(level_id))
+          else
+            # Add to lookup if this is first time the level_id is encountered
+            lookup_arr = values_for(level_id).map{|x| [x, true]}
+            lookups_by_level_id[level_id] = Hash[lookup_arr]
+          end
+        end
+
+        def values_for(level_id)
+          elements.map{|elm| elm[level_id]}
+        end
+      end
+
+    end
+  end
+end

data/lib/martyr/runtime/dimension_scopes/base_level_scope.rb

@@ -0,0 +1,20 @@
+module Martyr
+  module Runtime
+    class BaseLevelScope
+      include Martyr::Level
+      include Martyr::LevelComparator
+
+      attr_accessor :level
+      attr_reader :collection
+      delegate :level_definition, :name, :dimension_name, :query?, :degenerate?, :to_i, to: :level
+      delegate :fact_key, :fact_alias, to: :level_definition
+
+      def initialize(collection, level)
+        @collection = collection
+        @level = level
+        @cache = nil
+      end
+
+    end
+  end
+end

data/lib/martyr/runtime/dimension_scopes/degenerate_level_scope.rb

@@ -0,0 +1,76 @@
+module Martyr
+  module Runtime
+    class DegenerateLevelScope < BaseLevelScope
+
+      delegate :query_level_with_finder, :query_level_key, :register_element_helper_methods, to: :level
+      delegate :nullify, to: :query_level_below
+
+      def sliceable?
+        !!query_level_below
+      end
+
+      def slice_with(values)
+        query_level_below.decorate_scope do |scope|
+          query_level_with_finder.call(scope, values)
+        end
+        query_level_below.set_bottom_sliced_level
+      end
+
+      def loaded?
+        query_level_below.loaded?
+      end
+
+      # TODO: load from fact when sliceable? is false
+      def load
+        return true if loaded?
+        query_level_below.load
+        true
+      end
+
+      def all
+        loaded_cache.keys
+      end
+      alias_method :keys, :all
+      alias_method :all_values, :all
+
+      # Useful when the fact is attempting to resolve Degenerate 1 value:
+      #   Degenerate 1
+      #         Degenerate 2    ----    Cube
+      #               Query 3
+      #
+      # @return [String] the value of the "Degenerate 1" parent
+      def recursive_lookup_up(degenerate_value, level:)
+        return degenerate_value if name == level.name
+        query_level_primary_key = query_level_below.record_primary_key(loaded_cache[degenerate_value])
+        query_level_below.recursive_lookup_up(query_level_primary_key, level: level)
+      end
+
+      def recursive_lookup_down(degenerate_values, level:)
+        degenerate_values = Array.wrap(degenerate_values)
+        return degenerate_values if name == level.name
+        query_level_records = degenerate_values.flat_map{|value| query_level_below.cached_records_by(query_level_key)[value]}
+        query_level_below.recursive_lookup_down(query_level_records, level: level)
+      end
+
+      protected
+
+      # The cache stored is basically one representative of the query level for each degenerate value.
+      # Assuming the hierarchy is strict, i.e. the state parent of "San Francisco" is always "California", we are able
+      # to infer correctly the hierarchy
+      def cache
+        @cache ||= query_level_below.all.index_by{|x| degenerate_value_from_query_record(x) }
+      end
+
+      def loaded_cache
+        load and return cache
+      end
+
+      public
+
+      def degenerate_value_from_query_record(record)
+        record.send(query_level_key)
+      end
+
+    end
+  end
+end

data/lib/martyr/runtime/dimension_scopes/dimension_scope_collection.rb

@@ -0,0 +1,78 @@
+module Martyr
+  module Runtime
+    class DimensionScopeCollection < HashWithIndifferentAccess
+      include Martyr::Registrable
+      include Martyr::Translations
+
+      attr_reader :dimension_definitions
+      alias_method :find_dimension, :find_or_error
+      alias_method :has_dimension?, :has_key?
+
+      def initialize(dimension_definitions)
+        @dimension_definitions = dimension_definitions
+      end
+
+      def to_s
+        values.flat_map{|x| x.level_objects.map(&:id)}.inspect
+      end
+
+      # @param level [Martyr::Level]
+      def register_level(level)
+        dimension_scope = find_or_nil(level.dimension_name) ||
+            register(Martyr::DimensionReference.new(level.dimension_definition, Runtime::LevelScopeCollection))
+        dimension_scope.register_level(level)
+      end
+
+      def find_level(level_id)
+        with_standard_id(level_id) { |dimension, level| find_dimension(dimension).find_level(level) }
+      end
+      alias_method :level_scope, :find_level
+
+      def level_scopes(level_ids)
+        Array.wrap(level_ids).map{|x| level_scope(x)}
+      end
+
+      # @param level_id [String]
+      # @yieldparam [BaseLevelScope]
+      def with_level_scope(level_id)
+        yield level_scope(level_id)
+      end
+
+      def level_loaded?(level_id)
+        level_scope(level_id).loaded?
+      end
+
+      # @param level_ids [Array<String>, String]
+      # @return [Array<BaseLevelScope>] lowest levels from the levels array in each dimension
+      def lowest_level_of(level_ids)
+        LevelDefinitionsByDimension.new(level_scopes(level_ids)).lowest_levels
+      end
+
+      # @param level_ids [Array<String>, String]
+      # @return [String] lowest levels from the levels array in each dimension
+      def lowest_level_ids_of(level_ids)
+        lowest_level_of(level_ids).map(&:id)
+      end
+
+      # @param level_ids [Array<String>, String]
+      # @return [Array<BaseLevelScope>] lowest levels from the levels array in each dimension, and all the level
+      #   scopes above them
+      def levels_and_above_for(level_ids)
+        lowest_level_of(level_ids).flat_map(&:level_and_above)
+      end
+
+      # @param level_ids [Array<Martyr::Level>]
+      # @return [Array<String>]
+      def level_ids_and_above_for(level_ids)
+        levels_and_above_for(level_ids).map(&:id)
+      end
+
+      def register_element_helper_methods(mod)
+        values.each do |dimension_reference|
+          dimension_reference.register_element_helper_methods(mod)
+        end
+      end
+
+    end
+  end
+end

data/lib/martyr/runtime/dimension_scopes/level_scope_collection.rb

@@ -0,0 +1,20 @@
+module Martyr
+  module Runtime
+    class LevelScopeCollection < HashWithIndifferentAccess
+      include Martyr::LevelCollection
+
+      attr_accessor :bottom_level_sliced_i
+
+      def initialize(*args)
+        super
+        @bottom_level_sliced_i = nil
+      end
+
+      # @param level [Martyr::Level]
+      def register_level(level)
+        register level.build(self)
+      end
+
+    end
+  end
+end