sequel 5.36.0 → 5.41.0

data/lib/sequel/dataset/sql.rb

@@ -22,7 +22,7 @@ module Sequel
     def insert_sql(*values)
       return static_sql(@opts[:sql]) if @opts[:sql]
 
-      check_modification_allowed!
+      check_insert_allowed!
 
       columns = []
 
@@ -172,7 +172,7 @@ module Sequel
     # than one table.
     def update_sql(values = OPTS)
       return static_sql(opts[:sql]) if opts[:sql]
-      check_modification_allowed!
+      check_update_allowed!
       check_not_limited!(:update)
 
       case values
@@ -215,7 +215,7 @@ module Sequel
       lines << "def #{'_' if priv}#{type}_sql"
       lines << 'if sql = opts[:sql]; return static_sql(sql) end' unless priv
       lines << "if sql = cache_get(:_#{type}_sql); return sql end" if cacheable
-      lines << 'check_modification_allowed!' << 'check_not_limited!(:delete)' if type == :delete
+      lines << 'check_delete_allowed!' << 'check_not_limited!(:delete)' if type == :delete
       lines << 'sql = @opts[:append_sql] || sql_string_origin'
 
       if clauses.all?{|c| c.is_a?(Array)}
@@ -918,10 +918,35 @@ module Sequel
       !@opts[:no_cache_sql] && !cache_get(:_no_cache_sql)
     end
 
-    # Raise an InvalidOperation exception if deletion is not allowed for this dataset.
+    # Raise an InvalidOperation exception if modification is not allowed for this dataset.
+    # Check whether it is allowed to insert into this dataset.
+    # Only for backwards compatibility with older external adapters.
     def check_modification_allowed!
+      # SEQUEL6: Remove
+      Sequel::Deprecation.deprecate("Dataset#check_modification_allowed!", "Use check_{insert,delete,update,truncation}_allowed! instead")
+      _check_modification_allowed!(supports_modifying_joins?)
+    end
+
+    # Check whether it is allowed to insert into this dataset.
+    def check_insert_allowed!
+      _check_modification_allowed!(false)
+    end
+    alias check_truncation_allowed! check_insert_allowed!
+
+    # Check whether it is allowed to delete from this dataset.
+    def check_delete_allowed!
+      _check_modification_allowed!(supports_deleting_joins?)
+    end
+
+    # Check whether it is allowed to update this dataset.
+    def check_update_allowed!
+      _check_modification_allowed!(supports_updating_joins?)
+    end
+
+    # Internals of the check_*_allowed! methods
+    def _check_modification_allowed!(modifying_joins_supported)
       raise(InvalidOperation, "Grouped datasets cannot be modified") if opts[:group]
-      raise(InvalidOperation, "Joined datasets cannot be modified") if !supports_modifying_joins? && joined_dataset?
+      raise(InvalidOperation, "Joined datasets cannot be modified") if !modifying_joins_supported && joined_dataset?
     end
 
     # Raise error if the dataset uses limits or offsets.
@@ -930,11 +955,6 @@ module Sequel
       raise InvalidOperation, "Dataset##{type} not supported on datasets with limits or offsets" if opts[:limit] || opts[:offset]
     end
 
-    # Alias of check_modification_allowed!
-    def check_truncation_allowed!
-      check_modification_allowed!
-    end
-
     # Append column list to SQL string.
     # If the column list is empty, a wildcard (*) is appended.
     def column_list_append(sql, columns)
@@ -971,7 +991,9 @@ module Sequel
     # operators unsupported by some databases. Used by adapters for databases
     # that don't support the operators natively.
     def complex_expression_emulate_append(sql, op, args)
+      # :nocov:
       case op
+      # :nocov:
       when :%
         complex_expression_arg_pairs_append(sql, args){|a, b| Sequel.function(:MOD, a, b)}
       when :>>

data/lib/sequel/extensions/blank.rb

@@ -6,6 +6,14 @@
 #
 #   Sequel.extension :blank
 
+[FalseClass, Object, NilClass, Numeric, String, TrueClass].each do |klass|
+  # :nocov:
+  if klass.method_defined?(:blank?)
+    klass.send(:alias_method, :blank?, :blank?)
+  end
+  # :nocov:
+end
+
 class FalseClass
   # false is always blank
   def blank?

data/lib/sequel/extensions/date_arithmetic.rb

@@ -49,14 +49,13 @@ module Sequel
       # Options:
       # :cast :: Cast to the specified type instead of the default if casting
       def date_sub(expr, interval, opts=OPTS)
-        interval = if interval.is_a?(Hash)
-          h = {}
-          interval.each{|k,v| h[k] = -v unless v.nil?}
-          h
-        else
-          -interval
+        if defined?(ActiveSupport::Duration) && interval.is_a?(ActiveSupport::Duration)
+          interval = interval.parts
         end
-        DateAdd.new(expr, interval, opts)
+        parts = {}
+        interval.each{|k,v| parts[k] = -v unless v.nil?}
+        parts
+        DateAdd.new(expr, parts, opts)
       end
     end
 
@@ -113,12 +112,12 @@ module Sequel
             end
           when :mssql, :h2, :access, :sqlanywhere
             units = case db_type
-            when :mssql, :sqlanywhere
-              MSSQL_DURATION_UNITS
             when :h2
               H2_DURATION_UNITS
             when :access
               ACCESS_DURATION_UNITS
+            else
+              MSSQL_DURATION_UNITS
             end
             each_valid_interval_unit(h, units) do |value, sql_unit|
               expr = Sequel.function(:DATEADD, sql_unit, value, expr)

data/lib/sequel/extensions/eval_inspect.rb

@@ -55,6 +55,8 @@ module Sequel
 
   module SQL
     class Expression
+      alias inspect inspect
+
       # Attempt to produce a string suitable for eval, such that:
       #
       #   eval(obj.inspect) == obj

data/lib/sequel/extensions/inflector.rb

@@ -105,6 +105,14 @@ class String
     yield Inflections if block_given?
     Inflections
   end
+  
+  %w'classify constantize dasherize demodulize foreign_key humanize pluralize singularize tableize underscore'.each do |m|
+    # :nocov:
+    if method_defined?(m)
+      alias_method(m, m)
+    end
+    # :nocov:
+  end
 
   # By default, camelize converts the string to UpperCamelCase. If the argument to camelize
   # is set to :lower then camelize produces lowerCamelCase.

data/lib/sequel/extensions/migration.rb

@@ -68,7 +68,9 @@ module Sequel
       # Allow calling private methods for backwards compatibility
       @db.send(method_sym, *args, &block)
     end
+    # :nocov:
     ruby2_keywords(:method_missing) if respond_to?(:ruby2_keywords, true)
+    # :nocov:
 
     # This object responds to all methods the database responds to.
     def respond_to_missing?(meth, include_private)
@@ -330,7 +332,8 @@ module Sequel
   # schema_migrations for timestamped migrations). in the database to keep track
   # of the current migration version. If no migration version is stored in the
   # database, the version is considered to be 0. If no target version is 
-  # specified, the database is migrated to the latest version available in the
+  # specified, or the target version specified is greater than the latest
+  # version available, the database is migrated to the latest version available in the
   # migration directory.
   #
   # For example, to migrate the database to the latest version:
@@ -538,6 +541,11 @@ module Sequel
       end
 
       @direction = current < target ? :up : :down
+
+      if @direction == :down && @current >= @files.length
+        raise Migrator::Error, "Missing migration version(s) needed to migrate down to target version (current: #{current}, target: #{target})"
+      end
+
       @migrations = get_migrations
     end
 

data/lib/sequel/extensions/named_timezones.rb

@@ -84,9 +84,9 @@ module Sequel
       def convert_output_time_other(v, output_timezone)
         Time.at(v.to_i, :in => output_timezone)
       end
-    else
       # :nodoc:
       # :nocov:
+    else
       def convert_input_time_other(v, input_timezone)
         local_offset = input_timezone.period_for_local(v, &tzinfo_disambiguator_for(v)).utc_total_offset
         Time.new(1970, 1, 1, 0, 0, 0, local_offset) + v.to_i
@@ -105,6 +105,8 @@ module Sequel
           Time.new(1970, 1, 1, 0, 0, 0, local_offset) + v.to_i
         end
       end
+      # :nodoc:
+      # :nocov:
     end
 
     # Handle both TZInfo 1 and TZInfo 2
@@ -142,6 +144,8 @@ module Sequel
         # Convert timezone offset from UTC to the offset for the output_timezone
         (v - local_offset).new_offset(local_offset)
       end
+      # :nodoc:
+      # :nocov:
     end
     
     # Returns TZInfo::Timezone instance if given a String.

data/lib/sequel/extensions/pg_array.rb

@@ -213,6 +213,7 @@ module Sequel
             scalar_typecast_method = :"typecast_value_#{opts.fetch(:scalar_typecast, type)}"
             define_method(meth){|v| typecast_value_pg_array(v, creator, scalar_typecast_method)}
             private meth
+            alias_method(meth, meth)
           end
 
           @schema_type_classes[:"#{type}_array"] = PGArray

data/lib/sequel/extensions/pg_interval.rb

@@ -34,6 +34,13 @@
 
 require 'active_support/duration'
 
+# :nocov:
+begin
+  require 'active_support/version'
+rescue LoadError
+end
+# :nocov:
+
 module Sequel
   module Postgres
     module IntervalDatabaseMethods
@@ -61,34 +68,47 @@ module Sequel
 
       # Creates callable objects that convert strings into ActiveSupport::Duration instances.
       class Parser
+        # Whether ActiveSupport::Duration.new takes parts as array instead of hash
+        USE_PARTS_ARRAY = !defined?(ActiveSupport::VERSION::STRING) || ActiveSupport::VERSION::STRING < '5.1'
+
+        if defined?(ActiveSupport::Duration::SECONDS_PER_MONTH)
+          SECONDS_PER_MONTH = ActiveSupport::Duration::SECONDS_PER_MONTH
+          SECONDS_PER_YEAR = ActiveSupport::Duration::SECONDS_PER_YEAR
+        # :nocov:
+        else
+          SECONDS_PER_MONTH = 2592000
+          SECONDS_PER_YEAR = 31557600
+        # :nocov:
+        end
+
         # Parse the interval input string into an ActiveSupport::Duration instance.
         def call(string)
           raise(InvalidValue, "invalid or unhandled interval format: #{string.inspect}") unless matches = /\A([+-]?\d+ years?\s?)?([+-]?\d+ mons?\s?)?([+-]?\d+ days?\s?)?(?:(?:([+-])?(\d{2,10}):(\d\d):(\d\d(\.\d+)?))|([+-]?\d+ hours?\s?)?([+-]?\d+ mins?\s?)?([+-]?\d+(\.\d+)? secs?\s?)?)?\z/.match(string)
 
           value = 0
-          parts = []
+          parts = {}
 
           if v = matches[1]
             v = v.to_i
-            value += 31557600 * v
-            parts << [:years, v]
+            value += SECONDS_PER_YEAR * v
+            parts[:years] = v
           end
           if v = matches[2]
             v = v.to_i
-            value += 2592000 * v
-            parts << [:months, v]
+            value += SECONDS_PER_MONTH * v
+            parts[:months] = v
           end
           if v = matches[3]
             v = v.to_i
             value += 86400 * v
-            parts << [:days, v]
+            parts[:days] = v
           end
           if matches[5]
             seconds = matches[5].to_i * 3600 + matches[6].to_i * 60
             seconds += matches[8] ? matches[7].to_f : matches[7].to_i
             seconds *= -1 if matches[4] == '-'
             value += seconds
-            parts << [:seconds, seconds]
+            parts[:seconds] = seconds
           elsif matches[9] || matches[10] || matches[11]
             seconds = 0
             if v = matches[9]
@@ -101,8 +121,14 @@ module Sequel
               seconds += matches[12] ? v.to_f : v.to_i
             end
             value += seconds
-            parts << [:seconds, seconds]
+            parts[:seconds] = seconds
+          end
+
+          # :nocov:
+          if USE_PARTS_ARRAY
+            parts = parts.to_a
           end
+          # :nocov:
 
           ActiveSupport::Duration.new(value, parts)
         end

data/lib/sequel/extensions/pg_row.rb

@@ -482,6 +482,7 @@ module Sequel
               row_type(db_type, v)
             end
             private meth
+            alias_method(meth, meth)
           end
 
           nil

data/lib/sequel/extensions/pg_row_ops.rb

@@ -158,6 +158,30 @@ module Sequel
         end
       end
     end
+
+    # :nocov:
+    if defined?(PGRow::ArrayRow)
+    # :nocov:
+      class PGRow::ArrayRow
+        # Wrap the PGRow::ArrayRow instance in an PGRowOp, allowing you to easily use
+        # the PostgreSQL row functions and operators with literal rows.
+        def op
+          Sequel.pg_row_op(self)
+        end
+      end
+    end
+
+    # :nocov:
+    if defined?(PGRow::HashRow)
+    # :nocov:
+      class PGRow::HashRow
+        # Wrap the PGRow::ArrayRow instance in an PGRowOp, allowing you to easily use
+        # the PostgreSQL row functions and operators with literal rows.
+        def op
+          Sequel.pg_row_op(self)
+        end
+      end
+    end
   end
 
   module SQL::Builders

data/lib/sequel/extensions/query.rb

@@ -74,7 +74,9 @@ module Sequel
         raise(Sequel::Error, "method #{method.inspect} did not return a dataset") unless @dataset.is_a?(Dataset)
         self
       end
+      # :nocov:
       ruby2_keywords(:method_missing) if respond_to?(:ruby2_keywords, true)
+      # :nocov:
     end
   end
 

data/lib/sequel/extensions/schema_dumper.rb

@@ -37,7 +37,7 @@ module Sequel
         {:type =>schema[:type] == :boolean ? TrueClass : Integer}
       when /\Abigint(?:\((?:\d+)\))?(?: unsigned)?\z/
         {:type=>:Bignum}
