dpickett-thinking-sphinx 1.1.12 → 1.1.23

data/lib/thinking_sphinx/property.rb

@@ -2,15 +2,23 @@ module ThinkingSphinx
   class Property
     attr_accessor :alias, :columns, :associations, :model, :faceted, :admin
     
-    def initialize(columns, options = {})
+    def initialize(source, columns, options = {})
+      @source       = source
+      @model        = source.model
       @columns      = Array(columns)
       @associations = {}
 
-      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) }
+      raise "Cannot define a field or attribute in #{source.model.name} 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]
       @faceted  = options[:facet]
       @admin    = options[:admin]
+      
+      @columns.each { |col|
+        @associations[col] = association_stack(col.__stack.clone).each { |assoc|
+          assoc.join_to(source.base)
+        }
+      }
     end
     
     # Returns the unique name of the attribute - which is either the alias of
@@ -129,5 +137,24 @@ module ThinkingSphinx
         }.compact.join(', ')
       end
     end
+    
+    # Gets a stack of associations for a specific path.
+    # 
+    def association_stack(path, parent = nil)
+      assocs = []
+      
+      if parent.nil?
+        assocs = @source.association(path.shift)
+      else
+        assocs = parent.children(path.shift)
+      end
+      
+      until path.empty?
+        point  = path.shift
+        assocs = assocs.collect { |assoc| assoc.children(point) }.flatten
+      end
+      
+      assocs
+    end
   end
 end

data/lib/thinking_sphinx/search.rb

@@ -1,3 +1,5 @@
+require 'thinking_sphinx/search/facets'
+
 module ThinkingSphinx
   # Once you've got those indexes in and built, this is the stuff that
   # matters - how to search! This class provides a generic search
@@ -13,6 +15,8 @@ module ThinkingSphinx
     }
     
     class << self
+      include ThinkingSphinx::Search::Facets
+      
       # Searches for results that match the parameters provided. Will only
       # return the ids for the matching objects. See #search for syntax
       # examples.
@@ -218,6 +222,10 @@ module ThinkingSphinx
       # * <tt>:group_by</tt> determines the field which is used for grouping
       # * <tt>:group_clause</tt> determines the sorting order 
       #
+      # As a convenience, you can also use
+      # * <tt>:group</tt>
+      # which sets :group_by and defaults to :group_function of :attr
+      # 
       # === group_function
       #  
       # Valid values for :group_function are
@@ -354,10 +362,8 @@ module ThinkingSphinx
         
         retry_search_on_stale_index(query, options) do
           results, client = search_results(*(query + [options]))
-        
-          ::ActiveRecord::Base.logger.error(
-            "Sphinx Error: #{results[:error]}"
-          ) if results[:error]
+          
+          log "Sphinx Error: #{results[:error]}", :error if results[:error]
         
           klass   = options[:class]
           page    = options[:page] ? options[:page].to_i : 1
@@ -390,9 +396,9 @@ module ThinkingSphinx
           options[:without_ids] = Array(options[:without_ids]) | e.ids  # Actual exclusion
 
           tries = stale_retries_left
-          ::ActiveRecord::Base.logger.debug("Sphinx Stale Ids (%s %s left): %s" % [
-              tries, (tries==1 ? 'try' : 'tries'), stale_ids.join(', ')
-          ])
+          log "Sphinx Stale Ids (%s %s left): %s" % [
+            tries, (tries==1 ? 'try' : 'tries'), stale_ids.join(', ')
+          ]
           
           retry
         end
@@ -432,21 +438,6 @@ module ThinkingSphinx
         end
       end
       
-      # Model.facets *args
-      # ThinkingSphinx::Search.facets *args
-      # ThinkingSphinx::Search.facets *args, :all_attributes  => true
-      # ThinkingSphinx::Search.facets *args, :class_facet     => false
-      # 
-      def facets(*args)
-        options = args.extract_options!
-        
-        if options[:class]
-          facets_for_model options[:class], args, options
-        else
-          facets_for_all_models args, options
-        end
-      end
-      
       private
       
       # This method handles the common search functionality, and returns both
