nixme-thinking-sphinx 0.9.7

data/lib/riddle/client/filter.rb

@@ -0,0 +1,44 @@
+module Riddle
+  class Client
+    # Used for querying Sphinx.
+    class Filter
+      attr_accessor :attribute, :values, :exclude
+      
+      # Attribute name, values (which can be an array or a range), and whether
+      # the filter should be exclusive.
+      def initialize(attribute, values, exclude=false)
+        @attribute, @values, @exclude = attribute, values, exclude
+      end
+      
+      def exclude?
+        self.exclude
+      end
+      
+      # Returns the message for this filter to send to the Sphinx service
+      def query_message
+        message = Message.new
+        
+        message.append_string self.attribute
+        case self.values
+        when Range
+          if self.values.first.is_a?(Float) && self.values.last.is_a?(Float)
+            message.append_int FilterTypes[:float_range]
+            message.append_floats self.values.first, self.values.last
+          else
+            message.append_int FilterTypes[:range]
+            message.append_ints self.values.first, self.values.last
+          end
+        when Array
+          message.append_int FilterTypes[:values]
+          message.append_int self.values.length
+          # using to_f is a hack from the php client - to workaround 32bit
+          # signed ints on x32 platforms
+          message.append_ints *self.values.collect { |val| val.to_f }
+        end
+        message.append_int self.exclude? ? 1 : 0
+        
+        message.to_s
+      end
+    end
+  end
+end

data/lib/riddle/client/message.rb

@@ -0,0 +1,65 @@
+module Riddle
+  class Client
+    # This class takes care of the translation of ints, strings and arrays to
+    # the format required by the Sphinx service.
+    class Message
+      def initialize
+        @message = ""
+        @size_method = @message.respond_to?(:bytesize) ? :bytesize : :length
+      end
+      
+      # Append raw data (only use if you know what you're doing)
+      def append(*args)
+        return if args.length == 0
+        
+        args.each { |arg| @message << arg }
+      end
+      
+      # Append a string's length, then the string itself
+      def append_string(str)
+        @message << [str.send(@size_method)].pack('N') + str
+      end
+      
+      # Append an integer
+      def append_int(int)
+        @message << [int].pack('N')
+      end
+      
+      def append_64bit_int(int)
+        @message << [int >> 32, int & 0xFFFFFFFF].pack('NN')
+      end
+      
+      # Append a float
+      def append_float(float)
+        @message << [float].pack('f').unpack('L*').pack("N")
+      end
+      
+      # Append multiple integers
+      def append_ints(*ints)
+        ints.each { |int| append_int(int) }
+      end
+      
+      def append_64bit_ints(*ints)
+        ints.each { |int| append_64bit_int(int) }
+      end
+      
+      # Append multiple floats
+      def append_floats(*floats)
+        floats.each { |float| append_float(float) }
+      end
+      
+      # Append an array of strings - first appends the length of the array,
+      # then each item's length and value.
+      def append_array(array)
+        append_int(array.length)
+        
+        array.each { |item| append_string(item) }
+      end
+      
+      # Returns the entire message
+      def to_s
+        @message
+      end
+    end
+  end
+end

data/lib/riddle/client/response.rb

@@ -0,0 +1,84 @@
+module Riddle
+  class Client
+    # Used to interrogate responses from the Sphinx daemon. Keep in mind none
+    # of the methods here check whether the data they're grabbing are what the
+    # user expects - it just assumes the user knows what the data stream is
+    # made up of.
+    class Response
+      # Create with the data to interpret
+      def initialize(str)
+        @str = str
+        @marker = 0
+      end
+      
+      # Return the next string value in the stream
+      def next
+        len = next_int
+        result = @str[@marker, len]
+        @marker += len
+        
+        return result
+      end
+      
+      # Return the next integer value from the stream
+      def next_int
+        int = @str[@marker, 4].unpack('N*').first
+        @marker += 4
+        
+        return int
+      end
+      
+      def next_64bit_int
+        high, low = @str[@marker, 8].unpack('N*N*')[0..1]
+        @marker += 8
+        
+        return (high << 32) + low
+      end
+      
+      # Return the next float value from the stream
+      def next_float
+        float = @str[@marker, 4].unpack('N*').pack('L').unpack('f*').first
+        @marker += 4
+        
+        return float
+      end
+      
+      # Returns an array of string items
+      def next_array
+        count = next_int
+        items = []
+        for i in 0...count
+          items << self.next
+        end
+        
+        return items
+      end
+      
+      # Returns an array of int items
+      def next_int_array
+        count = next_int
+        items = []
+        for i in 0...count
+          items << self.next_int
+        end
+        
+        return items
+      end
+      
+      def next_float_array
+        count = next_int
+        items = []
+        for i in 0...count
+          items << self.next_float
+        end
+        
+        return items
+      end
+      
+      # Returns the length of the streamed data
+      def length
+        @str.length
+      end
+    end
+  end
+end

