sequel 5.51.0 → 5.54.0

data/lib/sequel/extensions/server_block.rb

@@ -88,12 +88,10 @@ module Sequel
   module UnthreadedServerBlock
     # Set a default server/shard to use inside the block.
     def with_server(default_server, read_only_server=default_server)
-      begin
-        set_default_server(default_server, read_only_server)
-        yield
-      ensure
-        clear_default_server
-      end
+      set_default_server(default_server, read_only_server)
+      yield
+    ensure
+      clear_default_server
     end
 
     private
@@ -131,12 +129,10 @@ module Sequel
     # Set a default server/shard to use inside the block for the current
     # thread.
     def with_server(default_server, read_only_server=default_server)
-      begin
-        set_default_server(default_server, read_only_server)
-        yield
-      ensure
-        clear_default_server
-      end
+      set_default_server(default_server, read_only_server)
+      yield
+    ensure
+      clear_default_server
     end
 
     private

data/lib/sequel/extensions/sql_comments.rb

@@ -44,11 +44,51 @@
 #
 #   DB.extension(:sql_comments)
 #
+# Loading the sql_comments extension into the database also adds 
+# support for block-level comment support via Database#with_comments.
+# You call #with_comments with a hash.  Queries inside the hash will
+# include a comment based on the hash (assuming they are inside the
+# same thread):
+#
+#   DB.with_comments(model: Album, action: :all) do
+#     DB[:albums].all
+#     # SELECT * FROM albums -- model:Album,action:all
+#   end
+#
+# You can nest calls to #with_comments, which will combine the
+# entries from both calls:
+#
+#   DB.with_comments(application: App, path: :scrubbed_path) do
+#     DB.with_comments(model: Album, action: :all) do
+#       ds = DB[:albums].all
+#       # SELECT * FROM albums
+#       # -- application:App,path:scrubbed_path,model:Album,action:all
+#     end
+#   end
+#
+# You can override comment entries specified in earlier blocks, or
+# remove entries specified earlier using a nil value:
+#
+#   DB.with_comments(application: App, path: :scrubbed_path) do
+#     DB.with_comments(application: Foo, path: nil) do
+#       ds = DB[:albums].all
+#       # SELECT * FROM albums # -- application:Foo
+#     end
+#   end
+#
+# You can combine block-level comments with dataset-specific
+# comments:
+#
+#   DB.with_comments(model: Album, action: :all) do
+#     DB[:table].comment("Some Comment").all
+#     # SELECT * FROM albums -- model:Album,action:all -- Some Comment
+#   end
+#
 # Note that Microsoft Access does not support inline comments,
 # and attempting to use comments on it will result in SQL syntax
 # errors.
 #
-# Related module: Sequel::SQLComments
+# Related modules: Sequel::SQLComments, Sequel::Database::SQLComments
 
 #
 module Sequel
@@ -62,7 +102,7 @@ module Sequel
     %w'select insert update delete'.each do |type|
       define_method(:"#{type}_sql") do |*a|
         sql = super(*a)
-        if comment = @opts[:comment]
+        if comment = _sql_comment
           # This assumes that the comment stored in the dataset has
           # already been formatted. If not, this could result in SQL
           # injection.
@@ -74,8 +114,10 @@ module Sequel
           if sql.frozen?
             sql += comment
             sql.freeze
-          else
+          elsif @opts[:append_sql] || @opts[:placeholder_literalizer]
             sql << comment
+          else
+            sql += comment
           end
         end
         sql
@@ -84,6 +126,11 @@ module Sequel
 
     private
 
+    # The comment to include in the SQL query, if any.
+    def _sql_comment
+      @opts[:comment]
+    end
+
     # Format the comment.  For maximum compatibility, this uses a
     # single line SQL comment, and converts all consecutive whitespace
     # in the comment to a single space.
@@ -92,5 +139,65 @@ module Sequel
     end
   end
 