@@ -474,11 +465,14 @@ module ThinkingSphinx
         page          = options[:page] ? options[:page].to_i : 1
         page          = 1 if page <= 0
         client.offset = (page - 1) * client.limit
-
+        
         begin
-          ::ActiveRecord::Base.logger.debug "Sphinx: #{query}"
-          results = client.query query
-          ::ActiveRecord::Base.logger.debug "Sphinx Result: #{results[:matches].collect{|m| m[:attributes]["sphinx_internal_id"]}.inspect}"
+          log "Sphinx: #{query}"
+          results = client.query(query, '*', options[:comment] || '')
+          log "Sphinx Result:"
+          log results[:matches].collect { |m|
+            m[:attributes]["sphinx_internal_id"]
+          }.inspect
         rescue Errno::ECONNREFUSED => err
           raise ThinkingSphinx::ConnectionError, "Connection to Sphinx Daemon (searchd) failed."
         end
@@ -518,6 +512,12 @@ module ThinkingSphinx
           end
         end
         
+        # Group by defaults using :group
+        if options[:group]
+          options[:group_by] = options[:group].to_s
+          options[:group_function] ||= :attr
+        end
+        
         [
           :max_matches, :match_mode, :sort_mode, :sort_by, :id_range,
           :group_by, :group_function, :group_clause, :group_distinct, :cut_off,
@@ -642,11 +642,11 @@ module ThinkingSphinx
         }.flatten : []
         
         lat_attr = klass ? klass.sphinx_indexes.collect { |index|
-          index.options[:latitude_attr]
+          index.local_options[:latitude_attr]
         }.compact.first : nil
         
         lon_attr = klass ? klass.sphinx_indexes.collect { |index|
-          index.options[:longitude_attr]
+          index.local_options[:longitude_attr]
         }.compact.first : nil
         
         lat_attr = options[:latitude_attr] if options[:latitude_attr]
@@ -695,7 +695,7 @@ module ThinkingSphinx
             client.sort_by = order.to_s
           end
         when String
-          client.sort_mode = :extended
+          client.sort_mode = :extended unless options[:sort_mode]
           client.sort_by   = sorted_fields_to_attributes(order, fields)
         else
           # do nothing
@@ -718,73 +718,9 @@ module ThinkingSphinx
         string
       end
       
-      def facets_for_model(klass, args, options)
-        hash    = ThinkingSphinx::FacetCollection.new args + [options]
-        options = options.clone.merge! facet_query_options
-        
-        klass.sphinx_facets.inject(hash) do |hash, facet|
-          unless facet.name == :class && !options[:class_facet]
-            options[:group_by]    = facet.attribute_name
-            hash.add_from_results facet, search(*(args + [options]))
-          end
-          
-          hash
-        end
-      end
-      
-      def facets_for_all_models(args, options)
-        options = GlobalFacetOptions.merge(options)
-        hash    = ThinkingSphinx::FacetCollection.new args + [options]
-        options = options.merge! facet_query_options
-        
-        facet_names(options).inject(hash) do |hash, name|
-          options[:group_by] = name
-          hash.add_from_results name, search(*(args + [options]))
-          hash
-        end
-      end
-      
-      def facet_query_options
-        config = ThinkingSphinx::Configuration.instance
-        max    = config.configuration.searchd.max_matches || 1000
-        
-        {
-          :group_function => :attr,
-          :limit          => max,
-          :max_matches    => max
-        }
-      end
-      
-      def facet_classes(options)
-        options[:classes] || ThinkingSphinx.indexed_models.collect { |model|
-          model.constantize
-        }
-      end
-      
-      def facet_names(options)
-        classes = facet_classes(options)
-        names   = options[:all_attributes] ?
-          facet_names_for_all_classes(classes) :
-          facet_names_common_to_all_classes(classes)
-        
-        names.delete "class_crc" unless options[:class_facet]
-        names
-      end
-      
-      def facet_names_for_all_classes(classes)
-        classes.collect { |klass|
-          klass.sphinx_facets.collect { |facet| facet.attribute_name }
-        }.flatten.uniq
-      end
-      
-      def facet_names_common_to_all_classes(classes)
-        facet_names_for_all_classes(classes).select { |name|
-          classes.all? { |klass|
-            klass.sphinx_facets.detect { |facet|
-              facet.attribute_name == name
-            }
-          }
-        }
+      def log(message, method = :debug)
+        return if ::ActiveRecord::Base.logger.nil?
+        ::ActiveRecord::Base.logger.send method, message
       end
     end
   end

