thinking-sphinx 1.4.6 → 1.4.7

data/lib/thinking_sphinx/adapters/abstract_adapter.rb

@@ -3,12 +3,12 @@ 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
@@ -22,7 +22,7 @@ module ThinkingSphinx
         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
@@ -35,7 +35,7 @@ module ThinkingSphinx
         ThinkingSphinx.database_adapter
       end
     end
-    
+
     def self.standard_adapter_for_model(model)
       case model.connection.class.name
       when "ActiveRecord::ConnectionAdapters::MysqlAdapter",
@@ -52,34 +52,34 @@ module ThinkingSphinx
         when "jdbcpostgresql"
           :postgresql
         else
-          model.connection.config[:adapter]
+          model.connection.config[:adapter].to_sym
         end
       else
         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/postgresql_adapter.rb

@@ -4,11 +4,11 @@ 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}' || ")
@@ -18,27 +18,31 @@ module ThinkingSphinx
         }.join(" || '#{separator}' || ")
       end
     end
-    
+
     def group_concatenate(clause, separator = ' ')
       "array_to_string(array_accum(COALESCE(#{clause}, '0')), '#{separator}')"
     end
-    
+
     def cast_to_string(clause)
       clause
     end
-    
+
     def cast_to_datetime(clause)
-      "cast(extract(epoch from #{clause}) as int)"
+      if ThinkingSphinx::Configuration.instance.use_64_bit
+        "cast(extract(epoch from #{clause}) as bigint)"
+      else
+        "cast(extract(epoch from #{clause}) as int)"
+      end
     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
@@ -50,34 +54,44 @@ 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'"
     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
@@ -89,7 +103,7 @@ module ThinkingSphinx
       connection.execute "release savepoint ts"
       connection.execute "commit"
     end
-    
+
     def create_array_accum_function
       if connection.raw_connection.respond_to?(:server_version) && connection.raw_connection.server_version > 80200
         execute <<-SQL
@@ -112,7 +126,7 @@ module ThinkingSphinx
         SQL
       end
     end
-    
+
     def create_crc32_function
       execute "CREATE LANGUAGE 'plpgsql';"
       function = <<-SQL
@@ -127,7 +141,7 @@ module ThinkingSphinx
             IF COALESCE(word, '') = '' THEN
               return 0;
             END IF;
-          
+
             i = 0;
             tmp = 4294967295;
             byte_length = bit_length(word) / 8;

data/lib/thinking_sphinx/association.rb

@@ -45,13 +45,8 @@ module ThinkingSphinx
       
       # association is polymorphic - create associations for each
       # non-polymorphic reflection.
-      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
-        )
+      polymorphic_classes(ref).collect { |poly_class|
+        Association.new parent, depolymorphic_reflection(ref, klass, poly_class)
       }
     end
     
@@ -119,6 +114,16 @@ 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

data/lib/thinking_sphinx/attribute.rb

@@ -7,10 +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,
@@ -21,11 +21,11 @@ module ThinkingSphinx
       :bigint    => :sql_attr_bigint,
       :wordcount => :sql_attr_str2wordcount
     }
-    
+
     if Riddle.loaded_version.to_i > 1
       SphinxTypeMappings[:string] = :sql_attr_string
     end
-    
+
     # To create a new attribute, you'll need to pass in either a single Column
     # or an array of them, and some (optional) options.
     #
@@ -37,13 +37,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
@@ -81,33 +81,34 @@ 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?
-      
+
       separator = all_ints? || all_datetimes? || @crc ? ',' : ' '
-      
+
       clause = columns_with_prefixes.collect { |column|
         case type
         when :string
@@ -122,28 +123,28 @@ 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]
     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" :
@@ -153,12 +154,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
@@ -169,21 +170,23 @@ 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) && !is_string?
+      [:integer, :datetime, :boolean].include?(type) &&
+      unique_name != :sphinx_internal_id &&
+      !is_string?
     end
-    
+
     def live_value(instance)
       object = instance
       column = @columns.first
@@ -191,29 +194,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_of_type?(:integer)
+      @all_ints || 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
@@ -225,12 +228,12 @@ module ThinkingSphinx
         "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')},
@@ -238,12 +241,12 @@ SELECT #{foreign_key_for_mva base_assoc}
 FROM #{quote_table_name base_assoc.table} #{association_joins}
       SQL
     end
-    
+
     def query_clause
       foreign_key = foreign_key_for_mva base_association_for_mva
       "WHERE #{foreign_key} >= $start AND #{foreign_key} <= $end"
     end
-    
+
     def query_delta
       foreign_key = foreign_key_for_mva base_association_for_mva
       <<-SQL
@@ -252,40 +255,40 @@ 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].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
@@ -293,22 +296,22 @@ WHERE #{@source.index.delta_object.clause(model, true)})
         joins << assoc.to_sql
         assoc = assoc.parent
       end
-      
+
       joins.join(' ')
     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
@@ -330,16 +333,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
@@ -347,16 +350,16 @@ 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].empty? ? [@model] :
@@ -367,7 +370,7 @@ block:
         }
       }
     end
-    
+
     def sphinx_value(value)
       case value
       when TrueClass
@@ -384,7 +387,7 @@ block:
         value
       end
     end
-    
+
     def insensitive?
       @sortable == :insensitive
     end