+  module Database::SQLComments
+    def self.extended(db)
+      db.instance_variable_set(:@comment_hashes, {})
+      db.extend_datasets DatasetSQLComments
+    end
+
+    # A map of threads to comment hashes, used for correctly setting
+    # comments for all queries inside #with_comments blocks.
+    attr_reader :comment_hashes
+
+    # Store the comment hash and use it to create comments inside the block
+    def with_comments(comment_hash)
+      hashes = @comment_hashes
+      t = Sequel.current
+      new_hash = if hash = Sequel.synchronize{hashes[t]}
+        hash.merge(comment_hash)
+      else
+        comment_hash.dup
+      end
+      yield Sequel.synchronize{hashes[t] = new_hash}
+    ensure
+      if hash
+        Sequel.synchronize{hashes[t] = hash}
+      else
+        t && Sequel.synchronize{hashes.delete(t)}
+      end
+    end
+
+    module DatasetSQLComments
+      include Sequel::SQLComments
+
+      private
+
+      # Include comments added via Database#with_comments in the output SQL.
+      def _sql_comment
+        specific_comment = super
+        return specific_comment if @opts[:append_sql]
+
+        t = Sequel.current
+        hashes = db.comment_hashes
+        block_comment = if comment_hash = Sequel.synchronize{hashes[t]}
+          comment_array = comment_hash.map{|k,v| "#{k}:#{v}" unless v.nil?}
+          comment_array.compact!
+          comment_array.join(",")
+        end
+
+        if block_comment
+          if specific_comment
+            format_sql_comment(block_comment + specific_comment)
+          else
+            format_sql_comment(block_comment)
+          end
+        else
+          specific_comment
+        end
+      end
+    end
+  end
+
   Dataset.register_extension(:sql_comments, SQLComments)
+  Database.register_extension(:sql_comments, Database::SQLComments)
 end

data/lib/sequel/extensions/string_date_time.rb

@@ -4,6 +4,10 @@
 # for converting the strings to a date (e.g. String#to_date), allowing
 # for backwards compatibility with legacy Sequel code.
 #
+# These methods calls +parse+ on the related class, and as such, can
+# result in denial of service in older versions of Ruby for large
+# untrusted input, and raise exceptions in newer versions of Ruby. 
+#
 # To load the extension:
 #
 #   Sequel.extension :string_date_time
@@ -11,42 +15,34 @@
 class String
   # Converts a string into a Date object.
   def to_date
-    begin
-      Date.parse(self, Sequel.convert_two_digit_years)
-    rescue => e
-      raise Sequel.convert_exception_class(e, Sequel::InvalidValue)
-    end
+    Date.parse(self, Sequel.convert_two_digit_years)
+  rescue => e
+    raise Sequel.convert_exception_class(e, Sequel::InvalidValue)
   end
 
   # Converts a string into a DateTime object.
   def to_datetime
-    begin
-      DateTime.parse(self, Sequel.convert_two_digit_years)
-    rescue => e
-      raise Sequel.convert_exception_class(e, Sequel::InvalidValue)
-    end
+    DateTime.parse(self, Sequel.convert_two_digit_years)
+  rescue => e
+    raise Sequel.convert_exception_class(e, Sequel::InvalidValue)
   end
 
   # Converts a string into a Time or DateTime object, depending on the
   # value of Sequel.datetime_class
   def to_sequel_time
-    begin
-      if Sequel.datetime_class == DateTime
-        DateTime.parse(self, Sequel.convert_two_digit_years)
-      else
-        Sequel.datetime_class.parse(self)
-      end
-    rescue => e
-      raise Sequel.convert_exception_class(e, Sequel::InvalidValue)
+    if Sequel.datetime_class == DateTime
+      DateTime.parse(self, Sequel.convert_two_digit_years)
+    else
+      Sequel.datetime_class.parse(self)
     end
+  rescue => e
+    raise Sequel.convert_exception_class(e, Sequel::InvalidValue)
   end
 
   # Converts a string into a Time object.
   def to_time
-    begin
-      Time.parse(self)
-    rescue => e
-      raise Sequel.convert_exception_class(e, Sequel::InvalidValue)
-    end
+    Time.parse(self)
+  rescue => e
+    raise Sequel.convert_exception_class(e, Sequel::InvalidValue)
   end
 end

data/lib/sequel/model/base.rb

