relix 1.1.1 → 1.2.0

data/HISTORY.md

@@ -1,3 +1,11 @@
+### 1.2.0
+
+* Improved keyer inheritance, including better legacy
+  support. (ntalbott)
+* Improved memory efficiency by not storing unnecessary
+  data. (myronmarston)
+* Added Ordered Indexes for easy range queries. (myronmarston)
+
 ### 1.1.1
 
 * Added keyers to the manifest file. (ntalbott)

data/README.md

@@ -143,6 +143,17 @@ When there are multiple attributes, they are specified in a hash:
     end
 
 
+### Space efficiency
+
+Model attributes that are indexed on but that never change can be marked as immutable to prevent them being stored (since they don't have to be reindexed). The primary key is marked immutable by default, but other attributes can be as well:
+
+    relix do
+      unique :token, immutable_attribute: true
+    end
+
+This can also provide concurrency benefits since the keys for the indexes on immutable attributes don't have to be watched for concurrent modification.
+
+
 ## Index Types
 
 ### PrimaryKeyIndex
@@ -182,6 +193,30 @@ Unique indexes ignore nil values - they will not be indexed and an error is not
 **Supported Operators**: eq, all  
 **Ordering**: can be ordered on any numeric attribute (default is the to_i of the indexed value)
 
+### OrderedIndex
+
+Ordered indexes are specifically designed to support range queries. Like a MultiIndex, they support multiple matching
+primary keys per indexed value. They are declared using #ordered in the relix block:
+
+    relix do
+      ordered :birthdate
+    end
+
+**Supported Operators**: eq, lt, lte, gt, gte, order, limit, offset  
+**Ordering**: ordered ascending by the indexed value, but can be queried in
+  reverse order if you use `order(:desc)`.
+
+Ordered indexes support a flexible fluent interface for specifying the query:
+
+    Person.lookup do |q|
+      q[:birthdate].
+        gte(Date.new(1990, 1, 1)).
+        lt(Date.new(1991, 1, 1).
+        order(:desc).
+        limit(10)
+    end
+
+This query returns the primary keys of the 10 youngest people born in 1990.
 
 ## Keying
 
@@ -195,6 +230,8 @@ You can set the default keyer like so:
 
     Relix.default_keyer(Relix::Keyer::Compact)
 
+Keyers are inherited, with child classes will use their parent's keyer unless a keyer is explicitly set on the child.
+
 
 ### Standard
 
@@ -208,4 +245,4 @@ Keys take up space, and especially since Redis holds the keyset in memory it can
 
 ### Legacy
 
-This (eventually to be deprecated and removed) strategy exactly mirrors the keying supported by Relix when first released.
+This (eventually to be deprecated and removed) strategy exactly mirrors the keying supported by Relix when first released.

data/lib/relix.rb

@@ -7,3 +7,4 @@ require 'relix/index'
 require 'relix/indexes/multi'
 require 'relix/indexes/unique'
 require 'relix/indexes/primary_key'
+require 'relix/indexes/ordered'

data/lib/relix/index.rb

@@ -8,10 +8,13 @@ module Relix
       @compact_kind ||= kind[0..0]
     end
 
+    attr_reader :model_name
     def initialize(set, base_name, accessor, options={})
       @set = set
       @base_name = base_name
+      @model_name = @set.klass.name
       @accessor = [accessor].flatten.collect{|a| a.to_s}
+      @attribute_immutable = !!options[:immutable_attribute]
       @options = options
     end
 
@@ -43,7 +46,11 @@ module Relix
       end.join(":")
     end
 
-    def watch
+    def watch(*values)
+      watch_keys(*values) unless attribute_immutable?
+    end
+
+    def watch_keys(*values)
       nil
     end
 
@@ -55,6 +62,14 @@ module Relix
       nil
     end
 
+    def create_query_clause(redis)
+      Query::Clause.new(redis, self)
+    end
+
+    def attribute_immutable?
+      @attribute_immutable
+    end
+
     module Ordering
       def initialize(*args)
         super
@@ -65,6 +80,11 @@ module Relix
         if @order
           value = object.send(@order)
         end
+
+        score_for_value(value)
+      end
+
+      def score_for_value(value)
         case value
         when Numeric
           value
@@ -96,4 +116,4 @@ module Relix
 
   class UnorderableValueError < Relix::Error; end
   class MissingIndexValueError < Relix::Error; end
-end
+end

data/lib/relix/index_set.rb

@@ -1,11 +1,12 @@
 module Relix
   class IndexSet
     attr_accessor :redis
+    attr_reader :klass
     def initialize(klass, redis)
       @klass = klass
       @redis = redis
       @indexes = Hash.new
-      @keyer = Keyer.default_for(@klass)
+      @keyer = Keyer.default_for(@klass) unless parent
     end
 
     def primary_key(accessor)
@@ -28,7 +29,7 @@ module Relix
       if value
         @keyer = value.new(@klass, options)
       else
-        @keyer
+        (@keyer || parent.keyer)
       end
     end
 
@@ -65,13 +66,13 @@ module Relix
       current_values = @redis.hgetall(current_values_name)
 
       ops = indexes.collect do |name,index|
-        ((watch = index.watch) && @redis.watch(*watch))
-
         value = index.read_normalized(object)
         old_value = current_values[name]
 
+        ((watch = index.watch(value, old_value)) && @redis.watch(*watch))
+
         next if value == old_value
-        current_values[name] = value
+        current_values[name] = value unless index.attribute_immutable?
 
         next unless index.filter(@redis, object, value)
 
@@ -83,7 +84,7 @@ module Relix
 
       ops << proc do
         @redis.hmset(current_values_name, *current_values.flatten)
-      end
+      end if current_values.any?
 
       ops
     end
@@ -105,8 +106,8 @@ module Relix
         current_values = @redis.hgetall(current_values_name)
 
         indexes.map do |name, index|
-          ((watch = index.watch) && @redis.watch(*watch))
           old_value = current_values[name]
+          ((watch = index.watch(old_value)) && @redis.watch(*watch))
           proc { index.deindex(@redis, pk, object, old_value) }
         end.tap { |ops| ops << proc { @redis.del current_values_name } }
       end
@@ -125,7 +126,7 @@ module Relix
     end
 
     def current_values_name(pk)
-      @keyer.values(pk)
+      keyer.values(pk, @klass)
     end
 
   private

data/lib/relix/indexes/multi.rb

@@ -2,6 +2,10 @@ module Relix
   class MultiIndex < Index
     include Ordering
 
+    def watch_keys(*values)
+      values.compact.map { |v| key_for(v) }
+    end
+
     def index(r, pk, object, value, old_value)
       r.zadd(key_for(value), score(object, value), pk)
       r.zrem(key_for(old_value), pk)

data/lib/relix/indexes/ordered.rb

@@ -0,0 +1,101 @@
+module Relix
+  class OrderedIndex < Index
+    include Ordering
+
+    def initialize(set, base_name, accessor, options={})
+      super
+      @order = accessor
+    end
+
+    def sorted_set_name
+      name
+    end
+
+    def watch_keys(*values)
+      sorted_set_name
+    end
+
+    def index(r, pk, object, value, old_value)
+      r.zadd(sorted_set_name, score(object, value), pk)
+    end
+
+    def deindex(r, pk, object, old_value)
+      r.zrem(sorted_set_name, pk)
+    end
+
+    def create_query_clause(redis)
+      QueryClause.new(redis, self)
+    end
+
+    class QueryClause
+      def initialize(redis, index)
+        @redis, @index = redis, index
+        @lt, @gt, @limit, @offset, @order = '+inf', '-inf', nil, nil, :asc
+      end
+
+      def lt(value)
+        @lt = "(#{@index.score_for_value(value)}"
+        self
+      end
+
+      def lte(value)
+        @lt = @index.score_for_value(value)
+        self
+      end
+
+      def gt(value)
+        @gt = "(#{@index.score_for_value(value)}"
+        self
+      end
+
+      def gte(value)
+        @gt = @index.score_for_value(value)
+        self
+      end
+
+      def eq(value)
+        lte(value)
+        gte(value)
+      end
+
+      def order(value)
+        unless [:asc, :desc].include?(value)
+          raise InvalidQueryOption.new("order must be :asc or :desc but was #{value.inspect}")
+        end
+
+        @order = value
+        self
+      end
+
+      def limit(value)
+        @limit = value
+        self
+      end
+
+      def offset(value)
+        @offset = value
+        self
+      end
+
+      def zrangebyscore_limit
+        # zrangebyscore uses offset/count rather than start/stop like zrange
+        offset, stop = @index.range_from_options(@redis, offset: @offset, limit: @limit)
+        count = stop == -1 ? -1 : (stop - offset + 1)
+        [offset, count]
+      end
+
+      def lookup
+        command, score_1, score_2 = case @order
+          when :desc then [:zrevrangebyscore, @lt, @gt]
+          when :asc  then [:zrangebyscore,    @gt, @lt]
+        end
+
+        @redis.send(command, @index.sorted_set_name, score_1, score_2, limit: zrangebyscore_limit)
+      end
+    end
+  end
+
+  register_index OrderedIndex
+  class InvalidQueryOption < Relix::Error; end
+end
+

data/lib/relix/indexes/primary_key.rb

@@ -2,12 +2,17 @@ module Relix
   class PrimaryKeyIndex < Index
     include Ordering
 
-    def watch
+    def initialize(set, base_name, accessor, options={})
+      options[:immutable_attribute] = true unless options.has_key?(:immutable_attribute)
+      super
+    end
+
+    def watch_keys(*values)
       name
     end
 
     def filter(r, object, value)
-      !r.zrank(name, value)
+      !r.zscore(name, value)
     end
 
     def query(r, value)
@@ -31,4 +36,4 @@ module Relix
     end
   end
   register_index PrimaryKeyIndex
-end
+end

data/lib/relix/indexes/unique.rb

@@ -10,7 +10,7 @@ module Relix
       @set.keyer.component(name, 'lookup')
     end
 
-    def watch
+    def watch_keys(*values)
       hash_name
     end
 

data/lib/relix/keyer.rb

@@ -18,16 +18,16 @@ module Relix
         @prefix = klass.name
       end
 
-      def values(pk)
-        "#{@prefix}:current_values:#{pk}"
+      def values(pk, klass)
+        "#{klass.name}:current_values:#{pk}"
       end
 
       def index(index, name)
         case index
         when PrimaryKeyIndex
-          "#{index.class.name}:#{@prefix}:primary_key"
+          "#{index.class.name}:#{index.model_name}:primary_key"
         else
-          "#{index.class.name}:#{@prefix}:#{name}"
+          "#{index.class.name}:#{index.model_name}:#{name}"
         end
       end
 
@@ -52,12 +52,12 @@ module Relix
         @prefix = klass.name
       end
 
-      def values(pk)
+      def values(pk, klass)
         "#{@prefix}:values:#{pk}"
       end
 
       def index(index, name)
-        "#{@prefix}:#{name}:#{index.class.kind}"
+        "#{index.model_name}:#{name}:#{index.class.kind}"
       end
 
       def component(name, component)
@@ -74,7 +74,7 @@ module Relix
         end
       end
 
-      def values(pk)
+      def values(pk, klass)
         "#{@prefix}:v:#{pk}"
       end
 

data/lib/relix/query.rb

@@ -8,7 +8,7 @@ module Relix
     def [](index_name)
       index = @model.indexes[index_name.to_s]
       raise MissingIndexError.new("No index declared for #{index_name}") unless index
-      @clause = Clause.new(@model.redis, index)
+      @clause = index.create_query_clause(@model.redis)
     end
 
     def run

data/lib/relix/version.rb

@@ -1,3 +1,3 @@
 module Relix
-  VERSION = "1.1.1"
+  VERSION = "1.2.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: relix
 version: !ruby/object:Gem::Version
-  version: 1.1.1
+  version: 1.2.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-01-05 00:00:00.000000000 Z
+date: 2012-01-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: hiredis
-  requirement: &70249249266500 !ruby/object:Gem::Requirement
+  requirement: &70287488679200 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -21,10 +21,10 @@ dependencies:
         version: 0.4.1
   type: :runtime
   prerelease: false
-  version_requirements: *70249249266500
+  version_requirements: *70287488679200
 - !ruby/object:Gem::Dependency
   name: redis
-  requirement: &70249249266000 !ruby/object:Gem::Requirement
+  requirement: &70287488678700 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -32,7 +32,7 @@ dependencies:
         version: 2.2.2
   type: :runtime
   prerelease: false
-  version_requirements: *70249249266000
+  version_requirements: *70287488678700
 description: ! 'Relix is a layer that can be added on to any model to make all the
   normal types of querying you want to do: equality, less than/greater than, in set,
   range, limit, etc., quick and painless. Relix depends on Redis to be awesome at
@@ -50,6 +50,7 @@ files:
 - lib/relix/core.rb
 - lib/relix/index.rb
 - lib/relix/indexes/multi.rb
+- lib/relix/indexes/ordered.rb
 - lib/relix/indexes/primary_key.rb
 - lib/relix/indexes/unique.rb
 - lib/relix/index_set.rb
@@ -71,7 +72,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 187409947092406271
+      hash: -969086072538235743
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements: