freelancing-god-thinking-sphinx 1.1.2 → 1.1.3

data/README

@@ -99,3 +99,7 @@ Since I first released this library, there's been quite a few people who have su
 - Thibaut Barrere
 - Kristopher Chambers
 - Dmitrij Smalko
+- Aleksey Yeschenko
+- Lachie Cox
+- Lourens Naude
+- Tom Davies

data/lib/thinking_sphinx.rb

@@ -6,11 +6,13 @@ require 'active_record'
 require 'riddle'
 require 'after_commit'
 
+require 'thinking_sphinx/core/string'
 require 'thinking_sphinx/active_record'
 require 'thinking_sphinx/association'
 require 'thinking_sphinx/attribute'
 require 'thinking_sphinx/collection'
 require 'thinking_sphinx/configuration'
+require 'thinking_sphinx/facet'
 require 'thinking_sphinx/field'
 require 'thinking_sphinx/index'
 require 'thinking_sphinx/rails_additions'
@@ -24,14 +26,14 @@ require 'thinking_sphinx/adapters/postgresql_adapter'
 ActiveRecord::Base.send(:include, ThinkingSphinx::ActiveRecord)
 
 Merb::Plugins.add_rakefiles(
-  File.join(File.dirname(__FILE__), "..", "tasks", "thinking_sphinx_tasks")
+  File.join(File.dirname(__FILE__), "thinking_sphinx", "tasks")
 ) if defined?(Merb)
 
 module ThinkingSphinx
   module Version #:nodoc:
     Major = 1
     Minor = 1
-    Tiny  = 2
+    Tiny  = 3
     
     String = [Major, Minor, Tiny].join('.')
   end

data/lib/thinking_sphinx/active_record.rb

@@ -10,7 +10,7 @@ module ThinkingSphinx
   module ActiveRecord
     def self.included(base)
       base.class_eval do
-        class_inheritable_array :sphinx_indexes
+        class_inheritable_array :sphinx_indexes, :sphinx_facets
         class << self
           # Allows creation of indexes for Sphinx. If you don't do this, there
           # isn't much point trying to search (or using this plugin at all,
@@ -94,14 +94,7 @@ module ThinkingSphinx
           # you in some other way, awesome.
           # 
           def to_crc32
-            result = 0xFFFFFFFF
-            self.name.each_byte do |byte|
-              result ^= byte
-              8.times do
-                result = (result >> 1) ^ (0xEDB88320 * (result & 1))
-              end
-            end
-            result ^ 0xFFFFFFFF
+            self.name.to_crc32
           end
           
           def to_crc32s
@@ -121,13 +114,18 @@ module ThinkingSphinx
           end
           
           def to_riddle(offset)
-            ThinkingSphinx::AbstractAdapter.detect(self).setup
+            sphinx_database_adapter.setup
             
             indexes = [to_riddle_for_core(offset)]
             indexes << to_riddle_for_delta(offset) if sphinx_delta?
             indexes << to_riddle_for_distributed
           end
           
+          def sphinx_database_adapter
+            @sphinx_database_adapter ||=
+              ThinkingSphinx::AbstractAdapter.detect(self)
+          end
+          
           private
           
           def sphinx_name

data/lib/thinking_sphinx/active_record/search.rb

@@ -42,6 +42,13 @@ module ThinkingSphinx
               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

data/lib/thinking_sphinx/adapters/abstract_adapter.rb

@@ -1,27 +1,33 @@
 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 initialize(model)
+      @model = model
+    end
+    
+    def setup
+      # Deliberately blank - subclasses should do something though. Well, if
+      # they need to.
+    end
       
-      def connection
-        @connection ||= ::ActiveRecord::Base.connection
+    def self.detect(model)
+      case model.connection.class.name
+      when "ActiveRecord::ConnectionAdapters::MysqlAdapter"
+        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

@@ -1,9 +1,53 @@
 module ThinkingSphinx
   class MysqlAdapter < AbstractAdapter
