martyr 0.1.74.pre

data/lib/martyr/runtime/query/query_context_builder.rb

@@ -0,0 +1,215 @@
+module Martyr
+  module Runtime
+    # This is a SubCube builder. The builder method is #execute.
+    # It takes the `select`, `slice`, and `granulate` clauses, makes sure they are well defined, and create a sub cube
+    # as a result of their application.
+    class QueryContextBuilder
+
+      include Martyr::LevelComparator
+      include Martyr::Translations
+
+      attr_reader :cube, :scope_helper_module
+      delegate :elements, :facts, :pivot, :total, :totals, to: :build
+
+      def initialize(cube, scope_helper_module)
+        @cube = cube
+        @metric_dependency_resolver = MetricDependencyResolver.new(cube)
+        @data_slice = {}
+        @granulate_args = []
+        @decorations = {}
+        @scope_helper_module = scope_helper_module
+        extend_scope_helper
+      end
+
+      # select(:a, :b, :c)
+      # select(:all)
+      def select!(*arr)
+        @all_metrics = true and return self if arr.length == 1 and arr.first.to_s == 'all'
+        standardize(arr).each do |metric_id|
+          @metric_dependency_resolver.add_metric(metric_id)
+        end
+        self
+      end
+
+      # Variant 1 - full slice as one hash:
+      #   slice('artist.name' => {with: 'AC/DC'}, 'genre.name' => {with: 'Rock'}, quantity: {gt: 0})
+      #
+      # Variant 2 - on one dimension or metric
+      #   slice('artist.name', with: 'AC/DC')
+      #
+      def slice!(*several_variants)
+        if several_variants.length == 1 and several_variants.first.is_a?(Hash)
+          several_variants.first.stringify_keys.except(PivotCell::METRIC_COORD_KEY).each do |slice_on, slice_definition|
+            @data_slice.merge! standardize(slice_on) => slice_definition
+          end
+        elsif several_variants.length == 2
+          slice_on, slice_definition = several_variants
+          @data_slice.merge! standardize(slice_on) => slice_definition
+        else
+          ArgumentError.new("wrong number of arguments (#{several_variants.length} for 1..2)")
+        end
+        self
+      end
+
+      # granulate('artist.name', 'genre.name')
+      def granulate!(*arr)
+        @granulate_args += arr
+        self
+      end
+
+      # @param level_id [String]
+      # @param *args [Array] will be sent to includes
+      def decorate!(level_id, lambda = nil, &block)
+        @decorations[level_id] = lambda || block
+        self
+      end
+
+      def select(*args)
+        data_dup.select!(*args)
+      end
+
+      def slice(*args)
+        data_dup.slice!(*args)
+      end
+
+      def granulate(*args)
+        data_dup.granulate!(*args)
+      end
+
+      def decorate(*args, &block)
+        data_dup.decorate!(*args, &block)
+      end
+
+      def build
+        return @context if @context
+        context = QueryContext.new
+        add_metric_slices_to_metric_dependencies
+        add_all_metrics_if_none_selected
+        setup_context_grain_and_metrics(context)
+        setup_context_dimension_scopes(context)
+        setup_context_sub_cubes_metrics_and_grain_and_sub_facts(context)
+        setup_context_data_slice(context)
+        setup_virtual_cube(context)
+        decorate_all_scopes(context)
+        @context = context
+      end
+
+      private
+
+      # = Building steps
+
+      def add_metric_slices_to_metric_dependencies
+        @data_slice.keys.select{ |slice_on| cube.metric?(slice_on) }.each do |metric_id|
+          @metric_dependency_resolver.add_metric(metric_id, explicit: false)
+        end
+      end
+
+      def add_all_metrics_if_none_selected
+        return unless @all_metrics
+        return if @metric_dependency_resolver.metric_ids.present?
+        cube.metrics.values.each do |metric|
+          @metric_dependency_resolver.add_metric(metric.id)
+        end
+      end
+
+      # Step 1
+      # Add all levels to the query grain
+      def setup_context_grain_and_metrics(context)
+        context.level_ids_in_grain = Array.wrap(@granulate_args)
+        context.metrics = @metric_dependency_resolver.metrics
+      end
+
+      # Step 2 (relies on Steps 1)
+      # Build the dimension scope objects supported by the grain AND slices.
+      #   DegeneratesAndBottomLevels.granulate('genres.name', 'media_types.name').slice('customers.country', with: 'USA')
+      def setup_context_dimension_scopes(context)
+        relevant_dimensions = (default_grains + context.level_ids_in_grain + @data_slice.keys).map { |x| first_element_from_id(x) }
+        context.dimension_scopes = cube.build_dimension_scopes(relevant_dimensions.uniq)
+
+        @decorations.each do |level_id, proc|
+          context.dimension_scopes.find_level(level_id).decorate_scope(&proc)
+        end
+      end
+
+      # Step 3
+      # Setup the sub cubes, metrics, and grain for all cubes. Note that each cube only takes the levels of dimensions
+      # it supports. That said, if dimension has levels L1, L2, L3 and a cube supports only L1 and L2, if L3 is
+      # requested it will yield an empty cube.
+      # If no metrics were given, select all.
+      # If no grain was given, select all levels - separately for each cube.
+      def setup_context_sub_cubes_metrics_and_grain_and_sub_facts(context)
+        cube.contained_cube_classes.index_by(&:cube_name).each do |cube_name, cube_class|
+          metric_ids = @metric_dependency_resolver.metric_ids_for(cube_name, all: true)
+          grain = (@granulate_args + @metric_dependency_resolver.inferred_fact_grain_for(cube_name) +
+                   cube_class.default_fact_grain).uniq
+          sub_facts = @metric_dependency_resolver.sub_facts_for(cube_name)
+
+          sub_cube = Runtime::SubCube.new(context, cube_class)
+          context.sub_cubes_hash[cube_name] = sub_cube
+          sub_cube.set_metrics(metric_ids)
+          sub_cube.set_grain(grain)
+          sub_cube.set_sub_facts(sub_facts)
+        end
+      end
+
+      # Step 4
+      # Sets the data slice. Note that no slicing actually occurs - only setup.
+      def setup_context_data_slice(context)
+        @data_slice.each do |slice_on, slice_definition|
+          context.data_slice.slice(slice_on, slice_definition)
+        end
+      end
+
+      # Step 5
+      # Sets the virtual cube
+      def setup_virtual_cube(context)
+        return unless cube.virtual?
+        context.virtual_cube = cube
+        context.virtual_cube_metric_ids = @metric_dependency_resolver.metric_ids_for(cube.cube_name, all: true)
+      end
+
+      # Step 6 (depends on steps 3 and 4)
+      # All scopes are altered to represent the necessary queries - fact scopes (select, where, and group by) and
+      # dimension scopes (where)
+      def decorate_all_scopes(context)
+        context.data_slice.add_to_dimension_scope(context)
+        context.sub_cubes_hash.each do |_cube_name, sub_cube|
+          sub_cube.decorate_all_scopes context.data_slice.for_cube(sub_cube)
+        end
+      end
+
+      protected
+
+      def extend_scope_helper
+        return self unless scope_helper_module
+        extend(scope_helper_module)
+      end
+
+      private
+
+      def data_dup
+        dup.instance_eval do
+          @decorations = @decorations.dup
+          @data_slice = @data_slice.dup
+          @granulate_args = @granulate_args.dup
+          @metric_dependency_resolver = @metric_dependency_resolver.data_dup
+          extend_scope_helper
+          self
+        end
+      end
+
+      def standardize(object)
+        @standardizer ||= Martyr::MetricIdStandardizer.new(cube.contained_cube_classes.first.cube_name,
+          raise_if_not_ok: cube.contained_cube_classes.length > 1)
+
+        @standardizer.standardize(object)
+      end
+
+      def default_grains
+        (@metric_dependency_resolver.inferred_fact_grain +
+          cube.contained_cube_classes.flat_map(&:default_fact_grain)).uniq
+      end
+
+    end
+  end
+end

