sbf-dm-aggregates 1.3.0.beta

data/lib/dm-aggregates/adapters/dm-do-adapter.rb

@@ -0,0 +1,98 @@
+module DataMapper
+  module Aggregates
+    module DataObjectsAdapter
+      extend Chainable
+
+      def aggregate(query)
+        fields = query.fields
+        types  = fields.map { |p| p.respond_to?(:operator) ? String : p.dump_class }
+
+        field_size = fields.size
+
+        records = []
+
+        with_connection do |connection|
+          statement, bind_values = select_statement(query)
+
+          command = connection.create_command(statement)
+          command.set_types(types)
+
+          reader = command.execute_reader(*bind_values)
+
+          begin
+            while reader.next!
+              row = fields.zip(reader.values).map do |field, value|
+                if field.respond_to?(:operator)
+                  send(field.operator, field.target, value)
+                else
+                  field.load(value)
+                end
+              end
+
+              records << ((field_size > 1) ? row : row[0])
+            end
+          ensure
+            reader.close
+          end
+        end
+
+        records
+      end
+
+      private def count(_property, value)
+        value.to_i
+      end
+
+      private def min(property, value)
+        property.load(value)
+      end
+
+      private def max(property, value)
+        property.load(value)
+      end
+
+      private def avg(property, value)
+        property.dump_class.equal?(::Integer) ? value.to_f : property.load(value)
+      end
+
+      private def sum(property, value)
+        property.load(value)
+      end
+
+      chainable do
+        def property_to_column_name(property, qualify)
+          case property
+          when DataMapper::Query::Operator
+            aggregate_field_statement(property.operator, property.target, qualify)
+
+          when Property, DataMapper::Query::Path
+            super
+
+          else
+            raise ArgumentError, '+property+ must be a DataMapper::Query::Operator, a DataMapper::Property or a Query::Path, but was a ' \
+                                 "#{property.class} (#{property.inspect})"
+          end
+        end
+      end
+
+      private def aggregate_field_statement(aggregate_function, property, qualify)
+        column_name = if aggregate_function == :count && property == :all
+                        '*'
+                      else
+                        property_to_column_name(property, qualify)
+                      end
+
+        function_name = case aggregate_function
+                        when :count then 'COUNT'
+                        when :min   then 'MIN'
+                        when :max   then 'MAX'
+                        when :avg   then 'AVG'
+                        when :sum   then 'SUM'
+                        else raise "Invalid aggregate function: #{aggregate_function.inspect}"
+                        end
+
+        "#{function_name}(#{column_name})"
+      end
+    end
+  end
+end

data/lib/dm-aggregates/aggregate_functions.rb

@@ -0,0 +1 @@
+require 'dm-aggregates/functions'

data/lib/dm-aggregates/collection.rb

@@ -0,0 +1,11 @@
+module DataMapper
+  module Aggregates
+    module Collection
+      include Functions
+
+      private def property_by_name(property_name)
+        properties[property_name]
+      end
+    end
+  end
+end

data/lib/dm-aggregates/core_ext/symbol.rb

@@ -0,0 +1,5 @@
+require 'dm-aggregates/symbol_operators'
+
+class Symbol
+  include DataMapper::Aggregates::SymbolOperators
+end

data/lib/dm-aggregates/functions.rb

@@ -0,0 +1,231 @@
+module DataMapper
+  module Aggregates
+    module Functions
+      include DataMapper::Assertions
+
+      # Count results (given the conditions)
+      #
+      # @example the count of all friends
+      #   Friend.count
+      #
+      # @example the count of all friends older then 18
+      #   Friend.count(:age.gt => 18)
+      #
+      # @example the count of all your female friends
+      #   Friend.count(:conditions => [ 'gender = ?', 'female' ])
+      #
+      # @example the count of all friends with an address (NULL values are not included)
+      #   Friend.count(:address)
+      #
+      # @example the count of all friends with an address that are older then 18
+      #   Friend.count(:address, :age.gt => 18)
+      #
+      # @example the count of all your female friends with an address
+      #   Friend.count(:address, :conditions => [ 'gender = ?', 'female' ])
+      #
+      # @param args [Mixed]
+      #   property [Symbol] of the property you with to count (optional)
+      #   opts [Hash, Symbol] the conditions
+      #
+      # @return [Integer] return the count given the conditions
+      #
+      # @api public
+      def count(*args)
+        query         = args.last.is_a?(Hash) ? args.pop : {}
+        property_name = args.first
+
+        assert_kind_of 'property', property_by_name(property_name), Property if property_name
+
+        aggregate(query&.merge(fields: [property_name ? property_name.count : :all.count])).to_i
+      end
+
+      # Get the lowest value of a property
+      #
+      # @example the age of the youngest friend
+      #   Friend.min(:age)
+      #
+      # @example  the age of the youngest female friend
+      #   Friend.min(:age, :conditions => [ 'gender = ?', 'female' ])
+      #
+      # @param args [Mixed]
+      #   property [Symbol] the property you wish to get the lowest value of
+      #   opts [Hash, Symbol] the conditions
+      #
+      # @return [Integer] return the lowest value of a property given the conditions
+      #
+      # @api public
+      def min(*args)
+        query         = args.last.is_a?(Hash) ? args.pop : {}
+        property_name = args.first
+
+        assert_property_type property_name, ::Integer, ::Float, ::BigDecimal, ::DateTime, ::Date, ::Time
+
+        aggregate(query&.merge(fields: [property_name&.min]))
+      end
+
+      # Get the highest value of a property
+      #
+      # @example the age of the oldest friend
+      #   Friend.max(:age)
+      #
+      # @example the age of the oldest female friend
+      #   Friend.max(:age, :conditions => [ 'gender = ?', 'female' ])
+      #
+      # @param args [Mixed]
+      #   property [Symbol] the property you wish to get the highest value of
+      #   opts [Hash, Symbol] the conditions
+      #
+      # @return [Integer] return the highest value of a property given the conditions
+      #
+      # @api public
+      def max(*args)
+        query         = args.last.is_a?(Hash) ? args.pop : {}
+        property_name = args.first
+
+        assert_property_type property_name, ::Integer, ::Float, ::BigDecimal, ::DateTime, ::Date, ::Time
+
+        aggregate(query&.merge(fields: [property_name&.max]))
+      end
+
+      # Get the average value of a property
+      #
+      # @example the average age of all friends
+      #   Friend.avg(:age)
+      #
+      # @example the average age of all female friends
+      #   Friend.avg(:age, :conditions => [ 'gender = ?', 'female' ])
+      #
+      # @param args [Mixed]
+      #   property [Symbol] the property you wish to get the average value of
+      #   opts [Hash, Symbol] the conditions
+      #
+      # @return [Integer] return the average value of a property given the conditions
+      #
+      # @api public
+      def avg(*args)
+        query         = args.last.is_a?(Hash) ? args.pop : {}
+        property_name = args.first
+
+        assert_property_type property_name, ::Integer, ::Float, ::BigDecimal
+
+        aggregate(query&.merge(fields: [property_name&.avg]))
+      end
+
+      # Get the total value of a property
+      #
+      # @example the total age of all friends
+      #   Friend.sum(:age)
+      #
+      # @example the total age of all female friends
+      #   Friend.max(:age, :conditions => [ 'gender = ?', 'female' ])
+      #
+      # @param args [Mixed]
+      #   property [Symbol] the property you wish to get the total value of
+      #   opts [Hash, Symbol] the conditions
+      #
+      # @return [Integer] return the total value of a property given the conditions
+      #
+      # @api public
+      def sum(*args)
+        query         = args.last.is_a?(::Hash) ? args.pop : {}
+        property_name = args.first
+
+        assert_property_type property_name, ::Integer, ::Float, ::BigDecimal
+
+        aggregate(query.merge(fields: [property_name.sum]))
+      end
+
+      # Perform aggregate queries
+      #
+      # @example the count of friends
+      #   Friend.aggregate(:all.count)
+      #
+      # @example the minimum age, the maximum age and the total age of friends
+      #   Friend.aggregate(:age.min, :age.max, :age.sum)
+      #
+      # @example the average age, grouped by gender
+      #   Friend.aggregate(:age.avg, :fields => [ :gender ])
+      #
+      # @param args [Mixed]
+      #   aggregates [Symbol, ...] operators to aggregate with
+      #   query [Hash] the conditions
+      #
+      # @return [Array,Numeric,DateTime,Date,Time] the results of the
+      #   aggregate query
+      #
+      # @api public
+      def aggregate(*args)
+        query = args.last.is_a?(Hash) ? args.pop : {}
+
+        query[:fields] ||= []
+        query[:fields]  |= args
+        query[:fields].map! { |f| normalize_field(f) }
+
+        raise ArgumentError, 'query[:fields] must not be empty' if query[:fields].empty?
+
+        unless query&.key?(:order)
+          # the current collection/model is already sorted by attributes
+          # and since we are projecting away some of the attributes,
+          # and then performing aggregate functions on the remainder,
+          # we need to honor the existing order, as if it were already
+          # materialized, and we are looping over the rows in order.
+
+          directions = direction_map
+
+          query[:order] = []
+
+          # use the current query order for each property if available
+          query[:fields].each do |property|
+            next unless property.is_a?(Property)
+
+            query[:order] << directions.fetch(property, property)
+          end
+        end
+
+        query = scoped_query(query)
+
+        if query.fields.any? { |p| p.is_a?(Property) }
+          query.repository.aggregate(query.update(unique: true))
+        else
+          query.repository.aggregate(query).first # only return one row
+        end
+      end
+
+      private def assert_property_type(name, *types)
+        raise ArgumentError, 'property name must not be nil' if name.nil?
+
+        property = property_by_name(name)
+        type     = property.dump_class
+
+        raise ArgumentError, "#{name} must be #{types * ' or '}, but was #{type}" unless types.include?(type)
+      end
+
+      private def normalize_field(field)
+        assert_kind_of 'field', field, DataMapper::Query::Operator, Symbol, Property
+
+        case field
+        when DataMapper::Query::Operator
+          if field.target == :all
+            field
+          else
+            field.class.new(property_by_name(field.target), field.operator)
+          end
+
+        when Symbol
+          property_by_name(field)
+
+        when Property
+          field
+        end
+      end
+
+      private def direction_map
+        direction_map = {}
+        query.order.each do |direction|
+          direction_map[direction.target] = direction
+        end
+        direction_map
+      end
+    end
+  end
+end

