active_record_calculator 0.2.0 → 0.9.0

data/README.md

@@ -0,0 +1,71 @@
+# active\_record\_calculator
+
+__Known Issues:__
+
+* not compatible with activerecord 3.0.0 or higher
+
+__Usage:__
+
+Use active record calculator to subgroup SQL calculations.  active record calculator is best used when:
+
+* whenever more than a third of the table rows need to be examined
+* when a group by returns many rows
+* when the alternative requires many queries whose conditions can not be totally indexed
+
+You should run benchmarks to determine when to use active record calculator. As a rule active record calculator queries are as slow as the slowest single query.
+
+__Example:__
+
+    calculator = Purchase.calculator(:conditions => ["created_at > ?", 1.year.ago], group => "store_id") do |c|
+      c.count(:id, :total_purchases)
+      c.cnt(:id, :expensive_purchases, "amount_in_cents > 100")
+      c.average(:amount_in_cents, :cost_per_purchase)
+      c.avg(:amount_in_cents, :cost_per_expensive_purchase, "amount_in_cents > 100")
+      c.sum(:amount_in_cents, :total_sales)
+      c.sum(:amount_in_cents, :total_expensive_sales, "amount_in_cents > 100")
+      c.min(:amount_in_cents, :least_over_100, "amount_in_cents > 100")
+      c.max(:amount_in_cents, :most_less_100, "amount_in_cents <= 100")
+    end
+    calculator.calculate
+
+__Will yield the same data as__
+
+    Purchase.count(:id, :conditions => ["created_at > ?", 1.year.ago], :group => "store_id")
+    Purchase.count(:id, :conditions => ["amount_in_cents > 100 and created_at > ?", 1.year.ago], :group => "store_id" )
+    Purchase.average(:amount_in_cents, :conditions => ["created_at > ?", 1.year.ago], :group => "store_id" )
+    Purchase.sum(:amount_in_cents, :conditions => ["created_at > ?", 1.year.ago])
+    Purchase.sum(:amount_in_cents, :conditions => ["amount_in_cents > 100 and created_at > ?", 1.year.ago])
+    Purchase.minimum(:amount_in_cents, :conditions => ["amount_in_cents > 100 and created_at > ?", 1.year.ago])
+    Purchase.maximum(:amount_in_cents, :conditions => ["amount_in_cents <= 100 and created_at > ?", 1.year.ago])
+
+When adding operations, the calculator expects the format
+
+ method(column, alias, sub\_group\_condition)
+ 
+The calculate method returns an array of hashes with the aliases as keys and results as values
+Group columns are automatically included
+
+__Example:__
+
+    >> calc = Transaction.calculator(:conditions => "transactions.user_id = 55555", :group => "transactions.user_id, bonus") do |c|
+    ?>   c.count :id, "transactions_count"
+    >>   c.count :id, "approved_bonus_count", "status = 'approved' and bonus = true"
+    >>   c.count :id, "approved_offers_count", "status = 'approved' and bonus = false"
+    >> end
+    ...
+    >> calc.calculate
+    => [{"approved_bonus_count"=>0, "group_column_1"=>"55555", "group_column_2"=>"0", "transactions_count"=>34, "approved_offers_count"=>0}, {"approved_bonus_count"=>17, "group_column_1"=>"55555", "group_column_2"=>"1", "transactions_count"=>18, "approved_offers_count"=>17}]
+
+You can use statement method to see the sql created.
+
+The updater can be used for fast direct sql updates.  An updater needs to be created where all the operations have aliases that have a respective column name in the update table.  The first two arguments are the update table and the key to join.  The key is joined with the first group column which is also required.
+
+    updater = Purchases.updater(:purchase_history, :user_id, :conditions => "created_at > '2011-07-01'", :group => "user_id")
+    updater.count :id, "total_purchases"
+    updater.cnt :id, "expensive_purchases", "price > 100"
+    updater.sum :price, "cheap_spending", "price < 100"
+    updater.avg :price, "cheap_average", "price < 100"
+    updater.min :price, "least_purchase"
+    updater.max :price, "most_purchase"
+  
+Update should work with all ActiveRecord supported databases except sqlite

data/active_record_calculator.gemspec

