activecube 0.1.0

data/lib/activecube/dimension.rb

@@ -0,0 +1,5 @@
+module Activecube
+  class Dimension
+    extend DimensionDefinitionMethods
+  end
+end

data/lib/activecube/dimension_definition_methods.rb

@@ -0,0 +1,32 @@
+module Activecube
+  module DimensionDefinitionMethods
+
+    attr_reader :column_names, :identity, :fields
+
+    def column_name
+      raise "Not defined column for a metric #{self.name}" if column_names.empty?
+      raise "Defined more than one column for a metric #{self.name}" if column_names.count>1
+      column_names.first
+    end
+
+    private
+
+    def column *args
+      array = (@column_names ||= [] )
+      data = [*args].flatten
+      values = data & array
+      raise DefinitionError, "#{values.join(',')} already defined for columns in #{self.name}" unless values.empty?
+      array.concat data
+    end
+
+    def field *args
+      (@fields ||= {} )[args.first.to_sym] = Field.new( *args)
+    end
+
+    def identity_column *args
+      raise "Identity already defined as #{identity} for #{self.name}" if @identity
+      @identity = args.first
+    end
+
+  end
+end

data/lib/activecube/field.rb

@@ -0,0 +1,12 @@
+module Activecube
+  class Field
+
+    attr_reader :name, :definition
+    def initialize *args
+      @name = args.first
+      @definition = args.second
+    end
+
+
+  end
+end

data/lib/activecube/metric.rb

@@ -0,0 +1,5 @@
+module Activecube
+  class Metric
+    extend DimensionDefinitionMethods
+  end
+end

data/lib/activecube/processor/composer.rb

@@ -0,0 +1,76 @@
+module Activecube::Processor
+  class Composer
+
+    attr_reader :cube_query, :models
+    def initialize cube_query
+      @cube_query = cube_query
+    end
+
+    def build_query
+      compose_queries optimize! ranked_tables
+    end
+
+    def connection
+      connections = models.map(&:connection).compact.uniq
+      raise "No connection found for query" if connections.empty?
+      raise "Tables #{models.map(&:name).join(',')} mapped to multiple connections, can not query" if connections.count>1
+      connections.first
+    end
+
+    private
+
+    def optimize! measure_tables
+
+      all_tables = measure_tables.map(&:tables).map(&:keys).flatten.uniq
+
+      cost_matrix = measure_tables.collect do |measure_table|
+        all_tables.collect{|table|
+          measure_table.tables[table].try(&:cost)
+        }
+      end
+
+      before = total_cost measure_tables
+      Optimizer.new(cost_matrix).optimize.each_with_index do |optimal, index|
+        measure_tables[index].selected = optimal
+      end
+      after = total_cost measure_tables
+
+      raise "Optimizer made it worth #{before} -> #{after} for #{cost_matrix}" unless after <= before
+      measure_tables
+
+    end
+
+    def total_cost measure_tables
+      measure_tables.group_by(&:table).collect{|t| t.second.map(&:entry).map(&:cost).max }.sum
+    end
+
+    def ranked_tables
+      tables = cube_query.cube.tables.select{|table| table.matches? cube_query, []}
+      cube_query.measures.collect do |measure|
+        by = MeasureTables.new measure
+        tables.each{|table|
+          next unless table.measures? measure
+          max_cardinality_index = table.model.activecube_indexes.select{|index|
+            index.indexes? cube_query, [measure]
+          }.sort_by(&:cardinality).last
+          by.add_table table, max_cardinality_index
+        }
+        raise "Metric #{measure.key} #{measure.definition.name} can not be measured by any of tables #{tables.map(&:name).join(',')}" if by.tables.empty?
+        by
+      end
+    end
+
+    def compose_queries measure_tables
+      composed_query  = nil
+      @models = []
+      measure_tables.group_by(&:table).each_pair do |table, list|
+        @models << table.model
+        reduced = cube_query.reduced list.map(&:measure)
+        table_query = table.query reduced
+        composed_query = composed_query ? table.join(cube_query, composed_query, table_query) : table_query
+      end
+      composed_query
+    end
+
+  end
+end

data/lib/activecube/processor/index.rb

@@ -0,0 +1,17 @@
+module Activecube
+  module Processor
+    class Index
+
+      attr_reader :fields, :cardinality
+      def initialize name, *args
+        @fields = [name].flatten
+        @cardinality = args.first && args.first[:cardinality]
+      end
+
+      def indexes? query, measures
+        (fields - query.selector_column_names(measures)).empty?
+      end
+
+    end
+  end
+end

data/lib/activecube/processor/measure_tables.rb

