sequel 4.36.0 → 5.61.0

data/lib/sequel/dataset.rb

@@ -1,32 +1,38 @@
 # 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].filter(: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.filter(:author => 'david')
-  #   old_posts = posts.filter('stamp < ?', Date.today - 7)
-  #   davids_old_posts = davids_posts.filter('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.
+  # Datasets are Enumerable objects, so they can be manipulated using many
+  # of the Enumerable methods, such as +map+ and +inject+.  Note that there are some methods
+  # that Dataset defines that override methods defined in Enumerable and result in different
+  # behavior, such as +select+ and +group_by+.
   #
   # For more information, see the {"Dataset Basics" guide}[rdoc-ref:doc/dataset_basics.rdoc].
   class Dataset
     OPTS = Sequel::OPTS
 
+    # Whether Dataset#freeze can actually freeze datasets.  True only on ruby 2.4+,
+    # as it requires clone(freeze: false)
+    TRUE_FREEZE = RUBY_VERSION >= '2.4'
+
     include Enumerable
     include SQL::AliasMethods
     include SQL::BooleanMethods
@@ -36,11 +42,15 @@ module Sequel
     include SQL::NumericMethods
     include SQL::OrderMethods
     include SQL::StringMethods
-
-    private
-
-    attr_writer :columns
   end
   