@@ -7,7 +7,7 @@ Gem::Specification.new do |s|
   s.version     = ActiveRecordCalculator::VERSION
   s.authors     = ["Grady Griffin"]
   s.email       = ["gradyg@izea.com"]
-  s.homepage    = ""
+  s.homepage    = "https://github.com/thegboat/active_record_calculator"
   s.summary     = %q{ActiveRecord Calculations done faster}
   s.description = %q{active_record_calculator does groupable aggregate functions in one sql call for better performance}
 
@@ -22,10 +22,12 @@ Gem::Specification.new do |s|
   # s.add_development_dependency "rspec"
   # s.add_runtime_dependency "rest-client"
   if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
-    s.add_runtime_dependency('activerecord', ">=0")
+    s.add_runtime_dependency('activerecord', "<3.0.0")
     s.add_development_dependency("rspec")
+    s.add_development_dependency("mysql")
   else
-    s.add_dependency('activerecord', ">=0")
+    s.add_dependency('activerecord', "<3.0.0")
     s.add_development_dependency("rspec")
+    s.add_development_dependency("mysql")
   end
 end

data/lib/active_record_calculator/calculator_proxy.rb

@@ -82,8 +82,7 @@ module ActiveRecordCalculator
     
     def statement
       add_group_operations
-      sql = @klass.send(:construct_finder_sql, @finder_options)
-      sql.gsub(/^SELECT\s+\*/i, select)
+      construct_finder_sql.gsub(/^SELECT\s+\*/i, select)
     end
     
     private
@@ -118,10 +117,6 @@ module ActiveRecordCalculator
       @group_operations = []
       return unless @finder_options[:group]
       group_attrs = @finder_options[:group].to_s.split(',')
-      if @finder_options[:for_update]
-        @finder_options[:group] = group_attrs.first
-        group_attrs = [group_attrs.first]
-      end
       group_attrs.each_with_index do |grp, i|
         grp.downcase!
         grp.strip!
@@ -135,5 +130,23 @@ module ActiveRecordCalculator
       options = {:conditions => options} if options.is_a?(String) 
       @operations << Operation.new(op, column_name, as, options)
     end
+    
+    def construct_finder_sql
+      @klass.send(:construct_finder_sql, @finder_options)
+    end
+    
+    # def sanitized_finder_params
+    #   @finder_options[:conditions] = sanitize_sql_for_conditions(@finder_options[:conditions]) if @finder_options[:conditions]
+    #   @finder_options[:group] = sanitize_sql(@finder_options[:group]) if @finder_options[:group]
+    #   @finder_options[:having] = sanitize_sql(@finder_options[:having]) if @finder_options[:having]
+    # end
+    
+    def sanitize_sql(ary)
+      ActiveRecord::Base.sanitize_sql(ary, table)
+    end
+    
+    def sanitize_sql_for_conditions(condition)
+      ActiveRecord::Base.sanitize_sql_for_conditions(condition, table)
+    end
   end
 end

data/lib/active_record_calculator/updater_proxy.rb

@@ -107,11 +107,11 @@ module ActiveRecordCalculator
     end
     
     def calculation_columns
-      @calculation_columns ||= (calculator.columns + calculator.operations.collect(&:name))
+      calculator.columns.collect(&:alias_name) + calculator.operations.collect(&:name)
     end
     
     def invalid_columns
-      @invalid_columns ||= calculation_columns - update_columns
+      calculation_columns - update_columns
     end
     
     def invalid_columns_sentence

data/lib/active_record_calculator/version.rb

@@ -1,3 +1,3 @@
 module ActiveRecordCalculator
-  VERSION = "0.2.0"
+  VERSION = "0.9.0"
 end

data/spec/calculator_proxy_spec.rb

@@ -1,72 +1,97 @@
 require 'spec_helper'
 
-describe ActiveRecordCalculator::CalculatorProxy, "#new" do
-  it "should return a ActiveRecordCalculator::CalculatorProxy instance" do
-    instance = ActiveRecordCalculator::CalculatorProxy.new(FakeClass)
-    instance.class.to_s.should eq('ActiveRecordCalculator::CalculatorProxy')
+describe ActiveRecordCalculator::CalculatorProxy do
+  describe  "#new" do
+    it "should return a ActiveRecordCalculator::CalculatorProxy instance" do
+      instance = ActiveRecordCalculator::CalculatorProxy.new(Purchase)
+      instance.class.to_s.should eq('ActiveRecordCalculator::CalculatorProxy')
+    end
   end
