thinking-sphinx 1.2.13 → 1.4.0

data/lib/thinking_sphinx/active_record.rb

@@ -12,7 +12,11 @@ module ThinkingSphinx
     def self.included(base)
       base.class_eval do
         class_inheritable_array :sphinx_indexes, :sphinx_facets
+        
+        extend ThinkingSphinx::ActiveRecord::ClassMethods
+        
         class << self
+          attr_accessor :sphinx_index_blocks
           
           def set_sphinx_primary_key(attribute)
             @sphinx_primary_key_attribute = attribute
@@ -22,93 +26,6 @@ module ThinkingSphinx
             @sphinx_primary_key_attribute || primary_key
           end
           
-          # Allows creation of indexes for Sphinx. If you don't do this, there
-          # isn't much point trying to search (or using this plugin at all,
-          # really).
-          #
-          # An example or two:
-          #
-          #   define_index
-          #     indexes :id, :as => :model_id
-          #     indexes name
-          #   end
-          #
-          # You can also grab fields from associations - multiple levels deep
-          # if necessary.
-          #
-          #   define_index do
-          #     indexes tags.name, :as => :tag
-          #     indexes articles.content
-          #     indexes orders.line_items.product.name, :as => :product
-          #   end
-          #
-          # And it will automatically concatenate multiple fields:
-          #
-          #   define_index do
-          #     indexes [author.first_name, author.last_name], :as => :author
-          #   end
-          #
-          # The #indexes method is for fields - if you want attributes, use
-          # #has instead. All the same rules apply - but keep in mind that
-          # attributes are for sorting, grouping and filtering, not searching.
-          #
-          #   define_index do
-          #     # fields ...
-          #     
-          #     has created_at, updated_at
-          #   end
-          #
-          # One last feature is the delta index. This requires the model to
-          # have a boolean field named 'delta', and is enabled as follows:
-          #
-          #   define_index do
-          #     # fields ...
-          #     # attributes ...
-          #     
-          #     set_property :delta => true
-          #   end
-          #
-          # Check out the more detailed documentation for each of these methods
-          # at ThinkingSphinx::Index::Builder.
-          # 
-          def define_index(&block)
-            return unless ThinkingSphinx.define_indexes?
-            
-            self.sphinx_indexes ||= []
-            self.sphinx_facets  ||= []
-            index = ThinkingSphinx::Index::Builder.generate(self, &block)
-            
-            self.sphinx_indexes << index
-            unless ThinkingSphinx.indexed_models.include?(self.name)
-              ThinkingSphinx.indexed_models << self.name
-            end
-            
-            if index.delta?
-              before_save   :toggle_delta
-              after_commit  :index_delta
-            end
-            
-            after_destroy :toggle_deleted
-            
-            include ThinkingSphinx::SearchMethods
-            include ThinkingSphinx::ActiveRecord::AttributeUpdates
-            include ThinkingSphinx::ActiveRecord::Scopes
-            
-            index
-            
-            # We want to make sure that if the database doesn't exist, then Thinking
-            # Sphinx doesn't mind when running non-TS tasks (like db:create, db:drop
-            # and db:migrate). It's a bit hacky, but I can't think of a better way.
-          rescue StandardError => err
-            case err.class.name
-            when "Mysql::Error", "Java::JavaSql::SQLException", "ActiveRecord::StatementInvalid"
-              return
-            else
-              raise err
-            end
-          end
-          alias_method :sphinx_index, :define_index
-          
           def sphinx_index_options
             sphinx_indexes.last.options
           end
@@ -127,26 +44,6 @@ module ThinkingSphinx
             (subclasses << self).collect { |klass| klass.to_crc32 }
           end
           
-          def source_of_sphinx_index
-            possible_models = self.sphinx_indexes.collect { |index| index.model }
-            return self if possible_models.include?(self)
-
-            parent = self.superclass
-            while !possible_models.include?(parent) && parent != ::ActiveRecord::Base
-              parent = parent.superclass
-            end
-
-            return parent
-          end
-          
-          def to_riddle(offset)
-            sphinx_database_adapter.setup
-            
-            indexes = [to_riddle_for_core(offset)]
-            indexes << to_riddle_for_delta(offset) if sphinx_delta?
-            indexes << to_riddle_for_distributed
-          end
-          
           def sphinx_database_adapter
             @sphinx_database_adapter ||=
               ThinkingSphinx::AbstractAdapter.detect(self)
