martyr 0.1.74.pre

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

@@ -0,0 +1,223 @@
+module Martyr
+  module Runtime
+    class QueryLevelScope < BaseLevelScope
+
+      # @attribute primary_keys_for_load [Array<Integer>] primary keys to restrict when loading the level with full_load
+      attr_accessor :primary_keys_for_load
+
+      delegate :record_value, :primary_key, :label_key, :label_expression, :register_element_helper_methods, to: :level
+
+      def initialize(*args)
+        super
+        @scope = level.scope
+      end
+
+      def parent_association_name
+        level.parent_association_name_with_default
+      end
+
+      def sliceable?
+        true
+      end
+
+      def nullify
+        decorate_scope do |scope|
+          scope.where('0=1')
+        end
+      end
+
+      def slice_with(values)
+        decorate_scope do |scope|
+          scope.where label_key => values
+        end
+        set_bottom_sliced_level
+      end
+
+      def loaded?
+        !!@cache
+      end
+
+      # We prefer to keep reference of the lowest (biggest index) level that is sliced because load_from_level_below
+      # is more efficient than load_from_level_above (does not need to join table).
+      def set_bottom_sliced_level
+        collection.bottom_level_sliced_i = [collection.bottom_level_sliced_i, to_i].compact.max
+      end
+
+      def load
+        return true if loaded?
+
+        if !collection.bottom_level_sliced_i
+          set_bottom_sliced_level
+          full_load
+        elsif to_i == collection.bottom_level_sliced_i
+          full_load
+        elsif to_i > collection.bottom_level_sliced_i
+          load_from_level_above
+        elsif to_i < collection.bottom_level_sliced_i
+          load_from_level_below
+        else
+          raise Internal::Error.new("Inconsistency in `#{dimension_name}.#{name}` scope structure")
+        end
+
+        true
+      end
+
+      # @return [Array<ActiveRecord::Base>]
+      def all
+        self.load and return cached_records
+      end
+
+      def all_values
+        all.map{|x| x[level.label_field]}
+      end
+
+      def keys
+        self.load and return cached_keys
+      end
+
+      # @return [ActiveRecord::Base]
+      def fetch(primary_key_value)
+        self.load and return @cache[primary_key_value.to_i]
+      end
+
+      # TODO: this is making the assumption that only degenerate levels can be above a query level
+      # This method allows finding the value of the level identified in `level` that is the parent of the record in the
+      # current level object that is identified by `primary_key_value`. It traversed the hierarchy UP until reaching
+      # the desired `level`.
+      #
+      # @param primary_key_value [String,Integer]
+      # @param level [Martyr::Level] this level must be equal or above the current level
+      # @return [ActiveRecord::Base, String] the record if query level, or the value if degenerate
+      def recursive_lookup_up(primary_key_value, level:)
+        record = fetch(primary_key_value)
+        return record if name == level.name
+        return record[level.query_level_key] if level_above.degenerate?
+
+        level_above.recursive_lookup_up(record_parent_primary_key(record), level: level)
+      end
+
+      # TODO: this is making the assumption that only degenerate levels can be above a query level
+      # @param records [Array<String>, String, Array<ActiveRecord::Base>, ActiveRecord::Base] two options:
+      #   - Single or Array of values as evaluated by the level value strategy, e.g. 'invoice-1'
+      #   - Single or Array of active record objects - this helps DRYing up code in this package that already obtained records
+      # @param level [Martyr::Level] this level must be equal or below the current level
+      # @return [Array<ActiveRecord::Base>, Array<String>]
+      def recursive_lookup_down(records, level:)
+        records = Array.wrap(records)
+        records = records.flat_map{|value| cached_records_by_value[value]} if records.first.is_a?(String)
+
+        return records if name == level.name
+        return records.map{|r| r[level.query_level_key]}.uniq if level.degenerate?
+        child_records = level_below.fetch_by_parent(records.map{|x| record_primary_key(x)})
+        level_below.recursive_lookup_down(child_records, level: level)
+      end
+
+      def decorate_scope(&block)
+        original_scope = @scope
+        @scope = Proc.new do
+          block.call(original_scope.call)
+        end
+      end
+
+      protected
+
+      # @param parent_primary_key_values [Array<Integer>]
+      # @return [Array<ActiveRecord::Base>] all records whose parent keys were given in parent_primary_key_values
+      def fetch_by_parent(parent_primary_key_values)
+        self.load and return Array.wrap(parent_primary_key_values).flat_map{|primary_key_value| cached_records_by_parent[primary_key_value]}
+      end
+
+      # TODO: inject one cube if exists
+
+      # def slice_from_fact_keys
+      #   decorate_scope do |scope|
+      #     scope.where primary_key => collection.foreign_keys_from_facts_for(self)
+      #   end
+      #   execute_query
+      # end
+
+      # Loading strategies
+
+      # def load_from_fact
+      #   return slice_from_fact_keys if common_denominator_with_cube.name == name
+      #   common_denominator_with_cube.load_from_fact
+      #   load_from_level_below
+      # end
+
+      def full_load
+        if primary_keys_for_load.present?
+          set_cache @scope.call.where(primary_key => primary_keys_for_load)
+        else
+          set_cache @scope.call
+        end
+      end
+
+      def load_from_level_above
+        raise Schema::Error.new("Cannot infer slice for dimension `#{dimension_name}` level `#{name}`: parent level is not query level") unless level_above.query?
+        parent_ids = level_above.all.map { |x| level_above.record_primary_key(x) }
+        set_cache @scope.call.joins(parent_association_name.to_sym).where(parent_association.foreign_key => parent_ids)
+      end
+      
+      def load_from_level_below
+        level_below = query_level_below
+        raise Schema::Error.new("Cannot infer slice for dimension `#{dimension_name}` level `#{name}`: child level cannot be found") unless level_below
+
+        ids_from_child = level_below.all.map { |x| level_below.record_parent_primary_key(x) }.uniq
+        set_cache @scope.call.where(primary_key => ids_from_child)
+      end
+
+      # TODO: this is making the assumption that only degenerate levels can be above a query level
+      # @return [ActiveRecord::Reflection::AssociationReflection]
+      def parent_association
+        return nil unless level_above.query?
+        return @parent_association if @parent_association
+
+        relation = @scope.call.klass.reflections[parent_association_name]
+        raise Schema::Error.new("Cannot find parent association `#{parent_association_name}` for dimension `#{dimension_name}` level `#{name}`") unless relation
+        @parent_association = relation
+      end
+
+      def set_cache(scope)
+        @cache = scope.index_by { |x| record_primary_key(x) }
+        true
+      end
+
+      # @return [Array<ActiveRecord::Base>]
+      def cached_records
+        @cache.values
+      end
+
+      def cached_keys
+        @cache.keys
+      end
+
+      # @return [Hash] { parent_key1 => Array<ActiveRecord::Base> }
+      def cached_records_by_parent
+        cached_records_by(parent_association.foreign_key)
+      end
+
+      # @return [Hash] { value1 => Array<ActiveRecord::Base> }
+      def cached_records_by_value
+        cached_records_by(level.label_field)
+      end
+
+      public
+
+      # @return [Hash] { key1 => Array<ActiveRecord::Base>, key2 => Array<ActiveRecord::Base> }
+      def cached_records_by(key)
+        self.load
+        @cached_records_by ||= {}
+        return @cached_records_by[key] if @cached_records_by[key]
+        @cached_records_by[key] = cached_records.group_by{|x| x[key]}
+      end
+
+      def record_primary_key(record)
+        record[primary_key].to_i
+      end
+
+      def record_parent_primary_key(record)
+        record[parent_association.foreign_key]
+      end
+    end
+  end
+end

