thinking-sphinx 2.1.0 → 3.0.0.pre

data/lib/thinking_sphinx/active_record/column.rb

@@ -0,0 +1,30 @@
+class ThinkingSphinx::ActiveRecord::Column
+  def initialize(*stack)
+    @stack = stack
+    @name  = stack.pop
+  end
+
+  def __name
+    @name
+  end
+
+  def __stack
+    @stack
+  end
+
+  def string?
+    __name.is_a?(String)
+  end
+
+  def to_ary
+    [self]
+  end
+
+  private
+
+  def method_missing(method, *args, &block)
+    @stack << @name
+    @name = method
+    self
+  end
+end

data/lib/thinking_sphinx/active_record/database_adapters.rb

@@ -0,0 +1,51 @@
+module ThinkingSphinx::ActiveRecord::DatabaseAdapters
+  def self.adapter_for(model)
+    return default.new(model) unless default.nil?
+
+    adapter = adapter_type_for(model)
+    klass   = case adapter
+    when :mysql
+      ThinkingSphinx::ActiveRecord::DatabaseAdapters::MySQLAdapter
+    when :postgresql
+      ThinkingSphinx::ActiveRecord::DatabaseAdapters::PostgreSQLAdapter
+    else
+      raise "Invalid Database Adapter '#{adapter}': Thinking Sphinx only supports MySQL and PostgreSQL."
+    end
+
+    klass.new model
+  end
+
+  def self.adapter_type_for(model)
+    case model.connection.class.name
+    when "ActiveRecord::ConnectionAdapters::MysqlAdapter",
+         "ActiveRecord::ConnectionAdapters::Mysql2Adapter"
+      :mysql
+    when "ActiveRecord::ConnectionAdapters::PostgreSQLAdapter"
+      :postgresql
+    when "ActiveRecord::ConnectionAdapters::JdbcAdapter"
+      case model.connection.config[:adapter]
+      when "jdbcmysql"
+        :mysql
+      when "jdbcpostgresql"
+        :postgresql
+      else
+        model.connection.config[:adapter]
+      end
+    else
+      model.connection.class.name
+    end
+  end
+
+  @default = nil
+  def self.default
+    @default
+  end
+
+  def self.default=(default)
+    @default = default
+  end
+end
+
+require 'thinking_sphinx/active_record/database_adapters/abstract_adapter'
+require 'thinking_sphinx/active_record/database_adapters/mysql_adapter'
+require 'thinking_sphinx/active_record/database_adapters/postgresql_adapter'

data/lib/thinking_sphinx/active_record/database_adapters/abstract_adapter.rb

@@ -0,0 +1,13 @@
+class ThinkingSphinx::ActiveRecord::DatabaseAdapters::AbstractAdapter
+  def initialize(model)
+    @model = model
+  end
+
+  def quote(column)
+    @model.connection.quote_column_name(column)
+  end
+
+  def quoted_table_name
+    @model.quoted_table_name
+  end
+end

data/lib/thinking_sphinx/active_record/database_adapters/mysql_adapter.rb

@@ -0,0 +1,23 @@
+class ThinkingSphinx::ActiveRecord::DatabaseAdapters::MySQLAdapter <
+  ThinkingSphinx::ActiveRecord::DatabaseAdapters::AbstractAdapter
+
+  def boolean_value(value)
+    value ? 1 : 0
+  end
+
+  def cast_to_timestamp(clause)
+    "UNIX_TIMESTAMP(#{clause})"
+  end
+
+  def concatenate(clause, separator = ' ')
+    "CONCAT_WS('#{separator}', #{clause})"
+  end
+
+  def convert_nulls(clause, default = '')
+    "IFNULL(#{clause}, #{default})"
+  end
+
+  def group_concatenate(clause, separator = ' ')
+    "GROUP_CONCAT(#{clause} SEPARATOR '#{separator}')"
+  end
+end

data/lib/thinking_sphinx/active_record/database_adapters/postgresql_adapter.rb