@@ -682,13 +682,11 @@ module Sequel
       
       # Yield to the passed block and if do_raise is false, swallow all errors other than DatabaseConnectionErrors.
       def check_non_connection_error(do_raise=require_valid_table)
-        begin
-          db.transaction(:savepoint=>:only){yield}
-        rescue Sequel::DatabaseConnectionError
-          raise
-        rescue Sequel::Error
-          raise if do_raise
-        end
+        db.transaction(:savepoint=>:only){yield}
+      rescue Sequel::DatabaseConnectionError
+        raise
+      rescue Sequel::Error
+        raise if do_raise
       end
 
       # Convert the given object to a Dataset that should be used as
@@ -1630,11 +1628,9 @@ module Sequel
       #   artist.set(name: 'Invalid').valid? # => false
       #   artist.errors.full_messages # => ['name cannot be Invalid']
       def valid?(opts = OPTS)
-        begin
-          _valid?(opts)
-        rescue HookFailed
-          false
-        end
+        _valid?(opts)
+      rescue HookFailed
+        false
       end
 
       private

data/lib/sequel/plugins/column_encryption.rb

@@ -356,7 +356,7 @@ module Sequel
 
         # Keys should be an array of arrays containing key_id, key string, auth_data, and padding.
         def initialize(keys)
-          if keys.empty?
+          if !keys || keys.empty?
             raise Error, "Cannot initialize encryptor without encryption key"
           end
 

data/lib/sequel/plugins/enum.rb

@@ -0,0 +1,124 @@
+# frozen-string-literal: true
+
+module Sequel
+  module Plugins
+    # The enum plugin allows for easily adding methods to modify the value of
+    # a column.  It allows treating the column itself as an enum, returning a
+    # symbol for the related enum value.  It also allows for setting up dataset
+    # methods to easily find records having or not having each enum value.
+    #
+    # After loading the plugin, you can call the +enum+ method to define the
+    # methods.  The +enum+ method accepts a symbol for the underlying
+    # database column, and a hash with symbol keys for the enum values.
+    # For example, the following call:
+    #
+    #   Album.enum :status_id, good: 1, bad: 2
+    #
+    # Will define the following instance methods:
+    #
+    # Album#good! :: Change +status_id+ to +1+ (does not save the receiver)
+    # Album#bad! :: Change +status_id+ to +2+ (does not save the receiver)
+    # Album#good? :: Return whether +status_id+ is +1+
+    # Album#bad? :: Return whether +status_id+ is +2+
+    #
+    # It will override the following instance methods:
+    #
+    # Album#status_id :: Return +:good+/+:bad+ instead of +1+/+2+ (other values returned as-is)
+    # Album#status_id= :: Allow calling with +:good+/+:bad+ to set +status_id+ to +1+/+2+ (other values,
+    #                     such as <tt>'good'</tt>/<tt>'bad'</tt> set as-is)
+    #
+    # If will define the following dataset methods:
+    #
+    # Album.dataset.good :: Return a dataset filtered to rows where +status_id+ is +1+
+    # Album.dataset.not_good :: Return a dataset filtered to rows where +status_id+ is not +1+
+    # Album.dataset.bad:: Return a dataset filtered to rows where +status_id+ is +2+
+    # Album.dataset.not_bad:: Return a dataset filtered to rows where +status_id+ is not +2+
+    #
+    # When calling +enum+, you can also provide the following options:
+    #
+    # :prefix :: Use a prefix for methods defined for each enum value. If +true+ is provided at the value, use the column name as the prefix.
+    #            For example, with <tt>prefix: 'status'</tt>, the instance methods defined above would be +status_good?+, +status_bad?+,
+    #            +status_good!+, and +status_bad!+, and the dataset methods defined would be +status_good+, +status_not_good+, +status_bad+,
+    #            and +status_not_bad+.
+    # :suffix :: Use a suffix for methods defined for each enum value. If +true+ is provided at the value, use the column name as the suffix.
+    #            For example, with <tt>suffix: 'status'</tt>, the instance methods defined above would be +good_status?+, +bad_status?+,
+    #            +good_status!+, and +bad_status!+, and the dataset methods defined would be +good_status+, +not_good_status+, +bad_status+,
+    #            and +not_bad_status+.
+    # :override_accessors :: Set to +false+ to not override the column accessor methods.
+    # :dataset_methods :: Set to +false+ to not define dataset methods.
+    #
+    # Note that this does not use a true enum column in the database.  If you are
+    # looking for enum support in the database, and your are using PostgreSQL,
+    # Sequel supports that via the pg_enum Database extension.
+    #
+    # Usage:
+    #
+    #   # Make all model subclasses handle enums
+    #   Sequel::Model.plugin :enum
+    #
+    #   # Make the Album class handle enums
+    #   Album.plugin :enum
+    module Enum
+      module ClassMethods
+        # Define instance and dataset methods in this class to treat column
+        # as a enum.  See Enum documentation for usage.
+        def enum(column, values, opts=OPTS)
+          raise Sequel::Error, "enum column must be a symbol" unless column.is_a?(Symbol)
+          raise Sequel::Error, "enum values must be provided as a hash with symbol keys" unless values.is_a?(Hash) && values.all?{|k,| k.is_a?(Symbol)}
+
+          if prefix = opts[:prefix]
+            prefix = column if prefix == true
+            prefix = "#{prefix}_"
+          end
+
+          if suffix = opts[:suffix]
+            suffix = column if suffix == true
+            suffix = "_#{suffix}"
+          end
+          
+          values = Hash[values].freeze
+          inverted = values.invert.freeze
+
+          unless @enum_methods
+            @enum_methods = Module.new
+            include @enum_methods
+          end
+
+          @enum_methods.module_eval do
+            unless opts[:override_accessors] == false
+              define_method(column) do
+                v = super()
+                inverted.fetch(v, v)
+              end
+
+              define_method(:"#{column}=") do |v|
+                super(values.fetch(v, v))
+              end
+            end
+
+            values.each do |key, value|
+              define_method(:"#{prefix}#{key}#{suffix}!") do
+                self[column] = value
+                nil
+              end
+
+              define_method(:"#{prefix}#{key}#{suffix}?") do
+                self[column] == value
+              end
+            end
+          end
+
+          unless opts[:dataset_methods] == false
+            dataset_module do
+              values.each do |key, value|
+                cond = Sequel[column=>value]
+                where :"#{prefix}#{key}#{suffix}", cond
+                where :"#{prefix}not_#{key}#{suffix}", ~cond
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sequel/plugins/sql_comments.rb