data/lib/martyr/runtime/fact_scopes/base_fact_scope.rb

@@ -0,0 +1,62 @@
+module Martyr
+  module Runtime
+    class BaseFactScope
+      attr_reader :fact_definition, :scope
+      delegate :name, :supports_metric?, :supports_dimension_level?, :dimensions, to: :fact_definition
+
+      # = Scope accessors
+
+      # @param fact_definition [Schema::MainFactDefinition]
+      def initialize(fact_definition)
+        @fact_definition = fact_definition
+        @scope = fact_definition.scope
+      end
+
+      def run_scope
+        @_run_scope ||= scope.call
+      end
+
+      def scope_sql
+        run_scope.try(:to_sql)
+      end
+
+      def null?
+        @scope.is_a?(NullScope)
+      end
+
+      def set_null_scope
+        @scope = NullScope.new
+      end
+
+      # @return [String] how to add a where condition to the level
+      def level_key_for_where(level_id)
+        fact_definition.find_level_association(level_id).fact_key
+      end
+
+      # = Scope support check
+
+      # = Scope updater
+
+      # Decorator pattern. The block must return a new scope.
+      # @example
+      #   Let @scope be: -> { Invoice.all }
+      #
+      #   decorate_scope {|scope| scope.where(id: 5)}
+      #
+      #   @scope is now: -> { ->{ Invoice.all }.call.where(id: 5) }
+      #
+      #   decorate_scope {|scope| scope.where.not(id: 7)}
+      #
+      #   @scope is now: -> { -> { ->{ Invoice.all }.call.where(id: 5) }.call.where.not(id: 7) }
+      #
+      def decorate_scope(&block)
+        return if null?
+        original_scope = self.scope
+        @scope = Proc.new do
+          block.call(original_scope.call, self)
+        end
+      end
+
+    end
+  end
+end

