freelancing-god-thinking-sphinx 1.1.18 → 1.1.19

data/README.textile

@@ -130,3 +130,4 @@ Since I first released this library, there's been quite a few people who have su
 * Anderson Dias
 * Jerome Riga
 * Tien Dung
+* Johannes Kaefer

data/lib/thinking_sphinx.rb

@@ -37,7 +37,7 @@ module ThinkingSphinx
   module Version #:nodoc:
     Major = 1
     Minor = 1
-    Tiny  = 18
+    Tiny  = 19
     
     String = [Major, Minor, Tiny].join('.')
   end

data/lib/thinking_sphinx/association.rb

@@ -103,13 +103,16 @@ module ThinkingSphinx
       if @reflection.options[:through]
         @reflection.source_reflection.options[:foreign_key] ||
         @reflection.source_reflection.primary_key_name
+      elsif @reflection.macro == :has_and_belongs_to_many
+        @reflection.association_foreign_key
       else
         nil
       end
     end
     
     def table
-      if @reflection.options[:through]
+      if @reflection.options[:through] ||
+        @reflection.macro == :has_and_belongs_to_many
         @join.aliased_join_table_name
       else
         @join.aliased_table_name

data/lib/thinking_sphinx/attribute.rb

@@ -127,7 +127,7 @@ module ThinkingSphinx
     def config_value(offset = nil)
       if type == :multi
         multi_config = include_as_association? ? "field" :
-          source_value(offset).gsub(/\n\s*/, " ")
+          source_value(offset).gsub(/\n\s*/, " ").strip
         "uint #{unique_name} from #{multi_config}"
       else
         unique_name

data/lib/thinking_sphinx/configuration.rb

@@ -54,6 +54,8 @@ module ThinkingSphinx
       min_infix_len min_prefix_len min_word_len mlock morphology ngram_chars
       ngram_len phrase_boundary phrase_boundary_step preopen stopwords
       wordforms )
+    
+    CustomOptions = %w( disable_range )
         
     attr_accessor :config_file, :searchd_log_file, :query_log_file,
       :pid_file, :searchd_file_path, :address, :port, :allow_star,
@@ -149,6 +151,8 @@ module ThinkingSphinx
     # messy dependencies issues).
     # 
     def load_models
