thinking-sphinx 1.5.0 → 2.0.0.rc1

data/lib/thinking_sphinx/active_record/delta.rb

@@ -3,7 +3,7 @@ module ThinkingSphinx
     # This module contains all the delta-related code for models. There isn't
     # really anything you need to call manually in here - except perhaps
     # index_delta, but not sure what reason why.
-    #
+    # 
     module Delta
       # Code for after_commit callback is written by Eli Miller:
       # http://elimiller.blogspot.com/2007/06/proper-cache-expiry-with-aftercommit.html
@@ -16,42 +16,36 @@ module ThinkingSphinx
             # if running in the test environment.
             #
             def index_delta(instance = nil)
-              delta_objects.each { |obj| obj.index(self, instance) }
+              delta_object.index(self, instance)
             end
-
-            def delta_objects
-              self.sphinx_indexes.collect(&:delta_object).compact
+            
+            def delta_object
+              self.sphinx_indexes.first.delta_object
             end
           end
-
+          
           def toggled_delta?
-            self.class.delta_objects.any? { |obj| obj.toggled(self) }
+            self.class.delta_object.toggled(self)
           end
-
+          
           private
-
+          
           # Set the delta value for the model to be true.
           def toggle_delta
-            self.class.delta_objects.each { |obj|
-              obj.toggle(self)
-            } if should_toggle_delta?
+            self.class.delta_object.toggle(self) if should_toggle_delta?
           end
-
+          
           # Build the delta index for the related model. This won't be called
           # if running in the test environment.
-          #
+          # 
           def index_delta
-            self.class.index_delta(self) if self.class.delta_objects.any? { |obj|
-              obj.toggled(self)
-            }
+            self.class.index_delta(self) if self.class.delta_object.toggled(self)
           end
-
+          
           def should_toggle_delta?
-            return fire_delta? if respond_to?(:fire_delta?)
-
             self.new_record? || indexed_data_changed?
           end
-
+          
           def indexed_data_changed?
             sphinx_indexes.any? { |index|
               index.fields.any? { |field| field.changed?(self) } ||

data/lib/thinking_sphinx/active_record/has_many_association.rb

@@ -2,23 +2,26 @@ module ThinkingSphinx
   module ActiveRecord
     module HasManyAssociation
       def search(*args)
-        @reflection.klass.search(*association_args(args))
-      end
-
-      def facets(*args)
-        @reflection.klass.facets(*association_args(args))
-      end
-
-      private
-
-      def association_args(args)
-        options = args.extract_options!
+        options   = args.extract_options!
         options[:with] ||= {}
         options[:with].merge! default_filter
-
-        args + [options]
+        
+        args << options
+        @reflection.klass.search(*args)
+      end
+      
+      def method_missing(method, *args, &block)
+        if responds_to_scope(method)
+          @reflection.klass.
+            search(:with => default_filter).
+            send(method, *args, &block)
+        else
+          super
+        end
       end
-
+      
+      private
+      
       def attribute_for_foreign_key
         foreign_key = @reflection.primary_key_name
         stack = [@reflection.options[:through]].compact
@@ -27,8 +30,7 @@ module ThinkingSphinx
         (@reflection.klass.sphinx_indexes || []).each do |index|
           attribute = index.attributes.detect { |attrib|
             attrib.columns.length == 1 &&
-            attrib.columns.first.__name  == foreign_key.to_sym ||
-            attrib.alias == foreign_key.to_sym
+            attrib.columns.first.__name  == foreign_key.to_sym
           }
           return attribute unless attribute.nil?
         end
@@ -39,6 +41,11 @@ module ThinkingSphinx
       def default_filter
         {attribute_for_foreign_key.unique_name => @owner.id}
       end
+      
+      def responds_to_scope(scope)
+        @reflection.klass.respond_to?(:sphinx_scopes)   &&
+        @reflection.klass.sphinx_scopes.include?(scope)
+      end
     end
   end
 end

data/lib/thinking_sphinx/active_record/scopes.rb

@@ -17,7 +17,6 @@ module ThinkingSphinx
         # The scope is automatically applied when the search method is called. It
         # will only be applied if it is an existing sphinx_scope.
         def default_sphinx_scope(sphinx_scope_name)
-          add_sphinx_scopes_support_to_has_many_associations
           @default_sphinx_scope = sphinx_scope_name
         end
 
@@ -44,8 +43,6 @@ module ThinkingSphinx
         #   @articles =  Article.latest_first.search 'pancakes'
         #
         def sphinx_scope(method, &block)
-          add_sphinx_scopes_support_to_has_many_associations
-
           @sphinx_scopes ||= []
           @sphinx_scopes << method
           
@@ -56,13 +53,6 @@ module ThinkingSphinx
               
               ThinkingSphinx::Search.new(options)
             end
-            
-            define_method("#{method}_without_default".to_sym) do |*args|
-              options = {:classes => classes_option, :ignore_default => true}
-              options.merge! block.call(*args)
-              
-              ThinkingSphinx::Search.new(options)
-            end
           end
         end
 
@@ -79,14 +69,6 @@ module ThinkingSphinx
           
           sphinx_scopes.clear
         end
-
-        def add_sphinx_scopes_support_to_has_many_associations
-          scope_mixin = ::ThinkingSphinx::ActiveRecord::HasManyAssociationWithScopes
-
-          ::ActiveRecord::Associations::HasManyAssociation.send(:include, scope_mixin)
-          ::ActiveRecord::Associations::HasManyThroughAssociation.send(:include, scope_mixin)
-        end
-
       end
     end
   end

data/lib/thinking_sphinx/adapters/abstract_adapter.rb

@@ -3,90 +3,42 @@ module ThinkingSphinx
     def initialize(model)
       @model = model
     end
-
+    
     def setup
       # Deliberately blank - subclasses should do something though. Well, if
       # they need to.
     end
-
+      
     def self.detect(model)
-      adapter = adapter_for_model model
-      case adapter
-      when :mysql
-        ThinkingSphinx::MysqlAdapter.new model
-      when :postgresql
-        ThinkingSphinx::PostgreSQLAdapter.new model
-      when Class
-        adapter.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",
-           "ActiveRecord::ConnectionAdapters::Mysql2Adapter",
-           "ActiveRecord::ConnectionAdapters::NullDBAdapter"
-        :mysql
+           "ActiveRecord::ConnectionAdapters::MysqlplusAdapter"
+        ThinkingSphinx::MysqlAdapter.new model
       when "ActiveRecord::ConnectionAdapters::PostgreSQLAdapter"
-        :postgresql
+        ThinkingSphinx::PostgreSQLAdapter.new model
       when "ActiveRecord::ConnectionAdapters::JdbcAdapter"
-        case model.connection.config[:adapter]
-        when "jdbcmysql"
-          :mysql
-        when "jdbcpostgresql"
-          :postgresql
-        when "jdbc"
-          match = /^jdbc:(mysql|postgresql):\/\//.match(model.connection.config[:url])
-          if match
-            match[1].to_sym
-          else
-            model.connection.config[:adapter]
-          end
+        if model.connection.config[:adapter] == "jdbcmysql"
+          ThinkingSphinx::MysqlAdapter.new model
+        elsif model.connection.config[:adapter] == "jdbcpostgresql"
+          ThinkingSphinx::PostgreSQLAdapter.new model
         else
-          model.connection.config[:adapter].to_sym
+          raise "Invalid Database Adapter: Sphinx only supports MySQL and PostgreSQL"
         end
       else
-        model.connection.class.name
+        raise "Invalid Database Adapter: Sphinx only supports MySQL and PostgreSQL, not #{model.connection.class.name}"
       end
     end
-
+    
     def quote_with_table(column)
       "#{@model.quoted_table_name}.#{@model.connection.quote_column_name(column)}"
     end
-
+    
     def bigint_pattern
       /bigint/i
     end
-
-    def downcase(clause)
-      "LOWER(#{clause})"
-    end
-
-    def case(expression, pairs, default)
-      "CASE #{expression} " +
-      pairs.keys.inject('') { |string, key|
-        string + "WHEN '#{key}' THEN #{pairs[key]} "
-      } + "ELSE #{default} END"
-    end
-
+    
     protected
-
+    
     def connection
       @connection ||= @model.connection
     end

data/lib/thinking_sphinx/adapters/mysql_adapter.rb

@@ -28,10 +28,6 @@ module ThinkingSphinx
       "CAST(#{clause} AS UNSIGNED)"
     end
     
-    def cast_to_int(clause)
-      "CAST(#{clause} AS SIGNED)"
-    end
-    
     def convert_nulls(clause, default = '')
       default = "'#{default}'" if default.is_a?(String)
       

data/lib/thinking_sphinx/adapters/postgresql_adapter.rb

@@ -4,49 +4,37 @@ module ThinkingSphinx
       create_array_accum_function
       create_crc32_function
     end
-
+    
     def sphinx_identifier
       "pgsql"
     end
-
+    
     def concatenate(clause, separator = ' ')
       if clause[/^COALESCE/]
         clause.split('), ').join(") || '#{separator}' || ")
       else
         clause.split(', ').collect { |field|
-          "CAST(COALESCE(#{field}::varchar, '') as varchar)"
+          "CAST(COALESCE(#{field}, '') as varchar)"
         }.join(" || '#{separator}' || ")
       end
     end
-
+    
     def group_concatenate(clause, separator = ' ')
-      if server_version >= 80400
-        "array_to_string(array_agg(COALESCE(#{clause}, '0')), '#{separator}')"
-      else
-        "array_to_string(array_accum(COALESCE(#{clause}, '0')), '#{separator}')"
-      end
+      "array_to_string(array_accum(COALESCE(#{clause}, '0')), '#{separator}')"
     end
-
+    
     def cast_to_string(clause)
       clause
     end
-
+    
     def cast_to_datetime(clause)
-      if ThinkingSphinx::Configuration.instance.use_64_bit
-        "cast(floor(extract(epoch from #{clause})) as bigint)"
-      else
-        "cast(floor(extract(epoch from #{clause})) as int)"
-      end
+      "cast(extract(epoch from #{clause}) as int)"
     end
-
+    
     def cast_to_unsigned(clause)
       clause
     end
-
-    def cast_to_int(clause)
-      "#{clause}::INT8"
-    end
-
+    
     def convert_nulls(clause, default = '')
       default = case default
       when String
@@ -58,44 +46,34 @@ module ThinkingSphinx
       else
         default
       end
-
+      
       "COALESCE(#{clause}, #{default})"
     end
-
+    
     def boolean(value)
       value ? 'TRUE' : 'FALSE'
     end
-
+    
     def crc(clause, blank_to_null = false)
       clause = "NULLIF(#{clause},'')" if blank_to_null
       "crc32(#{clause})"
     end
-
+    
     def utf8_query_pre
       nil
     end
-
+    
     def time_difference(diff)
       "current_timestamp - interval '#{diff} seconds'"
     end
-
+    
     def utc_query_pre
-      "SET TIME ZONE 'UTC'"
+      'SET TIME ZONE UTC'
     end
-
+    
     private
-
+    
     def execute(command, output_error = false)
-      if RUBY_PLATFORM == 'java'
-        connection.transaction do
-          execute_command command, output_error
-        end
-      else
-        execute_command command, output_error
-      end
-    end
-
-    def execute_command(command, output_error = false)
       connection.execute "begin"
       connection.execute "savepoint ts"
       begin
@@ -107,11 +85,9 @@ module ThinkingSphinx
       connection.execute "release savepoint ts"
       connection.execute "commit"
     end
-
+    
     def create_array_accum_function
-      if server_version >= 80311
-        return
-      elsif server_version > 80200
+      if connection.raw_connection.respond_to?(:server_version) && connection.raw_connection.server_version > 80200
         execute <<-SQL
           CREATE AGGREGATE array_accum (anyelement)
           (
@@ -132,7 +108,7 @@ module ThinkingSphinx
         SQL
       end
     end
-
+    
     def create_crc32_function
       execute "CREATE LANGUAGE 'plpgsql';"
       function = <<-SQL
@@ -141,16 +117,10 @@ module ThinkingSphinx
           DECLARE tmp bigint;
           DECLARE i int;
           DECLARE j int;
-          DECLARE byte_length int;
           DECLARE word_array bytea;
           BEGIN
-            IF COALESCE(word, '') = '' THEN
-              return 0;
-            END IF;
-
             i = 0;
             tmp = 4294967295;
-            byte_length = bit_length(word) / 8;
             word_array = decode(replace(word, E'\\\\', E'\\\\\\\\'), 'escape');
             LOOP
               tmp = (tmp # get_byte(word_array, i))::bigint;
@@ -163,26 +133,15 @@ module ThinkingSphinx
                   EXIT;
                 END IF;
               END LOOP;
-              IF i >= byte_length THEN
+              IF i >= char_length(word) THEN
                 EXIT;
               END IF;
             END LOOP;
             return (tmp # 4294967295);
           END
-        $$ IMMUTABLE LANGUAGE plpgsql;
+        $$ IMMUTABLE STRICT LANGUAGE plpgsql;
       SQL
       execute function, true
     end
-
-    def server_version
-      if RUBY_PLATFORM == 'java'
-        (connection.raw_connection.connection.server_major_version * 10000) +
-        (connection.raw_connection.connection.server_minor_version * 100)
-      elsif connection.raw_connection.respond_to?(:server_version)
-        connection.raw_connection.server_version
-      else
-        0
-      end
-    end
   end
 end