-end
 
-describe ActiveRecordCalculator::CalculatorProxy, "#col, #column" do
-  it "should add a ActiveRecordCalculator::Column instance to columns" do
-    instance = ActiveRecordCalculator::CalculatorProxy.new(FakeClass)
-    instance.col(:id)
-    instance.column(:id)
-    instance.columns.length.should eq(2)
-    instance.columns.first.class.should eq(ActiveRecordCalculator::Column)
+  describe "#col, #column" do
+    it "should add a ActiveRecordCalculator::Column instance to columns" do
+      instance = ActiveRecordCalculator::CalculatorProxy.new(Purchase)
+      instance.col(:id)
+      instance.column(:id)
+      instance.columns.length.should eq(2)
+      instance.columns.first.class.should eq(ActiveRecordCalculator::Column)
+    end
   end
-end
 
-describe ActiveRecordCalculator::CalculatorProxy, "#count, #cnt" do
-  it "should add a ActiveRecordCalculator::Operation instance to operations" do
-    instance = ActiveRecordCalculator::CalculatorProxy.new(FakeClass)
-    instance.count(:id, 'counter')
-    instance.cnt(:id, 'counter2')
-    instance.operations.length.should eq(2)
-    instance.operations.first.op.should eq(:count)
-    instance.operations.first.class.should eq(ActiveRecordCalculator::Operation)
+  describe "#count, #cnt" do
+    it "should add a ActiveRecordCalculator::Operation instance to operations" do
+      instance = ActiveRecordCalculator::CalculatorProxy.new(Purchase)
+      instance.count(:id, 'counter')
+      instance.cnt(:id, 'counter2')
+      instance.operations.length.should eq(2)
+      instance.operations.first.op.should eq(:count)
+      instance.operations.first.class.should eq(ActiveRecordCalculator::Operation)
+    end
   end
-end
 
-describe ActiveRecordCalculator::CalculatorProxy, "#max, #maximum" do
-  it "should add a ActiveRecordCalculator::Operation instance to operations" do
-    instance = ActiveRecordCalculator::CalculatorProxy.new(FakeClass)
-    instance.max(:id, 'counter')
-    instance.maximum(:id, 'counter2')
-    instance.operations.length.should eq(2)
-    instance.operations.first.op.should eq(:max)
-    instance.operations.first.class.should eq(ActiveRecordCalculator::Operation)
+  describe "#max, #maximum" do
+    it "should add a ActiveRecordCalculator::Operation instance to operations" do
+      instance = ActiveRecordCalculator::CalculatorProxy.new(Purchase)
+      instance.max(:id, 'counter')
+      instance.maximum(:id, 'counter2')
+      instance.operations.length.should eq(2)
+      instance.operations.first.op.should eq(:max)
+      instance.operations.first.class.should eq(ActiveRecordCalculator::Operation)
+    end
   end
-end
 
-describe ActiveRecordCalculator::CalculatorProxy, "#min, #minimum" do
-  it "should add a ActiveRecordCalculator::Operation instance to operations" do
-    instance = ActiveRecordCalculator::CalculatorProxy.new(FakeClass)
-    instance.min(:id, 'counter')
-    instance.minimum(:id, 'counter2')
-    instance.operations.length.should eq(2)
-    instance.operations.first.op.should eq(:min)
-    instance.operations.first.class.should eq(ActiveRecordCalculator::Operation)
+  describe "#min, #minimum" do
+    it "should add a ActiveRecordCalculator::Operation instance to operations" do
+      instance = ActiveRecordCalculator::CalculatorProxy.new(Purchase)
+      instance.min(:id, 'counter')
+      instance.minimum(:id, 'counter2')
+      instance.operations.length.should eq(2)
+      instance.operations.first.op.should eq(:min)
+      instance.operations.first.class.should eq(ActiveRecordCalculator::Operation)
+    end
   end
-end
 
