mochigome 0.0.9 → 0.0.10

data/lib/mochigome_ver.rb

@@ -1,3 +1,3 @@
 module Mochigome
-  VERSION = "0.0.9"
+  VERSION = "0.0.10"
 end

data/lib/model_extensions.rb

@@ -305,13 +305,13 @@ module Mochigome
 
     if vals.size == 1
       vals << :id # TODO : Use real primary key, only do this for appropriate agg funcs
-    elsif vals.size != 2
+    elsif vals.empty? || vals.size > 3
       raise ModelSetupError.new "Wrong # of components for agg: #{obj.inspect}"
     end
 
     {
-      :agg_proc => aggregation_proc(vals.first),
-      :value_proc => value_proc(vals.last)
-    }
+      :agg_proc => aggregation_proc(vals[0]),
+      :value_proc => value_proc(vals[1])
+    }.merge(vals[2] || {})
   end
 end

data/lib/query.rb

@@ -76,23 +76,41 @@ module Mochigome
 
           agg_data_rel = self.class.relation_over_path(agg_path, focus_rel.dup)
           agg_data_rel = access_filtered_relation(agg_data_rel, @layers_path + agg_path)
-          data_tbl = Arel::Table.new(data_model.table_name)
           agg_fields = data_model.mochigome_aggregation_settings.options[:fields].reject{|a| a[:in_ruby]}
+          agg_joined_models = @layers_path + agg_path
           agg_fields.each_with_index do |a, i|