@@ -0,0 +1,25 @@
+class ThinkingSphinx::ActiveRecord::DatabaseAdapters::PostgreSQLAdapter <
+  ThinkingSphinx::ActiveRecord::DatabaseAdapters::AbstractAdapter
+
+  def boolean_value(value)
+    value ? 'TRUE' : 'FALSE'
+  end
+
+  def cast_to_timestamp(clause)
+    "extract(epoch from #{clause})::int"
+  end
+
+  def concatenate(clause, separator = ' ')
+    clause.split(', ').collect { |part|
+      convert_nulls(part, "''")
+    }.join(" || '#{separator}' || ")
+  end
+
+  def convert_nulls(clause, default = '')
+    "COALESCE(#{clause}, #{default})"
+  end
+
+  def group_concatenate(clause, separator = ' ')
+    "array_to_string(array_agg(#{clause}), '#{separator}')"
+  end
+end

data/lib/thinking_sphinx/active_record/field.rb

@@ -0,0 +1,11 @@
+class ThinkingSphinx::ActiveRecord::Field <
+  ThinkingSphinx::ActiveRecord::Property
+
+  def file?
+    options[:file]
+  end
+
+  def with_attribute?
+    options[:sortable] || options[:facet]
+  end
+end

data/lib/thinking_sphinx/active_record/index.rb

@@ -0,0 +1,55 @@
+class ThinkingSphinx::ActiveRecord::Index < Riddle::Configuration::Index
+  include ThinkingSphinx::Core::Index
+
+  attr_reader :reference
+  attr_writer :definition_block
+
+  def append_source
+    ThinkingSphinx::ActiveRecord::SQLSource.new(
+      model, source_options
+    ).tap do |source|
+      sources << source
+    end
+  end
+
+  def delta?
+    @options[:delta?]
+  end
+
+  def delta_processor
+    @options[:delta_processor].try(:new, adapter)
+  end
+
+  def facets
+    @facets ||= sources.collect(&:facets).flatten
+  end
+
+  def unique_attribute_names
+    sources.collect(&:attributes).flatten.collect(&:name)
+  end
+
+  private
+
+  def adapter
+    @adapter ||= ThinkingSphinx::ActiveRecord::DatabaseAdapters.
+      adapter_for(model)
+  end
+
+  def interpreter
+    ThinkingSphinx::ActiveRecord::Interpreter
+  end
+
+  def name_suffix
+    @options[:delta?] ? 'delta' : 'core'
+  end
+
+  def source_options
+    {
+      :name            => name,
+      :offset          => offset,
+      :delta?          => @options[:delta?],
+      :delta_processor => @options[:delta_processor],
+      :primary_key     => @options[:primary_key] || model.primary_key || :id
+    }
+  end
+end

data/lib/thinking_sphinx/active_record/interpreter.rb

@@ -0,0 +1,47 @@
+class ThinkingSphinx::ActiveRecord::Interpreter <
+  ::ThinkingSphinx::Core::Interpreter
+
+  def group_by(*columns)
+    __source.groupings += columns
+  end
+
+  def has(*columns)
+    __source.attributes += build_properties(
+      ::ThinkingSphinx::ActiveRecord::Attribute, columns
+    )
+  end
+
+  def indexes(*columns)
+    __source.fields += build_properties(
+      ::ThinkingSphinx::ActiveRecord::Field, columns
+    )
+  end
+
+  def join(*columns)
+    __source.associations += columns.collect { |column|
+      ::ThinkingSphinx::ActiveRecord::Association.new column
+    }
+  end
+
+  def set_property(properties)
+    properties.each do |key, value|
+      @index.send("#{key}=", value)   if @index.class.settings.include?(key)
+      __source.send("#{key}=", value) if __source.class.settings.include?(key)
+    end
+  end
+
+  def where(*conditions)
+    __source.conditions += conditions
+  end
+
+  private
+
+  def __source
+    @source ||= @index.append_source
+  end
+
+  def build_properties(klass, columns)
+    options = columns.extract_options!
+    columns.collect { |column| klass.new(__source.model, column, options) }
+  end
+end

data/lib/thinking_sphinx/active_record/log_subscriber.rb

@@ -1,61 +1,13 @@
-require 'active_support/log_subscriber'
-
-module ThinkingSphinx
-  module ActiveRecord
-    class LogSubscriber < ActiveSupport::LogSubscriber
-      def self.runtime=(value)
-        Thread.current['thinking_sphinx_query_runtime'] = value
-      end
-
-      def self.runtime
-        Thread.current['thinking_sphinx_query_runtime'] ||= 0
-      end
-
-      def self.reset_runtime
-        rt, self.runtime = runtime, 0
-        rt
-      end
-
-      def initialize
-        super
-        @odd_or_even = false
-      end
-
-      def query(event)
-        self.class.runtime += event.duration
-        return unless logger.debug?
-
-        identifier = color('Sphinx Query (%.1fms)' % event.duration, GREEN, true)
-        query = event.payload[:query]
-        query = color query, nil, true if odd?
-
-        debug "  #{identifier}  #{query}"
-      end
-
-      def message(event)
-        return unless logger.debug?
-
-        identifier = color 'Sphinx', GREEN, true
-        message = event.payload[:message]
-        message = color message, nil, true if odd?
-
-        debug "  #{identifier}  #{message}"
-      end
-
-      def odd?
-        @odd_or_even = !@odd_or_even
-      end
-
-      def logger
-        return @logger if defined? @logger
-        self.logger = ::ActiveRecord::Base.logger
-      end
-
-      def logger=(logger)
-        @logger = logger
-      end
+class ThinkingSphinx::ActiveRecord::LogSubscriber < ActiveSupport::LogSubscriber
+  def query(event)
+    identifier = color('Sphinx Query (%.1fms)' % event.duration, GREEN, true)
+    debug "  #{identifier}  #{event.payload[:query]}"
+  end
 
-      attach_to :thinking_sphinx
-    end
+  def message(event)
+    identifier = color 'Sphinx', GREEN, true
+    debug "  #{identifier}  #{event.payload[:message]}"
   end
 end
+
+ThinkingSphinx::ActiveRecord::LogSubscriber.attach_to :thinking_sphinx

data/lib/thinking_sphinx/active_record/property.rb

@@ -0,0 +1,28 @@
+class ThinkingSphinx::ActiveRecord::Property
+  attr_reader :columns, :options
+
+  def initialize(model, columns, options = {})
+    @model, @options = model, options
+
+    @columns = Array(columns).collect { |column|
+      column.respond_to?(:__name) ? column :
+        ThinkingSphinx::ActiveRecord::Column.new(column)
+    }
+  end
+
+  def facet?
+    options[:facet]
+  end
+
+  def multi?
+    false
+  end
+
+  def name
+    (options[:as] || columns.first.__name).to_s
+  end
+
+  def type
+    nil
+  end
+end

data/lib/thinking_sphinx/active_record/property_sql_presenter.rb

@@ -0,0 +1,60 @@
+class ThinkingSphinx::ActiveRecord::PropertySQLPresenter
+  attr_reader :property, :adapter, :associations
+
+  def initialize(property, adapter, associations)
+    @property, @adapter, @associations = property, adapter, associations
+  end
+
+  def to_group
+    return nil unless group?
+
+    columns_with_table
+  end
+
+  def to_select
+    "#{casted_column_with_table} AS #{adapter.quote property.name}"
+  end
+
+  private
+
+  def aggregate?
+    property.columns.any? { |column|
+      associations.aggregate_for?(column.__stack)
+    }
+  end
+
+  def aggregate_separator
+    (property.multi?) ? ',' : ' '
+  end
+
+  def casted_column_with_table
+    clause = columns_with_table
+    clause = adapter.cast_to_timestamp(clause) if property.type == :timestamp
+    clause = adapter.concatenate(clause, ' ')  if concatenating?
+    if aggregate?
+      clause = adapter.group_concatenate(clause, aggregate_separator)
+    end
+
+    clause
+  end
+
+  def column_with_table(column)
+    return column.__name if column.string?
+
+    "#{associations.alias_for(column.__stack)}.#{adapter.quote column.__name}"
+  end
+
+  def columns_with_table
+    property.columns.collect { |column|
+      column_with_table(column)
+    }.join(', ')
+  end
+
+  def concatenating?
+    property.columns.length > 1
+  end
+
+  def group?
+    !(aggregate? || property.columns.any?(&:string?))
+  end
+end

data/lib/thinking_sphinx/active_record/sql_builder.rb

