sequel 4.49.0 → 5.0.0

data/lib/sequel/dataset.rb

@@ -1,24 +1,24 @@
 # frozen-string-literal: true
 
 module Sequel
-  # A dataset represents an SQL query, or more generally, an abstract
-  # set of rows in the database.  Datasets
-  # can be used to create, retrieve, update and delete records.
+  # A dataset represents an SQL query. Datasets
+  # can be used to select, insert, update and delete records.
   # 
   # Query results are always retrieved on demand, so a dataset can be kept
   # around and reused indefinitely (datasets never cache results):
   #
-  #   my_posts = DB[:posts].where(:author => 'david') # no records are retrieved
+  #   my_posts = DB[:posts].where(author: 'david') # no records are retrieved
   #   my_posts.all # records are retrieved
   #   my_posts.all # records are retrieved again
   #
-  # Most dataset methods return modified copies of the dataset (functional style), so you can
-  # reuse different datasets to access data:
+  # Datasets are frozen and use a functional style where modification methods
+  # return modified copies of the the dataset.  This allows you to reuse
+  # datasets:
   #
   #   posts = DB[:posts]
-  #   davids_posts = posts.where(:author => 'david')
-  #   old_posts = posts.where('stamp < ?', Date.today - 7)
-  #   davids_old_posts = davids_posts.where('stamp < ?', Date.today - 7)
+  #   davids_posts = posts.where(author: 'david')
+  #   old_posts = posts.where{stamp < Date.today - 7}
+  #   davids_old_posts = davids_posts.where{stamp < Date.today - 7}
   #
   # Datasets are Enumerable objects, so they can be manipulated using any
   # of the Enumerable methods, such as map, inject, etc.
@@ -42,5 +42,13 @@ module Sequel
     include SQL::StringMethods
   end
   
-  require(%w"query actions features graph prepared_statements misc mutation sql placeholder_literalizer dataset_module", 'dataset')
+  require_relative "dataset/query"
+  require_relative "dataset/actions"
+  require_relative "dataset/features"
+  require_relative "dataset/graph"
+  require_relative "dataset/prepared_statements"
+  require_relative "dataset/misc"
+  require_relative "dataset/sql"
+  require_relative "dataset/placeholder_literalizer"
+  require_relative "dataset/dataset_module"
 end

data/lib/sequel/dataset/actions.rb

@@ -12,12 +12,11 @@ module Sequel
     # Action methods defined by Sequel that execute code on the database.
     ACTION_METHODS = (<<-METHS).split.map(&:to_sym).freeze
       << [] all as_hash avg count columns columns! delete each
-      empty? fetch_rows first first! get import insert interval last
-      map max min multi_insert paged_each range select_hash select_hash_groups select_map select_order_map
+      empty? fetch_rows first first! get import insert last
+      map max min multi_insert paged_each select_hash select_hash_groups select_map select_order_map
       single_record single_record! single_value single_value! sum to_hash to_hash_groups truncate update
       where_all where_each where_single_value
     METHS
-    # SEQUEL5: Remove interval, range
 
     # The clone options to use when retriveing columns for a dataset.
     COLUMNS_CLONE_OPTIONS = {:distinct => nil, :limit => 1, :offset=>nil, :where=>nil, :having=>nil, :order=>nil, :row_proc=>nil, :graph=>nil, :eager_graph=>nil}.freeze
@@ -25,7 +24,7 @@ module Sequel
     # Inserts the given argument into the database.  Returns self so it
     # can be used safely when chaining:
     # 
-    #   DB[:items] << {:id=>0, :name=>'Zero'} << DB[:old_items].select(:id, name)
+    #   DB[:items] << {id: 0, name: 'Zero'} << DB[:old_items].select(:id, name)
     def <<(arg)
       insert(arg)
       self
@@ -33,8 +32,8 @@ module Sequel
     
     # Returns the first record matching the conditions. Examples:
     #