@@ -156,86 +53,36 @@ module ThinkingSphinx
             self.name.underscore.tr(':/\\', '_')
           end
           
-          def sphinx_index_names
-            klass = source_of_sphinx_index
-            names = ["#{klass.sphinx_name}_core"]
-            names << "#{klass.sphinx_name}_delta" if sphinx_delta?
-            
-            names
+          #
+          # The above method to_crc32s is dependant on the subclasses being loaded consistently
+          # After a reset_subclasses is called (during a Dispatcher.cleanup_application in development)
+          # Our subclasses will be lost but our context will not reload them for us.
+          #
+          # We reset the context which causes the subclasses to be reloaded next time the context is called.
+          #
+          def reset_subclasses_with_thinking_sphinx
+            reset_subclasses_without_thinking_sphinx
+            ThinkingSphinx.reset_context!
           end
           
-          private
-          
-          def sphinx_delta?
-            self.sphinx_indexes.any? { |index| index.delta? }
-          end
+          alias_method_chain :reset_subclasses, :thinking_sphinx
           
-          def to_riddle_for_core(offset)
-            index = Riddle::Configuration::Index.new("#{sphinx_name}_core")
-            index.path = File.join(
-              ThinkingSphinx::Configuration.instance.searchd_file_path, index.name
-            )
-            
-            set_configuration_options_for_indexes index
-            set_field_settings_for_indexes        index
-            
-            self.sphinx_indexes.select { |ts_index|
-              ts_index.model == self
-            }.each_with_index do |ts_index, i|
-              index.sources += ts_index.sources.collect { |source|
-                source.to_riddle_for_core(offset, i)
-              }
-            end
-            
-            index
-          end
-          
-          def to_riddle_for_delta(offset)
-            index = Riddle::Configuration::Index.new("#{sphinx_name}_delta")
-            index.parent = "#{sphinx_name}_core"
-            index.path = File.join(ThinkingSphinx::Configuration.instance.searchd_file_path, index.name)
-            
-            self.sphinx_indexes.each_with_index do |ts_index, i|
-              index.sources += ts_index.sources.collect { |source|
-                source.to_riddle_for_delta(offset, i)
-              } if ts_index.delta?
-            end
-            
-            index
-          end
+          private
           
-          def to_riddle_for_distributed
-            index = Riddle::Configuration::DistributedIndex.new(sphinx_name)
-            index.local_indexes << "#{sphinx_name}_core"
-            index.local_indexes.unshift "#{sphinx_name}_delta" if sphinx_delta?
-            index
+          def defined_indexes?
+            @defined_indexes
           end
           
-          def set_configuration_options_for_indexes(index)
-            ThinkingSphinx::Configuration.instance.index_options.each do |key, value|
-              index.send("#{key}=".to_sym, value)
-            end
-            
-            self.sphinx_indexes.each do |ts_index|
-              ts_index.options.each do |key, value|
-                index.send("#{key}=".to_sym, value) if ThinkingSphinx::Configuration::IndexOptions.include?(key.to_s) && !value.nil?
-              end
-            end
+          def defined_indexes=(value)
+            @defined_indexes = value
           end
           
-          def set_field_settings_for_indexes(index)
-            field_names = lambda { |field| field.unique_name.to_s }
-            
-            self.sphinx_indexes.each do |ts_index|
-              index.prefix_field_names += ts_index.prefix_fields.collect(&field_names)
-              index.infix_field_names  += ts_index.infix_fields.collect(&field_names)
-            end
+          def sphinx_delta?
+            self.sphinx_indexes.any? { |index| index.delta? }
           end
         end
       end
       
-      base.send(:include, ThinkingSphinx::ActiveRecord::Delta)
-      
       ::ActiveRecord::Associations::HasManyAssociation.send(
         :include, ThinkingSphinx::ActiveRecord::HasManyAssociation
       )
@@ -244,6 +91,241 @@ module ThinkingSphinx
       )
     end
     