-describe ActiveRecordCalculator::CalculatorProxy, "#avg, #average" do
-  it "should add a ActiveRecordCalculator::Operation instance to operations" do
-    instance = ActiveRecordCalculator::CalculatorProxy.new(FakeClass)
-    instance.avg(:id, 'counter')
-    instance.average(:id, 'counter2')
-    instance.operations.length.should eq(2)
-    instance.operations.first.op.should eq(:avg)
-    instance.operations.first.class.should eq(ActiveRecordCalculator::Operation)
+  describe "#avg, #average" do
+    it "should add a ActiveRecordCalculator::Operation instance to operations" do
+      instance = ActiveRecordCalculator::CalculatorProxy.new(Purchase)
+      instance.avg(:id, 'counter')
+      instance.average(:id, 'counter2')
+      instance.operations.length.should eq(2)
+      instance.operations.first.op.should eq(:avg)
+      instance.operations.first.class.should eq(ActiveRecordCalculator::Operation)
+    end
   end
-end
 
-describe ActiveRecordCalculator::CalculatorProxy, "#sum" do
-  it "should add a ActiveRecordCalculator::Operation instance to operations" do
-    instance = ActiveRecordCalculator::CalculatorProxy.new(FakeClass)
-    instance.sum(:id, 'counter')
-    instance.operations.length.should eq(1)
-    instance.operations.first.op.should eq(:sum)
-    instance.operations.first.class.should eq(ActiveRecordCalculator::Operation)
+  describe "#sum" do
+    it "should add a ActiveRecordCalculator::Operation instance to operations" do
+      instance = ActiveRecordCalculator::CalculatorProxy.new(Purchase)
+      instance.sum(:id, 'counter')
+      instance.operations.length.should eq(1)
+      instance.operations.first.op.should eq(:sum)
+      instance.operations.first.class.should eq(ActiveRecordCalculator::Operation)
+    end
+  end
+  
+  describe "#calculate" do
+    it "should calculate as base aggregate methods" do
+      instance = ActiveRecordCalculator::CalculatorProxy.new(Purchase)
+      instance.count(:id, :total_purchases)
+      instance.count(:id, :expensive_purchases, "amount_in_cents > 100")
+      instance.avg(:amount_in_cents, :cost_per_purchase)
+      instance.avg(:amount_in_cents, :cost_per_expensive_purchase, "amount_in_cents > 100")
+      instance.sum(:amount_in_cents, :total_sales)
+      instance.sum(:amount_in_cents, :total_expensive_sales, "amount_in_cents > 100")
+      instance.min(:amount_in_cents, :least_over_100, "amount_in_cents > 100")
+      instance.max(:amount_in_cents, :most_less_100, "amount_in_cents <= 100")
+      rtn = instance.calculate.first
+      rtn['total_purchases'].should eq(Purchase.count)
+      rtn['expensive_purchases'].should eq(Purchase.count(:id, :conditions => "amount_in_cents > 100"))
+      rtn['cost_per_purchase'].should eq(Purchase.average(:amount_in_cents))
+      rtn['cost_per_expensive_purchase'].should eq(Purchase.average(:amount_in_cents, :conditions => "amount_in_cents > 100"))
+      rtn['total_sales'].should eq(Purchase.sum(:amount_in_cents))
+      rtn['total_expensive_sales'].should eq(Purchase.sum(:amount_in_cents, :conditions => "amount_in_cents > 100"))
+      rtn['least_over_100'].should eq(Purchase.minimum(:amount_in_cents, :conditions => "amount_in_cents > 100"))
+      rtn['most_less_100'].should eq(Purchase.maximum(:amount_in_cents, :conditions => "amount_in_cents <= 100"))
+    end
   end
 end

data/spec/spec_helper.rb

@@ -3,17 +3,61 @@ require 'bundler/setup'
 
 require 'active_record_calculator'
 
-class FakeConnection
+
+RSpec.configure do |config|
+  # some (optional) config here
 end
 
-class FakeClass
-  
-  def table_name
-    "some_records"
-  end
-  
+ActiveRecord::Base.establish_connection(
+:adapter => "mysql",
+:database => "active_record_calculator_test"
+)
+
+ActiveRecord::Migration.create_table :purchases, :force => true do |t|
+  t.integer :store_id, :null => false
+  t.integer :amount_in_cents, :null => false, :default => 0
+  t.boolean :used_coupon, :null => false, :default => false
+  t.datetime :purchase_date, :null => false
 end
 
