freelancing-god-thinking-sphinx 1.1.2 → 1.1.3

data/lib/thinking_sphinx/collection.rb

@@ -33,22 +33,27 @@ module ThinkingSphinx
     end
     
     def self.instances_from_matches(matches, options = {})
-      return matches.collect { |match|
-        instance_from_match match, options
-      } unless klass = options[:class]
-      
+      if klass = options[:class]
+        instances_from_class klass, matches, options
+      else
+        instances_from_classes matches, options
+      end
+    end
+    
+    def self.instances_from_class(klass, matches, options = {})
       index_options = klass.sphinx_index_options
-      
+
       ids = matches.collect { |match| match[:attributes]["sphinx_internal_id"] }
       instances = ids.length > 0 ? klass.find(
         :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])
       ) : []
-      
-      # Raise an exception if we find records in Sphinx but not in the DB, so the search method
-      # can retry without them. See ThinkingSphinx::Search.retry_search_on_stale_index.
+
+      # Raise an exception if we find records in Sphinx but not in the DB, so
+      # the search method can retry without them. See 
+      # ThinkingSphinx::Search.retry_search_on_stale_index.
       if options[:raise_on_stale] && instances.length < ids.length
         stale_ids = ids - instances.map {|i| i.id }
         raise StaleIdsException, stale_ids
@@ -59,14 +64,24 @@ module ThinkingSphinx
       }
     end
     
-    def self.instance_from_match(match, options)
-      class_from_crc(match[:attributes]["class_crc"]).find(
-        match[:attributes]["sphinx_internal_id"],
-        :include => options[:include],
-        :select  => options[:select]
-      )
-    rescue ::ActiveRecord::RecordNotFound
-      nil
+    # Group results by class and call #find(:all) once for each group to reduce
+    # the number of #find's in multi-model searches.
+    # 
+    def self.instances_from_classes(matches, options = {})
+      groups = matches.group_by { |match| match[:attributes]["class_crc"] }
+      groups.each do |crc, group|
+        group.replace(
+          instances_from_class(class_from_crc(crc), group, options)
+        )
+      end
+      
+      matches.collect do |match|
+        groups.detect { |crc, group|
+          crc == match[:attributes]["class_crc"]
+        }[1].detect { |obj|
+          obj.id == match[:attributes]["sphinx_internal_id"]
+        }
+      end
     end
     
     def self.class_from_crc(crc)
@@ -98,9 +113,9 @@ module ThinkingSphinx
       each_with_attribute method.to_s.gsub(/^each_with_/, ''), &block
     end
     
-    def each_with_group_and_count(&block)
+    def each_with_groupby_and_count(&block)
       results[:matches].each_with_index do |match, index|
-        yield self[index], match[:attributes]["@group"], match[:attributes]["@count"]
+        yield self[index], match[:attributes]["@groupby"], match[:attributes]["@count"]
       end
     end
     

data/lib/thinking_sphinx/configuration.rb

@@ -156,31 +156,6 @@ module ThinkingSphinx
       end
     end
     
-    def hash_to_config(hash)
-      hash.collect { |key, value|
-        translated_value = case value
-        when TrueClass
-          "1"
-        when FalseClass
-          "0"
-        when NilClass, ""
-          next
-        else
-          value
-        end
-        "  #{key} = #{translated_value}"
-      }.join("\n")
-    end
-    
-    def self.options_merge(base, extra)
-      base = base.clone
-      extra.each do |key, value|
-        next if value.nil? || value == ""
-        base[key] = value
-      end
-      base
-    end
-    
     def address
       @configuration.searchd.address
     end

data/lib/thinking_sphinx/core/string.rb

@@ -0,0 +1,22 @@
+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
+      end
+      
+    end
+  end
+end
+
+class String
+  include ThinkingSphinx::Core::String
+end

data/lib/thinking_sphinx/deltas/datetime_delta.rb

@@ -40,22 +40,11 @@ module ThinkingSphinx
       def clause(model, toggled)
         if toggled
           "#{model.quoted_table_name}.#{@index.quote_column(@column.to_s)}" +
-          " > #{time_difference}"
+          " > #{adapter.time_difference(@threshold)}"
         else
           nil
         end
       end
-      
-      def time_difference
-        case @index.adapter
-        when :mysql
-          "DATE_SUB(NOW(), INTERVAL #{@threshold} SECOND)"
-        when :postgres
-          "current_timestamp - interval '#{@threshold} seconds'"
-        else
-          raise "Unknown Database Adapter"
-        end
-      end
     end
   end
 end