data/lib/martyr/runtime/scope_operators/base_operator.rb

@@ -0,0 +1,113 @@
+module Martyr
+  module Runtime
+
+    class BaseOperator
+      attr_reader :setup_block, :operation_args
+      attr_accessor :fact_scope
+
+      # Defines the method #add_<operator_name> to a class.
+      #
+      # @param klass [#operators] any class that has an instance method called operators
+      def self.register_to(klass)
+        current_class = self
+        klass.class_eval do
+          define_method "add_#{current_class.name.split('::').last.underscore}" do |*args, &block|
+            operators << current_class.new(*args, &block)
+          end
+        end
+      end
+
+      def initialize(&setup_block)
+        @setup_block = setup_block
+      end
+
+      def inspect
+        to_hash.inspect
+      end
+
+      def to_hash
+        {
+          self.class.name.split('::').last.underscore =>
+          (instance_variables - [:@setup_block, :@main_setup, :@fact_scope]).map{|x| {x => instance_variable_get(x)}}
+        }
+      end
+
+      # = Running
+
+      # There are 3 types of fact scopes that are handled:
+      #   Inner main
+      #     The main query fact scope.
+      #   Inner sub
+      #     A sub query fact scope.
+      #   Outer wrapper
+      #     The wrapper block on the query.
+      #
+      # Step 1
+      #   Run the setup block if it is determined that the block can be supported for the current scope.
+      #   The setup block is expected to run the appropriate operator "verb" on the provided operator instance, e.g.
+      #   #add_select, #add_where, etc.
+      #   The verb saves information that is to be applied on a fact scope - main, sub, or outer.
+      #   The execution of the setup block is yielded self with the @fact_scope ivar initialized, so that
+      #   support methods on self are available to the setup block.
+      #
+      # Step 2
+      #   If the fact_scope is the main fact scope, a dup of the object is stored in @main_setup ivar, so that the
+      #   result of running the setup block can be reused when reapplying on the outer wrapper.
+      #
+      # Step 3
+      #   The concrete handle_inner is called for the current fact scope, which is assumed to be the main.
+      #
+
+      def apply_on_inner(fact_scope)
+        return if fact_scope.is_a?(Runtime::SubFactScope) and !run_for_sub_fact?
+        return unless supported_for?(fact_scope)
+        with_fact_scope_ivar(fact_scope) { setup_block.call(self) }
+        @main_setup = dup unless fact_scope.is_a?(Runtime::SubFactScope)
+        dup.send(:handle_inner, fact_scope)
+      end
+
+      def reapply_on_outer_wrapper(wrapper)
+        raise Internal::Error.new('@main_setup is not initialized. #apply_on_inner must be run on the ' +
+          'main fact scope before calling #reapply_on_outer_wrapper') unless @main_setup.present?
+
+        @main_setup.send(:handle_outer, wrapper)
+      end
+
+      # Concrete classes can optionally alias their particular verb (add_where, add_group, etc.) to this method
+      def operate(*args)
+        @operation_args = args
+      end
+
+      private
+
+      # = Concrete class methods to override
+
+      # @return [Boolean] whether the operator should be run for sub facts
+      def run_for_sub_fact?
+        false
+      end
+
+      # @return [Boolean] whether the particular fact_scope is supported by this operator
+      def supported_for?(fact_scope)
+        true
+      end
+
+      def handle_inner(fact_scope)
+        # no-op
+      end
+
+      def handle_outer(wrapper)
+        # no-op
+      end
+
+      # = Helpers
+
+      def with_fact_scope_ivar(fact_scope)
+        @fact_scope = fact_scope
+        yield
+      ensure
+        @fact_scope = nil
+      end
+    end
+  end
+end

