thinking-sphinx 3.3.0 → 3.4.0

data/lib/thinking_sphinx/connection/jruby.rb

@@ -0,0 +1,53 @@
+class ThinkingSphinx::Connection::JRuby < ThinkingSphinx::Connection::Client
+  attr_reader :address, :options
+
+  def initialize(options)
+    @address = "jdbc:mysql://#{options[:host]}:#{options[:port]}/?allowMultiQueries=true"
+    @options = options
+  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,28 @@
+class ThinkingSphinx::Connection::MRI < ThinkingSphinx::Connection::Client
+  def initialize(options)
+    @options = options
+  end
+
+  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/core/index.rb

@@ -25,7 +25,13 @@ module ThinkingSphinx::Core::Index
     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
 
@@ -47,6 +53,11 @@ module ThinkingSphinx::Core::Index
     @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

data/lib/thinking_sphinx/deletion.rb

@@ -25,8 +25,12 @@ class ThinkingSphinx::Deletion
   end
 
   def execute(statement)
-    ThinkingSphinx::Connection.take do |connection|
-      connection.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
 

data/lib/thinking_sphinx/deltas/default_delta.rb

@@ -13,7 +13,7 @@ class ThinkingSphinx::Deltas::DefaultDelta
 
   def delete(index, instance)
     ThinkingSphinx::Deltas::DeleteJob.new(
-      index.name, index.document_id_for_key(instance.id)
+      index.name, index.document_id_for_instance(instance)
     ).perform
   end
 

data/lib/thinking_sphinx/deltas/delete_job.rb

@@ -4,12 +4,22 @@ class ThinkingSphinx::Deltas::DeleteJob
   end
 
   def perform
-    ThinkingSphinx::Connection.take do |connection|
-      connection.execute Riddle::Query.update(
-        @index_name, @document_id, :sphinx_deleted => true
-      )
+    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/distributed/index.rb

@@ -21,4 +21,14 @@ class ThinkingSphinx::Distributed::Index <
   def model
     @model ||= reference.to_s.camelize.constantize
   end
+
+  def primary_key
+    @primary_key ||= configuration.settings['primary_key'] || :id
+  end
+
+  private
+
+  def configuration
+    ThinkingSphinx::Configuration.instance
+  end
 end

data/lib/thinking_sphinx/errors.rb

@@ -3,7 +3,7 @@ class ThinkingSphinx::SphinxError < StandardError
 
   def self.new_from_mysql(error)
     case error.message
-    when /parse error/
+    when /parse error/, /query is non-computable/
       replacement = ThinkingSphinx::ParseError.new(error.message)
     when /syntax error/
       replacement = ThinkingSphinx::SyntaxError.new(error.message)

data/lib/thinking_sphinx/index_set.rb

@@ -1,6 +1,6 @@
 class ThinkingSphinx::IndexSet
   include Enumerable
-  
+
   def self.reference_name(klass)
     @cached_results ||= {}
     @cached_results[klass.name] ||= klass.name.underscore.to_sym
@@ -40,7 +40,7 @@ class ThinkingSphinx::IndexSet
   end
 
   def classes_and_ancestors
