ultrasphinx 1.8 → 1.9

data/lib/ultrasphinx/core_extensions.rb

@@ -27,6 +27,15 @@ class Object
   end
 end
 
+#class HashWithIndifferentAccess
+#  # Returns a regular Hash with all string keys. Much faster
+#  # than HWIA#merge.
+#  def _fast_merge(right)
+#    left = Hash[self]
+#    left.merge!(self.class.new(right))
+#  end
+#end
+
 class Hash
   def _coerce_basic_types
     # XXX To remove
@@ -89,7 +98,7 @@ class String
   end
   
   def _interpolate(value)
-    self.sub('?', value)
+    self.gsub('?', value)
   end
 end
 

data/lib/ultrasphinx/is_indexed.rb

@@ -58,7 +58,7 @@ The keys <tt>:facet</tt>, <tt>:sortable</tt>, <tt>:class_name</tt>, <tt>:associa
 
 == Concatenating several fields within one record
 
-Use the <tt>:concatenate</tt> key (MySQL only).
+Use the <tt>:concatenate</tt> key.
 
 Accepts an array of option hashes. 
 
@@ -88,6 +88,26 @@ Also, If you want to include a model that you don't have an actual ActiveRecord
 
 Ultrasphinx is not an object-relational mapper, and the association generation is intended to stay minimal--don't be afraid of <tt>:association_sql</tt>.
 
+== Enabling delta indexing
+
+Use the <tt>:delta</tt> key.
+
+Accepts either <tt>true</tt>, or a hash with a <tt>:field</tt> key.
+
+If you pass <tt>true</tt>, the <tt>updated_at</tt> column will be used for choosing the delta records, if it exists. If it doesn't exist, the entire table will be reindexed at every delta. Example:
+
+  :delta => true
+
+If you need to use a non-default column name, use a hash:
+ 
+  :delta => {:field => 'created_at'}
+  
+Note that the column type must be time-comparable in the DB. Also note that faceting may return higher counts than actually exist on delta-indexed tables, and that sorting by string columns will not work well. These are both limitations of Sphinx's index merge scheme. You can perhaps mitigate the issues by only searching the main index for facets or sorts:
+
+  Ultrasphinx::Search.new(:query => "query", :indexes => Ultrasphinx::MAIN_INDEX)
+
+The date range of the delta include is set in the <tt>.base</tt> file.
+
 = Examples
 
 == Complex configuration
@@ -110,6 +130,7 @@ Here's an example configuration using most of the options, taken from production
         {:association_name => 'comments', :field => 'body', :as => 'comments', 
           :conditions => "comments.item_type = '#{base_class}'"}
       ],
+      :delta => {:field => 'published_at'},
       :conditions => self.live_condition_string
   end  
 
@@ -137,16 +158,38 @@ If the associations weren't just <tt>has_many</tt> and <tt>belongs_to</tt>, you
     def self.is_indexed opts = {}    
       opts = HashWithIndifferentAccess.new(opts)
           
-      opts.assert_valid_keys ['fields', 'concatenate', 'conditions', 'include']
+      opts.assert_valid_keys ['fields', 'concatenate', 'conditions', 'include', 'delta']
+
+      # Single options
       
-      Array(opts['fields']).each do |entry|
+      if opts['conditions']
+        # Do nothing
+      end
+      
+      if opts['delta']
+        if opts['delta'] == true
+          opts['delta'] = {'field' => 'updated_at'} 
+        elsif opts['delta'].is_a? String
+          opts['delta'] = {'field' => opts['delta']} 
+        end
+        opts['delta'].stringify_keys!
+        opts['delta'].assert_valid_keys ['field']
+      end
+      
+      # Enumerable options
+      
+      opts['fields'] = Array(opts['fields'])
+      opts['concatenate'] = Array(opts['concatenate'])
+      opts['include'] = Array(opts['include'])
+                  
+      opts['fields'].each do |entry|
         if entry.is_a? Hash
           entry.stringify_keys!
           entry.assert_valid_keys ['field', 'as', 'facet', 'function_sql', 'sortable']
         end
       end
       
-      Array(opts['concatenate']).each do |entry|
+      opts['concatenate'].each do |entry|
         entry.stringify_keys!
         entry.assert_valid_keys ['class_name', 'association_name', 'conditions', 'field', 'as', 'fields', 'association_sql', 'facet', 'function_sql', 'sortable']
         raise Ultrasphinx::ConfigurationError, "You can't mix regular concat and group concats" if entry['fields'] and (entry['field'] or entry['class_name'] or entry['association_name'])
@@ -155,11 +198,11 @@ If the associations weren't just <tt>has_many</tt> and <tt>belongs_to</tt>, you
         raise Ultrasphinx::ConfigurationError, "Regular concatenations should have multiple fields" if entry['fields'] and !entry['fields'].is_a?(Array)
       end
       
-      Array(opts['include']).each do |entry|
+      opts['include'].each do |entry|
         entry.stringify_keys!
         entry.assert_valid_keys ['class_name', 'association_name', 'field', 'as', 'association_sql', 'facet', 'function_sql', 'sortable']
       end
-      
+            
       Ultrasphinx::MODEL_CONFIGURATION[self.name] = opts
     end
   end

data/lib/ultrasphinx/search.rb

@@ -24,7 +24,7 @@ Now, to run the query, call its <tt>run</tt> method. Your results will be availa
 The query string supports boolean operation, parentheses, phrases, and field-specific search. Query words are stemmed and joined by an implicit <tt>AND</tt> by default.
 
 * Valid boolean operators are <tt>AND</tt>, <tt>OR</tt>, and <tt>NOT</tt>.
-* Field-specific searches should be formatted as <tt>fieldname:contents</tt>. (This will only work for text fields. For numeric and date fields, see the <tt>'filters</tt> parameter, below.)
+* Field-specific searches should be formatted as <tt>fieldname:contents</tt>. (This will only work for text fields. For numeric and date fields, see the <tt>:filters</tt> parameter, below.)
 * Phrases must be enclosed in double quotes.
     
 A Sphinx::SphinxInternalError will be raised on invalid queries. In general, queries can only be nested to one level. 
@@ -42,10 +42,11 @@ The hash lets you customize internal aspects of the search.
 <tt>:weights</tt>:: A hash. Text-field names and associated query weighting. The default weight for every field is 1.0. Example: <tt>:weights => {'title' => 2.0}</tt>
 <tt>:filters</tt>:: A hash. Names of numeric or date fields and associated values. You can use a single value, an array of values, or a range. (See the bottom of the ActiveRecord::Base page for an example.)
 <tt>:facets</tt>:: An array of fields for grouping/faceting. You can access the returned facet values and their result counts with the <tt>facets</tt> method.
+<tt>:indexes</tt>:: An array of indexes to search. Currently only <tt>Ultrasphinx::MAIN_INDEX</tt> and <tt>Ultrasphinx::DELTA_INDEX</tt> are available. Defaults to both; changing this is rarely needed.
 
 Note that you can set up your own query defaults in <tt>environment.rb</tt>: 
   
-  Ultrasphinx::Search.query_defaults = HashWithIndifferentAccess.new({
+  self.class.query_defaults = HashWithIndifferentAccess.new({
     :per_page => 10,
     :sort_mode => 'relevance',
     :weights => {'title' => 2.0}
@@ -53,9 +54,9 @@ Note that you can set up your own query defaults in <tt>environment.rb</tt>:
 
 = Advanced features
 
-== Cache_fu integration
+== Interlock integration
   
-The <tt>get_cache</tt> method will be used to instantiate records for models that respond to it. Otherwise, <tt>find</tt> is used.
+Ultrasphinx uses the <tt>find_all_by_id</tt> method to instantiate records. If you set <tt>with_finders: true</tt> in {Interlock's}[http://blog.evanweaver.com/files/doc/fauna/interlock] <tt>config/memcached.yml</tt>, Interlock overrides <tt>find_all_by_id</tt> with a caching version.
 
 == Will_paginate integration
 
@@ -100,6 +101,10 @@ Note that your database is never changed by anything Ultrasphinx does.
       :per_page => 20,
       :sort_by => nil,
       :sort_mode => 'relevance',
+      :indexes => [
+          MAIN_INDEX, 
+          (DELTA_INDEX if Ultrasphinx.delta_index_present?)
+        ].compact,
       :weights => {},
       :class_names => [],
       :filters => {},
@@ -112,7 +117,8 @@ Note that your database is never changed by anything Ultrasphinx does.
       :chunk_separator => "...",
       :limit => 256,
       :around => 3,
-      # Results should respond to one in each group of these, in precedence order, for the excerpting to fire
+      # Results should respond to one in each group of these, in precedence order, for the 
+      # excerpting to fire
       :content_methods => [['title', 'name'], ['body', 'description', 'content'], ['metadata']] 
     })
     
@@ -120,63 +126,41 @@ Note that your database is never changed by anything Ultrasphinx does.
     self.client_options ||= HashWithIndifferentAccess.new({ 
       :with_subtotals => false, 
       :ignore_missing_records => false,
-      :max_missing_records => 5, # Has no effect if :ignore_missing_records => false
+      # Has no effect if :ignore_missing_records => false
+      :max_missing_records => 5, 
       :max_retries => 4,
       :retry_sleep_time => 0.5,
-      :max_facets => 100,
-      :finder_methods => ['get_cache', 'find']
+      :max_facets => 1000,
+      :max_matches_offset => 1000,
+      # Whether to add an accessor to each returned result that specifies its global rank in 
+      # the search.
+      :with_global_rank => false,
+      # Which method names to try to use for loading records. You can define your own (for 
+      # example, with :includes) and then attach it here. Each method must accept an Array 
+      # of ids, but do not have to preserve order. If the class does not respond_to? any 
+      # method name in the array, :find_all_by_id will be used.
+      :finder_methods => [] 
     })
     
     # Friendly sort mode mappings    
-    SPHINX_CLIENT_PARAMS = HashWithIndifferentAccess.new({ 
-      :sort_mode => HashWithIndifferentAccess.new({
+    SPHINX_CLIENT_PARAMS = { 
+      'sort_mode' => {
         'relevance' => :relevance,
         'descending' => :attr_desc, 
         'ascending' => :attr_asc, 
         'time' => :time_segments,
         'extended' => :extended,
-      })
-    })
+      }
+    }
     
     INTERNAL_KEYS = ['parsed_query'] #:nodoc:
 
-    def self.get_models_to_class_ids #:nodoc:
-      # Reading the conf file makes sure that we are in sync with the actual Sphinx index,
-      # not whatever you happened to change your models to most recently
-      unless File.exist? CONF_PATH
-        Ultrasphinx.say "configuration file not found for #{RAILS_ENV.inspect} environment"
-        Ultrasphinx.say "please run 'rake ultrasphinx:configure'"
-      else
-        begin  
-          lines = open(CONF_PATH).readlines          
+    MODELS_TO_IDS = Ultrasphinx.get_models_to_class_ids || {} 
 
-          sources = lines.select do |line| 
-            line =~ /^source \w/
-          end.map do |line| 
-            line[/source ([\w\d_-]*)/, 1].gsub('__', '/').classify
-          end
-          
-          ids = lines.select do |line| 
-            line =~ /^sql_query /
-          end.map do |line| 
-            line[/(\d*) AS class_id/, 1].to_i
-          end
-          
-          raise unless sources.size == ids.size          
-          Hash[*sources.zip(ids).flatten]
-                                  
-        rescue
-          Ultrasphinx.say "#{CONF_PATH} file is corrupted"
-          Ultrasphinx.say "please run 'rake ultrasphinx:configure'"
-        end    
-        
-      end
-    end
-
-    MODELS_TO_IDS = get_models_to_class_ids || {} 
-      
-    MAX_MATCHES = DAEMON_SETTINGS["max_matches"].to_i 
+    IDS_TO_MODELS = MODELS_TO_IDS.invert #:nodoc:
     
+    MAX_MATCHES = DAEMON_SETTINGS["max_matches"].to_i 
+
     FACET_CACHE = {} #:nodoc: 
     
     # Returns the options hash.
@@ -214,9 +198,11 @@ Note that your database is never changed by anything Ultrasphinx does.
       @response
     end
     
-    # Returns a hash of total result counts, scoped to each available model. This requires extra queries against the search daemon right now. Set <tt>Ultrasphinx::Search.client_options[:with_subtotals] = true</tt> to enable the extra queries. Most of the overhead is in instantiating the AR result sets, so the performance hit is not usually significant.
+    # Returns a hash of total result counts, scoped to each available model. Set <tt>Ultrasphinx::Search.client_options[:with_subtotals] = true</tt> to enable.
+    # 
+    # The subtotals are implemented as a special type of facet.
     def subtotals
-      raise UsageError, "Subtotals are not enabled" unless Ultrasphinx::Search.client_options['with_subtotals']
+      raise UsageError, "Subtotals are not enabled" unless self.class.client_options['with_subtotals']
       require_run
       @subtotals
     end
@@ -267,16 +253,25 @@ Note that your database is never changed by anything Ultrasphinx does.
     # Returns the global index position of the first result on this page.
     def offset 
       (current_page - 1) * per_page
-    end    
+    end
     
     # Builds a new command-interface Search object.
     def initialize opts = {} 
-      opts = HashWithIndifferentAccess.new(opts)            
-      @options = Ultrasphinx::Search.query_defaults.merge(opts._deep_dup._coerce_basic_types)            
 
+      # Change to normal hashes with String keys for speed
+      opts = Hash[HashWithIndifferentAccess.new(opts._deep_dup._coerce_basic_types)]
+      unless self.class.query_defaults.instance_of? Hash
+        self.class.query_defaults = Hash[self.class.query_defaults]
+        self.class.client_options = Hash[self.class.client_options]
+        self.class.excerpting_options = Hash[self.class.excerpting_options]
+        self.class.excerpting_options['content_methods'].map! {|ary| ary.map {|m| m.to_s}}
+      end    
+      
+      @options = self.class.query_defaults.merge(opts)            
       @options['query'] = @options['query'].to_s
       @options['class_names'] = Array(@options['class_names'])
       @options['facets'] = Array(@options['facets'])
+      @options['indexes'] = Array(@options['indexes']).join(" ")
             
       raise UsageError, "Weights must be a Hash" unless @options['weights'].is_a? Hash
       raise UsageError, "Filters must be a Hash" unless @options['filters'].is_a? Hash
@@ -285,22 +280,30 @@ Note that your database is never changed by anything Ultrasphinx does.
   
       @results, @subtotals, @facets, @response = [], {}, {}, {}
         
-      extra_keys = @options.keys - (SPHINX_CLIENT_PARAMS.merge(Ultrasphinx::Search.query_defaults).keys + INTERNAL_KEYS)
+      extra_keys = @options.keys - (self.class.query_defaults.keys + INTERNAL_KEYS)
       say "discarded invalid keys: #{extra_keys * ', '}" if extra_keys.any? and RAILS_ENV != "test" 
     end
     
-    # Run the search, filling results with an array of ActiveRecord objects. Set the parameter to false if you only want the ids returned.
+    # Run the search, filling results with an array of ActiveRecord objects. Set the parameter to false 
+    # if you only want the ids returned.
     def run(reify = true)
       @request = build_request_with_options(@options)
 
       say "searching for #{@options.inspect}"
 
       perform_action_with_retries do
-        @response = @request.query(parsed_query, UNIFIED_INDEX_NAME)
+        @response = @request.query(parsed_query, @options['indexes'])
         say "search returned #{total_entries}/#{response[:total_found].to_i} in #{time.to_f} seconds."
           
-        if Ultrasphinx::Search.client_options['with_subtotals']        
+        if self.class.client_options['with_subtotals']        
           @subtotals = get_subtotals(@request, parsed_query) 
+          
+          # If the original query has a filter on this class, we will use its more accurate total rather the facet's 
+          # less accurate total.
+          if @options['class_names'].size == 1
+            @subtotals[@options['class_names'].first] = response[:total_found]
+          end
+          
         end
         
         Array(@options['facets']).each do |facet|
@@ -318,19 +321,22 @@ Note that your database is never changed by anything Ultrasphinx does.
     end
   
   
-    # Overwrite the configured content accessors with excerpted and highlighted versions of themselves.
-    # Runs run if it hasn't already been done. Please note that this does not change the @attributes
-    # hash in the record; only the accessor.
+    # Overwrite the configured content attributes with excerpted and highlighted versions of themselves.
+    # Runs run if it hasn't already been done.
     def excerpt
     
       require_run         
       return if results.empty?
     
-      # See what fields each result might respond to for our excerpting
+      # See what fields in each result might respond to our excerptable methods
       results_with_content_methods = results.map do |result|
-        [result] << Ultrasphinx::Search.excerpting_options['content_methods'].map do |methods|
-          methods.detect { |x| result.respond_to? x }
-        end
+        [result, 
+          self.class.excerpting_options['content_methods'].map do |methods|
+            methods.detect do |this| 
+              result.respond_to? this
+            end
+          end
+        ]
       end
   
       # Fetch the actual field contents
@@ -341,10 +347,11 @@ Note that your database is never changed by anything Ultrasphinx does.
       end.flatten
       
       excerpting_options = {
-        :docs => docs, 
-        :index => UNIFIED_INDEX_NAME, 
-        :words => strip_query_commands(parsed_query)}
-      Ultrasphinx::Search.excerpting_options.except('content_methods').each do |key, value|
+        :docs => docs,         
+        :index => MAIN_INDEX, # http://www.sphinxsearch.com/forum/view.html?id=100
+        :words => strip_query_commands(parsed_query)
+      }
+      self.class.excerpting_options.except('content_methods').each do |key, value|
         # Riddle only wants symbols
         excerpting_options[key.to_sym] ||= value
       end
@@ -354,13 +361,18 @@ Note that your database is never changed by anything Ultrasphinx does.
         @request.excerpts(excerpting_options)
       end
       
-      responses = responses.in_groups_of(Ultrasphinx::Search.excerpting_options['content_methods'].size)
+      responses = responses.in_groups_of(self.class.excerpting_options['content_methods'].size)
       
       results_with_content_methods.each_with_index do |result_and_methods, i|
         # Override the individual model accessors with the excerpted data
         result, methods = result_and_methods
         methods.each_with_index do |method, j|
-          result._metaclass.send('define_method', method) { responses[i][j] } if method
+          data = responses[i][j]
+          if method
+            result._metaclass.send('define_method', method) { data }
+            attributes = result.instance_variable_get('@attributes')
+            attributes[method] = data if attributes[method]
+          end
         end
       end
   

data/lib/ultrasphinx/search/internals.rb

@@ -17,7 +17,7 @@ module Ultrasphinx
           @match_mode = :extended # Force extended query mode
           @offset = opts['per_page'] * (opts['page'] - 1)
           @limit = opts['per_page']
-          @max_matches = [@offset + @limit, MAX_MATCHES].min
+          @max_matches = [@offset + @limit + Ultrasphinx::Search.client_options['max_matches_offset'], MAX_MATCHES].min
         end
           
         # Sorting
@@ -40,9 +40,13 @@ module Ultrasphinx
         weights = opts['weights']
         if weights.any?
           # Order according to the field order for Sphinx, and set the missing fields to 1.0
-          request.weights = (Fields.instance.types.select{|n,t| t == 'text'}.map(&:first).sort.inject([]) do |array, field|
-            array << (weights[field] || 1.0)
-          end)
+          ordered_weights = []
+          Fields.instance.types.map do |name, type| 
+            name if type == 'text'
+          end.compact.sort.each do |name|
+            ordered_weights << (weights[name] || 1.0)
+          end
+          request.weights = ordered_weights
         end
         
         # Class names
@@ -126,12 +130,12 @@ module Ultrasphinx
           @group_clauses = '@count desc'
           @offset = 0
           @limit = Ultrasphinx::Search.client_options['max_facets']
-          @max_matches = [@limit, MAX_MATCHES].min
+          @max_matches = [@limit + Ultrasphinx::Search.client_options['max_matches_offset'], MAX_MATCHES].min
         end
         
         # Run the query
         begin
-          matches = request.query(query, UNIFIED_INDEX_NAME)[:matches]
+          matches = request.query(query, options['indexes'])[:matches]
         rescue DaemonError
           raise ConfigurationError, "Index seems out of date. Run 'rake ultrasphinx:index'"
         end
@@ -171,7 +175,7 @@ module Ultrasphinx
 
           # Concatenates might not work well
           type, configuration = nil, nil
-          MODEL_CONFIGURATION[klass.name].except('conditions').each do |_type, values| 
+          MODEL_CONFIGURATION[klass.name].except('conditions', 'delta').each do |_type, values| 
             type = _type
             configuration = values.detect { |this_field| this_field['as'] == facet }
             break if configuration
@@ -192,16 +196,16 @@ module Ultrasphinx
               [configuration['field'], ""]
             when 'include'
               # XXX Only handles the basic case. No test coverage.
-              
+
               table_alias = configuration['table_alias']
               association_model = if configuration['class_name']
                 configuration['class_name'].constantize
               else
                 get_association_model(klass, configuration)
               end
-              
-              ["table_alias.#{configuration['field']}", 
-                (configuration['association_sql'] or "LEFT OUTER JOIN #{association_model.table_name} AS table_alias ON table_alias.#{association_model.primary_key} = #{klass.table_name}.#{association_model.class_name.underscore}_id")
+
+              ["#{table_alias}.#{configuration['field']}", 
+                (configuration['association_sql'] or "LEFT OUTER JOIN #{association_model.table_name} AS #{table_alias} ON #{table_alias}.#{klass.to_s.downcase}_id = #{klass.table_name}.#{association_model.primary_key}")
               ]
             when 'concatenate'
               # Wait for someone to complain before worrying about this
@@ -222,12 +226,13 @@ module Ultrasphinx
             
       # Inverse-modulus map the Sphinx ids to the table-specific ids
       def convert_sphinx_ids(sphinx_ids)    
+        number_of_models = IDS_TO_MODELS.size
         sphinx_ids.sort_by do |item| 
           item[:index]
         end.map do |item|
-          class_name = MODELS_TO_IDS.invert[item[:doc] % MODELS_TO_IDS.size]
+          class_name = IDS_TO_MODELS[item[:doc] % number_of_models]
           raise DaemonError, "Impossible Sphinx document id #{item[:doc]} in query result" unless class_name
-          [class_name, item[:doc] / MODELS_TO_IDS.size]
+          [class_name, item[:doc] / number_of_models]
         end
       end
 
@@ -235,39 +240,57 @@ module Ultrasphinx
       def reify_results(ids)
         results = []
         
-        ids.each do |klass_name, id|
+        ids_hash = {}
+        ids.each do |class_name, id|
+          (ids_hash[class_name] ||= []) << id
+        end
         
-          # What class and class method are we using to get the record?
-          klass = klass_name.constantize
-          finder = Ultrasphinx::Search.client_options['finder_methods'].detect do |method_name|
-            klass.respond_to? method_name
-          end
+        ids.map {|ary| ary.first}.uniq.each do |class_name|
+          klass = class_name.constantize
           
-          # Load it
-          begin
-            # XXX Does not use Memcached's multiget, or MySQL's, for that matter
-            record = klass.send(finder, id)
-            raise ActiveRecord::RecordNotFound unless record
-          rescue ActiveRecord::RecordNotFound => e
-            if Ultrasphinx::Search.client_options['ignore_missing_records']
-              say "warning; #{klass}.#{finder}(#{id}) returned RecordNotFound"
-            else
-              raise(e)
+          finder = (
+            Ultrasphinx::Search.client_options['finder_methods'].detect do |method_name| 
+              klass.respond_to? method_name
+            end or
+              # XXX This default is kind of buried, but I'm not sure why you would need it to be 
+              # configurable, since you can use ['finder_methods'].
+              "find_all_by_id"
+            )
+
+          records = klass.send(finder, ids_hash[class_name])
+          
+          unless Ultrasphinx::Search.client_options['ignore_missing_records']
+            if records.size != ids_hash[class_name].size
+              missed_ids = ids_hash[class_name] - records.map(&:id)
+              msg = if missed_ids.size == 1
+                "Couldn't find #{class_name} with ID=#{missed_ids.first}"
+              else
+                "Couldn't find #{class_name.pluralize} with IDs: #{missed_ids.join(',')} (found #{records.size} results, but was looking for #{ids_hash[class_name].size})"
+              end
+              raise ActiveRecord::RecordNotFound, msg
             end
-          end  
+          end
           
-          # Add it to the list. Cache_fu does funny things with returned record organization.
-          results += record.is_a?(Hash) ? record.values : Array(record)                
+          records.each do |record|
+            results[ids.index([class_name, record.id])] = record
+          end
         end
-    
-        # Add an accessor for absolute search rank for each record (does anyone use this?)
-        results.each_with_index do |result, index|
-          i = per_page * (current_page - 1) + index
-          result._metaclass.send('define_method', 'result_index') { i }
+        
+        # Add an accessor for global search rank for each record, if requested
+        if self.class.client_options['with_global_rank']
+          # XXX Nobody uses this
+          results.each_with_index do |result, index|
+            if result
+              global_index = per_page * (current_page - 1) + index
+              result.instance_variable_get('@attributes')['result_index'] = global_index
+            end
+          end
         end
         
+        results.compact!
+        
         if ids.size - results.size > Ultrasphinx::Search.client_options['max_missing_records']
-          # Never reached if Ultrasphinx::Search.client_options['ignore_missing_records'] is false
+          # Never reached if Ultrasphinx::Search.client_options['ignore_missing_records'] is false due to raise
           raise ConfigurationError, "Too many results for this query returned ActiveRecord::RecordNotFound. The index is probably out of date" 
         end