data/lib/martyr/runtime/scope_operators/group_operator.rb

@@ -0,0 +1,18 @@
+module Martyr
+  module Runtime
+    class GroupOperator < BaseOperator
+
+      attr_reader :field_alias
+
+      def add_group(field_alias)
+        @field_alias = field_alias
+      end
+
+      private
+
+      def handle_outer(wrapper)
+        wrapper.add_to_group_by(field_alias)
+      end
+    end
+  end
+end

data/lib/martyr/runtime/scope_operators/select_operator_for_dimension.rb

@@ -0,0 +1,24 @@
+module Martyr
+  module Runtime
+    class SelectOperatorForDimension < BaseOperator
+
+      attr_reader :what, :as
+
+      def add_select(what, as:)
+        @what = what
+        @as = as
+      end
+
+      private
+
+      def handle_inner(fact_scope)
+        fact_scope.decorate_scope {|scope| scope.select("#{what} AS #{as}") }
+      end
+
+      def handle_outer(wrapper)
+        wrapper.add_to_select(as)
+      end
+
+    end
+  end
+end

data/lib/martyr/runtime/scope_operators/select_operator_for_metric.rb

@@ -0,0 +1,35 @@
+module Martyr
+  module Runtime
+    class SelectOperatorForMetric < BaseOperator
+
+      attr_reader :metric_name
+      attr_reader :what, :as, :data_rollup_sql
+
+      def initialize(metric_name, &block)
+        super(&block)
+        @metric_name = metric_name
+      end
+
+      def add_select(what, as:, data_rollup_sql: nil)
+        @what = what
+        @as = as
+        @data_rollup_sql = data_rollup_sql
+      end
+
+      private
+
+      def handle_inner(fact_scope)
+        fact_scope.decorate_scope {|scope| scope.select("#{what} AS #{as}") }
+      end
+
+      def handle_outer(wrapper)
+        wrapper.add_to_select(data_rollup_sql) if data_rollup_sql.present?
+      end
+
+      def supported_for?(fact_scope)
+        fact_scope.supports_metric?(metric_name)
+      end
+
+    end
+  end
+end

