sequel 5.8.0 → 5.38.0

data/lib/sequel/deprecated.rb

@@ -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 Sequel 5.1.  #{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
@@ -60,7 +60,9 @@ module Sequel
     # 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

data/lib/sequel/exceptions.rb

@@ -8,7 +8,9 @@ module Sequel
     # 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

data/lib/sequel/extensions/_pretty_table.rb

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

data/lib/sequel/extensions/caller_logging.rb

@@ -0,0 +1,79 @@
+# frozen-string-literal: true
+#
+# The caller_logging extension includes caller information before
+# query logging, showing which code caused the query.  It skips
+# internal Sequel code, showing the first non-Sequel caller line.
+#
+#   DB.extension :caller_logging
+#   DB[:table].first
+#   # Logger:
+#   # (0.000041s) (source: /path/to/app/foo/t.rb:12 in `get_first`) SELECT * FROM table LIMIT 1
+#
+# You can further filter the caller lines by setting
+# <tt>Database#caller_logging_ignore</tt> to a regexp of additional
+# caller lines to ignore.  This is useful if you have specific
+# methods or internal extensions/plugins that you would also
+# like to ignore as they obscure the code actually making the
+# request.
+#
+#   DB.caller_logging_ignore = %r{/path/to/app/lib/plugins}
+#
+# You can also format the caller before it is placed in the logger,
+# using +caller_logging_formatter+:
+#
+#   DB.caller_logging_formatter = lambda do |caller|
+#     "(#{caller.sub(/\A\/path\/to\/app\//, '')})"
+#   end
+#   DB[:table].first
+#   # Logger:
+#   # (0.000041s) (foo/t.rb:12 in `get_first`) SELECT * FROM table LIMIT 1
+#
+# Related module: Sequel::CallerLogging
+
+require 'rbconfig'
+
+#
+module Sequel
+  module CallerLogging
+    SEQUEL_LIB_PATH = (File.expand_path('../../..', __FILE__) + '/').freeze
+
+    # A regexp of caller lines to ignore, in addition to internal Sequel and Ruby code.
+    attr_accessor :caller_logging_ignore
+
+    # A callable to format the external caller
+    attr_accessor :caller_logging_formatter
+
+    # Include caller information when logging query.
+    def log_connection_yield(sql, conn, args=nil)
+      if !@loggers.empty? && (external_caller = external_caller_for_log)
+        sql = "#{external_caller} #{sql}"
+      end
+      super
+    end
+
+    private
+
+    # The caller to log, ignoring internal Sequel and Ruby code, and user specified
+    # lines to ignore.
+    def external_caller_for_log
+      ignore = caller_logging_ignore
+      c = caller.find do |line|
+        !(line.start_with?(SEQUEL_LIB_PATH) ||
+          line.start_with?(RbConfig::CONFIG["rubylibdir"]) ||
+          (ignore && line =~ ignore))
+      end
+
+      if c
+        c = if formatter = caller_logging_formatter
+          formatter.call(c)
+        else
+          "(source: #{c})"
+        end
+      end
+
+      c
+    end
+  end
+
+  Database.register_extension(:caller_logging, CallerLogging)
+end

data/lib/sequel/extensions/columns_introspection.rb

@@ -75,8 +75,7 @@ module Sequel
       when SQL::Identifier
         c.value.to_sym
       when SQL::QualifiedIdentifier
-        col = c.column
-        col.is_a?(SQL::Identifier) ? col.value.to_sym : col.to_sym
+        c.column.to_sym
       when SQL::AliasedExpression
         a = c.alias
         a.is_a?(SQL::Identifier) ? a.value.to_sym : a.to_sym

data/lib/sequel/extensions/connection_expiration.rb

@@ -32,6 +32,7 @@
 module Sequel
   module ConnectionExpiration
     class Retry < Error; end
+    Sequel::Deprecation.deprecate_constant(self, :Retry)
 
     # The number of seconds that need to pass since
     # connection creation before expiring a connection.
@@ -72,22 +73,21 @@ module Sequel
     # If it is expired, disconnect the connection, and retry with a new
     # connection.
     def acquire(*a)
-      begin
+      conn = nil
+      1.times do
         if (conn = super) &&
            (cet = sync{@connection_expiration_timestamps[conn]}) &&
            Sequel.elapsed_seconds_since(cet[0]) > cet[1]
 
           if pool_type == :sharded_threaded
-            sync{allocated(a.last).delete(Thread.current)}
+            sync{allocated(a.last).delete(Sequel.current)}
           else
-            sync{@allocated.delete(Thread.current)}
+            sync{@allocated.delete(Sequel.current)}
           end
 
           disconnect_connection(conn)
-          raise Retry
+          redo
         end
-      rescue Retry
-        retry
       end
 
       conn

data/lib/sequel/extensions/connection_validator.rb

@@ -51,6 +51,7 @@
 module Sequel
   module ConnectionValidator
     class Retry < Error; end
+    Sequel::Deprecation.deprecate_constant(self, :Retry)
 
     # The number of seconds that need to pass since
     # connection checkin before attempting to validate
