thinking-sphinx 3.0.6 → 3.1.0

data/lib/thinking_sphinx/active_record/sql_builder.rb

@@ -24,6 +24,12 @@ module ThinkingSphinx
         query.to_query
       end
 
+      def sql_query_post_index
+        return [] unless delta_processor && !source.delta?
+
+        [delta_processor.reset_query]
+      end
+
       private
 
       delegate :adapter, :model, :delta_processor, :to => :source
@@ -47,7 +53,7 @@ module ThinkingSphinx
       end
 
       def associations
-        @associations ||= ThinkingSphinx::ActiveRecord::Associations.new(model).tap do |assocs|
+        @associations ||= Joiner::Joins.new(model).tap do |assocs|
           source.associations.reject(&:string?).each do |association|
             assocs.add_join_to association.stack
           end

data/lib/thinking_sphinx/active_record/sql_builder/query.rb

@@ -18,17 +18,10 @@ module ThinkingSphinx
 
       def filter_by_query_pre
         scope_by_time_zone
-        scope_by_delta_processor
         scope_by_session
         scope_by_utf8
       end
 
-      def scope_by_delta_processor
-        return unless delta_processor && !source.delta?
-
-        self.scope << delta_processor.reset_query
-      end
-
       def scope_by_session
         return unless max_len = source.options[:group_concat_max_len]
 

data/lib/thinking_sphinx/active_record/sql_source.rb

@@ -6,13 +6,13 @@ module ThinkingSphinx
       attr_accessor :fields, :attributes, :associations, :conditions,
         :groupings, :polymorphs
 
-      OPTIONS = [:name, :offset, :delta_processor, :delta?, :disable_range?,
-        :group_concat_max_len, :utf8?, :position, :minimal_group_by?]
+      OPTIONS = [:name, :offset, :delta_processor, :delta?, :delta_options,
+        :disable_range?, :group_concat_max_len, :utf8?, :position, 
+        :minimal_group_by?]
 
       def initialize(model, options = {})
         @model             = model
-        @database_settings = ::ActiveRecord::Base.connection.
-          instance_variable_get(:@config).clone
+        @database_settings = model.connection.instance_variable_get(:@config).clone
         @options           = {
           :utf8? => (@database_settings[:encoding] == 'utf8')
         }.merge options
@@ -38,7 +38,7 @@ module ThinkingSphinx
       end
 
       def delta_processor
-        options[:delta_processor].try(:new, adapter)
+        options[:delta_processor].try(:new, adapter, @options[:delta_options] || {})
       end
 
       def delta?
@@ -67,6 +67,15 @@ module ThinkingSphinx
         super
       end
 
+      def set_database_settings(settings)
+        @sql_host ||= settings[:host]     || 'localhost'
+        @sql_user ||= settings[:username] || settings[:user] || ENV['USER']
+        @sql_pass ||= settings[:password].to_s.gsub('#', '\#')
+        @sql_db   ||= settings[:database]
+        @sql_port ||= settings[:port]
+        @sql_sock ||= settings[:socket]
+      end
+
       def type
         @type ||= case adapter
         when DatabaseAdapters::MySQLAdapter
@@ -107,10 +116,11 @@ module ThinkingSphinx
       end
 
       def build_sql_query
-        @sql_query         = builder.sql_query
-        @sql_query_range ||= builder.sql_query_range
-        @sql_query_info  ||= builder.sql_query_info
-        @sql_query_pre    += builder.sql_query_pre
+        @sql_query             = builder.sql_query
+        @sql_query_range     ||= builder.sql_query_range
+        @sql_query_info      ||= builder.sql_query_info
+        @sql_query_pre        += builder.sql_query_pre
+        @sql_query_post_index += builder.sql_query_post_index
       end
 
       def config
@@ -121,7 +131,7 @@ module ThinkingSphinx
         polymorphs.each &:morph!
         append_presenter_to_attribute_array
 
-        set_database_settings
+        set_database_settings database_settings
         build_sql_fields
         build_sql_query
 
@@ -131,16 +141,6 @@ module ThinkingSphinx
       def properties
         fields + attributes
       end