-  require(%w"query actions features graph prepared_statements misc mutation sql placeholder_literalizer", '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/deprecated.rb

@@ -20,7 +20,7 @@ module Sequel
   module Deprecation
     @backtrace_filter = 10
     @output = $stderr
-    @prefix = "SEQUEL DEPRECATION WARNING: "
+    @prefix = "SEQUEL DEPRECATION WARNING: ".freeze
 
     class << self
       # How to filter backtraces.  +false+ does not include backtraces, +true+ includes
@@ -39,7 +39,7 @@ module Sequel
     # Print the message and possibly backtrace to the output.
     def self.deprecate(method, instead=nil)
       return unless output
-      message = instead ? "#{method} is deprecated and will be removed in a future version of Sequel.  #{instead}." : method
+      message = instead ? "#{method} is deprecated and will be removed in Sequel 6.  #{instead}." : method
       message = "#{prefix}#{message}" if prefix
       output.puts(message)
       case b = backtrace_filter
@@ -56,5 +56,15 @@ module Sequel
       end
       nil
     end
+
+    # If using ruby 2.3+, use Module#deprecate_constant to deprecate the constant,
+    # otherwise do nothing as the ruby implementation does not support constant deprecation.
+    def self.deprecate_constant(mod, constant)
+      # :nocov:
+      if RUBY_VERSION > '2.3'
+      # :nocov:
+        mod.deprecate_constant(constant)
+      end
+    end
   end
 end

data/lib/sequel/exceptions.rb

@@ -7,50 +7,91 @@ module Sequel
     # If this exception wraps an underlying exception, the underlying
     # exception is held here.
     attr_accessor :wrapped_exception
+
+    # :nocov:
+    if RUBY_VERSION >= '2.1'
+    # :nocov:
+      # Returned the wrapped exception if one exists, otherwise use
+      # ruby's default behavior.
+      def cause
+        wrapped_exception || super
+      end
+    end
   end  
     
+  (
   # Error raised when the adapter requested doesn't exist or can't be loaded.
   AdapterNotFound = Class.new(Error)
+  ).name
 
+  (
   # Generic error raised by the database adapters, indicating a
   # problem originating from the database server.  Usually raised
   # because incorrect SQL syntax is used.
   DatabaseError = Class.new(Error)
+  ).name
   
+  (
   # Error raised when the Sequel is unable to connect to the database with the
   # connection parameters it was given.
   DatabaseConnectionError = Class.new(DatabaseError)
+  ).name
 
+  (
   # Error raised by adapters when they determine that the connection
   # to the database has been lost.  Instructs the connection pool code to 
   # remove that connection from the pool so that other connections can be acquired
   # automatically.
   DatabaseDisconnectError = Class.new(DatabaseError)
+  ).name
 
+  (
   # Generic error raised when Sequel determines a database constraint has been violated.
   ConstraintViolation = Class.new(DatabaseError)
+  ).name
 
+  (
   # Error raised when Sequel determines a database check constraint has been violated.
   CheckConstraintViolation = Class.new(ConstraintViolation)
+  ).name
 
+  (
   # Error raised when Sequel determines a database foreign key constraint has been violated.
   ForeignKeyConstraintViolation = Class.new(ConstraintViolation)
+  ).name
 
+  (
   # Error raised when Sequel determines a database NOT NULL constraint has been violated.
   NotNullConstraintViolation = Class.new(ConstraintViolation)
+  ).name
 
+  (
   # Error raised when Sequel determines a database unique constraint has been violated.
   UniqueConstraintViolation = Class.new(ConstraintViolation)
+  ).name
 
+  (
   # Error raised when Sequel determines a serialization failure/deadlock in the database.
   SerializationFailure = Class.new(DatabaseError)
+  ).name
+
+  (
+  # Error raised when Sequel determines the database could not acquire a necessary lock
+  # before timing out. Use of Dataset#nowait can often cause this exception when
+  # retrieving rows.
+  DatabaseLockTimeout = Class.new(DatabaseError)
+  ).name
 
+  (
   # Error raised on an invalid operation, such as trying to update or delete
-  # a joined or grouped dataset.
+  # a joined or grouped dataset when the database does not support that.
   InvalidOperation = Class.new(Error)
+  ).name
 
+  (
   # Error raised when attempting an invalid type conversion.
   InvalidValue = Class.new(Error)
+  ).name
 
   # Error raised when the user requests a record via the first! or similar
   # method, and the dataset does not yield any rows.
@@ -69,27 +110,16 @@ module Sequel
     end
   end
 
+  (
   # Error raised when the connection pool cannot acquire a database connection
   # before the timeout.
   PoolTimeout = Class.new(Error)
+  ).name
 
+  (
   # Error that you should raise to signal a rollback of the current transaction.
   # The transaction block will catch this exception, rollback the current transaction,
   # and won't reraise it (unless a reraise is requested).
   Rollback = Class.new(Error)
-
-  # Error raised when unbinding a dataset that has multiple different values
-  # for a given variable.
-  UnbindDuplicate = Class.new(Error)
-
-  # Call name on each class to set the name for the class, so it gets cached.
-  constants.map{|c| const_get(c)}.each do |c|
-    Class === c && c.name
-  end
-
-  Error::AdapterNotFound = AdapterNotFound
-  Error::InvalidOperation = InvalidOperation
-  Error::InvalidValue = InvalidValue
-  Error::PoolTimeoutError = PoolTimeout
-  Error::Rollback = Rollback
+  ).name
 end

data/lib/sequel/extensions/_model_constraint_validations.rb

@@ -0,0 +1,16 @@
+# frozen-string-literal: true
+
+module Sequel
+  module Plugins
+    module ConstraintValidations
+      module DatabaseMethods
+        # A hash of validation method call metadata for all tables in the database.
+        # The hash is keyed by table name string and contains arrays of validation
+        # method call arrays.
+        attr_accessor :constraint_validations
+      end
+    end
+  end
+
+  Database.register_extension(:_model_constraint_validations, Plugins::ConstraintValidations::DatabaseMethods)
+end

data/lib/sequel/extensions/_model_pg_row.rb

@@ -0,0 +1,43 @@
+# frozen-string-literal: true
+
+module Sequel
+  module Plugins
+    module PgRow
+      module DatabaseMethods
+        # Handle Sequel::Model instances in bound variables.
+        def bound_variable_arg(arg, conn)
+          case arg
+          when Sequel::Model
+            "(#{arg.values.values_at(*arg.columns).map{|v| bound_variable_array(v)}.join(',')})"
+          else
+            super
+          end
+        end
+
+        # If a Sequel::Model instance is given, return it as-is
+        # instead of attempting to convert it.
+        def row_type(db_type, v)
+          if v.is_a?(Sequel::Model)
+            v
+          else
+            super
+          end
+        end
+
+        private
+
+        # Handle Sequel::Model instances in bound variable arrays.
+        def bound_variable_array(arg)
+          case arg
+          when Sequel::Model
+            "\"(#{arg.values.values_at(*arg.columns).map{|v| bound_variable_array(v)}.join(',').gsub(/("|\\)/, '\\\\\1')})\""
+          else
+            super
+          end
+        end
+      end
+    end
+  end
+
+  Database.register_extension(:_model_pg_row, Plugins::PgRow::DatabaseMethods)
+end

data/lib/sequel/extensions/_pretty_table.rb