-    #   DB[:table][:id=>1] # SELECT * FROM table WHERE (id = 1) LIMIT 1
-    #   # => {:id=1}
+    #   DB[:table][id: 1] # SELECT * FROM table WHERE (id = 1) LIMIT 1
+    #   # => {:id=>1}
     def [](*conditions)
       raise(Error, 'You cannot call Dataset#[] with an integer or with no arguments') if (conditions.length == 1 and conditions.first.is_a?(Integer)) or conditions.length == 0
       first(*conditions)
@@ -92,6 +91,8 @@ module Sequel
       end
     end
     
+    COUNT_SELECT = Sequel.function(:count).*.as(:count)
+
     # Returns the number of records in the dataset. If an argument is provided,
     # it is used as the argument to count.  If a block is provided, it is
     # treated as a virtual row, and the result is used as the argument to
@@ -106,8 +107,7 @@ module Sequel
     def count(arg=(no_arg=true), &block)
       if no_arg && !block
         cached_dataset(:_count_ds) do
-          aggregate_dataset.select(Sequel.function(:count).*.as(:count)).single_value_ds
-          #aggregate_dataset.select(COUNT_SELECT).single_value_ds # SEQUEL5
+          aggregate_dataset.select(COUNT_SELECT).single_value_ds
         end.single_value!.to_i
       else
         if block
@@ -121,12 +121,8 @@ module Sequel
         _aggregate(:count, arg)
       end
     end
-    # SEQUEL5
-    #COUNT_SELECT = Sequel.function(:count).*.as(:count)
-    #private_constant :COUNT_SELECT
 
-    # Deletes the records in the dataset.  The returned value should be 
-    # number of records deleted, but that is adapter dependent.
+    # Deletes the records in the dataset, returning the number of records deleted.
     #
     #   DB[:table].delete # DELETE * FROM table
     #   # => 3
@@ -157,24 +153,22 @@ module Sequel
       self
     end
     
+    EMPTY_SELECT = Sequel::SQL::AliasedExpression.new(1, :one)
+
     # Returns true if no records exist in the dataset, false otherwise
     #
     #   DB[:table].empty? # SELECT 1 AS one FROM table LIMIT 1
     #   # => false
     def empty?
       cached_dataset(:_empty_ds) do
-        single_value_ds.unordered.select(Sequel::SQL::AliasedExpression.new(1, :one))
-        # single_value_ds.unordered.select(EMPTY_SELECT) # SEQUEL5
+        single_value_ds.unordered.select(EMPTY_SELECT)
       end.single_value!.nil?
     end
-    # SEQUEL5
-    #EMPTY_SELECT = Sequel::SQL::AliasedExpression.new(1, :one)
-    #private_constant :EMPTY_SELECT
 
+    # Returns the first matching record if no arguments are given.
     # If a integer argument is given, it is interpreted as a limit, and then returns all 
-    # matching records up to that limit.  If no argument is passed,
-    # it returns the first matching record.  If any other type of
-    # argument(s) is passed, it is given to filter and the
+    # matching records up to that limit.  If any other type of
+    # argument(s) is passed, it is treated as a filter and the
     # first matching record is returned.  If a block is given, it is used
     # to filter the dataset before returning anything.
     #
@@ -189,19 +183,19 @@ module Sequel
     #   DB[:table].first(2) # SELECT * FROM table LIMIT 2
     #   # => [{:id=>6}, {:id=>4}]
     #
-    #   DB[:table].first(:id=>2) # SELECT * FROM table WHERE (id = 2) LIMIT 1
+    #   DB[:table].first(id: 2) # SELECT * FROM table WHERE (id = 2) LIMIT 1
     #   # => {:id=>2}
     #
-    #   DB[:table].first("id = 3") # SELECT * FROM table WHERE (id = 3) LIMIT 1
+    #   DB[:table].first(Sequel.lit("id = 3")) # SELECT * FROM table WHERE (id = 3) LIMIT 1
     #   # => {:id=>3}
     #
-    #   DB[:table].first("id = ?", 4) # SELECT * FROM table WHERE (id = 4) LIMIT 1
+    #   DB[:table].first(Sequel.lit("id = ?", 4)) # SELECT * FROM table WHERE (id = 4) LIMIT 1
     #   # => {:id=>4}
     #
     #   DB[:table].first{id > 2} # SELECT * FROM table WHERE (id > 2) LIMIT 1
     #   # => {:id=>5}
     #