-
-      def set_database_settings
-        @sql_host ||= database_settings[:host]     || 'localhost'
-        @sql_user ||= database_settings[:username] || database_settings[:user] ||
-          ENV['USER']
-        @sql_pass ||= database_settings[:password].to_s.gsub('#', '\#')
-        @sql_db   ||= database_settings[:database]
-        @sql_port ||= database_settings[:port]
-        @sql_sock ||= database_settings[:socket]
-      end
     end
   end
 end

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

@@ -33,7 +33,7 @@ class ThinkingSphinx::ActiveRecord::SQLSource::Template
     if inheriting?
       adapter = source.adapter
       quoted_column = "#{adapter.quoted_table_name}.#{adapter.quote(model.inheritance_column)}"
-      source.adapter.convert_nulls quoted_column, "'#{model.sti_name}'"
+      source.adapter.convert_blank quoted_column, "'#{model.sti_name}'"
     else
       "'#{model.name}'"
     end

data/lib/thinking_sphinx/capistrano.rb

@@ -1,67 +1,8 @@
-Capistrano::Configuration.instance(:must_exist).load do
-  _cset(:thinking_sphinx_roles)   { :db }
-  _cset(:thinking_sphinx_options) { {:roles => fetch(:thinking_sphinx_roles)} }
-
-  namespace :thinking_sphinx do
-    desc 'Generate the Sphinx configuration file.'
-    task :configure, fetch(:thinking_sphinx_options) do
-      rake 'ts:configure'
-    end
-
-    desc 'Build Sphinx indexes into the shared path and symlink them into your release.'
-    task :index, fetch(:thinking_sphinx_options) do
-      rake 'ts:index'
-    end
-    after 'thinking_sphinx:index', 'thinking_sphinx:symlink_indexes'
-
-    desc 'Start the Sphinx search daemon.'
-    task :start, fetch(:thinking_sphinx_options) do
-      rake 'ts:start'
-    end
-    before 'thinking_sphinx:start', 'thinking_sphinx:configure'
-
-    desc 'Stop the Sphinx search daemon.'
-    task :stop, fetch(:thinking_sphinx_options) do
-      rake 'ts:stop'
-    end
-
-    desc 'Restart the Sphinx search daemon.'
-    task :restart, fetch(:thinking_sphinx_options) do
-      rake 'ts:stop ts:configure ts:start'
-    end
-
-    desc <<-DESC
-Stop, reindex, and then start the Sphinx search daemon. This task must be executed \
-if you alter the structure of your indexes.
-    DESC
-    task :rebuild, fetch(:thinking_sphinx_options) do
-      rake 'ts:rebuild'
-    end
-    after 'thinking_sphinx:rebuild', 'thinking_sphinx:symlink_indexes'
-
-    desc 'Create the shared folder for sphinx indexes.'
-    task :shared_sphinx_folder, fetch(:thinking_sphinx_options) do
-      rails_env = fetch(:rails_env, 'production')
-      run "mkdir -p #{shared_path}/db/sphinx/#{rails_env}"
-    end
-
-    desc 'Symlink Sphinx indexes from the shared folder to the latest release.'
-    task :symlink_indexes, fetch(:thinking_sphinx_options) do
-      run "if [ -d #{release_path} ]; then ln -nfs #{shared_path}/db/sphinx #{release_path}/db/sphinx; else ln -nfs #{shared_path}/db/sphinx #{current_path}/db/sphinx; fi;"
-    end
-
-    # Logical flow for deploying an app
-    after  'deploy:cold',            'thinking_sphinx:index'
-    after  'deploy:cold',            'thinking_sphinx:start'
-    after  'deploy:setup',           'thinking_sphinx:shared_sphinx_folder'
-    after  'deploy:finalize_update', 'thinking_sphinx:symlink_indexes'
-
-    def rake(tasks)
-      rails_env = fetch(:rails_env, 'production')
-      rake = fetch(:rake, 'rake')
-      tasks += ' INDEX_ONLY=true' if ENV['INDEX_ONLY'] == 'true'
-
-      run "if [ -d #{release_path} ]; then cd #{release_path}; else cd #{current_path}; fi; if [ -f Rakefile ]; then #{rake} RAILS_ENV=#{rails_env} #{tasks}; fi;"
-    end
+if defined?(Capistrano::VERSION)
+  if Gem::Version.new(Capistrano::VERSION).release >= Gem::Version.new('3.0.0')
+    recipe_version = 3
   end
 end
