active_record_calculator 0.0.4 → 0.1.0

data/README

@@ -0,0 +1,61 @@
+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 calculator can be used for fast direct sql updates.  A calculator needs to be created where all the operations have aliases
+that have a respective column name in the update table:
+
+  calculator = Purchases.calculator(:conditions => "created_at > '2011-07-01'", :group => "user_id")
+  calculator.count :id, "total_purchases"
+  calculator.cnt :id, "expensive_purchases", "price > 100"
+  calculator.sum :price, "cheap_spending", "price < 100"
+  calculator.avg :price, "cheap_average", "price < 100"
+  calculator.min :price, "least_purchase"
+  calculator.max :price, "most_purchase"
+  
+  calculator.update(:purchase_history, :user_id) #the tables are joined by the second argument and the first grouping column
+  
+Update only works with mysql adapters currently

data/active_record_calculator.gemspec

@@ -22,10 +22,10 @@ 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')
+    s.add_runtime_dependency('activerecord', ">=0")
     s.add_development_dependency("rspec")
   else
-    s.add_dependency('activerecord')
+    s.add_dependency('activerecord', ">=0")
     s.add_development_dependency("rspec")
   end
 end

data/lib/active_record_calculator.rb

@@ -1,6 +1,12 @@
+require 'active_record'
 require "active_record_calculator/version"
 require "active_record_calculator/calculator_proxy"
+require "active_record_calculator/updater_proxy"
 require "active_record_calculator/operation"
+require "active_record_calculator/group_operation"
+require "active_record_calculator/column"
+require "active_record_calculator/error"
+require "bigdecimal"
 
 module ActiveRecordCalculator
   def self.included(base)
@@ -8,14 +14,10 @@ module ActiveRecordCalculator
   end
   
   module ClassMethods
-    def calculate_many(options = {}, &blk)
-      calculator = CalculatorProxy.new(self, options)
-      yield calculator
-      calculator.calculate
-    end
-    
-    def calculator
-      CalculatorProxy.new(self)
+    def calculator(options = {}, &blk)
+      c = CalculatorProxy.new(self, options)
+      yield c if blk
+      c
     end
   end
 end

data/lib/active_record_calculator/calculator_proxy.rb

@@ -4,7 +4,8 @@ module ActiveRecordCalculator
       @klass = klass
       @operations = []
       @columns = []
-      @finder_options = finder_options.except(:order, :select)
+      @group_operations = []
+      find(finder_options)
     end
     
     def col(column_name, as = nil)
@@ -36,31 +37,106 @@ module ActiveRecordCalculator
     end
     alias :minimum :min
     
+    def table_name
+      @klass.table_name
+    end
+    
+    def columns
+      @columns
+    end
+    
+    def operations
+      @operations
+    end
+    
+    def group_operations
+      @group_operations
+    end
+    
+    def update_key
+      @group_operations.first ? @group_operations.first.name : nil
+    end
+    
     def calculate
-      sql = @klass.send(:construct_finder_sql, @finder_options)
-      sql.gsub!(/^SELECT \*/, select)
-      @operations = []
-      @klass.find_by_sql(sql)
+      result = select_all(statement)
+      result.collect do |row|
+        @operations.each do |op|
+          row[op.name] = type_cast(row[op.name])
+        end
+        row
+      end
     end
     
-    def set_finder_options(finder_options = {})
-      @finder_options = finder_options.except(:select)
+    def connection
+      @klass.connection
     end
     
-    def select
-      s = "SELECT\n"
-      s += @columns.join(', ') + "\n"
-      s += @operations.collect {|op| op.build_select(@klass)}.join(",\n")
+    def select_all(query)
+      connection.select_all(query)
+    end
+    
+    def update(table, foreign_key)
+      unless connection.adapter_name =~ /^mysql/i
+        raise UnsupportedAdapterError, "Updates with the database adapter is not supported."
+      end
+      updater = UpdaterProxy.new(table, foreign_key, self)
+      updater
+    end
+    
+    def find(finder_options = {})
+      finder_options.symbolize_keys!
+      @finder_options = finder_options.except(:select, :include, :from, :readonly, :lock)
+    end
+    
+    def statement
+      add_group_operations
+      sql = @klass.send(:construct_finder_sql, @finder_options.except(:update_key))
+      sql.gsub(/^SELECT\s+\*/i, select)
     end
     
     private
     
-    def add_column(column_name, as)
-      if as
-        @columns << column_name
+    def select
+      s = []
+      s += @group_operations.collect {|op| op.build_select}
+      s += @columns.collect {|col| op.build_select}
+      s += @operations.collect {|op| op.build_select(@klass)}
+      "SELECT " + s.join(",\n")
+    end
+    
+    def groupings
+      @groupings ||= @group_operations.collect(&:name)
+    end
+    
+    def type_cast(data)
+      if data =~ /^\d+$/
+        data.to_i
+      elsif data =~ /^\d+\.\d+$/
+        BigDecimal(data)
       else
-        @columns << "#{column_name} AS #{as}"
+        data
+      end
+    end
+    
+    def add_column(column_name, as) 
+      @columns << Column.new(column_name,as)
+    end
+    
+    def add_group_operations
+      @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!
+        grp_alias = "group_column_#{i+1}"
+        @group_operations << GroupOperation.new(grp, grp_alias)
       end
