sequel 4.26.0 → 5.37.0

data/lib/sequel/deprecated.rb

@@ -1,3 +1,5 @@
+# frozen-string-literal: true
+
 module Sequel
   # This module makes it easy to print deprecation warnings with optional backtraces to a given stream.
   # There are a two accessors you can use to change how/where the deprecation methods are printed
@@ -18,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
@@ -37,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
@@ -54,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

@@ -1,3 +1,5 @@
+# frozen-string-literal: true
+
 module Sequel
   # The default exception class for exceptions raised by Sequel.
   # All exception classes defined by Sequel are descendants of this class.
@@ -5,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.
@@ -67,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

@@ -1,3 +1,5 @@
+# frozen-string-literal: true
+#
 # This _pretty_table extension is only for internal use.
 # It adds the Sequel::PrettyTable class without modifying 
 # Sequel::Dataset.
@@ -5,6 +7,8 @@
 # To load the extension:
 #
 #   Sequel.extension :_pretty_table
+#
+# Related module: Sequel::PrettyTable
 
 #
 module Sequel
@@ -23,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)
 
@@ -33,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|
@@ -53,13 +54,13 @@ module Sequel
     
     # String for each data line
     def self.data_line(columns, sizes, record) # :nodoc:
-      '|' << columns.map {|c| format_cell(sizes[c], record[c])}.join('|') << '|'
+      String.new << '|' << columns.map {|c| format_cell(sizes[c], record[c])}.join('|') << '|'
     end
     
     # Format the value so it takes up exactly size characters
     def self.format_cell(size, v) # :nodoc:
       case v
-      when Bignum, Fixnum
+      when Integer
         "%#{size}d" % v
       when Float, BigDecimal
         "%#{size}g" % v
@@ -70,12 +71,12 @@ module Sequel
     
     # String for header line
     def self.header_line(columns, sizes) # :nodoc:
-      '|' << columns.map {|c| "%-#{sizes[c]}s" % c.to_s}.join('|') << '|'
+      String.new << '|' << columns.map {|c| "%-#{sizes[c]}s" % c.to_s}.join('|') << '|'
     end
 
     # String for separtor line
     def self.separator_line(columns, sizes) # :nodoc:
-      '+' << columns.map {|c| '-' * sizes[c]}.join('+') << '+'
+      String.new << '+' << columns.map {|c| '-' * sizes[c]}.join('+') << '+'
     end
 
     private_class_method :column_sizes, :data_line, :format_cell, :header_line, :separator_line

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 block_given?
+        super
+      else
+        !empty?
+      end
+    end
+  end
+
+  Dataset.register_extension(:any_not_empty, AnyNotEmpty)
+end

data/lib/sequel/extensions/arbitrary_servers.rb

@@ -1,3 +1,5 @@
+# frozen-string-literal: true
+#
 # The arbitrary_servers extension allows you to connect to arbitrary
 # servers/shards that were not defined when you created the database.
 # To use it, you first load the extension into the Database object:
@@ -7,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
@@ -44,14 +46,16 @@
 # 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
 # pool.  If you are using the sharded single connection pool, you need
 # to switch to the sharded threaded connection pool before using this
 # extension.
+#
+# Related module: Sequel::ArbitraryServers
 
 #
 module Sequel
@@ -98,7 +102,7 @@ module Sequel
         a = @allocated[thread]
         a.delete(server)
         @allocated.delete(thread) if a.empty?
-        db.disconnect_connection(conn)
+        disconnect_connection(conn)
       else  
         super
       end

data/lib/sequel/extensions/auto_literal_strings.rb

@@ -0,0 +1,74 @@
+# frozen-string-literal: true
+#
+# The auto_literal_strings extension treats string values passed as filter
+# arguments as SQL query fragments.  This is the behavior of previous
+# versions of Sequel.  Using this extension makes using raw SQL fragments
+# easier, since you don't need to wrap them with Sequel.lit, but also makes
+# it easier to introduce SQL injection vulnerabilities into the application.
+# It is only recommended to use this extension for
+# backwards compatibility with previous versions of Sequel.
+#
+# With this extension, if a single string is given, it is used as an SQL
+# query fragment:
+#
+#   ds = DB[:table].extension(:auto_literal_strings)
+#   ds.where("name > 'A'")
+#   # SELECT * FROM table WHERE (name > 'A')
+#
+# If additional arguments are given, they are used as placeholders:
+#
+#   ds.where("name > ?", "A")
+#   # SELECT * FROM table WHERE (name > 'A')
+#
+# Named placeholders can also be used with a hash:
+#
+#   ds.where("name > :a", :a=>"A")
+#   # SELECT * FROM table WHERE (name > 'A')
+#
+# This extension also allows the use of a plain string passed to Dataset#update:
+#
+#   ds.update("column = column + 1")
+#   # UPDATE table SET column = column + 1
+#
+# Related module: Sequel::Dataset::AutoLiteralStrings
+
+#
+module Sequel
+  class Dataset
+    module AutoLiteralStrings
+      # Treat plain strings as literal strings, and arrays where the first element
+      # is a string as a literal string with placeholders.
+      def filter_expr(expr = nil)
+        case expr
+        when LiteralString
+          super
+        when String
+          super(LiteralString.new(expr))
+        when Array
+          if (sexpr = expr.first).is_a?(String)
+            super(SQL::PlaceholderLiteralString.new(sexpr, expr[1..-1], true))
+          else
+            super
+          end
+        else
+          super
+        end
+      end
+
+      # Treat plain strings as literal strings.
+      def update_sql(values=OPTS)
+        case values
+        when LiteralString
+          super
+        when String
+          super(LiteralString.new(values))
+        else
+          super
+        end
+      end
+    end
+
+    register_extension(:auto_literal_strings, AutoLiteralStrings)
+  end
+end
+