thinking-sphinx 1.5.0 → 2.0.0.rc1

data/lib/thinking_sphinx/association.rb

@@ -45,8 +45,13 @@ module ThinkingSphinx
       
       # association is polymorphic - create associations for each
       # non-polymorphic reflection.
-      polymorphic_classes(ref).collect { |poly_class|
-        Association.new parent, depolymorphic_reflection(ref, klass, poly_class)
+      polymorphic_classes(ref).collect { |klass|
+        Association.new parent, ::ActiveRecord::Reflection::AssociationReflection.new(
+          ref.macro,
+          "#{ref.name}_#{klass.name}".to_sym,
+          casted_options(klass, ref),
+          ref.active_record
+        )
       }
     end
     
@@ -66,7 +71,9 @@ module ThinkingSphinx
     # join conditions avoid column name collisions.
     # 
     def to_sql
-      rewrite_conditions
+      @join.to_sql.gsub(/::ts_join_alias::/,
+        "#{@reflection.klass.connection.quote_table_name(@join.parent.aliased_table_name)}"
+      )
     end
     
     # Returns true if the association - or a parent - is a has_many or
@@ -114,16 +121,6 @@ module ThinkingSphinx
     
     private
     
-    def self.depolymorphic_reflection(reflection, source_class, poly_class)
-      name = "#{reflection.name}_#{poly_class.name}".to_sym
-      
-      source_class.reflect_on_association(name) ||
-      ::ActiveRecord::Reflection::AssociationReflection.new(
-        reflection.macro, name, casted_options(poly_class, reflection),
-        reflection.active_record
-      )
-    end
-    
     # Returns all the objects that could be currently instantiated from a
     # polymorphic association. This is pretty damn fast if there's an index on
     # the foreign type column - but if there isn't, it can take a while if you
@@ -163,27 +160,5 @@ module ThinkingSphinx
       
       options
     end
-    
-    def rewrite_conditions
-      rewrite_condition @join.association_join
-    end
-    
-    def rewrite_condition(condition)
-      return condition unless condition.is_a?(String)
-      
-      if defined?(ActsAsTaggableOn) &&
-        @reflection.klass == ActsAsTaggableOn::Tagging &&
-        @reflection.name.to_s[/_taggings$/]
-        condition = condition.gsub /taggings\./, "#{quoted_alias @join}."
-      end
-      
-      condition.gsub /::ts_join_alias::/, quoted_alias(@join.parent)
-    end
-    
-    def quoted_alias(join)
-      @reflection.klass.connection.quote_table_name(
-        join.aliased_table_name
-      )
-    end
   end
-end
+end

data/lib/thinking_sphinx/attribute.rb

@@ -7,21 +7,10 @@ module ThinkingSphinx
   # One key thing to remember - if you're using the attribute manually to
   # generate SQL statements, you'll need to set the base model, and all the
   # associations. Which can get messy. Use Index.link!, it really helps.
-  #
+  # 
   class Attribute < ThinkingSphinx::Property
     attr_accessor :query_source
-
-    SphinxTypeMappings = {
-      :multi     => :sql_attr_multi,
-      :datetime  => :sql_attr_timestamp,
-      :string    => :sql_attr_str2ordinal,
-      :float     => :sql_attr_float,
-      :boolean   => :sql_attr_bool,
-      :integer   => :sql_attr_uint,
-      :bigint    => :sql_attr_bigint,
-      :wordcount => :sql_attr_str2wordcount
-    }
-
+    
     # To create a new attribute, you'll need to pass in either a single Column
     # or an array of them, and some (optional) options.
     #
@@ -33,13 +22,13 @@ module ThinkingSphinx
     # Alias is only required in three circumstances: when there's
     # another attribute or field with the same name, when the column name is
     # 'id', or when there's more than one column.
-    #
+    # 
     # Type is not required, unless you want to force a column to be a certain
     # type (but keep in mind the value will not be CASTed in the SQL
     # statements). The only time you really need to use this is when the type
     # can't be figured out by the column - ie: when not actually using a
     # database column as your source.
-    #
+    # 
     # Source is only used for multi-value attributes (MVA). By default this will
     # use a left-join and a group_concat to obtain the values. For better performance
     # during indexing it can be beneficial to let Sphinx use a separate query to retrieve
@@ -77,34 +66,33 @@ module ThinkingSphinx
     #
     # If you're creating attributes for latitude and longitude, don't forget
     # that Sphinx expects these values to be in radians.
-    #
+    #  
     def initialize(source, columns, options = {})
       super
-
+      
       @type           = options[:type]
       @query_source   = options[:source]
       @crc            = options[:crc]
-      @all_ints       = options[:all_ints]
-
+      
       @type         ||= :multi    unless @query_source.nil?
       if @type == :string && @crc
         @type = is_many? ? :multi : :integer
       end
-
+      
       source.attributes << self
     end
-
+    
     # Get the part of the SELECT clause related to this attribute. Don't forget
     # to set your model and associations first though.
     #
     # This will concatenate strings and arrays of integers, and convert
     # datetimes to timestamps, as needed.
-    #
+    # 
     def to_select_sql
-      return nil unless include_as_association? && available?
-
+      return nil unless include_as_association?
+      
       separator = all_ints? || all_datetimes? || @crc ? ',' : ' '
-
+      
       clause = columns_with_prefixes.collect { |column|
         case type
         when :string
@@ -119,28 +107,35 @@ module ThinkingSphinx
           column
         end
       }.join(', ')
-
+      
       clause = adapter.crc(clause)                          if @crc
       clause = adapter.concatenate(clause, separator)       if concat_ws?
       clause = adapter.group_concatenate(clause, separator) if is_many?
-      clause = adapter.downcase(clause)                     if insensitive?
-
+      
       "#{clause} AS #{quote_column(unique_name)}"
     end
-
+    
     def type_to_config
-      SphinxTypeMappings[type]
+      {
+        :multi    => :sql_attr_multi,
+        :datetime => :sql_attr_timestamp,
+        :string   => :sql_attr_str2ordinal,
+        :float    => :sql_attr_float,
+        :boolean  => :sql_attr_bool,
+        :integer  => :sql_attr_uint,
+        :bigint   => :sql_attr_bigint
+      }[type]
     end
-
+    
     def include_as_association?
       ! (type == :multi && (query_source == :query || query_source == :ranged_query))
     end
-
+    
     # Returns the configuration value that should be used for
     # the attribute.
     # Special case is the multi-valued attribute that needs some
-    # extra configuration.
-    #
+    # extra configuration. 
+    # 
     def config_value(offset = nil, delta = false)
       if type == :multi
         multi_config = include_as_association? ? "field" :
@@ -150,12 +145,12 @@ module ThinkingSphinx
         unique_name
       end
     end
-
+        
     # Returns the type of the column. If that's not already set, it returns
     # :multi if there's the possibility of more than one value, :string if
     # there's more than one association, otherwise it figures out what the
     # actual column's datatype is and returns that.
-    #
+    # 
     def type
       @type ||= begin
         base_type = case
@@ -166,23 +161,21 @@ module ThinkingSphinx
         else
           translated_type_from_database
         end
-
+        
         if base_type == :string && @crc
           base_type = :integer
         else
           @crc = false unless base_type == :multi && is_many_strings? && @crc
         end
-
+        
         base_type
       end
     end
-
+    
     def updatable?
-      [:integer, :datetime, :boolean].include?(type) &&
-      unique_name != :sphinx_internal_id &&
-      !is_string?
+      [:integer, :datetime, :boolean].include?(type) && !is_string?
     end
-
+    
     def live_value(instance)
       object = instance
       column = @columns.first
@@ -190,29 +183,29 @@ module ThinkingSphinx
         object = object.send(method)
         return sphinx_value(nil) if object.nil?
       }
