DrMark-thinking-sphinx 0.9.9 → 1.1.6

data/lib/thinking_sphinx/core/string.rb

@@ -0,0 +1,15 @@
+require 'zlib'
+
+module ThinkingSphinx
+  module Core
+    module String
+      def to_crc32
+        Zlib.crc32 self
+      end
+    end
+  end
+end
+
+class String
+  include ThinkingSphinx::Core::String
+end

data/lib/thinking_sphinx/deltas.rb

@@ -0,0 +1,27 @@
+require 'thinking_sphinx/deltas/default_delta'
+require 'thinking_sphinx/deltas/delayed_delta'
+require 'thinking_sphinx/deltas/datetime_delta'
+
+module ThinkingSphinx
+  module Deltas
+    def self.parse(index, options)
+      delta_option = options.delete(:delta)
+      case delta_option
+      when TrueClass, :default
+        DefaultDelta.new index, options
+      when :delayed
+        DelayedDelta.new index, options
+      when :datetime
+        DatetimeDelta.new index, options
+      when FalseClass, nil
+        nil
+      else
+        if delta_option.ancestors.include?(ThinkingSphinx::Deltas::DefaultDelta)
+          delta_option.new index, options
+        else
+          raise "Unknown delta type"
+        end
+      end
+    end
+  end
+end

data/lib/thinking_sphinx/deltas/datetime_delta.rb

@@ -0,0 +1,50 @@
+module ThinkingSphinx
+  module Deltas
+    class DatetimeDelta < ThinkingSphinx::Deltas::DefaultDelta
+      attr_accessor :column, :threshold
+      
+      def initialize(index, options)
+        @index      = index
+        @column     = options.delete(:delta_column) || :updated_at
+        @threshold  = options.delete(:threshold)    || 1.day
+      end
+      
+      def index(model, instance = nil)
+        # do nothing
+        true
+      end
+      
+      def delayed_index(model)
+        config = ThinkingSphinx::Configuration.instance
+        rotate = ThinkingSphinx.sphinx_running? ? "--rotate" : ""
+        
+        output = `#{config.bin_path}indexer --config #{config.config_file} #{rotate} #{delta_index_name model}`
+        output += `#{config.bin_path}indexer --config #{config.config_file} #{rotate} --merge #{core_index_name model} #{delta_index_name model} --merge-dst-range sphinx_deleted 0 0`
+        puts output unless ThinkingSphinx.suppress_delta_output?
+        
+        true
+      end
+            
+      def toggle(instance)
+        # do nothing
+      end
+      
+      def toggled(instance)
+        instance.send(@column) > @threshold.ago
+      end
+      
+      def reset_query(model)
+        nil
+      end
+      
+      def clause(model, toggled)
+        if toggled
+          "#{model.quoted_table_name}.#{@index.quote_column(@column.to_s)}" +
+          " > #{adapter.time_difference(@threshold)}"
+        else
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/thinking_sphinx/deltas/default_delta.rb

@@ -0,0 +1,67 @@
+module ThinkingSphinx
+  module Deltas
+    class DefaultDelta
+      attr_accessor :column
+      
+      def initialize(index, options)
+        @index  = index
+        @column = options.delete(:delta_column) || :delta
+      end
+      
+      def index(model, instance = nil)
+        return true unless ThinkingSphinx.updates_enabled? &&
+          ThinkingSphinx.deltas_enabled?
+        return true if instance && !toggled(instance)
+        
+        config = ThinkingSphinx::Configuration.instance
+        client = Riddle::Client.new config.address, config.port
+        rotate = ThinkingSphinx.sphinx_running? ? "--rotate" : ""
+        
+        output = `#{config.bin_path}indexer --config #{config.config_file} #{rotate} #{delta_index_name model}`
+        puts(output) unless ThinkingSphinx.suppress_delta_output?
+        
+        client.update(
+          core_index_name(model),
+          ['sphinx_deleted'],
+          {instance.sphinx_document_id => [1]}
+        ) if instance && ThinkingSphinx.sphinx_running? && instance.in_both_indexes?
+        
+        true
+      end
+      
+      def toggle(instance)
+        instance.delta = true
+      end
+      
+      def toggled(instance)
+        instance.delta
+      end
+      
+      def reset_query(model)
+        "UPDATE #{model.quoted_table_name} SET " +
+        "#{@index.quote_column(@column.to_s)} = #{adapter.boolean(false)}"
+      end
+      
+      def clause(model, toggled)
+        "#{model.quoted_table_name}.#{@index.quote_column(@column.to_s)}" +
+        " = #{adapter.boolean(toggled)}"
+      end
+      
+      protected
+      
+      def core_index_name(model)
+        "#{model.source_of_sphinx_index.name.underscore.tr(':/\\', '_')}_core"
+      end
+      
+      def delta_index_name(model)
+        "#{model.source_of_sphinx_index.name.underscore.tr(':/\\', '_')}_delta"
+      end  
+      
+      private
+      
+      def adapter
+        @adapter = @index.model.sphinx_database_adapter
+      end
+    end
+  end
+end

data/lib/thinking_sphinx/deltas/delayed_delta.rb

