sequel 5.8.0 → 5.38.0

data/lib/sequel/plugins/throw_failures.rb

@@ -0,0 +1,110 @@
+# frozen-string-literal: true
+
+module Sequel
+  module Plugins
+    # The throw_failures plugin throws HookFailed and ValidationFailed exceptions instead
+    # of raising them.  If there is no matching catch block, the UncaughtThrowError will be rescued
+    # and the HookFailed or ValidationFailed exception will be raised normally.
+    #
+    # If you are setting up the catch blocks to handle these failures, in the failure case this
+    # plugin is about 10-15% faster on CRuby and 10x faster on JRuby.  If you are not
+    # setting up the catch blocks, in the failure case this plugin is about 30% slower on CRuby
+    # and 2x slower on JRuby.  So this plugin should only be used if you are setting up catch
+    # blocks manually.
+    #
+    # This plugin will setup catch blocks automatically for internally rescued HookFailed
+    # exceptions when the model is configured to not raise exceptions on failure (by default,
+    # the exceptions are internally rescued in that case.
+    #
+    # To set up the catch blocks, use the class of the exception:
+    #
+    #   ret = catch(Sequel::ValidationFailed) do
+    #     model_instance.save
+    #   end
+    #   if ret.is_a?(Sequel::ValidationFailed)
+    #     # handle failure
+    #   else
+    #     # handle success
+    #   end
+    #
+    # Usage:
+    #
+    #   # Make all model subclass instances throw HookFailed and ValidationFailed exceptions
+    #   # (called before loading subclasses)
+    #   Sequel::Model.plugin :throw_failures
+    #
+    #   # Make the Album class throw HookFailed and ValidationFailed exceptions
+    #   Album.plugin :throw_failures
+    module ThrowFailures
+      module InstanceMethods
+        # Catch any thrown HookFailed exceptions.
+        def valid?(opts = OPTS)
+          catch_hook_failures{super} || false
+        end
+
+        private
+
+        # Catch any HookFailed exceptions thrown inside the block, and return
+        # nil if there were any.
+        def catch_hook_failures
+          called = ret = nil
+          catch(HookFailed) do
+            ret = yield
+            called = true
+          end
+          ret if called
+        end
+
+        # Catch any thrown HookFailed exceptions if not raising on failure.
+        def checked_save_failure(opts)
+          if raise_on_failure?(opts)
+            super
+          else
+            catch_hook_failures{super}
+          end
+        end
+
+        if RUBY_VERSION >= '2.2' && (!defined?(JRUBY_VERSION) || JRUBY_VERSION > '9.1')
+          # Throw HookFailed with the generated error.  If the throw is not
+          # caught, just return the originally generated error.
+          def hook_failed_error(msg)
+            e = super
+            throw HookFailed, e
+          rescue UncaughtThrowError
+            e
+          end
+
+          # Throw ValidationFailed with the generated error.  If the throw is not
+          # caught, just return the originally generated error.
+          def validation_failed_error
+            e = super
+            throw ValidationFailed, e
+          rescue UncaughtThrowError
+            e
+          end
+        else
+          # UncaughtThrowError was added in Ruby 2.2.  Older Ruby versions
+          # used ArgumentError with "uncaught throw" at the start of the message
+
+          # :nocov:
+          def hook_failed_error(msg)
+            e = super
+            throw HookFailed, e
+          rescue ArgumentError => e2
+            raise e2 unless e2.message.start_with?('uncaught throw')
+            e
+          end
+
+          def validation_failed_error
+            e = super
+            throw ValidationFailed, e
+          rescue ArgumentError => e2
+            raise e2 unless e2.message.start_with?('uncaught throw')
+            e
+          end
+          # :nocov:
+        end
+      end
+    end
+  end
+end

data/lib/sequel/plugins/tree.rb

@@ -32,25 +32,27 @@ module Sequel
       def self.apply(model, opts=OPTS)
         opts = opts.dup
         opts[:class] = model
+        opts[:key] ||= :parent_id
 
-        model.instance_exec do
-          @parent_column = (opts[:key] ||= :parent_id)
-          @tree_order = opts[:order]
-        end
-        
-        par = opts.merge(opts.fetch(:parent, {}))
+        par = opts.merge(opts.fetch(:parent, OPTS))
         parent = par.fetch(:name, :parent)
         
