thinking-sphinx 2.0.4 → 2.0.5

data/lib/thinking_sphinx/field.rb

@@ -19,6 +19,8 @@ module ThinkingSphinx
     # - :sortable => true
     # - :infixes  => true
     # - :prefixes => true
+    # - :file     => true
+    # - :with     => :attribute # or :wordcount
     #
     # Alias is only required in three circumstances: when there's
     # another attribute or field with the same name, when the column name is
@@ -58,6 +60,8 @@ module ThinkingSphinx
       @sortable = options[:sortable] || false
       @infixes  = options[:infixes]  || false
       @prefixes = options[:prefixes] || false
+      @file     = options[:file]     || false
+      @with     = options[:with]
       
       source.fields << self
     end
@@ -78,5 +82,17 @@ module ThinkingSphinx
       
       "#{clause} AS #{quote_column(unique_name)}"
     end
+    
+    def file?
+      @file
+    end
+    
+    def with_attribute?
+      @with == :attribute
+    end
+    
+    def with_wordcount?
+      @with == :wordcount
+    end
   end
 end

data/lib/thinking_sphinx/search.rb

@@ -22,7 +22,7 @@ module ThinkingSphinx
       undef_method method
     }
     
-    HashOptions   = [:conditions, :with, :without, :with_all]
+    HashOptions   = [:conditions, :with, :without, :with_all, :without_any]
     ArrayOptions  = [:classes, :without_ids]
     
     attr_reader :args, :options
@@ -482,9 +482,12 @@ module ThinkingSphinx
     
     def match_hash(object)
       @results[:matches].detect { |match|
+        class_crc = object.class.name
+        class_crc = object.class.to_crc32 if Riddle.loaded_version.to_i < 2
+        
         match[:attributes]['sphinx_internal_id'] == object.
           primary_key_for_sphinx &&
-        match[:attributes]['class_crc'] == object.class.to_crc32
+        match[:attributes][crc_attribute] == class_crc
       }
     end
 
@@ -722,6 +725,11 @@ module ThinkingSphinx
         Array(values).collect { |value|
           Riddle::Client::Filter.new attrib.to_s, filter_value(value)
         }
+      }.flatten +
+      (options[:without_any] || {}).collect { |attrib, values|
+        Array(values).collect { |value|
+          Riddle::Client::Filter.new attrib.to_s, filter_value(value), true
+        }
       }.flatten
     end
     
