redis-search 0.9.5 → 0.9.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 60fec212ee4e4748c4133d4e0c4b9aff8ef79f08
-  data.tar.gz: 835d412d57bcea35bd328d5a988667e34d4e79fb
+  metadata.gz: 9f06b8b05df240f527992050fa3174ae7726cb0e
+  data.tar.gz: 1f37d2e08628b4a5fe6a9a5416a88f5c6b1b989d
 SHA512:
-  metadata.gz: 01a0c60c0594feb93a1ede4d305790ba28191d8f2319a1483f5f9ba83264404f11167c429c80e2dbdbd7356a33c1603ced9b345a511795080a32016b03c57055
-  data.tar.gz: ae3a0a94241cdfd30a4448625c7a8efbb698c152c913701caeacf8b21dd26522a542da3b6fa9dbf3955d1dbe85523f0736b157fa384a5a20a9beb77e895dec6b
+  metadata.gz: ec74e499cf300aeab20a0851c2228f0bacbbae75683d4517f44894bb4c331f83c753ae98c112b342762e59457b9adf36b645728dcf495b890d516a52351871fe
+  data.tar.gz: c6ea104e95e3d83ba984a18522925dc881eb37fb021750c5b1476b14c8ae90eab70d07b14fe88c56a3bd3e298f3923a8fb83236b52c0a5033370e382be9bf63a

data/README.md

