record_filter 0.9.17 → 1.0.0

data/VERSION.yml

@@ -1,4 +1,4 @@
 --- 
-:major: 0
-:minor: 9
-:patch: 17
+:major: 1
+:minor: 0
+:patch: 0

data/lib/record_filter/conjunctions.rb

@@ -1,7 +1,7 @@
 module RecordFilter
   module Conjunctions # :nodoc: all
     class Base
-      attr_reader :table_name, :limit, :offset, :distinct
+      attr_reader :table_name, :limit, :offset, :distinct, :select_columns
 
       def self.create_from(dsl_conjunction, table)
         result = case dsl_conjunction.type
@@ -39,6 +39,7 @@ module RecordFilter
           end
         end
         result.set_distinct(dsl_conjunction.distinct)
+        result.set_select_columns(dsl_conjunction.select_columns)
         result
       end
 
@@ -94,6 +95,10 @@ module RecordFilter
         @distinct = value
       end
 
+      def set_select_columns(select_columns)
+        @select_columns = select_columns
+      end
+
       def add_named_filter(name, args)
         unless @table.model_class.named_filters.include?(name.to_sym)
           raise NamedFilterNotFoundException.new("The named filter #{name} was not found in #{@table.model_class}")

data/lib/record_filter/dsl/conjunction.rb

@@ -2,7 +2,7 @@ module RecordFilter
   module DSL
     class Conjunction # :nodoc: all
 
-      attr_reader :type, :steps, :distinct
+      attr_reader :type, :steps, :distinct, :select_columns
 
       def initialize(model_class, type=:all_of)
         @model_class, @type, @steps, @distinct = model_class, type, [], false
@@ -53,6 +53,10 @@ module RecordFilter
         @distinct = true
       end
 
+      def set_select_columns(columns)
+        @select_columns = columns
+      end
+
       def add_named_filter(method, *args)
         @steps << NamedFilter.new(method, *args)
       end

data/lib/record_filter/dsl/dsl.rb

@@ -129,16 +129,27 @@ module RecordFilter
       # block, etc.).
       #
       # ==== Parameters
-      # none
+      # 
+      # columns...<Symbol>:
+      #   Zero or more column names to select. Equivalent to
+      #   select(:col1, :col2) ; distinct. If empty, select all columns.
       #
       # ==== Returns
       # nil
       #
       # @public
-      def distinct
+      def distinct(*columns)
+        select(*columns) unless columns.empty?
         @conjunction.set_distinct
         nil
       end
+
+      #
+      # Specify one or more columns to select from the database.
+      #
+      def select(*columns)
+        @conjunction.set_select_columns(columns)
+      end
     end
   end
 end

data/lib/record_filter/dsl/restriction.rb

@@ -305,7 +305,7 @@ module RecordFilter
       def take_value(value) # :nodoc:
         if value.nil?
           is_null
-        elsif value != DEFAULT_VALUE
+        elsif value.respond_to?(:to_subquery) || value != DEFAULT_VALUE
           equal_to(value)
         end
       end

data/lib/record_filter/filter.rb

@@ -65,6 +65,20 @@ module RecordFilter
       @query.to_find_params(count_query)
     end
 
+    def to_subquery(single_result = true)
+      proxy_options = proxy_options()
+      if @query.select_columns && @query.select_columns.length > 1
+        raise(InvalidFilterException, "Only one select column allowed in a subquery")
+      end
+      @clazz.module_eval do
+        options = proxy_options.reverse_merge(
+          :select => "#{quoted_table_name}.#{primary_key}"
+        )
+        options.merge!(:limit => 1) if single_result
+        construct_finder_sql(options)
+      end
+    end
+
     protected
 
     def method_missing(method, *args, &block) # :nodoc:

data/lib/record_filter/query.rb

@@ -36,15 +36,25 @@ module RecordFilter
       end
     end
 
+    def select_columns
+      @conjunction.select_columns
+    end
+
     protected
 
     def set_select(params, count_query)
-      if @conjunction.distinct || (@table.all_joins.any? { |j| j.requires_distinct_select? })
+      select_column_statement =
         if count_query
-          params[:select] = "DISTINCT #{@table.table_name}.#{@table.model_class.primary_key}"
+          "#{@table.table_name}.#{@table.model_class.primary_key}"
+        elsif select_columns
+          select_columns.map { |column| "#{@table.table_name}.#{column}" }.join(', ')
         else
-          params[:select] = "DISTINCT #{@table.table_name}.*"
+          "#{@table.table_name}.*"
         end
+      if @conjunction.distinct || (@table.all_joins.any? { |j| j.requires_distinct_select? })
+        params[:select] = "DISTINCT #{select_column_statement}"
+      elsif @conjunction.select_columns
+        params[:select] = select_column_statement
       end
     end
 