data/lib/martyr/runtime/fact_scopes/fact_scope_collection.rb

@@ -0,0 +1,127 @@
+module Martyr
+  module Runtime
+    class FactScopeCollection < HashWithIndifferentAccess
+      include Martyr::Registrable
+
+      alias_method :scopes, :values
+      delegate :set_null_scope, :null?, to: :main_fact
+
+      def operators
+        @operators ||= []
+      end
+
+      # Add the add_<operator> methods:
+      #   add_select_operator_for_metric
+      #   add_select_operator_for_dimension
+      #   add_group_opeartor
+      #   add_where_operator_for_dimension
+      #   add_where_operator_for_metric
+      [GroupOperator, SelectOperatorForMetric, SelectOperatorForDimension,
+        WhereOperatorForDimension, WhereOperatorForMetric].each {|op| op.register_to(self)}
+
+      # = Running
+
+      def run
+        ActiveRecord::Base.connection.execute(combined_sql)
+      end
+
+      def test
+        run
+        true
+      end
+
+      # = Accessors
+
+      def sub_facts
+        except(:main).values
+      end
+
+      def main_fact
+        fetch(:main)
+      end
+
+      # = Access to SQL
+
+      def combined_sql
+        @combined_sql ||= combined_outer_sql
+      end
+
+      private
+
+      def decorate_inner_scopes
+        operators.each do |operator|
+          operator.apply_on_inner(main_fact)
+        end
+        return false if null?
+        sub_facts.each do |sub_fact_scope|
+          operators.each do |operator|
+            operator.apply_on_inner(sub_fact_scope)
+          end
+        end
+        true
+      end
+
+      def join_sub_facts
+        sub_facts.each {|x| x.add_to_join(main_fact)}
+      end
+
+      def combined_inner_scope
+        decorate_inner_scopes
+        join_sub_facts
+        main_fact.run_scope
+      end
+
+      def combined_inner_sql
+        combined_inner_scope.to_sql
+      end
+
+      def combined_outer_sql
+        wrapper = SqlWrapper.new(combined_inner_sql)
+        operators.each { |operator| operator.reapply_on_outer_wrapper(wrapper) }
+        wrapper.to_sql
+      end
+
+      class SqlWrapper
+        attr_reader :from_sql, :where_added
+        attr_accessor :select, :group, :where
+
+        def initialize(from_sql)
+          @from_sql = from_sql
+          @select = []
+          @group = []
+
+          # TODO: find a better way to solve this other than using Dummy.
+          #       Note that the same approach is not doable for select and group by, since for these ActiveRecord
+          #       requires the table to exist.
+          @where = Dummy
+          @where_added = false
+        end
+
+        def add_to_select(operand)
+          @select << operand
+        end
+
+        def add_to_where(*args)
+          @where = where.where(*args)
+          @where_added = true
+        end
+
+        def add_to_group_by(operand)
+          @group << operand
+        end
+
+        def to_sql
+          sql = "SELECT #{select.join(', ')}" +
+                 " FROM (#{from_sql}) martyr_wrapper"
+          sql += " WHERE #{where.to_sql.match(/WHERE (.*)$/)[1]}" if where_added
+          sql += " GROUP BY #{group.join(', ')}" if @group.present?
+          sql
+        end
+
+        class Dummy < ActiveRecord::Base
+        end
+      end
+
+    end
+  end
+end