-    #   DB[:table].first("id > ?", 4){id < 6} # SELECT * FROM table WHERE ((id > 4) AND (id < 6)) LIMIT 1
+    #   DB[:table].first(Sequel.lit("id > ?", 4)){id < 6} # SELECT * FROM table WHERE ((id > 4) AND (id < 6)) LIMIT 1
     #   # => {:id=>5}
     #
     #   DB[:table].first(2){id < 2} # SELECT * FROM table WHERE (id < 2) LIMIT 2
@@ -361,7 +355,8 @@ module Sequel
     end
 
     # Inserts values into the associated table.  The returned value is generally
-    # the value of the primary key for the inserted row, but that is adapter dependent.
+    # the value of the autoincremented primary key for the inserted row, assuming that
+    # the a single row is inserted and the table has an autoincrementing primary key.
     #
     # +insert+ handles a number of different argument formats:
     # no arguments or single empty hash :: Uses DEFAULT VALUES
@@ -387,7 +382,7 @@ module Sequel
     #   DB[:items].insert([:a, :b], [1,2])
     #   # INSERT INTO items (a, b) VALUES (1, 2)
     #
-    #   DB[:items].insert(:a => 1, :b => 2)
+    #   DB[:items].insert(a: 1, b: 2)
     #   # INSERT INTO items (a, b) VALUES (1, 2)
     #
     #   DB[:items].insert(DB[:old_items])
@@ -404,26 +399,6 @@ module Sequel
       end
     end
     
-    # Returns the interval between minimum and maximum values for the given 
-    # column/expression. Uses a virtual row block if no argument is given.
-    #
-    #   DB[:table].interval(:id) # SELECT (max(id) - min(id)) FROM table LIMIT 1
-    #   # => 6
-    #   DB[:table].interval{function(column)} # SELECT (max(function(column)) - min(function(column))) FROM table LIMIT 1
-    #   # => 7
-    def interval(column=Sequel.virtual_row(&Proc.new))
-      Sequel::Deprecation.deprecate("Sequel::Dataset#interval", "Use #max - #min, or use the sequel_4_dataset_methods extension")
-      if loader = cached_placeholder_literalizer(:_interval_loader) do |pl|
-          arg = pl.arg
-          aggregate_dataset.limit(1).select((SQL::Function.new(:max, arg) - SQL::Function.new(:min, arg)).as(:interval))
-        end
-
-        loader.get(column)
-      else
-        aggregate_dataset.get{(max(column) - min(column)).as(:interval)}
-      end
-    end
-
     # Reverses the order and then runs #first with the given arguments and block.  Note that this
     # will not necessarily give you the last record in the dataset,
     # unless you have an unambiguous order.  If there is not
@@ -439,8 +414,8 @@ module Sequel
       reverse.first(*args, &block)
     end
     
-    # Maps column values for each record in the dataset (if a column name is
-    # given), or performs the stock mapping functionality of +Enumerable+ otherwise. 
+    # Maps column values for each record in the dataset (if an argument is given)
+    # or performs the stock mapping functionality of +Enumerable+ otherwise. 
     # Raises an +Error+ if both an argument and block are given.
     #
     #   DB[:table].map(:id) # SELECT * FROM table
@@ -492,7 +467,7 @@ module Sequel
     # This is a front end for import that allows you to submit an array of
     # hashes instead of arrays of columns and values:
     # 
-    #   DB[:table].multi_insert([{:x => 1}, {:x => 2}])
+    #   DB[:table].multi_insert([{x: 1}, {x: 2}])
     #   # INSERT INTO table (x) VALUES (1)
     #   # INSERT INTO table (x) VALUES (2)
     #
@@ -528,7 +503,7 @@ module Sequel
     #              selecting the columns you are ordering by, and none of the columns can contain
     #              NULLs.  Note that some Sequel adapters have optimized implementations that will
     #              use cursors or streaming regardless of the :strategy option used.
