freelancing-god-thinking-sphinx 1.1.12 → 1.1.14

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.
@@ -432,21 +436,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
@@ -717,75 +706,6 @@ 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
-            }
-          }
-        }
-      end
     end
   end
 end

data/lib/thinking_sphinx/search/facets.rb

@@ -0,0 +1,98 @@
+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
+        
+        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)
+        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
+    
+    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
+      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)
+      attributes.each do |attrib|
+        source.send(attrib.type_to_config) << attrib.config_value(offset)
+      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 @options[:group_concat_max_len]
+        source.sql_query_pre << "SET SESSION group_concat_max_len = #{@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

data/lib/thinking_sphinx/source/internal_properties.rb

@@ -0,0 +1,46 @@
+module ThinkingSphinx
+  class Source
+    module InternalProperties
+      def add_internal_attributes_and_facets
+        add_internal_attribute :sphinx_internal_id, :integer, @model.primary_key.to_sym
+        add_internal_attribute :class_crc,          :integer, crc_column, true
+        add_internal_attribute :subclass_crcs,      :multi,   subclasses_to_s
+        add_internal_attribute :sphinx_deleted,     :integer, "0"
+
+        add_internal_facet :class_crc
+      end
+
+      def add_internal_attribute(name, type, contents, facet = false)
+        return unless attribute_by_alias(name).nil?
+
+        Attribute.new(self,
+          ThinkingSphinx::Index::FauxColumn.new(contents),
+          :type   => type,
+          :as     => name,
+          :facet  => facet,
+          :admin  => true
+        )
+      end
+
+      def add_internal_facet(name)
+        return unless facet_by_alias(name).nil?
+
+        @model.sphinx_facets << ClassFacet.new(attribute_by_alias(name))
+      end
+
+      def attribute_by_alias(attr_alias)
+        @attributes.detect { |attrib| attrib.alias == attr_alias }
+      end
+
+      def facet_by_alias(name)
+        @model.sphinx_facets.detect { |facet| facet.name == name }
+      end
+
+      def subclasses_to_s
+        "'" + (@model.send(:subclasses).collect { |klass|
+          klass.to_crc32.to_s
+        } << @model.to_crc32.to_s).join(",") + "'"
+      end
+    end
+  end
+end