data/lib/martyr/runtime/fact_scopes/main_fact_scope.rb

@@ -0,0 +1,7 @@
+module Martyr
+  module Runtime
+    class MainFactScope < BaseFactScope
+
+    end
+  end
+end

data/lib/martyr/runtime/fact_scopes/null_scope.rb

@@ -0,0 +1,7 @@
+module Martyr
+  module Runtime
+    class NullScope
+
+    end
+  end
+end

data/lib/martyr/runtime/fact_scopes/sub_fact_scope.rb

@@ -0,0 +1,16 @@
+module Martyr
+  module Runtime
+    class SubFactScope < BaseFactScope
+
+      delegate :add_to_join, to: :fact_definition
+
+      def add_to_join(main_fact_scope)
+        raise Schema::Error.new("Sub query #{name} does not have a join clause. Did you forget to call `joins_with`?") unless fact_definition.join_clause
+        main_fact_scope.decorate_scope do |scope|
+          scope.joins("#{fact_definition.join_clause} (#{scope_sql}) #{fact_definition.name} ON #{fact_definition.join_on}")
+        end
+      end
+
+    end
+  end
+end

data/lib/martyr/runtime/fact_scopes/wrapped_fact_scope.rb

@@ -0,0 +1,11 @@
+module Martyr
+  module Runtime
+    class WrappedFactScope
+
+      def initialize(sql)
+
+      end
+
+    end
+  end
+end

data/lib/martyr/runtime/pivot/pivot_axis.rb

@@ -0,0 +1,67 @@
+module Martyr
+  module Runtime
+    class PivotAxis
+      include ActiveModel::Model
+
+      attr_accessor :grain_elements
+      attr_reader :values
+
+      def inspect
+        grain_elements.inspect
+      end
+
+      def ids
+        grain_elements.map(&:id)
+      end
+
+      # = CSV
+
+      # Run on column axis only
+      def add_header_column_cells_to_csv(csv, row_axis)
+        grain_elements.each do |grain|
+          prev_value = nil
+          column_values = values.map do |x|
+            # #chomp is just a trick to avoid removing consecutive (total)
+            prev_value.try(:chomp, PivotCell::TOTAL_VALUE) == x[grain.id] ? nil : prev_value = x[grain.id]
+          end
+          csv << row_axis.csv_empty_row_axis_cells + column_values
+        end
+      end
+
+      # Run on row axis only
+      def csv_empty_row_axis_cells
+        [nil] * grain_elements.length
+      end
+
+      # @return [Array<Hash>] where each hash is of format {level_id_1 => value_1, ... }
+      def load_values(cells, reset: false)
+        @values = nil if reset
+        @values ||= cells.map { |cell| hash_grain_value_for(cell) }.uniq
+      end
+
+      def index_values_lookup
+        @index_values_lookup ||= Hash[values.each_with_index.map{|value_hash, i| [value_hash, i]}]
+      end
+
+      def sort_cells_by_values(cells)
+        cells.sort_by{|cell| index_values_lookup[hash_grain_value_for(cell)]}
+      end
+
+      def flat_values_nil_hash
+        Hash[values.map{|hash| [hash.values.join(' : '), nil]}]
+      end
+
+      def hash_values_nil_hash
+        Hash[values.map{|x| [x, nil]}]
+      end
+
+      def flat_grain_value_for(cell)
+        grain_elements.map{ |grain| grain.cell_value(cell) }.join(' : ')
+      end
+
+      def hash_grain_value_for(cell)
+        Hash[grain_elements.map{ |grain| [grain.id, grain.cell_value(cell)] }]
+      end
+    end
+  end
+end

