thinking-sphinx 4.3.1 → 5.1.0

data/lib/thinking_sphinx.rb

@@ -17,8 +17,6 @@ require 'active_support/core_ext/module/delegation'
 require 'active_support/core_ext/module/attribute_accessors'
 
 module ThinkingSphinx
-  MAXIMUM_STATEMENT_LENGTH = (2 ** 23) - 5
-
   def self.count(query = '', options = {})
     search_for_ids(query, options).total_entries
   end

data/lib/thinking_sphinx/active_record.rb

@@ -29,6 +29,7 @@ require 'thinking_sphinx/active_record/source_joins'
 require 'thinking_sphinx/active_record/sql_builder'
 require 'thinking_sphinx/active_record/sql_source'
 
+require 'thinking_sphinx/active_record/callbacks/association_delta_callbacks'
 require 'thinking_sphinx/active_record/callbacks/delete_callbacks'
 require 'thinking_sphinx/active_record/callbacks/delta_callbacks'
 require 'thinking_sphinx/active_record/callbacks/update_callbacks'

data/lib/thinking_sphinx/active_record/association_proxy.rb

@@ -1,8 +1,6 @@
 # frozen_string_literal: true
 
 module ThinkingSphinx::ActiveRecord::AssociationProxy
-  extend ActiveSupport::Concern
-
   def search(query = nil, options = {})
     perform_search super(*normalise_search_arguments(query, options))
   end
@@ -12,6 +10,7 @@ module ThinkingSphinx::ActiveRecord::AssociationProxy
   end
 
   private
+
   def normalise_search_arguments(query, options)
     query, options = nil, query if query.is_a?(Hash)
     options[:ignore_scopes] = true

data/lib/thinking_sphinx/active_record/association_proxy/attribute_finder.rb

@@ -31,7 +31,7 @@ class ThinkingSphinx::ActiveRecord::AssociationProxy::AttributeFinder
     @indices ||= begin
       configuration.preload_indices
       configuration.indices_for_references(
-        *ThinkingSphinx::IndexSet.reference_name(@association.klass)
+        *configuration.index_set_class.reference_name(@association.klass)
       ).reject &:distributed?
     end
   end

data/lib/thinking_sphinx/active_record/attribute/sphinx_presenter.rb