@@ -8,7 +8,7 @@ High performance real-time search (Support Chinese), index in Redis for Rails ap
 
 ![](http://l.ruby-china.org/photo/34368688ee1c1928c2841eb2f41306ec.png)
 
-You can try the search feature in [`720p.so`](http://720p.so) | [`shu.im`](http://shu.im)
+You can try the search feature in [`IMAX.im`](http://imax.im) | [`shu.im`](http://shu.im)
 
 And there is an  [Example App](https://github.com/huacnlee/redis-search-example) to show you how to use redis-search.
 
@@ -38,7 +38,7 @@ And there is an  [Example App](https://github.com/huacnlee/redis-search-example)
 
     ```ruby
     gem 'ruby-pinyin', '0.3.0'
-    gem 'redis-search', '0.9.0'
+    gem 'redis-search', '0.9.6'
     ```
 
     ```bash
@@ -151,4 +151,4 @@ There is my performance test result.
 
 ## License
 
-* [Apache V2](http://choosealicense.com/licenses/nses/apache)
+* MIT

data/lib/redis-search.rb

@@ -3,4 +3,4 @@ require "redis/search/base"
 require "redis/search/finder"
 require "redis/search/index"
 require "redis/search/config"
-require 'redis/search/railtie' if defined?(Rails)
+require 'redis/search/railtie' if defined?(Rails)

data/lib/redis/search/base.rb

@@ -3,7 +3,7 @@
 class Redis
   module Search
     autoload :PinYin, 'ruby-pinyin'
-        
+
     extend ::ActiveSupport::Concern
 
     module ClassMethods
@@ -15,21 +15,22 @@ class Redis
       #   ext_fields    What kind fields do you need inlucde to search indexes
       #   score_field   Give a score for search sort, need Integer value, default is `created_at`
       def redis_search_index(options = {})
-        title_field = options[:title_field] || :title
-        alias_field = options[:alias_field] || nil
+        title_field         = options[:title_field] || :title
+        alias_field         = options[:alias_field] || nil
         prefix_index_enable = options[:prefix_index_enable] || false
-        ext_fields = options[:ext_fields] || []
-        score_field = options[:score_field] || :created_at
-        condition_fields = options[:condition_fields] || []        
+        ext_fields          = options[:ext_fields] || []
+        score_field         = options[:score_field] || :created_at
+        condition_fields    = options[:condition_fields] || []
+
         # Add score field to ext_fields
         ext_fields |= [score_field]
         # Add condition fields to ext_fields
         ext_fields |= condition_fields
-        
+
         if RUBY_VERSION.start_with?('1.8')
           condition_fields =  "[#{condition_fields.collect { |c| "'#{c}'" }.join(',')}]"
         end
-        
+
         # store Model name to indexed_models for Rake tasks
         Search.indexed_models = [] if Search.indexed_models == nil
         Search.indexed_models << self
@@ -42,9 +43,9 @@ class Redis
             end
             exts
           end
-          
+
           def redis_search_alias_value(field)
-            return [] if field.blank? or field == "_was"
+            return [] if field.blank? || field == "_was"
             val = (instance_eval("self.\#{field}") || "").clone
             return [] if !val.class.in?([String,Array])
             if val.is_a?(String)
@@ -54,10 +55,10 @@ class Redis
           end
 
           def redis_search_index_create
-            s = Search::Index.new(:title => self.#{title_field}, 
-                                  :aliases => self.redis_search_alias_value(#{alias_field.inspect}), 
-                                  :id => self.id, 
-                                  :exts => self.redis_search_fields_to_hash(#{ext_fields.inspect}), 
+            s = Search::Index.new(:title => self.#{title_field},
+                                  :aliases => self.redis_search_alias_value(#{alias_field.inspect}),
+                                  :id => self.id,
+                                  :exts => self.redis_search_fields_to_hash(#{ext_fields.inspect}),
                                   :type => self.class.to_s,
                                   :condition_fields => #{condition_fields},
                                   :score => self.#{score_field}.to_i,
@@ -67,7 +68,7 @@ class Redis
             s = nil
             true
           end
-          
+
           def redis_search_index_delete(titles)
             titles.uniq.each do |title|
               next if title.blank?
@@ -75,24 +76,22 @@ class Redis
             end
             true
           end
-          
 
           before_destroy do
             titles = []
             titles = redis_search_alias_value("#{alias_field}")
             titles << self.#{title_field}
-            
+
             redis_search_index_delete(titles)
             true
           end
-          
-          
+
           def redis_search_index_need_reindex
             index_fields_changed = false
             #{ext_fields.inspect}.each do |f|
               next if f.to_s == "id"
               field_method = f.to_s + "_changed?"
-              if !self.methods.include?(field_method.to_sym)
+              if self.methods.index(field_method.to_sym) == nil
                 Search.warn("#{self.class.name} model reindex on update need "+field_method+" method.")
                 next
               end
@@ -111,7 +110,7 @@ class Redis
             end
             return index_fields_changed
           end
-          
+
           after_update do
             if self.redis_search_index_need_reindex
               titles = []
@@ -124,7 +123,7 @@ class Redis
 
           after_save :redis_search_index_update
           def redis_search_index_update
-            if self.redis_search_index_need_reindex or self.new_record?
+            if self.redis_search_index_need_reindex || self.new_record?
               self.redis_search_index_create
             end
             true

data/lib/redis/search/config.rb

@@ -3,20 +3,20 @@ class Redis
   module Search
     class << self
       attr_accessor :config, :indexed_models
-    
+
       def configure
-        yield self.config ||= Config.new
-        
-        if not self.config.disable_rmmseg
+        yield @config ||= Config.new
+
+        if not @config.disable_rmmseg
           require "rmmseg"
           # loading RMMSeg chinese word dicts.
           RMMSeg::Dictionary.load_dictionaries
         end
       end
     end
-  
+
     class Config
-      # Redis 
+      # Redis
       attr_accessor :redis
       # Debug toggle, default false
       attr_accessor :debug
@@ -32,14 +32,14 @@ class Redis
       attr_accessor :pinyin_match
       # Disable RMMSeg, if you don't need, disable this will save memory. (true|false) default = true
       attr_accessor :disable_rmmseg
-    
+
       def initialize
-        self.debug = false
-        self.redis = nil
-        self.complete_max_length = 100
-        self.pinyin_match = false
-        self.disable_rmmseg = false        
+        @debug               = false
+        @redis               = nil
+        @complete_max_length = 100
+        @pinyin_match        = false
+        @disable_rmmseg      = false
       end
     end
   end
-end
+end

data/lib/redis/search/finder.rb

@@ -1,248 +1,249 @@
 # coding: utf-8
 class Redis
-  module Search    
-    # use rmmseg to split words
-    def self.split(text)
-      _split(text)
-    end    
-
-    # Use for short title search, this method is search by chars, for example Tag, User, Category ...
-    # 
-    # h3. params:
-    #   type      model name
-    #   w         search char
-    #   :limit    result limit
-    # h3. usage:
-    # * Redis::Search.complete("Tag","r") => ["Ruby","Rails", "REST", "Redis", "Redmine"]
-    # * Redis::Search.complete("Tag","re") => ["Redis", "Redmine"]
-    # * Redis::Search.complete("Tag","red") => ["Redis", "Redmine"]
-    # * Redis::Search.complete("Tag","redi") => ["Redis"]
-    def self.complete(type, w, options = {})
-      limit = options[:limit] || 10 
-      conditions = options[:conditions] || []
-      return [] if (w.blank? and conditions.blank?) or type.blank?
-      
-      prefix_matchs = []
-      # This is not random, try to get replies < MTU size
-      rangelen = Redis::Search.config.complete_max_length
-      prefix = w.downcase
-      key = Search.mk_complete_key(type)
-      
-      
-      if start = Redis::Search.config.redis.zrank(key,prefix)
-        count = limit
-        max_range = start+(rangelen*limit)-1
-        range = Redis::Search.config.redis.zrange(key,start,max_range)
-        while prefix_matchs.length <= count
-          start += rangelen
-          break if !range or range.length == 0
-          range.each {|entry|
-            minlen = [entry.length,prefix.length].min
-            if entry[0...minlen] != prefix[0...minlen]
-              count = prefix_matchs.count
-              break
-            end
-            if entry[-1..-1] == "*" and prefix_matchs.length != count
-              prefix_matchs << entry[0...-1]
+  module Search
+    class << self
+      # use rmmseg to split words
+      def split(text)
+        _split(text)
+      end
+
+      # Use for short title search, this method is search by chars, for example Tag, User, Category ...
+      #
+      # h3. params:
+      #   type      model name
+      #   w         search char
+      #   :limit    result limit
+      # h3. usage:
+      # * Redis::Search.complete("Tag","r") => ["Ruby","Rails", "REST", "Redis", "Redmine"]
+      # * Redis::Search.complete("Tag","re") => ["Redis", "Redmine"]
+      # * Redis::Search.complete("Tag","red") => ["Redis", "Redmine"]
+      # * Redis::Search.complete("Tag","redi") => ["Redis"]
+      def complete(type, w, options = {})
+        limit = options[:limit] || 10
+        conditions = options[:conditions] || []
+        return [] if (w.blank? && conditions.blank?) || type.blank?
+
+        prefix_matchs = []
+        # This is not random, try to get replies < MTU size
+        rangelen = self.config.complete_max_length
+        prefix = w.downcase
+        key = self.mk_complete_key(type)
+
+        if start = self.config.redis.zrank(key,prefix)
+          count = limit
+          max_range = start + (rangelen * limit) - 1
+          range = self.config.redis.zrange(key,start,max_range)
+          while prefix_matchs.length <= count
+            start += rangelen
+            break if !range || range.length == 0
+            range.each do |entry|
+              minlen = [entry.length,prefix.length].min
+              if entry[0...minlen] != prefix[0...minlen]
+                count = prefix_matchs.count
+                break
+              end
+              if entry[-1..-1] == "*" && prefix_matchs.length != count
+                prefix_matchs << entry[0...-1]
+              end
             end
-          }
-          range = range[start..max_range]
+
+            range = range[start..max_range]
+          end
         end
-      end
-      
-      # 组合 words 的特别 key 名
-      words = []
-      words = prefix_matchs.uniq.collect { |w| Search.mk_sets_key(type,w) }
-      
-      # 组合特别 key ,但这里不会像 query 那样放入 words， 因为在 complete 里面 words 是用 union 取的，condition_keys 和 words 应该取交集
-      condition_keys = []
-      if !conditions.blank?
-        conditions = conditions[0] if conditions.is_a?(Array)
-        conditions.keys.each do |c|
-          condition_keys << Search.mk_condition_key(type,c,conditions[c])
+        prefix_matchs.uniq!
+
+        # 组合 words 的特别 key 名
+        words = prefix_matchs.collect { |w| self.mk_sets_key(type,w) }
+
+        # 组合特别 key ,但这里不会像 query 那样放入 words， 因为在 complete 里面 words 是用 union 取的，condition_keys 和 words 应该取交集
+        condition_keys = []
+        if !conditions.blank?
+          conditions = conditions[0] if conditions.is_a?(Array)
+          conditions.keys.each do |c|
+            condition_keys << self.mk_condition_key(type,c,conditions[c])
+          end
         end
-      end
-      
-      # 按词语搜索
-      temp_store_key = "tmpsunionstore:#{words.join("+")}"
-      if words.length > 1
-        if !Redis::Search.config.redis.exists(temp_store_key)
-          # 将多个词语组合对比，得到并集，并存入临时区域   
-          Redis::Search.config.redis.sunionstore(temp_store_key,*words)
-          # 将临时搜索设为1天后自动清除
-          Redis::Search.config.redis.expire(temp_store_key,86400)
+
+        # 按词语搜索
+        temp_store_key = "tmpsunionstore:#{words.join("+")}"
+        if words.length > 1
+          if !self.config.redis.exists(temp_store_key)
+            # 将多个词语组合对比，得到并集，并存入临时区域
+            self.config.redis.sunionstore(temp_store_key,*words)
+            # 将临时搜索设为1天后自动清除
+            self.config.redis.expire(temp_store_key,86400)
+          end
+          # 根据需要的数量取出 ids
+        else
+          temp_store_key = words.first
         end
-        # 根据需要的数量取出 ids
-      else
-        temp_store_key = words.first
-      end
-      
-      # 如果有条件，这里再次组合一下
-      if !condition_keys.blank?
-        condition_keys << temp_store_key if !words. blank?
-        temp_store_key = "tmpsinterstore:#{condition_keys.join('+')}"
-        if !Redis::Search.config.redis.exists(temp_store_key)
-          Redis::Search.config.redis.sinterstore(temp_store_key,*condition_keys)
-          Redis::Search.config.redis.expire(temp_store_key,86400)
+
+        # 如果有条件，这里再次组合一下
+        if !condition_keys.blank?
+          condition_keys << temp_store_key if !words.blank?
+          temp_store_key = "tmpsinterstore:#{condition_keys.join('+')}"
+          if !self.config.redis.exists(temp_store_key)
+            self.config.redis.sinterstore(temp_store_key,*condition_keys)
+            self.config.redis.expire(temp_store_key,86400)
+          end
         end
+
+        ids = self.config.redis.sort(temp_store_key,
+                                    :limit => [0,limit],
+                                    :by => self.mk_score_key(type,"*"),
+                                    :order => "desc")
+        return [] if ids.blank?
+        self.hmget(type,ids)
       end
-      
-      ids = Redis::Search.config.redis.sort(temp_store_key,
-                                            :limit => [0,limit], 
-                                            :by => Search.mk_score_key(type,"*"),
-                                            :order => "desc")
-      return [] if ids.blank?
-      hmget(type,ids)
-    end
 
-    # Search items, this will split words by Libmmseg
-    # 
-    # h3. params:
-    #   type      model name
-    #   text         search text
-    #   :limit    result limit
-    # h3. usage:
-    # * Redis::Search.query("Tag","Ruby vs Python")
-    def self.query(type, text,options = {})
-      tm = Time.now
-      result = []
-      
-      limit = options[:limit] || 10
-      sort_field = options[:sort_field] || "id"
-      conditions = options[:conditions] || []
-      
-      # 如果搜索文本和查询条件均没有，那就直接返回 []
-      return result if text.strip.blank? and conditions.blank?
-
-      words = Search.split(text)
-      words = words.collect { |w| Search.mk_sets_key(type,w) }
-      
-      
-      condition_keys = []
-      if !conditions.blank?
-        conditions = conditions[0] if conditions.is_a?(Array)
-        conditions.keys.each do |c|
-          condition_keys << Search.mk_condition_key(type,c,conditions[c])
+      # Search items, this will split words by Libmmseg
+      #
+      # h3. params:
+      #   type      model name
+      #   text         search text
+      #   :limit    result limit
+      # h3. usage:
+      # * Redis::Search.query("Tag","Ruby vs Python")
+      def query(type, text, options = {})
+        tm = Time.now
+        result = []
+
+        limit = options[:limit] || 10
+        sort_field = options[:sort_field] || "id"
+        conditions = options[:conditions] || []
+
+        # 如果搜索文本和查询条件均没有，那就直接返回 []
+        return result if text.strip.blank? && conditions.blank?
+
+        words = self.split(text)
+        words = words.collect { |w| self.mk_sets_key(type,w) }
+
+        condition_keys = []
+        if !conditions.blank?
+          conditions = conditions[0] if conditions.is_a?(Array)
+          conditions.keys.each do |c|
+            condition_keys << self.mk_condition_key(type,c,conditions[c])
+          end
+          # 将条件的 key 放入关键词搜索集合内，用于 sinterstore 搜索
+          words += condition_keys
         end
-        # 将条件的 key 放入关键词搜索集合内，用于 sinterstore 搜索
-        words += condition_keys
-      end
-      
-      return result if words.blank?
-      
-      temp_store_key = "tmpinterstore:#{words.join("+")}"
-      
-      if words.length > 1
-        if !Redis::Search.config.redis.exists(temp_store_key)
-          # 将多个词语组合对比，得到交集，并存入临时区域
-          Redis::Search.config.redis.sinterstore(temp_store_key,*words)
-          # 将临时搜索设为1天后自动清除
-          Redis::Search.config.redis.expire(temp_store_key,86400)
-          
-          # 拼音搜索
-          if Search.config.pinyin_match
-            pinyin_words = Search.split_pinyin(text)
-            pinyin_words = pinyin_words.collect { |w| Search.mk_sets_key(type,w) }
-            pinyin_words += condition_keys
-            temp_sunion_key = "tmpsunionstore:#{words.join("+")}"
-            if Search.config.pinyin_match
-              temp_pinyin_store_key = "tmpinterstore:#{pinyin_words.join("+")}"
+
+        return result if words.blank?
+
+        temp_store_key = "tmpinterstore:#{words.join("+")}"
+
+        if words.length > 1
+          if !self.config.redis.exists(temp_store_key)
+            self.config.redis.pipelined do
+              # 将多个词语组合对比，得到交集，并存入临时区域
+              self.config.redis.sinterstore(temp_store_key,*words)
+              # 将临时搜索设为1天后自动清除
+              self.config.redis.expire(temp_store_key,86400)
+
+              # 拼音搜索
+              if self.config.pinyin_match
+                pinyin_words = self.split_pinyin(text)
+                pinyin_words = pinyin_words.collect { |w| self.mk_sets_key(type,w) }
+                pinyin_words += condition_keys
+                temp_sunion_key = "tmpsunionstore:#{words.join("+")}"
+                temp_pinyin_store_key = "tmpinterstore:#{pinyin_words.join("+")}"
+                # 找出拼音的
+                self.config.redis.sinterstore(temp_pinyin_store_key,*pinyin_words)
+                # 合并中文和拼音的搜索结果
+                self.config.redis.sunionstore(temp_sunion_key,*[temp_store_key,temp_pinyin_store_key])
+                # 将临时搜索设为1天后自动清除
+                self.config.redis.expire(temp_pinyin_store_key,86400)
+                self.config.redis.expire(temp_sunion_key,86400)
+              end
+              temp_store_key = temp_sunion_key
             end
-            # 找出拼音的
-            Redis::Search.config.redis.sinterstore(temp_pinyin_store_key,*pinyin_words)
-            # 合并中文和拼音的搜索结果
-            Redis::Search.config.redis.sunionstore(temp_sunion_key,*[temp_store_key,temp_pinyin_store_key])
-            # 将临时搜索设为1天后自动清除
-            Redis::Search.config.redis.expire(temp_pinyin_store_key,86400)
-            Redis::Search.config.redis.expire(temp_sunion_key,86400)
-            temp_store_key = temp_sunion_key
           end
+        else
+          temp_store_key = words.first
         end
-      else
-        temp_store_key = words.first
+
+        # 根据需要的数量取出 ids
+        ids = self.config.redis.sort(temp_store_key,
+                                    :limit => [0,limit],
+                                    :by => self.mk_score_key(type,"*"),
+                                    :order => "desc")
+        result = self.hmget(type,ids, :sort_field => sort_field)
+        self.info("{#{type} : \"#{text}\"} | Time spend: #{Time.now - tm}s")
+        result
       end
-      
-      # 根据需要的数量取出 ids
-      ids = Search.config.redis.sort(temp_store_key,
-                                            :limit => [0,limit], 
-                                            :by => Search.mk_score_key(type,"*"),
-                                            :order => "desc")
-      result = hmget(type,ids, :sort_field => sort_field)
-      Search.info("{#{type} : \"#{text}\"} | Time spend: #{Time.now - tm}s")
-      result 
-    end
-  
+    end # end class << self
+
     protected
-      def self.split_pinyin(text)
-        # Pinyin search split as pinyin again
-        _split(PinYin.sentence(text))
-      end
-  
+    def self.split_pinyin(text)
+      # Pinyin search split as pinyin again
+      _split(PinYin.sentence(text))
+    end
+
     private
-      def self._split(text)
-        return [] if text.blank?
-        # return chars if disabled rmmseg
-        return text.split("") if Search.config.disable_rmmseg
-          
-        algor = RMMSeg::Algorithm.new(text)
-        words = []
-        loop do
-          tok = algor.next_token
-          break if tok.nil?
-          words << tok.text
-        end
-        words
-      end
-    
-      def self.warn(msg)
-        return if not Redis::Search.config.debug
-        msg = "\e[33m[Redis::Search] #{msg}\e[0m"
-        if defined?(Rails) == 'constant' && Rails.class == Class
-          ::Rails.logger.warn(msg)
-        else
-          puts msg
-        end
-      end
-      
-      def self.info(msg)
-        return if not Redis::Search.config.debug
-        msg = "\e[32m[Redis::Search] #{msg}\e[0m"
-        if defined?(Rails) == 'constant' && Rails.class == Class
-          ::Rails.logger.debug(msg)
-        else
-          puts msg
-        end
-      end
-  
-      # 生成 uuid，用于作为 hashes 的 field, sets 关键词的值
-      def self.mk_sets_key(type, key)
-        "#{type}:#{key.downcase}"
-      end
-    
-      def self.mk_score_key(type, id)
-        "#{type}:_score_:#{id}"
+    def self._split(text)
+      return [] if text.blank?
+      # return chars if disabled rmmseg
+      return text.split("") if Search.config.disable_rmmseg
+
+      algor = RMMSeg::Algorithm.new(text)
+      words = []
+      loop do
+        tok = algor.next_token
+        break if tok.nil?
+        words << tok.text
       end
-      
-      def self.mk_condition_key(type, field, id)
-        "#{type}:_by:_#{field}:#{id}"
+      words
+    end
+
+    def self.warn(msg)
+      return if not Redis::Search.config.debug
+      msg = "\e[33m[Redis::Search] #{msg}\e[0m"
+      if defined?(Rails) == 'constant' && Rails.class == Class
+        ::Rails.logger.warn(msg)
+      else
+        puts msg
       end
-  
-      def self.mk_complete_key(type)
-        "Compl#{type}"
+    end
+
+    def self.info(msg)
+      return if not Redis::Search.config.debug
+      msg = "\e[32m[Redis::Search] #{msg}\e[0m"
+      if defined?(Rails) == 'constant' && Rails.class == Class
+        ::Rails.logger.debug(msg)
+      else
+        puts msg
       end
-      
-      def self.hmget(type, ids, options = {})
-        result = []
-        sort_field = options[:sort_field] || "id"
-        return result if ids.blank?
-        Redis::Search.config.redis.hmget(type,*ids).each do |r|
-          begin
-            result << JSON.parse(r) if !r.blank?
-          rescue => e
-            Search.warn("Search.query failed: #{e}")
-          end
+    end
+
+    # 生成 uuid，用于作为 hashes 的 field, sets 关键词的值
+    def self.mk_sets_key(type, key)
+      "#{type}:#{key.downcase}"
+    end
+
+    def self.mk_score_key(type, id)
+      "#{type}:_score_:#{id}"
+    end
+
+    def self.mk_condition_key(type, field, id)
+      "#{type}:_by:_#{field}:#{id}"
+    end
+
+    def self.mk_complete_key(type)
+      "Compl#{type}"
+    end
+
+    def self.hmget(type, ids, options = {})
+      result = []
+      sort_field = options[:sort_field] || "id"
+      return result if ids.blank?
+      self.config.redis.hmget(type,*ids).each do |r|
+        begin
+          result << JSON.parse(r) if !r.blank?
+        rescue => e
+          self.warn("Search.query failed: #{e}")
         end
-        result
       end
-  end
+      result
+    end
+  end # end Search
 end

data/lib/redis/search/index.rb

@@ -1,109 +1,143 @@
 class Redis
   module Search
     class Index
-      attr_accessor :type, :title, :id,:score, :aliases, :exts, :condition_fields, :prefix_index_enable
+      attr_accessor :type, :title, :id, :score, :aliases, :exts, :condition_fields, :prefix_index_enable
+
+      class << self
+        def redis
+          Redis::Search.config.redis
+        end
+
+        def remove(options = {})
+          type = options[:type]
+
+          self.redis.pipelined do
+            self.redis.hdel(type,options[:id])
+            self.redis.del(Search.mk_score_key(type,options[:id]))
+
+            words = self.split_words_for_index(options[:title])
+            words.each do |word|
+              self.redis.srem(Search.mk_sets_key(type,word), options[:id])
+            end
+
+            # remove set for prefix index key
+            self.redis.srem(Search.mk_sets_key(type,options[:title]),options[:id])
+          end
+        end
+
+        def split_words_for_index(title)
+          words = Search.split(title)
+          if Search.config.pinyin_match
+            # covert Chinese to pinyin to as an index
+            pinyin_full = Search.split_pinyin(title)
+            pinyin_first = pinyin_full.collect { |p| p[0] }.join("")
+            words += pinyin_full
+            words << pinyin_first
+            pinyin_full = nil
+            pinyin_first = nil
+          end
+          words.uniq
+        end
+
+        def bm
+          t1 = Time.now
+          yield
+          t2 = Time.now
+          puts "spend (#{t2 - t1}s)"
+        end
+      end # end class << self
+
+      def redis
+        self.class.redis
+      end
+
       def initialize(options = {})
         # default data
-        self.condition_fields = []
-        self.exts = []
-        self.aliases = []
-        self.prefix_index_enable = false
+        @condition_fields    = []
+        @exts                = []
+        @aliases             = []
+        @prefix_index_enable = false
 
         # set attributes value from params
         options.keys.each do |k|
-          eval("self.#{k} = options[k]")
+          self.send("#{k}=", options[k])
         end
-        self.aliases << self.title
-        self.aliases.uniq!
+        @aliases << self.title
+        @aliases.uniq!
       end
 
       def save
-        return if self.title.blank?
-        data = {:title => self.title, :id => self.id, :type => self.type}
-        self.exts.each do |f|
-          data[f[0]] = f[1]
-        end
-
-        # 将原始数据存入 hashes
-        res = Redis::Search.config.redis.hset(self.type, self.id, data.to_json)
+        return if @title.blank?
 
-        # 将目前的编号保存到条件(conditions)字段所创立的索引上面
-        self.condition_fields.each do |field|
-          Redis::Search.config.redis.sadd(Search.mk_condition_key(self.type,field,data[field.to_sym]), self.id)
-        end
+        self.redis.pipelined do
+          data = {:title => @title, :id => @id, :type => @type}
+          self.exts.each do |f|
+            data[f[0]] = f[1]
+          end
 
-        # score for search sort
-        Redis::Search.config.redis.set(Search.mk_score_key(self.type,self.id),self.score)
+          # 将原始数据存入 hashes
+          res = self.redis.hset(@type, @id, data.to_json)
 
-        # 保存 sets 索引，以分词的单词为key，用于后面搜索，里面存储 ids
-        self.aliases.each do |val|
-          words = Search::Index.split_words_for_index(val)
-          return if words.blank?
-          words.each do |word|
-            Redis::Search.config.redis.sadd(Search.mk_sets_key(self.type,word), self.id)
+          # 将目前的编号保存到条件(conditions)字段所创立的索引上面
+          self.condition_fields.each do |field|
+            self.redis.sadd(Search.mk_condition_key(@type,field,data[field.to_sym]), @id)
           end
-        end
 
-        # 建立前缀索引
-        save_prefix_index if prefix_index_enable
-      end
+          # score for search sort
+          self.redis.set(Search.mk_score_key(@type,@id),@score)
 
-      def self.remove(options = {})
-        type = options[:type]
-        Redis::Search.config.redis.hdel(type,options[:id])
-        Redis::Search.config.redis.del(Search.mk_score_key(type,options[:id]))
+          # 保存 sets 索引，以分词的单词为key，用于后面搜索，里面存储 ids
+          self.aliases.each do |val|
+            words = Search::Index.split_words_for_index(val)
+            next if words.blank?
+            words.each do |word|
+              self.redis.sadd(Search.mk_sets_key(@type,word), @id)
+            end
+          end
 
-        words = Search::Index.split_words_for_index(options[:title])
-        words.each do |word|
-          Redis::Search.config.redis.srem(Search.mk_sets_key(type,word), options[:id])
+          # 建立前缀索引
+          save_prefix_index if prefix_index_enable
         end
-
-        # remove set for prefix index key
-        Redis::Search.config.redis.srem(Search.mk_sets_key(type,options[:title]),options[:id])
       end
 
       private
-        def self.split_words_for_index(title)
-          words = Search.split(title)
+      def save_prefix_index
+        sorted_set_key = Search.mk_complete_key(@type)
+        sorted_vals = []
+
+        self.aliases.each do |val|
+          words = []
+          words << val.downcase
+
+          self.redis.sadd(Search.mk_sets_key(@type,val), @id)
+
           if Search.config.pinyin_match
-            # covert Chinese to pinyin to as an index
-            pinyin_full = Search.split_pinyin(title)
+            pinyin_full = Search.split_pinyin(val.downcase)
             pinyin_first = pinyin_full.collect { |p| p[0] }.join("")
-            words += pinyin_full
+            pinyin = pinyin_full.join("")
+
+            words << pinyin
             words << pinyin_first
+
+            self.redis.sadd(Search.mk_sets_key(@type,pinyin), @id)
+
             pinyin_full = nil
             pinyin_first = nil
+            pinyin = nil
           end
-          words.uniq
-        end
 
-        def save_prefix_index
-          self.aliases.each do |val|
-            words = []
-            words << val.downcase
-            Redis::Search.config.redis.sadd(Search.mk_sets_key(self.type,val), self.id)
-            if Search.config.pinyin_match
-              pinyin_full = Search.split_pinyin(val.downcase)
-              pinyin_first = pinyin_full.collect { |p| p[0] }.join("")
-              pinyin = pinyin_full.join("")
-              words << pinyin
-              words << pinyin_first
-              Redis::Search.config.redis.sadd(Search.mk_sets_key(self.type,pinyin), self.id)
-              pinyin_full = nil
-              pinyin_first = nil
-              pinyin = nil
-            end
-
-            words.each do |word|
-              key = Search.mk_complete_key(self.type)
-              (1..(word.length)).each do |l|
-                prefix = word[0...l]
-                Redis::Search.config.redis.zadd(key, 0, prefix)
-              end
-              Redis::Search.config.redis.zadd(key, 0, word + "*")
+          words.each do |word|
+            (1..(word.length)).each do |l|
+              prefix = word[0...l]
+              sorted_vals << [0, prefix]
             end
+            sorted_vals << [0, "#{word}*"]
           end
         end
-    end
+
+        self.redis.zadd(sorted_set_key, sorted_vals)
+      end
+
+    end # end Index
   end
 end

data/lib/redis/search/tasks.rb

@@ -21,11 +21,13 @@ namespace :redis_search do
           end
         end
       elsif klass.included_modules.collect { |m| m.to_s }.include?("Mongoid::Document")
-        klass.all.each do |item|
-          item.redis_search_index_create
-    			item = nil
-    			count += 1
-          print "."
+        klass.all.each_slice(1000) do |items|
+          items.each do |item|
+            item.redis_search_index_create
+      			item = nil
+      			count += 1
+            print "."
+          end
         end
       else
         puts "skiped, not support this ORM in current."
@@ -37,4 +39,4 @@ namespace :redis_search do
     puts "Indexed #{count} rows  |  Time spend: #{(Time.now - tm)}s".rjust(120)
     puts "Rebuild Index done.".rjust(120)
   end
-end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: redis-search
 version: !ruby/object:Gem::Version
-  version: 0.9.5
+  version: 0.9.6
 platform: ruby
 authors:
 - Jason Lee
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-02-17 00:00:00.000000000 Z
+date: 2014-04-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ruby-pinyin
@@ -36,30 +36,30 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.0.2
+        version: 1.3.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.0.2
+        version: 1.3.0
 - !ruby/object:Gem::Dependency
   name: redis
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 2.1.1
+        version: 3.0.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 2.1.1
-description: 'High performance real-time search (Support Chinese), index in Redis
-  for Rails application. '
+        version: 3.0.0
+description: 'High performance real-time search (Support Chinese), indexes store in
+  Redis for Rails applications. '
 email:
 - huacnlee@gmail.com
 executables: []
@@ -95,9 +95,10 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: 1.3.6
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.0.rc.1
+rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
-summary: High performance real-time search (Support Chinese), index in Redis for Rails
-  application.
+summary: High performance real-time search (Support Chinese), indexes store in Redis
+  for Rails applications.
 test_files: []
+has_rdoc: