dpickett-thinking-sphinx 1.1.12 → 1.1.23

data/lib/thinking_sphinx/deltas.rb

@@ -4,20 +4,23 @@ require 'thinking_sphinx/deltas/datetime_delta'
 
 module ThinkingSphinx
   module Deltas
-    def self.parse(index, options)
-      delta_option = options.delete(:delta)
+    def self.parse(index)
+      delta_option = index.local_options.delete(:delta)
       case delta_option
       when TrueClass, :default
-        DefaultDelta.new index, options
+        DefaultDelta.new index, index.local_options
       when :delayed
-        DelayedDelta.new index, options
+        DelayedDelta.new index, index.local_options
       when :datetime
-        DatetimeDelta.new index, options
+        DatetimeDelta.new index, index.local_options
       when FalseClass, nil
         nil
       else
+        if delta_option.is_a?(String)
+          delta_option = Kernel.const_get(delta_option)
+        end
         if delta_option.ancestors.include?(ThinkingSphinx::Deltas::DefaultDelta)
-          delta_option.new index, options
+          delta_option.new index, index.local_options
         else
           raise "Unknown delta type"
         end

data/lib/thinking_sphinx/deltas/datetime_delta.rb

@@ -18,8 +18,8 @@ module ThinkingSphinx
         config = ThinkingSphinx::Configuration.instance
         rotate = ThinkingSphinx.sphinx_running? ? "--rotate" : ""
         
-        output = `#{config.bin_path}indexer --config #{config.config_file} #{rotate} #{delta_index_name model}`
-        output += `#{config.bin_path}indexer --config #{config.config_file} #{rotate} --merge #{core_index_name model} #{delta_index_name model} --merge-dst-range sphinx_deleted 0 0`
+        output = `#{config.bin_path}#{config.indexer_binary_name} --config #{config.config_file} #{rotate} #{delta_index_name model}`
+        output += `#{config.bin_path}#{config.indexer_binary_name} --config #{config.config_file} #{rotate} --merge #{core_index_name model} #{delta_index_name model} --merge-dst-range sphinx_deleted 0 0`
         puts output unless ThinkingSphinx.suppress_delta_output?
         
         true
@@ -39,7 +39,7 @@ module ThinkingSphinx
       
       def clause(model, toggled)
         if toggled
-          "#{model.quoted_table_name}.#{@index.quote_column(@column.to_s)}" +
+          "#{model.quoted_table_name}.#{model.connection.quote_column_name(@column.to_s)}" +
           " > #{adapter.time_difference(@threshold)}"
         else
           nil

data/lib/thinking_sphinx/deltas/default_delta.rb

@@ -17,7 +17,7 @@ module ThinkingSphinx
         client = Riddle::Client.new config.address, config.port
         rotate = ThinkingSphinx.sphinx_running? ? "--rotate" : ""
         
