thinking-sphinx 1.2.13 → 6.0.0

data/lib/thinking_sphinx/connection/client.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+class ThinkingSphinx::Connection::Client
+  def initialize(options)
+    if options[:socket].present?
+      options[:socket] = options[:socket].remove /:mysql41$/
+
+      options.delete :host
+      options.delete :port
+    else
+      options.delete :socket
+
+      # If you use localhost, MySQL insists on a socket connection, but in this
+      # situation we want a TCP connection. Using 127.0.0.1 fixes that.
+      if options[:host].nil? || options[:host] == "localhost"
+        options[:host] = "127.0.0.1"
+      end
+    end
+
+    @options = options
+  end
+
+  def close
+    close! unless ThinkingSphinx::Connection.persistent?
+  end
+
+  def close!
+    client.close
+  end
+
+  def execute(statement)
+    check_and_perform(statement).first
+  end
+
+  def query_all(*statements)
+    check_and_perform statements.join('; ')
+  end
+
+  private
+
+  def check(statements)
+    if statements.length > maximum_statement_length
+      exception           = ThinkingSphinx::QueryLengthError.new
+      exception.statement = statements
+      raise exception
+    end
+  end
+
+  def check_and_perform(statements)
+    check statements
+    perform statements
+  end
+
+  def close_and_clear
+    client.close
+    @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
+    message           = "#{error.message} - #{statements}"
+    wrapper           = ThinkingSphinx::QueryExecutionError.new message
+    wrapper.statement = statements
+    raise wrapper
+  ensure
+    close_and_clear unless ThinkingSphinx::Connection.persistent?
+  end
+end

data/lib/thinking_sphinx/connection/jruby.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+class ThinkingSphinx::Connection::JRuby < ThinkingSphinx::Connection::Client
+  attr_reader :address, :options
+
+  def initialize(options)
+    options.delete :socket
+
+    super
+
+    @address = "jdbc:mysql://#{@options[:host]}:#{@options[:port]}/?allowMultiQueries=true"
+  end
+
+  def base_error
+    Java::JavaSql::SQLException
+  end
+
+  private
+
+  def client
+    @client ||= Java::ComMysqlJdbc::Driver.new.connect address, properties
+  rescue base_error => error
+    raise ThinkingSphinx::SphinxError.new_from_mysql error
+  end
+
+  def properties
+    object = Java::JavaUtil::Properties.new
+    object.setProperty "user", options[:username]     if options[:username]
+    object.setProperty "password", options[:password] if options[:password]
+    object
+  end
+
+  def results_for(statements)
+    statement = client.createStatement
+    statement.execute statements
+
+    results   = [set_to_array(statement.getResultSet)]
+    results  << set_to_array(statement.getResultSet) while statement.getMoreResults
+    results.compact
+  end
+
+  def set_to_array(set)
+    return nil if set.nil?
+
+    meta = set.getMetaData
+    rows = []
+
+    while set.next
+      rows << (1..meta.getColumnCount).inject({}) do |row, index|
+        name      = meta.getColumnName index
+        row[name] = set.getObject(index)
+        row
+      end
+    end
+
+    rows
+  end
+end

data/lib/thinking_sphinx/connection/mri.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+class ThinkingSphinx::Connection::MRI < ThinkingSphinx::Connection::Client
+  def base_error
+    Mysql2::Error
+  end
+
+  private
+
+  attr_reader :options
+
+  def client
+    @client ||= Mysql2::Client.new({
+      :flags           => Mysql2::Client::MULTI_STATEMENTS,
+      :connect_timeout => 5
+    }.merge(options))
+  rescue base_error => error
+    raise ThinkingSphinx::SphinxError.new_from_mysql error
+  end
+
+  def results_for(statements)
+    results  = [client.query(statements)]
+    results << client.store_result while client.next_result
+    results
+  end
+end

data/lib/thinking_sphinx/connection.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module ThinkingSphinx::Connection
+  MAXIMUM_RETRIES = 3
+
+  def self.new
+    configuration = ThinkingSphinx::Configuration.instance
+
+    options = {
+      :host      => configuration.searchd.address,
+      :port      => configuration.searchd.mysql41,
+      :socket    => configuration.searchd.socket,
+      :reconnect => true
+    }.merge(configuration.settings['connection_options'] || {})
+
+    connection_class.new options
+  end
+
+  def self.clear
+    @pool = nil
+  end
+
+  def self.connection_class
+    return ThinkingSphinx::Connection::JRuby if RUBY_PLATFORM == 'java'
+
+    ThinkingSphinx::Connection::MRI
+  end
+
+  def self.pool
+    @pool ||= Innertube::Pool.new(
+      Proc.new { ThinkingSphinx::Connection.new },
+      Proc.new { |connection| connection.close! }
+    )
+  end
+
+  def self.take
+    retries  = 0
+    original = nil
+    begin
+      pool.take do |connection|
+        begin
+          yield connection
+        rescue ThinkingSphinx::QueryExecutionError, connection.base_error => error
+          original = ThinkingSphinx::SphinxError.new_from_mysql error
+          retries += MAXIMUM_RETRIES if original.is_a?(ThinkingSphinx::QueryError)
+          raise Innertube::Pool::BadResource
+        end
+      end
+    rescue Innertube::Pool::BadResource
+      retries += 1
+      raise original unless retries < MAXIMUM_RETRIES
+
+      ActiveSupport::Notifications.instrument(
+        "message.thinking_sphinx", :message => "Retrying query \"#{original.statement}\" after error: #{original.message}"
+      )
+      retry
+    end
+  end
+
+  def self.persistent?
+    @persistent
+  end
+
+  def self.persistent=(persist)
+    @persistent = persist
+  end
+
+  @persistent = true
+end
+
+require 'thinking_sphinx/connection/client'
+require 'thinking_sphinx/connection/jruby'
+require 'thinking_sphinx/connection/mri'

data/lib/thinking_sphinx/core/field.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module ThinkingSphinx::Core::Field
+  def infixing?
+    options[:infixes]
+  end
+
+  def prefixing?
+    options[:prefixes]
+  end
+end

data/lib/thinking_sphinx/core/index.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+module ThinkingSphinx::Core::Index
+  extend ActiveSupport::Concern
+  include ThinkingSphinx::Core::Settings
+
+  included do
+    attr_reader :reference, :offset
+    attr_writer :definition_block
+  end
+
+  def initialize(reference, options = {})
+    @reference    = reference.to_sym
+    @options      = options
+    @offset       = config.next_offset(options[:offset_as] || reference)
+    @type         = 'plain'
+
+    super "#{options[:name] || reference.to_s.gsub('/', '_')}_#{name_suffix}"
+  end
+
+  def delta?
+    false
+  end
+
+  def distributed?
+    false
+  end
+
+  def document_id_for_instance(instance)
+    document_id_for_key instance.public_send(primary_key)
+  end
+
+  def document_id_for_key(key)
+    return nil if key.nil?
+
+    key * config.indices.count + offset
+  end
+
+  def interpret_definition!
+    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!
+
+    @interpreted_definition = true
+    interpreter.translate! self, @definition_block if @definition_block
+  end
+
+  def model
+    @model ||= reference.to_s.camelize.constantize
+  end
+
+  def options
+    interpret_definition!
+    @options
+  end
+
+  def primary_key
+    @primary_key ||= @options[:primary_key] ||
+      config.settings['primary_key'] || model.primary_key || :id
+  end
+
+  def render
+    pre_render
+    set_path
+
+    assign_infix_fields
+    assign_prefix_fields
+
+    super
+  end
+
+  private
+
+  def assign_infix_fields
+    self.infix_fields  = fields.select(&:infixing?).collect(&:name)
+  end
+
+  def assign_prefix_fields
+    self.prefix_fields = fields.select(&:prefixing?).collect(&:name)
+  end
+
+  def config
+    ThinkingSphinx::Configuration.instance
+  end
+
+  def name_suffix
+    'core'
+  end
+
+  def path_prefix
+    options[:path] || config.indices_location
+  end
+
+  def pre_render
+    interpret_definition!
+  end
+
+  def set_path
+    unless config.settings['skip_directory_creation']
+      FileUtils.mkdir_p path_prefix
+    end
+
+    @path = File.join path_prefix, name
+  end
+end

data/lib/thinking_sphinx/core/interpreter.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+class ThinkingSphinx::Core::Interpreter < BasicObject
+  def self.translate!(index, block)
+    new(index, block).translate!
+  end
+
+  def initialize(index, block)
+    @index = index
+
+    mod = ::Module.new
+    mod.send :define_method, :translate!, block
+    mod.send :extend_object, self
+  end
+
+  private
+
+  def search_option?(key)
+    ::ThinkingSphinx::Middlewares::SphinxQL::SELECT_OPTIONS.include? key
+  end
+
+  def method_missing(method, *args)
+    ::ThinkingSphinx::ActiveRecord::Column.new method, *args
+  end
+end

data/lib/thinking_sphinx/core/property.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module ThinkingSphinx::Core::Property
+  def facet?
+    options[:facet]
+  end
+
+  def multi?
+    false
+  end
+
+  def type
+    nil
+  end
+end

data/lib/thinking_sphinx/core/settings.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module ThinkingSphinx::Core::Settings
+  private
+  def apply_defaults!(defaults = self.class.settings)
+    defaults.each do |setting|
+      value = config.settings[setting.to_s]
+      send("#{setting}=", value) unless value.nil?
+    end
+  end
+end

data/lib/thinking_sphinx/core.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module ThinkingSphinx::Core
+  #
+end
+
+require 'thinking_sphinx/core/settings'
+require 'thinking_sphinx/core/field'
+require 'thinking_sphinx/core/index'
+require 'thinking_sphinx/core/interpreter'
+require 'thinking_sphinx/core/property'

data/lib/thinking_sphinx/deletion.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+class ThinkingSphinx::Deletion
+  delegate :name, :to => :index
+
+  def self.perform(index, ids)
+    return if index.distributed?
+
+    {
+      'plain' => PlainDeletion,
+      'rt'    => RealtimeDeletion
+    }[index.type].new(index, ids).perform
+  rescue ThinkingSphinx::ConnectionError => error
+    # This isn't vital, so don't raise the error.
+  end
+
+  def initialize(index, ids)
+    @index, @ids = index, Array(ids)
+  end
+
+  private
+
+  attr_reader :index, :ids
+
+  def execute(statement)
+    statement = statement.gsub(/\s*\n\s*/, ' ').strip
+
+    ThinkingSphinx::Logger.log :query, statement do
+      ThinkingSphinx::Connection.take do |connection|
+        connection.execute statement
+      end
+    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?
+
+      ids.each_slice(1000) do |some_ids|
+        execute <<-SQL
+DELETE FROM #{name}
+WHERE sphinx_internal_id IN (#{some_ids.join(', ')})
+        SQL
+      end
+    end
+
+    private
+
+    def callbacks_enabled?
+      setting = configuration.settings['real_time_callbacks']
+      setting.nil? || setting
+    end
+
+    def configuration
+      ThinkingSphinx::Configuration.instance
+    end
+  end
+end

data/lib/thinking_sphinx/deltas/default_delta.rb

@@ -1,68 +1,59 @@
-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}#{config.indexer_binary_name} --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 " +
-        "#{model.connection.quote_column_name(@column.to_s)} = #{adapter.boolean(false)} " +
-        "WHERE #{model.connection.quote_column_name(@column.to_s)} = #{adapter.boolean(true)}"
-      end
-      
-      def clause(model, toggled)
-        "#{model.quoted_table_name}.#{model.connection.quote_column_name(@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
+# frozen_string_literal: true
+
+class ThinkingSphinx::Deltas::DefaultDelta
+  attr_reader :adapter, :options
+
+  def initialize(adapter, options = {})
+    @adapter, @options = adapter, options
+  end
+
+  def clause(delta_source = false)
+    return nil unless delta_source
+
+    "#{adapter.quoted_table_name}.#{quoted_column} = #{adapter.boolean_value delta_source}"
+  end
+
+  def delete(index, instance)
+    ThinkingSphinx::Deltas::DeleteJob.new(
+      index.name, index.document_id_for_instance(instance)
+    ).perform
+  end
+
+  def index(index)
+    ThinkingSphinx::Deltas::IndexJob.new(index.name).perform
+  end
+
+  def reset_query
+    (<<-SQL).strip.gsub(/\n\s*/, ' ')
+UPDATE #{adapter.quoted_table_name}
+SET #{quoted_column} = #{adapter.boolean_value false}
+WHERE #{quoted_column} = #{adapter.boolean_value true}
+    SQL
+  end
+
+  def toggle(instance)
+    instance.send "#{column}=", true
+  end
+
+  def toggled?(instance)
+    instance.send "#{column}?"
+  end
+
+  private
+
+  def column
+    options[:column] || :delta
+  end
+
+  def config
+    ThinkingSphinx::Configuration.instance
+  end
+
+  def controller
+    config.controller
+  end
+
+  def quoted_column
+    adapter.quote column
   end
 end

data/lib/thinking_sphinx/deltas/delete_job.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+class ThinkingSphinx::Deltas::DeleteJob
+  def initialize(index_name, document_id)
+    @index_name, @document_id = index_name, document_id
+  end
+
+  def perform
+    return if @document_id.nil?
+
+    ThinkingSphinx::Logger.log :query, statement do
+      ThinkingSphinx::Connection.take do |connection|
+        connection.execute statement
+      end
+    end
+  rescue ThinkingSphinx::ConnectionError => error
+    # This isn't vital, so don't raise the error.
+  end
+
+  private
+
+  def statement
+    @statement ||= Riddle::Query.update(
+      @index_name, @document_id, :sphinx_deleted => true
+    )
+  end
+end

data/lib/thinking_sphinx/deltas/index_job.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+class ThinkingSphinx::Deltas::IndexJob
+  def initialize(index_name)
+    @index_name = index_name
+  end
+
+  def perform
+    ThinkingSphinx::Commander.call(
+      :index_sql, configuration,
+      :indices => [index_name],
+      :verbose => !quiet_deltas?
+    )
+  end
+
+  private
+
+  attr_reader :index_name
+
+  def configuration
+    @configuration ||= ThinkingSphinx::Configuration.instance
+  end
+
+  def quiet_deltas?
+    configuration.settings['quiet_deltas'].nil? ||
+    configuration.settings['quiet_deltas']
+  end
+end