-            agg_data_rel.project(a[:value_proc].call(data_tbl).as("d#{i}"))
+            (a[:joins] || []).each do |m|
+              unless agg_joined_models.include?(m)
+                cand = nil
+                agg_joined_models.each do |agg_join_src_m|
+                  p = self.class.path_thru([agg_join_src_m, m])
+                  if p && (cand.nil? || p.size < cand.size)
+                    cand = p
+                  end
+                end
+                if cand
+                  agg_data_rel = self.class.relation_over_path(cand, agg_data_rel)
+                  agg_joined_models += cand
+                else
+                  raise QueryError.new("Can't join from query to agg join model #{m.name}") # TODO: Test this
+                end
+              end
+            end
+            d_expr = a[:value_proc].call(data_model.arel_table)
+            agg_data_rel.project(d_expr.as("d#{i}"))
           end
 
           @aggregate_rels[focus_model][data_model] = (0..key_cols.length).map{|n|
             lambda {|cond|
               d_rel = agg_data_rel.dup
-              d_cols = key_cols.take(n) + [Arel::Table.new(data_model.table_name)[data_model.primary_key]]
+              d_cols = key_cols.take(n) + [data_model.arel_primary_key]
               d_cols.each_with_index do |col, i|
                 d_rel.project(col.as("g#{i}")).group(col)
               end
               d_rel.where(cond) if cond
 
-              # FIXME: This subtable won't be necessary for all forms of aggregation.
-              # When we can avoid it, we should, because query performance is greatly increased.
+              # FIXME: This subtable won't be necessary for all aggregation funcs.
+              # When we can avoid it, we should, for performance.
               a_rel = Arel::SelectManager.new(
                 Arel::Table.engine,
                 Arel.sql("(#{d_rel.to_sql}) as mochigome_data")
@@ -122,16 +140,14 @@ module Mochigome
       if cond.is_a?(Array)
         return root if cond.empty?
         cond = cond.inject(nil) do |expr, obj|
-          cls = obj.class
-          tbl = Arel::Table.new(cls.table_name)
-          subexpr = tbl[cls.primary_key].eq(obj.id)
+          subexpr = obj.class.arel_primary_key.eq(obj.id)
           expr ? expr.or(subexpr) : subexpr
         end
       end
       if cond
         self.class.expr_tables(cond).each do |t|
           raise QueryError.new("Condition table #{t} not in layer list") unless
-            @layers_path.any?{|m| m.table_name == t}
+            @layers_path.any?{|m| m.real_model? && m.table_name == t}
         end
       end
 
@@ -270,6 +286,7 @@ module Mochigome
 
     # TODO: Move the stuff below into its own module
 
+    # Take an expression and return a Set of all tables it references
     def self.expr_tables(e)
       # TODO: This is kind of hacky, Arel probably has a better way
       # to do this with its API.
@@ -287,9 +304,9 @@ module Mochigome
     @@shortest_paths = {}
 
     def self.relation_over_path(path, rel = nil)
-      # Project ensures that we don't return a Table even if path is empty
       real_path = path.map{|e| (e.real_model? ? e : e.model)}.uniq
-      rel ||= Arel::Table.new(real_path.first.table_name).project
+      # Project ensures that we return a Rel, not a Table, even if path is empty
+      rel ||= real_path.first.arel_table.project
       (0..(real_path.size-2)).each do |i|
         rel = relation_func(real_path[i], real_path[i+1]).call(rel)
       end

data/lib/subgroup_model.rb

@@ -54,7 +54,7 @@ module Mochigome
       unless c.is_a?(Hash) && c.size == 1 && c[@attr].is_a?(Array)
         raise QueryError.new("Invalid conditions given to SubgroupModel#all")
       end
-      recs = c[@attr].map do |val|
+      recs = c[@attr].compact.map do |val|
         SubgroupPseudoRecord.new(self, val)
       end
       # TODO: Support some kind of custom ordering

data/test/app_root/app/models/sale.rb

@@ -1,6 +1,10 @@
 class Sale < ActiveRecord::Base
   has_mochigome_aggregations do |a|
-    a.fields [:count]
+    a.fields [:count, {
+      "Gross" => [:sum, lambda {|t|
+        Product.arel_table[:price]
+      }, {:joins => [Product]}]
+    }]
   end
 
   belongs_to :store_product

data/test/unit/query_test.rb

@@ -200,6 +200,7 @@ describe Mochigome::Query do
     # Store X, Product C
     assert_equal "Product C", (data_node/0/0/1).name
     assert_equal 3, (data_node/0/0/1)['Sales count']
+    assert_equal (3*@product_c.price).to_s, (data_node/0/0/1)['Gross'].to_s
     # Store Z, Product C
     assert_equal "Product C", (data_node/1/1/0).name
     assert_equal 2, (data_node/1/1/0)['Sales count']
@@ -211,6 +212,7 @@ describe Mochigome::Query do
     # Store Z, Product C
     assert_equal "Product C", (data_node/1/0/0).name
     assert_equal 2, (data_node/1/0/0)['Sales count']
+    assert_equal (2*@product_c.price).to_s, (data_node/1/0/0)['Gross'].to_s
   end
 
   it "collects aggregate data in subgroups" do
@@ -325,6 +327,19 @@ describe Mochigome::Query do
     assert_nil (data_node/0/0/0/0)['Sales count']
   end
 
+  it "can collect aggregate data involving joins to tables not on path" do
+    q = Mochigome::Query.new(
+      [Owner, Store],
+      :aggregate_sources => [Sale]
+    )
+
+    data_node = q.run()
+    assert_equal "John's Store", (data_node/0/0).name
+    assert_equal 8, (data_node/0/0)['Sales count']
+    assert_equal (5*@product_a.price + 3*@product_c.price).to_s,
+      (data_node/0/0)['Gross'].to_s
+  end
+
   it "can do conditional counts" do
     q = Mochigome::Query.new(
       [Category],
@@ -447,7 +462,7 @@ describe Mochigome::Query do
       }
     end
     q = Mochigome::Query.new([Product], :access_filter => af)
-    dn = q.run(Product.all) # FIXME: Need a better way of doing "all objs" queries
+    dn = q.run
     assert_equal 4, dn.children.size
     refute dn.children.any?{|c| c.name == "Product E"}
   end
@@ -461,7 +476,7 @@ describe Mochigome::Query do
       }
     end
     q = Mochigome::Query.new([Product], :access_filter => af)
-    dn = q.run(Product.all) # FIXME: Need a better way of doing "all objs" queries
+    dn = q.run
     assert_equal 2, dn.children.size
     refute dn.children.any?{|c| c.name == "Product E"}
   end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: mochigome
 version: !ruby/object:Gem::Version 
-  hash: 13
+  hash: 11
   prerelease: 
   segments: 
   - 0
   - 0
-  - 9
-  version: 0.0.9
+  - 10
+  version: 0.0.10
 platform: ruby
 authors: 
 - David Mike Simon
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-03-16 00:00:00 Z
+date: 2012-04-01 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   version_requirements: &id001 !ruby/object:Gem::Requirement