data/lib/dm-aggregates/model.rb

@@ -0,0 +1,11 @@
+module DataMapper
+  module Aggregates
+    module Model
+      include Functions
+
+      private def property_by_name(property_name)
+        properties(repository.name)[property_name]
+      end
+    end
+  end
+end

data/lib/dm-aggregates/query.rb

@@ -0,0 +1,27 @@
+module DataMapper
+  module Aggregates
+    module Query
+      def self.included(base)
+        base.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+          # FIXME: figure out a cleaner approach than AMC
+          alias_method :assert_valid_fields_without_operator, :assert_valid_fields
+          alias_method :assert_valid_fields, :assert_valid_fields_with_operator
+        RUBY
+      end
+
+      def assert_valid_fields_with_operator(fields, unique)
+        operators, fields = fields.partition { |f| f.is_a?(DataMapper::Query::Operator) }
+
+        operators.each do |operator|
+          target = operator.target
+
+          unless target == :all || @properties.include?(target)
+            raise ArgumentError, "+options[:fields]+ entry #{target.inspect} does not map to a property in #{model}"
+          end
+        end
+
+        assert_valid_fields_without_operator(fields, unique)
+      end
+    end
+  end
+end

data/lib/dm-aggregates/repository.rb

@@ -0,0 +1,13 @@
+module DataMapper
+  module Aggregates
+    module Repository
+      def aggregate(query)
+        if query.valid?
+          adapter.aggregate(query)
+        else
+          []
+        end
+      end
+    end
+  end
+end

data/lib/dm-aggregates/symbol_operators.rb