data/lib/thinking_sphinx/deltas/default_delta.rb

@@ -37,12 +37,12 @@ module ThinkingSphinx
       
       def reset_query(model)
         "UPDATE #{model.quoted_table_name} SET " +
-        "#{@index.quote_column(@column.to_s)} = #{@index.db_boolean(false)}"
+        "#{@index.quote_column(@column.to_s)} = #{adapter.boolean(false)}"
       end
       
       def clause(model, toggled)
         "#{model.quoted_table_name}.#{@index.quote_column(@column.to_s)}" +
-        " = #{@index.db_boolean(toggled)}"
+        " = #{adapter.boolean(toggled)}"
       end
       
       protected
@@ -53,7 +53,13 @@ module ThinkingSphinx
       
       def delta_index_name(model)
         "#{model.source_of_sphinx_index.name.underscore.tr(':/\\', '_')}_delta"
-      end      
+      end  
+      
+      private
+      
+      def adapter
+        @adapter = @index.model.sphinx_database_adapter
+      end
     end
   end
 end

data/lib/thinking_sphinx/field.rb

@@ -8,7 +8,8 @@ module ThinkingSphinx
   # associations. Which can get messy. Use Index.link!, it really helps.
   # 
   class Field
-    attr_accessor :alias, :columns, :sortable, :associations, :model, :infixes, :prefixes
+    attr_accessor :alias, :columns, :sortable, :associations, :model, :infixes,
+      :prefixes, :faceted
     
     # To create a new field, you'll need to pass in either a single Column
     # or an array of them, and some (optional) options. The columns are
@@ -58,10 +59,11 @@ module ThinkingSphinx
 
       raise "Cannot define a field with no columns. Maybe you are trying to index a field with a reserved name (id, name). You can fix this error by using a symbol rather than a bare name (:id instead of id)." if @columns.empty? || @columns.any? { |column| !column.respond_to?(:__stack) }
       
-      @alias        = options[:as]
-      @sortable     = options[:sortable] || false
-      @infixes      = options[:infixes]  || false
-      @prefixes     = options[:prefixes] || false
+      @alias    = options[:as]
+      @sortable = options[:sortable] || false
+      @infixes  = options[:infixes]  || false
+      @prefixes = options[:prefixes] || false
+      @faceted  = options[:facet]    || false
     end
     
     # Get the part of the SELECT clause related to this field. Don't forget
@@ -75,10 +77,10 @@ module ThinkingSphinx
         column_with_prefix(column)
       }.join(', ')
       
-      clause = concatenate(clause) if concat_ws?
-      clause = group_concatenate(clause) if is_many?
+      clause = adapter.concatenate(clause) if concat_ws?
+      clause = adapter.group_concatenate(clause) if is_many?
       
-      "#{cast_to_string clause } AS #{quote_column(unique_name)}"
+      "#{adapter.cast_to_string clause } AS #{quote_column(unique_name)}"
     end
     
     # Get the part of the GROUP BY clause related to this field - if one is
@@ -110,41 +112,16 @@ module ThinkingSphinx
       end
     end
     
-    private
-    
-    def concatenate(clause)
-      case @model.connection.class.name
-      when "ActiveRecord::ConnectionAdapters::MysqlAdapter"
-        "CONCAT_WS(' ', #{clause})"
-      when "ActiveRecord::ConnectionAdapters::PostgreSQLAdapter"
-        clause.split(', ').collect { |field|
-          "COALESCE(#{field}, '')"
-        }.join(" || ' ' || ")
-      else
-        clause
-      end
+    def to_facet
+      return nil unless @faceted
+      
+      ThinkingSphinx::Facet.new(unique_name, @columns, self)
     end
     
-    def group_concatenate(clause)
-      case @model.connection.class.name
-      when "ActiveRecord::ConnectionAdapters::MysqlAdapter"
-        "GROUP_CONCAT(#{clause} SEPARATOR ' ')"
-      when "ActiveRecord::ConnectionAdapters::PostgreSQLAdapter"
-        "array_to_string(array_accum(#{clause}), ' ')"
-      else
-        clause
-      end
-    end
+    private
     
-    def cast_to_string(clause)
-      case @model.connection.class.name
-      when "ActiveRecord::ConnectionAdapters::MysqlAdapter"
-        "CAST(#{clause} AS CHAR)"
-      when "ActiveRecord::ConnectionAdapters::PostgreSQLAdapter"
-        clause
-      else
-        clause
-      end
+    def adapter
+      @adapter ||= @model.sphinx_database_adapter
     end
     
     def quote_column(column)
@@ -158,16 +135,7 @@ module ThinkingSphinx
     def concat_ws?
       @columns.length > 1 || multiple_associations?
     end
-    
-    # Checks the association tree for each column - if they're all the same,
-    # returns false.
-    # 
-    def multiple_sources?
-      first = associations[@columns.first]
-      
-      !@columns.all? { |col| associations[col] == first }
-    end
-    
+        
     # Checks whether any column requires multiple associations (which only
     # happens for polymorphic situations).
     # 
@@ -200,9 +168,5 @@ module ThinkingSphinx
     def is_many?
       associations.values.flatten.any? { |assoc| assoc.is_many? }
     end
-    
-    def is_string?
-      columns.all? { |col| col.is_string? }
-    end
   end
 end

data/lib/thinking_sphinx/index.rb

@@ -46,18 +46,13 @@ module ThinkingSphinx
     def self.name(model)
       model.name.underscore.tr(':/\\', '_')
     end
-        
-    def to_riddle(model, index, offset)
-      add_internal_attributes
-      link!
-    end
     
     def to_riddle_for_core(offset, index)
       add_internal_attributes
       link!
       
       source = Riddle::Configuration::SQLSource.new(
-        "#{name}_core_#{index}", riddle_adapter
+        "#{name}_core_#{index}", adapter.sphinx_identifier
       )
       
       set_source_database_settings  source
@@ -73,7 +68,7 @@ module ThinkingSphinx
       link!
       
       source = Riddle::Configuration::SQLSource.new(
-        "#{name}_delta_#{index}", riddle_adapter
+        "#{name}_delta_#{index}", adapter.sphinx_identifier
       )
       source.parent = "#{name}_core_#{index}"
       
@@ -111,92 +106,6 @@ module ThinkingSphinx
       }
     end
     
-    # Generates the big SQL statement to get the data back for all the fields
-    # and attributes, using all the relevant association joins. If you want
-    # the version filtered for delta values, send through :delta => true in the
-    # options. Won't do much though if the index isn't set up to support a
-    # delta sibling.
-    # 
-    # Examples:
-    # 
-    #   index.to_sql
-    #   index.to_sql(:delta => true)
-    #
-    def to_sql(options={})
-      assocs = all_associations
-      
-      where_clause = ""
-      if self.delta? && !@delta_object.clause(@model, options[:delta]).blank?
-        where_clause << " AND #{@delta_object.clause(@model, options[:delta])}"
-      end
-      unless @conditions.empty?
-        where_clause << " AND " << @conditions.join(" AND ")
-      end
-      
-      internal_groupings = []
-      if @model.column_names.include?(@model.inheritance_column)
-         internal_groupings << "#{@model.quoted_table_name}.#{quote_column(@model.inheritance_column)}"
-      end
-      
-      unique_id_expr = "* #{ThinkingSphinx.indexed_models.size} + #{options[:offset] || 0}"
-      
-      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(", ") }
-FROM #{ @model.table_name }
-  #{ assocs.collect { |assoc| assoc.to_sql }.join(' ') }
-WHERE #{@model.quoted_table_name}.#{quote_column(@model.primary_key)} >= $start
-  AND #{@model.quoted_table_name}.#{quote_column(@model.primary_key)} <= $end
-  #{ where_clause }
-GROUP BY #{ (
-  ["#{@model.quoted_table_name}.#{quote_column(@model.primary_key)}"] + 
-  @fields.collect { |field| field.to_group_sql }.compact +
-  @attributes.collect { |attribute| attribute.to_group_sql }.compact +
-  @groupings + internal_groupings
-).join(", ") }
-      SQL
-      
-      if @model.connection.class.name == "ActiveRecord::ConnectionAdapters::MysqlAdapter"
-        sql += " ORDER BY NULL"
-      end
-      
-      sql
-    end
-    
-    # Simple helper method for the query info SQL - which is a statement that
-    # returns the single row for a corresponding id.
-    # 
-    def to_sql_query_info(offset)
-      "SELECT * FROM #{@model.quoted_table_name} WHERE " +
-      " #{quote_column(@model.primary_key)} = (($id - #{offset}) / #{ThinkingSphinx.indexed_models.size})"
-    end
-    
-    # Simple helper method for the query range SQL - which is a statement that
-    # returns minimum and maximum id values. These can be filtered by delta -
-    # so pass in :delta => true to get the delta version of the SQL.
-    # 
-    def to_sql_query_range(options={})
-      min_statement = "MIN(#{quote_column(@model.primary_key)})"
-      max_statement = "MAX(#{quote_column(@model.primary_key)})"
-      
-      # Fix to handle Sphinx PostgreSQL bug (it doesn't like NULLs or 0's)
-      if adapter == :postgres
-        min_statement = "COALESCE(#{min_statement}, 1)"
-        max_statement = "COALESCE(#{max_statement}, 1)"
-      end
-      
-      sql = "SELECT #{min_statement}, #{max_statement} " +
-            "FROM #{@model.quoted_table_name} "
-      if self.delta? && !@delta_object.clause(@model, options[:delta]).blank?
-        sql << "WHERE #{@delta_object.clause(@model, options[:delta])}"
-      end
-      
-      sql
-    end
-    
     # Flag to indicate whether this index has a corresponding delta index.
     #
     def delta?