-
+      
       sphinx_value object.send(column.__name)
     end
-
+    
     def all_ints?
-      @all_ints || all_of_type?(:integer)
+      all_of_type?(:integer)
     end
-
+    
     def all_datetimes?
       all_of_type?(:datetime, :date, :timestamp)
     end
-
+    
     def all_strings?
       all_of_type?(:string, :text)
     end
-
+    
     private
-
+    
     def source_value(offset, delta)
       if is_string?
         return "#{query_source.to_s.dasherize}; #{columns.first.__name}"
       end
-
+      
       query = query(offset)
 
       if query_source == :ranged_query
@@ -220,29 +213,33 @@ module ThinkingSphinx
         query += " AND #{query_delta.strip}" if delta
         "ranged-query; #{query}; #{range_query}"
       else
-        query += "WHERE #{query_delta.strip}" if delta
+        query += " WHERE #{query_delta.strip}" if delta
         "query; #{query}"
       end
     end
-
+    
     def query(offset)
       base_assoc = base_association_for_mva
       end_assoc  = end_association_for_mva
       raise "Could not determine SQL for MVA" if base_assoc.nil?
-
-      <<-SQL
-SELECT #{foreign_key_for_mva base_assoc}
-  #{ThinkingSphinx.unique_id_expression(adapter, offset)} AS #{quote_column('id')},
-  #{primary_key_for_mva(end_assoc)} AS #{quote_column(unique_name)}
-FROM #{quote_table_name base_assoc.table} #{association_joins}
-      SQL
+      
+      relation = Table(base_assoc.table)
+      
+      association_joins.each do |join|
+        relation = relation.join(join.relation, Arel::OuterJoin).
+          on(*join.association_join)
+      end
+      
+      relation = relation.project "#{foreign_key_for_mva base_assoc} #{ThinkingSphinx.unique_id_expression(offset)} AS #{quote_column('id')}, #{primary_key_for_mva(end_assoc)} AS #{quote_column(unique_name)}"
+      
+      relation.to_sql
     end
