freelancing-god-thinking-sphinx 0.9.8 → 0.9.10

data/README

@@ -54,4 +54,23 @@ Since I first released this library, there's been quite a few people who have su
 - Andrew Bennett
 - Jordan Fowler
 - Seth Walker
-- Joe Noon
+- Joe Noon
+- Wolfgang Postler
+- Rick Olson
+- Killian Murphy
+- Morten Primdahl
+- Ryan Bates
+- David Eisinger
+- Shay Arnett
+- Minh Tran
+- Jeremy Durham
+- Piotr Sarnacki
+- Matt Johnson
+- Nicolas Blanco
+- Max Lapshin
+- Josh Natanson
+- Philip Hallstrom
+- Christian Rishøj
+- Mike Flester
+- Jim Remsik
+- Kennon Ballou

data/lib/thinking_sphinx.rb

@@ -1,15 +1,25 @@
+Dir[File.join(File.dirname(__FILE__), '../vendor/*/lib')].each do |path|
+  $LOAD_PATH.unshift path
+end
+
 require 'active_record'
 require 'riddle'
+require 'after_commit'
 
 require 'thinking_sphinx/active_record'
 require 'thinking_sphinx/association'
 require 'thinking_sphinx/attribute'
+require 'thinking_sphinx/collection'
 require 'thinking_sphinx/configuration'
 require 'thinking_sphinx/field'
 require 'thinking_sphinx/index'
 require 'thinking_sphinx/rails_additions'
 require 'thinking_sphinx/search'
 