@@ -0,0 +1,42 @@
+module Activecube
+  module Processor
+    class MeasureTables
+
+      class Entry
+        attr_reader :table, :index, :cardinality, :cost
+        def initialize table, index
+          @table = table
+          @index = index
+          @cardinality = index ? index.cardinality : 0
+          @cost = 1.0 / (1.0 + cardinality)
+        end
+      end
+
+      attr_reader :measure, :entries, :tables
+      attr_accessor :selected
+
+      def initialize measure
+        @measure = measure
+        @tables = {}
+        @entries = []
+        @selected = 0
+      end
+
+
+      def add_table table, index
+        e = Entry.new(table, index)
+        entries << e
+        tables[table] = e
+      end
+
+      def table
+        entry.table
+      end
+
+      def entry
+        entries[selected]
+      end
+
+    end
+  end
+end

data/lib/activecube/processor/optimizer.rb

@@ -0,0 +1,123 @@
+module Activecube::Processor
+
+  class Optimizer
+
+    UNLIM_COST = 9999
+    MAX_ITERATIONS = 3
+
+    attr_reader :tables_count, :metrics_count, :cost_matrix
+    def initialize cost_matrix
+      @cost_matrix = cost_matrix
+    end
+
+    def optimize
+
+      Rails.cache.fetch(cost_matrix, expires_in: 12.hours) do
+
+        @tables_count = cost_matrix.map(&:count).max
+        @metrics_count = cost_matrix.count
+
+        tables_count==1 ? [0]*metrics_count : do_optimize
+
+       end
+
+
+    end
+
+    private
+
+
+    def do_optimize
+      @tables_by_metrics = []
+
+      # sort metrics from low min cost to higher min costs ( by all applicable tables )
+      sort_metrics
+
+      # fill initial @tables_by_metrics by selecting tables with minimum cost for metrics.
+      # If there are more than one table with this minimum cost, then select already selected table with maximum cost
+      select_min_cost_by_metric
+
+      # make iterations over @tables_by_metrics ( max MAX_ITERATIONS)
+      iterates
+
+      @tables_by_metrics
+    end
+
+    def sort_metrics
+      @metrics_index_sorted = (0...metrics_count).sort_by{|m_i| cost_matrix[m_i].compact.min || UNLIM_COST }
+    end
+
+    def select_min_cost_by_metric
+
+      @metrics_index_sorted.collect do |m_i|
+
+        table_index_cost = (0...tables_count).map{|c_i| [c_i,
+                                                        cost_matrix[m_i][c_i] || UNLIM_COST,
+                                                        (@tables_by_metrics.include?(c_i) ? -cost_matrix[@tables_by_metrics.index(c_i)][c_i] : 0)
+        ]}.sort_by(&:third).sort_by(&:second)
+
+        @tables_by_metrics[m_i] = table_index_cost.first.first
+
+      end
+    end
+
+    def iterates
+
+      steps = [@tables_by_metrics]
+
+      (1..MAX_ITERATIONS).each do |iteration|
+
+        step = []
+        prev_step = steps.last
+
+        prev_step.each_with_index {|c_i, m_i|
+
+          table_included_times = prev_step.select{|c| c==c_i }.count
+          old_cost = cost_matrix[m_i][c_i]
+          new_c_i = (0...tables_count).detect{|c_n|
+            new_cost = cost_matrix[m_i][c_n]
+            next if c_i==c_n || new_cost.nil?
+            new_table_included_times = prev_step.select{|c| c==c_n }.count
+
+            if old_cost.nil?
+              # if we have non indexed table now
+              true
+            elsif table_included_times>1
+              if new_table_included_times>0
+                # table to used table if
+                # cost now > new cost
+                old_cost > new_cost
+              else
+                # table to unused table if
+                # cost now > new cost + max other cost in table now
+                old_cost > new_cost + ( prev_step.select.with_index{|c,i| c==c_i && i!=m_i }.max || UNLIM_COST )
+              end
+            else
+              if new_table_included_times>0
+                # unused table to table if
+                # new cost <  cost now + max other cost in new table
+                old_cost > new_cost - ( prev_step.select{|c| c==c_n }.max || UNLIM_COST )
+              else
+                # unused to unused
+                # cost now > new cost
+                old_cost > new_cost
+              end
+            end
+
+          }
+
+          step << c_i || new_c_i
+
+        }
+
+        break if steps.include? step
+        steps << step
+      end
+
+      @tables_by_metrics = steps.last
+
+    end
+
+  end
+
+end

data/lib/activecube/processor/table.rb

