pixeltrix-thinking-sphinx 1.1.5

data/lib/thinking_sphinx/active_record/delta.rb

@@ -0,0 +1,74 @@
+module ThinkingSphinx
+  module ActiveRecord
+    # This module contains all the delta-related code for models. There isn't
+    # really anything you need to call manually in here - except perhaps
+    # index_delta, but not sure what reason why.
+    # 
+    module Delta
+      # Code for after_commit callback is written by Eli Miller:
+      # http://elimiller.blogspot.com/2007/06/proper-cache-expiry-with-aftercommit.html
+      # with slight modification from Joost Hietbrink.
+      #
+      def self.included(base)
+        base.class_eval do
+          class << self
+            # Temporarily disable delta indexing inside a block, then perform a single
+            # rebuild of index at the end.
+            #
+            # Useful when performing updates to batches of models to prevent
+            # the delta index being rebuilt after each individual update.
+            #
+            # In the following example, the delta index will only be rebuilt once,
+            # not 10 times.
+            #
+            #   SomeModel.suspended_delta do
+            #     10.times do
+            #       SomeModel.create( ... )
+            #     end
+            #   end
+            #
+            def suspended_delta(reindex_after = true, &block)
+              original_setting = ThinkingSphinx.deltas_enabled?
+              ThinkingSphinx.deltas_enabled = false
+              begin
+                yield
+              ensure
+                ThinkingSphinx.deltas_enabled = original_setting
+                self.index_delta if reindex_after
+              end
+            end
+
+            # Build the delta index for the related model. This won't be called
+            # if running in the test environment.
+            #
+            def index_delta(instance = nil)
+              delta_object.index(self, instance)
+            end
+            
+            def delta_object
+              self.sphinx_indexes.first.delta_object
+            end
+          end
+          
+          private
+          
+          # Set the delta value for the model to be true.
+          def toggle_delta
+            self.class.delta_object.toggle(self) if should_toggle_delta?
+          end
+          
+          # Build the delta index for the related model. This won't be called
+          # if running in the test environment.
+          # 
+          def index_delta
+            self.class.index_delta(self) if self.class.delta_object.toggled(self)
+          end
+          
+          def should_toggle_delta?
+            !self.respond_to?(:changed?) || self.changed? || self.new_record?
+          end
+        end
+      end
+    end
+  end
+end

data/lib/thinking_sphinx/active_record/has_many_association.rb

@@ -0,0 +1,29 @@
+module ThinkingSphinx
+  module ActiveRecord
+    module HasManyAssociation
+      def search(*args)
+        foreign_key = @reflection.primary_key_name
+        stack = [@reflection.options[:through]].compact
+        
+        attribute   = nil
+        (@reflection.klass.sphinx_indexes || []).each do |index|
+          attribute = index.attributes.detect { |attrib|
+            attrib.columns.length == 1 &&
+            attrib.columns.first.__name  == foreign_key.to_sym &&
+            attrib.columns.first.__stack == stack
+          }
+          break if attribute
+        end
+        
+        raise "Missing Attribute for Foreign Key #{foreign_key}" unless attribute
+        
+        options = args.extract_options!
+        options[:with] ||= {}
+        options[:with][attribute.unique_name] = @owner.id
+        
+        args << options
+        @reflection.klass.search(*args)
+      end
+    end
+  end
+end

data/lib/thinking_sphinx/active_record/search.rb