+require 'thinking_sphinx/adapters/abstract_adapter'
+require 'thinking_sphinx/adapters/mysql_adapter'
+require 'thinking_sphinx/adapters/postgresql_adapter'
+
 ActiveRecord::Base.send(:include, ThinkingSphinx::ActiveRecord)
 
 Merb::Plugins.add_rakefiles(
@@ -20,7 +30,7 @@ module ThinkingSphinx
   module Version #:nodoc:
     Major = 0
     Minor = 9
-    Tiny  = 8
+    Tiny  = 10
     
     String = [Major, Minor, Tiny].join('.')
   end
@@ -58,7 +68,7 @@ module ThinkingSphinx
   # 
   def self.deltas_enabled?
     @@deltas_enabled  = (ThinkingSphinx::Configuration.environment != 'test') if @@deltas_enabled.nil?
-    @@deltas_enabled == true
+    @@deltas_enabled
   end
   
   # Enable/disable all delta indexing.
@@ -69,6 +79,24 @@ module ThinkingSphinx
     @@deltas_enabled = value
   end
   
+  @@updates_enabled = nil
+  
+  # Check if updates are enabled. True by default, unless within the test
+  # environment.
+  # 
+  def self.updates_enabled?
+    @@updates_enabled  = (ThinkingSphinx::Configuration.environment != 'test') if @@updates_enabled.nil?
+    @@updates_enabled
+  end
+  
+  # Enable/disable updates to Sphinx
+  # 
+  #   ThinkingSphinx.updates_enabled = false
+  #
+  def self.updates_enabled=(value)
+    @@updates_enabled = value
+  end
+  
   # Checks to see if MySQL will allow simplistic GROUP BY statements. If not,
   # or if not using MySQL, this will return false.
   # 

data/lib/thinking_sphinx/active_record.rb

@@ -5,12 +5,12 @@ require 'thinking_sphinx/active_record/has_many_association'
 module ThinkingSphinx
   # Core additions to ActiveRecord models - define_index for creating indexes
   # for models. If you want to interrogate the index objects created for the
-  # model, you can use the class-level accessor :indexes.
+  # model, you can use the class-level accessor :sphinx_indexes.
   #
   module ActiveRecord
     def self.included(base)
       base.class_eval do
-        class_inheritable_array :indexes
+        class_inheritable_array :sphinx_indexes
         class << self
           # 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,
@@ -64,10 +64,10 @@ module ThinkingSphinx
           def define_index(&block)
             return unless ThinkingSphinx.define_indexes?
             
-            self.indexes ||= []
+            self.sphinx_indexes ||= []
             index = Index.new(self, &block)
             
-            self.indexes << index
+            self.sphinx_indexes << index
             unless ThinkingSphinx.indexed_models.include?(self.name)
               ThinkingSphinx.indexed_models << self.name
             end
@@ -99,6 +99,10 @@ module ThinkingSphinx
             end
             result ^ 0xFFFFFFFF
           end
+          
+          def to_crc32s
+            (subclasses << self).collect { |klass| klass.to_crc32 }
+          end
         end
       end
       
@@ -114,26 +118,36 @@ module ThinkingSphinx
     end
     
     def in_core_index?
-      @in_core_index ||= self.class.search_for_id(self.id, "#{self.class.name.downcase}_core")
+      self.class.search_for_id(
+        self.sphinx_document_id,
+        "#{self.class.name.underscore.tr(':/\\', '_')}_core"
+      )
     end
     
     def toggle_deleted
-      config = ThinkingSphinx::Configuration.new
+      return unless ThinkingSphinx.updates_enabled?
+      
+      config = ThinkingSphinx::Configuration.instance
       client = Riddle::Client.new config.address, config.port
       
       client.update(
-        "#{self.class.indexes.first.name}_core",
+        "#{self.class.sphinx_indexes.first.name}_core",
         ['sphinx_deleted'],
-        {self.id => 1}
+        {self.sphinx_document_id => 1}
       ) if self.in_core_index?
       
       client.update(
-        "#{self.class.indexes.first.name}_delta",
+        "#{self.class.sphinx_indexes.first.name}_delta",
         ['sphinx_deleted'],
-        {self.id => 1}
+        {self.sphinx_document_id => 1}
       ) if ThinkingSphinx.deltas_enabled? &&
-        self.class.indexes.any? { |index| index.delta? } &&
+        self.class.sphinx_indexes.any? { |index| index.delta? } &&
         self.delta?
     end
+    
+    def sphinx_document_id
+      (self.id * ThinkingSphinx.indexed_models.size) +
+        ThinkingSphinx.indexed_models.index(self.class.name)
+    end
   end
 end

data/lib/thinking_sphinx/active_record/delta.rb

@@ -11,57 +11,55 @@ module ThinkingSphinx
       #
       def self.included(base)
         base.class_eval do
-          # The define_callbacks method was added post Rails 2.0.2 - if it
-          # doesn't exist, we define the callback manually
-          #
-          if respond_to?(:define_callbacks)
-            define_callbacks :after_commit
-          else
-            class << self
-              # Handle after_commit callbacks - call all the registered callbacks.
-              #
-              def after_commit(*callbacks, &block)
-                callbacks << block if block_given?
-                write_inheritable_array(:after_commit, callbacks)
+          class << self
+            # 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)
+              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
+
+            # Build the delta index for the related model. This won't be called
+            # if running in the test environment.
+            #
+            def index_delta(instance = nil)
+              return true unless ThinkingSphinx.updates_enabled? &&
+                ThinkingSphinx.deltas_enabled?
+              
+              config = ThinkingSphinx::Configuration.instance
+              client = Riddle::Client.new config.address, config.port
+              
+              client.update(
+                "#{self.sphinx_indexes.first.name}_core",
+                ['sphinx_deleted'],
+                {instance.sphinx_document_id => 1}
+              ) if instance && instance.in_core_index?
+              
+              system "#{config.bin_path}indexer --config #{config.config_file} --rotate #{self.sphinx_indexes.first.name}_delta"
+
+              true
+            end
           end
           
-          def after_commit
-            # Deliberately blank.
-          end
-          
-          # Normal boolean save wrapped in a handler for the after_commit
-          # callback.
-          # 
-          def save_with_after_commit_callback(*args)
-            value = save_without_after_commit_callback(*args)
-            callback(:after_commit) if value
-            return value
-          end
-          
-          alias_method_chain :save, :after_commit_callback
-          
-          # Forceful save wrapped in a handler for the after_commit callback.
-          #
-          def save_with_after_commit_callback!(*args)
-            value = save_without_after_commit_callback!(*args)
-            callback(:after_commit) if value
-            return value
-          end
-          
-          alias_method_chain :save!, :after_commit_callback
-          
-          # Normal destroy wrapped in a handler for the after_commit callback.
-          #
-          def destroy_with_after_commit_callback
-            value = destroy_without_after_commit_callback
-            callback(:after_commit) if value
-            return value
-          end
-          
-          alias_method_chain :destroy, :after_commit_callback
-          
           private
           
           # Set the delta value for the model to be true.
@@ -73,12 +71,7 @@ module ThinkingSphinx
           # if running in the test environment.
           # 
           def index_delta
-            return true unless ThinkingSphinx.deltas_enabled?
-            
-            configuration = ThinkingSphinx::Configuration.new
-            system "indexer --config #{configuration.config_file} --rotate #{self.class.indexes.first.name}_delta"
-            
-            true
+            self.class.index_delta(self)
           end
         end
       end

data/lib/thinking_sphinx/active_record/has_many_association.rb

@@ -6,7 +6,7 @@ module ThinkingSphinx
         stack = [@reflection.options[:through]].compact
         
         attribute   = nil
-        (@reflection.klass.indexes || []).each do |index|
+        (@reflection.klass.sphinx_indexes || []).each do |index|
           attribute = index.attributes.detect { |attrib|
             attrib.columns.length == 1 &&
             attrib.columns.first.__name  == foreign_key.to_sym &&

data/lib/thinking_sphinx/active_record/search.rb

@@ -28,7 +28,14 @@ module ThinkingSphinx
               args << options
               ThinkingSphinx::Search.search(*args)
             end
-            
+
+            def search_count(*args)
+              options = args.extract_options!
+              options[:class] = self
+              args << options
+              ThinkingSphinx::Search.count(*args)
+            end
+
             def search_for_id(*args)
               options = args.extract_options!
               options[:class] = self

data/lib/thinking_sphinx/adapters/abstract_adapter.rb

@@ -0,0 +1,27 @@
+module ThinkingSphinx
+  class AbstractAdapter
+    class << self
+      def setup
+        # Deliberately blank - subclasses should do something though. Well, if
+        # they need to.
+      end
+      
+      def detect(model)
+        case model.connection.class.name
+        when "ActiveRecord::ConnectionAdapters::MysqlAdapter"
+          ThinkingSphinx::MysqlAdapter
+        when "ActiveRecord::ConnectionAdapters::PostgreSQLAdapter"
+          ThinkingSphinx::PostgreSQLAdapter
+        else
+          raise "Invalid Database Adapter: Sphinx only supports MySQL and PostgreSQL"
+        end
+      end
+      
+      protected
+      
+      def connection
+        @connection ||= ::ActiveRecord::Base.connection
+      end
+    end
+  end
+end

data/lib/thinking_sphinx/adapters/mysql_adapter.rb

@@ -0,0 +1,9 @@
+module ThinkingSphinx
+  class MysqlAdapter < AbstractAdapter
+    class << self
+      def setup
+        # Does MySQL actually need to do anything?
+      end
+    end
+  end
+end

data/lib/thinking_sphinx/adapters/postgresql_adapter.rb

@@ -0,0 +1,84 @@
+module ThinkingSphinx
+  class PostgreSQLAdapter < AbstractAdapter
+    class << self
+      def setup
+        create_array_accum_function
+        create_crc32_function
+      end
+      
+      private
+      
+      def create_array_accum_function
+        connection.execute "begin"
+        connection.execute "savepoint ts"
+        begin
+          # See http://www.postgresql.org/docs/8.2/interactive/sql-createaggregate.html
+          if connection.raw_connection.server_version > 80200
+            connection.execute <<-SQL
+              CREATE AGGREGATE array_accum (anyelement)
+              (
+                  sfunc = array_append,
+                  stype = anyarray,
+                  initcond = '{}'
+              );
+            SQL
+          else
+            connection.execute <<-SQL
+              CREATE AGGREGATE array_accum
+              (
+                  basetype = anyelement,
+                  sfunc = array_append,
+                  stype = anyarray,
+                  initcond = '{}'
+              );
+            SQL
+          end
+        rescue
+          connection.execute "rollback to savepoint ts"
+        end
+        connection.execute "release savepoint ts"
+        connection.execute "commit"
+      end
+      
+      def create_crc32_function
+        connection.execute "begin"
+        connection.execute "savepoint ts"
+        begin
+          connection.execute "CREATE LANGUAGE 'plpgsql';"
+          connection.execute <<-SQL
+            CREATE OR REPLACE FUNCTION crc32(word text)
+            RETURNS bigint AS $$
+              DECLARE tmp bigint;
+              DECLARE i int;
+              DECLARE j int;
+              BEGIN
+                i = 0;
+                tmp = 4294967295;
+                LOOP
+                  tmp = (tmp # get_byte(word::bytea, i))::bigint;
+                  i = i + 1;
+                  j = 0;
+                  LOOP
+                    tmp = ((tmp >> 1) # (3988292384 * (tmp & 1)))::bigint;
+                    j = j + 1;
+                    IF j >= 8 THEN
+                      EXIT;
+                    END IF;
+                  END LOOP;
+                  IF i >= char_length(word) THEN
+                    EXIT;
+                  END IF;
+                END LOOP;
+                return (tmp # 4294967295);
+              END
+            $$ IMMUTABLE STRICT LANGUAGE plpgsql;
+          SQL
+        rescue
+          connection.execute "rollback to savepoint ts"
+        end
+        connection.execute "release savepoint ts"
+        connection.execute "commit"
+      end
+    end
+  end
+end

data/lib/thinking_sphinx/association.rb

@@ -95,6 +95,10 @@ module ThinkingSphinx
       (parent ? parent.ancestors : []) << self
     end
     
+    def has_column?(column)
+      @reflection.klass.column_names.include?(column.to_s)
+    end
+    
     private
     
     # Returns all the objects that could be currently instantiated from a