+
+recipe_version ||= 2
+require_relative "capistrano/v#{recipe_version}"

data/lib/thinking_sphinx/capistrano/v2.rb

@@ -0,0 +1,58 @@
+Capistrano::Configuration.instance(:must_exist).load do
+  _cset(:thinking_sphinx_roles)   { :db }
+  _cset(:thinking_sphinx_options) { {:roles => fetch(:thinking_sphinx_roles)} }
+
+  namespace :thinking_sphinx do
+    desc 'Generate the Sphinx configuration file.'
+    task :configure, fetch(:thinking_sphinx_options) do
+      rake 'ts:configure'
+    end
+
+    desc 'Build Sphinx indexes into the shared path.'
+    task :index, fetch(:thinking_sphinx_options) do
+      rake 'ts:index'
+    end
+
+    desc 'Generate Sphinx indexes into the shared path.'
+    task :generate, fetch(:thinking_sphinx_options) do
+      rake 'ts:generate'
+    end
+
+    desc 'Start the Sphinx search daemon.'
+    task :start, fetch(:thinking_sphinx_options) do
+      rake 'ts:start'
+    end
+    before 'thinking_sphinx:start', 'thinking_sphinx:configure'
+
+    desc 'Stop the Sphinx search daemon.'
+    task :stop, fetch(:thinking_sphinx_options) do
+      rake 'ts:stop'
+    end
+
+    desc 'Restart the Sphinx search daemon.'
+    task :restart, fetch(:thinking_sphinx_options) do
+      rake 'ts:stop ts:configure ts:start'
+    end
+
+    desc <<-DESC
+Stop, reindex, and then start the Sphinx search daemon. This task must be executed \
+if you alter the structure of your indexes.
+    DESC
+    task :rebuild, fetch(:thinking_sphinx_options) do
+      rake 'ts:rebuild'
+    end
+
+    desc 'Stop Sphinx, clear Sphinx index files, generate configuration file, start Sphinx, repopulate all data.'
+    task :regenerate, fetch(:thinking_sphinx_options) do
+      rake 'ts:regenerate'
+    end
+
+    def rake(tasks)
+      rails_env = fetch(:rails_env, 'production')
+      rake = fetch(:rake, 'rake')
+      tasks += ' INDEX_ONLY=true' if ENV['INDEX_ONLY'] == 'true'
+
+      run "if [ -d #{release_path} ]; then cd #{release_path}; else cd #{current_path}; fi; if [ -f Rakefile ]; then #{rake} RAILS_ENV=#{rails_env} #{tasks}; fi;"
+    end
+  end
+end

data/lib/thinking_sphinx/capistrano/v3.rb

@@ -0,0 +1,101 @@
+namespace :load do
+  task :defaults do
+    set :thinking_sphinx_roles, :db
+  end
+end
+
+namespace :thinking_sphinx do
+  desc <<-DESC
+Stop, reindex, and then start the Sphinx search daemon. This task must be executed \
+if you alter the structure of your indexes.
+  DESC
+  task :rebuild do
+    on roles fetch(:thinking_sphinx_roles) do
+      within current_path do
+        with rails_env: fetch(:stage) do
+          execute :rake, "ts:rebuild"
+        end
+      end
+    end
+  end
+
+  desc 'Stop Sphinx, clear Sphinx index files, generate configuration file, start Sphinx, repopulate all data.'
+  task :regenerate do
+    on roles fetch(:thinking_sphinx_options) do
+      within current_path do
+        with rails_env: fetch(:stage) do
+          execute :rake, 'ts:regenerate'
+        end
+      end
+    end
+  end
+
+  desc 'Build Sphinx indexes into the shared path.'
+  task :index do
+    on roles fetch(:thinking_sphinx_roles) do
+      within current_path do
+        with rails_env: fetch(:stage) do
+          execute :rake, 'ts:index'
+        end
+      end
+    end
+  end
+
+  desc 'Generate Sphinx indexes into the shared path.'
+  task :generate do
+    on roles fetch(:thinking_sphinx_options) do
+      within current_path do
+        with rails_env: fetch(:stage) do
+          execute :rake, 'ts:generate'
+        end
+      end
+    end
+  end
+
+  desc 'Restart the Sphinx search daemon.'
+  task :restart do
+    on roles fetch(:thinking_sphinx_roles) do
+      within current_path do
+        with rails_env: fetch(:stage) do
+          %w(stop configure start).each do |task|
+            execute :rake, "ts:#{task}"
+          end
+        end
+      end
+    end
+  end
+
+  desc 'Start the Sphinx search daemon.'
+  task :start do
+    on roles fetch(:thinking_sphinx_roles) do
+      within current_path do
+        with rails_env: fetch(:stage) do
+          execute :rake, 'ts:start'
+        end
+      end
+    end
+  end
+  before :start, 'thinking_sphinx:configure'
+
+  desc 'Generate the Sphinx configuration file.'
+  task :configure do
+    on roles fetch(:thinking_sphinx_roles) do
+      within current_path do
+        with rails_env: fetch(:stage) do
+          execute :rake, 'ts:configure'
+        end
+      end
+    end
+  end
+
+  desc 'Stop the Sphinx search daemon.'
+  task :stop do
+    on roles fetch(:thinking_sphinx_roles) do
+      within current_path do
+        with rails_env: fetch(:stage) do
+          execute :rake, 'ts:stop'
+        end
+      end
+    end
+  end
+end

data/lib/thinking_sphinx/configuration.rb

@@ -27,7 +27,7 @@ class ThinkingSphinx::Configuration < Riddle::Configuration
 
   def controller
     @controller ||= begin
-      rc = Riddle::Controller.new self, configuration_file
+      rc = ThinkingSphinx::Controller.new self, configuration_file
       rc.bin_path = bin_path.gsub(/([^\/])$/, '\1/') if bin_path.present?
       rc
     end
@@ -50,8 +50,9 @@ class ThinkingSphinx::Configuration < Riddle::Configuration
   end
 
   def engine_indice_paths
-    Rails::Engine::Railties.engines.collect do |engine|
-      engine.paths['app/indices'].existent if engine.paths['app/indices']
+    Rails::Engine.subclasses.collect(&:instance).collect do |engine|
+      engine.paths.add 'app/indices' unless engine.paths['app/indices']
+      engine.paths['app/indices'].existent
     end
   end
 
@@ -73,6 +74,8 @@ class ThinkingSphinx::Configuration < Riddle::Configuration
       end
     end
 
+    ThinkingSphinx::Configuration::DistributedIndices.new(indices).reconcile
+
     @preloaded_indices = true
   end
 
@@ -104,6 +107,7 @@ class ThinkingSphinx::Configuration < Riddle::Configuration
     searchd.address = settings['address'].presence || Defaults::ADDRESS
     searchd.mysql41 = settings['mysql41'] || settings['port'] || Defaults::PORT
     searchd.workers = 'threads'
+    searchd.mysql_version_string = '5.5.21' if RUBY_PLATFORM == 'java'
   end
 
   def configure_searchd_log_files
@@ -165,4 +169,5 @@ end
 
 require 'thinking_sphinx/configuration/consistent_ids'
 require 'thinking_sphinx/configuration/defaults'
+require 'thinking_sphinx/configuration/distributed_indices'
 require 'thinking_sphinx/configuration/minimum_fields'

data/lib/thinking_sphinx/configuration/distributed_indices.rb

@@ -0,0 +1,29 @@
+class ThinkingSphinx::Configuration::DistributedIndices
+  def initialize(indices)
+    @indices = indices
+  end
+
+  def reconcile
+    grouped_indices.each do |reference, indices|
+      append distributed_index(reference, indices)
+    end
+  end
+
+  private
+
+  attr_reader :indices
+
+  def append(index)
+    ThinkingSphinx::Configuration.instance.indices << index
+  end
+
+  def distributed_index(reference, indices)
+    index = ThinkingSphinx::Distributed::Index.new reference
+    index.local_indices += indices.collect &:name
+    index
+  end
+
+  def grouped_indices
+    indices.group_by &:reference
+  end
+end

data/lib/thinking_sphinx/connection.rb

@@ -16,7 +16,6 @@ module ThinkingSphinx::Connection
   end
 
   def self.connection_class
-    raise "Sphinx's MySQL protocol does not work with JDBC." if RUBY_PLATFORM == 'java'
     return ThinkingSphinx::Connection::JRuby if RUBY_PLATFORM == 'java'
 
     ThinkingSphinx::Connection::MRI
@@ -36,7 +35,7 @@ module ThinkingSphinx::Connection
       pool.take do |connection|
         begin
           yield connection
-        rescue ThinkingSphinx::QueryExecutionError, Mysql2::Error => error
+        rescue ThinkingSphinx::QueryExecutionError, connection.base_error => error
           original = ThinkingSphinx::SphinxError.new_from_mysql error
           raise original if original.is_a?(ThinkingSphinx::QueryError)
           raise Innertube::Pool::BadResource
@@ -53,65 +52,122 @@ module ThinkingSphinx::Connection
     end
   end
 
-  class MRI
-    attr_reader :client
+  def self.persistent?
+    @persistent
+  end
 
-    def initialize(address, port, options)
-      @client = Mysql2::Client.new({
-        :host  => address,
-        :port  => port,
-        :flags => Mysql2::Client::MULTI_STATEMENTS
-      }.merge(options))
-    rescue Mysql2::Error => error
-      raise ThinkingSphinx::SphinxError.new_from_mysql error
-    end
+  def self.persistent=(persist)
+    @persistent = persist
+  end
 
+  @persistent = true
+
+  class Client
     def close
-      client.close
+      client.close unless ThinkingSphinx::Connection.persistent?
     end
 
     def execute(statement)
-      client.query statement
+      query(statement).first
+    end
+
+    def query_all(*statements)
+      query *statements
+    end
+
+    private
+
+    def close_and_clear
+      client.close
+      @client = nil
+    end
+
+    def query(*statements)
+      results_for *statements
     rescue => error
       wrapper           = ThinkingSphinx::QueryExecutionError.new error.message
-      wrapper.statement = statement
+      wrapper.statement = statements.join('; ')
       raise wrapper
+    ensure
+      close_and_clear unless ThinkingSphinx::Connection.persistent?
     end
+  end
 
-    def query(statement)
-      client.query statement
+  class MRI < Client
+    def initialize(address, port, options)
+      @address, @port, @options = address, port, options
     end
 
-    def query_all(*statements)
+    def base_error
+      Mysql2::Error
+    end
+
+    private
+
+    attr_reader :address, :port, :options
+
+    def client
+      @client ||= Mysql2::Client.new({
+        :host  => address,
+        :port  => port,
+        :flags => Mysql2::Client::MULTI_STATEMENTS
+      }.merge(options))
+    rescue base_error => error
+      raise ThinkingSphinx::SphinxError.new_from_mysql error
+    end
+
+    def results_for(*statements)
       results  = [client.query(statements.join('; '))]
       results << client.store_result while client.next_result
       results
-    rescue => error
-      wrapper           = ThinkingSphinx::QueryExecutionError.new error.message
-      wrapper.statement = statements.join('; ')
-      raise wrapper
     end
   end
 
-  class JRuby
-    attr_reader :client
+  class JRuby < Client
+    attr_reader :address, :options
 
     def initialize(address, port, options)
-      address = "jdbc:mysql://#{address}:#{searchd.mysql41}"
-      @client = java.sql.DriverManager.getConnection address,
-        options[:username], options[:password]
+      @address = "jdbc:mysql://#{address}:#{port}?allowMultiQueries=true"
+      @options = options
     end
 
-    def execute(statement)
-      client.createStatement.execute statement
+    def base_error
+      Java::JavaSql::SQLException
     end
 
-    def query(statement)
-      #
+    private
+
+    def client
+      @client ||= java.sql.DriverManager.getConnection address,
+        options[:username], options[:password]
+    rescue base_error => error
+      raise ThinkingSphinx::SphinxError.new_from_mysql error
     end
 
-    def query_all(*statements)
-      #
+    def results_for(*statements)
+      statement = client.createStatement
+      statement.execute statements.join('; ')
+
+      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.meta_data
+      rows = []
+
+      while set.next
+        rows << (1..meta.column_count).inject({}) do |row, index|
+          name      = meta.column_name index
+          row[name] = set.get_object(index)
+          row
+        end
+      end
+
+      rows
     end
   end
 end