zermelo 1.0.1 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a7492dc2e67e9921a87e1dbea33eb721464dce5f
-  data.tar.gz: 62906c88696b9eb2fdfb8d2a94d0244184cd33da
+  metadata.gz: c9908061576a4c3d173358524eaf988a6d16bd33
+  data.tar.gz: 843acdcd8b10b1b13407a7c1440f30f87412ac71
 SHA512:
-  metadata.gz: dde70cf8e7c241eeef5de1925a67719a6c3779cc7afc784ffdca13e5925a146e8b8cb1797b4f70eb1c377a990057a1f2a008f94156201c81bcf705f999c61f27
-  data.tar.gz: 62fe986cbc4ab69699bfc2286ef58c17b8fa12c4e79c0c11a2d82ce805637c7f66a002a94b3e785bb4cb7d34fc1ffe74a7ce6f47c1d7ffb8ed8b82f56e34de58
+  metadata.gz: 5365e1259edae7641187444a6dce2f903be37ae3787f47c5d12006d8f4dd7cf308e6874e54509dabd1ac336a62c39e166839b8ffd76d8126530e43fcc6488a22
+  data.tar.gz: c405762c072ab4f1fe5d366e9997448ba6f35d4b202a6be33535481abc20a1fdf6cbb1d14f87cd4bae37a082cbd9dbe9be3010785c453dd22622064bf5c3bea7

data/.rspec

@@ -1,5 +1,5 @@
 --color
---format progress
+--format documentation
 --format html
 --out tmp/spec.html
 --require ./spec/support/uncolored_doc_formatter.rb

data/.travis.yml

@@ -8,15 +8,13 @@ services:
 - redis-server
 before_install:
 - gem --version
-- wget http://s3.amazonaws.com/influxdb/influxdb_0.8.8_amd64.deb
+- wget https://s3.amazonaws.com/influxdb/influxdb_0.8.8_amd64.deb
 - sudo dpkg -i influxdb_0.8.8_amd64.deb
 - sudo /etc/init.d/influxdb start
 - sleep 8
 - 'curl -X POST ''http://localhost:8086/db?u=root&p=root'' -d ''{"name": "zermelo_test"}'''
-- 'curl -X POST ''http://localhost:8086/db/zermelo_test/users?u=root&p=root'' -d
-  ''{"name": "zermelo", "password": "zermelo"}'''
-- 'curl -X POST ''http://localhost:8086/db/zermelo_test/users/zermelo?u=root&p=root''
-  -d ''{"admin": true}'''
+- 'curl -X POST ''http://localhost:8086/db/zermelo_test/users?u=root&p=root'' -d ''{"name": "zermelo", "password": "zermelo"}'''
+- 'curl -X POST ''http://localhost:8086/db/zermelo_test/users/zermelo?u=root&p=root'' -d ''{"admin": true}'''
 notifications:
   hipchat:
     template:

data/CHANGELOG.md

@@ -1,10 +1,16 @@
 ## Zermelo Changelog
 
+# 1.1.0 - 2015-04-09
+
+* refactored query builder to improve composability
+* bugfix; source key not included when intersecting redis sets
+* log redis return values as well when redis log is used
+
 # 1.0.1 - 2015-02-04
 