@@ -0,0 +1,159 @@
+class ThinkingSphinx::ActiveRecord::SQLBuilder
+  attr_reader :source
+
+  def initialize(source)
+    @source = source
+  end
+
+  def sql_query
+    relation = model.unscoped
+    relation = relation.select pre_select + select_clause
+    relation = relation.where where_clause
+    relation = relation.group group_clause
+    relation = relation.order('NULL') if source.type == 'mysql'
+    relation = relation.joins associations.join_values
+
+    relation.to_sql
+  end
+
+  def sql_query_range
+    return nil if source.disable_range?
+
+    minimum = source.adapter.convert_nulls "MIN(#{quoted_primary_key})", 1
+    maximum = source.adapter.convert_nulls "MAX(#{quoted_primary_key})", 1
+
+    relation = source.model.unscoped
+    relation = relation.select "#{minimum}, #{maximum}"
+    relation = relation.where where_clause(true)
+
+    relation.to_sql
+  end
+
+  def sql_query_info
+    relation = source.model.unscoped
+    relation.where("#{quoted_primary_key} = #{reversed_document_id}").to_sql
+  end
+
+  def sql_query_pre
+    queries = []
+
+    reset_delta = delta_processor && !source.delta?
+    max_len     = source.options[:group_concat_max_len]
+
+    queries << delta_processor.reset_query if reset_delta
+    queries << "SET SESSION group_concat_max_len = #{max_len}" if max_len
+    queries << source.adapter.utf8_query_pre if source.options[:utf8?]
+
+    queries.compact
+  end
+
+  private
+
+  def config
+    ThinkingSphinx::Configuration.instance
+  end
+
+  def model
+    source.model
+  end
+
+  def base_join
+    @base_join ||= join_dependency_class.new model, [], initial_joins
+  end
+
+  def delta_processor
+    source.delta_processor
+  end
+
+  def associations
+    @associations ||= ThinkingSphinx::ActiveRecord::Associations.new(model).tap do |assocs|
+      source.associations.each do |association|
+        assocs.add_join_to association.stack
+      end
+    end
+  end
+
+  def quote_column(column)
+    model.connection.quote_column_name(column)
+  end
+
+  def quoted_primary_key
+    "#{model.quoted_table_name}.#{quote_column(source.primary_key)}"
+  end
+
+  def quoted_inheritance_column
+    "#{model.quoted_table_name}.#{quote_column model.inheritance_column}"
+  end
+
+  def pre_select
+    source.type == 'mysql' ? 'SQL_NO_CACHE ' : ''
+  end
+
+  def document_id
+    quoted_alias = quote_column source.primary_key
+    "#{quoted_primary_key} * #{config.indices.count} + #{source.offset} AS #{quoted_alias}"
+  end
+
+  def reversed_document_id
+    "($id - #{source.offset}) / #{config.indices.count}"
+  end
+
+  def attribute_presenters
+    @attribute_presenters ||= begin
+      source.attributes.collect { |attribute|
+        ThinkingSphinx::ActiveRecord::PropertySQLPresenter.new(
+          attribute, source.adapter, associations
+        )
+      }
+    end
+  end
+
+  def field_presenters
+    @field_presenters ||= source.fields.collect { |field|
+      ThinkingSphinx::ActiveRecord::PropertySQLPresenter.new(
+        field, source.adapter, associations
+      )
+    }
+  end
+
+  def select_clause
+    (
+      [document_id] +
+      field_presenters.collect(&:to_select) +
+      attribute_presenters.collect(&:to_select)
+    ).compact.join(', ')
+  end
+
+  def where_clause(without_range = false)
+    logic = []
+
+    unless without_range || source.disable_range?
+      logic << "#{quoted_primary_key} >= $start"
+      logic << "#{quoted_primary_key} <= $end"
+    end
+
+    unless model.descends_from_active_record?
+      klass = model.store_full_sti_class ? model.name : model.name.demodulize
+      logic << "#{quoted_inheritance_column} = '#{klass}'"
+    end
+
+    logic << delta_processor.clause(source.delta?) if delta_processor
+    logic += source.conditions
+
+    logic.compact.join(' AND ')
+  end
+
+  def group_clause
+    internal_groupings = []
+    if model.column_names.include?(model.inheritance_column)
+      internal_groupings << quoted_inheritance_column
+    end
+
+    (
+      [quoted_primary_key] +
+      field_presenters.collect(&:to_group).compact +
+      attribute_presenters.collect(&:to_group).compact +
+      source.groupings + internal_groupings
+    ).join(', ')
+  end
+end