-        output = `#{config.bin_path}indexer --config #{config.config_file} #{rotate} #{delta_index_name model}`
+        output = `#{config.bin_path}#{config.indexer_binary_name} --config #{config.config_file} #{rotate} #{delta_index_name model}`
         puts(output) unless ThinkingSphinx.suppress_delta_output?
         
         client.update(
@@ -39,12 +39,12 @@ module ThinkingSphinx
       
       def reset_query(model)
         "UPDATE #{model.quoted_table_name} SET " +
-        "#{@index.quote_column(@column.to_s)} = #{adapter.boolean(false)} " +
-        "WHERE #{@index.quote_column(@column.to_s)} = #{adapter.boolean(true)}"
+        "#{model.connection.quote_column_name(@column.to_s)} = #{adapter.boolean(false)} " +
+        "WHERE #{model.connection.quote_column_name(@column.to_s)} = #{adapter.boolean(true)}"
       end
       
       def clause(model, toggled)
-        "#{model.quoted_table_name}.#{@index.quote_column(@column.to_s)}" +
+        "#{model.quoted_table_name}.#{model.connection.quote_column_name(@column.to_s)}" +
         " = #{adapter.boolean(toggled)}"
       end
       

data/lib/thinking_sphinx/deltas/delayed_delta/delta_job.rb

@@ -14,7 +14,7 @@ module ThinkingSphinx
         config = ThinkingSphinx::Configuration.instance
         client = Riddle::Client.new config.address, config.port
         
-        output = `#{config.bin_path}indexer --config #{config.config_file} --rotate #{index}`
+        output = `#{config.bin_path}#{config.indexer_binary_name} --config #{config.config_file} --rotate #{index}`
         puts output unless ThinkingSphinx.suppress_delta_output?
         
         true

data/lib/thinking_sphinx/deploy/capistrano.rb

@@ -1,80 +1,98 @@
-namespace :thinking_sphinx do
-  namespace :install do
-    desc "Install Sphinx by source"
-    task :sphinx do
-      with_postgres = false
-      run "which pg_config" do |channel, stream, data|
-        with_postgres = !(data.nil? || data == "")
-      end
+Capistrano::Configuration.instance(:must_exist).load do
+  namespace :thinking_sphinx do
+    namespace :install do
+      desc <<-DESC
+        Install Sphinx by source
+        
+        If Postgres is available, Sphinx will use it.
+        
+        If the variable :thinking_sphinx_configure_args is set, it will
+        be passed to the Sphinx configure script. You can use this to
+        install Sphinx in a non-standard location:
+        
+          set :thinking_sphinx_configure_args, "--prefix=$HOME/software"
+DESC
+
+      task :sphinx do
+        with_postgres = false
+        begin
+          run "which pg_config" do |channel, stream, data|
+            with_postgres = !(data.nil? || data == "")
+          end
+        rescue Capistrano::CommandError => e
+          puts "Continuing despite error: #{e.message}"
+        end
       
-      args = []
-      if with_postgres
-        run "pg_config --pkgincludedir" do |channel, stream, data|
-          args << "--with-pgsql=#{data}"
+        args = []
+        if with_postgres
+          run "pg_config --pkgincludedir" do |channel, stream, data|
+            args << "--with-pgsql=#{data}"
+          end
         end
+        args << fetch(:thinking_sphinx_configure_args, '')
+        
+        commands = <<-CMD
+        wget -q http://www.sphinxsearch.com/downloads/sphinx-0.9.8.1.tar.gz >> sphinx.log
+        tar xzvf sphinx-0.9.8.1.tar.gz
+        cd sphinx-0.9.8.1
+        ./configure #{args.join(" ")}
+        make
+        #{try_sudo} make install
+        rm -rf sphinx-0.9.8.1 sphinx-0.9.8.1.tar.gz
+        CMD
+        run commands.split(/\n\s+/).join(" && ")
       end
-      
-      commands = <<-CMD
-      wget -q http://www.sphinxsearch.com/downloads/sphinx-0.9.8.1.tar.gz >> sphinx.log
-      tar xzvf sphinx-0.9.8.1.tar.gz
-      cd sphinx-0.9.8.1
-      ./configure #{args.join(" ")}
-      make
-      sudo make install
-      rm -rf sphinx-0.9.8.1 sphinx-0.9.8.1.tar.gz
-      CMD
-      run commands.split(/\n\s+/).join(" && ")
-    end
     
-    desc "Install Thinking Sphinx as a gem from GitHub"
-    task :ts do
-      sudo "gem install freelancing-god-thinking-sphinx --source http://gems.github.com"
+      desc "Install Thinking Sphinx as a gem from GitHub"
+      task :ts do
+        run "#{try_sudo} gem install freelancing-god-thinking-sphinx --source http://gems.github.com"
+      end
     end
-  end
   
-  desc "Generate the Sphinx configuration file"
-  task :configure do
-    rake "thinking_sphinx:configure"
-  end
+    desc "Generate the Sphinx configuration file"
+    task :configure do
+      rake "thinking_sphinx:configure"
+    end
   
-  desc "Index data"
-  task :index do
-    rake "thinking_sphinx:index"
-  end
+    desc "Index data"
+    task :index do
+      rake "thinking_sphinx:index"
+    end
   
-  desc "Start the Sphinx daemon"
-  task :start do
-    configure
-    rake "thinking_sphinx:start"
-  end
+    desc "Start the Sphinx daemon"
+    task :start do
+      configure
+      rake "thinking_sphinx:start"
+    end
   
-  desc "Stop the Sphinx daemon"
-  task :stop do
-    configure
-    rake "thinking_sphinx:stop"
-  end
+    desc "Stop the Sphinx daemon"
+    task :stop do
+      configure
+      rake "thinking_sphinx:stop"
+    end
   
-  desc "Stop and then start the Sphinx daemon"
-  task :restart do
-    stop
-    start
-  end
+    desc "Stop and then start the Sphinx daemon"
+    task :restart do
+      stop
+      start
+    end
   
-  desc "Stop, re-index and then start the Sphinx daemon"
-  task :rebuild do
-    stop
-    index
-    start
-  end
+    desc "Stop, re-index and then start the Sphinx daemon"
+    task :rebuild do
+      stop
+      index
+      start
+    end
   
-  desc "Add the shared folder for sphinx files for the production environment"
-  task :shared_sphinx_folder, :roles => :web do
-    sudo "mkdir -p #{shared_path}/db/sphinx/production"
-  end
+    desc "Add the shared folder for sphinx files for the production environment"
+    task :shared_sphinx_folder, :roles => :web do
+      run "mkdir -p #{shared_path}/db/sphinx/production"
+    end
 
-  def rake(*tasks)
-    tasks.each do |t|
-      run "cd #{current_path} && rake #{t} RAILS_ENV=production"
+    def rake(*tasks)
+      tasks.each do |t|
+        run "cd #{current_path} && rake #{t} RAILS_ENV=production"
+      end
     end
   end
 end

data/lib/thinking_sphinx/facet.rb

@@ -1,11 +1,11 @@
 module ThinkingSphinx
   class Facet
-    attr_reader :reference
+    attr_reader :property
     
-    def initialize(reference)
-      @reference = reference
+    def initialize(property)
+      @property = property
       
-      if reference.columns.length != 1
+      if property.columns.length != 1
         raise "Can't translate Facets on multiple-column field or attribute"
       end
     end
@@ -19,29 +19,62 @@ module ThinkingSphinx
       end
     end
     
-    def name
-      reference.unique_name
-    end
-
     def self.attribute_name_for(name)
       name.to_s == 'class' ? 'class_crc' : "#{name}_facet"
     end
     
+    def self.attribute_name_from_value(name, value)
+      case value
+      when String
+        attribute_name_for(name)
+      when Array
+        if value.all? { |val| val.is_a?(Integer) }
+          name
+        else
+          attribute_name_for(name)
+        end
+      else
+        name
+      end
+    end
+    
+    def self.translate?(property)
+      return true if property.is_a?(Field)
+      
+      case property.type
+      when :string
+        true
+      when :integer, :boolean, :datetime, :float
+        false
+      when :multi
+        !property.all_ints?
+      end
+    end
+    
+    def name
+      property.unique_name
+    end
+    
     def attribute_name
-      # @attribute_name ||= case @reference
-      # when Attribute
-      #   @reference.unique_name.to_s
-      # when Field
-      @attribute_name ||= @reference.unique_name.to_s + "_facet"
-      # end
+      if translate?
+        Facet.attribute_name_for(@property.unique_name)
+      else
+        @property.unique_name.to_s
+      end
+    end
+    
+    def translate?
+      Facet.translate?(@property)
+    end
+    
+    def type
+      @property.is_a?(Field) ? :string : @property.type
     end
     
     def value(object, attribute_value)
-      return translate(object, attribute_value) if @reference.is_a?(Field)
+      return translate(object, attribute_value) if translate?
       
-      case @reference.type
-      when :string
-        translate(object, attribute_value)
+      case @property.type
       when :datetime
         Time.at(attribute_value)
       when :boolean
@@ -59,13 +92,17 @@ module ThinkingSphinx
     
     def translate(object, attribute_value)
       column.__stack.each { |method|
-        object = object.send(method)
+        return nil unless object = object.send(method)
       }
-      object.send(column.__name)
+      if object.is_a?(Array)
+        object.collect { |item| item.send(column.__name) }
+      else
+        object.send(column.__name)
+      end
     end
     
     def column
-      @reference.columns.first
+      @property.columns.first
     end
   end
 end

data/lib/thinking_sphinx/facet_collection.rb

@@ -3,28 +3,25 @@ module ThinkingSphinx
     attr_accessor :arguments
     
     def initialize(arguments)
-      @arguments        = arguments.clone
-      @attribute_values = {}
-      @facet_names           = []
+      @arguments    = arguments.clone
+      @facet_names  = []
     end
     
     def add_from_results(facet, results)
       name = ThinkingSphinx::Facet.name_for(facet)
-
-      self[name]              ||= {}
-      @attribute_values[name] ||= {}
+      
+      self[name]  ||= {}
       @facet_names << name
-
+      
       return if results.empty?
-
+      
       facet = facet_from_object(results.first, facet) if facet.is_a?(String)
       
       results.each_with_groupby_and_count { |result, group, count|
         facet_value = facet.value(result, group)
         
-        self[name][facet_value]              ||= 0
-        self[name][facet_value]              += count
-        @attribute_values[name][facet_value]  = group
+        self[name][facet_value] ||= 0
+        self[name][facet_value]  += count
       }
     end
     
@@ -34,7 +31,7 @@ module ThinkingSphinx
       options[:with] ||= {}
       
       hash.each do |key, value|
-        attrib = ThinkingSphinx::Facet.attribute_name_for(key)
+        attrib = ThinkingSphinx::Facet.attribute_name_from_value(key, value)
         options[:with][attrib] = underlying_value key, value
       end
       
@@ -48,8 +45,10 @@ module ThinkingSphinx
       case value
       when Array
         value.collect { |item| underlying_value(key, item) }
+      when String
+        value.to_crc32
       else
-        @attribute_values[key][value]
+        value
       end
     end
     

data/lib/thinking_sphinx/field.rb

@@ -52,12 +52,14 @@ module ThinkingSphinx
     #     :as => :posts, :prefixes => true
     #   )
     # 
-    def initialize(columns, options = {})
+    def initialize(source, columns, options = {})
       super
       
       @sortable = options[:sortable] || false
       @infixes  = options[:infixes]  || false
       @prefixes = options[:prefixes] || false
+      
+      source.fields << self
     end
     
     # Get the part of the SELECT clause related to this field. Don't forget

data/lib/thinking_sphinx/index.rb

@@ -9,8 +9,7 @@ module ThinkingSphinx
   # Enjoy.
   # 
   class Index
-    attr_accessor :model, :fields, :attributes, :conditions, :groupings,
-      :delta_object, :options
+    attr_accessor :model, :sources, :delta_object
     
     # Create a new index instance by passing in the model it is tied to, and
     # a block to build it with (optional but recommended). For documentation
@@ -28,129 +27,60 @@ module ThinkingSphinx
     #
     def initialize(model, &block)
       @model        = model
-      @associations = {}
-      @fields       = []
-      @attributes   = []
-      @conditions   = []
-      @groupings    = []
+      @sources      = []
       @options      = {}
       @delta_object = nil
-      
-      initialize_from_builder(&block) if block_given?
-      
-      add_internal_attributes_and_facets
-      
-      # 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
     
-    def name
-      self.class.name(@model)
+    def fields
+      @sources.collect { |source| source.fields }.flatten
     end
     
-    def self.name(model)
-      model.name.underscore.tr(':/\\', '_')
+    def attributes
+      @sources.collect { |source| source.attributes }.flatten
     end
     
-    def to_riddle_for_core(offset, index)
-      link!
-      
-      source = Riddle::Configuration::SQLSource.new(
-        "#{name}_core_#{index}", adapter.sphinx_identifier
-      )
-      
-      set_source_database_settings  source
-      set_source_attributes         source, offset
-      set_source_sql                source, offset
-      set_source_settings           source
-      
-      source
+    def name
+      self.class.name(@model)
     end
     
-    def to_riddle_for_delta(offset, index)
-      link!
-      
-      source = Riddle::Configuration::SQLSource.new(
-        "#{name}_delta_#{index}", adapter.sphinx_identifier
-      )
-      source.parent = "#{name}_core_#{index}"
-      
-      set_source_database_settings  source
-      set_source_attributes         source, offset
-      set_source_sql                source, offset, true
-      
-      source
+    def self.name(model)
+      model.name.underscore.tr(':/\\', '_')
     end
     
-    # Link all the fields and associations to their corresponding
-    # associations and joins. This _must_ be called before interrogating
-    # the index's fields and associations for anything that may reference
-    # their SQL structure.
-    # 
-    def link!
-      base = ::ActiveRecord::Associations::ClassMethods::JoinDependency.new(
-        @model, [], nil
-      )
-      
-      @fields.each { |field|
-        field.model ||= @model
-        field.columns.each { |col|
-          field.associations[col] = associations(col.__stack.clone)
-          field.associations[col].each { |assoc| assoc.join_to(base) }
-        }
-      }
-      
-      @attributes.each { |attribute|
-        attribute.model ||= @model
-        attribute.columns.each { |col|
-          attribute.associations[col] = associations(col.__stack.clone)
-          attribute.associations[col].each { |assoc| assoc.join_to(base) }
-        }
-      }
+    def prefix_fields
+      fields.select { |field| field.prefixes }
     end
     
-    # Flag to indicate whether this index has a corresponding delta index.
-    #
-    def delta?
-      !@delta_object.nil?
+    def infix_fields
+      fields.select { |field| field.infixes }
     end
     
-    def adapter
-      @adapter ||= @model.sphinx_database_adapter
-    end
-        
-    def prefix_fields
-      @fields.select { |field| field.prefixes }
+    def local_options
+      @options
     end
     
-    def infix_fields
-      @fields.select { |field| field.infixes }
-    end
-        
-    def index_options
+    def options
       all_index_options = ThinkingSphinx::Configuration.instance.index_options.clone
       @options.keys.select { |key|
-        ThinkingSphinx::Configuration::IndexOptions.include?(key.to_s)
+        ThinkingSphinx::Configuration::IndexOptions.include?(key.to_s) ||
+        ThinkingSphinx::Configuration::CustomOptions.include?(key.to_s)
       }.each { |key| all_index_options[key.to_sym] = @options[key] }
       all_index_options
     end
-        
-    def quote_column(column)
-      @model.connection.quote_column_name(column)
+    
+    def delta?
+      !@delta_object.nil?
     end
     
     private
     
+    def adapter
+      @adapter ||= @model.sphinx_database_adapter
+    end
+    
     def utf8?
-      self.index_options[:charset_type] == "utf-8"
+      options[:charset_type] == "utf-8"
     end
     
     # Does all the magic with the block provided to the base #initialize.
@@ -158,267 +88,12 @@ module ThinkingSphinx
     # on it, then pulls all relevant settings - fields, attributes, conditions,
     # properties - into the new index.
     # 
-    # Also creates a CRC attribute for the model.
-    # 
     def initialize_from_builder(&block)
-      builder = Class.new(Builder)
-      builder.setup
-      
-      builder.instance_eval &block
-      
-      unless @model.descends_from_active_record?
-        stored_class = @model.store_full_sti_class ? @model.name : @model.name.demodulize
-        builder.where("#{@model.quoted_table_name}.#{quote_column(@model.inheritance_column)} = '#{stored_class}'")
-      end
-      
-      set_model = Proc.new { |item| item.model = @model }
-      
-      @fields       = builder.fields &set_model
-      @attributes   = builder.attributes.each &set_model
-      @conditions   = builder.conditions
-      @groupings    = builder.groupings
-      @delta_object = ThinkingSphinx::Deltas.parse self, builder.properties
-      @options      = builder.properties
-      
-      is_faceted = Proc.new { |item| item.faceted }
-      add_facet  = Proc.new { |item| @model.sphinx_facets << item.to_facet }
-      
-      @model.sphinx_facets ||= []
-      @fields.select(    &is_faceted).each &add_facet
-      @attributes.select(&is_faceted).each &add_facet
-    end
-    
-    # Returns all associations used amongst all the fields and attributes.
-    # This includes all associations between the model and what the actual
-    # columns are from.
-    # 
-    def all_associations
-      @all_associations ||= (
-        # field associations
-        @fields.collect { |field|
-          field.associations.values
-        }.flatten +
-        # attribute associations
-        @attributes.collect { |attrib|
-          attrib.associations.values if attrib.include_as_association?
-        }.compact.flatten
-      ).uniq.collect { |assoc|
-        # get ancestors as well as column-level associations
-        assoc.ancestors
-      }.flatten.uniq
-    end
-    
-    # Gets a stack of associations for a specific path.
-    # 
-    def associations(path, parent = nil)
-      assocs = []
-      
-      if parent.nil?
-        assocs = association(path.shift)
-      else
-        assocs = parent.children(path.shift)
-      end
-      
-      until path.empty?
-        point = path.shift
-        assocs = assocs.collect { |assoc|
-          assoc.children(point)
-        }.flatten
-      end
-      
-      assocs
-    end
-    
-    # Gets the association stack for a specific key.
-    # 
-    def association(key)
-      @associations[key] ||= Association.children(@model, key)
-    end
-
-    def crc_column
-      if @model.column_names.include?(@model.inheritance_column)
-        adapter.cast_to_unsigned(adapter.convert_nulls(
-          adapter.crc(adapter.quote_with_table(@model.inheritance_column), true),
-          @model.to_crc32
-        ))
-      else
-        @model.to_crc32.to_s
-      end
-    end
-    
-    def add_internal_attributes_and_facets
-      add_internal_attribute :sphinx_internal_id, :integer, @model.primary_key.to_sym
-      add_internal_attribute :class_crc,          :integer, crc_column, true
-      add_internal_attribute :subclass_crcs,      :multi,   subclasses_to_s
-      add_internal_attribute :sphinx_deleted,     :integer, "0"
-      
-      add_internal_facet :class_crc
-    end
-    
-    def add_internal_attribute(name, type, contents, facet = false)
-      return unless attribute_by_alias(name).nil?
-      
-      @attributes << Attribute.new(
-        FauxColumn.new(contents),
-        :type   => type,
-        :as     => name,
-        :facet  => facet,
-        :admin  => true
-      )
-    end
-    
-    def add_internal_facet(name)
-      return unless facet_by_alias(name).nil?
-      
-      @model.sphinx_facets << ClassFacet.new(attribute_by_alias(name))
-    end
-    
-    def attribute_by_alias(attr_alias)
-      @attributes.detect { |attrib| attrib.alias == attr_alias }
-    end
-    
-    def facet_by_alias(name)
-      @model.sphinx_facets.detect { |facet| facet.name == name }
-    end
-    
-    def subclasses_to_s
-      "'" + (@model.send(:subclasses).collect { |klass|
-        klass.to_crc32.to_s
-      } << @model.to_crc32.to_s).join(",") + "'"
-    end
-        
-    def set_source_database_settings(source)
-      config = @model.connection.instance_variable_get(:@config)
-      
-      source.sql_host = config[:host]           || "localhost"
-      source.sql_user = config[:username]       || config[:user] || ""
-      source.sql_pass = (config[:password].to_s || "").gsub('#', '\#')
-      source.sql_db   = config[:database]
-      source.sql_port = config[:port]
-      source.sql_sock = config[:socket]
-    end
-    
-    def set_source_attributes(source, offset = nil)
-      attributes.each do |attrib|
-        source.send(attrib.type_to_config) << attrib.config_value(offset)
-      end
-    end
-    
-    def set_source_sql(source, offset, delta = false)
-      source.sql_query        = to_sql(:offset => offset, :delta => delta).gsub(/\n/, ' ')
-      source.sql_query_range  = to_sql_query_range(:delta => delta)
-      source.sql_query_info   = to_sql_query_info(offset)
-      
-      source.sql_query_pre += send(!delta ? :sql_query_pre_for_core : :sql_query_pre_for_delta)
-      
-      if @options[:group_concat_max_len]
-        source.sql_query_pre << "SET SESSION group_concat_max_len = #{@options[:group_concat_max_len]}"
-      end
-      
-      source.sql_query_pre += [adapter.utf8_query_pre].compact if utf8?
-    end
-    
-    def set_source_settings(source)
-      ThinkingSphinx::Configuration.instance.source_options.each do |key, value|
-        source.send("#{key}=".to_sym, value)
-      end
-      
-      @options.each do |key, value|
-        source.send("#{key}=".to_sym, value) if ThinkingSphinx::Configuration::SourceOptions.include?(key.to_s) && !value.nil?
-      end
-    end
-    
-    def sql_query_pre_for_core
-      if self.delta? && !@delta_object.reset_query(@model).blank?
-        [@delta_object.reset_query(@model)]
-      else
-        []
-      end
+      #
     end
     
     def sql_query_pre_for_delta
       [""]
     end
-    
-    # Generates the big SQL statement to get the data back for all the fields
-    # and attributes, using all the relevant association joins. If you want
-    # the version filtered for delta values, send through :delta => true in the
-    # options. Won't do much though if the index isn't set up to support a
-    # delta sibling.
-    # 
-    # Examples:
-    # 
-    #   index.to_sql
-    #   index.to_sql(:delta => true)
-    #
-    def to_sql(options={})
-      assocs = all_associations
-      
-      where_clause = ""
-      if self.delta? && !@delta_object.clause(@model, options[:delta]).blank?
-        where_clause << " AND #{@delta_object.clause(@model, options[:delta])}"
-      end
-      unless @conditions.empty?
-        where_clause << " AND " << @conditions.join(" AND ")
-      end
-      
-      internal_groupings = []
-      if @model.column_names.include?(@model.inheritance_column)
-         internal_groupings << "#{@model.quoted_table_name}.#{quote_column(@model.inheritance_column)}"
-      end
-      
-      unique_id_expr = ThinkingSphinx.unique_id_expression(options[:offset])
-      
-      sql = <<-SQL
-SELECT #{ (
-  ["#{@model.quoted_table_name}.#{quote_column(@model.primary_key)} #{unique_id_expr} AS #{quote_column(@model.primary_key)} "] + 
-  @fields.collect { |field| field.to_select_sql } +
-  @attributes.collect { |attribute| attribute.to_select_sql }
-).compact.join(", ") }
-FROM #{ @model.table_name }
-  #{ assocs.collect { |assoc| assoc.to_sql }.join(' ') }
-WHERE #{@model.quoted_table_name}.#{quote_column(@model.primary_key)} >= $start
-  AND #{@model.quoted_table_name}.#{quote_column(@model.primary_key)} <= $end
-  #{ where_clause }
-GROUP BY #{ (
-  ["#{@model.quoted_table_name}.#{quote_column(@model.primary_key)}"] + 
-  @fields.collect { |field| field.to_group_sql }.compact +
-  @attributes.collect { |attribute| attribute.to_group_sql }.compact +
-  @groupings + internal_groupings
-).join(", ") }
-      SQL
-      
-      sql += " ORDER BY NULL" if adapter.sphinx_identifier == "mysql"
-      sql
-    end
-    
-    # Simple helper method for the query info SQL - which is a statement that
-    # returns the single row for a corresponding id.
-    # 
-    def to_sql_query_info(offset)
-      "SELECT * FROM #{@model.quoted_table_name} WHERE " +
-      " #{quote_column(@model.primary_key)} = (($id - #{offset}) / #{ThinkingSphinx.indexed_models.size})"
-    end
-    
-    # Simple helper method for the query range SQL - which is a statement that
-    # returns minimum and maximum id values. These can be filtered by delta -
-    # so pass in :delta => true to get the delta version of the SQL.
-    # 
-    def to_sql_query_range(options={})
-      min_statement = adapter.convert_nulls(
-        "MIN(#{quote_column(@model.primary_key)})", 1
-      )
-      max_statement = adapter.convert_nulls(
-        "MAX(#{quote_column(@model.primary_key)})", 1
-      )
-      
-      sql = "SELECT #{min_statement}, #{max_statement} " +
-            "FROM #{@model.quoted_table_name} "
-      if self.delta? && !@delta_object.clause(@model, options[:delta]).blank?
-        sql << "WHERE #{@delta_object.clause(@model, options[:delta])}"
-      end
-      
-      sql
-    end
   end
 end