@@ -877,7 +885,7 @@ module ThinkingSphinx
       return single_class_results if one_class
       
       groups = results[:matches].group_by { |match|
-        match[:attributes]["class_crc"]
+        match[:attributes][crc_attribute]
       }
       groups.each do |crc, group|
         group.replace(
@@ -887,7 +895,7 @@ module ThinkingSphinx
       
       results[:matches].collect do |match|
         groups.detect { |crc, group|
-          crc == match[:attributes]["class_crc"]
+          crc == match[:attributes][crc_attribute]
         }[1].compact.detect { |obj|
           obj.primary_key_for_sphinx == match[:attributes]["sphinx_internal_id"]
         }
@@ -899,7 +907,11 @@ module ThinkingSphinx
     end
     
     def class_from_crc(crc)
-      config.models_by_crc[crc].constantize
+      if Riddle.loaded_version.to_i < 2
+        config.models_by_crc[crc].constantize
+      else
+        crc.constantize
+      end
     end
     
     def each_with_attribute(attribute, &block)
@@ -952,5 +964,9 @@ module ThinkingSphinx
       
       results_count
     end
+    
+    def crc_attribute
+      Riddle.loaded_version.to_i < 2 ? 'class_crc' : 'sphinx_internal_class'
+    end
   end
 end

data/lib/thinking_sphinx/sinatra.rb

@@ -0,0 +1,7 @@
+require 'thinking_sphinx'
+
+ThinkingSphinx::Configuration.instance
+
+ActiveSupport.on_load :active_record do
+  include ThinkingSphinx::ActiveRecord
+end

data/lib/thinking_sphinx/source.rb

@@ -23,8 +23,8 @@ module ThinkingSphinx
       @database_configuration = @model.connection.
         instance_variable_get(:@config).clone
       
-      @base = ::ActiveRecord::Associations::ClassMethods::JoinDependency.new(
-        @model, [], nil
+      @base = join_dependency_class.new(
+        @model, [], initial_joins
       )
       
       unless @model.descends_from_active_record?
@@ -45,6 +45,7 @@ module ThinkingSphinx
       )
       
       set_source_database_settings  source
+      set_source_fields             source
       set_source_attributes         source, offset
       set_source_settings           source
       set_source_sql                source, offset
@@ -59,6 +60,7 @@ module ThinkingSphinx
       source.parent = "#{index.core_name}_#{position}"
       
       set_source_database_settings  source
+      set_source_fields             source
       set_source_attributes         source, offset, true
       set_source_settings           source
       set_source_sql                source, offset, true
@@ -97,6 +99,14 @@ module ThinkingSphinx
       source.sql_sock = config[:socket]
     end
     
+    def set_source_fields(source)
+      fields.each do |field|
+        source.sql_file_field   << field.unique_name if field.file?
+        source.sql_field_string << field.unique_name if field.with_attribute?
+        source.sql_field_str2wordcount << field.unique_name if field.with_wordcount?
+      end
+    end
+    
     def set_source_attributes(source, offset, delta = false)
       available_attributes.each do |attrib|
         source.send(attrib.type_to_config) << attrib.config_value(offset, delta)
@@ -159,5 +169,26 @@ module ThinkingSphinx
     def utf8?
       @index.options[:charset_type] =~ /utf-8|zh_cn.utf-8/
     end
+    
+    def join_dependency_class
+      if rails_3_1?
+        ::ActiveRecord::Associations::JoinDependency
+      else
+        ::ActiveRecord::Associations::ClassMethods::JoinDependency
+      end
+    end
+    
+    def initial_joins
+      if rails_3_1?
+        []
+      else
+        nil
+      end
+    end
+    
+    def rails_3_1?
+      ::ActiveRecord::Associations.constants.include?(:JoinDependency) ||
+      ::ActiveRecord::Associations.constants.include?('JoinDependency')
+    end
   end
 end

data/lib/thinking_sphinx/source/internal_properties.rb

@@ -4,10 +4,15 @@ module ThinkingSphinx
       def add_internal_attributes_and_facets
         add_internal_attribute :sphinx_internal_id, nil,
           @model.primary_key_for_sphinx.to_sym
-        add_internal_attribute :class_crc,          :integer, crc_column, true
         add_internal_attribute :sphinx_deleted,     :integer, "0"
-
-        add_internal_facet :class_crc
+        add_internal_attribute :class_crc,          :integer, crc_column, true
+        
+        unless Riddle.loaded_version.to_i < 2
+          add_internal_attribute :sphinx_internal_class, :string, internal_class_column, true
+          add_internal_facet :sphinx_internal_class
+        else
+          add_internal_facet :class_crc
+        end
       end
 
       def add_internal_attribute(name, type, contents, facet = false)

data/lib/thinking_sphinx/source/sql.rb

@@ -61,7 +61,7 @@ module ThinkingSphinx
       end
 
       def sql_select_clause(offset)
-        unique_id_expr = ThinkingSphinx.unique_id_expression(offset)
+        unique_id_expr = ThinkingSphinx.unique_id_expression(adapter, offset)
 
         (
           ["#{@model.quoted_table_name}.#{quote_column(@model.primary_key_for_sphinx)} #{unique_id_expr} AS #{quote_column(@model.primary_key_for_sphinx)} "] + 
@@ -130,6 +130,15 @@ module ThinkingSphinx
         end
       end
       
+      def internal_class_column
+        if @model.table_exists? &&
+          @model.column_names.include?(@model.inheritance_column)
+          adapter.quote_with_table(@model.inheritance_column)
+        else
+          "'#{@model.name}'"
+        end
+      end
+      
       def type_values
         @model.connection.select_values <<-SQL
 SELECT DISTINCT #{@model.inheritance_column}

data/spec/thinking_sphinx/attribute_spec.rb

@@ -298,184 +298,176 @@ describe ThinkingSphinx::Attribute do
   end
   
   describe "MVA with source query" do
-    before :each do
-      @attribute = ThinkingSphinx::Attribute.new(@source,
-        [ThinkingSphinx::Index::FauxColumn.new(:tags, :id)],
-        :as => :tag_ids, :source => :query
-      )
-    end
+    let(:attribute) { ThinkingSphinx::Attribute.new(@source,
+      [ThinkingSphinx::Index::FauxColumn.new(:tags, :id)],
+      :as => :tag_ids, :source => :query)
+    }
+    let(:adapter)   { attribute.send(:adapter) }
     
     it "should use a query" do
-      @attribute.type_to_config.should == :sql_attr_multi
+      attribute.type_to_config.should == :sql_attr_multi
       
-      declaration, query = @attribute.config_value.split('; ')
+      declaration, query = attribute.config_value.split('; ')
       declaration.should == "uint tag_ids from query"
-      query.should       == "SELECT `tags`.`person_id` #{ThinkingSphinx.unique_id_expression} AS `id`, `tags`.`id` AS `tag_ids` FROM `tags`"
+      query.should       == "SELECT `tags`.`person_id` #{ThinkingSphinx.unique_id_expression adapter} AS `id`, `tags`.`id` AS `tag_ids` FROM `tags`"
     end
   end
   
   describe "MVA with source query for a delta source" do
-    before :each do
-      @attribute = ThinkingSphinx::Attribute.new(@source,
-        [ThinkingSphinx::Index::FauxColumn.new(:tags, :id)],
-        :as => :tag_ids, :source => :query
-      )
-    end
+    let(:attribute) { ThinkingSphinx::Attribute.new(@source,
+      [ThinkingSphinx::Index::FauxColumn.new(:tags, :id)],
+      :as => :tag_ids, :source => :query)
+    }
+    let(:adapter)   { attribute.send(:adapter) }
     
     it "should use a query" do
-      @attribute.type_to_config.should == :sql_attr_multi
+      attribute.type_to_config.should == :sql_attr_multi
       
-      declaration, query = @attribute.config_value(nil, true).split('; ')
+      declaration, query = attribute.config_value(nil, true).split('; ')
       declaration.should == "uint tag_ids from query"
-      query.should       == "SELECT `tags`.`person_id` #{ThinkingSphinx.unique_id_expression} AS `id`, `tags`.`id` AS `tag_ids` FROM `tags` WHERE `tags`.`person_id` IN (SELECT `id` FROM `people` WHERE `people`.`delta` = 1)"
+      query.should       == "SELECT `tags`.`person_id` #{ThinkingSphinx.unique_id_expression adapter} AS `id`, `tags`.`id` AS `tag_ids` FROM `tags` WHERE `tags`.`person_id` IN (SELECT `id` FROM `people` WHERE `people`.`delta` = 1)"
     end
   end
   
   describe "MVA via a HABTM association with a source query" do
-    before :each do
-      @attribute = ThinkingSphinx::Attribute.new(@source,
-        [ThinkingSphinx::Index::FauxColumn.new(:links, :id)],
-        :as => :link_ids, :source => :query
-      )
-    end
+    let(:attribute) { ThinkingSphinx::Attribute.new(@source,
+      [ThinkingSphinx::Index::FauxColumn.new(:links, :id)],
+      :as => :link_ids, :source => :query)
+    }
+    let(:adapter)   { attribute.send(:adapter) }
     
     it "should use a ranged query" do
-      @attribute.type_to_config.should == :sql_attr_multi
+      attribute.type_to_config.should == :sql_attr_multi
       
-      declaration, query = @attribute.config_value.split('; ')
+      declaration, query = attribute.config_value.split('; ')
       declaration.should == "uint link_ids from query"
-      query.should       == "SELECT `links_people`.`person_id` #{ThinkingSphinx.unique_id_expression} AS `id`, `links_people`.`link_id` AS `link_ids` FROM `links_people`"
+      query.should       == "SELECT `links_people`.`person_id` #{ThinkingSphinx.unique_id_expression adapter} AS `id`, `links_people`.`link_id` AS `link_ids` FROM `links_people`"
     end
   end
   
   describe "MVA with ranged source query" do
-    before :each do
-      @attribute = ThinkingSphinx::Attribute.new(@source,
-        [ThinkingSphinx::Index::FauxColumn.new(:tags, :id)],
-        :as => :tag_ids, :source => :ranged_query
-      )
-    end
+    let(:attribute) { ThinkingSphinx::Attribute.new(@source,
+      [ThinkingSphinx::Index::FauxColumn.new(:tags, :id)],
+      :as => :tag_ids, :source => :ranged_query)
+    }
+    let(:adapter)   { attribute.send(:adapter) }
     
     it "should use a ranged query" do
-      @attribute.type_to_config.should == :sql_attr_multi
+      attribute.type_to_config.should == :sql_attr_multi
       
-      declaration, query, range_query = @attribute.config_value.split('; ')
+      declaration, query, range_query = attribute.config_value.split('; ')
       declaration.should == "uint tag_ids from ranged-query"
-      query.should       == "SELECT `tags`.`person_id` #{ThinkingSphinx.unique_id_expression} AS `id`, `tags`.`id` AS `tag_ids` FROM `tags` WHERE `tags`.`person_id` >= $start AND `tags`.`person_id` <= $end"
+      query.should       == "SELECT `tags`.`person_id` #{ThinkingSphinx.unique_id_expression adapter} AS `id`, `tags`.`id` AS `tag_ids` FROM `tags` WHERE `tags`.`person_id` >= $start AND `tags`.`person_id` <= $end"
       range_query.should == "SELECT MIN(`tags`.`person_id`), MAX(`tags`.`person_id`) FROM `tags`"
     end
   end
   
   describe "MVA with ranged source query for a delta source" do
-    before :each do
-      @attribute = ThinkingSphinx::Attribute.new(@source,
-        [ThinkingSphinx::Index::FauxColumn.new(:tags, :id)],
-        :as => :tag_ids, :source => :ranged_query
-      )
-    end
+    let(:attribute) { ThinkingSphinx::Attribute.new(@source,
+      [ThinkingSphinx::Index::FauxColumn.new(:tags, :id)],
+      :as => :tag_ids, :source => :ranged_query)
+    }
+    let(:adapter)   { attribute.send(:adapter) }
     
     it "should use a ranged query" do
-      @attribute.type_to_config.should == :sql_attr_multi
+      attribute.type_to_config.should == :sql_attr_multi
       
-      declaration, query, range_query = @attribute.config_value(nil, true).split('; ')
+      declaration, query, range_query = attribute.config_value(nil, true).split('; ')
       declaration.should == "uint tag_ids from ranged-query"
-      query.should       == "SELECT `tags`.`person_id` #{ThinkingSphinx.unique_id_expression} AS `id`, `tags`.`id` AS `tag_ids` FROM `tags` WHERE `tags`.`person_id` >= $start AND `tags`.`person_id` <= $end AND `tags`.`person_id` IN (SELECT `id` FROM `people` WHERE `people`.`delta` = 1)"
+      query.should       == "SELECT `tags`.`person_id` #{ThinkingSphinx.unique_id_expression adapter} AS `id`, `tags`.`id` AS `tag_ids` FROM `tags` WHERE `tags`.`person_id` >= $start AND `tags`.`person_id` <= $end AND `tags`.`person_id` IN (SELECT `id` FROM `people` WHERE `people`.`delta` = 1)"
       range_query.should == "SELECT MIN(`tags`.`person_id`), MAX(`tags`.`person_id`) FROM `tags`"
     end
   end
   
   describe "MVA via a has-many :through with a ranged source query" do
-    before :each do
-      @attribute = ThinkingSphinx::Attribute.new(@source,
-        [ThinkingSphinx::Index::FauxColumn.new(:football_teams, :id)],
-        :as => :football_team_ids, :source => :ranged_query
-      )
-    end
+    let(:attribute) { ThinkingSphinx::Attribute.new(@source,
+      [ThinkingSphinx::Index::FauxColumn.new(:football_teams, :id)],
+      :as => :football_team_ids, :source => :ranged_query)
+    }
+    let(:adapter)   { attribute.send(:adapter) }
     
     it "should use a ranged query" do
-      @attribute.type_to_config.should == :sql_attr_multi
+      attribute.type_to_config.should == :sql_attr_multi
       
-      declaration, query, range_query = @attribute.config_value.split('; ')
+      declaration, query, range_query = attribute.config_value.split('; ')
       declaration.should == "uint football_team_ids from ranged-query"
-      query.should       == "SELECT `tags`.`person_id` #{ThinkingSphinx.unique_id_expression} AS `id`, `tags`.`football_team_id` AS `football_team_ids` FROM `tags` WHERE `tags`.`person_id` >= $start AND `tags`.`person_id` <= $end"
+      query.should       == "SELECT `tags`.`person_id` #{ThinkingSphinx.unique_id_expression adapter} AS `id`, `tags`.`football_team_id` AS `football_team_ids` FROM `tags` WHERE `tags`.`person_id` >= $start AND `tags`.`person_id` <= $end"
       range_query.should == "SELECT MIN(`tags`.`person_id`), MAX(`tags`.`person_id`) FROM `tags`"
     end
   end
   
   describe "MVA via a has-many :through using a foreign key with a ranged source query" do
-    before :each do
-      @attribute = ThinkingSphinx::Attribute.new(@source,
-        [ThinkingSphinx::Index::FauxColumn.new(:friends, :id)],
-        :as => :friend_ids, :source => :ranged_query
-      )
-    end
+    let(:attribute) { ThinkingSphinx::Attribute.new(@source,
+      [ThinkingSphinx::Index::FauxColumn.new(:friends, :id)],
+      :as => :friend_ids, :source => :ranged_query)
+    }
+    let(:adapter)   { attribute.send(:adapter) }
     
     it "should use a ranged query" do
-      @attribute.type_to_config.should == :sql_attr_multi
+      attribute.type_to_config.should == :sql_attr_multi
       
-      declaration, query, range_query = @attribute.config_value.split('; ')
+      declaration, query, range_query = attribute.config_value.split('; ')
       declaration.should == "uint friend_ids from ranged-query"
-      query.should       == "SELECT `friendships`.`person_id` #{ThinkingSphinx.unique_id_expression} AS `id`, `friendships`.`friend_id` AS `friend_ids` FROM `friendships` WHERE `friendships`.`person_id` >= $start AND `friendships`.`person_id` <= $end"
+      query.should       == "SELECT `friendships`.`person_id` #{ThinkingSphinx.unique_id_expression adapter} AS `id`, `friendships`.`friend_id` AS `friend_ids` FROM `friendships` WHERE `friendships`.`person_id` >= $start AND `friendships`.`person_id` <= $end"
       range_query.should == "SELECT MIN(`friendships`.`person_id`), MAX(`friendships`.`person_id`) FROM `friendships`"
     end
   end
   
   describe "MVA via a HABTM with a ranged source query" do
-    before :each do
-      @attribute = ThinkingSphinx::Attribute.new(@source,
-        [ThinkingSphinx::Index::FauxColumn.new(:links, :id)],
-        :as => :link_ids, :source => :ranged_query
-      )
-    end
+    let(:attribute) { ThinkingSphinx::Attribute.new(@source,
+      [ThinkingSphinx::Index::FauxColumn.new(:links, :id)],
+      :as => :link_ids, :source => :ranged_query)
+    }
+    let(:adapter)   { attribute.send(:adapter) }
     
     it "should use a ranged query" do
-      @attribute.type_to_config.should == :sql_attr_multi
+      attribute.type_to_config.should == :sql_attr_multi
       
-      declaration, query, range_query = @attribute.config_value.split('; ')
+      declaration, query, range_query = attribute.config_value.split('; ')
       declaration.should == "uint link_ids from ranged-query"
-      query.should       == "SELECT `links_people`.`person_id` #{ThinkingSphinx.unique_id_expression} AS `id`, `links_people`.`link_id` AS `link_ids` FROM `links_people` WHERE `links_people`.`person_id` >= $start AND `links_people`.`person_id` <= $end"
+      query.should       == "SELECT `links_people`.`person_id` #{ThinkingSphinx.unique_id_expression adapter} AS `id`, `links_people`.`link_id` AS `link_ids` FROM `links_people` WHERE `links_people`.`person_id` >= $start AND `links_people`.`person_id` <= $end"
       range_query.should == "SELECT MIN(`links_people`.`person_id`), MAX(`links_people`.`person_id`) FROM `links_people`"
     end
   end
   
   describe "MVA via two has-many associations with a ranged source query" do
-    before :each do
-      @index  = ThinkingSphinx::Index.new(Alpha)
-      @source = ThinkingSphinx::Source.new(@index)
-      @attribute = ThinkingSphinx::Attribute.new(@source,
-        [ThinkingSphinx::Index::FauxColumn.new(:betas, :gammas, :value)],
-        :as => :gamma_values, :source => :ranged_query
-      )
-    end
+    let(:index)     { ThinkingSphinx::Index.new(Alpha) }
+    let(:source)    { ThinkingSphinx::Source.new(index) }
+    let(:attribute) { ThinkingSphinx::Attribute.new(source,
+      [ThinkingSphinx::Index::FauxColumn.new(:betas, :gammas, :value)],
+      :as => :gamma_values, :source => :ranged_query)
+    }
+    let(:adapter)   { attribute.send(:adapter) }
     
     it "should use a ranged query" do
-      @attribute.type_to_config.should == :sql_attr_multi
+      attribute.type_to_config.should == :sql_attr_multi
       
-      declaration, query, range_query = @attribute.config_value.split('; ')
+      declaration, query, range_query = attribute.config_value.split('; ')
       declaration.should == "uint gamma_values from ranged-query"
-      query.should       == "SELECT `betas`.`alpha_id` #{ThinkingSphinx.unique_id_expression} AS `id`, `gammas`.`value` AS `gamma_values` FROM `betas` LEFT OUTER JOIN `gammas` ON `gammas`.`beta_id` = `betas`.`id` WHERE `betas`.`alpha_id` >= $start AND `betas`.`alpha_id` <= $end"
+      query.should       == "SELECT `betas`.`alpha_id` #{ThinkingSphinx.unique_id_expression adapter} AS `id`, `gammas`.`value` AS `gamma_values` FROM `betas` LEFT OUTER JOIN `gammas` ON `gammas`.`beta_id` = `betas`.`id` WHERE `betas`.`alpha_id` >= $start AND `betas`.`alpha_id` <= $end"
       range_query.should == "SELECT MIN(`betas`.`alpha_id`), MAX(`betas`.`alpha_id`) FROM `betas`"
     end
   end
   
   describe "MVA via two has-many associations with a ranged source query for a delta source" do
-    before :each do
-      @index  = ThinkingSphinx::Index.new(Alpha)
-      @source = ThinkingSphinx::Source.new(@index)
-      @attribute = ThinkingSphinx::Attribute.new(@source,
-        [ThinkingSphinx::Index::FauxColumn.new(:betas, :gammas, :value)],
-        :as => :gamma_values, :source => :ranged_query
-      )
+    let(:index)     { ThinkingSphinx::Index.new(Alpha) }
+    let(:source)    { ThinkingSphinx::Source.new(index) }
+    let(:attribute) { ThinkingSphinx::Attribute.new(source,
+      [ThinkingSphinx::Index::FauxColumn.new(:betas, :gammas, :value)],
+      :as => :gamma_values, :source => :ranged_query)
+    }
+    let(:adapter)   { attribute.send(:adapter) }
       
-      @index.delta_object = ThinkingSphinx::Deltas::DefaultDelta.new @index, @index.local_options
+    before :each do
+      index.delta_object = ThinkingSphinx::Deltas::DefaultDelta.new index, index.local_options
     end
     
     it "should use a ranged query" do
-      @attribute.type_to_config.should == :sql_attr_multi
+      attribute.type_to_config.should == :sql_attr_multi
       
-      declaration, query, range_query = @attribute.config_value(nil, true).split('; ')
+      declaration, query, range_query = attribute.config_value(nil, true).split('; ')
       declaration.should == "uint gamma_values from ranged-query"
-      query.should       == "SELECT `betas`.`alpha_id` #{ThinkingSphinx.unique_id_expression} AS `id`, `gammas`.`value` AS `gamma_values` FROM `betas` LEFT OUTER JOIN `gammas` ON `gammas`.`beta_id` = `betas`.`id` WHERE `betas`.`alpha_id` >= $start AND `betas`.`alpha_id` <= $end AND `betas`.`alpha_id` IN (SELECT `id` FROM `alphas` WHERE `alphas`.`delta` = 1)"
+      query.should       == "SELECT `betas`.`alpha_id` #{ThinkingSphinx.unique_id_expression adapter} AS `id`, `gammas`.`value` AS `gamma_values` FROM `betas` LEFT OUTER JOIN `gammas` ON `gammas`.`beta_id` = `betas`.`id` WHERE `betas`.`alpha_id` >= $start AND `betas`.`alpha_id` <= $end AND `betas`.`alpha_id` IN (SELECT `id` FROM `alphas` WHERE `alphas`.`delta` = 1)"
       range_query.should == "SELECT MIN(`betas`.`alpha_id`), MAX(`betas`.`alpha_id`) FROM `betas`"
     end
   end