@@ -0,0 +1,189 @@
+# frozen-string-literal: true
+
+module Sequel
+  module Plugins
+    # The sql_comments plugin will automatically use SQL comments on
+    # queries for the model it is loaded into.  These comments will
+    # show the related model, what type of method was called, and
+    # the method name (or association name for queries to load
+    # associations):
+    #
+    #   album = Album[1]
+    #   # SELECT * FROM albums WHERE (id = 1) LIMIT 1
+    #   # -- model:Album,method_type:class,method:[]
+    #
+    #   album.update(:name=>'A')
+    #   # UPDATE albums SET name = 'baz' WHERE (id = 1)
+    #   # -- model:Album,method_type:instance,method:update
+    #
+    #   album.artist
+    #   # SELECT * FROM artists WHERE (artists.id = 1)
+    #   # -- model:Album,method_type:association_load,association:artist
+    #
+    #   Album.eager(:artists).all
+    #   # SELECT * FROM albums
+    #   # SELECT * FROM artists WHERE (artists.id IN (1))
+    #   # -- model:Album,method_type:association_eager_load,association:artist
+    #   
+    #   Album.where(id: 1).delete
+    #   # DELETE FROM albums WHERE (id = 1)
+    #   # -- model:Album,method_type:dataset,method:delete
+    #
+    # This plugin automatically supports the class, instance, and dataset
+    # methods are are supported by default in Sequel::Model.  To support
+    # custom class, instance, and dataset methods, such as those added by
+    # other plugins, you can use the appropriate <tt>sql_comments_*_methods</tt>
+    # class method:
+    #
+    #   Album.sql_comments_class_methods :first_by_name # example from finder plugin, with :mod option
+    #   Album.sql_comments_instance_methods :lazy_attribute_lookup # lazy_attributes plugin
+    #   Album.sql_comments_dataset_methods :to_csv # csv_serializer plugin
+    #
+    # In order for the sql_comments plugin to work, the sql_comments
+    # Database extension must be loaded into the model's database.
+    #
+    # Note that in order to make sure SQL comments are included, some
+    # optimizations are disabled if this plugin is loaded.
+    # 
+    # Usage:
+    #
+    #   # Make all model subclasses support automatic SQL comments
+    #   # (called before loading subclasses)
+    #   Sequel::Model.plugin :sql_comments
+    #
+    #   # Make the Album class support automatic SQL comments
+    #   Album.plugin :sql_comments
+    module SqlComments
+      # Define a method +meth+ on the given module +mod+ that will use automatic
+      # SQL comments with the given model, method_type, and method.
+      def self.def_sql_commend_method(mod, model, method_type, meth)
+        mod.send(:define_method, meth) do |*a, &block|
+          model.db.with_comments(:model=>model, :method_type=>method_type, :method=>meth) do
+            super(*a, &block)
+          end
+        end
+        # :nocov:
+        ruby2_keywords(meth) if respond_to?(:ruby2_keywords, false)
+        # :nocov:
+      end
+
+      def self.configure(model)
+        model.send(:reset_fast_pk_lookup_sql)
+      end
+
+      module ClassMethods
+        # Use automatic SQL comments for the given class methods.
+        def sql_comments_class_methods(*meths)
+          _sql_comments_methods(singleton_class, :class, meths)
+        end
+
+        # Use automatic SQL comments for the given instance methods.
+        def sql_comments_instance_methods(*meths)
+          _sql_comments_methods(self, :instance, meths)
+        end
+
+        # Use automatic SQL comments for the given dataset methods.
+        def sql_comments_dataset_methods(*meths)
+          unless @_sql_comments_dataset_module
+            dataset_module(@_sql_comments_dataset_module = Module.new)
+          end
+          _sql_comments_methods(@_sql_comments_dataset_module, :dataset, meths)
+        end
+
+        [:[], :create, :find, :find_or_create, :with_pk, :with_pk!].each do |meth|
+          define_method(meth) do |*a, &block|
+            db.with_comments(:model=>self, :method_type=>:class, :method=>meth) do
+              super(*a, &block)
+            end
+          end
+          # :nocov:
+          ruby2_keywords(meth) if respond_to?(:ruby2_keywords, false)
+          # :nocov:
+        end
+
+        private
+
+        # Don't optimize the fast PK lookups, as it uses static SQL that
+        # won't support the SQL comments.
+        def reset_fast_pk_lookup_sql
+          @fast_pk_lookup_sql = @fast_instance_delete_sql = nil
+        end
+
+        # Define automatic SQL comment methods in +mod+ for each method in +meths+,
+        # with the given +method_type+.
+        def _sql_comments_methods(mod, method_type, meths)
+          meths.each do |meth|
+            SqlComments.def_sql_commend_method(mod, self, method_type, meth)
+          end
+        end
+      end
+
+      module InstanceMethods
+        [:delete, :destroy, :lock!, :refresh, :save, :save_changes, :update, :update_fields].each do |meth|
+          define_method(meth) do |*a, &block|
+            t = Sequel.current
+            return super(*a, &block) if (hash = Sequel.synchronize{db.comment_hashes[t]}) && hash[:model]
+
+            db.with_comments(:model=>model, :method_type=>:instance, :method=>meth) do
+              super(*a, &block)
+            end
+          end
+          # :nocov:
+          ruby2_keywords(meth) if respond_to?(:ruby2_keywords, false)
+          # :nocov:
+        end
+
+        private
+
+        # Do not use a placeholder loader for associations.
+        def _associated_object_loader(opts, dynamic_opts)
+          nil
+        end
+
+        # Use SQL comments on normal association load queries, showing they are association loads.
+        def _load_associated_objects(opts, dynamic_opts=OPTS)
+          db.with_comments(:model=>model, :method_type=>:association_load, :association=>opts[:name]) do
+            super
+          end
+        end
+      end
+
+      module DatasetMethods
+        Dataset::ACTION_METHODS.each do |meth|
+          define_method(meth) do |*a, &block|
+            t = Sequel.current
+            return super(*a, &block) if (hash = Sequel.synchronize{db.comment_hashes[t]}) && hash[:model]
+
+            db.with_comments(:model=>model, :method_type=>:dataset, :method=>meth) do
+              super(*a, &block)
+            end
+          end
+          # :nocov:
+          ruby2_keywords(meth) if respond_to?(:ruby2_keywords, false)
+          # :nocov:
+        end
+
+        private
+
+        # Add the association name as part of the eager load data, so
+        # perform_eager_load has access to it.
+        def prepare_eager_load(a, reflections, eager_assoc)
+          res = super
+          
+          reflections.each do |r|
+            res[r[:eager_loader]][:association] = r[:name]
+          end
+
+          res
+        end
+
+        # Use SQL comments on eager load queries, showing they are eager loads.
+        def perform_eager_load(loader, eo)
+          db.with_comments(:model=>model, :method_type=>:association_eager_load, :method=>nil, :association=>eo[:association]) do
+            super
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sequel/plugins/subclasses.rb

@@ -5,7 +5,7 @@ module Sequel
     # The subclasses plugin keeps track of all subclasses of the
     # current model class.  Direct subclasses are available via the
     # subclasses method, and all descendent classes are available via the
-    # descendents method:
+    # descendants method:
     #
     #   c = Class.new(Sequel::Model)
     #   c.plugin :subclasses
@@ -16,7 +16,7 @@ module Sequel
     #   sc1.subclasses  # [ssc1]
     #   sc2.subclasses  # []
     #   ssc1.subclasses # []
-    #   c.descendents   # [sc1, ssc1, sc2]
+    #   c.descendants   # [sc1, ssc1, sc2]
     #
     # You can also finalize the associations and then freeze the classes
     # in all descendent classes.  Doing so is a recommended practice after
@@ -35,9 +35,14 @@ module Sequel
     #   class B < Sequel::Model; end
     #   a # => [A, B]
     module Subclasses
+      NEED_SUBCLASSES = !Object.respond_to?(:subclasses) || Object.method(:subclasses).source_location
+      private_constant :NEED_SUBCLASSES
+
       # Initialize the subclasses instance variable for the model.
       def self.apply(model, &block)
-        model.instance_variable_set(:@subclasses, [])
+        # :nocov:
+        model.instance_variable_set(:@subclasses, [])  if NEED_SUBCLASSES
+        # :nocov:
         model.instance_variable_set(:@on_subclass, block)
       end
 
