thinking-sphinx 3.0.3 → 3.0.4

data/lib/thinking_sphinx/active_record/sql_builder.rb

@@ -1,164 +1,143 @@
-class ThinkingSphinx::ActiveRecord::SQLBuilder
-  attr_reader :source
+module ThinkingSphinx
+  module ActiveRecord
+    class 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 = relation.joins custom_joins.collect(&:to_s) if custom_joins.any?
-
-    relation.to_sql.gsub(/\n/, "\\\n")
-  end
-
-  def sql_query_range
-    return nil if source.disable_range?
+      def initialize(source)
+        @source = source
+      end
 
-    minimum = source.adapter.convert_nulls "MIN(#{quoted_primary_key})", 1
-    maximum = source.adapter.convert_nulls "MAX(#{quoted_primary_key})", 1
+      def sql_query
+        statement.to_relation.to_sql.gsub(/\n/, "\\\n")
+      end
 
-    relation = source.model.unscoped
-    relation = relation.select "#{minimum}, #{maximum}"
-    relation = relation.where where_clause(true)
+      def sql_query_range
+        return nil if source.disable_range?
+        statement.to_query_range_relation.to_sql
+      end
 
-    relation.to_sql
-  end
+      def sql_query_info
+        statement.to_query_info_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
+        query.to_query
+      end
 
-  def sql_query_pre
-    queries = []
+      private
 
-    reset_delta = delta_processor && !source.delta?
-    max_len     = source.options[:group_concat_max_len]
+      def query
+        Query.new(self)
+      end
 
-    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?]
+      def statement
+        Statement.new(self)
+      end
 
-    queries.compact
-  end
+      def config
+        ThinkingSphinx::Configuration.instance
+      end
 
-  private
+      delegate :adapter, :model, :delta_processor, :to => :source
+      delegate :convert_nulls, :utf8_query_pre, :to => :adapter
+      def relation
+        model.unscoped
+      end
 
-  def config
-    ThinkingSphinx::Configuration.instance
-  end
+      def base_join
+        @base_join ||= join_dependency_class.new model, [], initial_joins
+      end
 
-  def model
-    source.model
-  end
+      def associations
+        @associations ||= ThinkingSphinx::ActiveRecord::Associations.new(model).tap do |assocs|
+          source.associations.reject(&:string?).each do |association|
+            assocs.add_join_to association.stack
+          end
+        end
+      end
 
-  def base_join
-    @base_join ||= join_dependency_class.new model, [], initial_joins
-  end
+      def custom_joins
+        @custom_joins ||= source.associations.select(&:string?).collect(&:to_s)
+      end
 
-  def delta_processor
-    source.delta_processor
-  end
+      def quote_column(column)
+        model.connection.quote_column_name(column)
+      end
 
-  def associations
-    @associations ||= ThinkingSphinx::ActiveRecord::Associations.new(model).tap do |assocs|
-      source.associations.reject(&:string?).each do |association|
-        assocs.add_join_to association.stack
+      def quoted_primary_key
+        "#{model.quoted_table_name}.#{quote_column(source.primary_key)}"
       end
-    end
-  end
 
-  def custom_joins
-    @custom_joins ||= source.associations.select &:string?
-  end
+      def quoted_inheritance_column
+        "#{model.quoted_table_name}.#{quote_column(model.inheritance_column)}"
+      end
 
-  def quote_column(column)
-    model.connection.quote_column_name(column)
-  end
+      def pre_select
+        ('SQL_NO_CACHE ' if source.type == 'mysql').to_s
+      end
 
-  def quoted_primary_key
-    "#{model.quoted_table_name}.#{quote_column(source.primary_key)}"
-  end
+      def document_id
+        quoted_alias = quote_column source.primary_key
+        "#{quoted_primary_key} * #{config.indices.count} + #{source.offset} AS #{quoted_alias}"
+      end
 
-  def quoted_inheritance_column
-    "#{model.quoted_table_name}.#{quote_column model.inheritance_column}"
-  end
+      def reversed_document_id
+        "($id - #{source.offset}) / #{config.indices.count}"
+      end
 
-  def pre_select
-    source.type == 'mysql' ? 'SQL_NO_CACHE ' : ''
-  end
+      def attribute_presenters
+        @attribute_presenters ||= property_sql_presenters_for(source.attributes)
+      end
 
-  def document_id
-    quoted_alias = quote_column source.primary_key
-    "#{quoted_primary_key} * #{config.indices.count} + #{source.offset} AS #{quoted_alias}"
-  end
+      def field_presenters
+        @field_presenters ||= property_sql_presenters_for(source.fields)
+      end
 
-  def reversed_document_id
-    "($id - #{source.offset}) / #{config.indices.count}"
-  end
+      def property_sql_presenters_for(fields)
+        fields.collect { |field| property_sql_presenter_for(field) }
+      end
 
