thinking-sphinx 1.2.13 → 6.0.0

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

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+class ThinkingSphinx::ActiveRecord::SQLSource::Template
+  attr_reader :source
+
+  def initialize(source)
+    @source = source
+  end
+
+  def apply
+    add_field class_column, :sphinx_internal_class_name
+
+    add_attribute primary_key,  :sphinx_internal_id,    nil
+    add_attribute class_column, :sphinx_internal_class, :string, :facet => true
+    add_attribute '0',          :sphinx_deleted,        :integer
+  end
+
+  private
+
+  def add_attribute(column, name, type, options = {})
+    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.add_field ThinkingSphinx::ActiveRecord::Field.new(
+      source.model, ThinkingSphinx::ActiveRecord::Column.new(column),
+      options.merge(:as => name)
+    )
+  end
+
+  def class_column
+    if inheriting?
+      adapter = source.adapter
+      quoted_column = "#{adapter.quoted_table_name}.#{adapter.quote(model.inheritance_column)}"
+      source.adapter.convert_blank quoted_column, "'#{model.sti_name}'"
+    else
+      "'#{model.name}'"
+    end
+  end
+
+  def inheriting?
+    model.column_names.include?(model.inheritance_column)
+  end
+
+  def model
+    source.model
+  end
+
+  def primary_key
+    source.options[:primary_key].to_sym
+  end
+end

data/lib/thinking_sphinx/active_record/sql_source.rb

@@ -0,0 +1,173 @@
+# frozen_string_literal: true
+
+module ThinkingSphinx
+  module ActiveRecord
+    class SQLSource < Riddle::Configuration::SQLSource
+      include ThinkingSphinx::Core::Settings
+
+      attr_reader :model, :options
+      attr_accessor :fields, :attributes, :associations, :conditions,
+        :groupings, :polymorphs
+
+      OPTIONS = [:name, :offset, :delta_processor, :delta?, :delta_options,
+        :disable_range?, :group_concat_max_len, :utf8?, :position,
+        :minimal_group_by?, :big_document_ids]
+
+      def initialize(model, options = {})
+        @model             = model
+        @options           = {
+          :utf8? => (database_settings[:encoding].to_s[/^utf8/])
+        }.merge options
+
+        @fields            = []
+        @attributes        = []
+        @associations      = []
+        @conditions        = []
+        @groupings         = []
+        @polymorphs        = []
+
+        Template.new(self).apply
+
+        name = "#{options[:name] || model.name.downcase}_#{options[:position]}"
+
+        super name, type
+
+        apply_defaults!
+      end
+
+      def adapter
+        @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
+
+      def delta?
+        options[:delta?]
+      end
+
+      def disable_range?
+        options[:disable_range?]
+      end
+
+      def facets
+        properties.select(&:facet?)
+      end
+
+      def offset
+        options[:offset]
+      end
+
+      def primary_key
+        options[:primary_key]
+      end
+
+      def properties
+        fields + attributes
+      end
+
+      def render
+        prepare_for_render unless @prepared
+
+        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]
+        @mysql_ssl_cert ||= settings[:sslcert]
+        @mysql_ssl_key  ||= settings[:sslkey]
+        @mysql_ssl_ca   ||= settings[:sslca]
+      end
+
+      def type
+        @type ||= case adapter
+        when DatabaseAdapters::MySQLAdapter
+          'mysql'
+        when DatabaseAdapters::PostgreSQLAdapter
+          'pgsql'
+        else
+          raise UnknownDatabaseAdapter, "Provided type: #{adapter.class.name}"
+        end
+      end
+
+      private
+
+      def append_presenter_to_attribute_array
+        attributes.each do |attribute|
+          presenter = Attribute::SphinxPresenter.new(attribute, self)
+
+          attribute_array_for(presenter.collection_type) << presenter.declaration
+        end
+      end
+
+      def attribute_array_for(type)
+        instance_variable_get "@sql_attr_#{type}".to_sym
+      end
+
+      def builder
+        @builder ||= SQLBuilder.new self
+      end
+
+      def build_sql_fields
+        fields.each do |field|
+          @sql_field_string        << field.name if field.with_attribute?
+          @sql_field_str2wordcount << field.name if field.wordcount?
+          @sql_file_field          << field.name if field.file?
+
+          @sql_joined_field << PropertyQuery.new(field, self).to_s if field.source_type
+        end
+      end
+
+      def build_sql_query
+        @sql_query             = builder.sql_query
+        @sql_query_range     ||= builder.sql_query_range
+        @sql_query_pre        += builder.sql_query_pre
+      end
+
+      def config
+        ThinkingSphinx::Configuration.instance
+      end
+
+      def database_settings
+        @database_settings ||= begin
+          if model.connection.respond_to?(:config)
+            model.connection.config.clone
+          else
+            model.connection.instance_variable_get(:@config).clone
+          end
+        end
+      end
+
+      def prepare_for_render
+        polymorphs.each &:morph!
+        append_presenter_to_attribute_array
+
+        set_database_settings database_settings
+        build_sql_fields
+        build_sql_query
+
+        @prepared = true
+      end
+    end
+  end
+end
+
+require 'thinking_sphinx/active_record/sql_source/template'