-    @classes_and_ancestors ||= classes.collect { |model|
+    @classes_and_ancestors ||= mti_classes + sti_classes.collect { |model|
       model.ancestors.take_while { |klass|
         klass != ActiveRecord::Base
       }.select { |klass|
@@ -66,6 +66,12 @@ class ThinkingSphinx::IndexSet
     all_indices.select { |index| references.include? index.reference }
   end
 
+  def mti_classes
+    classes.reject { |klass|
+      klass.column_names.include?(klass.inheritance_column)
+    }
+  end
+
   def references
     options[:references] || classes_and_ancestors.collect { |klass|
       ThinkingSphinx::IndexSet.reference_name(klass)
@@ -75,4 +81,10 @@ class ThinkingSphinx::IndexSet
   def references_specified?
     options[:references] && options[:references].any?
   end
+
+  def sti_classes
+    classes.select { |klass|
+      klass.column_names.include?(klass.inheritance_column)
+    }
+  end
 end

data/lib/thinking_sphinx/interfaces/daemon.rb

@@ -0,0 +1,32 @@
+class ThinkingSphinx::Interfaces::Daemon
+  include ThinkingSphinx::WithOutput
+
+  def start
+    if running?
+      raise ThinkingSphinx::SphinxAlreadyRunning, 'searchd is already running'
+    end
+
+    if options[:nodetach]
+      ThinkingSphinx::Commands::StartAttached.call configuration, options
+    else
+      ThinkingSphinx::Commands::StartDetached.call configuration, options
+    end
+  end
+
+  def status
+    if running?
+      stream.puts "The Sphinx daemon searchd is currently running."
+    else
+      stream.puts "The Sphinx daemon searchd is not currently running."
+    end
+  end
+
+  def stop
+    ThinkingSphinx::Commands::Stop.call configuration, options
+  end
+
+  private
+
+  delegate :controller, :to => :configuration
+  delegate :running?,   :to => :controller
+end

data/lib/thinking_sphinx/interfaces/real_time.rb

@@ -0,0 +1,41 @@
+class ThinkingSphinx::Interfaces::RealTime
+  include ThinkingSphinx::WithOutput
+
+  def initialize(configuration, options, stream = STDOUT)
+    super
+
+    configuration.preload_indices
+
+    FileUtils.mkdir_p configuration.indices_location
+  end
+
+  def clear
+    indices.each do |index|
+      index.render
+      Dir["#{index.path}.*"].each { |path| FileUtils.rm path }
+    end
+
+    path = configuration.searchd.binlog_path
+    FileUtils.rm_r(path) if File.exists?(path)
+  end
+
+  def index
+    return if indices.empty? || !configuration.controller.running?
+
+    indices.each { |index| ThinkingSphinx::RealTime::Populator.populate index }
+  end
+
+  private
+
+  def indices
+    @indices ||= begin
+      indices = configuration.indices.select { |index| index.type == 'rt' }
+
+      if options[:index_filter]
+        indices.select! { |index| index.name == options[:index_filter] }
+      end
+
+      indices
+    end
+  end
+end

data/lib/thinking_sphinx/interfaces/sql.rb

@@ -0,0 +1,41 @@
+class ThinkingSphinx::Interfaces::SQL
+  include ThinkingSphinx::WithOutput
+
+  def initialize(configuration, options, stream = STDOUT)
+    super
+
+    configuration.preload_indices
+
+    FileUtils.mkdir_p configuration.indices_location
+  end
+
+  def clear
+    indices.each do |index|
+      index.render
+      Dir["#{index.path}.*"].each { |path| FileUtils.rm path }
+    end
+  end
+
+  def index(reconfigure = true, verbose = nil)
+    stream.puts <<-TXT unless verbose.nil?
+The verbose argument to the index method is now deprecated, and can instead be
+managed by the :verbose option passed in when initialising RakeInterface. That
+option is set automatically when invoked by rake, via rake's --silent and/or
+--quiet arguments.
+    TXT
+    return if indices.empty?
+
+    ThinkingSphinx::Commands::Configure.call configuration, options if reconfigure
+    ThinkingSphinx.before_index_hooks.each { |hook| hook.call }
+
+    ThinkingSphinx::Commands::Index.call configuration, options, stream
+  end
+
+  private
+
+  def indices
+    @indices ||= configuration.indices.select do |index|
+      index.type == 'plain' || index.type.blank?
+    end
+  end
+end

data/lib/thinking_sphinx/middlewares.rb

@@ -1,7 +1,9 @@
 module ThinkingSphinx::Middlewares; end
 
-%w[middleware active_record_translator geographer glazier ids_only inquirer
-   sphinxql stale_id_checker stale_id_filter utf8].each do |middleware|
+%w[
+  middleware active_record_translator attribute_typer geographer glazier
+  ids_only inquirer sphinxql stale_id_checker stale_id_filter utf8 valid_options
+].each do |middleware|
   require "thinking_sphinx/middlewares/#{middleware}"
 end
 
@@ -10,7 +12,7 @@ module ThinkingSphinx::Middlewares
     middlewares.each { |m| builder.use m }
   end
 
-  BASE_MIDDLEWARES = [SphinxQL, Geographer, Inquirer]
+  BASE_MIDDLEWARES = [ValidOptions, AttributeTyper, SphinxQL, Geographer, Inquirer]
 
   DEFAULT = ::Middleware::Builder.new do
     use StaleIdFilter

data/lib/thinking_sphinx/middlewares/active_record_translator.rb

@@ -2,6 +2,7 @@ class ThinkingSphinx::Middlewares::ActiveRecordTranslator <
   ThinkingSphinx::Middlewares::Middleware
 
   NO_MODEL = Struct.new(:primary_key).new(:id).freeze
+  NO_INDEX = Struct.new(:primary_key).new(:id).freeze
 
   def call(contexts)
     contexts.each do |context|
@@ -38,20 +39,23 @@ class ThinkingSphinx::Middlewares::ActiveRecordTranslator <
       }.compact
     end
 
+    def index_for(model)
+      return NO_INDEX unless context[:indices]
+
+      context[:indices].detect { |index| index.model == model } || NO_INDEX
+    end
+
     def model_names
       @model_names ||= context[:results].collect { |row|
         row['sphinx_internal_class']
       }.uniq
     end
 
-    def primary_key
-      @primary_key ||= primary_key_for NO_MODEL
-    end
-
     def primary_key_for(model)
       model = NO_MODEL unless model.respond_to?(:primary_key)
 
-      context.configuration.settings['primary_key'] || model.primary_key || :id
+      @primary_keys        ||= {}
+      @primary_keys[model] ||= index_for(model).primary_key
     end
 
     def reset_memos
@@ -61,13 +65,16 @@ class ThinkingSphinx::Middlewares::ActiveRecordTranslator <
 
     def result_for(row)
       results_for_models[row['sphinx_internal_class']].detect { |record|
-        record.public_send(primary_key) == row['sphinx_internal_id']
+        record.public_send(
+          primary_key_for(record.class)
+        ) == row['sphinx_internal_id']
       }
     end
 
     def results_for_models
       @results_for_models ||= model_names.inject({}) do |hash, name|
         model = name.constantize
+
         hash[name] = model_relation_with_sql_options(model.unscoped).where(
           primary_key_for(model) => ids_for_model(name)
         )

data/lib/thinking_sphinx/middlewares/attribute_typer.rb

@@ -0,0 +1,48 @@
+class ThinkingSphinx::Middlewares::AttributeTyper <
+  ThinkingSphinx::Middlewares::Middleware
+
+  def call(contexts)
+    contexts.each do |context|
+      deprecate_filters_in context.search.options[:with]
+      deprecate_filters_in context.search.options[:without]
+      deprecate_filters_in context.search.options[:with_all]
+      deprecate_filters_in context.search.options[:without_all]
+    end
+
+    app.call contexts
+  end
+
+  private
+
+  def attributes
+    @attributes ||= ThinkingSphinx::AttributeTypes.call
+  end
+
+  def casted_value_for(type, value)
+    case type
+    when :uint, :bigint, :timestamp, :bool
+      value.to_i
+    when :float
+      value.to_f
+    else
+      value
+    end
+  end
+
+  def deprecate_filters_in(filters)
+    return if filters.nil?
+
+    filters.each do |key, value|
+      known_types = attributes[key.to_s] || [:string]
+
+      next unless value.is_a?(String) && !known_types.include?(:string)
+
+      ActiveSupport::Deprecation.warn(<<-MSG.squish, caller(11))
+You are filtering on a non-string attribute #{key} with a string value (#{value.inspect}).
+  Thinking Sphinx will quote string values by default in upcoming releases (which will cause query syntax errors on non-string attributes), so please cast these values to their appropriate types.
+      MSG
+
+      filters[key] = casted_value_for known_types.first, value
+    end
+  end
+end