@@ -0,0 +1,25 @@
+module DataMapper
+  module Aggregates
+    module SymbolOperators
+      def count
+        DataMapper::Query::Operator.new(self, :count)
+      end
+
+      def min
+        DataMapper::Query::Operator.new(self, :min)
+      end
+
+      def max
+        DataMapper::Query::Operator.new(self, :max)
+      end
+
+      def avg
+        DataMapper::Query::Operator.new(self, :avg)
+      end
+
+      def sum
+        DataMapper::Query::Operator.new(self, :sum)
+      end
+    end
+  end
+end

data/lib/dm-aggregates/version.rb

@@ -0,0 +1,5 @@
+module DataMapper
+  module Aggregates
+    VERSION = '1.3.0.beta'.freeze
+  end
+end

data/lib/dm-aggregates.rb

@@ -0,0 +1,57 @@
+require 'dm-core'
+
+require 'dm-aggregates/aggregate_functions'
+require 'dm-aggregates/collection'
+require 'dm-aggregates/core_ext/symbol'
+require 'dm-aggregates/model'
+require 'dm-aggregates/query'
+require 'dm-aggregates/repository'
+
+module DataMapper
+  module Aggregates
+    def self.include_aggregate_api
+      %i(Repository Model Collection Query).each do |name|
+        DataMapper.const_get(name).send(:include, const_get(name))
+      end
+      Adapters::AbstractAdapter.descendants.each do |adapter_class|
+        Adapters.include_aggregate_api(DataMapper::Inflector.demodulize(adapter_class.name))
+      end
+    end
+  end
+
+  module Adapters
+    def self.include_aggregate_api(const_name)
+      require aggregate_extensions(const_name)
+      if Aggregates.const_defined?(const_name)
+        adapter = const_get(const_name)
+        adapter.send(:include, aggregate_module(const_name))
+      end
+    rescue LoadError
+      # Silently ignore the fact that no adapter extensions could be required
+      # This means that the adapter in use doesn't support aggregates
+    end
+
+    def self.aggregate_module(const_name)
+      Aggregates.const_get(const_name)
+    end
+
+    class << self
+      # @api private
+      private def aggregate_extensions(const_name)
+        name = adapter_name(const_name)
+        name = 'do' if name == 'dataobjects'
+        "dm-aggregates/adapters/dm-#{name}-adapter"
+      end
+    end
+
+    extendable do
+      # @api private
+      def const_added(const_name)
+        include_aggregate_api(const_name)
+        super
+      end
+    end
+  end
+
+  Aggregates.include_aggregate_api
+end

data/spec/isolated/require_after_setup_spec.rb

@@ -0,0 +1,18 @@
+require 'rspec'
+
+require_relative '../isolated/require_spec'
+require 'dm-core/spec/setup'
+
+# To really test this behavior, this spec needs to be run in isolation and not
+# as part of the typical rake spec run, which requires dm-aggregates upfront
+
+if %w(postgres mysql sqlite oracle sqlserver).include?(ENV['ADAPTER'])
+  describe "require 'dm-aggregates after calling DataMapper.setup" do
+    before(:all) do
+      @adapter = DataMapper::Spec.adapter
+      require 'dm-aggregates'
+    end
+
+    it_behaves_like "require 'dm-aggregates'"
+  end
+end

data/spec/isolated/require_before_setup_spec.rb

@@ -0,0 +1,18 @@
+require 'rspec'
+
+require_relative 'require_spec'
+require 'dm-core/spec/setup'
+
+# To really test this behavior, this spec needs to be run in isolation and not
+# as part of the typical rake spec run, which requires dm-aggregates upfront
+
+if %w(postgres mysql sqlite oracle sqlserver).include?(ENV['ADAPTER'])
+  describe "require 'dm-aggregates' before calling DataMapper.setup" do
+    before(:all) do
+      require 'dm-aggregates'
+      @adapter = DataMapper::Spec.adapter
+    end
+
+    it_behaves_like "require 'dm-aggregates'"
+  end
+end

data/spec/isolated/require_spec.rb

@@ -0,0 +1,11 @@
+shared_examples "require 'dm-aggregates'" do
+  %w(Repository Model Collection Query).each do |name|
+    it "includes the aggregate api in DataMapper::#{name}" do
+      expect(DataMapper.const_get(name) < DataMapper::Aggregates.const_get(name)).to be(true)
+    end
+  end
+
+  it 'includes the aggregate api into the adapter' do
+    expect(@adapter.respond_to?(:aggregate)).to be(true)
+  end
+end