-  def attribute_presenters
-    @attribute_presenters ||= begin
-      source.attributes.collect { |attribute|
+      def property_sql_presenter_for(field)
         ThinkingSphinx::ActiveRecord::PropertySQLPresenter.new(
-          attribute, source.adapter, associations
+          field, 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
+      end
 
-  def where_clause(for_range = false)
-    logic = []
+      def inheritance_column_condition
+        "#{quoted_inheritance_column} = '#{model_name}'"
+      end
 
-    unless for_range || source.disable_range?
-      logic << "#{quoted_primary_key} >= $start"
-      logic << "#{quoted_primary_key} <= $end"
-    end
+      def range_condition
+        condition = []
+        condition << "#{quoted_primary_key} BETWEEN $start AND $end" unless source.disable_range?
+        condition += source.conditions
+        condition
+      end
 
-    unless model.descends_from_active_record?
-      klass = model.store_full_sti_class ? model.name : model.name.demodulize
-      logic << "#{quoted_inheritance_column} = '#{klass}'"
-    end
+      def presenters_to_group(presenters)
+        presenters.collect(&:to_group)
+      end
 
-    logic << delta_processor.clause(source.delta?) if delta_processor
-    logic += source.conditions unless for_range
+      def presenters_to_select(presenters)
+        presenters.collect(&:to_select)
+      end
 
-    logic.compact.join(' AND ')
-  end
+      def groupings
+        groupings = source.groupings
+        if model.column_names.include?(model.inheritance_column)
+          groupings << quoted_inheritance_column
+        end
+        groupings
+      end
 
-  def group_clause
-    internal_groupings = []
-    if model.column_names.include?(model.inheritance_column)
-      internal_groupings << quoted_inheritance_column
+      def model_name
+        klass = model.name
+        klass = klass.demodulize unless model.store_full_sti_class
+        klass
+      end
     end
-
-    (
-      [quoted_primary_key] +
-      field_presenters.collect(&:to_group).compact +
-      attribute_presenters.collect(&:to_group).compact +
-      source.groupings + internal_groupings
-    ).join(', ')
   end
 end
+
+require 'thinking_sphinx/active_record/sql_builder/statement'
+require 'thinking_sphinx/active_record/sql_builder/query'

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

@@ -0,0 +1,28 @@
+module ThinkingSphinx
+  module ActiveRecord
+    class SQLBuilder::ClauseBuilder
+      def initialize(first_element)
+        @first_element = first_element
+      end
+
+      def compose(*additions)
+        additions.each &method(:add_clause)
+        self
+      end
+
+      def add_clause(clause)
+        self.clauses += Array(clause)
+      end
+
+      def separated(by = ', ')
+        clauses.flatten.compact.join(by)
+      end
+
+      protected
+      attr_accessor :clauses
+      def clauses
+        @clauses ||= [@first_element]
+      end
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+module ThinkingSphinx
+  module ActiveRecord
+    class SQLBuilder::Query
+      def initialize(report)
+        self.report = report
+        self.scope = []
+      end
+
+      def to_query
+        filter_by_query_pre
+
+        scope.compact
+      end
+
+      protected
+      attr_accessor :report, :scope
+
+      def filter_by_query_pre
+        scope_by_delta_processor
+        scope_by_session
+        scope_by_utf8
+      end
+
+      def scope_by_delta_processor
+        self.scope << delta_processor.reset_query if delta_processor && !source.delta?
+      end
+
+      def scope_by_session
+        if max_len = source.options[:group_concat_max_len]
+          self.scope << "SET SESSION group_concat_max_len = #{max_len}"
+        end
+      end
+
+      def scope_by_utf8
+        self.scope += utf8_query_pre if source.options[:utf8?]
+      end
+
+      def method_missing(*args, &block)
+        report.send *args, &block
+      end
+    end
+  end
+end

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

@@ -0,0 +1,110 @@
+require 'thinking_sphinx/active_record/sql_builder/clause_builder'
+
+module ThinkingSphinx
+  module ActiveRecord
+    class SQLBuilder::Statement
+      def initialize(report)
+        self.report = report
+        self.scope = relation
+      end
+
+      def to_relation
+        filter_by_scopes
+
+        scope
+      end
+
+      def to_query_range_relation
+        filter_by_query_range
+
+        scope
+      end
+
+      def to_query_info_relation
+        filter_by_query_info
+
+        scope
+      end
+
+      def to_query_pre
+        filter_by_query_pre
+
+        scope
+      end
+
+      protected
+      attr_accessor :report, :scope
+
+      def filter_by_query_range
+        minimum = convert_nulls "MIN(#{quoted_primary_key})", 1
+        maximum = convert_nulls "MAX(#{quoted_primary_key})", 1
+
+        self.scope = scope.select("#{minimum}, #{maximum}").where(where_clause(true))
+      end
+
+      def filter_by_query_info
+        self.scope = scope.where("#{quoted_primary_key} = #{reversed_document_id}")
+      end
+
+      def filter_by_scopes
+        scope_by_select
+        scope_by_where_clause
+        scope_by_group_clause
+        scope_by_joins
+        scope_by_custom_joins
+        scope_by_order
+      end
+
+      def scope_by_select
+        self.scope = scope.select(pre_select + select_clause)
+      end
+
+      def scope_by_where_clause
+        self.scope = scope.where where_clause
+      end
+
+      def scope_by_group_clause
+        self.scope = scope.group(group_clause)
+      end
+
+      def scope_by_joins
+        self.scope = scope.joins(associations.join_values)
+      end
+
+      def scope_by_custom_joins
+        self.scope = scope.joins(custom_joins) if custom_joins.any?
+      end
+
+      def scope_by_order
+        self.scope = scope.order('NULL') if source.type == 'mysql'
+      end
+
+      def method_missing(*args, &block)
+        report.send *args, &block
+      end
+
+      def select_clause
+        SQLBuilder::ClauseBuilder.new(document_id).compose(
+          presenters_to_select(field_presenters),
+          presenters_to_select(attribute_presenters)
+        ).separated
+      end
+
+      def where_clause(for_range = false)
+        builder = SQLBuilder::ClauseBuilder.new(nil)
+        builder.add_clause inheritance_column_condition unless model.descends_from_active_record?
+        builder.add_clause delta_processor.clause(source.delta?) if delta_processor
+        builder.add_clause range_condition unless for_range
+        builder.separated(' AND ')
+      end
+
+      def group_clause
+        SQLBuilder::ClauseBuilder.new(quoted_primary_key).compose(
+          presenters_to_group(field_presenters),
+          presenters_to_group(attribute_presenters),
+          groupings
+        ).separated
+      end
+    end
+  end
+end