thinking-sphinx 1.2.13 → 6.0.0

data/lib/thinking_sphinx/active_record/property_query.rb

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+class ThinkingSphinx::ActiveRecord::PropertyQuery
+  def initialize(property, source, type = nil)
+    @property, @source, @type = property, source, type
+  end
+
+  def to_s
+    if unsafe_habtm_column?
+      raise <<-MESSAGE
+Source queries cannot be used with HABTM joins if they use anything beyond the
+primary key.
+      MESSAGE
+    end
+
+    if safe_habtm_column?
+      ThinkingSphinx::ActiveRecord::SimpleManyQuery.new(
+        property, source, type
+      ).to_s
+    else
+      "#{identifier} from #{source_type}; #{queries.join('; ')}"
+    end
+  end
+
+  private
+
+  attr_reader :property, :source, :type
+
+  delegate :unscoped, :to => :base_association_class, :prefix => true
+  delegate :sql,      :to => Arel
+
+  def base_association
+    reflections.first
+  end
+
+  def base_association_class
+    base_association.klass
+  end
+
+  def column
+    @column ||= property.columns.first
+  end
+
+  def extend_reflection(reflection)
+    return [reflection] unless reflection.through_reflection
+
+    [reflection.through_reflection, reflection.source_reflection]
+  end
+
+  def identifier
+    [type, property.name].compact.join(' ')
+  end
+
+  def joins
+    @joins ||= begin
+      remainder = reflections.collect(&:name)[1..-1]
+      return nil             if remainder.empty?
+      return remainder.first if remainder.length == 1
+
+      remainder[0..-2].reverse.inject(remainder.last) { |value, key|
+        {key => value}
+      }
+    end
+  end
+
+  def macros
+    reflections.collect &:macro
+  end
+
+  def offset
+    "* #{ThinkingSphinx::Configuration.instance.indices.count} + #{source.offset}"
+  end
+
+  def queries
+    queries    = []
+    if column.string?
+      queries << column.__name.strip.gsub(/\n/, "\\\n")
+    else
+      queries << to_sql
+      queries << range_sql if ranged?
+    end
+    queries
+  end
+
+  def quoted_foreign_key
+    quote_with_table(base_association_class.table_name, base_association.foreign_key)
+  end
+
+  def quoted_primary_key
+    quote_with_table(reflections.last.klass.table_name, column.__name)
+  end
+
+  def quote_with_table(table, column)
+    "#{quote_column(table)}.#{quote_column(column)}"
+  end
+
+  def quote_column(column)
+    ActiveRecord::Base.connection.quote_column_name(column)
+  end
+
+  def ranged?
+    property.source_type == :ranged_query
+  end
+
+  def range_sql
+    base_association_class_unscoped.select(
+      "MIN(#{quoted_foreign_key}), MAX(#{quoted_foreign_key})"
+    ).to_sql
+  end
+
+  def reflections
+    @reflections ||= begin
+      base = source.model
+
+      column.__stack.collect { |key|
+        reflection = base.reflect_on_association key
+        base = reflection.klass
+
+        extend_reflection reflection
+      }.flatten
+    end
+  end
+
+  def safe_habtm_column?
+    macros == [:has_and_belongs_to_many] && column.__name == :id
+  end
+
+  def source_type
+    property.source_type.to_s.dasherize
+  end
+
+  def to_sql
+    raise "Could not determine SQL for MVA" if reflections.empty?
+
+    relation = base_association_class_unscoped.select("#{quoted_foreign_key} #{offset} AS #{quote_column('id')}, #{quoted_primary_key} AS #{quote_column(property.name)}")
+    relation = relation.joins(joins) if joins.present?
+    relation = relation.where("#{quoted_foreign_key} BETWEEN $start AND $end") if ranged?
+    relation = relation.where("#{quoted_foreign_key} IS NOT NULL")
+    relation = relation.order(sql("#{quoted_foreign_key} ASC")) if type.nil?
+
+    relation.to_sql
+  end
+
+  def unsafe_habtm_column?
+    macros.include?(:has_and_belongs_to_many) && (
+      macros.length > 1 || column.__name != :id
+    )
+  end
+end

data/lib/thinking_sphinx/active_record/property_sql_presenter.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+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 if sourced_by_query? || !group?
+
+    columns_with_table
+  end
+
+  def to_select
+    return nil if sourced_by_query?
+
+    "#{casted_column_with_table} AS #{adapter.quote property.name}"
+  end
+
+  private
+
+  delegate :multi?, :to => :property
+
+  def aggregate?
+    column_presenters.any? &:aggregate?
+  end
+
+  def aggregate_separator
+    multi? ? ',' : ' '
+  end
+
+  def cast_to_timestamp(clause)
+    return adapter.cast_to_timestamp clause if property.columns.any?(&:string?)
+
+    clause.split(', ').collect { |part|
+      adapter.cast_to_timestamp part
+    }.join(', ')
+  end
+
+  def casted_column_with_table
+    clause = columns_with_table
+    clause = cast_to_timestamp clause if property.type == :timestamp
+    clause = concatenate clause
+    if aggregate?
+      clause = adapter.group_concatenate(clause, aggregate_separator)
+    end
+
+    clause
+  end
+
+  def column_presenters
+    @column_presenters ||= property.columns.collect { |column|
+      ThinkingSphinx::ActiveRecord::ColumnSQLPresenter.new(
+        property.model, column, adapter, associations
+      )
+    }
+  end
+
+  def columns_with_table
+    column_presenters.collect(&:with_table).compact.join(', ')
+  end
+
+  def concatenating?
+    property.columns.length > 1
+  end
+
+  def concatenate(clause)
+    return clause unless concatenating?
+
+    if property.type.nil?
+      adapter.concatenate clause, ' '
+    else
+      clause = clause.split(', ').collect { |part|
+        adapter.cast_to_string part
+      }.join(', ')
+      adapter.concatenate clause, ','
+    end
+  end
+
+  def group?
+    !(aggregate? || property.columns.any?(&:string?))
+  end
+
+  def sourced_by_query?
+    property.source_type.to_s[/query/]
+  end
+end

data/lib/thinking_sphinx/active_record/simple_many_query.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+class ThinkingSphinx::ActiveRecord::SimpleManyQuery <
+  ThinkingSphinx::ActiveRecord::PropertyQuery
+
+  def to_s
+    "#{identifier} from #{source_type}; #{queries.join('; ')}"
+  end
+
+  private
+
+  def reflection
+    @reflection ||= source.model.reflect_on_association column.__stack.first
+  end
+
+  def quoted_foreign_key
+    quote_with_table reflection.join_table, reflection.foreign_key
+  end
+
+  def quoted_primary_key
+    quote_with_table reflection.join_table, reflection.association_foreign_key
+  end
+
+  def range_sql
+    "SELECT MIN(#{quoted_foreign_key}), MAX(#{quoted_foreign_key}) FROM #{quote_column reflection.join_table}"
+  end
+
+  def to_sql
+    selects = [
+      "#{quoted_foreign_key} #{offset} AS #{quote_column('id')}",
+      "#{quoted_primary_key} AS #{quote_column(property.name)}"
+    ]
+    sql  = "SELECT #{selects.join(', ')} FROM #{quote_column reflection.join_table}"
+    sql += " WHERE (#{quoted_foreign_key} BETWEEN $start AND $end)" if ranged?
+    sql
+  end
+end