-* bugfix has_one class locking (779907d8d)
+* bugfix; has_one class locking (779907d8d)
 * add save! command, raise exceptions on error (#13)
 
 # 1.0.0 - 2015-01-28
 
-* Initial release
+* Initial release

data/lib/zermelo/associations/belongs_to.rb

@@ -14,7 +14,7 @@ module Zermelo
         @backend = parent.send(:backend)
 
         @record_ids_key = Zermelo::Records::Key.new(
-          :klass  => parent.class.send(:class_key),
+          :klass  => parent.class,
           :id     => parent.id,
           :name   => 'belongs_to',
           :type   => :hash,
@@ -88,10 +88,10 @@ module Zermelo
         @backend.clear(@record_ids_key)
       end
 
-      def self.associated_ids_for(backend, class_key, name, inversed, *these_ids)
+      def self.associated_ids_for(backend, klass, name, inversed, *these_ids)
         these_ids.each_with_object({}) do |this_id, memo|
           key = Zermelo::Records::Key.new(
-            :klass  => class_key,
+            :klass  => klass,
             :id     => this_id,
             :name   => 'belongs_to',
             :type   => :hash,

data/lib/zermelo/associations/has_and_belongs_to_many.rb

@@ -23,7 +23,7 @@ module Zermelo
         @backend = parent.send(:backend)
 
         @record_ids_key = Zermelo::Records::Key.new(
-          :klass  => parent.class.send(:class_key),
+          :klass  => parent.class,
           :id     => parent.id,
           :name   => "#{name}_ids",
           :type   => :set,
@@ -110,10 +110,10 @@ module Zermelo
         @backend.filter(@record_ids_key, @associated_class)
       end
 
-      def self.associated_ids_for(backend, class_key, name, *these_ids)
+      def self.associated_ids_for(backend, klass, name, *these_ids)
         these_ids.each_with_object({}) do |this_id, memo|
           key = Zermelo::Records::Key.new(
-            :klass  => class_key,
+            :klass  => klass,
             :id     => this_id,
             :name   => "#{name}_ids",
             :type   => :set,

data/lib/zermelo/associations/has_many.rb

@@ -19,7 +19,7 @@ module Zermelo
         @backend = parent.send(:backend)
 
         @record_ids_key = Zermelo::Records::Key.new(
-          :klass  => parent.class.send(:class_key),
+          :klass  => parent.class,
           :id     => parent.id,
           :name   => "#{name}_ids",
           :type   => :set,
@@ -102,10 +102,10 @@ module Zermelo
         @backend.filter(@record_ids_key, @associated_class)
       end
 
-      def self.associated_ids_for(backend, class_key, name, *these_ids)
+      def self.associated_ids_for(backend, klass, name, *these_ids)
         these_ids.each_with_object({}) do |this_id, memo|
           key = Zermelo::Records::Key.new(
-            :klass  => class_key,
+            :klass  => klass,
             :id     => this_id,
             :name   => "#{name}_ids",
             :type   => :set,

data/lib/zermelo/associations/has_one.rb

@@ -9,7 +9,7 @@ module Zermelo
 
         # TODO would be better as a 'has_one' hash, a bit like belongs_to
         @record_id_key = Zermelo::Records::Key.new(
-          :klass  => parent.class.send(:class_key),
+          :klass  => parent.class,
           :id     => parent.id,
           :name   => "#{name}_id",
           :type   => :string,
@@ -91,10 +91,10 @@ module Zermelo
         @backend.clear(@record_id_key)
       end
 
-      def self.associated_ids_for(backend, class_key, name, *these_ids)
+      def self.associated_ids_for(backend, klass, name, *these_ids)
         these_ids.each_with_object({}) do |this_id, memo|
           key = Zermelo::Records::Key.new(
-            :klass  => class_key,
+            :klass  => klass,
             :id     => this_id,
             :name   => "#{name}_id",
             :type   => :string,

data/lib/zermelo/associations/has_sorted_set.rb

@@ -21,7 +21,7 @@ module Zermelo
         @backend = parent.send(:backend)
 
         @record_ids_key = Zermelo::Records::Key.new(
-          :klass  => parent.class.send(:class_key),
+          :klass  => parent.class,
           :id     => parent.id,
           :name   => "#{name}_ids",
           :type   => :sorted_set,
@@ -32,7 +32,7 @@ module Zermelo
           @associated_class = data.data_klass
           @lock_klasses     = [data.data_klass] + data.related_klasses
           @inverse          = data.inverse
-          @sort_key         = data.sort_key
+          @sort_key         = data.sort_key || backend.default_sort_key
           @callbacks        = data.callbacks
         end
       end
@@ -106,10 +106,10 @@ module Zermelo
         @backend.filter(@record_ids_key, @associated_class)
       end
 
-      def self.associated_ids_for(backend, class_key, name, *these_ids)
+      def self.associated_ids_for(backend, klass, name, *these_ids)
         these_ids.each_with_object({}) do |this_id, memo|
           key = Zermelo::Records::Key.new(
-            :klass  => class_key,
+            :klass  => klass,
             :id     => this_id,
             :name   => "#{name}_ids",
             :type   => :sorted_set,

data/lib/zermelo/associations/index.rb

@@ -9,7 +9,6 @@ module Zermelo
         @attribute_name = name
 
         @backend   = parent_klass.send(:backend)
-        @class_key = parent_klass.send(:class_key)
 
         @indexers = {}
 
@@ -38,7 +37,7 @@ module Zermelo
         raise "Can't index '#{@value}' (#{@attribute_type}" if index_keys.nil?
 
         @indexers[index_keys.join(":")] ||= Zermelo::Records::Key.new(
-          :klass  => @class_key,
+          :klass  => @parent_klass,
           :name   => "by_#{@attribute_name}:#{index_keys.join(':')}",
           :type   => :set,
           :object => :index

data/lib/zermelo/associations/unique_index.rb

@@ -9,7 +9,6 @@ module Zermelo
         @attribute_name = name
 
         @backend   = parent_klass.send(:backend)
-        @class_key = parent_klass.send(:class_key)
 
         @indexers = {}
 
@@ -32,7 +31,7 @@ module Zermelo
 
       def key
         @indexer ||= Zermelo::Records::Key.new(
-          :klass  => @class_key,
+          :klass  => @parent_klass,
           :name   => "by_#{@attribute_name}",
           :type   => :hash,
           :object => :index

data/lib/zermelo/backends/base.rb

@@ -73,7 +73,7 @@ module Zermelo
       end
 
       def get(attr_key)
-        get_multiple(attr_key)[attr_key.klass][attr_key.id][attr_key.name.to_s]
+        get_multiple(attr_key)[attr_key.klass.send(:class_key)][attr_key.id][attr_key.name.to_s]
       end
 
       def lock(*klasses, &block)

data/lib/zermelo/backends/influxdb_backend.rb

@@ -15,6 +15,10 @@ module Zermelo
 
       include Zermelo::Backends::Base
 
+      def default_sorted_set_key
+        :time
+      end
+
       def filter(ids_key, record)
         Zermelo::Filters::InfluxDBFilter.new(self, ids_key, record)
       end
@@ -22,28 +26,30 @@ module Zermelo
       # TODO get filter calling this instead of using same logic
       def exists?(key)
         return if key.id.nil?
-        Zermelo.influxdb.query("SELECT id FROM /#{key.klass}\\/.*/ LIMIT 1").size > 0
+        class_key = attr_key.klass.send(:class_key)
+        Zermelo.influxdb.query("SELECT id FROM /#{class_key}\\/.*/ LIMIT 1").size > 0
       end
 
       # nb: does lots of queries, should batch, but ensuring single operations are correct
       # for now
       def get_multiple(*attr_keys)
         attr_keys.inject({}) do |memo, attr_key|
+          class_key = attr_key.klass.send(:class_key)
           begin
           records = Zermelo.influxdb.query("SELECT #{attr_key.name} FROM " +
-            "\"#{attr_key.klass}/#{attr_key.id}\" LIMIT 1")["#{attr_key.klass}/#{attr_key.id}"]
+            "\"#{class_key}/#{attr_key.id}\" LIMIT 1")["#{class_key}/#{attr_key.id}"]
           rescue InfluxDB::Error => ide
             raise unless
-              /^Field #{attr_key.name} doesn't exist in series #{attr_key.klass}\/#{attr_key.id}$/ === ide.message
+              /^Field #{attr_key.name} doesn't exist in series #{class_key}\/#{attr_key.id}$/ === ide.message
 
             records = []
           end
           value = (records && !records.empty?) ? records.first[attr_key.name.to_s] : nil
 
-          memo[attr_key.klass] ||= {}
-          memo[attr_key.klass][attr_key.id] ||= {}
+          memo[class_key] ||= {}
+          memo[class_key][attr_key.id] ||= {}
 
-          memo[attr_key.klass][attr_key.id][attr_key.name.to_s] = if value.nil?
+          memo[class_key][attr_key.id][attr_key.name.to_s] = if value.nil?
             nil
           else
 
@@ -121,18 +127,20 @@ module Zermelo
 
           next if key.id.nil?
 
-          records[key.klass]         ||= {}
-          records[key.klass][key.id] ||= {}
+          class_key = key.klass.send(:class_key)
+
+          records[class_key]         ||= {}
+          records[class_key][key.id] ||= {}
 
-          records[key.klass][key.id][key.name] = case op
+          records[class_key][key.id][key.name] = case op
           when :set
             case key.type
             when :string, :integer
-              value.to_s
+              value.nil? ? nil : value.to_s
             when :timestamp
-              value.to_f
+              value.nil? ? nil : value.to_f
             when :boolean
-              (!!value).to_s
+              value.nil? ? nil : (!!value).to_s
             when :list, :hash
               value
             when :set
@@ -144,27 +152,30 @@ module Zermelo
               value
             when :set
               value.to_a
+            when :sorted_set
+              (1...value.size).step(2).collect {|i| value[i] }
             end
           when :purge
-            purges << "\"#{key.klass}/#{key.id}\""
+            purges << "\"#{class_key}/#{key.id}\""
           end
 
         end
 
-        records.each_pair do |klass, klass_records|
+        records.each_pair do |class_key, klass_records|
           klass_records.each_pair do |id, data|
             begin
-              prior = Zermelo.influxdb.query("SELECT * FROM \"#{klass}/#{id}\" LIMIT 1")["#{klass}/#{id}"]
+              prior = Zermelo.influxdb.query("SELECT * FROM \"#{class_key}/#{id}\" LIMIT 1")["#{class_key}/#{id}"]
             rescue InfluxDB::Error => ide
               raise unless
-                (/^Couldn't look up columns for series: #{klass}\/#{id}$/ === ide.message) ||
+                (/^Couldn't look up columns for series: #{class_key}\/#{id}$/ === ide.message) ||
                 (/^Couldn't look up columns$/ === ide.message) ||
-                (/^Couldn't find series: #{klass}\/#{id}$/ === ide.message)
+                (/^Couldn't find series: #{class_key}\/#{id}$/ === ide.message)
 
               prior = nil
             end
             record = prior.nil? ? {} : prior.first.delete_if {|k,v| ["time", "sequence_number"].include?(k) }
-            Zermelo.influxdb.write_point("#{klass}/#{id}", record.merge(data).merge('id' => id))
+            data.delete('time') if data.has_key?('time') && data['time'].nil?
+            Zermelo.influxdb.write_point("#{class_key}/#{id}", record.merge(data).merge('id' => id))
           end
         end
 

data/lib/zermelo/backends/redis_backend.rb

@@ -11,6 +11,10 @@ module Zermelo
 
       include Zermelo::Backends::Base
 
+      def default_sorted_set_key
+        :timestamp
+      end
+
       def generate_lock
         Zermelo::Locks::RedisLock.new
       end
@@ -23,9 +27,11 @@ module Zermelo
         attr_keys.inject({}) do |memo, attr_key|
           redis_attr_key = key_to_redis_key(attr_key)
 
-          memo[attr_key.klass] ||= {}
-          memo[attr_key.klass][attr_key.id] ||= {}
-          memo[attr_key.klass][attr_key.id][attr_key.name.to_s] = if Zermelo::COLLECTION_TYPES.has_key?(attr_key.type)
+          class_key = attr_key.klass.send(:class_key)
+
+          memo[class_key] ||= {}
+          memo[class_key][attr_key.id] ||= {}
+          memo[class_key][attr_key.id][attr_key.name.to_s] = if Zermelo::COLLECTION_TYPES.has_key?(attr_key.type)
 
             case attr_key.type
             when :list
@@ -126,8 +132,9 @@ module Zermelo
         true
       end
 
-      # used by redis_filter
       def key_to_redis_key(key)
+        class_key = key.klass.send(:class_key)
+
         obj = case key.object
         when :attribute
           'attrs'
@@ -135,11 +142,104 @@ module Zermelo
           'assocs'
         when :index
           'indices'
+        when :temporary
+          'tmp'
         end
 
         name = Zermelo::COLLECTION_TYPES.has_key?(key.type) ? ":#{key.name}" : ''
 
-        "#{key.klass}:#{key.id.nil? ? '' : key.id}:#{obj}#{name}"
+        "#{class_key}:#{key.id.nil? ? '' : key.id}:#{obj}#{name}"
+      end
+
+      def temp_key_wrap
+        return unless block_given?
+        temp_keys = []
+        begin
+          yield(temp_keys)
+        rescue
+          raise
+        ensure
+          unless temp_keys.empty?
+            Zermelo.redis.del(*temp_keys.collect {|tk| key_to_redis_key(tk)})
+            temp_keys.clear
+          end
+        end
+      end
+
+      # TODO converge usage of idx_class and _index lookup invocation
+
+      def index_lookup(att, associated_class, idx_class, value, attr_type, temp_keys)
+        case value
+        # when Zermelo::Filters::RedisFilter
+
+          # TODO (maybe) if a filter from different backend, resolve to ids and
+          # put that in a Redis temp set
+
+          # collection, should_be_deleted = value.resolve_steps
+
+          # if should_be_deleted
+          #   temp_sets << collection.name
+          # end
+
+          # unless :set.eql?(collection.type)
+          #   raise "Unsure as yet if non-sets are safe as Filter step values"
+          # end
+
+        when Regexp
+          raise "Can't query non-string values via regexp" unless :string.eql?(attr_type)
+
+          idx_key = associated_class.send(:temp_key, :set)
+          temp_keys << idx_key
+          idx_result = key_to_redis_key(idx_key)
+
+          starts_with_string_re = /^string:/
+          case idx_class.name
+          when 'Zermelo::Associations::UniqueIndex'
+            index_key = key_to_redis_key(Zermelo::Records::Key.new(
+              :klass  => associated_class,
+              :name   => "by_#{att}",
+              :type   => :hash,
+              :object => :index
+            ))
+            candidates = Zermelo.redis.hgetall(index_key)
+            matching_ids = candidates.values_at(*candidates.keys.select {|k|
+              (starts_with_string_re === k) &&
+                (value === unescape_key_name(k.sub(starts_with_string_re, '')))
+            })
+            Zermelo.redis.sadd(idx_result, matching_ids) unless matching_ids.empty?
+          when 'Zermelo::Associations::Index'
+            key_root = key_to_redis_key(Zermelo::Records::Key.new(
+              :klass  => associated_class,
+              :name   => "by_#{att}:string",
+              :type   => :set,
+              :object => :index
+            ))
+
+            matching_sets = Zermelo.redis.keys(key_root + ":*").inject([]) do |memo, k|
+              k =~ /^#{key_root}:(.+)$/
+              memo << k if value === $1
+              memo
+            end
+
+            Zermelo.redis.sunionstore(idx_result, matching_sets) unless matching_sets.empty?
+          end
+          idx_key
+        else
+          index = associated_class.send("#{att}_index")
+
+          case index
+          when Zermelo::Associations::UniqueIndex
+            idx_key = associated_class.send(:temp_key, :set)
+            temp_keys << idx_key
+
+            Zermelo.redis.sadd(key_to_redis_key(idx_key),
+              Zermelo.redis.hget(key_to_redis_key(index.key),
+                                   index_keys(attr_type, value).join(':')))
+            idx_key
+          when Zermelo::Associations::Index
+            index.key(value)
+          end
+        end
       end
 
       private
@@ -230,7 +330,7 @@ module Zermelo
 
           elsif :purge.eql?(op)
             # TODO get keys for all assocs & indices, purge them too
-            purges << ["#{key.klass}:#{key.id}:attrs"]
+            purges << ["#{key.klass.send(:class_key)}:#{key.id}:attrs"]
           else
             simple_attr_key = key_to_redis_key(key)
             simple_attrs[simple_attr_key] ||= {}

data/lib/zermelo/filters/base.rb

@@ -2,15 +2,10 @@ require 'active_support/concern'
 
 require 'zermelo/records/errors'
 
-require 'zermelo/filters/steps/diff_range_step'
-require 'zermelo/filters/steps/diff_step'
-require 'zermelo/filters/steps/intersect_range_step'
-require 'zermelo/filters/steps/intersect_step'
-require 'zermelo/filters/steps/limit_step'
-require 'zermelo/filters/steps/offset_step'
+require 'zermelo/filters/steps/list_step'
+require 'zermelo/filters/steps/set_step'
+require 'zermelo/filters/steps/sorted_set_step'
 require 'zermelo/filters/steps/sort_step'
-require 'zermelo/filters/steps/union_range_step'
-require 'zermelo/filters/steps/union_step'
 
 module Zermelo
 
@@ -24,75 +19,74 @@ module Zermelo
 
       # initial set         a Zermelo::Record::Key object
       # associated_class    the class of the result record
-      def initialize(data_backend, initial_set, associated_class, ancestor = nil, step = nil)
+      def initialize(data_backend, initial_key, associated_class, ancestor = nil, step = nil)
         @backend          = data_backend
-        @initial_set      = initial_set
+        @initial_key      = initial_key
         @associated_class = associated_class
         @steps            = ancestor.nil? ? [] : ancestor.steps.dup
         @steps << step unless step.nil?
       end
 
-      # TODO each step type have class methods list its acceptable input types, and
-      # have a class method giving its output type
-
       def intersect(attrs = {})
-        self.class.new(@backend, @initial_set, @associated_class, self,
-          ::Zermelo::Filters::Steps::IntersectStep.new({}, attrs))
+        self.class.new(@backend, @initial_key, @associated_class, self,
+          ::Zermelo::Filters::Steps::SetStep.new({:op => :intersect}, attrs))
       end
 
       def union(attrs = {})
-        self.class.new(@backend, @initial_set, @associated_class, self,
-          ::Zermelo::Filters::Steps::UnionStep.new({}, attrs))
+        self.class.new(@backend, @initial_key, @associated_class, self,
+          ::Zermelo::Filters::Steps::SetStep.new({:op => :union}, attrs))
       end
 
       def diff(attrs = {})
-        self.class.new(@backend, @initial_set, @associated_class, self,
-          ::Zermelo::Filters::Steps::DiffStep.new({}, attrs))
+        self.class.new(@backend, @initial_key, @associated_class, self,
+          ::Zermelo::Filters::Steps::SetStep.new({:op => :diff}, attrs))
       end
 
       def sort(keys, opts = {})
-        self.class.new(@backend, @initial_set, @associated_class, self,
+        self.class.new(@backend, @initial_key, @associated_class, self,
           ::Zermelo::Filters::Steps::SortStep.new({:keys => keys,
             :desc => opts[:desc], :limit => opts[:limit],
             :offset => opts[:offset]}, {})
           )
       end
 
-      def limit(amount)
-        self.class.new(@backend, @initial_set, @associated_class, self,
-          ::Zermelo::Filters::Steps::LimitStep.new({:amount => amount}, {}))
+      def offset(amount, opts = {})
+        self.class.new(@backend, @initial_key, @associated_class, self,
+          ::Zermelo::Filters::Steps::ListStep.new({:offset => amount,
+            :limit => opts[:limit]}, {}))
       end
 
-      def offset(amount)
-        self.class.new(@backend, @initial_set, @associated_class, self,
-          ::Zermelo::Filters::Steps::OffsetStep.new({:amount => amount}, {}))
+      def page(num, opts = {})
+        per_page = opts[:per_page].to_i || 20
+        start  = per_page * (num - 1)
+        finish = start + (per_page - 1)
+        self.class.new(@backend, @initial_key, @associated_class, self,
+          ::Zermelo::Filters::Steps::ListStep.new({:offset => start,
+            :limit => per_page}, {}))
       end
 
       def intersect_range(start, finish, attrs_opts = {})
-        self.class.new(@backend, @initial_set, @associated_class, self,
-          ::Zermelo::Filters::Steps::IntersectRangeStep.new(
-            {:start => start, :finish => finish,
-             :desc => attrs_opts.delete(:desc),
+        self.class.new(@backend, @initial_key, @associated_class, self,
+          ::Zermelo::Filters::Steps::SortedSetStep.new(
+            {:op => :intersect_range, :start => start, :finish => finish,
              :by_score => attrs_opts.delete(:by_score)},
             attrs_opts)
           )
       end
 
       def union_range(start, finish, attrs_opts = {})
-        self.class.new(@backend, @initial_set, @associated_class, self,
-          ::Zermelo::Filters::Steps::UnionRangeStep.new(
-            {:start => start, :finish => finish,
-             :desc => attrs_opts.delete(:desc),
+        self.class.new(@backend, @initial_key, @associated_class, self,
+          ::Zermelo::Filters::Steps::SortedSetStep.new(
+            {:op => :union_range, :start => start, :finish => finish,
              :by_score => attrs_opts.delete(:by_score)},
             attrs_opts)
           )
       end
 
       def diff_range(start, finish, attrs_opts = {})
-        self.class.new(@backend, @initial_set, @associated_class, self,
-          ::Zermelo::Filters::Steps::DiffRangeStep.new(
-            {:start => start, :finish => finish,
-             :desc => attrs_opts.delete(:desc),
+        self.class.new(@backend, @initial_key, @associated_class, self,
+          ::Zermelo::Filters::Steps::SortedSetStep.new(
+            {:op => :diff_range, :start => start, :finish => finish,
              :by_score => attrs_opts.delete(:by_score)},
             attrs_opts)
           )
@@ -141,23 +135,6 @@ module Zermelo
         lock { _all }
       end
 
-      # NB makes no sense to apply this without order clause
-      def page(num, opts = {})
-        ret = nil
-        per_page = opts[:per_page].to_i || 20
-        if (num > 0) && (per_page > 0)
-          lock do
-            start  = per_page * (num - 1)
-            finish = start + (per_page - 1)
-            @steps += [Zermelo::Filters::Steps::OffsetStep.new({:amount => start},    {}),
-                       Zermelo::Filters::Steps::LimitStep.new({:amount => per_page}, {})]
-            page_ids = _ids
-            ret = page_ids.collect {|f_id| _load(f_id)} unless page_ids.nil?
-          end
-        end
-        ret || []
-      end
-
       def collect(&block)
         lock { _ids.collect {|id| block.call(_load(id))} }
       end
@@ -191,11 +168,11 @@ module Zermelo
           case klass.name
           when ::Zermelo::Associations::BelongsTo.name
             klass.send(:associated_ids_for, @backend,
-              @associated_class.send(:class_key), name,
+              @associated_class, name,
               options[:inversed].is_a?(TrueClass), *_ids)
           else
             klass.send(:associated_ids_for, @backend,
-              @associated_class.send(:class_key), name, *_ids)
+              @associated_class, name, *_ids)
           end
         }
       end