-        chi = opts.merge(opts.fetch(:children, {}))
+        chi = opts.merge(opts.fetch(:children, OPTS))
         children = chi.fetch(:name, :children)
 
         par[:reciprocal] = children
         chi[:reciprocal] = parent
 
-        model.many_to_one parent, par
-        model.one_to_many children, chi
+        model.instance_exec do
+          @parent_column = opts[:key]
+          @tree_order = opts[:order]
+          @parent_association_name = parent
+          @children_association_name = children
 
-        model.plugin SingleRoot if opts[:single_root]
+          many_to_one parent, par
+          one_to_many children, chi
+          plugin SingleRoot if opts[:single_root]
+        end
       end
       
       module ClassMethods
@@ -61,7 +63,14 @@ module Sequel
         # parent of the leaf.
         attr_accessor :parent_column
 
-        Plugins.inherited_instance_variables(self, :@parent_column=>nil, :@tree_order=>nil)
+        # The association name for the parent association
+        attr_reader :parent_association_name
+
+        # The association name for the children association
+        attr_reader :children_association_name
+
+        Plugins.inherited_instance_variables(self, :@parent_column=>nil, :@tree_order=>nil, :@parent_association_name=>nil, :@children_association_name=>nil)
+        Plugins.def_dataset_methods(self, [:roots, :roots_dataset])
 
         # Should freeze tree order if it is an array when freezing the model class.
         def freeze
@@ -69,22 +78,6 @@ module Sequel
         
           super
         end
-
-        # Returns list of all root nodes (those with no parent nodes).
-        #
-        #   TreeClass.roots # => [root1, root2]
-        def roots
-          roots_dataset.all
-        end
-        
-        # Returns the dataset for retrieval of all root nodes
-        #
-        #   TreeClass.roots_dataset # => Sequel::Dataset instance
-        def roots_dataset
-          ds = where(Sequel.or(Array(parent_column).zip([])))
-          ds = ds.order(*tree_order) if tree_order
-          ds
-        end
       end
       
       module InstanceMethods
@@ -93,7 +86,10 @@ module Sequel
         #   subchild1.ancestors # => [child1, root]
         def ancestors
           node, nodes = self, []
-          nodes << node = node.parent while node.parent
+          meth = model.parent_association_name
+          while par = node.send(meth)
+            nodes << node = par
+          end
           nodes
         end
 
@@ -101,8 +97,8 @@ module Sequel
         #
         #   node.descendants # => [child1, child2, subchild1_1, subchild1_2, subchild2_1, subchild2_2]
         def descendants
-          nodes = children.dup
-          children.each{|child| nodes.concat(child.descendants)}
+          nodes = send(model.children_association_name).dup
+          send(model.children_association_name).each{|child| nodes.concat(child.descendants)}
           nodes 
         end
 
@@ -121,7 +117,11 @@ module Sequel
         #
         #   subchild1.self_and_siblings # => [subchild1, subchild2]
         def self_and_siblings
-          parent ? parent.children : model.roots
+          if parent = send(model.parent_association_name)
+            parent.send(model.children_association_name)
+          else
+            model.roots
+          end
         end
 
         # Returns all siblings of the current node.
@@ -139,6 +139,24 @@ module Sequel
         end
       end
 
+      module DatasetMethods
+        # Returns list of all root nodes (those with no parent nodes).
+        #
+        #   TreeClass.roots # => [root1, root2]
+        def roots
+          roots_dataset.all
+        end
+
+        # Returns the dataset for retrieval of all root nodes
+        #
+        #   TreeClass.roots_dataset # => Sequel::Dataset instance
+        def roots_dataset
+          ds = where(Sequel.or(Array(model.parent_column).zip([])))
+          ds = ds.order(*model.tree_order) if model.tree_order
+          ds
+        end
+      end
+
       # Plugin included when :single_root option is passed.
       module SingleRoot
         module ClassMethods

data/lib/sequel/plugins/typecast_on_load.rb

@@ -41,7 +41,9 @@ module Sequel
         # Typecast values using #load_typecast when the values are retrieved
         # from the database.
         def call(values)