data/lib/thinking_sphinx/search/facets.rb

@@ -0,0 +1,104 @@
+module ThinkingSphinx
+  class Search
+    module Facets
+      # Model.facets *args
+      # ThinkingSphinx::Search.facets *args
+      # ThinkingSphinx::Search.facets *args, :all_attributes  => true
+      # ThinkingSphinx::Search.facets *args, :class_facet     => false
+      # 
+      def facets(*args)
+        options = args.extract_options!
+        
+        if options[:class]
+          facets_for_model options[:class], args, options
+        else
+          facets_for_all_models args, options
+        end
+      end
+      
+      private
+      
+      def facets_for_model(klass, args, options)
+        hash    = ThinkingSphinx::FacetCollection.new args + [options]
+        options = options.clone.merge! facet_query_options
+        
+        facets  = klass.sphinx_facets
+        facets  = Array(options.delete(:facets)).collect { |name|
+          klass.sphinx_facets.detect { |facet| facet.name.to_s == name.to_s }
+        }.compact if options[:facets]
+        
+        facets.inject(hash) do |hash, facet|
+          unless facet.name == :class && !options[:class_facet]
+            options[:group_by]    = facet.attribute_name
+            hash.add_from_results facet, search(*(args + [options]))
+          end
+          
+          hash
+        end
+      end
+      
+      def facets_for_all_models(args, options)
+        options = GlobalFacetOptions.merge(options)
+        hash    = ThinkingSphinx::FacetCollection.new args + [options]
+        options = options.merge! facet_query_options
+        
+        facet_names(options).inject(hash) do |hash, name|
+          options[:group_by] = name
+          hash.add_from_results name, search(*(args + [options]))
+          hash
+        end
+      end
+      
+      def facet_query_options
+        config = ThinkingSphinx::Configuration.instance
+        max    = config.configuration.searchd.max_matches || 1000
+        
+        {
+          :group_function => :attr,
+          :limit          => max,
+          :max_matches    => max,
+          :page           => 1
+        }
+      end
+      
+      def facet_classes(options)
+        options[:classes] || ThinkingSphinx.indexed_models.collect { |model|
+          model.constantize
+        }
+      end
+      
+      def facet_names(options)
+        classes = facet_classes(options)
+        names   = options[:all_attributes] ?
+          facet_names_for_all_classes(classes) :
+          facet_names_common_to_all_classes(classes)
+        
+        names.delete "class_crc" unless options[:class_facet]
+        names
+      end
+      
+      def facet_names_for_all_classes(classes)
+        all_facets = classes.collect { |klass| klass.sphinx_facets }.flatten
+        
+        all_facets.group_by { |facet|
+          facet.name
+        }.collect { |name, facets|
+          if facets.collect { |facet| facet.type }.uniq.length > 1
+            raise "Facet #{name} exists in more than one model with different types"
+          end
+          facets.first.attribute_name
+        }
+      end
+      
+      def facet_names_common_to_all_classes(classes)
+        facet_names_for_all_classes(classes).select { |name|
+          classes.all? { |klass|
+            klass.sphinx_facets.detect { |facet|
+              facet.attribute_name == name
+            }
+          }
+        }
+      end
+    end
+  end
+end

data/lib/thinking_sphinx/source.rb