-RSpec.configure do |config|
-  # some (optional) config here
-end
+ActiveRecord::Migration.create_table :stat_summaries, :force => true do |t|
+  t.integer :store_id, :null => false
+  t.integer :total_purchases, :null => false, :default => 0
+  t.decimal :cost_per_purchase, :precision => 14, :scale => 2, :default => 0.0,   :null => false
+  t.integer :total_sales, :null => false, :default => 0
+  t.integer :purchases_with_coupon, :null => false, :default => 0
+end
+
+ActiveRecord::Migration.create_table :stores, :force => true do |t|
+  t.string :name
+end
+
+class Purchase < ActiveRecord::Base
+  belongs_to :store
+end
+
+class Store < ActiveRecord::Base
+  has_many :purchases
+  has_one :stat_summary
+end
+
+class StatSummary < ActiveRecord::Base
+  belongs_to :store
+end
+
+store_ids = 1.upto(5).collect do |n|
+  store = Store.create(:name => "Store_#{n}")
+  StatSummary.create(:store_id => store.id)
+  store.id
+end
+ 
+1.upto(1000).each do |n|
+  Purchase.create(
+    :store_id => store_ids.shuffle.first,
+    :used_coupon => rand(2) == 1,
+    :amount_in_cents => rand(2)*100 + rand(100),
+    :purchase_date => (rand(365) + 1).days.ago
+  )
+end
+
+

data/spec/updater_proxy_spec.rb

@@ -1 +1,114 @@
-require 'spec_helper'
+require 'spec_helper'
+
+describe ActiveRecordCalculator::UpdaterProxy do
+  describe  "#new" do
+    it "should raise exception if no group on calculator" do
+      calculator = ActiveRecordCalculator::CalculatorProxy.new(Purchase)
+      lambda { 
+        ActiveRecordCalculator::UpdaterProxy.new(:stat_summaries, :store_id, calculator) 
+      }.should raise_error(ActiveRecordCalculator::NoUpdateKeyError)
+    end
+    
+    it "should raise exception if there is an alias for the calculator that does not match the updater" do
+      calculator = ActiveRecordCalculator::CalculatorProxy.new(Purchase)
+      calculator.count(:id, :not_existent_column)
+      lambda { 
+        ActiveRecordCalculator::UpdaterProxy.new(:stat_summaries, :store_id, calculator) 
+      }.should raise_error(ActiveRecordCalculator::InvalidColumnError)
+    end
+    
+    it "should return a ActiveRecordCalculator::UpdaterProxy instance" do
+      calculator = ActiveRecordCalculator::CalculatorProxy.new(Purchase, {:group => "purchases.store_id"})
+      instance = ActiveRecordCalculator::UpdaterProxy.new(:stat_summaries, :store_id, calculator)
+      instance.class.to_s.should eq('ActiveRecordCalculator::UpdaterProxy')
+    end
+  end
+
+  describe "#col, #column" do
+    it "should add a ActiveRecordCalculator::Column instance to columns" do
+      calculator = ActiveRecordCalculator::CalculatorProxy.new(Purchase, {:group => "purchases.store_id"})
+      instance = ActiveRecordCalculator::UpdaterProxy.new(:stat_summaries, :store_id, calculator)
+      instance.col(:id)
+      instance.column(:id)
+      instance.send(:calculator).columns.length.should eq(2)
+      instance.send(:calculator).columns.first.class.should eq(ActiveRecordCalculator::Column)
+    end
+  end
+
+  describe "#count, #cnt" do
+    it "should add a ActiveRecordCalculator::Operation instance to operations" do
+      calculator = ActiveRecordCalculator::CalculatorProxy.new(Purchase, {:group => "purchases.store_id"})
+      instance = ActiveRecordCalculator::UpdaterProxy.new(:stat_summaries, :store_id, calculator)
+      instance.count(:id, 'counter')
+      instance.cnt(:id, 'counter2')
+      instance.send(:calculator).operations.length.should eq(2)
+      instance.send(:calculator).operations.first.op.should eq(:count)
+      instance.send(:calculator).operations.first.class.should eq(ActiveRecordCalculator::Operation)
+    end
+  end
+
+  describe "#max, #maximum" do
+    it "should add a ActiveRecordCalculator::Operation instance to operations" do
+      calculator = ActiveRecordCalculator::CalculatorProxy.new(Purchase, {:group => "purchases.store_id"})
+      instance = ActiveRecordCalculator::UpdaterProxy.new(:stat_summaries, :store_id, calculator)
+      instance.max(:id, 'counter')
+      instance.maximum(:id, 'counter2')
+      instance.send(:calculator).operations.length.should eq(2)
+      instance.send(:calculator).operations.first.op.should eq(:max)
+      instance.send(:calculator).operations.first.class.should eq(ActiveRecordCalculator::Operation)
+    end
+  end
+
+  describe "#min, #minimum" do
+    it "should add a ActiveRecordCalculator::Operation instance to operations" do
+      calculator = ActiveRecordCalculator::CalculatorProxy.new(Purchase, {:group => "purchases.store_id"})
+      instance = ActiveRecordCalculator::UpdaterProxy.new(:stat_summaries, :store_id, calculator)
+      instance.min(:id, 'counter')
+      instance.minimum(:id, 'counter2')
+      instance.send(:calculator).operations.length.should eq(2)
+      instance.send(:calculator).operations.first.op.should eq(:min)
+      instance.send(:calculator).operations.first.class.should eq(ActiveRecordCalculator::Operation)
+    end
+  end
+
+  describe "#avg, #average" do
+    it "should add a ActiveRecordCalculator::Operation instance to operations" do
+      calculator = ActiveRecordCalculator::CalculatorProxy.new(Purchase, {:group => "purchases.store_id"})
+      instance = ActiveRecordCalculator::UpdaterProxy.new(:stat_summaries, :store_id, calculator)
+      instance.avg(:id, 'counter')
+      instance.average(:id, 'counter2')
+      instance.send(:calculator).operations.length.should eq(2)
+      instance.send(:calculator).operations.first.op.should eq(:avg)
+      instance.send(:calculator).operations.first.class.should eq(ActiveRecordCalculator::Operation)
+    end
+  end
+
+  describe "#sum" do
+    it "should add a ActiveRecordCalculator::Operation instance to operations" do
+      calculator = ActiveRecordCalculator::CalculatorProxy.new(Purchase, {:group => "purchases.store_id"})
+      instance = ActiveRecordCalculator::UpdaterProxy.new(:stat_summaries, :store_id, calculator)
+      instance.sum(:id, 'counter')
+      instance.send(:calculator).operations.length.should eq(1)
+      instance.send(:calculator).operations.first.op.should eq(:sum)
+      instance.send(:calculator).operations.first.class.should eq(ActiveRecordCalculator::Operation)
+    end
+  end
+  
+  describe "#update" do
+    it "should update the specified table" do
+      calculator = ActiveRecordCalculator::CalculatorProxy.new(Purchase, {:group => "purchases.store_id"})
+      instance = ActiveRecordCalculator::UpdaterProxy.new(:stat_summaries, :store_id, calculator)
+      instance.count(:id, :total_purchases)
+      instance.avg(:amount_in_cents, :cost_per_purchase)
+      instance.sum(:amount_in_cents, :total_sales)
+      instance.count(:id, :purchases_with_coupon, "used_coupon = true")
+      instance.update
+      StatSummary.all.each do |stat_summary|
+        stat_summary.total_purchases.should eq(Purchase.count(:id, :conditions => {:store_id => stat_summary.store_id}))
+        stat_summary.cost_per_purchase.round(2).should eq(Purchase.average(:amount_in_cents, :conditions => {:store_id => stat_summary.store_id}).round(2))
+        stat_summary.total_sales.should eq(Purchase.sum(:amount_in_cents, :conditions => {:store_id => stat_summary.store_id}))
+        stat_summary.purchases_with_coupon.should eq(Purchase.count(:id, :conditions => {:store_id => stat_summary.store_id, :used_coupon => true}))
+      end
+    end
+  end
+end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: active_record_calculator
 version: !ruby/object:Gem::Version 
-  hash: 23
+  hash: 59
   prerelease: 
   segments: 
   - 0
-  - 2
+  - 9
   - 0