@@ -94,23 +95,23 @@ module Sequel
     # test the connection for validity.  If it is not valid,
     # disconnect the connection, and retry with a new connection.
     def acquire(*a)
-      begin
+      conn = nil
+
+      1.times do
         if (conn = super) &&
            (timer = sync{@connection_timestamps.delete(conn)}) &&
            Sequel.elapsed_seconds_since(timer) > @connection_validation_timeout &&
            !db.valid_connection?(conn)
 
           if pool_type == :sharded_threaded
-            sync{allocated(a.last).delete(Thread.current)}
+            sync{allocated(a.last).delete(Sequel.current)}
           else
-            sync{@allocated.delete(Thread.current)}
+            sync{@allocated.delete(Sequel.current)}
           end
 
           disconnect_connection(conn)
-          raise Retry
+          redo
         end
-      rescue Retry
-        retry
       end
 
       conn

data/lib/sequel/extensions/constant_sql_override.rb

@@ -0,0 +1,65 @@
+# frozen-string-literal: true
+#
+# The constant_sql_override extension allows you to change the SQL
+# generated for Sequel constants.
+#
+# One possible use-case for this is to have Sequel::CURRENT_TIMESTAMP use UTC time when
+# you have Sequel.database_timezone = :utc, but the database uses localtime when
+# generating CURRENT_TIMESTAMP.
+#
+# You can set SQL overrides with Database#set_constant_sql:
+#
+#   DB.set_constant_sql(Sequel::CURRENT_TIMESTAMP, "CURRENT_TIMESTAMP AT TIME ZONE 'UTC'")
+#
+# Now, using Sequel::CURRENT_TIMESTAMP will use your override instead:
+#
+#   Album.where(released_at: Sequel::CURRENT_TIMESTAMP).sql
+#   # => SELECT "albums.*" FROM "albums" WHERE ("released_at" = CURRENT_TIMESTAMP AT TIME ZONE 'UTC')
+#
+# To use this extension, first load it into your Sequel::Database instance:
+#
+#   DB.extension :constant_sql_override
+#
+# Related module: Sequel::ConstantSqlOverride
+
+#
+module Sequel
+  module ConstantSqlOverride
+    module DatabaseMethods
+      # Create the initial empty hash of constant sql overrides.
+      def self.extended(db)
+        db.instance_exec do
+          @constant_sqls ||= {}
+          extend_datasets(DatasetMethods)
+        end
+      end
+
+      # Hash mapping constant symbols to SQL.  For internal use only.
+      attr_reader :constant_sqls # :nodoc:
+
+      # Set the SQL to use for the given Sequel::SQL::Constant
+      def set_constant_sql(constant, override)
+        @constant_sqls[constant.constant] = override
+      end
+
+      # Freeze the constant_sqls hash to prevent adding new overrides.
+      def freeze
+        @constant_sqls.freeze
+        super
+      end
+    end
+
+    module DatasetMethods
+      # Use overridden constant SQL
+      def constant_sql_append(sql, constant)
+        if constant_sql = db.constant_sqls[constant]
+          sql << constant_sql
+        else
+          super
+        end
+      end
+    end
+  end
+
+  Database.register_extension(:constant_sql_override, ConstantSqlOverride::DatabaseMethods)
+end

data/lib/sequel/extensions/constraint_validations.rb

@@ -130,6 +130,10 @@
 #   readd all constraints you want to use inside the alter table block,
 #   making no other changes inside the alter_table block.
 #
+# Dropping a table will automatically delete all constraint validations for
+# that table.  However, altering a table (e.g. to drop a column) will not
+# currently make any changes to the constraint validations metadata.
+#
 # Related module: Sequel::ConstraintValidations
 
 #
@@ -264,6 +268,16 @@ module Sequel
       end
     end
 
+    # Drop all constraint validations for a table if dropping the table.
+    def drop_table(*names)
+      names.each do |name|
+        if !name.is_a?(Hash) && table_exists?(constraint_validations_table)
+          drop_constraint_validations_for(:table=>name)
+        end
+      end
+      super
+    end
+
     # Drop the constraint validations table.
     def drop_constraint_validations_table
       drop_table(constraint_validations_table)
@@ -355,6 +369,18 @@ module Sequel
       super
     end
 
+    def constraint_validation_expression(cols, allow_nil)
+      exprs = cols.map do |c|
+        expr = yield c
+        if allow_nil
+          Sequel.|({c=>nil}, expr)
+        else
+          Sequel.&(Sequel.~(c=>nil), expr)
+        end
+      end
+      Sequel.&(*exprs)
+    end
+
     # For the given table, generator, and validations, add constraints
     # to the generator for each of the validations, as well as adding
     # validation metadata to the constraint validations table.
@@ -365,28 +391,44 @@ module Sequel
 
         case validation_type
         when :presence
-          string_check = columns.select{|c| generator_string_column?(generator, table, c)}.map{|c| [Sequel.trim(c), blank_string_value]}
-          generator_add_constraint_from_validation(generator, val, (Sequel.negate(string_check) unless string_check.empty?))
+          strings, non_strings = columns.partition{|c| generator_string_column?(generator, table, c)}
+          if !non_strings.empty? && !allow_nil
+            non_strings_expr = Sequel.&(*non_strings.map{|c| Sequel.~(c=>nil)})
+          end
+
+          unless strings.empty?
+            strings_expr = constraint_validation_expression(strings, allow_nil){|c| Sequel.~(Sequel.trim(c) => blank_string_value)}
+          end
+
+          expr = if non_strings_expr && strings_expr
+            Sequel.&(strings_expr, non_strings_expr)
+          else
+            strings_expr || non_strings_expr
+          end
+
+          if expr
+            generator.constraint(constraint, expr)
+          end
         when :exact_length
-          generator_add_constraint_from_validation(generator, val, Sequel.&(*columns.map{|c| {Sequel.char_length(c) => arg}}))
+          generator.constraint(constraint, constraint_validation_expression(columns, allow_nil){|c| {Sequel.char_length(c) => arg}})
         when :min_length
-          generator_add_constraint_from_validation(generator, val, Sequel.&(*columns.map{|c| Sequel.char_length(c) >= arg}))
+          generator.constraint(constraint, constraint_validation_expression(columns, allow_nil){|c| Sequel.char_length(c) >= arg})
         when :max_length
-          generator_add_constraint_from_validation(generator, val, Sequel.&(*columns.map{|c| Sequel.char_length(c) <= arg}))
+          generator.constraint(constraint, constraint_validation_expression(columns, allow_nil){|c| Sequel.char_length(c) <= arg})
         when *REVERSE_OPERATOR_MAP.keys
-          generator_add_constraint_from_validation(generator, val, Sequel.&(*columns.map{|c| Sequel.identifier(c).public_send(REVERSE_OPERATOR_MAP[validation_type], arg)}))
+          generator.constraint(constraint, constraint_validation_expression(columns, allow_nil){|c| Sequel.identifier(c).public_send(REVERSE_OPERATOR_MAP[validation_type], arg)})
         when :length_range
           op = arg.exclude_end? ? :< : :<=
-          generator_add_constraint_from_validation(generator, val, Sequel.&(*columns.map{|c| (Sequel.char_length(c) >= arg.begin) & Sequel.char_length(c).public_send(op, arg.end)}))
+          generator.constraint(constraint, constraint_validation_expression(columns, allow_nil){|c| (Sequel.char_length(c) >= arg.begin) & Sequel.char_length(c).public_send(op, arg.end)})
           arg = "#{arg.begin}..#{'.' if arg.exclude_end?}#{arg.end}"
         when :format
-          generator_add_constraint_from_validation(generator, val, Sequel.&(*columns.map{|c| {c => arg}}))
+          generator.constraint(constraint, constraint_validation_expression(columns, allow_nil){|c| {c => arg}})
           if arg.casefold?
             validation_type = :iformat
           end
           arg = arg.source
         when :includes
-          generator_add_constraint_from_validation(generator, val, Sequel.&(*columns.map{|c| {c => arg}}))
+          generator.constraint(constraint, constraint_validation_expression(columns, allow_nil){|c| {c => arg}})
           if arg.is_a?(Range)
             if arg.begin.is_a?(Integer) && arg.end.is_a?(Integer)
               validation_type = :includes_int_range
@@ -407,7 +449,7 @@ module Sequel
             raise Error, "validates includes only supports arrays and ranges currently, cannot handle: #{arg.inspect}"
           end
         when :like, :ilike
-          generator_add_constraint_from_validation(generator, val, Sequel.&(*columns.map{|c| Sequel.public_send(validation_type, c, arg)}))
+          generator.constraint(constraint, constraint_validation_expression(columns, allow_nil){|c| Sequel.public_send(validation_type, c, arg)})
         when :unique
           generator.unique(columns, :name=>constraint)
           columns = [columns.join(',')]
@@ -431,30 +473,13 @@ module Sequel
         end
       end
 
-      ds = from(:sequel_constraint_validations)
+      ds = from(constraint_validations_table)
       unless drop_rows.empty?
         ds.where([:table, :constraint_name]=>drop_rows).delete
       end
       ds.multi_insert(rows.flatten)
     end
 
-    # Add the constraint to the generator, including a NOT NULL constraint
-    # for all columns unless the :allow_nil option is given.
-    def generator_add_constraint_from_validation(generator, val, cons)
-      if val[:allow_nil]
-        nil_cons = Sequel[val[:columns].map{|c| [c, nil]}]
-        cons = Sequel.|(nil_cons, cons) if cons
-      else
-        nil_cons = Sequel.negate(val[:columns].map{|c| [c, nil]})
-        cons = cons ? Sequel.&(nil_cons, cons) : nil_cons
-      end
-
-      if cons
-        generator.constraint(val[:name], cons)
-      end
-    end
-
-
     # Introspect the generator to determine if column
     # created is a string or not.
     def generator_string_column?(generator, table, c)