-          super.load_typecast
+          o = super.load_typecast
+          o.send(:_clear_changed_columns, :initialize)
+          o
         end
 
         # Freeze typecast on load columns when freezing model class.
@@ -63,7 +65,6 @@ module Sequel
               set_column_value("#{c}=", v)
             end
           end
-          _changed_columns.clear
           self
         end
 

data/lib/sequel/plugins/validation_class_methods.rb

@@ -188,13 +188,21 @@ module Sequel
         #                   Sequel will attempt to insert a NULL value into the database, instead of using the
         #                   database's default.
         # :allow_nil :: Whether to skip the validation if the value is nil.
-        # :if :: A symbol (indicating an instance_method) or proc (which is instance_execed)
+        # :if :: A symbol (indicating an instance_method) or proc (which is used to define an instance method)
         #        skipping this validation if it returns nil or false.
         # :tag :: The tag to use for this validation.
         def validates_each(*atts, &block)
           opts = extract_options!(atts)
           blank_meth = db.method(:blank_object?).to_proc
-          blk = if (i = opts[:if]) || (am = opts[:allow_missing]) || (an = opts[:allow_nil]) || (ab = opts[:allow_blank])
+          i = opts[:if]
+          am = opts[:allow_missing]
+          an = opts[:allow_nil]
+          ab = opts[:allow_blank]
+          blk = if i || am || an || ab
+            if i.is_a?(Proc)
+              i = Plugins.def_sequel_method(self, "validation_class_methods_if", 0, &i)
+            end
+
             proc do |o,a,v|
               next if i && !validation_if_proc(o, i)
               next if an && Array(v).all?(&:nil?)
@@ -419,7 +427,7 @@ module Sequel
         # an empty hash is returned This method is useful when writing methods that
         # take an options hash as the last parameter.
         def extract_options!(array)
-          array.last.is_a?(Hash) ? array.pop : {}
+          array.last.is_a?(Hash) ? array.pop : OPTS
         end
 
         # Add the validation reflection to the class's validations.
@@ -434,8 +442,6 @@ module Sequel
           case i
           when Symbol
             o.get_column_value(i)
-          when Proc
-            o.instance_exec(&i)
           else
             raise(::Sequel::Error, "invalid value for :if validation option")
           end

data/lib/sequel/plugins/validation_helpers.rb

@@ -244,7 +244,7 @@ module Sequel
         def validates_unique(*atts)
           opts = default_validation_helpers_options(:unique)
           if atts.last.is_a?(Hash)
-            opts = Hash[opts].merge!(atts.pop)
+            opts = opts.merge(atts.pop)
           end
           message = validation_error_message(opts[:message])
           from_values = opts[:from] == :values
@@ -302,7 +302,7 @@ module Sequel
         # Merge the given options with the default options for the given type
         # and call validatable_attributes with the merged options.
         def validatable_attributes_for_type(type, atts, opts, &block)
-          validatable_attributes(atts, Hash[default_validation_helpers_options(type)].merge!(opts), &block)
+          validatable_attributes(atts, default_validation_helpers_options(type).merge(opts), &block)
         end
         
         # The validation error message to use, as a string.  If message

data/lib/sequel/sql.rb

@@ -18,7 +18,8 @@ module Sequel
   end
 
   # Time subclass that gets literalized with only the time value, so it operates
-  # like a standard SQL time type.
+  # like a standard SQL time type.  This type does not support timezones, by design,
+  # so it will not work correctly with <tt>time with time zone</tt> types.
   class SQLTime < ::Time
     @date = nil
 
@@ -26,12 +27,27 @@ module Sequel
       # Set the date used for SQLTime instances.
       attr_writer :date
 
-      # use the date explicitly set, or the current date if there is not a
+      # Use the date explicitly set, or the current date if there is not a
       # date set.
       def date
         @date || now
       end
 
+      # Set the correct date and timezone when parsing times.
+      def parse(*)
+        t = super
+
+        utc = Sequel.application_timezone == :utc
+        d = @date
+        if d || utc
+          meth = utc ? :utc : :local
+          d ||= t
+          t = public_send(meth, d.year, d.month, d.day, t.hour, t.min, t.sec, t.usec)
+        end
+
+        t
+      end
+
       # Create a new SQLTime instance given an hour, minute, second, and usec.
       def create(hour, minute, second, usec = 0)
         t = date
@@ -250,12 +266,12 @@ module Sequel
     # methods overlap with the standard +BooleanMethods methods+, and they only
     # make sense for integers, they are only included in +NumericExpression+.
     #
-    #   :a.sql_number & :b # "a" & "b"
-    #   :a.sql_number | :b # "a" | "b"
-    #   :a.sql_number ^ :b # "a" ^ "b"
-    #   :a.sql_number << :b # "a" << "b"
-    #   :a.sql_number >> :b # "a" >> "b"
-    #   ~:a.sql_number # ~"a"
+    #   Sequel[:a].sql_number & :b # "a" & "b"
+    #   Sequel[:a].sql_number | :b # "a" | "b"
+    #   Sequel[:a].sql_number ^ :b # "a" ^ "b"
+    #   Sequel[:a].sql_number << :b # "a" << "b"
+    #   Sequel[:a].sql_number >> :b # "a" >> "b"
+    #   ~Sequel[:a].sql_number # ~"a"
     module BitwiseMethods
       ComplexExpression::BITWISE_OPERATORS.each do |o|
         module_eval("def #{o}(o) NumericExpression.new(#{o.inspect}, self, o) end", __FILE__, __LINE__)
@@ -339,9 +355,15 @@ module Sequel
       end
 
       # Return an <tt>SQL::CaseExpression</tt> created with the given arguments.
+      # The first argument are the <tt>WHEN</tt>/<tt>THEN</tt> conditions,
+      # specified as an array or a hash.  The second argument is the
+      # <tt>ELSE</tt> default value.  The third optional argument is the
+      # <tt>CASE</tt> expression.
       #
-      #   Sequel.case([[{a: [2,3]}, 1]], 0) # SQL: CASE WHEN a IN (2, 3) THEN 1 ELSE 0 END
+      #   Sequel.case({a: 1}, 0) # SQL: CASE WHEN a THEN 1 ELSE 0 END
       #   Sequel.case({a: 1}, 0, :b) # SQL: CASE b WHEN a THEN 1 ELSE 0 END
+      #   Sequel.case({{a: [2,3]} => 1}, 0) # SQL: CASE WHEN a IN (2, 3) THEN 1 ELSE 0 END
+      #   Sequel.case([[{a: [2,3]}, 1]], 0) # SQL: CASE WHEN a IN (2, 3) THEN 1 ELSE 0 END
       def case(*args)
         SQL::CaseExpression.new(*args)
       end
@@ -730,10 +752,10 @@ module Sequel
     # This module includes the inequality methods (>, <, >=, <=) that are defined on objects that can be 
     # used in a numeric or string context in SQL.
     #
-    #   Sequel.lit('a') > :b # a > "b"
-    #   Sequel.lit('a') < :b # a > "b"
-    #   Sequel.lit('a') >= :b # a >= "b"
-    #   Sequel.lit('a') <= :b # a <= "b"
+    #   Sequel[:a] > :b # a > "b"
+    #   Sequel[:a] < :b # a > "b"
+    #   Sequel[:a] >= :b # a >= "b"
+    #   Sequel[:a] <= :b # a <= "b"
     module InequalityMethods
       ComplexExpression::INEQUALITY_OPERATORS.each do |o|
         module_eval("def #{o}(o) BooleanExpression.new(#{o.inspect}, self, o) end", __FILE__, __LINE__)
@@ -744,10 +766,10 @@ module Sequel
     # that are defined on objects that can be used in a numeric context in SQL
     # (+Symbol+, +LiteralString+, and +SQL::GenericExpression+).
     #
-    #   :a + :b # "a" + "b"
-    #   :a - :b # "a" - "b"
-    #   :a * :b # "a" * "b"
-    #   :a / :b # "a" / "b"
+    #   Sequel[:a] + :b # "a" + "b"
+    #   Sequel[:a] - :b # "a" - "b"
+    #   Sequel[:a] * :b # "a" * "b"
+    #   Sequel[:a] / :b # "a" / "b"
     #
     # One exception to this is if + is called with a +String+ or +StringExpression+,
     # in which case the || operator is used instead of the + operator:
@@ -766,8 +788,10 @@ module Sequel
       def coerce(other)
         if other.is_a?(Numeric)
           [SQL::NumericExpression.new(:NOOP, other), self]
-        else
+        elsif defined?(super)
           super 
+        else
+          [self, other]
         end
       end
 
@@ -998,6 +1022,11 @@ module Sequel
       include SQL::AliasMethods
       include SQL::CastMethods
 
+      class << self
+        # Alias new to call for usage in conversion procs
+        alias call new
+      end
+
       # Return a LiteralString with the same content if no args are given, otherwise
       # return a SQL::PlaceholderLiteralString with the current string and the given args.
       def lit(*args)
@@ -1059,8 +1088,30 @@ module Sequel
       def self.from_value_pair(l, r)
         case r
         when Range
-          new(:AND, new(:>=, l, r.begin), new(r.exclude_end? ? :< : :<=, l, r.end))
-        when ::Array, ::Sequel::Dataset
+          unless r.begin.nil?
+            begin_expr = new(:>=, l, r.begin)
+          end
+          unless r.end.nil?
+            end_expr = new(r.exclude_end? ? :< : :<=, l, r.end)
+          end
+          if begin_expr
+            if end_expr
+              new(:AND, begin_expr, end_expr)
+            else
+              begin_expr
+            end
+          elsif end_expr
+            end_expr
+          else
+            new(:'=', 1, 1)
+          end
+        when ::Array
+          r = r.dup.freeze unless r.frozen?
+          new(:IN, l, r)
+        when ::String
+          r = r.dup.freeze unless r.frozen?
+          new(:'=', l, r)
+        when ::Sequel::Dataset
           new(:IN, l, r)
         when NegativeBooleanConstant
           new(:"IS NOT", l, r.constant)
@@ -1092,8 +1143,21 @@ module Sequel
           case op = ce.op
           when :AND, :OR
             BooleanExpression.new(OPERTATOR_INVERSIONS[op], *ce.args.map{|a| BooleanExpression.invert(a)})
-          else
+          when :IN, :"NOT IN"
             BooleanExpression.new(OPERTATOR_INVERSIONS[op], *ce.args.dup)
+          else
+            if ce.args.length == 2
+              case ce.args[1]
+              when Function, LiteralString, PlaceholderLiteralString
+                # Special behavior to not push down inversion in this case because doing so
+                # can result in incorrect behavior for ANY/SOME/ALL operators.
+                BooleanExpression.new(:NOT, ce)
+              else
+                BooleanExpression.new(OPERTATOR_INVERSIONS[op], *ce.args.dup)
+              end
+            else
+              BooleanExpression.new(OPERTATOR_INVERSIONS[op], *ce.args.dup)
+            end
           end
         when StringExpression, NumericExpression
           raise(Sequel::Error, "cannot invert #{ce.inspect}")
@@ -1253,6 +1317,7 @@ module Sequel
       CURRENT_DATE = Constant.new(:CURRENT_DATE)
       CURRENT_TIME = Constant.new(:CURRENT_TIME)
       CURRENT_TIMESTAMP = Constant.new(:CURRENT_TIMESTAMP)
+      DEFAULT = Constant.new(:DEFAULT)
       SQLTRUE = TRUE = BooleanConstant.new(true)
       SQLFALSE = FALSE = BooleanConstant.new(false)
       NULL = BooleanConstant.new(nil)
@@ -1366,7 +1431,7 @@ module Sequel
       end
 
       # Return a new function with an OVER clause (making it a window function).
-      # See {SQL::Window} for the list of options +over+ can receive.
+      # See Sequel::SQL::Window for the list of options +over+ can receive.
       #
       #   Sequel.function(:row_number).over(partition: :col) # row_number() OVER (PARTITION BY col)
       def over(window=OPTS)
@@ -1422,7 +1487,7 @@ module Sequel
 
       # Return a new function call with the given opts merged into the current opts.
       def with_opts(opts)
-        self.class.new!(name, args, Hash[@opts].merge!(opts))
+        self.class.new!(name, args, @opts.merge(opts))
       end
     end
 
@@ -1703,7 +1768,7 @@ module Sequel
       #   StringExpression.like(:a, 'a%', /^a/i) # (("a" LIKE 'a%' ESCAPE '\') OR ("a" ~* '^a'))
       def self.like(l, *ces)
         l, lre, lci = like_element(l)