@@ -0,0 +1,25 @@
+require 'delayed/job'
+
+require 'thinking_sphinx/deltas/delayed_delta/delta_job'
+require 'thinking_sphinx/deltas/delayed_delta/flag_as_deleted_job'
+require 'thinking_sphinx/deltas/delayed_delta/job'
+
+module ThinkingSphinx
+  module Deltas
+    class DelayedDelta < ThinkingSphinx::Deltas::DefaultDelta
+      def index(model, instance = nil)
+        ThinkingSphinx::Deltas::Job.enqueue(
+          ThinkingSphinx::Deltas::DeltaJob.new(delta_index_name(model))
+        )
+        
+        Delayed::Job.enqueue(
+          ThinkingSphinx::Deltas::FlagAsDeletedJob.new(
+            core_index_name(model), instance.sphinx_document_id
+          )
+        ) if instance
+        
+        true
+      end
+    end
+  end
+end

data/lib/thinking_sphinx/deltas/delayed_delta/delta_job.rb

@@ -0,0 +1,24 @@
+module ThinkingSphinx
+  module Deltas
+    class DeltaJob
+      attr_accessor :index
+      
+      def initialize(index)
+        @index = index
+      end
+      
+      def perform
+        return true unless ThinkingSphinx.updates_enabled? &&
+          ThinkingSphinx.deltas_enabled?
+        
+        config = ThinkingSphinx::Configuration.instance
+        client = Riddle::Client.new config.address, config.port
+        
+        output = `#{config.bin_path}indexer --config #{config.config_file} --rotate #{index}`
+        puts output unless ThinkingSphinx.suppress_delta_output?
+        
+        true
+      end
+    end
+  end
+end

data/lib/thinking_sphinx/deltas/delayed_delta/flag_as_deleted_job.rb

@@ -0,0 +1,27 @@
+module ThinkingSphinx
+  module Deltas
+    class FlagAsDeletedJob
+      attr_accessor :index, :document_id
+      
+      def initialize(index, document_id)
+        @index, @document_id = index, document_id
+      end
+      
+      def perform
+        return true unless ThinkingSphinx.updates_enabled?
+        
+        config = ThinkingSphinx::Configuration.instance
+        client = Riddle::Client.new config.address, config.port
+        
+        client.update(
+          @index,
+          ['sphinx_deleted'],
+          {@document_id => [1]}
+        ) if ThinkingSphinx.sphinx_running? &&
+          ThinkingSphinx::Search.search_for_id(@document_id, @index)
+        
+        true
+      end
+    end
+  end
+end

data/lib/thinking_sphinx/deltas/delayed_delta/job.rb

@@ -0,0 +1,26 @@
+module ThinkingSphinx
+  module Deltas
+    class Job < Delayed::Job
+      def self.enqueue(object, priority = 0)
+        super unless duplicates_exist(object)
+      end
+      
+      def self.cancel_thinking_sphinx_jobs
+        if connection.tables.include?("delayed_jobs")
+          delete_all("handler LIKE '--- !ruby/object:ThinkingSphinx::Deltas::%'")
+        end
+      end
+
+      private
+
+      def self.duplicates_exist(object)
+        count(
+          :conditions => {
+            :handler    => object.to_yaml,
+            :locked_at  => nil
+          }
+        ) > 0
+      end
+    end
+  end
+end

data/lib/thinking_sphinx/facet.rb

@@ -0,0 +1,58 @@
+module ThinkingSphinx
+  class Facet
+    attr_reader :reference
+    
+    def initialize(reference)
+      @reference = reference
+      
+      if reference.columns.length != 1
+        raise "Can't translate Facets on multiple-column field or attribute"
+      end
+    end
+    
+    def name
+      reference.unique_name
+    end
+    
+    def attribute_name
+      # @attribute_name ||= case @reference
+      # when Attribute
+      #   @reference.unique_name.to_s
+      # when Field
+      @attribute_name ||= @reference.unique_name.to_s + "_facet"
+      # end
+    end
+    
+    def value(object, attribute_value)
+      return translate(object, attribute_value) if @reference.is_a?(Field)
+      
+      case @reference.type
+      when :string
+        translate(object, attribute_value)
+      when :datetime
+        Time.at(attribute_value)
+      when :boolean
+        attribute_value > 0
+      else
+        attribute_value
+      end
+    end
+    
+    def to_s
+      name
+    end
+    
+    private
+    
+    def translate(object, attribute_value)
+      column.__stack.each { |method|
+        object = object.send(method)
+      }
+      object.send(column.__name)
+    end
+    
+    def column
+      @reference.columns.first
+    end
+  end
+end

data/lib/thinking_sphinx/facet_collection.rb