data/spec/public/collection_spec.rb

@@ -0,0 +1,128 @@
+require_relative '../spec_helper'
+
+describe DataMapper::Collection do
+  supported_by :sqlite, :mysql, :postgres do
+    let(:dragons)   { Dragon.all  }
+    let(:countries) { Country.all }
+
+    it_behaves_like 'It Has Setup Resources'
+    it_behaves_like 'An Aggregatable Class'
+
+    describe 'ignore invalid query' do
+      let(:dragons) { Dragon.all.all(id: []) }
+
+      %i(size count).each do |method|
+        describe "##{method}" do
+          subject { dragons.send(method) }
+
+          it { is_expected.to eq 0 }
+        end
+      end
+
+      describe '#min' do
+        subject { dragons.min(:id) }
+
+        it { is_expected.to be_nil }
+      end
+
+      describe '#max' do
+        subject { dragons.max(:id) }
+
+        it { is_expected.to be_nil }
+      end
+
+      describe '#avg' do
+        subject { dragons.avg(:id) }
+
+        it { is_expected.to be_nil }
+      end
+
+      describe '#sum' do
+        subject { dragons.sum(:id) }
+
+        it { is_expected.to be_nil }
+      end
+
+      describe '#aggregate' do
+        subject { dragons.aggregate(:id) }
+
+        it { is_expected.to eq [] }
+      end
+    end
+
+    context 'with collections created with Set operations' do
+      let(:collection) { dragons.all(name: 'George') | dragons.all(name: 'Puff') }
+
+      describe '#size' do
+        subject { collection.size }
+
+        it { is_expected.to eq 2 }
+      end
+
+      describe '#count' do
+        subject { collection.count }
+
+        it { is_expected.to eq 2 }
+      end
+
+      describe '#min' do
+        subject { collection.min(:toes_on_claw) }
+
+        it { is_expected.to eq 3 }
+      end
+
+      describe '#max' do
+        subject { collection.max(:toes_on_claw) }
+
+        it { is_expected.to eq 4 }
+      end
+
+      describe '#avg' do
+        subject { collection.avg(:toes_on_claw) }
+
+        it { is_expected.to eq 3.5 }
+      end
+
+      describe '#sum' do
+        subject { collection.sum(:toes_on_claw) }
+
+        it { is_expected.to eq 7 }
+      end
+
+      describe '#aggregate' do
+        subject { collection.aggregate(:all.count, :name.count, :toes_on_claw.min, :toes_on_claw.max, :toes_on_claw.avg, :toes_on_claw.sum) }
+
+        it { is_expected.to eq [2, 2, 3, 4, 3.5, 7] }
+      end
+    end
+
+    context 'with a collection limited to 1 result' do
+      let(:dragons) { Dragon.all(limit: 1) }
+
+      describe '#size' do
+        subject { dragons.size }
+
+        it { is_expected.to eq 1 }
+      end
+
+      describe '#count' do
+        subject { dragons.count }
+
+        it {
+          pending 'TODO: make count apply to the limited collection. Currently limit applies after the count'
+          is_expected.to eq 1
+        }
+      end
+    end
+
+    context 'with the order reversed by the grouping field' do
+      subject { dragons.aggregate(:birth_at, :all.count) }
+
+      let(:dragons) { Dragon.all(order: [:birth_at.desc]) }
+
+      it 'displays the results in reverse order' do
+        is_expected.to eq Dragon.aggregate(:birth_at, :all.count).reverse
+      end
+    end
+  end
+end

data/spec/public/model_spec.rb

@@ -0,0 +1,11 @@
+require_relative '../spec_helper'
+
+describe DataMapper::Model do
+  supported_by :sqlite, :mysql, :postgres do
+    let(:dragons)   { Dragon  }
+    let(:countries) { Country }
+
+    it_behaves_like 'It Has Setup Resources'
+    it_behaves_like 'An Aggregatable Class'
+  end
+end