sequel-seek-pagination 0.4.0 → 0.4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 9751ce847311d620172aefa80a83148dc6a2dd83
-  data.tar.gz: a525864295cf2d3a2680bcc0eea4c88be7d94f3a
+SHA256:
+  metadata.gz: 9dfe03d36fb53800c54b429a7930afe26d146b7bb97262dd3295b2e2fefd8376
+  data.tar.gz: 3b26d4ac8282c81fcc08d0ccb16f40612281bacc3aabe0cb205692aa1b3fdf73
 SHA512:
-  metadata.gz: 8be865383b88eb55f9e7b6b19fa9a79a885a630c5a61cedc736196a450ff495af6e36ce381a959775bf42e4fff05807964abe8bfd194d406bf8246cadaa5a2c3
-  data.tar.gz: e526f7d0531401db2b8931d3cc7b5a92fe3592b7d5d9c062c57f1c0f12ea349e47cbb0376e6615b7565e3b60d9daf4efec3f671f51c851762f89d97145fd0948
+  metadata.gz: 920966063e123eec91588025445af46127c68deda371b0b73f60e14907648cc9cb70c503a32939981d3f87414c741673c0cb870a2295f0cf1509ac04c6ecec7d
+  data.tar.gz: ba980e3f6991239d7c3c10396f96beff84952ca0d3ef51a175bb817f0dfbbe25bdf42dd1354dc24963659dc98c8ae125e869782823e1745772e75b818f26c5a0

data/lib/sequel/extensions/seek_pagination.rb

@@ -5,7 +5,27 @@ module Sequel
   module SeekPagination
     class Error < StandardError; end
 
-    def seek(value: nil, pk: nil, include_exact_match: false, not_null: nil)
+    def seek(missing_pk: :raise, **args)
+      if c = seek_conditions(raise_on_missing_pk: missing_pk == :raise, **args)
+        where(c)
+      else
+        case missing_pk
+        when :ignore     then self
+        when :nullify    then nullify
+        when :return_nil then nil
+        else raise Error, "passed an invalid argument for missing_pk: #{missing_pk.inspect}"
+        end
+      end
+    end
+
+    def seek_conditions(
+      value: nil,
+      pk: nil,
+      include_exact_match: false,
+      not_null: nil,
+      raise_on_missing_pk: false
+    )
+
       order = opts[:order]
       model = opts[:model]
 
@@ -13,32 +33,19 @@ module Sequel
         raise Error, "must pass exactly one of :value and :pk to #seek"
       elsif order.nil? || order.length.zero?
         raise Error, "cannot call #seek on a dataset with no order"
-      elsif model.nil? && pk
-        raise Error, "attempted a primary key lookup on a dataset that doesn't have an associated model"
       end
 
-      if pk
-        target_ds = where(model.qualified_primary_key_hash(pk))
-
-        # Need to load the values to order from for that pk from the DB, so we
-        # need to fetch the actual expressions being ordered by. Also,
-        # Dataset#get won't like it if we pass it expressions that aren't
-        # simple columns, so we need to give it aliases for everything.
-        al = :a
-        gettable = order.map do |o|
-          expression = Sequel::SQL::OrderedExpression === o ? o.expression : o
-          Sequel.as(expression, (al = al.next))
+      values =
+        if pk
+          get_order_values_for_pk(pk, raise_on_failure: raise_on_missing_pk)
+        else
+          Array(value)
         end
 
-        unless values = target_ds.get(gettable)
-          raise NoMatchingRow.new(target_ds)
-        end
-      else
-        values = Array(value)
+      return unless values
 
-        if values.length != order.length
-          raise Error, "passed the wrong number of values to #seek"
-        end
+      if values.length != order.length
+        raise Error, "passed the wrong number of values to #seek"
       end
 
       if not_null.nil?
@@ -47,8 +54,11 @@ module Sequel
         # If the dataset was chained off a model, use its stored schema
         # information to figure out what columns are not null.
         if model
+          table = model.table_name
+
           model.db_schema.each do |column, schema|
-            not_null << column if schema[:allow_null] == false
+            next if schema[:allow_null]
+            not_null << column << Sequel.qualify(table, column)
           end
         end
       end
@@ -57,7 +67,40 @@ module Sequel
         order.zip(values),
         include_exact_match: include_exact_match,
         not_null: not_null
-      ).apply(self)
+      ).build_conditions
+    end
+
+    def get_order_values_for_pk(pk, raise_on_failure: false)
+      order = opts[:order]
+
+      unless model = opts[:model]
+        raise Error, "attempted a primary key lookup on a dataset that doesn't have an associated model"
+      end
+
+      al = nil
+      aliases = order.map { al = al ? al.next : :a }
+
+      ds =
+        cached_dataset(:_seek_pagination_get_order_values_ds) do
+          # Need to load the values to order from for that pk from the DB, so we
+          # need to fetch the actual expressions being ordered by. Also,
+          # Dataset#get won't like it if we pass it expressions that aren't
+          # simple columns, so we need to give it aliases for everything.
+          naked.limit(1).select(
+            *order.map.with_index { |o, i|
+              expression = Sequel::SQL::OrderedExpression === o ? o.expression : o
+              Sequel.as(expression, aliases[i])
+            }
+          )
+        end
+
+      condition = model.qualified_primary_key_hash(pk)
+
+      if result = ds.where_all(condition).first
+        result.values_at(*aliases)
+      elsif raise_on_failure
+        raise NoMatchingRow.new(ds.where(condition))
+      end
     end
 
     private
@@ -71,46 +114,43 @@ module Sequel
         @orders = order_values.map { |order, value| OrderedColumn.new(self, order, value) }
       end
 
-      def apply(dataset)
+      def build_conditions
         length = orders.length
 
-        conditions =
-          # Handle the common case where we can do a simpler (and faster)
-          # WHERE (non_nullable_1, non_nullable_2) > (1, 2) clause.
-          if length > 1 && orders.all?(&:not_null) && has_uniform_order_direction?
-            Sequel.virtual_row do |o|
-              o.__send__(
-                orders.first.inequality_method(include_exact_match),
-                orders.map(&:name),
-                orders.map(&:value)
-              )
-            end
-          else
-            Sequel.&(
-              *length.times.map { |i|
-                allow_equal = include_exact_match || i != (length - 1)
-                conditions = orders[0..i]
-
-                if i.zero?
-                  conditions[0].inequality_condition(allow_equal: allow_equal)
-                else
-                  c = conditions[-2]
-
-                  list = if filter = conditions[-1].inequality_condition(allow_equal: allow_equal)
-                           [Sequel.&(c.eq_filter, filter)]
-                         else
-                           [c.eq_filter]
-                         end
-
-                  list += conditions[0..-2].map { |c| c.inequality_condition(allow_equal: false) }
-
-                  Sequel.|(*list.compact)
-                end
-              }.compact
+        # Handle the common case where we can do a simpler (and faster)
+        # WHERE (non_nullable_1, non_nullable_2) > (1, 2) clause.
+        if length > 1 && orders.all?(&:not_null) && has_uniform_order_direction?
+          Sequel.virtual_row do |o|
+            o.__send__(
+              orders.first.inequality_method(include_exact_match),
+              orders.map(&:name),
+              orders.map(&:value)
             )
           end
-
-        dataset.where(conditions)
+        else
+          Sequel.&(
+            *length.times.map { |i|
+              allow_equal = include_exact_match || i != (length - 1)
+              conditions = orders[0..i]
+
+              if i.zero?
+                conditions[0].inequality_condition(allow_equal: allow_equal)
+              else
+                c = conditions[-2]
+
+                list = if filter = conditions[-1].inequality_condition(allow_equal: allow_equal)
+                         [Sequel.&(c.eq_filter, filter)]
+                       else
+                         [c.eq_filter]
+                       end
+
+                list += conditions[0..-2].map { |c| c.inequality_condition(allow_equal: false) }
+
+                Sequel.|(*list.compact)
+              end
+            }.compact
+          )
+        end
       end
 
       private

data/lib/sequel/extensions/seek_pagination/version.rb

@@ -1,5 +1,5 @@
 module Sequel
   module SeekPagination
-    VERSION = '0.4.0'
+    VERSION = '0.4.1'
   end
 end

data/spec/seek_pagination_spec.rb

@@ -200,8 +200,40 @@ class SeekPaginationSpec < Minitest::Spec
         SeekModel.order(:not_nullable_1, :not_nullable_2, :id).seek(value: [1, 2, 3]).limit(5).sql
     end
 
-    it "should raise an error when passed a pk for a record that doesn't exist in the dataset" do
-      assert_raises(Sequel::NoMatchingRow) { SeekModel.order(:id).seek(pk: -45) }
+    it "shouldn't be fooled by table-qualified orderings" do
+      assert_equal %(SELECT * FROM "seek" WHERE (("seek"."not_nullable_1", "seek"."not_nullable_2", "seek"."id") > (1, 2, 3)) ORDER BY "seek"."not_nullable_1", "seek"."not_nullable_2", "seek"."id" LIMIT 5),
+        SeekModel.order(Sequel.qualify(:seek, :not_nullable_1), Sequel.qualify(:seek, :not_nullable_2), Sequel.qualify(:seek, :id)).seek(value: [1, 2, 3]).limit(5).sql
+    end
+
+    describe "when passed a pk and no record is found" do
+      it "should default to raising an error" do
+        assert_raises(Sequel::NoMatchingRow) do
+          SeekModel.order(:id).seek(pk: -45)
+        end
+      end
+
+      it "should support returning nil" do
+        assert_nil SeekModel.order(:id).seek(pk: -45, missing_pk: :return_nil)
+      end
+
+      it "should support ignoring the condition" do
+        ds = SeekModel.order(:id).seek(pk: -45, missing_pk: :ignore)
+
+        assert_equal SeekModel.order(:id), ds
+      end
+
+      it "should support nullifying the dataset" do
+        ds = SeekModel.order(:id).seek(pk: -45, missing_pk: :nullify)
+
+        assert_equal [], ds.all
+        assert_equal 0, ds.count
+      end
+
+      it "should raise when an unsupported option is passed" do
+        assert_error_message "passed an invalid argument for missing_pk: :nonexistent_option" do
+          SeekModel.order(:id).seek(pk: -45, missing_pk: :nonexistent_option)
+        end
+      end
     end
   end
 end

data/spec/spec_helper.rb

@@ -3,6 +3,7 @@ require 'sequel'
 $: << File.join(File.dirname(__FILE__), '..', 'lib')
 
 Sequel::Database.extension :seek_pagination
+Sequel::Database.extension :null_dataset
 
 DB = Sequel.connect "postgres:///sequel-seek-pagination-test"
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sequel-seek-pagination
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.4.1
 platform: ruby
 authors:
 - Chris Hanks
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-09-05 00:00:00.000000000 Z
+date: 2018-04-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -107,7 +107,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.5.1
+rubygems_version: 2.7.3
 signing_key: 
 specification_version: 4
 summary: Seek pagination for Sequel + PostgreSQL