data/lib/martyr/runtime/scope_operators/where_operator_for_dimension.rb

@@ -0,0 +1,43 @@
+module Martyr
+  module Runtime
+    class WhereOperatorForDimension < BaseOperator
+      include Martyr::LevelComparator
+
+      attr_reader :dimension_name, :level_name, :block
+      delegate :level_key_for_where, to: :fact_scope
+
+      alias_method :add_where, :operate
+
+      def initialize(dimension_name, level_name, &block)
+        super(&block)
+        @dimension_name = dimension_name
+        @level_name = level_name
+      end
+
+      # = Support methods (@fact_scope is initialized)
+
+      def common_denominator_level(level_definition)
+        common_level = find_common_denominator_level(level_definition, fact_scope.dimensions[dimension_name].level_objects)
+
+        # This should never be raised, since the QueryGrain should have already nullified the cube
+        raise Internal::Error.new("Internal error: Dimension `#{dimension_name}` slice on level `#{level_name}` has no common denominator.") unless common_level
+        common_level
+      end
+
+      private
+
+      def handle_inner(fact_scope)
+        fact_scope.decorate_scope {|scope| scope.where(*operation_args) }
+      end
+
+      def run_for_sub_fact?
+        true
+      end
+
+      def supported_for?(fact_scope)
+        fact_scope.supports_dimension_level?(dimension_name, level_name)
+      end
+
+    end
+  end
+end

data/lib/martyr/runtime/scope_operators/where_operator_for_metric.rb