@@ -46,21 +51,31 @@ module Sequel
         # class created.
         attr_reader :on_subclass
 
-        # All subclasses for the current model.  Does not
-        # include the model itself.
-        attr_reader :subclasses
+        # :nocov:
+        if NEED_SUBCLASSES
+          # All subclasses for the current model.  Does not
+          # include the model itself.
+          attr_reader :subclasses
+        end
+        # :nocov:
 
         # All descendent classes of this model.
-        def descendents
-          Sequel.synchronize{subclasses.dup}.map{|x| [x] + x.send(:descendents)}.flatten
+        def descendants
+          Sequel.synchronize{subclasses.dup}.map{|x| [x] + x.send(:descendants)}.flatten
         end
 
+        # SEQUEL6: Remove
+        alias descendents descendants
+
         # Freeze all descendent classes.  This also finalizes the associations for those
         # classes before freezing.
-        def freeze_descendents
-          descendents.each(&:finalize_associations).each(&:freeze)
+        def freeze_descendants
+          descendants.each(&:finalize_associations).each(&:freeze)
         end
 
+        # SEQUEL6: Remove
+        alias freeze_descendents freeze_descendants
+
         Plugins.inherited_instance_variables(self, :@subclasses=>lambda{|v| []}, :@on_subclass=>nil)
 
         private
@@ -70,7 +85,9 @@ module Sequel
         # in the subclass.
         def inherited(subclass)
           super
-          Sequel.synchronize{subclasses << subclass}
+          # :nocov:
+          Sequel.synchronize{subclasses << subclass} if NEED_SUBCLASSES
+          # :nocov:
           on_subclass.call(subclass) if on_subclass
         end
       end