@@ -0,0 +1,57 @@
+module ThinkingSphinx
+  module ActiveRecord
+    # This module covers the specific model searches - but the syntax is
+    # exactly the same as the core Search class - so use that as your refence
+    # point.
+    # 
+    module Search
+      def self.included(base)
+        base.class_eval do
+          class << self
+            # Searches for results that match the parameters provided. Will only
+            # return the ids for the matching objects. See
+            # ThinkingSphinx::Search#search for syntax examples.
+            #
+            def search_for_ids(*args)
+              options = args.extract_options!
+              options[:class] = self
+              args << options
+              ThinkingSphinx::Search.search_for_ids(*args)
+            end
+
+            # Searches for results limited to a single model. See
+            # ThinkingSphinx::Search#search for syntax examples.
+            #
+            def search(*args)
+              options = args.extract_options!
+              options[:class] = self
+              args << options
+              ThinkingSphinx::Search.search(*args)
+            end
+
+            def search_count(*args)
+              options = args.extract_options!
+              options[:class] = self
+              args << options
+              ThinkingSphinx::Search.count(*args)
+            end
+
+            def search_for_id(*args)
+              options = args.extract_options!
+              options[:class] = self
+              args << options
+              ThinkingSphinx::Search.search_for_id(*args)
+            end
+            
+            def facets(*args)
+              options = args.extract_options!
+              options[:class] = self
+              args << options
+              ThinkingSphinx::Search.facets(*args)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/thinking_sphinx/adapters/abstract_adapter.rb

@@ -0,0 +1,34 @@
+module ThinkingSphinx
+  class AbstractAdapter
+    def initialize(model)
+      @model = model
+    end
+    
+    def setup
+      # Deliberately blank - subclasses should do something though. Well, if
+      # they need to.
+    end
+      
+    def self.detect(model)
+      case model.connection.class.name
+      when "ActiveRecord::ConnectionAdapters::MysqlAdapter",
+           "ActiveRecord::ConnectionAdapters::MysqlplusAdapter"
+        ThinkingSphinx::MysqlAdapter.new model
+      when "ActiveRecord::ConnectionAdapters::PostgreSQLAdapter"
+        ThinkingSphinx::PostgreSQLAdapter.new model
+      else
+        raise "Invalid Database Adapter: Sphinx only supports MySQL and PostgreSQL"
+      end
+    end
+    
+    def quote_with_table(column)
+      "#{@model.quoted_table_name}.#{@model.connection.quote_column_name(column)}"
+    end
+    
+    protected
+    
+    def connection
+      @connection ||= @model.connection
+    end
+  end
+end

data/lib/thinking_sphinx/adapters/mysql_adapter.rb

@@ -0,0 +1,53 @@
+module ThinkingSphinx
+  class MysqlAdapter < AbstractAdapter
+    def setup
+      # Does MySQL actually need to do anything?
+    end
+    
+    def sphinx_identifier
+      "mysql"
+    end
+    
+    def concatenate(clause, separator = ' ')
+      "CONCAT_WS('#{separator}', #{clause})"
+    end
+    
+    def group_concatenate(clause, separator = ' ')
+      "GROUP_CONCAT(#{clause} SEPARATOR '#{separator}')"
+    end
+    
+    def cast_to_string(clause)
+      "CAST(#{clause} AS CHAR)"
+    end
+    
+    def cast_to_datetime(clause)
+      "UNIX_TIMESTAMP(#{clause})"
+    end
+    
+    def cast_to_unsigned(clause)
+      "CAST(#{clause} AS UNSIGNED)"
+    end
+    
+    def convert_nulls(clause, default = '')
+      default = "'#{default}'" if default.is_a?(String)
+      
+      "IFNULL(#{clause}, #{default})"
+    end
+    
+    def boolean(value)
+      value ? 1 : 0
+    end
+    
+    def crc(clause)
+      "CRC32(#{clause})"
+    end
+    
+    def utf8_query_pre
+      "SET NAMES utf8"
+    end
+    
+    def time_difference(diff)
+      "DATE_SUB(NOW(), INTERVAL #{diff} SECOND)"
+    end
+  end
+end

data/lib/thinking_sphinx/adapters/postgresql_adapter.rb