@@ -0,0 +1,25 @@
+module Martyr
+  module Runtime
+    class WhereOperatorForMetric < BaseOperator
+
+      attr_reader :metric_name
+      alias_method :add_where, :operate
+
+      def initialize(metric_name, &block)
+        super(&block)
+        @metric_name = metric_name
+      end
+
+      private
+
+      def handle_outer(wrapper)
+        wrapper.add_to_where(*operation_args)
+      end
+
+      def supported_for?(fact_scope)
+        fact_scope.supports_metric?(metric_name)
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,70 @@
+module Martyr
+  module Runtime
+    class DataSlice
+
+      attr_accessor :slices
+      attr_reader :definition_resolver
+
+      include Martyr::Delegators
+      each_child_delegator :add_to_grain, :add_to_where, :add_to_dimension_scope, to: :slice_objects
+
+      include Martyr::Translations
+
+      # = Slice definitions
+
+      # @param definition_resolver [#definition_from_id]
+      def initialize(definition_resolver)
+        @definition_resolver = definition_resolver
+        @slices = ScopeableSliceData.new
+      end
+
+      def inspect
+        to_hash.inspect
+      end
+
+      def to_hash
+        slice_objects.inject({}) {|h,slice| h.merge! slice.to_hash}
+      end
+
+      # @return [Array<String>] with either metric ID or level ID (contrast with dimension name)
+      def keys
+        slice_objects.flat_map(&:keys)
+      end
+
+      def definition_object_for(slice_on)
+        definition_resolver.definition_from_id(slice_on) || raise(Query::Error.new("Could not find `#{slice_on}` to apply slice on"))
+      end
+
+      # @param slice_on [String] e.g. 'customers.last_name' or 'amount_sold'
+      # @param slice_definition [Hash]
+      def slice(slice_on, slice_definition)
+        slice_on_object = definition_object_for(slice_on)
+        slices[slice_on_object.slice_id] ||= slice_on_object.build_data_slice
+        slices[slice_on_object.slice_id].set_slice(slice_on_object, **slice_definition.symbolize_keys)
+      end
+
+      def slice_objects
+        slices.values
+      end
+
+      # @return [Array<String>]
+      def dimension_names
+        slices.reject{|_slice_id, slice_object| slice_object.is_a?(MetricDataSlice)}.keys
+      end
+
+      # @param sub_cube [SubCube]
+      # @return [DataSlice] new object with a new ScopeableDataSliceData object set to be scoped to the sub cube
+      def for_cube(sub_cube)
+        dup.for_cube!(sub_cube)
+      end
+
+      # @param sub_cube [SubCube]
+      # @return [DataSlice] same object with a new ScopeableDataSliceData object set to be scoped to the sub cube
+      def for_cube!(sub_cube)
+        self.slices = slices.scope(sub_cube)
+        self
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,54 @@
+module Martyr
+  module Runtime
+    class MetricDataSlice
+      attr_reader :metric, :slice_definition
+      delegate :to_hash, to: :slice_definition
+      delegate :cube_name, to: :metric
+      delegate :id, to: :metric, prefix: true
+
+      def initialize(metric)
+        @metric = metric
+      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
+        @slice_definition = MetricSliceDefinition.new(metric: metric, **options)
+      end
+
+      def get_slice(metric_id_for_get)
+        raise Martyr::Error.new('Internal error. Inconsistent metric received') unless metric_id_for_get == metric_id
+        @slice_definition
+      end
+
+      def add_to_dimension_scope(*)
+        # no-op
+      end
+
+      def add_to_grain(*)
+        # no-op
+      end
+
+      # @param fact_scopes [Runtime::FactScopeCollection]
+      def add_to_where(fact_scopes, *)
+        slice_definition.combined_statements.each do |or_statements|
+          fact_scopes.add_where_operator_for_metric(metric_id) do |operator|
+            operator.add_where compile_or_statement_group(or_statements),
+                           *or_statements.map{|slice_statement| slice_statement[:value]}
+          end
+        end
+      end
+
+      private
+
+      def compile_or_statement_group(or_statement_group)
+        or_statement_group.map do |slice_statement|
+          "#{metric.fact_alias} #{slice_statement[:data_operator]} ?"
+        end.join(' OR ')
+      end
+    end
+  end
+end