@@ -0,0 +1,150 @@
+require 'thinking_sphinx/source/internal_properties'
+require 'thinking_sphinx/source/sql'
+
+module ThinkingSphinx
+  class Source
+    include ThinkingSphinx::Source::InternalProperties
+    include ThinkingSphinx::Source::SQL
+    
+    attr_accessor :model, :fields, :attributes, :conditions, :groupings,
+      :options
+    attr_reader :base, :index
+    
+    def initialize(index, options = {})
+      @index        = index
+      @model        = index.model
+      @fields       = []
+      @attributes   = []
+      @conditions   = []
+      @groupings    = []
+      @options      = options
+      @associations = {}
+      
+      @base = ::ActiveRecord::Associations::ClassMethods::JoinDependency.new(
+        @model, [], nil
+      )
+      
+      unless @model.descends_from_active_record?
+        stored_class = @model.store_full_sti_class ? @model.name : @model.name.demodulize
+        @conditions << "#{@model.quoted_table_name}.#{quote_column(@model.inheritance_column)} = '#{stored_class}'"
+      end
+      
+      add_internal_attributes_and_facets
+    end
+    
+    def name
+      @model.name.underscore.tr(':/\\', '_')
+    end
+    
+    def to_riddle_for_core(offset, index)
+      source = Riddle::Configuration::SQLSource.new(
+        "#{name}_core_#{index}", adapter.sphinx_identifier
+      )
+      
+      set_source_database_settings  source
+      set_source_attributes         source, offset
+      set_source_sql                source, offset
+      set_source_settings           source
+      
+      source
+    end
+    
+    def to_riddle_for_delta(offset, index)
+      source = Riddle::Configuration::SQLSource.new(
+        "#{name}_delta_#{index}", adapter.sphinx_identifier
+      )
+      source.parent = "#{name}_core_#{index}"
+      
+      set_source_database_settings  source
+      set_source_attributes         source, offset, true
+      set_source_sql                source, offset, true
+      
+      source
+    end
+    
+    def delta?
+      !@index.delta_object.nil?
+    end
+    
+    # Gets the association stack for a specific key.
+    # 
+    def association(key)
+      @associations[key] ||= Association.children(@model, key)
+    end
+    
+    private
+    
+    def adapter
+      @adapter ||= @model.sphinx_database_adapter
+    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].to_s || "").gsub('#', '\#')
+      source.sql_db   = config[:database]
+      source.sql_port = config[:port]
+      source.sql_sock = config[:socket]
+    end
+    
+    def set_source_attributes(source, offset, delta = false)
+      attributes.each do |attrib|
+        source.send(attrib.type_to_config) << attrib.config_value(offset, delta)
+      end
+    end
+    
+    def set_source_sql(source, offset, delta = false)
+      source.sql_query        = to_sql(:offset => offset, :delta => delta).gsub(/\n/, ' ')
+      source.sql_query_range  = to_sql_query_range(:delta => delta)
+      source.sql_query_info   = to_sql_query_info(offset)
+      
+      source.sql_query_pre += send(!delta ? :sql_query_pre_for_core : :sql_query_pre_for_delta)
+      
+      if @index.local_options[:group_concat_max_len]
+        source.sql_query_pre << "SET SESSION group_concat_max_len = #{@index.local_options[:group_concat_max_len]}"
+      end
+      
+      source.sql_query_pre += [adapter.utf8_query_pre].compact if utf8?
+    end
+    
+    def set_source_settings(source)
+      config = ThinkingSphinx::Configuration.instance
+      config.source_options.each do |key, value|
+        source.send("#{key}=".to_sym, value)
+      end
+      
+      source_options = ThinkingSphinx::Configuration::SourceOptions
+      @options.each do |key, value|
+        if source_options.include?(key.to_s) && !value.nil?
+          source.send("#{key}=".to_sym, value)
+        end
+      end
+    end
+    
+    # Returns all associations used amongst all the fields and attributes.
+    # This includes all associations between the model and what the actual
+    # columns are from.
+    # 
+    def all_associations
+      @all_associations ||= (
+        # field associations
+        @fields.collect { |field|
+          field.associations.values
+        }.flatten +
+        # attribute associations
+        @attributes.collect { |attrib|
+          attrib.associations.values if attrib.include_as_association?
+        }.compact.flatten
+      ).uniq.collect { |assoc|
+        # get ancestors as well as column-level associations
+        assoc.ancestors
+      }.flatten.uniq
+    end
+    
+    def utf8?
+      @index.options[:charset_type] == "utf-8"
+    end
+  end
+end