data/lib/test.rb

@@ -0,0 +1,46 @@
+require 'thinking_sphinx'
+
+ActiveRecord::Base.establish_connection(
+  :adapter  => 'mysql',
+  :database => 'nullus_development',
+  :username => 'nullus',
+  :password => 'wossname',
+  :host     => 'localhost'
+)
+ActiveRecord::Base.logger = Logger.new(STDERR)
+
+class User < ActiveRecord::Base
+  has_many :posts, :foreign_key => "created_by"
+end
+
+class Post < ActiveRecord::Base
+  belongs_to :creator, :foreign_key => "created_by", :class_name => "User"
+  belongs_to :updater, :foreign_key => "updated_by", :class_name => "User"
+  belongs_to :topic
+end
+
+class Topic < ActiveRecord::Base
+  belongs_to :creator, :foreign_key => "created_by", :class_name => "User"
+  belongs_to :forum
+  has_many :posts
+end
+
+class Forum < ActiveRecord::Base
+  belongs_to :creator, :foreign_key => "created_by", :class_name => "User"
+  has_many :topics
+end
+
+def index
+  @index ||= ThinkingSphinx::Index.new(Topic) do
+    indexes posts.content, :as => :posts
+    indexes posts.creator.login, :as => :authors
+    
+    has :created_at
+    has :id, :as => :topic_id
+    has :forum_id
+    has posts(:id), :as => :post_ids
+    has posts.creator(:id), :as => :user_ids
+    
+    where "posts.created_at < NOW()"
+  end
+end

data/lib/thinking_sphinx.rb

@@ -0,0 +1,82 @@
+require 'active_record'
+require 'riddle'
+
+require 'thinking_sphinx/active_record'
+require 'thinking_sphinx/association'
+require 'thinking_sphinx/attribute'
+require 'thinking_sphinx/configuration'
+require 'thinking_sphinx/field'
+require 'thinking_sphinx/index'
+require 'thinking_sphinx/rails_additions'
+require 'thinking_sphinx/search'
+
+ActiveRecord::Base.send(:include, ThinkingSphinx::ActiveRecord)
+
+Merb::Plugins.add_rakefiles(
+  File.join(File.dirname(__FILE__), "..", "tasks", "thinking_sphinx_tasks")
+) if defined?(Merb)
+
+module ThinkingSphinx
+  module Version #:nodoc:
+    Major = 0
+    Minor = 9
+    Tiny  = 7
+    
+    String = [Major, Minor, Tiny].join('.')
+  end
+  
+  # A ConnectionError will get thrown when a connection to Sphinx can't be
+  # made.
+  class ConnectionError < StandardError
+  end
+  
+  # The collection of indexed models. Keep in mind that Rails lazily loads
+  # its classes, so this may not actually be populated with _all_ the models
+  # that have Sphinx indexes.
+  def self.indexed_models
+    @@indexed_models ||= []
+  end
+  
+  # Check if index definition is disabled.
+  # 
+  def self.define_indexes?
+    @@define_indexes =  true unless defined?(@@define_indexes)
+    @@define_indexes == true
+  end
+  
+  # Enable/disable indexes - you may want to do this while migrating data.
+  # 
+  #   ThinkingSphinx.define_indexes = false
+  # 
+  def self.define_indexes=(value)
+    @@define_indexes = value
+  end
+  
+  # Check if delta indexing is enabled.
+  # 
+  def self.deltas_enabled?
+    @@deltas_enabled =  true unless defined?(@@deltas_enabled)
+    @@deltas_enabled == true
+  end
+  
+  # Enable/disable all delta indexing.
+  #
+  #   ThinkingSphinx.deltas_enabled = false
+  #
+  def self.deltas_enabled=(value)
+    @@deltas_enabled = value
+  end
+  
+  # Checks to see if MySQL will allow simplistic GROUP BY statements. If not,
+  # or if not using MySQL, this will return false.
+  # 
+  def self.use_group_by_shortcut?
+    ::ActiveRecord::ConnectionAdapters.constants.include?("MysqlAdapter") &&
+    ::ActiveRecord::Base.connection.is_a?(
+      ::ActiveRecord::ConnectionAdapters::MysqlAdapter
+    ) &&
+    ::ActiveRecord::Base.connection.select_all(
+      "SELECT @@global.sql_mode, @@session.sql_mode;"
+    ).all? { |key,value| value.nil? || value[/ONLY_FULL_GROUP_BY/].nil? }
+  end
+end

