sequel 4.36.0 → 5.61.0

data/lib/sequel/extensions/null_dataset.rb

@@ -13,7 +13,7 @@
 #
 # Usage:
 #
-#   ds = DB[:items].nullify.where(:a=>:b).select(:c)
+#   ds = DB[:items].nullify.where(a: :b).select(:c)
 #   ds.sql # => "SELECT c FROM items WHERE (a = b)"
 #   ds.all # => [] # no query sent to the database
 #
@@ -41,12 +41,9 @@ module Sequel
     module Nullifiable
       # Return a cloned nullified dataset.
       def nullify
-        clone.nullify!
-      end
-
-      # Nullify the current dataset
-      def nullify!
-        extend NullDataset
+        cached_dataset(:_nullify_ds) do
+          with_extend(NullDataset)
+        end
       end
     end
 
@@ -54,7 +51,10 @@ module Sequel
       # Create a new dataset from the dataset (which won't
       # be nulled) to get the columns if they aren't already cached.
       def columns
-        @columns ||= db.dataset.clone(@opts).columns
+        if cols = _columns
+          return cols
+        end
+        self.columns = db.dataset.clone(@opts).columns
       end
 
       # Return 0 without sending a database query.

data/lib/sequel/extensions/pagination.rb

@@ -39,9 +39,14 @@ module Sequel
     # number of records for this dataset.
     def paginate(page_no, page_size, record_count=nil)
       raise(Error, "You cannot paginate a dataset that already has a limit") if @opts[:limit]
-      paginated = limit(page_size, (page_no - 1) * page_size)
-      paginated.extend(Dataset::Pagination)
-      paginated.set_pagination_info(page_no, page_size, record_count || count)
+
+      record_count ||= count
+      page_count = (record_count / page_size.to_f).ceil
+      page_count = 1 if page_count == 0
+
+      limit(page_size, (page_no - 1) * page_size).
+        with_extend(Dataset::Pagination).
+        clone(:page_size=>page_size, :current_page=>page_no, :pagination_record_count=>record_count, :page_count=>page_count)
     end
       
     # Yields a paginated dataset for each page and returns the receiver. Does
@@ -49,7 +54,7 @@ module Sequel
     # an enumerator if no block is given.
     def each_page(page_size)
       raise(Error, "You cannot paginate a dataset that already has a limit") if @opts[:limit]
-      return to_enum(:each_page, page_size) unless block_given?
+      return to_enum(:each_page, page_size) unless defined?(yield)
       record_count = count
       total_pages = (record_count / page_size.to_f).ceil
       (1..total_pages).each{|page_no| yield paginate(page_no, page_size, record_count)}
@@ -59,51 +64,59 @@ module Sequel
 
   class Dataset
     # Holds methods that only relate to paginated datasets. Paginated dataset
-    # have pages starting at 1 (page 1 is offset 0, page 1 is offset page_size).
+    # have pages starting at 1 (page 1 is offset 0, page 2 is offset 1 * page_size).
     module Pagination
       # The number of records per page (the final page may have fewer than
       # this number of records).
-      attr_accessor :page_size
+      def page_size
+        @opts[:page_size]
+      end
 
       # The number of pages in the dataset before pagination, of which
       # this paginated dataset is one.  Empty datasets are considered
       # to have a single page.
-      attr_accessor :page_count
+      def page_count
+        @opts[:page_count]
+      end
 
       # The current page of the dataset, starting at 1 and not 0.
-      attr_accessor :current_page
+      def current_page
+        @opts[:current_page]
+      end
 
       # The total number of records in the dataset before pagination.
-      attr_accessor :pagination_record_count
+      def pagination_record_count
+        @opts[:pagination_record_count]
+      end
 
       # Returns the record range for the current page
       def current_page_record_range
-        return (0..0) if @current_page > @page_count
+        return (0..0) if current_page > page_count
         
-        a = 1 + (@current_page - 1) * @page_size
-        b = a + @page_size - 1
-        b = @pagination_record_count if b > @pagination_record_count
+        a = 1 + (current_page - 1) * page_size
+        b = a + page_size - 1
+        b = pagination_record_count if b > pagination_record_count
         a..b
       end
 
       # Returns the number of records in the current page
       def current_page_record_count
-        return 0 if @current_page > @page_count
+        return 0 if current_page > page_count
         
-        a = 1 + (@current_page - 1) * @page_size
-        b = a + @page_size - 1
-        b = @pagination_record_count if b > @pagination_record_count
+        a = 1 + (current_page - 1) * page_size
+        b = a + page_size - 1
+        b = pagination_record_count if b > pagination_record_count
         b - a + 1
       end
 
       # Returns true if the current page is the first page
       def first_page?
-        @current_page == 1
+        current_page == 1
       end
 
       # Returns true if the current page is the last page
       def last_page?
-        @current_page == @page_count
+        current_page == page_count
       end
 
       # Returns the next page number or nil if the current page is the last page
@@ -120,16 +133,6 @@ module Sequel
       def prev_page
         current_page > 1 ? (current_page - 1) : nil
       end
-
-      # Sets the pagination info for this paginated dataset, and returns self.
-      def set_pagination_info(page_no, page_size, record_count)
-        @current_page = page_no
-        @page_size = page_size
-        @pagination_record_count = record_count
-        @page_count = (record_count / page_size.to_f).ceil
-        @page_count = 1 if @page_count == 0
-        self
-      end
     end
   end