@@ -0,0 +1,60 @@
+module ThinkingSphinx
+  class FacetCollection < Hash
+    attr_accessor :arguments
+    
+    def initialize(arguments)
+      @arguments        = arguments.clone
+      @attribute_values = {}
+      @facets           = []
+    end
+    
+    def add_from_results(facet, results)
+      facet = facet_from_object(results.first, facet) if facet.is_a?(String)
+      
+      self[facet.name]              ||= {}
+      @attribute_values[facet.name] ||= {}
+      @facets << facet
+      
+      results.each_with_groupby_and_count { |result, group, count|
+        facet_value = facet.value(result, group)
+        
+        self[facet.name][facet_value]              ||= 0
+        self[facet.name][facet_value]              += count
+        @attribute_values[facet.name][facet_value]  = group
+      }
+    end
+    
+    def for(hash = {})
+      arguments        = @arguments.clone
+      options          = arguments.extract_options!
+      options[:with] ||= {}
+      
+      hash.each do |key, value|
+        attrib = facet_for_key(key).attribute_name
+        options[:with][attrib] = underlying_value key, value
+      end
+      
+      arguments << options
+      ThinkingSphinx::Search.search *arguments
+    end
+    
+    private
+    
+    def underlying_value(key, value)
+      case value
+      when Array
+        value.collect { |item| underlying_value(key, item) }
+      else
+        @attribute_values[key][value]
+      end
+    end
+    
+    def facet_for_key(key)
+      @facets.detect { |facet| facet.name == key }
+    end
+    
+    def facet_from_object(object, name)
+      object.sphinx_facets.detect { |facet| facet.attribute_name == name }
+    end
+  end
+end

data/lib/thinking_sphinx/field.rb

@@ -8,7 +8,8 @@ module ThinkingSphinx
   # associations. Which can get messy. Use Index.link!, it really helps.
   # 
   class Field
-    attr_accessor :alias, :columns, :sortable, :associations, :model, :infixes, :prefixes
+    attr_accessor :alias, :columns, :sortable, :associations, :model, :infixes,
+      :prefixes, :faceted
     
     # To create a new field, you'll need to pass in either a single Column
     # or an array of them, and some (optional) options. The columns are
@@ -58,10 +59,11 @@ module ThinkingSphinx
 
       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) }
       
-      @alias        = options[:as]
-      @sortable     = options[:sortable] || false
-      @infixes      = options[:infixes]  || false
-      @prefixes     = options[:prefixes] || false
+      @alias    = options[:as]
+      @sortable = options[:sortable] || false
+      @infixes  = options[:infixes]  || false
+      @prefixes = options[:prefixes] || false
+      @faceted  = options[:facet]    || false
     end
     
     # Get the part of the SELECT clause related to this field. Don't forget
@@ -75,10 +77,10 @@ module ThinkingSphinx
         column_with_prefix(column)
       }.join(', ')
       
-      clause = concatenate(clause) if concat_ws?
-      clause = group_concatenate(clause) if is_many?
+      clause = adapter.concatenate(clause) if concat_ws?
+      clause = adapter.group_concatenate(clause) if is_many?
       
-      "#{cast_to_string clause } AS #{quote_column(unique_name)}"
+      "#{adapter.cast_to_string clause } AS #{quote_column(unique_name)}"
     end
     
     # Get the part of the GROUP BY clause related to this field - if one is
@@ -110,39 +112,16 @@ module ThinkingSphinx
       end
     end
     
-    private
-    
-    def concatenate(clause)
-      case @model.connection.class.name
-      when "ActiveRecord::ConnectionAdapters::MysqlAdapter"
-        "CONCAT_WS(' ', #{clause})"
-      when "ActiveRecord::ConnectionAdapters::PostgreSQLAdapter"
-        clause.split(', ').join(" || ' ' || ")
-      else
-        clause
-      end
+    def to_facet
+      return nil unless @faceted
+      
+      ThinkingSphinx::Facet.new(self)
     end
     
-    def group_concatenate(clause)
-      case @model.connection.class.name
-      when "ActiveRecord::ConnectionAdapters::MysqlAdapter"
-        "GROUP_CONCAT(#{clause} SEPARATOR ' ')"
-      when "ActiveRecord::ConnectionAdapters::PostgreSQLAdapter"
-        "array_to_string(array_accum(#{clause}), ' ')"
-      else
-        clause
-      end
-    end
+    private
     
-    def cast_to_string(clause)
-      case @model.connection.class.name
-      when "ActiveRecord::ConnectionAdapters::MysqlAdapter"
-        "CAST(#{clause} AS CHAR)"
-      when "ActiveRecord::ConnectionAdapters::PostgreSQLAdapter"
-        clause
-      else
-        clause
-      end
+    def adapter
+      @adapter ||= @model.sphinx_database_adapter
     end
     
     def quote_column(column)
@@ -156,16 +135,7 @@ module ThinkingSphinx
     def concat_ws?
       @columns.length > 1 || multiple_associations?
     end
-    
-    # Checks the association tree for each column - if they're all the same,
-    # returns false.
-    # 
-    def multiple_sources?
-      first = associations[@columns.first]
-      
-      !@columns.all? { |col| associations[col] == first }
-    end
-    
+        
     # Checks whether any column requires multiple associations (which only
     # happens for polymorphic situations).
     # 
@@ -198,9 +168,5 @@ module ThinkingSphinx
     def is_many?
       associations.values.flatten.any? { |assoc| assoc.is_many? }
     end
-    
-    def is_string?
-      columns.all? { |col| col.is_string? }
-    end
   end
 end