+      @group_operations.uniq!
     end
     
     def add_operation(op, column_name, as, options)

data/lib/active_record_calculator/column.rb

@@ -0,0 +1,21 @@
+module ActiveRecordCalculator
+  class Column
+    
+    def initialize(name, as)
+      @name = name
+      @as = as
+    end
+    
+    def build_select
+      "#{@name} AS #{@as || @name}"
+    end
+    
+    def inspect
+      @name
+    end
+    
+    def alias_name
+      @as
+    end
+  end
+end

data/lib/active_record_calculator/error.rb

@@ -0,0 +1,5 @@
+module ActiveRecordCalculator
+  class NoUpdateKeyError < StandardError; end
+  class InvalidColumnError < StandardError; end
+  class UnsupportedAdapterError < StandardError; end
+end

data/lib/active_record_calculator/group_operation.rb

@@ -0,0 +1,21 @@
+module ActiveRecordCalculator
+  class GroupOperation
+    
+    def initialize(column, as)
+      @column = column
+      @as = as
+    end
+    
+    def build_select
+      "#{@column} AS #{@as}"
+    end
+    
+    def inspect
+      @column
+    end
+    
+    def name
+      @as
+    end
+  end
+end

data/lib/active_record_calculator/operation.rb

@@ -27,6 +27,10 @@ module ActiveRecordCalculator
       "#{@as} => #{@op}"
     end
     
+    def name
+      @as
+    end
+    
     private
     
     def default

data/lib/active_record_calculator/updater_proxy.rb

@@ -0,0 +1,86 @@
+module ActiveRecordCalculator
+  class UpdaterProxy
+    def initialize(table, foreign_key, calculator_proxy)
+      @table = table
+      set_calculator(calculator_proxy)
+      @key = foreign_key
+      valid_columns?
+      valid_update_key?
+    end
+    
+    def statement
+      start = %{UPDATE #{table}
+      INNER JOIN
+      (#{calculator.statement}
+      ) AS sub_#{subquery_table} ON sub_#{subquery_table}.group_column_1 = #{table}.#{key}
+      SET\n}
+      start += calculation_columns.collect do |col|
+        "#{table}.#{col} = sub_#{subquery_table}.#{col}"
+      end.join(",\n")
+      start
+    end
+    
+    private
+    
+    def connection
+      calculator.connection
+    end
+    
+    def calculator
+      @calculator
+    end
+    
+    def key
+      "#{remove_table(@key)}"
+    end
+    
+    def set_calculator(calculator_proxy)
+      calculator_proxy.send(:add_group_operations)
+      @calculator = calculator_proxy
+    end
+    
+    def table
+      @table
+    end
+    
+    def subquery_table
+      calculator.table_name
+    end
+    
+    def update_columns
+      @update_columns ||= connection.columns(table).collect {|obj| obj.name.to_s}
+    end
+    
+    def calculation_columns
+      @calculation_columns ||= (calculator.columns + calculator.operations.collect(&:name))
+    end
+    
+    def invalid_columns
+      @invalid_columns ||= calculation_columns - update_columns
+    end
+    
+    def invalid_columns_sentence
+      start = invalid_columns[0..-2].join(', ')
+      if invalid_columns.length > 1
+        start += ' and ' + invalid_columns[-1..-1].to_s
+      end
+      start
+    end
+    
+    def valid_columns?
+      raise InvalidColumnError, "Can not resolve update column(s) #{invalid_columns.to_sentence} for table #{update_table}" unless invalid_columns.empty?
+      true
+    end
+    
+    def remove_table(s)
+      s.to_s.split('.').last
+    end
+    
+    def valid_update_key?
+      unless calculator.update_key
+        raise NoUpdateKeyError, "No valid update key was provided for table #{subquery_table}"
+      end
+      true
+    end
+  end
+end

data/lib/active_record_calculator/version.rb

@@ -1,3 +1,3 @@
 module ActiveRecordCalculator
-  VERSION = "0.0.4"
+  VERSION = "0.1.0"
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: active_record_calculator
 version: !ruby/object:Gem::Version 
-  hash: 23
+  hash: 27
   prerelease: 
   segments: 
   - 0
+  - 1
   - 0
-  - 4
-  version: 0.0.4
+  version: 0.1.0
 platform: ruby
 authors: 
 - Grady Griffin
@@ -15,7 +15,8 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-01-27 00:00:00 Z
+date: 2012-01-31 00:00:00 -05:00
+default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: activerecord
@@ -57,12 +58,18 @@ extra_rdoc_files: []
 files: 
 - .gitignore
 - Gemfile
+- README
 - Rakefile
 - active_record_calculator.gemspec
 - lib/active_record_calculator.rb
 - lib/active_record_calculator/calculator_proxy.rb
+- lib/active_record_calculator/column.rb
+- lib/active_record_calculator/error.rb
+- lib/active_record_calculator/group_operation.rb
 - lib/active_record_calculator/operation.rb
+- lib/active_record_calculator/updater_proxy.rb
 - lib/active_record_calculator/version.rb
+has_rdoc: true
 homepage: ""
 licenses: []
 
@@ -92,7 +99,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: active_record_calculator
-rubygems_version: 1.8.15
+rubygems_version: 1.4.2
 signing_key: 
 specification_version: 3
 summary: ActiveRecord Calculations done faster