@@ -0,0 +1,129 @@
+module ThinkingSphinx
+  class PostgreSQLAdapter < AbstractAdapter
+    def setup
+      create_array_accum_function
+      create_crc32_function
+    end
+    
+    def sphinx_identifier
+      "pgsql"
+    end
+    
+    def concatenate(clause, separator = ' ')
+      clause.split(', ').collect { |field|
+        "COALESCE(CAST(#{field} as varchar), '')"
+      }.join(" || '#{separator}' || ")
+    end
+    
+    def group_concatenate(clause, separator = ' ')
+      "array_to_string(array_accum(#{clause}), '#{separator}')"
+    end
+    
+    def cast_to_string(clause)
+      clause
+    end
+    
+    def cast_to_datetime(clause)
+      "cast(extract(epoch from #{clause}) as int)"
+    end
+    
+    def cast_to_unsigned(clause)
+      clause
+    end
+    
+    def convert_nulls(clause, default = '')
+      default = "'#{default}'" if default.is_a?(String)
+      
+      "COALESCE(#{clause}, #{default})"
+    end
+    
+    def boolean(value)
+      value ? 'TRUE' : 'FALSE'
+    end
+    
+    def crc(clause)
+      "crc32(#{clause})"
+    end
+    
+    def utf8_query_pre
+      nil
+    end
+    
+    def time_difference(diff)
+      "current_timestamp - interval '#{diff} seconds'"
+    end
+    
+    private
+    
+    def execute(command, output_error = false)
+      connection.execute "begin"
+      connection.execute "savepoint ts"
+      begin
+        connection.execute command
+      rescue StandardError => err
+        puts err if output_error
+        connection.execute "rollback to savepoint ts"
+      end
+      connection.execute "release savepoint ts"
+      connection.execute "commit"
+    end
+    
+    def create_array_accum_function
+      if connection.raw_connection.server_version > 80200
+        execute <<-SQL
+          CREATE AGGREGATE array_accum (anyelement)
+          (
+              sfunc = array_append,
+              stype = anyarray,
+              initcond = '{}'
+          );
+        SQL
+      else
+        execute <<-SQL
+          CREATE AGGREGATE array_accum
+          (
+              basetype = anyelement,
+              sfunc = array_append,
+              stype = anyarray,
+              initcond = '{}'
+          );
+        SQL
+      end
+    end
+    
+    def create_crc32_function
+      execute "CREATE LANGUAGE 'plpgsql';"
+      function = <<-SQL
+        CREATE OR REPLACE FUNCTION crc32(word text)
+        RETURNS bigint AS $$
+          DECLARE tmp bigint;
+          DECLARE i int;
+          DECLARE j int;
+          DECLARE word_array bytea;
+          BEGIN
+            i = 0;
+            tmp = 4294967295;
+            word_array = decode(replace(word, E'\\\\', E'\\\\\\\\'), 'escape');
+            LOOP
+              tmp = (tmp # get_byte(word_array, i))::bigint;
+              i = i + 1;
+              j = 0;
+              LOOP
+                tmp = ((tmp >> 1) # (3988292384 * (tmp & 1)))::bigint;
+                j = j + 1;
+                IF j >= 8 THEN
+                  EXIT;
+                END IF;
+              END LOOP;
+              IF i >= char_length(word) THEN
+                EXIT;
+              END IF;
+            END LOOP;
+            return (tmp # 4294967295);
+          END
+        $$ IMMUTABLE STRICT LANGUAGE plpgsql;
+      SQL
+      execute function, true
+    end
+  end
+end

data/lib/thinking_sphinx/association.rb

@@ -0,0 +1,144 @@
+module ThinkingSphinx
+  # Association tracks a specific reflection and join to reference data that
+  # isn't in the base model. Very much an internal class for Thinking Sphinx -
+  # perhaps because I feel it's not as strong (or simple) as most of the rest.
+  # 
+  class Association
+    attr_accessor :parent, :reflection, :join
+    
+    # Create a new association by passing in the parent association, and the
+    # corresponding reflection instance. If there is no parent, pass in nil.
+    # 
+    #   top   = Association.new nil, top_reflection
+    #   child = Association.new top, child_reflection
+    # 
+    def initialize(parent, reflection)
+      @parent, @reflection = parent, reflection
+      @children = {}
+    end
+    
+    # Get the children associations for a given association name. The only time
+    # that there'll actually be more than one association is when the
+    # relationship is polymorphic. To keep things simple though, it will always
+    # be an Array that gets returned (an empty one if no matches).
+    #
+    #   # where pages is an association on the class tied to the reflection.
+    #   association.children(:pages)
+    # 
+    def children(assoc)
+      @children[assoc] ||= Association.children(@reflection.klass, assoc, self)
+    end
+    
+    # Get the children associations for a given class, association name and
+    # parent association. Much like the instance method of the same name, it
+    # will return an empty array if no associations have the name, and only
+    # have multiple association instances if the underlying relationship is
+    # polymorphic.
+    # 
+    #   Association.children(User, :pages, user_association)
+    # 
+    def self.children(klass, assoc, parent=nil)
+      ref = klass.reflect_on_association(assoc)
+      
+      return [] if ref.nil?
+      return [Association.new(parent, ref)] unless ref.options[:polymorphic]
+      
+      # association is polymorphic - create associations for each
+      # non-polymorphic reflection.
+      polymorphic_classes(ref).collect { |klass|
+        Association.new parent, ::ActiveRecord::Reflection::AssociationReflection.new(
+          ref.macro,
+          "#{ref.name}_#{klass.name}".to_sym,
+          casted_options(klass, ref),
+          ref.active_record
+        )
+      }
+    end
+    
+    # Link up the join for this model from a base join - and set parent
+    # associations' joins recursively.
+    #
+    def join_to(base_join)
+      parent.join_to(base_join) if parent && parent.join.nil?
+      
+      @join ||= ::ActiveRecord::Associations::ClassMethods::JoinDependency::JoinAssociation.new(
+        @reflection, base_join, parent ? parent.join : base_join.joins.first
+      )
+    end
+    
+    # Returns the association's join SQL statements - and it replaces
+    # ::ts_join_alias:: with the aliased table name so the generated reflection
+    # join conditions avoid column name collisions.
+    # 
+    def to_sql
+      @join.association_join.gsub(/::ts_join_alias::/,
+        "#{@reflection.klass.connection.quote_table_name(@join.parent.aliased_table_name)}"
+      )
+    end
+    
+    # Returns true if the association - or a parent - is a has_many or
+    # has_and_belongs_to_many.
+    # 
+    def is_many?
+      case @reflection.macro
+      when :has_many, :has_and_belongs_to_many
+        true
+      else
+        @parent ? @parent.is_many? : false
+      end
+    end
+    
+    # Returns an array of all the associations that lead to this one - starting
+    # with the top level all the way to the current association object.
+    # 
+    def ancestors
+      (parent ? parent.ancestors : []) << self
+    end
+    
+    def has_column?(column)
+      @reflection.klass.column_names.include?(column.to_s)
+    end
+    
+    private
+    
+    # Returns all the objects that could be currently instantiated from a
+    # polymorphic association. This is pretty damn fast if there's an index on
+    # the foreign type column - but if there isn't, it can take a while if you
+    # have a lot of data.
+    # 
+    def self.polymorphic_classes(ref)
+      ref.active_record.connection.select_all(
+        "SELECT DISTINCT #{ref.options[:foreign_type]} " +
+        "FROM #{ref.active_record.table_name} " +
+        "WHERE #{ref.options[:foreign_type]} IS NOT NULL"
+      ).collect { |row|
+        row[ref.options[:foreign_type]].constantize
+      }
+    end
+    
+    # Returns a new set of options for an association that mimics an existing
+    # polymorphic relationship for a specific class. It adds a condition to
+    # filter by the appropriate object.
+    # 
+    def self.casted_options(klass, ref)
+      options = ref.options.clone
+      options[:polymorphic]   = nil
+      options[:class_name]    = klass.name
+      options[:foreign_key] ||= "#{ref.name}_id"
+      
+      quoted_foreign_type = klass.connection.quote_column_name ref.options[:foreign_type]
+      case options[:conditions]
+      when nil
+        options[:conditions] = "::ts_join_alias::.#{quoted_foreign_type} = '#{klass.name}'"
+      when Array
+        options[:conditions] << "::ts_join_alias::.#{quoted_foreign_type} = '#{klass.name}'"
+      when Hash
+        options[:conditions].merge!(ref.options[:foreign_type] => klass.name)
+      else
+        options[:conditions] << " AND ::ts_join_alias::.#{quoted_foreign_type} = '#{klass.name}'"
+      end
+      
+      options
+    end
+  end
+end