@@ -4,7 +4,7 @@ class ThinkingSphinx::ActiveRecord::Attribute::SphinxPresenter
   SPHINX_TYPES = {
     :integer   => :uint,
     :boolean   => :bool,
-    :timestamp => :timestamp,
+    :timestamp => :uint,
     :float     => :float,
     :string    => :string,
     :bigint    => :bigint,

data/lib/thinking_sphinx/active_record/base.rb

@@ -4,13 +4,24 @@ module ThinkingSphinx::ActiveRecord::Base
   extend ActiveSupport::Concern
 
   included do
-    after_destroy ThinkingSphinx::ActiveRecord::Callbacks::DeleteCallbacks
-    before_save   ThinkingSphinx::ActiveRecord::Callbacks::DeltaCallbacks
-    after_update  ThinkingSphinx::ActiveRecord::Callbacks::UpdateCallbacks
-    after_commit  ThinkingSphinx::ActiveRecord::Callbacks::DeltaCallbacks
+    if ActiveRecord::VERSION::STRING.to_i >= 5
+      [
+        ::ActiveRecord::Reflection::HasManyReflection,
+        ::ActiveRecord::Reflection::HasAndBelongsToManyReflection
+      ].each do |reflection_class|
+        reflection_class.include DefaultReflectionAssociations
+      end
+    else
+      ::ActiveRecord::Associations::CollectionProxy.include(
+        ThinkingSphinx::ActiveRecord::AssociationProxy
+      )
+    end
+  end
 
-    ::ActiveRecord::Associations::CollectionProxy.send :include,
-      ThinkingSphinx::ActiveRecord::AssociationProxy
+  module DefaultReflectionAssociations
+    def extensions
+      super + [ThinkingSphinx::ActiveRecord::AssociationProxy]
+    end
   end
 
   module ClassMethods

data/lib/thinking_sphinx/active_record/callbacks/association_delta_callbacks.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+class ThinkingSphinx::ActiveRecord::Callbacks::AssociationDeltaCallbacks
+  def initialize(path)
+    @path = path
+  end
+
+  def after_commit(instance)
+    Array(objects_for(instance)).each do |object|
+      object.update :delta => true unless object.frozen?
+    end
+  end
+
+  private
+
+  attr_reader :path
+
+  def objects_for(instance)
+    path.inject(instance) { |object, method| object.send method }
+  end
+end

data/lib/thinking_sphinx/active_record/callbacks/delete_callbacks.rb

@@ -27,7 +27,7 @@ class ThinkingSphinx::ActiveRecord::Callbacks::DeleteCallbacks <
 
   def indices
     ThinkingSphinx::Configuration.instance.index_set_class.new(
-      :classes => [instance.class]
+      :instances => [instance], :classes => [instance.class]
     ).to_a
   end
 end

data/lib/thinking_sphinx/active_record/callbacks/delta_callbacks.rb

@@ -43,8 +43,9 @@ class ThinkingSphinx::ActiveRecord::Callbacks::DeltaCallbacks <
   end
 
   def indices
-    @indices ||= config.index_set_class.new(:classes => [instance.class]).
-      select { |index| index.type == "plain" }
+    @indices ||= config.index_set_class.new(
+      :instances => [instance], :classes => [instance.class]
+    ).select { |index| index.type == "plain" }
   end
 
   def new_or_changed?

data/lib/thinking_sphinx/active_record/callbacks/update_callbacks.rb

@@ -47,7 +47,7 @@ class ThinkingSphinx::ActiveRecord::Callbacks::UpdateCallbacks <
   end
 
   def reference
-    ThinkingSphinx::IndexSet.reference_name(instance.class)
+    configuration.index_set_class.reference_name(instance.class)
   end
 
   def update(index)

data/lib/thinking_sphinx/active_record/interpreter.rb

@@ -13,15 +13,15 @@ class ThinkingSphinx::ActiveRecord::Interpreter <
   end
 
   def has(*columns)
-    __source.attributes += build_properties(
+    build_properties(
       ::ThinkingSphinx::ActiveRecord::Attribute, columns
-    )
+    ).each { |attribute| __source.add_attribute attribute }
   end
 
   def indexes(*columns)
-    __source.fields += build_properties(
+    build_properties(
       ::ThinkingSphinx::ActiveRecord::Field, columns
-    )
+    ).each { |field| __source.add_field field }
   end
 
   def join(*columns)

data/lib/thinking_sphinx/active_record/sql_source.rb

@@ -39,6 +39,18 @@ module ThinkingSphinx
         @adapter ||= DatabaseAdapters.adapter_for(@model)
       end
 
+      def add_attribute(attribute)
+        attributes.delete_if { |existing| existing.name == attribute.name }
+
+        attributes << attribute
+      end
+
+      def add_field(field)
+        fields.delete_if { |existing| existing.name == field.name }
+
+        fields << field
+      end
+
       def delta_processor
         options[:delta_processor].try(:new, adapter, @options[:delta_options] || {})
       end

data/lib/thinking_sphinx/active_record/sql_source/template.rb

@@ -18,14 +18,14 @@ class ThinkingSphinx::ActiveRecord::SQLSource::Template
   private
 
   def add_attribute(column, name, type, options = {})
-    source.attributes << ThinkingSphinx::ActiveRecord::Attribute.new(
+    source.add_attribute ThinkingSphinx::ActiveRecord::Attribute.new(
       source.model, ThinkingSphinx::ActiveRecord::Column.new(column),
       options.merge(:as => name, :type => type)
     )
   end
 
   def add_field(column, name, options = {})
-    source.fields << ThinkingSphinx::ActiveRecord::Field.new(
+    source.add_field ThinkingSphinx::ActiveRecord::Field.new(
       source.model, ThinkingSphinx::ActiveRecord::Column.new(column),
       options.merge(:as => name)
     )

data/lib/thinking_sphinx/callbacks.rb

@@ -3,6 +3,13 @@
 class ThinkingSphinx::Callbacks
   attr_reader :instance
 
+  def self.append(model, reference = nil, options, &block)
+    reference ||= ThinkingSphinx::Configuration.instance.index_set_class.
+      reference_name(model)
+
+    ThinkingSphinx::Callbacks::Appender.call(model, reference, options, &block)
+  end
+
   def self.callbacks(*methods)
     mod = Module.new
     methods.each do |method|
@@ -33,3 +40,5 @@ class ThinkingSphinx::Callbacks
     @instance = instance
   end
 end
+
+require "thinking_sphinx/callbacks/appender"

data/lib/thinking_sphinx/callbacks/appender.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+class ThinkingSphinx::Callbacks::Appender
+  def self.call(model, reference, options, &block)
+    new(model, reference, options, &block).call
+  end
+
+  def initialize(model, reference, options, &block)
+    @model = model
+    @reference = reference
+    @options = options
+    @block = block
+  end
+
+  def call
+    add_core_callbacks
+    add_delta_callbacks     if behaviours.include?(:deltas)
+    add_real_time_callbacks if behaviours.include?(:real_time)
+    add_update_callbacks    if behaviours.include?(:updates)
+  end
+
+  private
+
+  attr_reader :model, :reference, :options, :block
+
+  def add_core_callbacks
+    model.after_destroy ThinkingSphinx::ActiveRecord::Callbacks::DeleteCallbacks
+  end
+
+  def add_delta_callbacks
+    if path.empty?
+      model.before_save  ThinkingSphinx::ActiveRecord::Callbacks::DeltaCallbacks
+      model.after_commit ThinkingSphinx::ActiveRecord::Callbacks::DeltaCallbacks
+    else
+      model.after_commit(
+        ThinkingSphinx::ActiveRecord::Callbacks::AssociationDeltaCallbacks
+          .new(path)
+      )
+    end
+  end
+
+  def add_real_time_callbacks
+    model.after_save ThinkingSphinx::RealTime.callback_for(
+      reference, path, &block
+    )
+  end
+
+  def add_update_callbacks
+    model.after_update ThinkingSphinx::ActiveRecord::Callbacks::UpdateCallbacks
+  end
+
+  def behaviours
+    options[:behaviours] || []
+  end
+
+  def path
+    options[:path] || []
+  end
+end

data/lib/thinking_sphinx/commands/index_real_time.rb

@@ -2,9 +2,7 @@
 
 class ThinkingSphinx::Commands::IndexRealTime < ThinkingSphinx::Commands::Base
   def call
-    options[:indices].each do |index|
-      ThinkingSphinx::RealTime::Populator.populate index
-
+    ThinkingSphinx::RealTime.processor.call options[:indices] do
       command :rotate
     end
   end

data/lib/thinking_sphinx/configuration.rb

@@ -98,7 +98,7 @@ class ThinkingSphinx::Configuration < Riddle::Configuration
   end
 
   def preload_index(file)
-    if ActiveRecord::VERSION::MAJOR < 5
+    if ActiveRecord::VERSION::MAJOR <= 5
       ActiveSupport::Dependencies.require_or_load file
     else
       load file

data/lib/thinking_sphinx/connection.rb

@@ -16,6 +16,10 @@ module ThinkingSphinx::Connection
     connection_class.new options
   end
 
+  def self.clear
+    @pool = nil
+  end
+
   def self.connection_class
     return ThinkingSphinx::Connection::JRuby if RUBY_PLATFORM == 'java'
 

data/lib/thinking_sphinx/connection/client.rb

@@ -39,7 +39,7 @@ class ThinkingSphinx::Connection::Client
   private
 
   def check(statements)
-    if statements.length > ThinkingSphinx::MAXIMUM_STATEMENT_LENGTH
+    if statements.length > maximum_statement_length
       exception           = ThinkingSphinx::QueryLengthError.new
       exception.statement = statements
       raise exception
@@ -56,6 +56,11 @@ class ThinkingSphinx::Connection::Client
     @client = nil
   end
 
+  def maximum_statement_length
+    @maximum_statement_length ||= ThinkingSphinx::Configuration.instance.
+      settings['maximum_statement_length']
+  end
+
   def perform(statements)
     results_for statements
   rescue => error

data/lib/thinking_sphinx/core/index.rb

@@ -11,7 +11,6 @@ module ThinkingSphinx::Core::Index
 
   def initialize(reference, options = {})
     @reference    = reference.to_sym
-    @docinfo      = :extern unless config.settings["skip_docinfo"]
     @options      = options
     @offset       = config.next_offset(options[:offset_as] || reference)
     @type         = 'plain'
@@ -38,7 +37,11 @@ module ThinkingSphinx::Core::Index
   end
 
   def interpret_definition!
-    return unless model.table_exists?
+    table_exists = model.table_exists?
+    unless table_exists
+      Rails.logger.info "No table exists for #{model}. Index can not be created"
+      return
+    end
     return if @interpreted_definition
 
     apply_defaults!

data/lib/thinking_sphinx/deletion.rb

@@ -22,10 +22,6 @@ class ThinkingSphinx::Deletion
 
   attr_reader :index, :ids
 
-  def document_ids_for_keys
-    ids.collect { |id| index.document_id_for_key id }
-  end
-
   def execute(statement)
     statement = statement.gsub(/\s*\n\s*/, ' ').strip
 
@@ -36,11 +32,28 @@ class ThinkingSphinx::Deletion
     end
   end
 
+  class PlainDeletion < ThinkingSphinx::Deletion
+    def perform
+      ids.each_slice(1000) do |some_ids|
+        execute <<-SQL
+UPDATE #{name}
+SET sphinx_deleted = 1
+WHERE sphinx_internal_id IN (#{some_ids.join(', ')})
+        SQL
+      end
+    end
+  end
+
   class RealtimeDeletion < ThinkingSphinx::Deletion
     def perform
       return unless callbacks_enabled?
 
-      execute Riddle::Query::Delete.new(name, document_ids_for_keys).to_sql
+      ids.each_slice(1000) do |some_ids|
+        execute <<-SQL
+DELETE FROM #{name}
+WHERE sphinx_internal_id IN (#{some_ids.join(', ')})
+        SQL
+      end
     end
 
     private
@@ -54,16 +67,4 @@ class ThinkingSphinx::Deletion
       ThinkingSphinx::Configuration.instance
     end
   end
-
-  class PlainDeletion < ThinkingSphinx::Deletion
-    def perform
-      document_ids_for_keys.each_slice(1000) do |document_ids|
-        execute <<-SQL
-UPDATE #{name}
-SET sphinx_deleted = 1
-WHERE id IN (#{document_ids.join(', ')})
-        SQL
-      end
-    end
-  end
 end

data/lib/thinking_sphinx/errors.rb

@@ -38,7 +38,7 @@ end
 class ThinkingSphinx::QueryLengthError < ThinkingSphinx::SphinxError
   def message
     <<-MESSAGE
-The supplied SphinxQL statement is #{statement.length} characters long. The maximum allowed length is #{ThinkingSphinx::MAXIMUM_STATEMENT_LENGTH}.
+The supplied SphinxQL statement is #{statement.length} characters long. The maximum allowed length is #{ThinkingSphinx::Configuration.instance.settings['maximum_statement_length']}.
 
 If this error has been raised during real-time index population, it's probably due to overly large batches of records being processed at once. The default is 1000, but you can lower it on a per-environment basis in config/thinking_sphinx.yml:
 

data/lib/thinking_sphinx/index_set.rb

@@ -34,11 +34,11 @@ class ThinkingSphinx::IndexSet
   end
 
   def classes
-    options[:classes] || []
+    options[:classes] || instances.collect(&:class)
   end
 
   def classes_specified?
-    classes.any? || references_specified?
+    instances.any? || classes.any? || references_specified?
   end
 
   def classes_and_ancestors
@@ -68,6 +68,10 @@ class ThinkingSphinx::IndexSet
     all_indices.select { |index| references.include? index.reference }
   end
 
+  def instances
+    options[:instances] || []
+  end
+
   def mti_classes
     classes.reject { |klass|
       klass.column_names.include?(klass.inheritance_column)
@@ -76,7 +80,7 @@ class ThinkingSphinx::IndexSet
 
   def references
     options[:references] || classes_and_ancestors.collect { |klass|
-      ThinkingSphinx::IndexSet.reference_name(klass)
+      self.class.reference_name(klass)
     }
   end