-        lci = (ces.last.is_a?(Hash) ? ces.pop : {})[:case_insensitive] ? true : lci
+        lci = (ces.last.is_a?(Hash) ? ces.pop : OPTS)[:case_insensitive] ? true : lci
         ces.map! do |ce|
           r, rre, rci = like_element(ce)
           BooleanExpression.new(LIKE_MAP[[lre||rre, lci||rci]], l, r)
@@ -1846,7 +1911,7 @@ module Sequel
         freeze
       end
 
-      include(Module.new do
+      m = Module.new do
         # Return an +Identifier+, +QualifiedIdentifier+, or +Function+, depending
         # on arguments and whether a block is provided.  Does not currently call the block.
         # See the class level documentation.
@@ -1862,7 +1927,8 @@ module Sequel
             Function.new(m, *args)
           end
         end
-      end)
+      end
+      include m
 
       Sequel::VIRTUAL_ROW = new
     end
@@ -1883,16 +1949,40 @@ module Sequel
     #   # (PARTITION BY col7 ROWS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING)
     #   Sequel::SQL::Window.new(partition: :col7, frame: :rows)
     #   # (PARTITION BY col7 ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW)
-    #   Sequel::SQL::Window.new(partition: :col7, frame: "RANGE CURRENT ROW")
+    #   Sequel::SQL::Window.new(partition: :col7, frame: {type: :range, start: current})
     #   # (PARTITION BY col7 RANGE CURRENT ROW)
+    #   Sequel::SQL::Window.new(partition: :col7, frame: {type: :range, start: 1, end: 1})
+    #   # (PARTITION BY col7 RANGE BETWEEN 1 PRECEDING AND 1 FOLLOWING)
+    #   Sequel::SQL::Window.new(partition: :col7, frame: {type: :range, start: 2, end: [1, :preceding]})
+    #   # (PARTITION BY col7 RANGE BETWEEN 2 PRECEDING AND 1 PRECEDING)
+    #   Sequel::SQL::Window.new(partition: :col7, frame: {type: :range, start: 1, end: [2, :following]})
+    #   # (PARTITION BY col7 RANGE BETWEEN 1 FOLLOWING AND 2 FOLLOWING)
+    #   Sequel::SQL::Window.new(partition: :col7, frame: {type: :range, start: :preceding, exclude: :current})
+    #   # (PARTITION BY col7 RANGE UNBOUNDED PRECEDING EXCLUDE CURRENT ROW)
     #
     #   Sequel::SQL::Window.new(window: :named_window) # you can create a named window with Dataset#window
     #   # (named_window)
     class Window < Expression
       # The options for this window.  Options currently supported:
-      # :frame :: if specified, should be :all, :rows, or a String that is used literally. :all always operates over all rows in the
-      #           partition, while :rows excludes the current row's later peers.  The default is to include
-      #           all previous rows in the partition up to the current row's last peer.
+      # :frame :: if specified, should be :all, :rows, :range, :groups, a String, or a Hash.
+      #           :all :: Always operates over all rows in the partition
+      #           :rows :: Includes rows in the partition up to and including the current row
+      #           :range, :groups :: Includes rows in the partition up to and including the current group
+      #           String :: Used as literal SQL code, try to avoid
+      #           Hash :: Hash of options for the frame:
+      #                   :type :: The type of frame, must be :rows, :range, or :groups (required)
+      #                   :start :: The start of the frame (required).  Possible values:
+      #                             :preceding :: UNBOUNDED PRECEDING
+      #                             :following :: UNBOUNDED FOLLOWING
+      #                             :current :: CURRENT ROW
+      #                             String, Numeric, or Cast :: Used as the offset of rows/values preceding
+      #                             Array :: Must have two elements, with first element being String, Numeric, or
+      #                                      Cast and second element being :preceding or :following
+      #                   :end :: The end of the frame.  Can be left out.  If present, takes the same values as
+      #                           :start, except that when a String, Numeric, or Hash, it is used as the offset
+      #                           for rows following
+      #                   :exclude :: Which rows to exclude.  Possible values are :current, :ties, :group
+      #                               :no_others.
       # :order :: order on the column(s) given
       # :partition :: partition/group on the column(s) given
       # :window :: base results on a previously specified named window