freelancing-god-thinking-sphinx 1.1.5 → 1.1.6

data/README

@@ -10,6 +10,8 @@ Keep in mind that while Thinking Sphinx works for ActiveRecord with Merb, it doe
 
 Fork on GitHub and after you've committed tested patches, send a pull request.
 
+To quickly see if your system is ready to run the thinking sphinx specs, run the contribute.rb script found in the project root directory. Use the following instructions to install any missing requirements.
+
 To get the spec suite running, you will need to install the not-a-mock gem if you don't already have it:
 
   git clone git://github.com/freelancing-god/not-a-mock.git
@@ -24,9 +26,14 @@ Then install the ginger gem. The steps are the same, except that you might need
   rake gem
   sudo gem install pkg/ginger-1.1.0.gem
 
+Then install the faker gem:
+
+  sudo gem install faker
+
 Then set up your database:
 
   cp spec/fixtures/database.yml.default spec/fixtures/database.yml
+  cp spec/fixtures/database.yml.default features/support/db/database.yml
   mysqladmin -u root create thinking_sphinx
   
 Make sure you don't have another Sphinx daemon (searchd) running. If you do, quit it with "rake ts:stop"
@@ -35,10 +42,12 @@ in the app root.
 You should now have a passing test suite from which to build your patch on.
 
   rake spec
+	rake features  (Note: You will need MySQL and Postgres gems to run the full suite. You may want to tweak your rakefile)
   
 If you get the message "Failed to start searchd daemon", run the spec with sudo:
 
   sudo rake spec
+  sudo rake features  
   
 If you quit the spec suite before it's completed, you may be left with data in the test
 database, causing the next run to have failures. Let that run complete and then try again.
@@ -106,3 +115,8 @@ Since I first released this library, there's been quite a few people who have su
 - Dan Pickett
 - Alex Caudill
 - Jim Benton
+- John Aughey
+- Keith Pitty
+- Jeff Talbot
+- Dana Contreras
+- Menno van der Sman

data/lib/thinking_sphinx.rb

@@ -34,7 +34,7 @@ module ThinkingSphinx
   module Version #:nodoc:
     Major = 1
     Minor = 1
-    Tiny  = 5
+    Tiny  = 6
     
     String = [Major, Minor, Tiny].join('.')
   end
@@ -60,6 +60,10 @@ module ThinkingSphinx
     @@indexed_models ||= []
   end
   
+  def self.unique_id_expression(offset = nil)
+    "* #{ThinkingSphinx.indexed_models.size} + #{offset || 0}"
+  end
+  
   # Check if index definition is disabled.
   # 
   def self.define_indexes?
@@ -134,11 +138,22 @@ module ThinkingSphinx
   end
   
   def self.sphinx_running?
-    !!sphinx_pid
+    !!sphinx_pid && pid_active?(sphinx_pid)
   end
   
   def self.sphinx_pid
     pid_file = ThinkingSphinx::Configuration.instance.pid_file    
     `cat #{pid_file}`[/\d+/] if File.exists?(pid_file)
   end
+  
+  def self.pid_active?(pid)
+    return true if RUBY_PLATFORM =~ /mswin/
+    
+    begin
+      Process.getpgid(pid.to_i)
+      true
+    rescue Exception => e
+      false
+    end
+  end
 end

data/lib/thinking_sphinx/active_record.rb

@@ -207,11 +207,20 @@ module ThinkingSphinx
       )
     end
     
+    def in_index?(suffix)
+      self.class.search_for_id self.sphinx_document_id, sphinx_index_name(suffix)
+    end
+    
     def in_core_index?
-      self.class.search_for_id(
-        self.sphinx_document_id,
-        "#{self.class.source_of_sphinx_index.name.underscore.tr(':/\\', '_')}_core"
-      )
+      in_index? "core"
+    end
+    
+    def in_delta_index?
+      in_index? "delta"
+    end
+    
+    def in_both_indexes?
+      in_core_index? && in_delta_index?
     end
     
     def toggle_deleted
@@ -241,5 +250,11 @@ module ThinkingSphinx
       (self.id * ThinkingSphinx.indexed_models.size) +
         ThinkingSphinx.indexed_models.index(self.class.source_of_sphinx_index.name)
     end
+    
+    private
+    
+    def sphinx_index_name(suffix)
+      "#{self.class.source_of_sphinx_index.name.underscore.tr(':/\\', '_')}_#{suffix}"
+    end
   end
 end

data/lib/thinking_sphinx/adapters/abstract_adapter.rb

@@ -17,7 +17,7 @@ module ThinkingSphinx
       when "ActiveRecord::ConnectionAdapters::PostgreSQLAdapter"
         ThinkingSphinx::PostgreSQLAdapter.new model
       else
-        raise "Invalid Database Adapter: Sphinx only supports MySQL and PostgreSQL"
+        raise "Invalid Database Adapter: Sphinx only supports MySQL and PostgreSQL, not #{model.connection.class.name}"
       end
     end
     

data/lib/thinking_sphinx/adapters/mysql_adapter.rb

@@ -13,7 +13,7 @@ module ThinkingSphinx
     end
     
     def group_concatenate(clause, separator = ' ')
-      "GROUP_CONCAT(#{clause} SEPARATOR '#{separator}')"
+      "GROUP_CONCAT(DISTINCT #{clause} SEPARATOR '#{separator}')"
     end
     
     def cast_to_string(clause)

data/lib/thinking_sphinx/association.rb

@@ -99,6 +99,23 @@ module ThinkingSphinx
       @reflection.klass.column_names.include?(column.to_s)
     end
     
+    def primary_key_from_reflection
+      if @reflection.options[:through]
+        @reflection.source_reflection.options[:foreign_key] ||
+        @reflection.source_reflection.primary_key_name
+      else
+        nil
+      end
+    end
+    
+    def table
+      if @reflection.options[:through]
+        @join.aliased_join_table_name
+      else
+        @join.aliased_table_name
+      end
+    end
+    
     private
     
     # Returns all the objects that could be currently instantiated from a

data/lib/thinking_sphinx/attribute.rb

@@ -9,14 +9,15 @@ module ThinkingSphinx
   # associations. Which can get messy. Use Index.link!, it really helps.
   # 
   class Attribute
-    attr_accessor :alias, :columns, :associations, :model, :faceted
+    attr_accessor :alias, :columns, :associations, :model, :faceted, :source
     
     # To create a new attribute, you'll need to pass in either a single Column
     # or an array of them, and some (optional) options.
     #
     # Valid options are:
-    # - :as   => :alias_name 
-    # - :type => :attribute_type
+    # - :as     => :alias_name
+    # - :type   => :attribute_type
+    # - :source => :field, :query, :ranged_query
     #
     # Alias is only required in three circumstances: when there's
     # another attribute or field with the same name, when the column name is
@@ -28,6 +29,13 @@ module ThinkingSphinx
     # can't be figured out by the column - ie: when not actually using a
     # database column as your source.
     # 
+    # Source is only used for multi-value attributes (MVA). By default this will
+    # use a left-join and a group_concat to obtain the values. For better performance
+    # during indexing it can be beneficial to let Sphinx use a separate query to retrieve
+    # all document,value-pairs.
+    # Either :query or :ranged_query will enable this feature, where :ranged_query will cause
+    # the query to be executed incremental.
+    #
     # Example usage:
     #
     #   Attribute.new(
@@ -40,6 +48,12 @@ module ThinkingSphinx
     #   )
     #
     #   Attribute.new(
+    #     Column.new(:posts, :id),
+    #     :as => :post_ids,
+    #     :source => :ranged_query
+    #   )
+    #
+    #   Attribute.new(
     #     [Column.new(:pages, :id), Column.new(:articles, :id)],
     #     :as => :content_ids
     #   )
@@ -62,6 +76,9 @@ module ThinkingSphinx
       @alias    = options[:as]
       @type     = options[:type]
       @faceted  = options[:facet]
+      @source   = options[:source]
+      
+      @type   ||= :multi unless @source.nil?
     end
     
     # Get the part of the SELECT clause related to this attribute. Don't forget
@@ -71,6 +88,8 @@ module ThinkingSphinx
     # datetimes to timestamps, as needed.
     # 
     def to_select_sql
+      return nil unless include_as_association?
+      
       clause = @columns.collect { |column|
         column_with_prefix(column)
       }.join(', ')
@@ -113,9 +132,20 @@ module ThinkingSphinx
       }[type]
     end
     
-    def config_value
+    def include_as_association?
+      ! (type == :multi && (source == :query || source == :ranged_query))
+    end
+    
+    # Returns the configuration value that should be used for
+    # the attribute.
+    # Special case is the multi-valued attribute that needs some
+    # extra configuration. 
+    # 
+    def config_value(offset = nil)
       if type == :multi
-        "uint #{unique_name} from field"
+        multi_config = include_as_association? ? "field" :
+          source_value(offset).gsub(/\n\s*/, " ")
+        "uint #{unique_name} from #{multi_config}"
       else
         unique_name
       end
@@ -157,14 +187,71 @@ module ThinkingSphinx
     
     private
     
+    def source_value(offset)
+      if is_string?
+        "#{source.to_s.dasherize}; #{columns.first.__name}"
+      elsif source == :ranged_query
+        "ranged-query; #{query offset} #{query_clause}; #{range_query}"
+      else
+        "query; #{query offset}"
+      end
+    end
+    
+    def query(offset)
+      assoc = association_for_mva
+      raise "Could not determine SQL for MVA" if assoc.nil?
+      
+      <<-SQL
+SELECT #{foreign_key_for_mva assoc}
+  #{ThinkingSphinx.unique_id_expression(offset)} AS #{quote_column('id')},
+  #{primary_key_for_mva(assoc)} AS #{quote_column(unique_name)}
+FROM #{quote_table_name assoc.table}
+      SQL
+    end
+    
+    def query_clause
+      foreign_key = foreign_key_for_mva association_for_mva
+      "WHERE #{foreign_key} >= $start AND #{foreign_key} <= $end"
+    end
+    
+    def range_query
+      assoc       = association_for_mva
+      foreign_key = foreign_key_for_mva assoc
+      "SELECT MIN(#{foreign_key}), MAX(#{foreign_key}) FROM #{quote_table_name assoc.table}"
+    end
+    
+    def primary_key_for_mva(assoc)
+      quote_with_table(
+        assoc.table, assoc.primary_key_from_reflection || columns.first.__name
+      )
+    end
+    
+    def foreign_key_for_mva(assoc)
+      quote_with_table assoc.table, assoc.reflection.primary_key_name
+    end
+    
+    def association_for_mva
+      @association_for_mva ||= associations[columns.first].detect { |assoc|
+        assoc.has_column?(columns.first.__name)
+      }
+    end
+    
     def adapter
       @adapter ||= @model.sphinx_database_adapter
     end
     
+    def quote_with_table(table, column)
+      "#{quote_table_name(table)}.#{quote_column(column)}"
+    end
+    
     def quote_column(column)
       @model.connection.quote_column_name(column)
     end
     
+    def quote_table_name(table_name)
+      @model.connection.quote_table_name(table_name)
+    end
+    
     # Indication of whether the columns should be concatenated with a space
     # between each value. True if there's either multiple sources or multiple
     # associations.
@@ -192,7 +279,7 @@ module ThinkingSphinx
       else
         associations[column].collect { |assoc|
           assoc.has_column?(column.__name) ?
-          "#{@model.connection.quote_table_name(assoc.join.aliased_table_name)}" + 
+          "#{quote_table_name(assoc.join.aliased_table_name)}" + 
           ".#{quote_column(column.__name)}" :
           nil
         }.compact.join(', ')

data/lib/thinking_sphinx/collection.rb

@@ -48,7 +48,8 @@ module ThinkingSphinx
         :all,
         :conditions => {klass.primary_key.to_sym => ids},
         :include    => (options[:include] || index_options[:include]),
-        :select     => (options[:select]  || index_options[:select])
+        :select     => (options[:select]  || index_options[:select]),
+        :order      => (options[:sql_order] || index_options[:sql_order])
       ) : []
 
       # Raise an exception if we find records in Sphinx but not in the DB, so
@@ -59,6 +60,10 @@ module ThinkingSphinx
         raise StaleIdsException, stale_ids
       end
 
+      # if the user has specified an SQL order, return the collection
+      # without rearranging it into the Sphinx order
+      return instances if options[:sql_order]
+
       ids.collect { |obj_id|
         instances.detect { |obj| obj.id == obj_id }
       }

data/lib/thinking_sphinx/core/string.rb

@@ -1,18 +1,11 @@
+require 'zlib'
+
 module ThinkingSphinx
   module Core
     module String
-      
       def to_crc32
-        result = 0xFFFFFFFF
-        self.each_byte do |byte|
-          result ^= byte
-          8.times do
-            result = (result >> 1) ^ (0xEDB88320 * (result & 1))
-          end
-        end
-        result ^ 0xFFFFFFFF
+        Zlib.crc32 self
       end
-      
     end
   end
 end

data/lib/thinking_sphinx/deltas.rb

@@ -5,7 +5,8 @@ require 'thinking_sphinx/deltas/datetime_delta'
 module ThinkingSphinx
   module Deltas
     def self.parse(index, options)
-      case options.delete(:delta)
+      delta_option = options.delete(:delta)
+      case delta_option
       when TrueClass, :default
         DefaultDelta.new index, options
       when :delayed
@@ -15,7 +16,11 @@ module ThinkingSphinx
       when FalseClass, nil
         nil
       else
-        raise "Unknown delta type"
+        if delta_option.ancestors.include?(ThinkingSphinx::Deltas::DefaultDelta)
+          delta_option.new index, options
+        else
+          raise "Unknown delta type"
+        end
       end
     end
   end

data/lib/thinking_sphinx/deltas/default_delta.rb

@@ -11,18 +11,20 @@ module ThinkingSphinx
       def index(model, instance = nil)
         return true unless ThinkingSphinx.updates_enabled? &&
           ThinkingSphinx.deltas_enabled?
+        return true if instance && !toggled(instance)
         
         config = ThinkingSphinx::Configuration.instance
         client = Riddle::Client.new config.address, config.port
+        rotate = ThinkingSphinx.sphinx_running? ? "--rotate" : ""
+        
+        output = `#{config.bin_path}indexer --config #{config.config_file} #{rotate} #{delta_index_name model}`
+        puts(output) unless ThinkingSphinx.suppress_delta_output?
         
         client.update(
           core_index_name(model),
           ['sphinx_deleted'],
           {instance.sphinx_document_id => [1]}
-        ) if instance && ThinkingSphinx.sphinx_running? && instance.in_core_index?
-        
-        output = `#{config.bin_path}indexer --config #{config.config_file} --rotate #{delta_index_name model}`
-        puts output unless ThinkingSphinx.suppress_delta_output?
+        ) if instance && ThinkingSphinx.sphinx_running? && instance.in_both_indexes?
         
         true
       end

data/lib/thinking_sphinx/facet.rb

@@ -27,7 +27,7 @@ module ThinkingSphinx
       return translate(object, attribute_value) if @reference.is_a?(Field)
       
       case @reference.type
-      when :string, :multi
+      when :string
         translate(object, attribute_value)
       when :datetime
         Time.at(attribute_value)

data/lib/thinking_sphinx/index.rb

@@ -56,7 +56,7 @@ module ThinkingSphinx
       )
       
       set_source_database_settings  source
-      set_source_attributes         source
+      set_source_attributes         source, offset
       set_source_sql                source, offset
       set_source_settings           source
       
@@ -73,7 +73,7 @@ module ThinkingSphinx
       source.parent = "#{name}_core_#{index}"
       
       set_source_database_settings  source
-      set_source_attributes         source
+      set_source_attributes         source, offset
       set_source_sql                source, offset, true
       
       source
@@ -200,8 +200,8 @@ module ThinkingSphinx
         }.flatten +
         # attribute associations
         @attributes.collect { |attrib|
-          attrib.associations.values
-        }.flatten
+          attrib.associations.values if attrib.include_as_association?
+        }.compact.flatten
       ).uniq.collect { |assoc|
         # get ancestors as well as column-level associations
         assoc.ancestors
@@ -285,9 +285,9 @@ module ThinkingSphinx
       source.sql_sock = config[:socket]
     end
     
-    def set_source_attributes(source)
+    def set_source_attributes(source, offset = nil)
       attributes.each do |attrib|
-        source.send(attrib.type_to_config) << attrib.config_value
+        source.send(attrib.type_to_config) << attrib.config_value(offset)
       end
     end
     
@@ -354,14 +354,14 @@ module ThinkingSphinx
          internal_groupings << "#{@model.quoted_table_name}.#{quote_column(@model.inheritance_column)}"
       end
       
-      unique_id_expr = "* #{ThinkingSphinx.indexed_models.size} + #{options[:offset] || 0}"
+      unique_id_expr = ThinkingSphinx.unique_id_expression(options[:offset])
       
       sql = <<-SQL
 SELECT #{ (
   ["#{@model.quoted_table_name}.#{quote_column(@model.primary_key)} #{unique_id_expr} AS #{quote_column(@model.primary_key)} "] + 
   @fields.collect { |field| field.to_select_sql } +
   @attributes.collect { |attribute| attribute.to_select_sql }
-).join(", ") }
+).compact.join(", ") }
 FROM #{ @model.table_name }
   #{ assocs.collect { |assoc| assoc.to_sql }.join(' ') }
 WHERE #{@model.quoted_table_name}.#{quote_column(@model.primary_key)} >= $start

data/lib/thinking_sphinx/index/builder.rb

@@ -200,7 +200,17 @@ module ThinkingSphinx
         # 
         # Please don't forget to add a boolean field named 'delta' to your
         # model's database table if enabling the delta index for it.
+        # Valid options for the delta property are:
         # 
+        # true
+        # false
+        # :default
+        # :delayed
+        # :datetime
+        # 
+        # You can also extend ThinkingSphinx::Deltas::DefaultDelta to implement 
+        # your own handling for delta indexing.
+        
         def set_property(*args)
           options = args.extract_options!
           if options.empty?
@@ -224,8 +234,8 @@ module ThinkingSphinx
         # 
         # Example: indexes assoc(:properties).column
         # 
-        def assoc(assoc)
-          FauxColumn.new(method)
+        def assoc(assoc, *args)
+          FauxColumn.new(assoc, *args)
         end
       end
     end

data/lib/thinking_sphinx/search.rb

@@ -94,16 +94,24 @@ module ThinkingSphinx
       # == Searching by Attributes
       #
       # Also known as filters, you can limit your searches to documents that
-      # have specific values for their attributes. There are two ways to do
-      # this. The first is one that works in all scenarios - using the :with
-      # option.
-      #
-      #   ThinkingSphinx::Search.search :with => {:parent_id => 10}
-      #
-      # The second is only viable if you're searching with a specific model
-      # (not multi-model searching). With a single model, Thinking Sphinx
-      # can figure out what attributes and fields are available, so you can
-      # put it all in the :conditions hash, and it will sort it out.
+      # have specific values for their attributes. There are three ways to do
+      # this. The first two techniques work in all scenarios - using the :with
+      # or :with_all options.
+      #
+      #   ThinkingSphinx::Search.search :with => {:tag_ids => 10}
+      #   ThinkingSphinx::Search.search :with => {:tag_ids => [10,12]}
+      #   ThinkingSphinx::Search.search :with_all => {:tag_ids => [10,12]}
+      #
+      # The first :with search will match records with a tag_id attribute of 10.
+      # The second :with will match records with a tag_id attribute of 10 OR 12.
+      # If you need to find records that are tagged with ids 10 AND 12, you
+      # will need to use the :with_all search parameter. This is particuarly
+      # useful in conjunction with Multi Value Attributes (MVAs).
+      #
+      # The third filtering technique is only viable if you're searching with a
+      # specific model (not multi-model searching). With a single model,
+      # Thinking Sphinx can figure out what attributes and fields are available,
+      # so you can put it all in the :conditions hash, and it will sort it out.
       # 
       #   Node.search :conditions => {:parent_id => 10}
       # 
@@ -186,6 +194,12 @@ module ThinkingSphinx
       # documentation[http://sphinxsearch.com/doc.html] for that level of
       # detail though.
       #
+      # If desired, you can sort by a column in your model instead of a sphinx
+      # field or attribute. This sort only applies to the current page, so is
+      # most useful when performing a search with a single page of results.
+      #
+      #   User.search("pat", :sql_order => "name")
+      #
       # == Grouping
       # 
       # For this you can use the group_by, group_clause and group_function
@@ -291,8 +305,10 @@ module ThinkingSphinx
       def retry_search_on_stale_index(query, options, &block)
         stale_ids = []
         stale_retries_left = case options[:retry_stale]
-                              when true:       3  # default to three retries
-                              when nil, false: 0  # no retries
+                              when true
+                                3  # default to three retries
+                              when nil, false
+                                0  # no retries
                               else             options[:retry_stale].to_i
                               end
         begin
@@ -389,6 +405,7 @@ module ThinkingSphinx
         
         client.limit  = options[:per_page].to_i if options[:per_page]
         page          = options[:page] ? options[:page].to_i : 1
+        page          = 1 if page <= 0
         client.offset = (page - 1) * client.limit
 
         begin

data/spec/unit/thinking_sphinx/active_record/delta_spec.rb

@@ -76,7 +76,7 @@ describe "ThinkingSphinx::ActiveRecord::Delta" do
       
       @person = Person.new
       @person.stub_method(
-        :in_core_index?     => false,
+        :in_both_indexes?     => false,
         :sphinx_document_id => 1
       )
       
@@ -126,7 +126,7 @@ describe "ThinkingSphinx::ActiveRecord::Delta" do
     end
     
     it "should update the deleted attribute if in the core index" do
-      @person.stub_method(:in_core_index? => true)
+      @person.stub_method(:in_both_indexes? => true)
       
       @person.send(:index_delta)
       

data/spec/unit/thinking_sphinx/attribute_spec.rb

@@ -209,4 +209,19 @@ describe ThinkingSphinx::Attribute do
       attribute.send(:all_ints?).should be_false
     end
   end
+  
+  describe "with custom queries" do
+    before :each do
+      index = CricketTeam.sphinx_indexes.first
+      @statement = index.to_riddle_for_core(0, 0).sql_attr_multi.first
+    end
+    
+    it "should track the query type accordingly" do
+      @statement.should match(/uint tags from query/)
+    end
+    
+    it "should include the SQL statement" do
+      @statement.should match(/SELECT cricket_team_id, id FROM tags/)
+    end
+  end
 end

data/spec/unit/thinking_sphinx/index_spec.rb