-      when /\A(?:real|float(?: unsigned)?|double(?: precision)?|double\(\d+,\d+\)(?: unsigned)?)\z/
+      when /\A(?:real|float|double(?: precision)?|double\(\d+,\d+\))(?: unsigned)?\z/
         {:type=>Float}
       when 'boolean', 'bit', 'bool'
         {:type=>TrueClass}
@@ -57,7 +57,7 @@ module Sequel
         {:type=>String, :size=>($1.to_i if $1)}
       when /\A(?:small)?money\z/
         {:type=>BigDecimal, :size=>[19,2]}
-      when /\A(?:decimal|numeric|number)(?:\((\d+)(?:,\s*(\d+))?\))?\z/
+      when /\A(?:decimal|numeric|number)(?:\((\d+)(?:,\s*(\d+))?\))?(?: unsigned)?\z/
         s = [($1.to_i if $1), ($2.to_i if $2)].compact
         {:type=>BigDecimal, :size=>(s.empty? ? nil : s)}
       when /\A(?:bytea|(?:tiny|medium|long)?blob|(?:var)?binary)(?:\((\d+)\))?\z/
@@ -218,7 +218,7 @@ END_MIG
           gen.foreign_key(name, table, col_opts)
         else
           gen.column(name, type, col_opts)
-          if [Integer, :Bignum, Float].include?(type) && schema[:db_type] =~ / unsigned\z/io
+          if [Integer, :Bignum, Float, BigDecimal].include?(type) && schema[:db_type] =~ / unsigned\z/io
             gen.check(Sequel::SQL::Identifier.new(name) >= 0)
           end
         end

data/lib/sequel/model/associations.rb

@@ -1929,7 +1929,22 @@ module Sequel
         # can be easily overridden in the class itself while allowing for
         # super to be called.
         def association_module_def(name, opts=OPTS, &block)
-          association_module(opts).send(:define_method, name, &block)
+          mod = association_module(opts)
+          mod.send(:define_method, name, &block)
+          mod.send(:alias_method, name, name)
+        end
+
+        # Add a method to the module included in the class, so the method
+        # can be easily overridden in the class itself while allowing for
+        # super to be called.  This method allows passing keywords through
+        # the defined methods.
+        def association_module_delegate_def(name, opts, &block)
+          mod = association_module(opts)
+          mod.send(:define_method, name, &block)
+          # :nocov:
+          mod.send(:ruby2_keywords, name) if mod.respond_to?(:ruby2_keywords, true)
+          # :nocov:
+          mod.send(:alias_method, name, name)
         end
       
         # Add a private method to the module included in the class.
@@ -1981,17 +1996,17 @@ module Sequel
 
           if adder = opts[:adder]
             association_module_private_def(opts[:_add_method], opts, &adder)
-            association_module_def(opts[:add_method], opts){|o,*args| add_associated_object(opts, o, *args)}
+            association_module_delegate_def(opts[:add_method], opts){|o,*args| add_associated_object(opts, o, *args)}
           end
 
           if remover = opts[:remover]
             association_module_private_def(opts[:_remove_method], opts, &remover)
-            association_module_def(opts[:remove_method], opts){|o,*args| remove_associated_object(opts, o, *args)}
+            association_module_delegate_def(opts[:remove_method], opts){|o,*args| remove_associated_object(opts, o, *args)}
           end
 
           if clearer = opts[:clearer]
             association_module_private_def(opts[:_remove_all_method], opts, &clearer)
-            association_module_def(opts[:remove_all_method], opts){|*args| remove_all_associated_objects(opts, *args)}
+            association_module_delegate_def(opts[:remove_all_method], opts){|*args| remove_all_associated_objects(opts, *args)}
           end
         end
         
@@ -2423,6 +2438,9 @@ module Sequel
           run_association_callbacks(opts, :after_add, o)
           o
         end
+        # :nocov:
+        ruby2_keywords(:add_associated_object) if respond_to?(:ruby2_keywords, true)
+        # :nocov:
 
         # Add/Set the current object to/as the given object's reciprocal association.
         def add_reciprocal_object(opts, o)
@@ -2565,6 +2583,9 @@ module Sequel
           associations[opts[:name]] = []
           ret
         end
+        # :nocov:
+        ruby2_keywords(:remove_all_associated_objects) if respond_to?(:ruby2_keywords, true)
+        # :nocov:
 
         # Remove the given associated object from the given association
         def remove_associated_object(opts, o, *args)
@@ -2586,6 +2607,9 @@ module Sequel
           run_association_callbacks(opts, :after_remove, o)
           o
         end
+        # :nocov:
+        ruby2_keywords(:remove_associated_object) if respond_to?(:ruby2_keywords, true)
+        # :nocov:
 
         # Check that the object from the associated table specified by the primary key
         # is currently associated to the receiver.  If it is associated, return the object, otherwise