+    module ClassMethods
+      # Allows creation of indexes for Sphinx. If you don't do this, there
+      # isn't much point trying to search (or using this plugin at all,
+      # really).
+      #
+      # An example or two:
+      #
+      #   define_index
+      #     indexes :id, :as => :model_id
+      #     indexes name
+      #   end
+      #
+      # You can also grab fields from associations - multiple levels deep
+      # if necessary.
+      #
+      #   define_index do
+      #     indexes tags.name, :as => :tag
+      #     indexes articles.content
+      #     indexes orders.line_items.product.name, :as => :product
+      #   end
+      #
+      # And it will automatically concatenate multiple fields:
+      #
+      #   define_index do
+      #     indexes [author.first_name, author.last_name], :as => :author
+      #   end
+      #
+      # The #indexes method is for fields - if you want attributes, use
+      # #has instead. All the same rules apply - but keep in mind that
+      # attributes are for sorting, grouping and filtering, not searching.
+      #
+      #   define_index do
+      #     # fields ...
+      #     
+      #     has created_at, updated_at
+      #   end
+      #
+      # One last feature is the delta index. This requires the model to
+      # have a boolean field named 'delta', and is enabled as follows:
+      #
+      #   define_index do
+      #     # fields ...
+      #     # attributes ...
+      #     
+      #     set_property :delta => true
+      #   end
+      #
+      # Check out the more detailed documentation for each of these methods
+      # at ThinkingSphinx::Index::Builder.
+      # 
+      def define_index(name = nil, &block)
+        self.sphinx_index_blocks ||= []
+        self.sphinx_indexes      ||= []
+        self.sphinx_facets       ||= []
+        
+        ThinkingSphinx.context.add_indexed_model self
+        
+        if sphinx_index_blocks.empty?
+          before_validation :define_indexes
+          before_destroy    :define_indexes
+        end
+        
+        self.sphinx_index_blocks << lambda {
+          add_sphinx_index name, &block
+        }
+        
+        include ThinkingSphinx::ActiveRecord::Scopes
+        include ThinkingSphinx::SearchMethods
+      end
+      
+      def define_indexes
+        superclass.define_indexes unless superclass == ::ActiveRecord::Base
+        
+        return if sphinx_index_blocks.nil? ||
+          defined_indexes?                 ||
+          !ThinkingSphinx.define_indexes?
+        
+        sphinx_index_blocks.each do |block|
+          block.call
+        end
+        
+        self.defined_indexes = true
+        
+        # We want to make sure that if the database doesn't exist, then Thinking
+        # Sphinx doesn't mind when running non-TS tasks (like db:create, db:drop
+        # and db:migrate). It's a bit hacky, but I can't think of a better way.
+      rescue StandardError => err
+        case err.class.name
+        when "Mysql::Error", "Java::JavaSql::SQLException", "ActiveRecord::StatementInvalid"
+          return
+        else
+          raise err
+        end
+      end
+      
+      def add_sphinx_index(name, &block)
+        index = ThinkingSphinx::Index::Builder.generate self, name, &block
+
+        unless sphinx_indexes.any? { |i| i.name == index.name }
+          add_sphinx_callbacks_and_extend(index.delta?)
+          insert_sphinx_index index
+        end
+      end
+      
+      def insert_sphinx_index(index)
+        self.sphinx_indexes << index
+        subclasses.each { |klass| klass.insert_sphinx_index(index) }
+      end
+      
+      def has_sphinx_indexes?
+        sphinx_indexes      && 
+        sphinx_index_blocks &&
+        (sphinx_indexes.length > 0 || sphinx_index_blocks.length > 0)
+      end
+      
+      def indexed_by_sphinx?
+        sphinx_indexes && sphinx_indexes.length > 0
+      end
+      
+      def delta_indexed_by_sphinx?
+        sphinx_indexes && sphinx_indexes.any? { |index| index.delta? }
+      end
+      
+      def sphinx_index_names
+        define_indexes
+        sphinx_indexes.collect(&:all_names).flatten
+      end
+      
+      def core_index_names
+        define_indexes
+        sphinx_indexes.collect(&:core_name)
+      end
+      
+      def delta_index_names
+        define_indexes
+        sphinx_indexes.select(&:delta?).collect(&:delta_name)
+      end
+      
+      def to_riddle
+        define_indexes
+        sphinx_database_adapter.setup
+        
+        local_sphinx_indexes.collect { |index|
+          index.to_riddle(sphinx_offset)
+        }.flatten
+      end
+      
+      def source_of_sphinx_index
+        define_indexes
+        possible_models = self.sphinx_indexes.collect { |index| index.model }
+        return self if possible_models.include?(self)
+
+        parent = self.superclass
+        while !possible_models.include?(parent) && parent != ::ActiveRecord::Base
+          parent = parent.superclass
+        end
+
+        return parent
+      end
+      
+      def delete_in_index(index, document_id)
+        return unless ThinkingSphinx.sphinx_running? &&
+          search_for_id(document_id, index)
+        
+        ThinkingSphinx::Configuration.instance.client.update(
+          index, ['sphinx_deleted'], {document_id => [1]}
+        )
+      end
+      
+      def sphinx_offset
+        ThinkingSphinx.context.superclass_indexed_models.
+          index eldest_indexed_ancestor
+      end
+      
+      # Temporarily disable delta indexing inside a block, then perform a single
+      # rebuild of index at the end.
+      #
+      # Useful when performing updates to batches of models to prevent
+      # the delta index being rebuilt after each individual update.
+      #
+      # In the following example, the delta index will only be rebuilt once,
+      # not 10 times.
+      #
+      #   SomeModel.suspended_delta do
+      #     10.times do
+      #       SomeModel.create( ... )
+      #     end
+      #   end
+      #
+      def suspended_delta(reindex_after = true, &block)
+        define_indexes
+        original_setting = ThinkingSphinx.deltas_enabled?
+        ThinkingSphinx.deltas_enabled = false
+        begin
+          yield
+        ensure
+          ThinkingSphinx.deltas_enabled = original_setting
+          self.index_delta if reindex_after
+        end
+      end
+      
+      private
+            
+      def local_sphinx_indexes
+        sphinx_indexes.select { |index|
+          index.model == self
+        }
+      end
+      
+      def add_sphinx_callbacks_and_extend(delta = false)
+        unless indexed_by_sphinx?
+          after_destroy :toggle_deleted
+          
+          include ThinkingSphinx::ActiveRecord::AttributeUpdates
+        end
+        
+        if delta && !delta_indexed_by_sphinx?
+          include ThinkingSphinx::ActiveRecord::Delta
+          
+          before_save   :toggle_delta
+          after_commit  :index_delta
+        end
+      end
+      
+      def eldest_indexed_ancestor
+        ancestors.reverse.detect { |ancestor|
+          ThinkingSphinx.context.indexed_models.include?(ancestor.name)
+        }.name
+      end
+    end
+    
+    attr_accessor :excerpts
+    attr_accessor :sphinx_attributes
+    attr_accessor :matching_fields
+    
     def in_index?(suffix)
       self.class.search_for_id self.sphinx_document_id, sphinx_index_name(suffix)
     end
