sayso-thinking-sphinx 2.0.3.001

data/lib/thinking_sphinx/active_record/has_many_association.rb

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

data/lib/thinking_sphinx/active_record/has_many_association_with_scopes.rb

@@ -0,0 +1,21 @@
+module ThinkingSphinx
+  module ActiveRecord
+    module HasManyAssociationWithScopes
+      def method_missing(method, *args, &block)
+        if responds_to_scope(method)
+          @reflection.klass.
+            search(:with => default_filter).
+            send(method, *args, &block)
+        else
+          super
+        end
+      end
+      
+      private
+      def responds_to_scope(scope)
+        @reflection.klass.respond_to?(:sphinx_scopes)   &&
+        @reflection.klass.sphinx_scopes.include?(scope)
+      end
+    end
+  end
+end

data/lib/thinking_sphinx/active_record/log_subscriber.rb

@@ -0,0 +1,61 @@
+require 'active_support/log_subscriber'
+
+module ThinkingSphinx
+  module ActiveRecord
+    class LogSubscriber < ActiveSupport::LogSubscriber
+      def self.runtime=(value)
+        Thread.current['thinking_sphinx_query_runtime'] = value
+      end
+
+      def self.runtime
+        Thread.current['thinking_sphinx_query_runtime'] ||= 0
+      end
+
+      def self.reset_runtime
+        rt, self.runtime = runtime, 0
+        rt
+      end
+
+      def initialize
+        super
+        @odd_or_even = false
+      end
+
+      def query(event)
+        self.class.runtime += event.duration
+        return unless logger.debug?
+
+        identifier = color('Sphinx Query (%.1fms)' % event.duration, GREEN, true)
+        query = event.payload[:query]
+        query = color query, nil, true if odd?
+
+        debug "  #{identifier}  #{query}"
+      end
+
+      def message(event)
+        return unless logger.debug?
+
+        identifier = color 'Sphinx', GREEN, true
+        message = event.payload[:message]
+        message = color message, nil, true if odd?
+
+        debug "  #{identifier}  #{message}"
+      end
+
+      def odd?
+        @odd_or_even = !@odd_or_even
+      end
+
+      def logger
+        return @logger if defined? @logger
+        self.logger = ::ActiveRecord::Base.logger
+      end
+
+      def logger=(logger)
+        @logger = logger
+      end
+
+      attach_to :thinking_sphinx
+    end
+  end
+end

data/lib/thinking_sphinx/active_record/scopes.rb

@@ -0,0 +1,93 @@
+module ThinkingSphinx
+  module ActiveRecord
+    module Scopes
+      def self.included(base)
+        base.class_eval do
+          extend ThinkingSphinx::ActiveRecord::Scopes::ClassMethods
+        end
+      end
+    
+      module ClassMethods
+        
+        # Similar to ActiveRecord's default_scope method Thinking Sphinx supports
+        # a default_sphinx_scope. For example:
+        #
+        #    default_sphinx_scope :some_sphinx_named_scope
+        #
+        # The scope is automatically applied when the search method is called. It
+        # will only be applied if it is an existing sphinx_scope.
+        def default_sphinx_scope(sphinx_scope_name)
+          add_sphinx_scopes_support_to_has_many_associations
+          @default_sphinx_scope = sphinx_scope_name
+        end
+
+        # Returns the default_sphinx_scope or nil if none is set.
+        def get_default_sphinx_scope
+          @default_sphinx_scope
+        end
+
+        # Returns true if the current Model has a default_sphinx_scope. Also checks if
+        # the default_sphinx_scope actually is a scope.
+        def has_default_sphinx_scope?
+          !@default_sphinx_scope.nil? && sphinx_scopes.include?(@default_sphinx_scope)
+        end
+
+        # Similar to ActiveRecord's named_scope method Thinking Sphinx supports
+        # scopes. For example:
+        #
+        #   sphinx_scope(:latest_first) { 
+        #       {:order => 'created_at DESC, @relevance DESC'}
+        #     }
+        #
+        # Usage:
+        #
+        #   @articles =  Article.latest_first.search 'pancakes'
+        #
+        def sphinx_scope(method, &block)
+          add_sphinx_scopes_support_to_has_many_associations
+
+          @sphinx_scopes ||= []
+          @sphinx_scopes << method
+          
+          singleton_class.instance_eval do
+            define_method(method) do |*args|
+              options = {:classes => classes_option}
+              options.merge! block.call(*args)
+              
+              ThinkingSphinx::Search.new(options)
+            end
+            
+            define_method("#{method}_without_default".to_sym) do |*args|
+              options = {:classes => classes_option, :ignore_default => true}
+              options.merge! block.call(*args)
+              
+              ThinkingSphinx::Search.new(options)
+            end
+          end
+        end
+
+        # This returns an Array of all defined scopes. The default
+        # scope shows as :default.
+        def sphinx_scopes
+          @sphinx_scopes || []
+        end
+        
+        def remove_sphinx_scopes
+          sphinx_scopes.each do |scope|
+            singleton_class.send(:undef_method, scope)
+          end
+          
+          sphinx_scopes.clear
+        end
+
+        def add_sphinx_scopes_support_to_has_many_associations
+          scope_mixin = ::ThinkingSphinx::ActiveRecord::HasManyAssociationWithScopes
+
+          ::ActiveRecord::Associations::HasManyAssociation.send(:include, scope_mixin)
+          ::ActiveRecord::Associations::HasManyThroughAssociation.send(:include, scope_mixin)
+        end
+
+      end
+    end
+  end
+end

