jaikoo-thinking-sphinx 0.9.10

data/lib/thinking_sphinx/active_record/search.rb

@@ -0,0 +1,50 @@
+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
+          end
+        end
+      end
+    end
+  end
+end

data/lib/thinking_sphinx/adapters/abstract_adapter.rb

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

data/lib/thinking_sphinx/adapters/mysql_adapter.rb

@@ -0,0 +1,9 @@
+module ThinkingSphinx
+  class MysqlAdapter < AbstractAdapter
+    class << self
+      def setup
+        # Does MySQL actually need to do anything?
+      end
+    end
+  end
+end

data/lib/thinking_sphinx/adapters/postgresql_adapter.rb

@@ -0,0 +1,84 @@
+module ThinkingSphinx
+  class PostgreSQLAdapter < AbstractAdapter
+    class << self
+      def setup
+        create_array_accum_function
+        create_crc32_function
+      end
+      
+      private
+      
+      def create_array_accum_function
+        connection.execute "begin"
+        connection.execute "savepoint ts"
+        begin
+          # See http://www.postgresql.org/docs/8.2/interactive/sql-createaggregate.html
+          if connection.raw_connection.server_version > 80200
+            connection.execute <<-SQL
+              CREATE AGGREGATE array_accum (anyelement)
+              (
+                  sfunc = array_append,
+                  stype = anyarray,
+                  initcond = '{}'
+              );
+            SQL
+          else
+            connection.execute <<-SQL
+              CREATE AGGREGATE array_accum
+              (
+                  basetype = anyelement,
+                  sfunc = array_append,
+                  stype = anyarray,
+                  initcond = '{}'
+              );
+            SQL
+          end
+        rescue
+          connection.execute "rollback to savepoint ts"
+        end
+        connection.execute "release savepoint ts"
+        connection.execute "commit"
+      end
+      
+      def create_crc32_function
+        connection.execute "begin"
+        connection.execute "savepoint ts"
+        begin
+          connection.execute "CREATE LANGUAGE 'plpgsql';"
+          connection.execute <<-SQL
+            CREATE OR REPLACE FUNCTION crc32(word text)
+            RETURNS bigint AS $$
+              DECLARE tmp bigint;
+              DECLARE i int;
+              DECLARE j int;
+              BEGIN
+                i = 0;
+                tmp = 4294967295;
+                LOOP
+                  tmp = (tmp # get_byte(word::bytea, 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
+        rescue
+          connection.execute "rollback to savepoint ts"
+        end
+        connection.execute "release savepoint ts"
+        connection.execute "commit"
+      end
+    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

data/lib/thinking_sphinx/attribute.rb

@@ -0,0 +1,284 @@
+module ThinkingSphinx
+  # Attributes - eternally useful when it comes to filtering, sorting or
+  # grouping. This class isn't really useful to you unless you're hacking
+  # around with the internals of Thinking Sphinx - but hey, don't let that
+  # stop you.
+  #
+  # One key thing to remember - if you're using the attribute manually to
+  # generate SQL statements, you'll need to set the base model, and all the
+  # associations. Which can get messy. Use Index.link!, it really helps.
+  # 
+  class Attribute
+    attr_accessor :alias, :columns, :associations, :model
+    
+    # To create a new attribute, you'll need to pass in either a single Column
+    # or an array of them, and some (optional) options.
+    #
+    # Valid options are:
+    # - :as   => :alias_name 
+    # - :type => :attribute_type
+    #
+    # Alias is only required in three circumstances: when there's
+    # another attribute or field with the same name, when the column name is
+    # 'id', or when there's more than one column.
+    # 
+    # Type is not required, unless you want to force a column to be a certain
+    # type (but keep in mind the value will not be CASTed in the SQL
+    # statements). The only time you really need to use this is when the type
+    # can't be figured out by the column - ie: when not actually using a
+    # database column as your source.
+    # 
+    # Example usage:
+    #
+    #   Attribute.new(
+    #     Column.new(:created_at)
+    #   )
+    #
+    #   Attribute.new(
+    #     Column.new(:posts, :id),
+    #     :as => :post_ids
+    #   )
+    #
+    #   Attribute.new(
+    #     [Column.new(:pages, :id), Column.new(:articles, :id)],
+    #     :as => :content_ids
+    #   )
+    #
+    #   Attribute.new(
+    #     Column.new("NOW()"),
+    #     :as   => :indexed_at,
+    #     :type => :datetime
+    #   )
+    #
+    # If you're creating attributes for latitude and longitude, don't forget
+    # that Sphinx expects these values to be in radians.
+    #  
+    def initialize(columns, options = {})
+      @columns      = Array(columns)
+      @associations = {}
+      
+      raise "Cannot define a field with no columns. Maybe you are trying to index a field with a reserved name (id, name). You can fix this error by using a symbol rather than a bare name (:id instead of id)." if @columns.empty? || @columns.any? { |column| !column.respond_to?(:__stack) }
+      
+      @alias        = options[:as]
+      @type         = options[:type]
+    end
+    
+    # Get the part of the SELECT clause related to this attribute. Don't forget
+    # to set your model and associations first though.
+    #
+    # This will concatenate strings and arrays of integers, and convert
+    # datetimes to timestamps, as needed.
+    # 
+    def to_select_sql
+      clause = @columns.collect { |column|
+        column_with_prefix(column)
+      }.join(', ')
+      
+      separator = all_ints? ? ',' : ' '
+      
+      clause = concatenate(clause, separator)       if concat_ws?
+      clause = group_concatenate(clause, separator) if is_many?
+      clause = cast_to_datetime(clause)             if type == :datetime
+      clause = convert_nulls(clause)                if type == :string
+      
+      "#{clause} AS #{quote_column(unique_name)}"
+    end
+    
+    # Get the part of the GROUP BY clause related to this attribute - if one is
+    # needed. If not, all you'll get back is nil. The latter will happen if
+    # there isn't actually a real column to get data from, or if there's
+    # multiple data values (read: a has_many or has_and_belongs_to_many
+    # association).
+    # 
+    def to_group_sql
+      case
+      when is_many?, is_string?, ThinkingSphinx.use_group_by_shortcut?
+        nil
+      else
+        @columns.collect { |column|
+          column_with_prefix(column)
+        }
+      end
+    end
+    
+    # Generates the appropriate attribute statement for a Sphinx configuration
+    # file, depending on the attribute's type.
+    # 
+    def to_sphinx_clause
+      case type
+      when :multi
+        "sql_attr_multi       = uint #{unique_name} from field"
+      when :datetime
+        "sql_attr_timestamp   = #{unique_name}"
+      when :string
+        "sql_attr_str2ordinal = #{unique_name}"
+      when :float
+        "sql_attr_float       = #{unique_name}"
+      when :boolean
+        "sql_attr_bool        = #{unique_name}"
+      else
+        "sql_attr_uint        = #{unique_name}"
+      end
+    end
+    
+    # Returns the unique name of the attribute - which is either the alias of
+    # the attribute, or the name of the only column - if there is only one. If
+    # there isn't, there should be an alias. Else things probably won't work.
+    # Consider yourself warned.
+    # 
+    def unique_name
+      if @columns.length == 1
+        @alias || @columns.first.__name
+      else
+        @alias
+      end
+    end
+    
+    private
+    
+    def concatenate(clause, separator = ' ')
+      case @model.connection.class.name
+      when "ActiveRecord::ConnectionAdapters::MysqlAdapter"
+        "CONCAT_WS('#{separator}', #{clause})"
+      when "ActiveRecord::ConnectionAdapters::PostgreSQLAdapter"
+        clause.split(', ').join(" || '#{separator}' || ")
+      else
+        clause
+      end
+    end
+    
+    def group_concatenate(clause, separator = ' ')
+      case @model.connection.class.name
+      when "ActiveRecord::ConnectionAdapters::MysqlAdapter"
+        "GROUP_CONCAT(#{clause} SEPARATOR '#{separator}')"
+      when "ActiveRecord::ConnectionAdapters::PostgreSQLAdapter"
+        "array_to_string(array_accum(#{clause}), '#{separator}')"
+      else
+        clause
+      end
+    end
+    
+    def cast_to_string(clause)
+      case @model.connection.class.name
+      when "ActiveRecord::ConnectionAdapters::MysqlAdapter"
+        "CAST(#{clause} AS CHAR)"
+      when "ActiveRecord::ConnectionAdapters::PostgreSQLAdapter"
+        clause
+      else
+        clause
+      end
+    end
+    
+    def cast_to_datetime(clause)
+      case @model.connection.class.name
+      when "ActiveRecord::ConnectionAdapters::MysqlAdapter"
+        "UNIX_TIMESTAMP(#{clause})"
+      when "ActiveRecord::ConnectionAdapters::PostgreSQLAdapter"
+        clause # Rails' datetimes are timestamps in PostgreSQL
+      else
+        clause
+      end
+    end
+    
+    def convert_nulls(clause)
+      case @model.connection.class.name
+      when "ActiveRecord::ConnectionAdapters::MysqlAdapter"
+        "IFNULL(#{clause}, '')"
+      when "ActiveRecord::ConnectionAdapters::PostgreSQLAdapter"
+        "COALESCE(#{clause}, '')"
+      else
+        clause
+      end
+    end
+    
+    def quote_column(column)
+      @model.connection.quote_column_name(column)
+    end
+    
+    # Indication of whether the columns should be concatenated with a space
+    # between each value. True if there's either multiple sources or multiple
+    # associations.
+    # 
+    def concat_ws?
+      multiple_associations? || @columns.length > 1
+    end
+    
+    # Checks the association tree for each column - if they're all the same,
+    # returns false.
+    # 
+    def multiple_sources?
+      first = associations[@columns.first]
+      
+      !@columns.all? { |col| associations[col] == first }
+    end
+    
+    # Checks whether any column requires multiple associations (which only
+    # happens for polymorphic situations).
+    # 
+    def multiple_associations?
+      associations.any? { |col,assocs| assocs.length > 1 }
+    end
+    
+    # Builds a column reference tied to the appropriate associations. This
+    # dives into the associations hash and their corresponding joins to
+    # figure out how to correctly reference a column in SQL.
+    # 
+    def column_with_prefix(column)
+      if column.is_string?
+        column.__name
+      elsif associations[column].empty?
+        "#{@model.quoted_table_name}.#{quote_column(column.__name)}"
+      else
+        associations[column].collect { |assoc|
+          assoc.has_column?(column.__name) ?
+          "#{@model.connection.quote_table_name(assoc.join.aliased_table_name)}" + 
+          ".#{quote_column(column.__name)}" :
+          nil
+        }.compact.join(', ')
+      end
+    end
+    
+    # Could there be more than one value related to the parent record? If so,
+    # then this will return true. If not, false. It's that simple.
+    # 
+    def is_many?
+      associations.values.flatten.any? { |assoc| assoc.is_many? }
+    end
+    
+    # Returns true if any of the columns are string values, instead of database
+    # column references.
+    def is_string?
+      columns.all? { |col| col.is_string? }
+    end
+    
+    # Returns the type of the column. If that's not already set, it returns
+    # :multi if there's the possibility of more than one value, :string if
+    # there's more than one association, otherwise it figures out what the
+    # actual column's datatype is and returns that.
+    def type
+      @type ||= case
+      when is_many?
+        :multi
+      when @associations.values.flatten.length > 1
+        :string
+      else
+        klass = @associations.values.flatten.first ? 
+          @associations.values.flatten.first.reflection.klass : @model
+        klass.columns.detect { |col|
+          @columns.collect { |c| c.__name.to_s }.include? col.name
+        }.type
+      end
+    end
+    
+    def all_ints?
+      @columns.all? { |col|
+        klasses = @associations[col].empty? ? [@model] :
+          @associations[col].collect { |assoc| assoc.reflection.klass }
+        klasses.all? { |klass|
+          column = klass.columns.detect { |column| column.name == col.__name.to_s }
+          !column.nil? && column.type == :integer
+        }
+      }
+    end
+  end
+end