@@ -204,14 +113,7 @@ GROUP BY #{ (
     end
     
     def adapter
-      @adapter ||= case @model.connection.class.name
-      when "ActiveRecord::ConnectionAdapters::MysqlAdapter"
-        :mysql
-      when "ActiveRecord::ConnectionAdapters::PostgreSQLAdapter"
-        :postgres
-      else
-        raise "Invalid Database Adapter: Sphinx only supports MySQL and PostgreSQL"
-      end
+      @adapter ||= @model.sphinx_database_adapter
     end
         
     def prefix_fields
@@ -229,30 +131,11 @@ GROUP BY #{ (
       }.each { |key| all_index_options[key.to_sym] = @options[key] }
       all_index_options
     end
-    
-    def source_options
-      all_source_options = ThinkingSphinx::Configuration.instance.source_options.clone
-      @options.keys.select { |key|
-        ThinkingSphinx::Configuration::SourceOptions.include?(key.to_s)
-      }.each { |key| all_source_options[key.to_sym] = @options[key] }
-      all_source_options
-    end
-    
+        
     def quote_column(column)
       @model.connection.quote_column_name(column)
     end
     
-    # Returns the proper boolean value string literal for the
-    # current database adapter.
-    #
-    def db_boolean(val)
-      if adapter == :postgres
-        val ? 'TRUE' : 'FALSE'
-      else
-        val ? '1' : '0'
-      end
-    end
-    
     private
     
     def utf8?
@@ -284,6 +167,14 @@ GROUP BY #{ (
       @delta_object = ThinkingSphinx::Deltas.parse self, builder.properties
       @options      = builder.properties
       
+      @model.sphinx_facets ||= []
+      @fields.select { |field| field.faceted }.each { |field|
+        @model.sphinx_facets << field.to_facet
+      }
+      @attributes.select { |attrib| attrib.faceted }.each { |attrib|
+        @model.sphinx_facets << attrib.to_facet
+      }
+      
       # 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.
@@ -345,12 +236,10 @@ GROUP BY #{ (
 
     def crc_column
       if @model.column_names.include?(@model.inheritance_column)
-        case adapter
-        when :postgres
-          "COALESCE(crc32(#{@model.quoted_table_name}.#{quote_column(@model.inheritance_column)}), #{@model.to_crc32.to_s})"
-        when :mysql
-          "CAST(IFNULL(CRC32(#{@model.quoted_table_name}.#{quote_column(@model.inheritance_column)}), #{@model.to_crc32.to_s}) AS UNSIGNED)"
-        end
+        adapter.cast_to_unsigned(adapter.convert_nulls(
+          adapter.crc(adapter.quote_with_table(@model.inheritance_column)),
+          @model.to_crc32
+        ))
       else
         @model.to_crc32.to_s
       end
@@ -383,24 +272,13 @@ GROUP BY #{ (
         :as   => :sphinx_deleted
       ) unless @attributes.detect { |attr| attr.alias == :sphinx_deleted }
     end
-    
-    def riddle_adapter
-      case adapter
-      when :postgres
-        "pgsql"
-      when :mysql
-        "mysql"
-      else
-        raise "Unsupported Database Adapter: Sphinx only supports MySQL and PosgreSQL"
-      end
-    end
-    
+        
     def set_source_database_settings(source)
       config = @model.connection.instance_variable_get(:@config)
       
-      source.sql_host = config[:host]      || "localhost"
-      source.sql_user = config[:username]  || config[:user]
-      source.sql_pass = (config[:password] || "").gsub('#', '\#')
+      source.sql_host = config[:host]           || "localhost"
+      source.sql_user = config[:username]       || config[:user]
+      source.sql_pass = (config[:password].to_s || "").gsub('#', '\#')
       source.sql_db   = config[:database]
       source.sql_port = config[:port]
       source.sql_sock = config[:socket]
@@ -423,9 +301,7 @@ GROUP BY #{ (
         source.sql_query_pre << "SET SESSION group_concat_max_len = #{@options[:group_concat_max_len]}"
       end
       
-      if utf8? && adapter == :mysql
-        source.sql_query_pre << "SET NAMES utf8"
-      end
+      source.sql_query_pre += [adapter.utf8_query_pre].compact if utf8?
     end
     
     def set_source_settings(source)
@@ -449,5 +325,89 @@ GROUP BY #{ (
     def sql_query_pre_for_delta
       [""]
     end
+    
+    # Generates the big SQL statement to get the data back for all the fields
+    # and attributes, using all the relevant association joins. If you want
+    # the version filtered for delta values, send through :delta => true in the
+    # options. Won't do much though if the index isn't set up to support a
+    # delta sibling.
+    # 
+    # Examples:
+    # 
+    #   index.to_sql
+    #   index.to_sql(:delta => true)
+    #
+    def to_sql(options={})
+      assocs = all_associations
+      
+      where_clause = ""
+      if self.delta? && !@delta_object.clause(@model, options[:delta]).blank?
+        where_clause << " AND #{@delta_object.clause(@model, options[:delta])}"
+      end
+      unless @conditions.empty?
+        where_clause << " AND " << @conditions.join(" AND ")
+      end
+      
+      internal_groupings = []
+      if @model.column_names.include?(@model.inheritance_column)
+         internal_groupings << "#{@model.quoted_table_name}.#{quote_column(@model.inheritance_column)}"
+      end
+      
+      unique_id_expr = "* #{ThinkingSphinx.indexed_models.size} + #{options[:offset] || 0}"
+      
+      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(", ") }
+FROM #{ @model.table_name }
+  #{ assocs.collect { |assoc| assoc.to_sql }.join(' ') }
+WHERE #{@model.quoted_table_name}.#{quote_column(@model.primary_key)} >= $start
+  AND #{@model.quoted_table_name}.#{quote_column(@model.primary_key)} <= $end
+  #{ where_clause }
+GROUP BY #{ (
+  ["#{@model.quoted_table_name}.#{quote_column(@model.primary_key)}"] + 
+  @fields.collect { |field| field.to_group_sql }.compact +
+  @attributes.collect { |attribute| attribute.to_group_sql }.compact +
+  @groupings + internal_groupings
+).join(", ") }
+      SQL
+      
+      if @model.connection.class.name == "ActiveRecord::ConnectionAdapters::MysqlAdapter"
+        sql += " ORDER BY NULL"
+      end
+      
+      sql
+    end
+    
+    # Simple helper method for the query info SQL - which is a statement that
+    # returns the single row for a corresponding id.
+    # 
+    def to_sql_query_info(offset)
+      "SELECT * FROM #{@model.quoted_table_name} WHERE " +
+      " #{quote_column(@model.primary_key)} = (($id - #{offset}) / #{ThinkingSphinx.indexed_models.size})"
+    end
+    
+    # Simple helper method for the query range SQL - which is a statement that
+    # returns minimum and maximum id values. These can be filtered by delta -
+    # so pass in :delta => true to get the delta version of the SQL.
+    # 
+    def to_sql_query_range(options={})
+      min_statement = adapter.convert_nulls(
+        "MIN(#{quote_column(@model.primary_key)})", 1
+      )
+      max_statement = adapter.convert_nulls(
+        "MAX(#{quote_column(@model.primary_key)})", 1
+      )
+      
+      sql = "SELECT #{min_statement}, #{max_statement} " +
+            "FROM #{@model.quoted_table_name} "
+      if self.delta? && !@delta_object.clause(@model, options[:delta]).blank?
+        sql << "WHERE #{@delta_object.clause(@model, options[:delta])}"
+      end
+      
+      sql
+    end
   end
 end