-
+    
     def query_clause
       foreign_key = foreign_key_for_mva base_association_for_mva
-      "WHERE #{foreign_key} >= $start AND #{foreign_key} <= $end"
+      " WHERE #{foreign_key} >= $start AND #{foreign_key} <= $end"
     end
-
+    
     def query_delta
       foreign_key = foreign_key_for_mva base_association_for_mva
       <<-SQL
@@ -251,63 +248,63 @@ FROM #{model.quoted_table_name}
 WHERE #{@source.index.delta_object.clause(model, true)})
       SQL
     end
-
+    
     def range_query
       assoc       = base_association_for_mva
       foreign_key = foreign_key_for_mva assoc
       "SELECT MIN(#{foreign_key}), MAX(#{foreign_key}) FROM #{quote_table_name assoc.table}"
     end
-
+    
     def primary_key_for_mva(assoc)
       quote_with_table(
         assoc.table, assoc.primary_key_from_reflection || columns.first.__name
       )
     end
-
+    
     def foreign_key_for_mva(assoc)
       quote_with_table assoc.table, assoc.reflection.primary_key_name
     end
-
+    
     def end_association_for_mva
-      @association_for_mva ||= associations[columns.first.__stack].detect { |assoc|
+      @association_for_mva ||= associations[columns.first].detect { |assoc|
         assoc.has_column?(columns.first.__name)
       }
     end
-
+    
     def base_association_for_mva
       @first_association_for_mva ||= begin
         assoc = end_association_for_mva
         while !assoc.parent.nil?
           assoc = assoc.parent
         end
-
+        
         assoc
       end
     end
-
+    
     def association_joins
       joins = []
       assoc = end_association_for_mva
       while assoc != base_association_for_mva
-        joins << assoc.to_sql
+        joins << assoc.join
         assoc = assoc.parent
       end
-
-      joins.join(' ')
+      
+      joins
     end
-
+    
     def is_many_ints?
       concat_ws? && all_ints?
     end
-
+    
     def is_many_datetimes?
       is_many? && all_datetimes?
     end
-
+    
     def is_many_strings?
       is_many? && all_strings?
     end
-
+       
     def translated_type_from_database
       case type_from_db = type_from_database
       when :integer
@@ -329,16 +326,16 @@ block:
         MESSAGE
       end
     end
-
+    
     def type_from_database
       column = column_from_db
       column.nil? ? nil : column.type
     end
-
+    
     def integer_type_from_db
       column = column_from_db
       return nil if column.nil?
-
+      
       case column.sql_type
       when adapter.bigint_pattern
         :bigint
@@ -346,27 +343,27 @@ block:
         :integer
       end
     end
-
+    
     def column_from_db
-      klass = @associations.values.flatten.first ?
+      klass = @associations.values.flatten.first ? 
         @associations.values.flatten.first.reflection.klass : @model
-
+      
       klass.columns.detect { |col|
         @columns.collect { |c| c.__name.to_s }.include? col.name
       }
     end
-
+    
     def all_of_type?(*column_types)
       @columns.all? { |col|
-        klasses = @associations[col.__stack].empty? ? [@model] :
-          @associations[col.__stack].collect { |assoc| assoc.reflection.klass }
+        klasses = @associations[col].empty? ? [@model] :
+          @associations[col].collect { |assoc| assoc.reflection.klass }
         klasses.all? { |klass|
           column = klass.columns.detect { |column| column.name == col.__name.to_s }
           !column.nil? && column_types.include?(column.type)
         }
       }
     end
-
+    
     def sphinx_value(value)
       case value
       when TrueClass
@@ -383,9 +380,5 @@ block:
         value
       end
     end
-
-    def insensitive?
-      @sortable == :insensitive
-    end
   end
 end