-    # :filter_values :: If the :strategy=>:filter option is used, this option should be a proc
+    # :filter_values :: If the strategy: :filter option is used, this option should be a proc
     #                   that accepts the last retreived row for the previous page and an array of
     #                   ORDER BY expressions, and returns an array of values relating to those
     #                   expressions for the last retrieved row.  You will need to use this option
@@ -548,13 +523,13 @@ module Sequel
     #   # SELECT * FROM table ORDER BY id LIMIT 100 OFFSET 100
     #   # ...
     #
-    #   DB[:table].order(:id).paged_each(:strategy=>:filter){|row| }
+    #   DB[:table].order(:id).paged_each(strategy: :filter){|row| }
     #   # SELECT * FROM table ORDER BY id LIMIT 1000
     #   # SELECT * FROM table WHERE id > 1001 ORDER BY id LIMIT 1000
     #   # ...
     #
-    #   DB[:table].order(:table__id).paged_each(:strategy=>:filter,
-    #     :filter_values=>proc{|row, exprs| [row[:id]]}){|row| }
+    #   DB[:table].order(:id).paged_each(strategy: :filter,
+    #     filter_values: lambda{|row, exprs| [row[:id]]}){|row| }
     #   # SELECT * FROM table ORDER BY id LIMIT 1000
     #   # SELECT * FROM table WHERE id > 1001 ORDER BY id LIMIT 1000
     #   # ...
@@ -618,30 +593,6 @@ module Sequel
       self
     end
 
-    # Returns a +Range+ instance made from the minimum and maximum values for the
-    # given column/expression.  Uses a virtual row block if no argument is given.
-    #
-    #   DB[:table].range(:id) # SELECT max(id) AS v1, min(id) AS v2 FROM table LIMIT 1
-    #   # => 1..10
-    #   DB[:table].interval{function(column)} # SELECT max(function(column)) AS v1, min(function(column)) AS v2 FROM table LIMIT 1
-    #   # => 0..7
-    def range(column=Sequel.virtual_row(&Proc.new))
-      Sequel::Deprecation.deprecate("Sequel::Dataset#range", "Use #min..#max, or use the sequel_4_dataset_methods extension")
-      r = if loader = cached_placeholder_literalizer(:_range_loader) do |pl|
-            arg = pl.arg
-            aggregate_dataset.limit(1).select(SQL::Function.new(:min, arg).as(:v1), SQL::Function.new(:max, arg).as(:v2))
-          end
-
-        loader.first(column)
-      else
-        aggregate_dataset.select{[min(column).as(v1), max(column).as(v2)]}.first
-      end
-
-      if r
-        (r[:v1]..r[:v2])
-      end
-    end
-    
     # Returns a hash with key_column values as keys and value_column values as
     # values.  Similar to as_hash, but only selects the columns given.  Like
     # as_hash, it accepts an optional :hash parameter, into which entries will
@@ -657,8 +608,7 @@ module Sequel
     #   # {[1, 3]=>['a', 'c'], [2, 4]=>['b', 'd'], ...}
     #
     # When using this method, you must be sure that each expression has an alias
-    # that Sequel can determine.  Usually you can do this by calling the #as method
-    # on the expression and providing an alias.
+    # that Sequel can determine.
     def select_hash(key_column, value_column, opts = OPTS)
       _select_hash(:as_hash, key_column, value_column, opts)
     end
@@ -677,8 +627,7 @@ module Sequel
     #   # {['a', 'b']=>[['c', 1], ['d', 2], ...], ...}
     #
     # When using this method, you must be sure that each expression has an alias
-    # that Sequel can determine.  Usually you can do this by calling the #as method
-    # on the expression and providing an alias.
+    # that Sequel can determine.
     def select_hash_groups(key_column, value_column, opts = OPTS)
       _select_hash(:to_hash_groups, key_column, value_column, opts)
     end
@@ -701,8 +650,7 @@ module Sequel
     #   # => [[1, 'A'], [2, 'B'], [3, 'C'], ...]
     #
     # If you provide an array of expressions, you must be sure that each entry
-    # in the array has an alias that Sequel can determine.  Usually you can do this
-    # by calling the #as method on the expression and providing an alias.
+    # in the array has an alias that Sequel can determine.
     def select_map(column=nil, &block)
       _select_map(column, false, &block)
     end
@@ -721,8 +669,7 @@ module Sequel
     #   # => [[1, 'A'], [2, 'B'], [3, 'C'], ...]
     #
     # If you provide an array of expressions, you must be sure that each entry
-    # in the array has an alias that Sequel can determine.  Usually you can do this
-    # by calling the #as method on the expression and providing an alias.
+    # in the array has an alias that Sequel can determine.
     def select_order_map(column=nil, &block)
       _select_map(column, true, &block)
     end
@@ -817,21 +764,21 @@ module Sequel
         return naked.as_hash(key_column, value_column, opts) if row_proc
         if value_column.is_a?(Array)
           if key_column.is_a?(Array)
-            send(meth){|r| h[r.values_at(*key_column)] = r.values_at(*value_column)}
+            public_send(meth){|r| h[r.values_at(*key_column)] = r.values_at(*value_column)}
           else
-            send(meth){|r| h[r[key_column]] = r.values_at(*value_column)}
+            public_send(meth){|r| h[r[key_column]] = r.values_at(*value_column)}
           end
         else
           if key_column.is_a?(Array)
-            send(meth){|r| h[r.values_at(*key_column)] = r[value_column]}
+            public_send(meth){|r| h[r.values_at(*key_column)] = r[value_column]}
           else
-            send(meth){|r| h[r[key_column]] = r[value_column]}
+            public_send(meth){|r| h[r[key_column]] = r[value_column]}
           end
         end
       elsif key_column.is_a?(Array)
-        send(meth){|r| h[key_column.map{|k| r[k]}] = r}
+        public_send(meth){|r| h[key_column.map{|k| r[k]}] = r}
       else
-        send(meth){|r| h[r[key_column]] = r}
+        public_send(meth){|r| h[r[key_column]] = r}
       end
       h
     end
@@ -872,21 +819,21 @@ module Sequel
         return naked.to_hash_groups(key_column, value_column, opts) if row_proc
         if value_column.is_a?(Array)
           if key_column.is_a?(Array)
-            send(meth){|r| (h[r.values_at(*key_column)] ||= []) << r.values_at(*value_column)}
+            public_send(meth){|r| (h[r.values_at(*key_column)] ||= []) << r.values_at(*value_column)}
           else
-            send(meth){|r| (h[r[key_column]] ||= []) << r.values_at(*value_column)}
+            public_send(meth){|r| (h[r[key_column]] ||= []) << r.values_at(*value_column)}
           end
         else
           if key_column.is_a?(Array)
-            send(meth){|r| (h[r.values_at(*key_column)] ||= []) << r[value_column]}
+            public_send(meth){|r| (h[r.values_at(*key_column)] ||= []) << r[value_column]}
           else
-            send(meth){|r| (h[r[key_column]] ||= []) << r[value_column]}
+            public_send(meth){|r| (h[r[key_column]] ||= []) << r[value_column]}
           end
         end
       elsif key_column.is_a?(Array)
-        send(meth){|r| (h[key_column.map{|k| r[k]}] ||= []) << r}
+        public_send(meth){|r| (h[key_column.map{|k| r[k]}] ||= []) << r}
       else
-        send(meth){|r| (h[r[key_column]] ||= []) << r}
+        public_send(meth){|r| (h[r[key_column]] ||= []) << r}
       end
       h
     end
@@ -899,15 +846,14 @@ module Sequel
       execute_ddl(truncate_sql)
     end
 
-    # Updates values for the dataset.  The returned value is generally the
-    # number of rows updated, but that is adapter dependent. +values+ should
-    # a hash where the keys are columns to set and values are the values to
+    # Updates values for the dataset.  The returned value is the number of rows updated.
+    # +values+ should be a hash where the keys are columns to set and values are the values to
     # which to set the columns.
     #
-    #   DB[:table].update(:x=>nil) # UPDATE table SET x = NULL
+    #   DB[:table].update(x: nil) # UPDATE table SET x = NULL
     #   # => 10
     #
-    #   DB[:table].update(:x=>Sequel[:x]+1, :y=>0) # UPDATE table SET x = (x + 1), y = 0
+    #   DB[:table].update(x: Sequel[:x]+1, y: 0) # UPDATE table SET x = (x + 1), y = 0
     #   # => 10
     def update(values=OPTS, &block)
       sql = update_sql(values)
@@ -922,7 +868,7 @@ module Sequel
     # yielding each row to the given block.  Basically the same as where(cond).all(&block),
     # except it can be optimized to not create an intermediate dataset.
     #
-    #   DB[:table].where_all(:id=>[1,2,3])
+    #   DB[:table].where_all(id: [1,2,3])
     #   # SELECT * FROM table WHERE (id IN (1, 2, 3))
     def where_all(cond, &block)
       if loader = _where_loader
@@ -936,7 +882,7 @@ module Sequel
     # yielding each row to the given block.  Basically the same as where(cond).each(&block),
     # except it can be optimized to not create an intermediate dataset.
     #
-    #   DB[:table].where_each(:id=>[1,2,3]){|row| p row}
+    #   DB[:table].where_each(id: [1,2,3]){|row| p row}
     #   # SELECT * FROM table WHERE (id IN (1, 2, 3))
     def where_each(cond, &block)
       if loader = _where_loader
@@ -951,7 +897,7 @@ module Sequel
     # a single column.  Basically the same as where(cond).single_value,
     # except it can be optimized to not create an intermediate dataset.
     #
-    #   DB[:table].select(:name).where_single_value(:id=>1)
+    #   DB[:table].select(:name).where_single_value(id: 1)
     #   # SELECT name FROM table WHERE (id = 1) LIMIT 1
     def where_single_value(cond)
       if loader = cached_placeholder_literalizer(:_where_single_value_loader) do |pl|
@@ -1069,7 +1015,7 @@ module Sequel
     # Internals of +select_hash+ and +select_hash_groups+
     def _select_hash(meth, key_column, value_column, opts=OPTS)
       select(*(key_column.is_a?(Array) ? key_column : [key_column]) + (value_column.is_a?(Array) ? value_column : [value_column])).
-        send(meth, hash_key_symbols(key_column), hash_key_symbols(value_column), opts)
+        public_send(meth, hash_key_symbols(key_column), hash_key_symbols(value_column), opts)
     end
     
     # Internals of +select_map+ and +select_order_map+

data/lib/sequel/dataset/dataset_module.rb

@@ -17,20 +17,8 @@ module Sequel
     #   DB[:table].active.with_id_and_name.by_id
     #   # SELECT id, name FROM table WHERE active ORDER BY id
     class DatasetModule < ::Module
-      %w'where exclude exclude_having having'.map(&:to_sym).each do |meth|
-        define_method(meth) do |name, *args, &block|
-          if block || args.flatten.any?{|arg| arg.is_a?(Proc)}
-            define_method(name){send(meth, *args, &block)}
-          else
-            key = :"_#{meth}_#{name}_ds"
-            define_method(name) do
-              cached_dataset(key){send(meth, *args)}
-            end
-          end
-        end
-      end
-
       meths = (<<-METHS).split.map(&:to_sym)
+        where exclude exclude_having having
         distinct grep group group_and_count group_append 
         limit offset order order_append order_prepend 
         select select_all select_append select_group server
@@ -40,11 +28,11 @@ module Sequel
       def self.def_dataset_caching_method(mod, meth)
         mod.send(:define_method, meth) do |name, *args, &block|
           if block
-            define_method(name){send(meth, *args, &block)}
+            define_method(name){public_send(meth, *args, &block)}
           else
             key = :"_#{meth}_#{name}_ds"
             define_method(name) do
-              cached_dataset(key){send(meth, *args)}
+              cached_dataset(key){public_send(meth, *args)}
             end
           end
         end