@@ -261,23 +343,15 @@ module ThinkingSphinx
     end
     
     def toggle_deleted
-      return unless ThinkingSphinx.updates_enabled? && ThinkingSphinx.sphinx_running?
-      
-      config = ThinkingSphinx::Configuration.instance
-      client = Riddle::Client.new config.address, config.port
+      return unless ThinkingSphinx.updates_enabled?
       
-      client.update(
-        "#{self.class.sphinx_indexes.first.name}_core",
-        ['sphinx_deleted'],
-        {self.sphinx_document_id => 1}
-      ) if self.in_core_index?
+      self.class.core_index_names.each do |index_name|
+        self.class.delete_in_index index_name, self.sphinx_document_id
+      end
+      self.class.delta_index_names.each do |index_name|
+        self.class.delete_in_index index_name, self.sphinx_document_id
+      end if self.class.delta_indexed_by_sphinx? && toggled_delta?
       
-      client.update(
-        "#{self.class.sphinx_indexes.first.name}_delta",
-        ['sphinx_deleted'],
-        {self.sphinx_document_id => 1}
-      ) if self.class.sphinx_indexes.any? { |index| index.delta? } &&
-        self.toggled_delta?
     rescue ::ThinkingSphinx::ConnectionError
       # nothing
     end
@@ -289,12 +363,12 @@ module ThinkingSphinx
     # @return [Integer] Unique record id for the purposes of Sphinx.
     # 
     def primary_key_for_sphinx
-      @primary_key_for_sphinx ||= read_attribute(self.class.primary_key_for_sphinx)
+      read_attribute(self.class.primary_key_for_sphinx)
     end
     
     def sphinx_document_id
-      primary_key_for_sphinx * ThinkingSphinx.indexed_models.size +
-        ThinkingSphinx.indexed_models.index(self.class.source_of_sphinx_index.name)
+      primary_key_for_sphinx * ThinkingSphinx.context.indexed_models.size +
+        self.class.sphinx_offset
     end
 
     private
@@ -302,5 +376,9 @@ module ThinkingSphinx
     def sphinx_index_name(suffix)
       "#{self.class.source_of_sphinx_index.name.underscore.tr(':/\\', '_')}_#{suffix}"
     end