data/lib/thinking_sphinx/active_record.rb

@@ -1,306 +1,44 @@
-require 'thinking_sphinx/active_record/attribute_updates'
-require 'thinking_sphinx/active_record/delta'
-require 'thinking_sphinx/active_record/has_many_association'
-require 'thinking_sphinx/active_record/scopes'
+# frozen_string_literal: true
 
-module ThinkingSphinx
-  # Core additions to ActiveRecord models - define_index for creating indexes
-  # for models. If you want to interrogate the index objects created for the
-  # model, you can use the class-level accessor :sphinx_indexes.
-  #
-  module ActiveRecord
-    def self.included(base)
-      base.class_eval do
-        class_inheritable_array :sphinx_indexes, :sphinx_facets
-        class << self
-          
-          def set_sphinx_primary_key(attribute)
-            @sphinx_primary_key_attribute = attribute
-          end
-          
-          def primary_key_for_sphinx
-            @sphinx_primary_key_attribute || primary_key
-          end
-          
-          # Allows creation of indexes for Sphinx. If you don't do this, there
-          # isn't much point trying to search (or using this plugin at all,
-          # really).
-          #
-          # An example or two:
-          #
-          #   define_index
-          #     indexes :id, :as => :model_id
-          #     indexes name
-          #   end
-          #
-          # You can also grab fields from associations - multiple levels deep
-          # if necessary.
-          #
-          #   define_index do
-          #     indexes tags.name, :as => :tag
-          #     indexes articles.content
-          #     indexes orders.line_items.product.name, :as => :product
-          #   end
-          #
-          # And it will automatically concatenate multiple fields:
-          #
-          #   define_index do
-          #     indexes [author.first_name, author.last_name], :as => :author
-          #   end
-          #
-          # The #indexes method is for fields - if you want attributes, use
-          # #has instead. All the same rules apply - but keep in mind that
-          # attributes are for sorting, grouping and filtering, not searching.
-          #
-          #   define_index do
-          #     # fields ...
-          #     
-          #     has created_at, updated_at
-          #   end
-          #
-          # One last feature is the delta index. This requires the model to
-          # have a boolean field named 'delta', and is enabled as follows:
-          #
-          #   define_index do
-          #     # fields ...
-          #     # attributes ...
-          #     
-          #     set_property :delta => true
-          #   end
-          #
-          # Check out the more detailed documentation for each of these methods
-          # at ThinkingSphinx::Index::Builder.
-          # 
-          def define_index(&block)
-            return unless ThinkingSphinx.define_indexes?
-            
-            self.sphinx_indexes ||= []
-            self.sphinx_facets  ||= []
-            index = ThinkingSphinx::Index::Builder.generate(self, &block)
-            
-            self.sphinx_indexes << index
-            unless ThinkingSphinx.indexed_models.include?(self.name)
-              ThinkingSphinx.indexed_models << self.name
-            end
-            
-            if index.delta?
-              before_save   :toggle_delta
-              after_commit  :index_delta
-            end
-            
-            after_destroy :toggle_deleted
-            
-            include ThinkingSphinx::SearchMethods
-            include ThinkingSphinx::ActiveRecord::AttributeUpdates
-            include ThinkingSphinx::ActiveRecord::Scopes
-            
-            index
-            
-            # We want to make sure that if the database doesn't exist, then Thinking
-            # Sphinx doesn't mind when running non-TS tasks (like db:create, db:drop
-            # and db:migrate). It's a bit hacky, but I can't think of a better way.
-          rescue StandardError => err
-            case err.class.name
-            when "Mysql::Error", "Java::JavaSql::SQLException", "ActiveRecord::StatementInvalid"
-              return
-            else
-              raise err
-            end
-          end
-          alias_method :sphinx_index, :define_index
-          
-          def sphinx_index_options
-            sphinx_indexes.last.options
-          end
-          
-          # Generate a unique CRC value for the model's name, to use to
-          # determine which Sphinx documents belong to which AR records.
-          # 
-          # Really only written for internal use - but hey, if it's useful to
-          # you in some other way, awesome.
-          # 
-          def to_crc32
-            self.name.to_crc32
-          end
-          
-          def to_crc32s
-            (subclasses << self).collect { |klass| klass.to_crc32 }
-          end
-          
-          def source_of_sphinx_index
-            possible_models = self.sphinx_indexes.collect { |index| index.model }
-            return self if possible_models.include?(self)
+require 'active_record'
+require 'joiner'
 
-            parent = self.superclass
-            while !possible_models.include?(parent) && parent != ::ActiveRecord::Base
-              parent = parent.superclass
-            end
+module ThinkingSphinx::ActiveRecord
+  module Callbacks; end
+  module Depolymorph; end
+end
 
-            return parent
-          end
-          
-          def to_riddle(offset)
-            sphinx_database_adapter.setup
-            
-            indexes = [to_riddle_for_core(offset)]
-            indexes << to_riddle_for_delta(offset) if sphinx_delta?
-            indexes << to_riddle_for_distributed
-          end
-          
-          def sphinx_database_adapter
-            @sphinx_database_adapter ||=
-              ThinkingSphinx::AbstractAdapter.detect(self)
-          end
-          
-          def sphinx_name
-            self.name.underscore.tr(':/\\', '_')
-          end
-          
-          def sphinx_index_names
-            klass = source_of_sphinx_index
-            names = ["#{klass.sphinx_name}_core"]
-            names << "#{klass.sphinx_name}_delta" if sphinx_delta?
-            
-            names
-          end
-          
-          private
-          
-          def sphinx_delta?
-            self.sphinx_indexes.any? { |index| index.delta? }
-          end
-          
-          def to_riddle_for_core(offset)
-            index = Riddle::Configuration::Index.new("#{sphinx_name}_core")
-            index.path = File.join(
-              ThinkingSphinx::Configuration.instance.searchd_file_path, index.name
-            )
-            
-            set_configuration_options_for_indexes index
-            set_field_settings_for_indexes        index
-            
-            self.sphinx_indexes.select { |ts_index|
-              ts_index.model == self
-            }.each_with_index do |ts_index, i|
-              index.sources += ts_index.sources.collect { |source|
-                source.to_riddle_for_core(offset, i)
-              }
-            end
-            
-            index
-          end
-          
-          def to_riddle_for_delta(offset)
-            index = Riddle::Configuration::Index.new("#{sphinx_name}_delta")
-            index.parent = "#{sphinx_name}_core"
-            index.path = File.join(ThinkingSphinx::Configuration.instance.searchd_file_path, index.name)
-            
-            self.sphinx_indexes.each_with_index do |ts_index, i|
-              index.sources += ts_index.sources.collect { |source|
-                source.to_riddle_for_delta(offset, i)
-              } if ts_index.delta?
-            end
-            
-            index
-          end
-          
-          def to_riddle_for_distributed
-            index = Riddle::Configuration::DistributedIndex.new(sphinx_name)
-            index.local_indexes << "#{sphinx_name}_core"
-            index.local_indexes.unshift "#{sphinx_name}_delta" if sphinx_delta?
-            index
-          end
-          
-          def set_configuration_options_for_indexes(index)
-            ThinkingSphinx::Configuration.instance.index_options.each do |key, value|
-              index.send("#{key}=".to_sym, value)
-            end
-            
-            self.sphinx_indexes.each do |ts_index|
-              ts_index.options.each do |key, value|
-                index.send("#{key}=".to_sym, value) if ThinkingSphinx::Configuration::IndexOptions.include?(key.to_s) && !value.nil?
-              end
-            end
-          end
-          
-          def set_field_settings_for_indexes(index)
-            field_names = lambda { |field| field.unique_name.to_s }
-            
-            self.sphinx_indexes.each do |ts_index|
-              index.prefix_field_names += ts_index.prefix_fields.collect(&field_names)
-              index.infix_field_names  += ts_index.infix_fields.collect(&field_names)
-            end
-          end
-        end
-      end
-      
-      base.send(:include, ThinkingSphinx::ActiveRecord::Delta)
-      
-      ::ActiveRecord::Associations::HasManyAssociation.send(
-        :include, ThinkingSphinx::ActiveRecord::HasManyAssociation
-      )
-      ::ActiveRecord::Associations::HasManyThroughAssociation.send(
-        :include, ThinkingSphinx::ActiveRecord::HasManyAssociation
-      )
-    end
-    
-    def in_index?(suffix)
-      self.class.search_for_id self.sphinx_document_id, sphinx_index_name(suffix)
-    end
-    
-    def in_core_index?
-      in_index? "core"
-    end
-    
-    def in_delta_index?
-      in_index? "delta"
-    end
-    
-    def in_both_indexes?
-      in_core_index? && in_delta_index?
-    end
-    
-    def toggle_deleted
-      return unless ThinkingSphinx.updates_enabled? && ThinkingSphinx.sphinx_running?
-      
-      config = ThinkingSphinx::Configuration.instance
-      client = Riddle::Client.new config.address, config.port
-      
-      client.update(
-        "#{self.class.sphinx_indexes.first.name}_core",
-        ['sphinx_deleted'],
-        {self.sphinx_document_id => 1}
-      ) if self.in_core_index?
-      
-      client.update(
-        "#{self.class.sphinx_indexes.first.name}_delta",
-        ['sphinx_deleted'],
-        {self.sphinx_document_id => 1}
-      ) if self.class.sphinx_indexes.any? { |index| index.delta? } &&
-        self.toggled_delta?
-    rescue ::ThinkingSphinx::ConnectionError
-      # nothing
-    end
-    
-    # Returns the unique integer id for the object. This method uses the
-    # attribute hash to get around ActiveRecord always mapping the #id method
-    # to whatever the real primary key is (which may be a unique string hash).
-    # 
-    # @return [Integer] Unique record id for the purposes of Sphinx.
-    # 
-    def primary_key_for_sphinx
-      @primary_key_for_sphinx ||= read_attribute(self.class.primary_key_for_sphinx)
-    end
-    
-    def sphinx_document_id
-      primary_key_for_sphinx * ThinkingSphinx.indexed_models.size +
-        ThinkingSphinx.indexed_models.index(self.class.source_of_sphinx_index.name)
-    end
+require 'thinking_sphinx/active_record/property'
+require 'thinking_sphinx/active_record/association'
+require 'thinking_sphinx/active_record/association_proxy'
+require 'thinking_sphinx/active_record/attribute'
+require 'thinking_sphinx/active_record/base'
+require 'thinking_sphinx/active_record/column'
+require 'thinking_sphinx/active_record/column_sql_presenter'
+require 'thinking_sphinx/active_record/database_adapters'
+require 'thinking_sphinx/active_record/field'
+require 'thinking_sphinx/active_record/index'
+require 'thinking_sphinx/active_record/interpreter'
+require 'thinking_sphinx/active_record/join_association'
+require 'thinking_sphinx/active_record/log_subscriber'
+require 'thinking_sphinx/active_record/polymorpher'
+require 'thinking_sphinx/active_record/property_query'
+require 'thinking_sphinx/active_record/property_sql_presenter'
+require 'thinking_sphinx/active_record/simple_many_query'
+require 'thinking_sphinx/active_record/source_joins'
+require 'thinking_sphinx/active_record/sql_builder'
+require 'thinking_sphinx/active_record/sql_source'
 
-    private
+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'
 
-    def sphinx_index_name(suffix)
-      "#{self.class.source_of_sphinx_index.name.underscore.tr(':/\\', '_')}_#{suffix}"
-    end
-  end
-end
+require 'thinking_sphinx/active_record/depolymorph/base_reflection'
+require 'thinking_sphinx/active_record/depolymorph/association_reflection'
+require 'thinking_sphinx/active_record/depolymorph/conditions_reflection'
+require 'thinking_sphinx/active_record/depolymorph/overridden_reflection'
+require 'thinking_sphinx/active_record/depolymorph/scoped_reflection'
+require 'thinking_sphinx/active_record/filter_reflection'
+
+ActiveRecord::Base.include ThinkingSphinx::ActiveRecord::Base

data/lib/thinking_sphinx/attribute_types.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+class ThinkingSphinx::AttributeTypes
+  def self.call
+    @call ||= new.call
+  end
+
+  def self.reset
+    @call = nil
+  end
+
+  def call
+    return {} unless File.exist?(configuration_file)
+
+    realtime_indices.each { |index|
+      map_types_with_prefix index, :rt,
+        [:uint, :bigint, :float, :timestamp, :string, :bool, :json]
+
+      index.rt_attr_multi.each     { |name| attributes[name] << :uint }
+      index.rt_attr_multi_64.each  { |name| attributes[name] << :bigint }
+    }
+
+    plain_sources.each { |source|
+      map_types_with_prefix source, :sql,
+        [:uint, :bigint, :float, :timestamp, :string, :bool, :json]
+
+      source.sql_attr_str2ordinal    { |name| attributes[name] << :uint }
+      source.sql_attr_str2wordcount  { |name| attributes[name] << :uint }
+      source.sql_attr_multi.each { |setting|
+        type, name, *ignored = setting.split(/\s+/)
+        attributes[name] << type.to_sym
+      }
+    }
+
+    attributes.values.each &:uniq!
+    attributes
+  end
+
+  private
+
+  def attributes
+    @attributes ||= Hash.new { |hash, key| hash[key] = [] }
+  end
+
+  def configuration
+    @configuration ||= Riddle::Configuration.parse!(
+      File.read(configuration_file)
+    )
+  end
+
+  def configuration_file
+    ThinkingSphinx::Configuration.instance.configuration_file
+  end
+
+  def map_types_with_prefix(object, prefix, types)
+    types.each do |type|
+      object.public_send("#{prefix}_attr_#{type}").each do |name|
+        attributes[name] << type
+      end
+    end
+  end
+
+  def plain_sources
+    configuration.indices.select { |index|
+      index.type == 'plain' || index.type.nil?
+    }.collect(&:sources).flatten
+  end
+
+  def realtime_indices
+    configuration.indices.select { |index| index.type == 'rt' }
+  end
+end

data/lib/thinking_sphinx/batched_search.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+class ThinkingSphinx::BatchedSearch
+  attr_accessor :searches
+
+  def initialize
+    @searches = []
+  end
+
+  def populate(middleware = ThinkingSphinx::Middlewares::DEFAULT)
+    return if populated? || searches.empty?
+
+    middleware.call contexts
+    searches.each &:populated!
+
+    @populated = true
+  end
+
+  private
+
+  def contexts
+    searches.collect &:context
+  end
+
+  def populated?
+    @populated
+  end
+end