data/lib/record_filter/restrictions.rb

@@ -5,11 +5,11 @@ module RecordFilter
 
       def initialize(column_name, value, table, options={})
         @column_name, @value, @table, @negated = column_name, value, table, !!options.delete(:negated)
-        @value = @value.id if @value.kind_of?(ActiveRecord::Base)
+        @value = @value.id if !subquery? && @value.kind_of?(ActiveRecord::Base)
       end
 
       def to_conditions
-        if @value.nil? || @value.is_a?(Hash)
+        if subquery? || @value.nil? || @value.is_a?(Hash)
           [to_sql]
         else
           [to_sql, @value]
@@ -25,7 +25,9 @@ module RecordFilter
       end
 
       def value_hash_as_column_or_question_mark
-        if @value.is_a?(Hash)
+        if subquery?
+          "(#{@value.to_subquery})"
+        elsif @value.is_a?(Hash)
           column, table = parse_column_in_table(@value, @table)
           if (table.has_column(column))
             "#{table.table_alias}.#{column}"
@@ -34,6 +36,10 @@ module RecordFilter
           '?'
         end
       end
+
+      def subquery?
+        @value.respond_to?(:to_subquery)
+      end
     end
 
     class EqualTo < Base
@@ -94,12 +100,22 @@ module RecordFilter
         # produce a condition like "WHERE id NOT IN (NULL)", and that will
         # return an empty set, which is presumably not what the user meant
         # to get. Doing some babysitting here.
-        if @negated && @value.respond_to?(:empty?) && @value.empty?
+        if subquery?
+          [to_sql]
+        elsif @negated && @value.respond_to?(:empty?) && @value.empty?
           []
         else
           [to_sql, @value]
         end
       end
+
+      def value_hash_as_column_or_question_mark
+        if subquery?
+          @value.to_subquery(false)
+        else
+          super
+        end
+      end
     end
 
     class Between < Base

data/record_filter.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{record_filter}
-  s.version = "0.9.17"
+  s.version = "1.0.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Aubrey Holland", "Mat Brown"]
-  s.date = %q{2010-03-04}
+  s.date = %q{2010-03-18}
   s.description = %q{RecordFilter is a Pure-ruby criteria API for building complex queries in ActiveRecord. It supports queries that are built on the fly as well as named filters that can be added to objects and chained to create complex queries. It also gets rid of the nasty hard-coded SQL that shows up in most ActiveRecord code with a clean API that makes queries simple and intuitive to build.}
   s.email = %q{aubreyholland@gmail.com}
   s.extra_rdoc_files = [
@@ -55,6 +55,7 @@ Gem::Specification.new do |s|
      "spec/active_record_spec.rb",
      "spec/exception_spec.rb",
      "spec/explicit_join_spec.rb",
+     "spec/explicit_subquery_spec.rb",
      "spec/implicit_join_spec.rb",
      "spec/limits_and_ordering_spec.rb",
      "spec/models.rb",
@@ -80,6 +81,7 @@ Gem::Specification.new do |s|
     "spec/active_record_spec.rb",
      "spec/exception_spec.rb",
      "spec/explicit_join_spec.rb",
+     "spec/explicit_subquery_spec.rb",
      "spec/implicit_join_spec.rb",
      "spec/limits_and_ordering_spec.rb",
      "spec/models.rb",

data/spec/explicit_subquery_spec.rb

@@ -0,0 +1,55 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+describe 'explicit subqueries' do
+  before :each do
+    TestModel.extended_models.each { |model| model.last_find = {} }
+  end
+
+  after :each do
+    Blog.last_find.should be_empty
+  end
+
+  describe 'IN subquery' do
+    it 'should generate an explicit subquery on ID field' do
+      Post.filter do
+        with(:blog_id).in(Blog.filter { with(:name, 'Test Name') })
+      end.inspect
+      Post.last_find[:conditions].should == 
+        [%q("posts".blog_id IN (SELECT "blogs".id FROM "blogs" WHERE ("blogs".name = 'Test Name') ))]
+    end
+
+    it 'should generate an explicit subquery on selected field' do
+      Post.filter do
+        with(:blog_id).in(Blog.filter { select(:name) ; with(:name, 'Test Name') })
+      end.inspect
+      Post.last_find[:conditions].should == 
+        [%q("posts".blog_id IN (SELECT "blogs".name FROM "blogs" WHERE ("blogs".name = 'Test Name') ))]
+    end
+
+    it 'should perform a negated subquery' do
+      Post.filter do
+        with(:blog_id).not.in(Blog.filter { with(:name, 'Test Name') })
+      end.inspect
+      Post.last_find[:conditions].should ==
+        [%q("posts".blog_id NOT IN (SELECT "blogs".id FROM "blogs" WHERE ("blogs".name = 'Test Name') ))]
+    end
+
+    it 'should fail fast if subselect performed with multiple select fields' do
+      lambda do
+        Post.filter do
+          with(:blog_id).in(Blog.filter { select(:id, :name) ; with(:name, 'Test Name') })
+        end.inspect
+      end.should raise_error(RecordFilter::InvalidFilterException)
+    end
+  end
+
+  describe 'equality subquery' do
+    it 'should perform subquery and implicitly add limit' do
+      Post.filter do
+        with(:blog_id, Blog.filter { with(:name, 'Test Name') })
+      end.inspect
+      Post.last_find[:conditions].should == 
+        [%q("posts".blog_id = (SELECT "blogs".id FROM "blogs" WHERE ("blogs".name = 'Test Name')  LIMIT 1))]
+    end
+  end
+end

data/spec/select_spec.rb

@@ -6,22 +6,40 @@ describe 'with custom selects for cases where DISTINCT is required' do
   end 
 
   describe 'on a standard filter' do
-    it 'should put nothing in the select' do
+    it 'should put nothing in the select by default' do
       Post.filter do
         having(:comments).with(:offensive, true)
       end.inspect
       Post.last_find[:select].should be_nil
     end
+
+    it 'should use the columns specified in the select' do
+      Post.filter do
+        select(:id, :title)
+        having(:comments).with(:offensive, true)
+      end.inspect
+      Post.last_find[:select].should == '"posts".id, "posts".title'
+    end
+
+    #XXX check bogus column names
   end
 
-  describe 'with join types that require distinct' do
-    it 'should put the distinct clause in the select' do
-      [:left, :right].each do |join_type|
+  [:left, :right].each do |join_type|
+    describe "with #{join_type} join" do
+      it 'should put the distinct clause in the select' do
         Post.filter do
           having(:comments, :join_type => join_type).with(:offensive, true)
         end.inspect rescue nil # required because sqlite doesn't support right joins
         Post.last_find[:select].should == %q(DISTINCT "posts".*)
       end
+
+      it 'should put the distinct clause with the columns specified in the select' do
+        Post.filter do
+          select(:id, :title)
+          having(:comments, :join_type => join_type).with(:offensive, true)
+        end.inspect rescue nil # required because sqlite doesn't support right joins
+        Post.last_find[:select].should == %q(DISTINCT "posts".id, "posts".title)
+      end
     end
   end
 
@@ -63,6 +81,25 @@ describe 'with custom selects for cases where DISTINCT is required' do
       end.inspect
       Blog.last_find[:select].should == %q(DISTINCT "blogs".*)
     end
+
+    it 'should create a distinct query on selected columns' do
+      Blog.filter do
+        with(:created_at).gt(1.day.ago)
+        having(:posts).with(:permalink, nil)
+        distinct
+        select(:id, :name)
+      end.inspect
+      Blog.last_find[:select].should == %q(DISTINCT "blogs".id, "blogs".name)
+    end
+
+    it 'should create a distinct query on selected columns passed into distinct()' do
+      Blog.filter do
+        with(:created_at).gt(1.day.ago)
+        having(:posts).with(:permalink, nil)
+        distinct(:id, :name)
+      end.inspect
+      Blog.last_find[:select].should == %q(DISTINCT "blogs".id, "blogs".name)
+    end
   end
 
   describe 'using the distinct method when chaining named scopes with joins that do not need it' do

metadata

@@ -3,10 +3,10 @@ name: record_filter
 version: !ruby/object:Gem::Version 
   prerelease: false
   segments: 
+  - 1
   - 0
-  - 9
-  - 17
-  version: 0.9.17
+  - 0
+  version: 1.0.0
 platform: ruby
 authors: 
 - Aubrey Holland
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-03-04 00:00:00 -05:00
+date: 2010-03-18 00:00:00 -04:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -90,6 +90,7 @@ files:
 - spec/active_record_spec.rb
 - spec/exception_spec.rb
 - spec/explicit_join_spec.rb
+- spec/explicit_subquery_spec.rb
 - spec/implicit_join_spec.rb
 - spec/limits_and_ordering_spec.rb
 - spec/models.rb
@@ -138,6 +139,7 @@ test_files:
 - spec/active_record_spec.rb
 - spec/exception_spec.rb
 - spec/explicit_join_spec.rb
+- spec/explicit_subquery_spec.rb
 - spec/implicit_join_spec.rb
 - spec/limits_and_ordering_spec.rb
 - spec/models.rb