-    class << self
-      def setup
-        # Does MySQL actually need to do anything?
-      end
+    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

@@ -1,83 +1,129 @@
 module ThinkingSphinx
   class PostgreSQLAdapter < AbstractAdapter
-    class << self
-      def setup
-        create_array_accum_function
-        create_crc32_function
-      end
-      
-      private
+    def setup
+      create_array_accum_function
+      create_crc32_function
+    end
+    
+    def sphinx_identifier
+      "pgsql"
+    end
+    
+    def concatenate(clause, separator = ' ')
+      clause.split(', ').collect { |field|
+        "COALESCE(#{field}, '')"
+      }.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)
       
-      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"
+      "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
-      
-      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
+      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
-      
-      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');
+    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 # 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
+                tmp = ((tmp >> 1) # (3988292384 * (tmp & 1)))::bigint;
+                j = j + 1;
+                IF j >= 8 THEN
                   EXIT;
                 END IF;
               END LOOP;
-              return (tmp # 4294967295);
-            END
-          $$ IMMUTABLE STRICT LANGUAGE plpgsql;
-        SQL
-        execute function, true
-      end
+              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/attribute.rb

@@ -9,7 +9,7 @@ module ThinkingSphinx
   # associations. Which can get messy. Use Index.link!, it really helps.
   # 
   class Attribute
-    attr_accessor :alias, :columns, :associations, :model
+    attr_accessor :alias, :columns, :associations, :model, :faceted
     
     # To create a new attribute, you'll need to pass in either a single Column
     # or an array of them, and some (optional) options.
@@ -59,8 +59,9 @@ module ThinkingSphinx
       
       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]
+      @alias    = options[:as]
+      @type     = options[:type]
+      @faceted  = options[:facet]
     end
     
     # Get the part of the SELECT clause related to this attribute. Don't forget
@@ -76,10 +77,10 @@ module ThinkingSphinx
       
       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 = adapter.concatenate(clause, separator)       if concat_ws?
+      clause = adapter.group_concatenate(clause, separator) if is_many?
+      clause = adapter.cast_to_datetime(clause)             if type == :datetime
+      clause = adapter.convert_nulls(clause)                if type == :string
       
       "#{clause} AS #{quote_column(unique_name)}"
     end
@@ -133,63 +134,31 @@ module ThinkingSphinx
       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(', ').collect { |attribute|
-          "COALESCE(#{attribute}, '')"
-        }.join(" || ' ' || ")
-      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}')"
+    # 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
-        clause
+        translated_type_from_database
       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
+    def to_facet
+      return nil unless @faceted
+      
+      ThinkingSphinx::Facet.new(unique_name, @columns, self)
     end
     
-    def cast_to_datetime(clause)
-      case @model.connection.class.name
-      when "ActiveRecord::ConnectionAdapters::MysqlAdapter"
-        "UNIX_TIMESTAMP(#{clause})"
-      when "ActiveRecord::ConnectionAdapters::PostgreSQLAdapter"
-        "cast(extract(epoch from #{clause}) as int)"
-      else
-        clause
-      end
-    end
+    private
     
-    def convert_nulls(clause)
-      case @model.connection.class.name
-      when "ActiveRecord::ConnectionAdapters::MysqlAdapter"
-        "IFNULL(#{clause}, '')"
-      when "ActiveRecord::ConnectionAdapters::PostgreSQLAdapter"
-        "COALESCE(#{clause}, '')"
-      else
-        clause
-      end
+    def adapter
+      @adapter ||= @model.sphinx_database_adapter
     end
     
     def quote_column(column)
@@ -203,16 +172,7 @@ module ThinkingSphinx
     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).
     # 
@@ -252,21 +212,6 @@ module ThinkingSphinx
       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
-        translated_type_from_database
-      end
-    end
-    
     def all_ints?
       @columns.all? { |col|
         klasses = @associations[col].empty? ? [@model] :