-  version: 0.2.0
+  version: 0.9.0
 platform: ruby
 authors: 
 - Grady Griffin
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-02-01 00:00:00 Z
+date: 2012-02-07 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: activerecord
@@ -23,12 +23,14 @@ dependencies:
   requirement: &id001 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
-    - - ">="
+    - - <
       - !ruby/object:Gem::Version 
-        hash: 3
+        hash: 7
         segments: 
+        - 3
         - 0
-        version: "0"
+        - 0
+        version: 3.0.0
   type: :runtime
   version_requirements: *id001
 - !ruby/object:Gem::Dependency 
@@ -45,6 +47,20 @@ dependencies:
         version: "0"
   type: :development
   version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: mysql
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id003
 description: active_record_calculator does groupable aggregate functions in one sql call for better performance
 email: 
 - gradyg@izea.com
@@ -57,7 +73,7 @@ extra_rdoc_files: []
 files: 
 - .gitignore
 - Gemfile
-- README
+- README.md
 - Rakefile
 - active_record_calculator.gemspec
 - lib/active_record_calculator.rb
@@ -74,7 +90,7 @@ files:
 - spec/operation_spec.rb
 - spec/spec_helper.rb
 - spec/updater_proxy_spec.rb
-homepage: ""
+homepage: https://github.com/thegboat/active_record_calculator
 licenses: []
 
 post_install_message: 

data/README

@@ -1,58 +0,0 @@
-Use active_record_calculator to perform subgrouping of aggregate calculations
-
-Example:
-
-  calculator = Purchases.calculator(:conditions => "created_at > '2011-07-01'", :group => "user_id") do |c|
-    c.count :id, "total"
-    c.cnt :id, "expensive", "price > 100" #cnt is an alias for count
-    c.sum :price, "cheap_spending", "price < 100"
-    c.avg :price, "cheap_average", "price < 100" #avg is an alias for average
-    c.min :price, "least"
-    c.max :price, "most" #max is an alias for maximum
-    c.col :item_name #col is an alias for column; adds a column to the result
-  end
-
-  calculator.calculate
-
-OR
-
-  calculator = Purchases.calculator(:conditions => "created_at > '2011-07-01'", :group => "user_id")
-  calculator.count :id, "total"
-  calculator.cnt :id, "expensive", "price > 100"
-  calculator.sum :price, "cheap_spending", "price < 100"
-  calculator.avg :price, "cheap_average", "price < 100"
-  calculator.min :price, "least"
-  calculator.max :price, "most"
-  calculator.calculate
-
-When adding operations, the calculator expects the format
-
- method(column, alias, sub_group_condition)
- 
-The calculate method yields an array of hashes with the aliases as keys and results as values
-Group columns are automatically included
-
-Example:
-
->> calc = Transaction.calculator(:conditions => "transactions.user_id = 55555", :group => "transactions.user_id, bonus") do |c|
-?>   c.count :id, "transactions_count"
->>   c.count :id, "approved_bonus_count", "status = 'approved' and bonus = true"
->>   c.count :id, "approved_offers_count", "status = 'approved' and bonus = false"
->> end
-...
->> calc.calculate
-=> [{"approved_bonus_count"=>0, "group_column_1"=>"55555", "group_column_2"=>"0", "transactions_count"=>34, "approved_offers_count"=>0}, {"approved_bonus_count"=>17, "group_column_1"=>"55555", "group_column_2"=>"1", "transactions_count"=>18, "approved_offers_count"=>17}]
-
-You can use statement to see the sql created
-
-The updater can be used for fast direct sql updates.  An updater needs to be created where all the operations have aliases that have a respective column name in the update table.  The first two arguments are the update table and the key to join.  The key is joined with the first group column which is also required.
-
-  updater = Purchases.updater(:purchase_history, :user_id, :conditions => "created_at > '2011-07-01'", :group => "user_id")
-  updater.count :id, "total_purchases"
-  updater.cnt :id, "expensive_purchases", "price > 100"
-  updater.sum :price, "cheap_spending", "price < 100"
-  updater.avg :price, "cheap_average", "price < 100"
-  updater.min :price, "least_purchase"
-  updater.max :price, "most_purchase"
-  
-Update should work with all ActiveRecord supported databases except sqlite