data/lib/thinking_sphinx/active_record.rb

@@ -0,0 +1,138 @@
+require 'thinking_sphinx/active_record/delta'
+require 'thinking_sphinx/active_record/search'
+require 'thinking_sphinx/active_record/has_many_association'
+
+module ThinkingSphinx
+  # Core additions to ActiveRecord models - define_index for creating indexes
+  # for models. If you want to interrogate the index objects created for the
+  # model, you can use the class-level accessor :indexes.
+  #
+  module ActiveRecord
+    def self.included(base)
+      base.class_eval do
+        class << self
+          attr_accessor :indexes
+          
+          # 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,
+          # really).
+          #
+          # An example or two:
+          #
+          #   define_index
+          #     indexes :id, :as => :model_id
+          #     indexes name
+          #   end
+          #
+          # You can also grab fields from associations - multiple levels deep
+          # if necessary.
+          #
+          #   define_index do
+          #     indexes tags.name, :as => :tag
+          #     indexes articles.content
+          #     indexes orders.line_items.product.name, :as => :product
+          #   end
+          #
+          # And it will automatically concatenate multiple fields:
+          #
+          #   define_index do
+          #     indexes [author.first_name, author.last_name], :as => :author
+          #   end
+          #
+          # The #indexes method is for fields - if you want attributes, use
+          # #has instead. All the same rules apply - but keep in mind that
+          # attributes are for sorting, grouping and filtering, not searching.
+          #
+          #   define_index do
+          #     # fields ...
+          #     
+          #     has created_at, updated_at
+          #   end
+          #
+          # One last feature is the delta index. This requires the model to
+          # have a boolean field named 'delta', and is enabled as follows:
+          #
+          #   define_index do
+          #     # fields ...
+          #     # attributes ...
+          #     
+          #     set_property :delta => true
+          #   end
+          #
+          # Check out the more detailed documentation for each of these methods
+          # at ThinkingSphinx::Index::Builder.
+          # 
+          def define_index(&block)
+            return unless ThinkingSphinx.define_indexes?
+            
+            @indexes ||= []
+            index = Index.new(self, &block)
+            
+            @indexes << index
+            unless ThinkingSphinx.indexed_models.include?(self.name)
+              ThinkingSphinx.indexed_models << self.name
+            end
+            
+            if index.delta?
+              before_save   :toggle_delta
+              after_commit  :index_delta
+            end
+            
+            after_destroy :toggle_deleted
+            
+            index
+          end
+          alias_method :sphinx_index, :define_index
+          
+          # Generate a unique CRC value for the model's name, to use to
+          # determine which Sphinx documents belong to which AR records.
+          # 
+          # Really only written for internal use - but hey, if it's useful to
+          # 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
+          end
+        end
+      end
+      
+      base.send(:include, ThinkingSphinx::ActiveRecord::Delta)
+      base.send(:include, ThinkingSphinx::ActiveRecord::Search)
+      
+      ::ActiveRecord::Associations::HasManyAssociation.send(
+        :include, ThinkingSphinx::ActiveRecord::HasManyAssociation
+      )
+      ::ActiveRecord::Associations::HasManyThroughAssociation.send(
+        :include, ThinkingSphinx::ActiveRecord::HasManyAssociation
+      )
+    end
+    
+    def in_core_index?
+      @in_core_index ||= self.class.search_for_id(self.id, "#{self.class.name.downcase}_core")
+    end
+    
+    def toggle_deleted
+      config = ThinkingSphinx::Configuration.new
+      client = Riddle::Client.new config.address, config.port
+      
+      client.update(
+        "#{self.class.indexes.first.name}_core",
+        ['sphinx_deleted'],
+        {self.id => 1}
+      ) if self.in_core_index?
+      
+      client.update(
+        "#{self.class.indexes.first.name}_delta",
+        ['sphinx_deleted'],
+        {self.id => 1}
+      ) if self.class.indexes.any? { |index| index.delta? } && self.delta?
+    end
+  end
+end