data/lib/martyr/runtime/pivot/pivot_cell.rb

@@ -0,0 +1,54 @@
+module Martyr
+  module Runtime
+    class PivotCell
+      METRIC_COORD_KEY = 'metric'
+      TOTAL_VALUE = '(total)'
+
+      attr_reader :metric_id, :metric_human_name, :element
+      delegate :facts, :coordinates, to: :element
+
+      # @param sub_total_levels [Array<String>]
+      def initialize(metric, element, sub_total_levels = [])
+        @metric_id = metric.id
+        @metric_human_name = metric.human_name
+        @element = element
+        @sub_total_levels = sub_total_levels
+      end
+
+      def inspect
+        to_hash.inspect
+      end
+
+      def to_hash
+        {'metric_human_name' => metric_human_name, 'value' => value}.merge!(element.grain_hash)
+      end
+
+      def coordinates
+        element.coordinates(metric_id).merge(METRIC_COORD_KEY => metric_id)
+      end
+
+      def to_axis_values(pivot_axis, flat: true)
+        flat ? pivot_axis.flat_grain_value_for(self) : pivot_axis.hash_grain_value_for(self)
+      end
+
+      def value
+        element.fetch(metric_id)
+      end
+
+      def warning
+        element.warning(metric_id)
+      end
+
+      def [](key)
+        case key.to_s
+          when 'metric'
+            metric_id
+          when 'value'
+            value
+          else
+            @sub_total_levels.include?(key.to_s) ? TOTAL_VALUE : element.fetch(key)
+        end
+      end
+    end
+  end
+end

data/lib/martyr/runtime/pivot/pivot_grain_element.rb

@@ -0,0 +1,22 @@
+module Martyr
+  module Runtime
+    class PivotGrainElement
+      include ActiveModel::Model
+
+      attr_accessor :id, :metrics, :level_definition
+
+      def inspect
+        id.inspect
+      end
+
+      def cell_value(cell)
+        if metrics.present?
+          cell.metric_human_name
+        else
+          cell[level_definition.id]
+        end
+      end
+
+    end
+  end
+end

data/lib/martyr/runtime/pivot/pivot_row.rb

@@ -0,0 +1,49 @@
+module Martyr
+  module Runtime
+    class PivotRow
+      include ActiveModel::Model
+
+      attr_reader :pivot_table, :header, :cells
+      delegate :column_axis, to: :pivot_table
+
+      # @attribute header [Hash] array of keys and values for each grain in the axis
+      def initialize(pivot_table, header, cells)
+        @pivot_table = pivot_table
+        @header = header
+        @cells = column_axis.sort_cells_by_values(cells)
+      end
+
+      def inspect
+        {row_header: header, column_headers: column_headers}.inspect
+      end
+
+      # = CSV
+
+      def to_a(previous: nil)
+        row_arr = header.values + cells_by_column_headers.values.map(&:value)
+        return row_arr unless previous
+        row_arr
+        # row_arr.each_with_index.map{|x, i| i < header.length && x.try(:chomp, PivotCell::TOTAL_VALUE) == previous[i] ? nil : x}
+      end
+
+      # = Value retrieval
+
+      def cell_at(column_header)
+        cells_by_column_headers[column_header]
+      end
+
+      def [](index)
+        cell_at column_headers[index]
+      end
+
+      def column_headers
+        column_axis.hash_values_nil_hash.keys
+      end
+
+      def cells_by_column_headers
+        @cells_by_column_headers ||= Hash[cells.map{|cell| [cell.to_axis_values(column_axis, flat: false), cell]}]
+      end
+
+    end
+  end
+end