@@ -51,4 +51,94 @@ describe ThinkingSphinx::Index do
       @index.infix_fields.should_not include(@field_b)
     end
   end
+  
+  describe "multi-value attribute as ranged-query with has-many association" do
+    before :each do 
+      @index = ThinkingSphinx::Index.new(Person) do
+        has tags(:id), :as => :tag_ids, :source => :ranged_query
+      end
+      @index.link!
+      
+      @sql = @index.to_riddle_for_core(0, 0).sql_query
+    end
+    
+    it "should not include attribute in select-clause sql_query" do
+      @sql.should_not match(/tag_ids/)
+      @sql.should_not match(/GROUP_CONCAT\(`tags`.`id`/)
+    end
+    
+    it "should not join with association table" do
+      @sql.should_not match(/LEFT OUTER JOIN `tags`/)
+    end
+    
+    it "should include sql_attr_multi as ranged-query" do
+      attribute = @index.send(:attributes).first
+      attribute.send(:type_to_config).to_s.should == "sql_attr_multi"
+      
+      declaration, query, range_query = attribute.send(: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"
+      range_query.should == "SELECT MIN(`tags`.`person_id`), MAX(`tags`.`person_id`) FROM `tags`"
+    end
+  end
+  
+  describe "multi-value attribute as ranged-query with has-many-through association" do
+    before :each do
+      @index = ThinkingSphinx::Index.new(Person) do
+        has football_teams(:id), :as => :football_teams_ids, :source => :ranged_query
+      end
+      @index.link!
+      
+      @sql = @index.to_riddle_for_core(0, 0).sql_query
+    end
+    
+    it "should not include attribute in select-clause sql_query" do
+      @sql.should_not match(/football_teams_ids/)
+      @sql.should_not match(/GROUP_CONCAT\(`tags`.`football_team_id`/)
+    end
+    
+    it "should not join with association table" do
+      @sql.should_not match(/LEFT OUTER JOIN `tags`/)
+    end
+    
+    it "should include sql_attr_multi as ranged-query" do
+      attribute = @index.send(:attributes).first
+      attribute.send(:type_to_config).to_s.should == "sql_attr_multi"
+      
+      declaration, query, range_query = attribute.send(:config_value).split('; ')
+      declaration.should == "uint football_teams_ids from ranged-query"
+      query.should       == "SELECT `tags`.`person_id` #{ThinkingSphinx.unique_id_expression} AS `id`, `tags`.`football_team_id` AS `football_teams_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 "multi-value attribute as ranged-query with has-many-through association and foreign_key" do
+    before :each do
+      @index = ThinkingSphinx::Index.new(Person) do
+        has friends(:id), :as => :friend_ids, :source => :ranged_query
+      end
+      @index.link!
+      
+      @sql = @index.to_riddle_for_core(0, 0).sql_query
+    end
+    
+    it "should not include attribute in select-clause sql_query" do
+      @sql.should_not match(/friend_ids/)
+      @sql.should_not match(/GROUP_CONCAT\(`friendships`.`friend_id`/)
+    end
+    
+    it "should not join with association table" do
+      @sql.should_not match(/LEFT OUTER JOIN `friendships`/)
+    end
+    
+    it "should include sql_attr_multi as ranged-query" do
+      attribute = @index.send(:attributes).first
+      attribute.send(:type_to_config).to_s.should == "sql_attr_multi"
+      
+      declaration, query, range_query = attribute.send(: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"
+      range_query.should == "SELECT MIN(`friendships`.`person_id`), MAX(`friendships`.`person_id`) FROM `friendships`"
+    end
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: freelancing-god-thinking-sphinx
 version: !ruby/object:Gem::Version 
-  version: 1.1.5
+  version: 1.1.6
 platform: ruby
 authors: 
 - Pat Allan
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-02-09 00:00:00 -08:00
+date: 2009-03-11 00:00:00 -07:00
 default_executable: 
 dependencies: []