data/lib/thinking_sphinx/adapters/abstract_adapter.rb

@@ -0,0 +1,87 @@
+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)
+      adapter = adapter_for_model model
+      case adapter
+      when :mysql
+        ThinkingSphinx::MysqlAdapter.new model
+      when :postgresql
+        ThinkingSphinx::PostgreSQLAdapter.new model
+      when Class
+        adapter.new model
+      else
+        raise "Invalid Database Adapter: Sphinx only supports MySQL and PostgreSQL, not #{adapter}"
+      end
+    end
+    
+    def self.adapter_for_model(model)
+      case ThinkingSphinx.database_adapter
+      when String
+        ThinkingSphinx.database_adapter.to_sym
+      when NilClass
+        standard_adapter_for_model model
+      when Proc
+        ThinkingSphinx.database_adapter.call model
+      else
+        ThinkingSphinx.database_adapter
+      end
+    end
+    
+    def self.standard_adapter_for_model(model)
+      case model.connection.class.name
+      when "ActiveRecord::ConnectionAdapters::MysqlAdapter",
+           "ActiveRecord::ConnectionAdapters::MysqlplusAdapter",
+           "ActiveRecord::ConnectionAdapters::Mysql2Adapter",
+           "ActiveRecord::ConnectionAdapters::NullDBAdapter"
+        :mysql
+      when "ActiveRecord::ConnectionAdapters::PostgreSQLAdapter"
+        :postgresql
+      when "ActiveRecord::ConnectionAdapters::JdbcAdapter"
+        case model.connection.config[:adapter]
+        when "jdbcmysql"
+          :mysql
+        when "jdbcpostgresql"
+          :postgresql
+        else
+          model.connection.config[:adapter]
+        end
+      else
+        model.connection.class.name
+      end
+    end
+    
+    def quote_with_table(column)
+      "#{@model.quoted_table_name}.#{@model.connection.quote_column_name(column)}"
+    end
+    
+    def bigint_pattern
+      /bigint/i
+    end
+    
+    def downcase(clause)
+      "LOWER(#{clause})"
+    end
+    
+    def case(expression, pairs, default)
+      "CASE #{expression} " +
+      pairs.keys.inject('') { |string, key|
+        string + "WHEN '#{key}' THEN #{pairs[key]} "
+      } + "ELSE #{default} END"
+    end
+    
+    protected
+    
+    def connection
+      @connection ||= @model.connection
+    end
+  end
+end

data/lib/thinking_sphinx/adapters/mysql_adapter.rb

@@ -0,0 +1,58 @@
+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(DISTINCT IFNULL(#{clause}, '0') 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, blank_to_null = false)
+      clause = "NULLIF(#{clause},'')" if blank_to_null
+      "CRC32(#{clause})"
+    end
+    
+    def utf8_query_pre
+      "SET NAMES utf8"
+    end
+    
+    def time_difference(diff)
+      "DATE_SUB(NOW(), INTERVAL #{diff} SECOND)"
+    end
+    
+    def utc_query_pre
+      "SET TIME_ZONE = '+0:00'"
+    end
+  end
+end

data/lib/thinking_sphinx/adapters/postgresql_adapter.rb

@@ -0,0 +1,153 @@
+module ThinkingSphinx
+  class PostgreSQLAdapter < AbstractAdapter
+    def setup
+      create_array_accum_function
+      create_crc32_function
+    end
+    
+    def sphinx_identifier
+      "pgsql"
+    end
+    
+    def concatenate(clause, separator = ' ')
+      if clause[/^COALESCE/]
+        clause.split('), ').join(") || '#{separator}' || ")
+      else
+        clause.split(', ').collect { |field|
+          "CAST(COALESCE(#{field}, '') as varchar)"
+        }.join(" || '#{separator}' || ")
+      end
+    end
+    
+    def group_concatenate(clause, separator = ' ')
+      "array_to_string(array_accum(COALESCE(#{clause}, '0')), '#{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 = case default
+      when String
+        "'#{default}'"
+      when NilClass
+        'NULL'
+      when Fixnum
+        "#{default}::bigint"
+      else
+        default
+      end
+      
+      "COALESCE(#{clause}, #{default})"
+    end
+    
+    def boolean(value)
+      value ? 'TRUE' : 'FALSE'
+    end
+    
+    def crc(clause, blank_to_null = false)
+      clause = "NULLIF(#{clause},'')" if blank_to_null
+      "crc32(#{clause})"
+    end
+    
+    def utf8_query_pre
+      nil
+    end
+    
+    def time_difference(diff)
+      "current_timestamp - interval '#{diff} seconds'"
+    end
+    
+    def utc_query_pre
+      "SET TIME ZONE 'UTC'"
+    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.respond_to?(:server_version) && 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 byte_length int;
+          DECLARE word_array bytea;
+          BEGIN
+            IF COALESCE(word, '') = '' THEN
+              return 0;
+            END IF;
+          
+            i = 0;
+            tmp = 4294967295;
+            byte_length = bit_length(word) / 8;
+            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 >= byte_length THEN
+                EXIT;
+              END IF;
+            END LOOP;
+            return (tmp # 4294967295);
+          END
+        $$ IMMUTABLE LANGUAGE plpgsql;
+      SQL
+      execute function, true
+    end
+  end
+end