cubicle 0.1.24 → 0.1.25

data/CHANGELOG.rdoc

@@ -1,3 +1,9 @@
+==0.1.25
+  *Modified data extraction to ensure that member and query level aliases are respected in the final result. Also
+  stopped automatically dropping temporary map reduce tables during query execution for performance reasons. Instead,
+  added a static method to the Cubicle module, clear_temp_tables, which can be called at application startup or teardown:
+  Cubicle.clear_temp_tables()
+
 ==0.1.24
   *Added more detail to the profile for the 'find' action
 

data/cubicle.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{cubicle}
-  s.version = "0.1.24"
+  s.version = "0.1.25"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Nathan Stults"]
-  s.date = %q{2010-05-13}
+  s.date = %q{2010-05-19}
   s.description = %q{Cubicle provides a dsl and aggregation caching framework for automating the generation, execution and caching of map reduce queries when using MongoDB in Ruby. Cubicle also includes a MongoMapper plugin for quickly performing ad-hoc, multi-level group-by queries against a MongoMapper model.}
   s.email = %q{hereiam@sonic.net}
   s.extra_rdoc_files = [

data/lib/cubicle.rb

@@ -52,7 +52,11 @@ module Cubicle
 
   def self.logger
     @logger ||= (Cubicle.mongo.logger || Logger.new("cubicle.log"))
-  end 
+  end
+
+  def self.clear_temp_tables
+    self.mongo.database.collection_names.each{|cn|self.mongo.database[cn].drop if cn =~ /tmp.mr.mapreduce/i}
+  end
 end
 
 #Turn off HTML escaping in Mustache

data/lib/cubicle/aggregation/aggregation_manager.rb

@@ -46,7 +46,7 @@ module Cubicle
           if query.all_dimensions? || (agg_data.member_names - query.member_names - [:all_measures]).blank?
             filter = prepare_filter(query,options[:where] || {})
           else
-            reduction = aggregate(query,:source_collection=>agg_data.target_collection_name, :reason=>"Last mile reduction - source aggregation has too many members")
+            reduction = aggregate(query,:source_collection=>agg_data.target_collection_name, :reason=>"Last mile reduction - source aggregation has too many members (#{agg_data.member_names.join(",").inspect})")
           end
         end
 
@@ -57,7 +57,7 @@ module Cubicle
           @profiler.measure(:find, :source=>reduction.name, :reason=>"Fetch final query results", :query=>find_options) do
             count = reduction.count
             results = reduction.find(filter,find_options).to_a
-            reduction.drop if reduction.name =~ /^tmp.mr.*/
+            #reduction.drop if reduction.name =~ /^tmp.mr.*/
             Cubicle::Data::Table.new(query, results, count)
           end
 

data/lib/cubicle/data.rb

@@ -1,29 +1,29 @@
-module Cubicle
-  module Data
-
-    def self.aggregate(data,measures)
-      aggregated = OrderedHashWithIndifferentAccess.new {|hash,key|hash[key]=[]}
-      #in step one, we will gather our values into columns to give to the measure
-      #definitions to aggregation.
-      data.each do |row|
-        measures.each do |measure|
-          if (row.include?(measure.name))
-            val = row[measure.name]
-            aggregated[measure.name] << val if val.kind_of?(Numeric)
-          end
-        end
-      end
-      #in step two, we will let the measures reduce the columns of values to a single number, preferably using
-      #black magic or human sacrifice
-      measures.each do |measure|
-        aggregated[measure.name] = measure.aggregate(aggregated[measure.name])
-      end
-
-      #give each measure a final shot to operate on the results. This is useful for measures that
-      #act on the results of other aggregations, like Ratio does.
-      measures.each {|measure|measure.finalize_aggregation(aggregated)}
-      aggregated
-    end
-
-  end
+module Cubicle
+  module Data
+
+    def self.aggregate(data,measures)
+      aggregated = OrderedHashWithIndifferentAccess.new {|hash,key|hash[key]=[]}
+      #in step one, we will gather our values into columns to give to the measure
+      #definitions to aggregation.
+      data.each do |row|
+        measures.each do |measure|
+          if (row.include?(measure.name))
+            val = row[measure.name]
+            (aggregated[measure.name] ||= []) << val if val.kind_of?(Numeric)
+          end
+        end
+      end
+      #in step two, we will let the measures reduce the columns of values to a single number, preferably using
+      #black magic or human sacrifice
+      measures.each do |measure|
+        aggregated[measure.name] = measure.aggregate(aggregated[measure.name])
+      end
+
+      #give each measure a final shot to operate on the results. This is useful for measures that
+      #act on the results of other aggregations, like Ratio does.
+      measures.each {|measure|measure.finalize_aggregation(aggregated)}
+      aggregated
+    end
+
+  end
 end

data/lib/cubicle/data/hierarchy.rb

@@ -1,55 +1,55 @@
-module Cubicle
-  module Data
-    class Hierarchy < Cubicle::Data::Level
-      include Member
-
-      attr_reader :measures
-      def initialize(root_dimension,measures)
-        super(root_dimension)
-        @measures = measures
-        @member_name = name
-      end
-
-      def self.hierarchize_table(table, dimension_names=nil)
-        dimension_names = [table.time_dimension_name || table.dimension_names].flatten if dimension_names.blank?
-        Cubicle::Data::Hierarchy.extract_dimensions(dimension_names,table,table.dup)
-      end
-      private
-
-      def self.extract_dimensions(dimension_names, data, table,parent_level=nil)
-        data, dimension_names = data.dup, dimension_names.dup
-
-        return data if dimension_names.blank?
-
-        dim_name = dimension_names.shift
-        dim = table.dimensions.find{|d|d.name==dim_name}
-        level = parent_level ? Cubicle::Data::Level.new(dim,parent_level) : Cubicle::Data::Hierarchy.new(dim,data.measures)
-        data.each do |tuple|
-          member_name = tuple.delete(dim_name.to_s) || "Unknown"
-          level[member_name] << tuple
-        end
-
-        level.each do |key,value|
-          level[key] = Cubicle::Data::Hierarchy.extract_dimensions(dimension_names,value,table,level)
-        end
-
-        Cubicle::Data::Hierarchy.expand_time_dimension_if_required(level,table)
-
-        level
-      end
-
-      def self.expand_time_dimension_if_required(data_level,table)
-        return unless data_level.leaf_level? && table.time_dimension_name && table.time_dimension_name.to_s == data_level.name.to_s &&
-                table.time_range && table.time_period
-
-        table.time_range.by!(table.time_period)
-
-        table.time_range.each do |date|
-          formatted_date = date.to_cubicle(table.time_period)
-          data_level[formatted_date] = [OrderedHashWithIndifferentAccess.new] unless data_level.include?(formatted_date)
-        end
-        data_level.keys.sort!
-      end
-    end
-  end
-end
+module Cubicle
+  module Data
+    class Hierarchy < Cubicle::Data::Level
+      include Member
+
+      attr_reader :measures
+      def initialize(root_dimension,measures)
+        super(root_dimension)
+        @measures = measures
+        @member_name = name
+      end
+
+      def self.hierarchize_table(table, dimension_names=nil)
+        dimension_names = [table.time_dimension_name || table.dimension_names].flatten if dimension_names.blank?
+        Cubicle::Data::Hierarchy.extract_dimensions(dimension_names,table,table.dup)
+      end
+      private
+
+      def self.extract_dimensions(dimension_names, data, table,parent_level=nil)
+        data, dimension_names = data.dup, dimension_names.dup
+
+        return data if dimension_names.blank?
+
+        dim_name = dimension_names.shift
+        dim = table.dimensions.find{|d|d.name==dim_name}
+        level = parent_level ? Cubicle::Data::Level.new(dim,parent_level) : Cubicle::Data::Hierarchy.new(dim,data.measures)
+        data.each do |tuple|
+          member_name = tuple.delete(dim_name.to_s) || "Unknown"
+          (level[member_name] ||= []) << tuple
+        end
+
+        level.each do |key,value|
+          level[key] = Cubicle::Data::Hierarchy.extract_dimensions(dimension_names,value,table,level)
+        end
+
+        Cubicle::Data::Hierarchy.expand_time_dimension_if_required(level,table)
+
+        level
+      end
+
+      def self.expand_time_dimension_if_required(data_level,table)
+        return unless data_level.leaf_level? && table.time_dimension_name && table.time_dimension_name.to_s == data_level.name.to_s &&
+                table.time_range && table.time_period
+
+        table.time_range.by!(table.time_period)
+
+        table.time_range.each do |date|
+          formatted_date = date.to_cubicle(table.time_period)
+          data_level[formatted_date] = [OrderedHashWithIndifferentAccess.new] unless data_level.include?(formatted_date)
+        end
+        data_level.keys.sort!
+      end
+    end
+  end
+end

data/lib/cubicle/data/level.rb

@@ -1,62 +1,61 @@
-module Cubicle
-  module Data
-    class Level < OrderedHashWithIndifferentAccess
-
-      def initialize(dimension,parent_level=nil)
-        @dimension = dimension
-        @parent_level = parent_level
-        super() {|hash,key|hash[key]=[]}#Always have an array freshly baked when strangers call
-      end
-
-      attr_reader   :dimension, :parent_level
-      attr_accessor :missing_member_default
-
-      alias member_names keys
-      alias members values
-
-      def name
-        @dimension.name
-      end
-
-      def flatten(member_name = nil, opts={}, &block)
-
-        default_val = opts[:default] || @missing_member_default || 0
-
-        self.values.inject([]) do |output, data|
-          data.inject(output) do |flattened, value|
-            value.missing_member_default = default_val if value.respond_to?(:missing_member_default)
-
-            if block_given?
-              flat_val = block.arity == 1 ? (yield value) : (value.instance_eval(&block))
-            end
-            flat_val ||= value[member_name] if member_name && value.include?(member_name)
-            flat_val ||= default_val
-            flattened << flat_val
-          end
-        end
-      end
-
-      def leaf_level?
-        return self.length < 1 ||
-                !self[self.keys[0]].is_a?(Cubicle::Data::Level)
-      end
-
-      def []=(key,val)
-        prepare_level_member(val,key,self)
-        super(key.to_s,val)
-      end
-
-      def hierarchy
-        parent_level || self
-      end
-            
-      private
-      def prepare_level_member(member,member_name,parent_level)
-        member.class_eval("include Cubicle::Data::Member")
-        member.member_name = member_name
-        member.parent_level = parent_level
-      end
-
-    end
-  end
-end
+module Cubicle
+  module Data
+    class Level < OrderedHashWithIndifferentAccess
+
+      def initialize(dimension,parent_level=nil)
+        @dimension = dimension
+        @parent_level = parent_level
+        super() {|hash,key|hash[key]=[]}#Always have an array freshly baked when strangers call
+      end
+
+      attr_reader   :dimension, :parent_level
+      attr_accessor :missing_member_default
+
+      alias member_names keys
+      alias members values
+
+      def name
+        @dimension.name
+      end
+
+      def flatten(member_name = nil, opts={}, &block)
+
+        default_val = opts[:default] || @missing_member_default || 0
+
+        self.values.inject([]) do |output, data|
+          value = data.measure_values
+          value.missing_member_default = default_val if value.respond_to?(:missing_member_default)
+
+          if block_given?
+            flat_val = block.arity == 1 ? (yield value) : (value.instance_eval(&block))
+          end
+          flat_val ||= value[member_name] if member_name && value.include?(member_name)
+          flat_val ||= default_val
+          output << flat_val
+        end
+      end
+
+      def leaf_level?
+        return self.length < 1 ||
+                !self[self.keys[0]].is_a?(Cubicle::Data::Level)
+      end
+
+      def []=(key,val)
+        prepare_level_member(val,key,self)
+        super(key.to_s,val)
+      end
+
+      def hierarchy
+        parent_level || self
+      end
+
+      private
+      def prepare_level_member(member,member_name,parent_level)
+        member.class_eval("include Cubicle::Data::Member")
+        member.member_name = member_name
+        member.parent_level = parent_level
+      end
+
+    end
+  end
+end

data/lib/cubicle/data/table.rb

@@ -9,7 +9,7 @@ module Cubicle
         @time_dimension_name = query.time_dimension.name if query.respond_to?(:time_dimension) && query.time_dimension
         @time_period = query.time_period if query.respond_to?(:time_period)
         @time_range = query.time_range if query.respond_to?(:time_range)
-        extract_data(query_results)
+        extract_data(query,query_results)
         @total_count = total_count if total_count
       end
 
@@ -45,16 +45,37 @@ module Cubicle
 
       private
 
-      def extract_data(data)
+      def extract_data(query,data)
         data.each do |result|
           new = result.dup
           self << OrderedHashWithIndifferentAccess.new(new.delete("_id").merge(new.delete("value")))
-          #these should be processed first, because they are often used as parts of the other calc measures
-          measures.select{|m|m.distinct_count?}.each do |m|
-            m.finalize_aggregation(self[-1])
+
+          finalize_aggregations(self[-1])
+
+          apply_aliases(query,self[-1])
+        end
+      end
+
+      def finalize_aggregations(row)
+        #these should be processed first, because they are often used as parts of the other calc measures
+        measures.select{|m|m.distinct_count?}.each do |m|
+          m.finalize_aggregation(row)
+        end
+        measures.select{|m|!m.distinct_count?}.each do |m|
+          m.finalize_aggregation(row)
+        end
+      end
+
+      def apply_aliases(query,row)
+        members = query.dimensions + query.measures
+        members.select{|m|m.alias_list}.each do |m|
+          m.alias_list.each do |m_alias|
+            row[m_alias.to_s] = row[m.name.to_s]
           end
-          measures.select{|m|!m.distinct_count?}.each do |m|
-            m.finalize_aggregation(self[-1])
+        end
+        if (query.respond_to?(:query_aliases) && query.query_aliases)
+          query.query_aliases.each do |key,value|
+            row[key.to_s] = row[value.to_s]
           end
         end
       end

data/lib/cubicle/ordered_hash_with_indifferent_access.rb

@@ -1,7 +1,6 @@
 class OrderedHashWithIndifferentAccess < OrderedHash
-  def initialize(initial_data={},&block)
+  def initialize(initial_data={})
     merge!(initial_data.stringify_keys)
-    super(&block) if block
   end
 
 

data/lib/cubicle/query.rb

@@ -2,7 +2,7 @@ module Cubicle
   class Query
     include Dsl
 
-    attr_reader  :time_period, :transient, :aggregation, :named_expressions
+    attr_reader  :time_period, :transient, :aggregation, :named_expressions, :query_aliases
     attr_accessor :source_collection_name
     
     def initialize(aggregation)
@@ -104,7 +104,9 @@ module Cubicle
 
     def convert_dimension(dimension)
       return dimension if transient?
-      Cubicle::Dimension.new(dimension.name, :expression=>"this._id.#{dimension.name}")
+      d = Cubicle::Dimension.new(dimension.name, :expression=>"this._id.#{dimension.name}")
+      d.alias_list = dimension.alias_list
+      d
     end
 
     def convert_measure(measure)
@@ -133,7 +135,9 @@ module Cubicle
         count_field = expression + "_count"
         expression = "#{expression}*#{count_field}"
       end
-      Cubicle::Measure.new(measure.name, :expression=>expression,:aggregation_method=>aggregation, :distinct=>measure.distinct_count?)
+      m = Cubicle::Measure.new(measure.name, :expression=>expression,:aggregation_method=>aggregation, :distinct=>measure.distinct_count?)
+      m.alias_list = measure.alias_list
+      m
     end
 
     def unalias(*name_or_names)

data/lib/cubicle/version.rb

@@ -1,3 +1,3 @@
 module Cubicle
-  VERSION = '0.1.24'
+  VERSION = '0.1.25'
 end