@@ -0,0 +1,54 @@
+module Activecube::Processor
+  class Table
+
+    attr_reader :model
+
+    def initialize model
+      @model = model
+    end
+
+    def name
+      model.table_name
+    end
+
+    def matches? query, measures = query.measures
+      (query.column_names(measures)-model.attribute_types.keys).empty?
+    end
+
+    def measures? measure
+      (measure.required_column_names - model.attribute_types.keys).empty?
+    end
+
+    def query cube_query
+
+      table = model.arel_table
+      query = table
+
+      (cube_query.slices + cube_query.measures + cube_query.selectors + cube_query.options).each do |s|
+        query = s.append_query cube_query, table, query
+      end
+
+      query
+    end
+
+    def join cube_query, left_query, right_query
+
+      outer_table = model.arel_table.class.new('').project(Arel.star)
+
+      dimension_names = cube_query.join_fields
+
+      query = outer_table.from(left_query).
+          join(right_query, ::Arel::Nodes::FullOuterJoin).
+          using(*dimension_names)
+
+      cube_query.options.each do |option|
+        query = option.append_query cube_query, outer_table, query
+      end
+
+
+      query
+    end
+
+
+  end
+end

data/lib/activecube/query/chain_appender.rb

@@ -0,0 +1,25 @@
+module Activecube::Query
+  module ChainAppender
+    private
+
+    def append *args, list, def_class, definitions
+      list.concat args.map{|arg|
+        if arg.kind_of?(Symbol) && definitions
+          definitions[arg]
+        elsif arg.kind_of?(def_class)
+          arg
+        elsif arg.kind_of? Hash
+          arg.collect{|pair|
+            raise ArgumentError, "Unexpected #{pair.second.class.name} to use for #{def_class} as #{arg}[#{pair.first}]" unless pair.second.kind_of?(def_class)
+            pair.second.alias! pair.first
+          }
+        else
+          raise ArgumentError, "Unexpected #{arg.class} to use for #{def_class} as #{arg}"
+        end
+      }.flatten
+      self
+    end
+
+
+  end
+end

data/lib/activecube/query/cube_query.rb

@@ -0,0 +1,112 @@
+module Activecube::Query
+  class CubeQuery
+
+    include ChainAppender
+
+    attr_reader :cube, :slices, :measures, :selectors, :orderings, :options
+    def initialize cube, slices = [], measures = [], selectors = [], options = []
+      @cube = cube
+      @slices = slices
+      @measures = measures
+      @selectors = selectors
+      @options = options
+    end
+
+    def slice *args
+      append *args, @slices, Slice, cube.dimensions
+    end
+
+    def measure *args
+      append *args, @measures, Measure, cube.metrics
+    end
+
+    def select *args
+      append *args, @selectors, Selector, cube.selectors
+    end
+
+    def desc *args
+      args.each{|arg|
+        options << Ordering.new(arg, :desc)
+      }
+      self
+    end
+
+    def asc *args
+      args.each{|arg|
+        options << Ordering.new( arg, :asc)
+      }
+      self
+    end
+
+    def skip *args
+      args.each{|arg|
+        options << Limit.new( arg, :skip)
+      }
+      self
+    end
+
+    def take *args
+      args.each{|arg|
+        options << Limit.new( arg, :take)
+      }
+      self
+    end
+
+    def query
+      composer = Activecube::Processor::Composer.new(self)
+      sql = composer.build_query.to_sql
+      composer.connection.exec_query(sql)
+    end
+
+    def to_query
+      Activecube::Processor::Composer.new(self).build_query
+    end
+
+    def to_sql
+      to_query.to_sql
+    end
+
+    def column_names measures = self.measures
+      (measures + slices + selectors).map(&:required_column_names).flatten.uniq
+    end
+
+    def selector_column_names measures = self.measures
+      (measures.map(&:selectors) + selectors).flatten.map(&:required_column_names).flatten.uniq
+    end
+
+    def reduced other_measures
+
+      common_selectors = []
+      other_measures.each_with_index do |m,i|
+        if i==0
+          common_selectors += m.selectors
+        else
+          common_selectors &= m.selectors
+        end
+      end
+
+      if common_selectors.empty?
+        reduced_measures = other_measures
+        reduced_selectors = self.selectors
+      else
+        reduced_measures = other_measures.collect{|m|
+          Measure.new m.cube, m.key, m.definition, (m.selectors - common_selectors)
+        }
+        reduced_selectors = self.selectors + common_selectors
+      end
+
+      unless reduced_measures.detect{|rm| rm.selectors.empty? }
+        reduced_selectors += [OrSelector.new(reduced_measures.map(&:selectors).flatten.uniq)]
+      end
+
+      return self if (reduced_measures == self.measures) && (reduced_selectors == self.selectors)
+
+      CubeQuery.new cube, slices, reduced_measures, reduced_selectors
+    end
+
+    def join_fields
+      slices.map{|s| s.dimension_class.identity || s.key }.uniq
+    end
+
+  end
+end