@@ -27,7 +27,7 @@ module Sequel
 
     # Return the string that #print will print via puts.
     def self.string(records, columns = nil) # records is an array of hashes
-      columns ||= records.first.keys.sort_by(&:to_s)
+      columns ||= records.first.keys.sort
       sizes = column_sizes(records, columns)
       sep_line = separator_line(columns, sizes)
 
@@ -37,14 +37,11 @@ module Sequel
       array.join("\n")
     end
 
-    ### Private Module Methods ###
-
     # Hash of the maximum size of the value for each column 
     def self.column_sizes(records, columns) # :nodoc:
       sizes = Hash.new {0}
       columns.each do |c|
-        s = c.to_s.size
-        sizes[c] = s if s > sizes[c]
+        sizes[c] = c.to_s.size
       end
       records.each do |r|
         columns.each do |c|

data/lib/sequel/extensions/any_not_empty.rb

@@ -0,0 +1,45 @@
+# frozen-string-literal: true
+#
+# The any_not_empty extension changes the behavior of Dataset#any?
+# if called without a block.  By default, this method uses the
+# standard Enumerable behavior of enumerating results and seeing
+# if any result is not false or nil.  With this extension, it
+# just checks whether the dataset is empty.  This approach can
+# be much faster if the dataset is currently large.
+#
+#   DB[:table].any?
+#   # SELECT * FROM table
+#
+#   DB[:table].extension(:any_not_empty).any?
+#   # SELECT 1 as one FROM table LIMIT 1
+#   
+# You can load this extension into specific datasets:
+#
+#   ds = DB[:table]
+#   ds = ds.extension(:any_not_empty)
+#
+# Or you can load it into all of a database's datasets, which
+# is probably the desired behavior if you are using this extension:
+#
+#   DB.extension(:any_not_empty)
+#
+# Note that this can result in any? returning a different result if
+# the dataset has a row_proc that can return false or nil.
+#
+# Related module: Sequel::AnyNotEmpty
+
+#
+module Sequel
+  module AnyNotEmpty
+    # If a block is not given, return whether the dataset is not empty.
+    def any?
+      if defined?(yield)
+        super
+      else
+        !empty?
+      end
+    end
+  end
+
+  Dataset.register_extension(:any_not_empty, AnyNotEmpty)
+end

data/lib/sequel/extensions/arbitrary_servers.rb

@@ -9,34 +9,34 @@
 # Then you can pass arbitrary connection options for the server/shard
 # to use as a hash:
 #
-#   DB[:table].server(:host=>'...', :database=>'...').all
+#   DB[:table].server(host: '...', database: '...').all
 #
 # Because Sequel can never be sure that the connection will be reused,
 # arbitrary connections are disconnected as soon as the outermost block
 # that uses them exits.  So this example uses the same connection:
 #
-#   DB.transaction(:server=>{:host=>'...', :database=>'...'}) do |c|
-#     DB.transaction(:server=>{:host=>'...', :database=>'...'}) do |c2|
+#   DB.transaction(server: {host: '...', database: '...'}) do |c|
+#     DB.transaction(server: {host: '...', database: '...'}) do |c2|
 #       # c == c2
 #     end
 #   end
 #
 # But this example does not:
 #
-#   DB.transaction(:server=>{:host=>'...', :database=>'...'}) do |c|
+#   DB.transaction(server: {host: '...', database: '...'}) do |c|
 #   end
-#   DB.transaction(:server=>{:host=>'...', :database=>'...'}) do |c2|
+#   DB.transaction(server: {host: '...', database: '...'}) do |c2|
 #     # c != c2
 #   end
 #
 # You can use this extension in conjunction with the server_block
 # extension:
 #
-#   DB.with_server(:host=>'...', :database=>'...') do
+#   DB.with_server(host: '...', database: '...') do
 #     DB.synchronize do
 #       # All of these use the host/database given to with_server
-#       DB[:table].insert(:c=>1)
-#       DB[:table].update(:c=>2)
+#       DB[:table].insert(c: 1)
+#       DB[:table].update(c: 2)
 #       DB.tables
 #       DB[:table].all
 #     end
@@ -46,8 +46,8 @@
 # extension may want to do the following to so that you don't need
 # to call synchronize separately:
 #
-#   def DB.with_server(*)
-#     super{synchronize{yield}}
+#   def DB.with_server(*a)
+#     super(*a){synchronize{yield}}
 #   end
 #
 # Note that this extension only works with the sharded threaded connection