+    
+    def define_indexes
+      self.class.define_indexes
+    end
   end
 end

data/lib/thinking_sphinx/adapters/abstract_adapter.rb

@@ -10,22 +10,50 @@ module ThinkingSphinx
     end
       
     def self.detect(model)
+      adapter = adapter_for_model model
+      case adapter
+      when :mysql
+        ThinkingSphinx::MysqlAdapter.new model
+      when :postgresql
+        ThinkingSphinx::PostgreSQLAdapter.new model
+      else
+        raise "Invalid Database Adapter: Sphinx only supports MySQL and PostgreSQL, not #{adapter}"
+      end
+    end
+    
+    def self.adapter_for_model(model)
+      case ThinkingSphinx.database_adapter
+      when String
+        ThinkingSphinx.database_adapter.to_sym
+      when NilClass
+        standard_adapter_for_model model
+      when Proc
+        ThinkingSphinx.database_adapter.call model
+      else
+        ThinkingSphinx.database_adapter
+      end
+    end
+    
+    def self.standard_adapter_for_model(model)
       case model.connection.class.name
       when "ActiveRecord::ConnectionAdapters::MysqlAdapter",
-           "ActiveRecord::ConnectionAdapters::MysqlplusAdapter"
-        ThinkingSphinx::MysqlAdapter.new model
+           "ActiveRecord::ConnectionAdapters::MysqlplusAdapter",
+           "ActiveRecord::ConnectionAdapters::Mysql2Adapter",
+           "ActiveRecord::ConnectionAdapters::NullDBAdapter"
+        :mysql
       when "ActiveRecord::ConnectionAdapters::PostgreSQLAdapter"
-        ThinkingSphinx::PostgreSQLAdapter.new model
+        :postgresql
       when "ActiveRecord::ConnectionAdapters::JdbcAdapter"
-        if model.connection.config[:adapter] == "jdbcmysql"
-          ThinkingSphinx::MysqlAdapter.new model
-        elsif model.connection.config[:adapter] == "jdbcpostgresql"
-          ThinkingSphinx::PostgreSQLAdapter.new model
+        case model.connection.config[:adapter]
+        when "jdbcmysql"
+          :mysql
+        when "jdbcpostgresql"
+          :postgresql
         else
-          raise "Invalid Database Adapter: Sphinx only supports MySQL and PostgreSQL"
+          model.connection.config[:adapter]
         end
       else
-        raise "Invalid Database Adapter: Sphinx only supports MySQL and PostgreSQL, not #{model.connection.class.name}"
+        model.connection.class.name
       end
     end
     
@@ -33,6 +61,14 @@ module ThinkingSphinx
       "#{@model.quoted_table_name}.#{@model.connection.quote_column_name(column)}"
     end
     
+    def bigint_pattern
+      /bigint/i
+    end
+    
+    def downcase(clause)
+      "LOWER(#{clause})"
+    end
+    
     protected
     
     def connection

data/lib/thinking_sphinx/adapters/mysql_adapter.rb

@@ -50,5 +50,9 @@ module ThinkingSphinx
     def time_difference(diff)
       "DATE_SUB(NOW(), INTERVAL #{diff} SECOND)"
     end
+    
+    def utc_query_pre
+      "SET TIME_ZONE = '+0:00'"
+    end
   end
-end
+end

data/lib/thinking_sphinx/adapters/postgresql_adapter.rb

@@ -67,6 +67,10 @@ module ThinkingSphinx
       "current_timestamp - interval '#{diff} seconds'"
     end
     
+    def utc_query_pre
+      "SET TIME ZONE 'UTC'"
+    end
+    
     private
     
     def execute(command, output_error = false)
@@ -115,6 +119,10 @@ module ThinkingSphinx
           DECLARE j int;
           DECLARE word_array bytea;
           BEGIN
+            IF COALESCE(word, '') = '' THEN
+              return 0;
+            END IF;
+          
             i = 0;
             tmp = 4294967295;
             word_array = decode(replace(word, E'\\\\', E'\\\\\\\\'), 'escape');
@@ -135,7 +143,7 @@ module ThinkingSphinx
             END LOOP;
             return (tmp # 4294967295);
           END
-        $$ IMMUTABLE STRICT LANGUAGE plpgsql;
+        $$ IMMUTABLE LANGUAGE plpgsql;
       SQL
       execute function, true
     end