+      return if defined?(Rails) && Rails.configuration.cache_classes
+      
       self.model_directories.each do |base|
         Dir["#{base}**/*.rb"].each do |file|
           model_name = file.gsub(/^#{base}([\w_\/\\]+)\.rb/, '\1')
@@ -225,6 +229,7 @@ module ThinkingSphinx
         
         set_sphinx_setting self.source_options, key, value, SourceOptions
         set_sphinx_setting self.index_options,  key, value, IndexOptions
+        set_sphinx_setting self.index_options,  key, value, CustomOptions
         set_sphinx_setting @configuration.searchd, key, value
         set_sphinx_setting @configuration.indexer, key, value
       end unless conf.nil?

data/lib/thinking_sphinx/index.rb

@@ -63,7 +63,8 @@ module ThinkingSphinx
     def options
       all_index_options = ThinkingSphinx::Configuration.instance.index_options.clone
       @options.keys.select { |key|
-        ThinkingSphinx::Configuration::IndexOptions.include?(key.to_s)
+        ThinkingSphinx::Configuration::IndexOptions.include?(key.to_s) ||
+        ThinkingSphinx::Configuration::CustomOptions.include?(key.to_s)
       }.each { |key| all_index_options[key.to_sym] = @options[key] }
       all_index_options
     end

data/lib/thinking_sphinx/source/sql.rb

@@ -17,7 +17,7 @@ module ThinkingSphinx
 SELECT #{ sql_select_clause options[:offset] }
 FROM #{ @model.quoted_table_name }
   #{ all_associations.collect { |assoc| assoc.to_sql }.join(' ') }
-WHERE #{ sql_where_clause(options) }
+#{ sql_where_clause(options) }
 GROUP BY #{ sql_group_clause }
         SQL
 
@@ -30,6 +30,8 @@ GROUP BY #{ sql_group_clause }
       # so pass in :delta => true to get the delta version of the SQL.
       # 
       def to_sql_query_range(options={})
+        return nil if @index.options[:disable_range]
+        
         min_statement = adapter.convert_nulls(
           "MIN(#{quote_column(@model.primary_key)})", 1
         )
@@ -65,18 +67,18 @@ GROUP BY #{ sql_group_clause }
       end
 
       def sql_where_clause(options)
-        logic = [
+        logic = []
+        logic += [
           "#{@model.quoted_table_name}.#{quote_column(@model.primary_key)} >= $start",
           "#{@model.quoted_table_name}.#{quote_column(@model.primary_key)} <= $end"
-        ]
+        ] unless @index.options[:disable_range]
 
         if self.delta? && !@index.delta_object.clause(@model, options[:delta]).blank?
           logic << "#{@index.delta_object.clause(@model, options[:delta])}"
         end
 
         logic += (@conditions || [])
-
-        logic.join(" AND ")
+        logic.empty? ? "" : "WHERE #{logic.join(' AND ')}"
       end
 
       def sql_group_clause

data/spec/unit/thinking_sphinx/attribute_spec.rb

@@ -215,6 +215,112 @@ describe ThinkingSphinx::Attribute do
     end
   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
+    
+    it "should use a query" do
+      @attribute.type_to_config.should == :sql_attr_multi
+      
+      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`"
+    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
+    
+    it "should use a ranged query" do
+      @attribute.type_to_config.should == :sql_attr_multi
+      
+      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`"
+    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
+    
+    it "should use a ranged query" do
+      @attribute.type_to_config.should == :sql_attr_multi
+      
+      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"
+      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
+    
+    it "should use a ranged query" do
+      @attribute.type_to_config.should == :sql_attr_multi
+      
+      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"
+      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
+    
+    it "should use a ranged query" do
+      @attribute.type_to_config.should == :sql_attr_multi
+      
+      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"
+      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
+    
+    it "should use a ranged query" do
+      @attribute.type_to_config.should == :sql_attr_multi
+      
+      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"
+      range_query.should == "SELECT MIN(`links_people`.`person_id`), MAX(`links_people`.`person_id`) FROM `links_people`"
+    end
+  end
+  
   describe "with custom queries" do
     before :each do
       index = CricketTeam.sphinx_indexes.first

data/spec/unit/thinking_sphinx/configuration_spec.rb

@@ -102,6 +102,25 @@ describe ThinkingSphinx::Configuration do
     end
   end
   
+  describe "index options" do
+    before :each do
+      @settings = {
+        "development" => {"disable_range" => true}
+      }
+      
+      open("#{RAILS_ROOT}/config/sphinx.yml", "w") do |f|
+        f.write  YAML.dump(@settings)
+      end
+      
+      @config = ThinkingSphinx::Configuration.instance
+      @config.send(:parse_config)
+    end
+    
+    it "should collect disable_range" do
+      @config.index_options[:disable_range].should be_true
+    end
+  end
+  
   it "should insert set index options into the configuration file" do
     config = ThinkingSphinx::Configuration.instance
     ThinkingSphinx::Configuration::IndexOptions.each do |option|

data/spec/unit/thinking_sphinx/index_spec.rb

@@ -42,98 +42,4 @@ 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::Builder.generate(Person) do
-        indexes first_name
-        has tags(:id), :as => :tag_ids, :source => :ranged_query
-      end
-      
-      @sql = @index.sources.first.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.attributes.detect { |attrib| attrib.unique_name == :tag_ids }
-      attribute.type_to_config.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::Builder.generate(Person) do
-        indexes first_name
-        has football_teams(:id), :as => :football_teams_ids, :source => :ranged_query
-      end
-      
-      @sql = @index.sources.first.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.attributes.detect { |attrib|
-        attrib.unique_name == :football_teams_ids
-      }
-      attribute.type_to_config.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::Builder.generate(Person) do
-        indexes first_name
-        has friends(:id), :as => :friend_ids, :source => :ranged_query
-      end
-      
-      @sql = @index.sources.first.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.attributes.detect { |attrib|
-        attrib.unique_name == :friend_ids
-      }
-      attribute.type_to_config.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

data/spec/unit/thinking_sphinx/source_spec.rb

@@ -37,6 +37,10 @@ describe ThinkingSphinx::Source do
       ThinkingSphinx::Attribute.new(
         @source, ThinkingSphinx::Index::FauxColumn.new(:tags, :id), :as => :tag_ids
       )
+      ThinkingSphinx::Attribute.new(
+        @source, ThinkingSphinx::Index::FauxColumn.new(:contacts, :id),
+        :as => :contact_ids, :source => :query
+      )
       
       @source.conditions << "`birthday` <= NOW()"
       @source.groupings  << "`first_name`"
@@ -102,10 +106,18 @@ describe ThinkingSphinx::Source do
         @query.should match(/`tags`.`id`.+ AS `tag_ids`.+FROM/)
       end
       
+      it "should not match the sourced MVA attribute" do
+        @query.should_not match(/contact_ids/)
+      end
+      
       it "should include joins for required associations" do
         @query.should match(/LEFT OUTER JOIN `tags`/)
       end
       
+      it "should not include joins for the sourced MVA attribute" do
+        @query.should_not match(/LEFT OUTER JOIN `contacts`/)
+      end
+      
       it "should include any defined conditions" do
         @query.should match(/WHERE.+`birthday` <= NOW()/)
       end
@@ -162,4 +174,44 @@ describe ThinkingSphinx::Source do
       end
     end
   end
+  
+  describe "#to_riddle_for_core with range disabled" do
+    before :each do
+      ThinkingSphinx::Field.new(
+        @source, ThinkingSphinx::Index::FauxColumn.new(:first_name)
+      )
+    end
+    
+    describe "set per-index" do
+      before :each do
+        @index.local_options[:disable_range] = true
+        @riddle = @source.to_riddle_for_core(1, 0)
+      end
+      
+      it "should not have the range in the sql_query" do
+        @riddle.sql_query.should_not match(/`people`.`id` >= \$start/)
+        @riddle.sql_query.should_not match(/`people`.`id` <= \$end/)
+      end
+    
+      it "should not have a sql_query_range" do
+        @riddle.sql_query_range.should be_nil
+      end
+    end
+    
+    describe "set globally" do
+      before :each do
+        ThinkingSphinx::Configuration.instance.index_options[:disable_range] = true
+        @riddle = @source.to_riddle_for_core(1, 0)
+      end
+      
+      it "should not have the range in the sql_query" do
+        @riddle.sql_query.should_not match(/`people`.`id` >= \$start/)
+        @riddle.sql_query.should_not match(/`people`.`id` <= \$end/)
+      end
+    
+      it "should not have a sql_query_range" do
+        @riddle.sql_query_range.should be_nil
+      end
+    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.18
+  version: 1.1.19
 platform: ruby
 authors: 
 - Pat Allan
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-05-27 00:00:00 -07:00
+date: 2009-06-01 00:00:00 -07:00
 default_executable: 
 dependencies: []