data/lib/thinking_sphinx/active_record/source_joins.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+class ThinkingSphinx::ActiveRecord::SourceJoins
+  def self.call(model, source)
+    new(model, source).call
+  end
+
+  def initialize(model, source)
+    @model, @source = model, source
+  end
+
+  def call
+    append_specified_associations
+    append_property_associations
+
+    joins
+  end
+
+  private
+
+  attr_reader :model, :source
+
+  def append_property_associations
+    source.properties.collect(&:columns).each do |columns|
+      columns.each { |column| append_column_associations column }
+    end
+  end
+
+  def append_column_associations(column)
+    return if column.__stack.empty? or column_included_in_queries?(column)
+
+    joins.add_join_to column.__stack if column_exists?(column)
+  end
+
+  def append_specified_associations
+    source.associations.reject(&:string?).each do |association|
+      joins.add_join_to association.stack
+    end
+  end
+
+  def column_exists?(column)
+    Joiner::Path.new(model, column.__stack).model
+    true
+  rescue Joiner::AssociationNotFound
+    false
+  end
+
+  def joins
+    @joins ||= begin
+      joins = Joiner::Joins.new model
+      if joins.respond_to?(:join_association_class)
+        joins.join_association_class = ThinkingSphinx::ActiveRecord::JoinAssociation
+      end
+      joins
+    end
+  end
+
+  def source_query_properties
+    source.properties.select { |field| field.source_type == :query }
+  end
+
+  # Use "first" here instead of a more intuitive flatten because flatten
+  # will also ask each column to become an Array and that will start
+  # to retrieve data.
+  def column_included_in_queries?(column)
+    source_query_properties.collect(&:columns).collect(&:first).include?(column)
+  end
+end

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

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

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

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+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_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]
+
+        self.scope << "SET SESSION group_concat_max_len = #{max_len}"
+      end
+
+      def scope_by_time_zone
+        return if config.settings['skip_time_zone']
+
+        self.scope += time_zone_query_pre
+      end
+
+      def scope_by_utf8
+        self.scope += utf8_query_pre if source.options[:utf8?]
+      end
+
+      def source
+        report.source
+      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,147 @@
+# frozen_string_literal: true
+
+require 'thinking_sphinx/active_record/sql_builder/clause_builder'
+
+module ThinkingSphinx
+  module ActiveRecord
+    class SQLBuilder::Statement
+      def initialize(report)
+        @report = report
+        @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_pre
+        filter_by_query_pre
+
+        scope
+      end
+
+      private
+
+      attr_reader :report, :scope
+
+      def custom_joins
+        @custom_joins ||= source.associations.select(&:string?).collect(&:to_s)
+      end
+
+      def filter_by_query_range
+        minimum = convert_nulls "MIN(#{quoted_primary_key})", 1
+        maximum = convert_nulls "MAX(#{quoted_primary_key})", 1
+
+        @scope = scope.select("#{minimum}, #{maximum}").where(
+          where_clause(true)
+        )
+      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 attribute_presenters
+        @attribute_presenters ||= property_sql_presenters_for source.attributes
+      end
+
+      def field_presenters
+        @field_presenters ||= property_sql_presenters_for source.fields
+      end
+
+      def presenters_to_group(presenters)
+        presenters.collect(&:to_group)
+      end
+
+      def presenters_to_select(presenters)
+        presenters.collect(&:to_select)
+      end
+
+      def property_sql_presenters_for(properties)
+        properties.collect { |property| property_sql_presenter_for(property) }
+      end
+
+      def property_sql_presenter_for(property)
+        ThinkingSphinx::ActiveRecord::PropertySQLPresenter.new(
+          property, source.adapter, associations
+        )
+      end
+
+      def scope_by_select
+        @scope = scope.select(pre_select + select_clause)
+      end
+
+      def scope_by_where_clause
+        @scope = scope.where where_clause
+      end
+
+      def scope_by_group_clause
+        @scope = scope.group(group_clause)
+      end
+
+      def scope_by_joins
+        @scope = scope.joins(associations.join_values)
+      end
+
+      def scope_by_custom_joins
+        @scope = scope.joins(custom_joins) if custom_joins.any?
+      end
+
+      def scope_by_order
+        @scope = scope.order('NULL') if source.type == 'mysql'
+      end
+
+      def source
+        report.source
+      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 delta_processor.clause(source.delta?) if delta_processor
+        builder.add_clause range_condition unless for_range
+        builder.separated(' AND ')
+      end
+
+      def group_clause
+        builder = SQLBuilder::ClauseBuilder.new(quoted_primary_key)
+
+        builder.compose(
+          presenters_to_group(field_presenters),
+          presenters_to_group(attribute_presenters)
+        ) unless minimal_group_by?
+
+        builder.compose(groupings).separated
+      end
+
+      def minimal_group_by?
+        source.options[:minimal_group_by?] ||
+        config.settings['minimal_group_by?'] ||
+        config.settings['minimal_group_by']
+      end
+    end
+  end
+end

data/lib/thinking_sphinx/active_record/sql_builder.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+module ThinkingSphinx
+  module ActiveRecord
+    class SQLBuilder
+      attr_reader :source
+
+      def initialize(source)
+        @source = source
+      end
+
+      def sql_query
+        statement.to_relation.to_sql.gsub(/\n/, "\\\n")
+      end
+
+      def sql_query_range
+        return nil if source.disable_range?
+        statement.to_query_range_relation.to_sql
+      end
+
+      def sql_query_pre
+        query.to_query
+      end
+
+      private
+
+      delegate :adapter, :model, :delta_processor, :to => :source
+      delegate :convert_nulls, :time_zone_query_pre, :utf8_query_pre,
+        :cast_to_bigint, :to => :adapter
+
+      def query
+        Query.new(self)
+      end
+
+      def statement
+        Statement.new(self)
+      end
+
+      def config
+        ThinkingSphinx::Configuration.instance
+      end
+
+      def relation
+        model.unscoped
+      end
+
+      def associations
+        @associations ||= ThinkingSphinx::ActiveRecord::SourceJoins.call(
+          model, source
+        )
+      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
+        ('SQL_NO_CACHE ' if source.type == 'mysql').to_s
+      end
+
+      def big_document_ids?
+        source.options[:big_document_ids] || config.settings['big_document_ids']
+      end
+
+      def document_id
+        quoted_alias = quote_column source.primary_key
+        column = quoted_primary_key
+        column = cast_to_bigint column if big_document_ids?
+        column = "#{column} * #{config.indices.count} + #{source.offset}"
+
+        "#{column} AS #{quoted_alias}"
+      end
+
+      def range_condition
+        condition = []
+        condition << "#{quoted_primary_key} BETWEEN $start AND $end" unless source.disable_range?
+        condition += source.conditions
+        condition
+      end
+
+      def groupings
+        groupings = source.groupings
+        if model.column_names.include?(model.inheritance_column)
+          groupings << quoted_inheritance_column
+        end
+        groupings
+      end
+
+      def model_name
+        klass = model.name
+        klass = klass.demodulize unless model.store_full_sti_class
+        klass
+      end
+    end
+  end
+end
+
+require 'thinking_sphinx/active_record/sql_builder/statement'
+require 'thinking_sphinx/active_record/sql_builder/query'