sequel 5.61.0 → 5.62.0

data/lib/sequel/extensions/pg_json.rb

@@ -142,6 +142,11 @@ module Sequel
           ds.literal_append(sql, Sequel.object_to_json(self))
           sql << '::json'
         end
+
+        # Allow automatic parameterization.
+        def sequel_auto_param_type(ds)
+          "::json"
+        end
       end
 
       jsonb_class = Class.new(base_class) do
@@ -151,6 +156,11 @@ module Sequel
           ds.literal_append(sql, Sequel.object_to_json(self))
           sql << '::jsonb'
         end
+
+        # Allow automatic parameterization.
+        def sequel_auto_param_type(ds)
+          "::jsonb"
+        end
       end
 
       const_set(:"JSON#{name}Base", base_class)
@@ -424,16 +434,6 @@ module Sequel
         end
       end
 
-      # Handle json[] and jsonb[] types in bound variables.
-      def bound_variable_array(a)
-        case a
-        when JSONObject, JSONBObject
-          "\"#{Sequel.object_to_json(a).gsub('"', '\\"')}\""
-        else
-          super
-        end
-      end
-
       # Make the column type detection recognize the json types.
       def schema_column_type(db_type)
         case db_type

data/lib/sequel/extensions/pg_multirange.rb

@@ -220,16 +220,6 @@ module Sequel
 
         private
 
-        # Handle arrays of multirange types in bound variables.
-        def bound_variable_array(a)
-          case a
-          when PGMultiRange
-            "\"#{bound_variable_arg(a, nil)}\""
-          else
-            super
-          end
-        end
-
         # Recognize the registered database multirange types.
         def schema_column_type(db_type)
           @pg_multirange_schema_types[db_type] || super
@@ -346,6 +336,11 @@ module Sequel
          
         val << "}"
       end
+
+      # Allow automatic parameterization.
+      def sequel_auto_param_type(ds)
+        "::#{db_type}"
+      end
     end
   end
 

data/lib/sequel/extensions/pg_range.rb

@@ -233,16 +233,6 @@ module Sequel
 
         private
 
-        # Handle arrays of range types in bound variables.
-        def bound_variable_array(a)
-          case a
-          when PGRange, Range
-            "\"#{bound_variable_arg(a, nil)}\""
-          else
-            super
-          end
-        end
-
         # Recognize the registered database range types.
         def schema_column_type(db_type)
           @pg_range_schema_types[db_type] || super
@@ -491,6 +481,11 @@ module Sequel
         end
       end
 
+      # Allow automatic parameterization for ranges with types.
+      def sequel_auto_param_type(ds)
+        "::#{db_type}" if db_type
+      end
+
       private
 
       # Escape common range types.  Instead of quoting, just backslash escape all

data/lib/sequel/extensions/pg_row.rb

@@ -136,6 +136,15 @@ module Sequel
             ds.quote_schema_table_append(sql, db_type)
           end
         end
+
+        # Allow automatic parameterization if all values support it.
+        def sequel_auto_param_type(ds)
+          if db_type && all?{|v| nil == v || ds.send(:auto_param_type, v)}
+            s = String.new << "::"
+            ds.quote_schema_table_append(s, db_type)
+            s
+          end
+        end
       end
 
       # Class for row-valued/composite types that are treated as hashes.
@@ -208,6 +217,15 @@ module Sequel
             ds.quote_schema_table_append(sql, db_type)
           end
         end
+
+        # Allow automatic parameterization if all values support it.
+        def sequel_auto_param_type(ds)
+          if db_type && all?{|_,v| nil == v || ds.send(:auto_param_type, v)}
+            s = String.new << "::"
+            ds.quote_schema_table_append(s, db_type)
+            s
+          end
+        end
       end
 
       ROW_TYPE_CLASSES = [HashRow, ArrayRow].freeze
@@ -519,19 +537,6 @@ module Sequel
 
         private
 
-        # Format composite types used in bound variable arrays.
-        def bound_variable_array(arg)
-          case arg
-          when ArrayRow
-            "\"(#{arg.map{|v| bound_variable_array(v) if v}.join(',').gsub(/("|\\)/, '\\\\\1')})\""
-          when HashRow
-            arg.check_columns!
-            "\"(#{arg.values_at(*arg.columns).map{|v| bound_variable_array(v) if v}.join(',').gsub(/("|\\)/, '\\\\\1')})\""
-          else
-            super
-          end
-        end
-
         # Make the column type detection handle registered row types.
         def schema_column_type(db_type)
           if type = @row_schema_types[db_type]

data/lib/sequel/model/associations.rb

@@ -276,7 +276,7 @@ module Sequel
 
           if eo[:no_results]
             no_results = true
-          elsif eo[:eager_block] || eo[:loader] == false
+          elsif eo[:eager_block] || eo[:loader] == false || !use_placeholder_loader?
             ds = eager_loading_dataset(eo)
 
             strategy = ds.opts[:eager_limit_strategy] || strategy
@@ -299,6 +299,11 @@ module Sequel
             strategy = :ruby if strategy == :correlated_subquery
             strategy = nil if strategy == :ruby && assign_singular?
             objects = apply_eager_limit_strategy(ds, strategy, eager_limit).all
+
+            if strategy == :window_function
+              delete_rn = ds.row_number_column 
+              objects.each{|obj| obj.values.delete(delete_rn)}
+            end
           elsif strategy == :union
             objects = []
             ds = associated_dataset
@@ -817,7 +822,7 @@ module Sequel
 
         # Whether the placeholder loader can be used to load the association.
         def use_placeholder_loader?
-          self[:use_placeholder_loader]
+          self[:use_placeholder_loader] && _associated_dataset.supports_placeholder_literalizer?
         end
       end
     

data/lib/sequel/model/base.rb

@@ -606,6 +606,7 @@ module Sequel
           @db_schema = get_db_schema
         end
 
+        @fast_pk_lookup_sql = @fast_instance_delete_sql = nil unless @dataset.supports_placeholder_literalizer?
         reset_instance_dataset
         self
       end
@@ -1141,7 +1142,7 @@ module Sequel
       #
       #   Artist[1] === Artist[1] # => true
       #   Artist.new === Artist.new # => false
-      #   Artist[1].set(:name=>'Bob') === Artist[1] # => true
+      #   Artist[1].set(name: 'Bob') === Artist[1] # => true
       def ===(obj)
         case pkv = pk
         when nil
@@ -1160,7 +1161,7 @@ module Sequel
       #
       #   Artist[1].pk_equal?(Artist[1]) # => true
       #   Artist.new.pk_equal?(Artist.new) # => false
-      #   Artist[1].set(:name=>'Bob').pk_equal?(Artist[1]) # => true
+      #   Artist[1].set(name: 'Bob').pk_equal?(Artist[1]) # => true
       alias pk_equal? ===
 
       # class is defined in Object, but it is also a keyword,
@@ -1232,7 +1233,7 @@ module Sequel
       #
       #   Artist[1] == Artist[1] # => true
       #   Artist.new == Artist.new # => true
-      #   Artist[1].set(:name=>'Bob') == Artist[1] # => false
+      #   Artist[1].set(name: 'Bob') == Artist[1] # => false
       def eql?(obj)
         (obj.class == model) && (obj.values == @values)
       end
@@ -1334,13 +1335,13 @@ module Sequel
       #   a = Artist[1]
       #   Artist.db.transaction do
       #     a.lock!
-      #     a.update(:name=>'A')
+      #     a.update(name: 'A')
       #   end
       #
       #   a = Artist[2]
       #   Artist.db.transaction do
       #     a.lock!('FOR NO KEY UPDATE')
-      #     a.update(:name=>'B')
+      #     a.update(name: 'B')
       #   end
       def lock!(style=:update)
         _refresh(this.lock_style(style)) unless new?

data/lib/sequel/plugins/auto_validations.rb

@@ -9,14 +9,16 @@ module Sequel
     # 2. not_null validations on NOT NULL columns (optionally, presence validations)
     # 3. unique validations on columns or sets of columns with unique indexes
     # 4. max length validations on string columns
+    # 5. no null byte validations on string columns
+    # 6. minimum and maximum values on columns
     #
-    # To determine the columns to use for the type/not_null/max_length validations,
+    # To determine the columns to use for the type/not_null/max_length/no_null_byte/max_value/min_value validations,
     # the plugin looks at the database schema for the model's table.  To determine
     # the unique validations, Sequel looks at the indexes on the table.  In order
     # for this plugin to be fully functional, the underlying database adapter needs
     # to support both schema and index parsing.  Additionally, unique validations are
     # only added for models that select from a simple table, they are not added for models
-    # that select from a subquery or joined dataset.
+    # that select from a subquery.
     #
     # This plugin uses the validation_helpers plugin underneath to implement the
     # validations.  It does not allow for any per-column validation message
@@ -50,7 +52,7 @@ module Sequel
     #
     #   Model.plugin :auto_validations, unique_opts: {only_if_modified: true}
     #
-    # This works for unique_opts, max_length_opts, schema_types_opts,
+    # This works for unique_opts, max_length_opts, schema_types_opts, max_value_opts, min_value_opts, no_null_byte_opts,
     # explicit_not_null_opts, and not_null_opts.
     #
     # If you only want auto_validations to add validations to columns that do not already
@@ -72,6 +74,19 @@ module Sequel
       SCHEMA_TYPES_OPTIONS = NOT_NULL_OPTIONS
       UNIQUE_OPTIONS = NOT_NULL_OPTIONS
       NO_NULL_BYTE_OPTIONS = MAX_LENGTH_OPTIONS
+      MAX_VALUE_OPTIONS = {:from=>:values, :allow_nil=>true, :skip_invalid=>true}.freeze
+      MIN_VALUE_OPTIONS = MAX_VALUE_OPTIONS
+      AUTO_VALIDATE_OPTIONS = {
+        :no_null_byte=>NO_NULL_BYTE_OPTIONS,
+        :not_null=>NOT_NULL_OPTIONS,
+        :explicit_not_null=>EXPLICIT_NOT_NULL_OPTIONS,
+        :max_length=>MAX_LENGTH_OPTIONS,
+        :max_value=>MAX_VALUE_OPTIONS,
+        :min_value=>MIN_VALUE_OPTIONS,
+        :schema_types=>SCHEMA_TYPES_OPTIONS,
+        :unique=>UNIQUE_OPTIONS
+      }.freeze
+
       EMPTY_ARRAY = [].freeze
 
       def self.apply(model, opts=OPTS)
@@ -82,17 +97,11 @@ module Sequel
           @auto_validate_not_null_columns = []
           @auto_validate_explicit_not_null_columns = []
           @auto_validate_max_length_columns = []
+          @auto_validate_max_value_columns = []
+          @auto_validate_min_value_columns = []
           @auto_validate_unique_columns = []
           @auto_validate_types = true
-
-          @auto_validate_options = {
-              :no_null_byte=>NO_NULL_BYTE_OPTIONS,
-              :not_null=>NOT_NULL_OPTIONS,
-              :explicit_not_null=>EXPLICIT_NOT_NULL_OPTIONS,
-              :max_length=>MAX_LENGTH_OPTIONS,
-              :schema_types=>SCHEMA_TYPES_OPTIONS,
-              :unique=>UNIQUE_OPTIONS
-          }.freeze
+          @auto_validate_options = AUTO_VALIDATE_OPTIONS
         end
       end
 
@@ -105,7 +114,7 @@ module Sequel
           end
 
           h = @auto_validate_options.dup
-          [:not_null, :explicit_not_null, :max_length, :no_null_byte, :schema_types, :unique].each do |type|
+          [:not_null, :explicit_not_null, :max_length, :max_value, :min_value, :no_null_byte, :schema_types, :unique].each do |type|
             if type_opts = opts[:"#{type}_opts"]
               h[type] = h[type].merge(type_opts).freeze
             end
@@ -135,6 +144,14 @@ module Sequel
         # pairs, with the first entry being the column name and second entry being the maximum length.
         attr_reader :auto_validate_max_length_columns
 
+        # The columns with automatch max value validations, as an array of
+        # pairs, with the first entry being the column name and second entry being the maximum value.
+        attr_reader :auto_validate_max_value_columns
+
+        # The columns with automatch min value validations, as an array of
+        # pairs, with the first entry being the column name and second entry being the minimum value.
+        attr_reader :auto_validate_min_value_columns
+
         # The columns or sets of columns with automatic unique validations
         attr_reader :auto_validate_unique_columns
 
@@ -148,6 +165,8 @@ module Sequel
           :@auto_validate_not_null_columns=>:dup,
           :@auto_validate_explicit_not_null_columns=>:dup,
           :@auto_validate_max_length_columns=>:dup,
+          :@auto_validate_max_value_columns=>:dup,
+          :@auto_validate_min_value_columns=>:dup,
           :@auto_validate_unique_columns=>:dup,
           :@auto_validate_options => :dup)
         Plugins.after_set_dataset(self, :setup_auto_validations)
@@ -168,18 +187,23 @@ module Sequel
           @auto_validate_not_null_columns.freeze
           @auto_validate_explicit_not_null_columns.freeze
           @auto_validate_max_length_columns.freeze
+          @auto_validate_max_value_columns.freeze
+          @auto_validate_min_value_columns.freeze
           @auto_validate_unique_columns.freeze
 
           super
         end
 
         # Skip automatic validations for the given validation type
-        # (:not_null, :types, :unique, :max_length, :no_null_byte).
+        # (:not_null, :no_null_byte, :types, :unique, :max_length, :max_value, :min_value).
         # If :all is given as the type, skip all auto validations.
+        #
+        # Skipping types validation automatically skips max_value and min_value validations,
+        # since those validations require valid types.
         def skip_auto_validations(type)
           case type
           when :all
-            [:not_null, :no_null_byte, :types, :unique, :max_length].each{|v| skip_auto_validations(v)}
+            [:not_null, :no_null_byte, :types, :unique, :max_length, :max_value, :min_value].each{|v| skip_auto_validations(v)}
           when :not_null
             auto_validate_not_null_columns.clear
             auto_validate_explicit_not_null_columns.clear
@@ -199,6 +223,8 @@ module Sequel
           explicit_not_null_cols += Array(primary_key)
           @auto_validate_explicit_not_null_columns = explicit_not_null_cols.uniq
           @auto_validate_max_length_columns = db_schema.select{|col, sch| sch[:type] == :string && sch[:max_length].is_a?(Integer)}.map{|col, sch| [col, sch[:max_length]]}
+          @auto_validate_max_value_columns = db_schema.select{|col, sch| sch[:max_value]}.map{|col, sch| [col, sch[:max_value]]}
+          @auto_validate_min_value_columns = db_schema.select{|col, sch| sch[:min_value]}.map{|col, sch| [col, sch[:min_value]]}
           @auto_validate_no_null_byte_columns = db_schema.select{|_, sch| sch[:type] == :string}.map{|col, _| col}
           table = dataset.first_source_table
           @auto_validate_unique_columns = if db.supports_index_parsing? && [Symbol, SQL::QualifiedIdentifier, SQL::Identifier, String].any?{|c| table.is_a?(c)}
@@ -248,6 +274,18 @@ module Sequel
 
           unless skip.include?(:types) || !model.auto_validate_types?
             validates_schema_types(keys, opts[:schema_types])
+
+            unless skip.include?(:max_value) || ((max_value_columns = model.auto_validate_max_value_columns).empty?)
+              max_value_columns.each do |col, max|
+                validates_max_value(max, col, opts[:max_value])
+              end
+            end
+
+            unless skip.include?(:min_value) || ((min_value_columns = model.auto_validate_min_value_columns).empty?)
+              min_value_columns.each do |col, min|
+                validates_min_value(min, col, opts[:min_value])
+              end
+            end
           end
 
           unless skip.include?(:unique)

data/lib/sequel/plugins/class_table_inheritance.rb

@@ -104,7 +104,7 @@ module Sequel
     # should reference the subquery alias (and qualified identifiers should not be needed
     # unless joining to another table):
     #
-    #   a = Executive.where(:id=>1).first # works
+    #   a = Executive.where(id: 1).first # works
     #   a = Executive.where{{employees[:id]=>1}}.first # works
     #   a = Executive.where{{executives[:id]=>1}}.first # doesn't work
     #
@@ -115,7 +115,7 @@ module Sequel
     #
     #   pks = Executive.where{num_staff < 10}.select_map(:id)
     #   Executive.cti_tables.reverse_each do |table|
-    #     DB.from(table).where(:id=>pks).delete
+    #     DB.from(table).where(id: pks).delete
     #   end
     #
     # = Usage

data/lib/sequel/plugins/composition.rb

@@ -39,8 +39,8 @@ module Sequel
     # also be implemented as:
     #
     #   Album.composition :date,
-    #     :composer=>proc{Date.new(year, month, day) if year || month || day},
-    #     :decomposer=>(proc do
+    #     composer: proc{Date.new(year, month, day) if year || month || day},
+    #     decomposer: (proc do
     #       if d = compositions[:date]
     #         self.year = d.year
     #         self.month = d.month

data/lib/sequel/plugins/concurrent_eager_loading.rb

@@ -50,10 +50,10 @@ module Sequel
     # support concurrent eager loading.  Taking this example from the
     # {Advanced Associations guide}[rdoc-ref:doc/advanced_associations.rdoc]
     #
-    #   Album.many_to_one :artist, :eager_loader=>(proc do |eo_opts|
+    #   Album.many_to_one :artist, eager_loader: (proc do |eo_opts|
     #     eo_opts[:rows].each{|album| album.associations[:artist] = nil}
     #     id_map = eo_opts[:id_map]
-    #     Artist.where(:id=>id_map.keys).all do |artist|
+    #     Artist.where(id: id_map.keys).all do |artist|
     #       if albums = id_map[artist.id]
     #         albums.each do |album|
     #           album.associations[:artist] = artist
@@ -74,12 +74,12 @@ module Sequel
     # the code that loads the objects, since that will prevent concurrent loading.
     # So after the changes, the custom eager loader would look like this:
     #
-    #   Album.many_to_one :artist, :eager_loader=>(proc do |eo_opts|
+    #   Album.many_to_one :artist, eager_loader: (proc do |eo_opts|
     #     Sequel.synchronize_with(eo[:mutex]) do
     #       eo_opts[:rows].each{|album| album.associations[:artist] = nil}
     #     end
     #     id_map = eo_opts[:id_map]
-    #     rows = Artist.where(:id=>id_map.keys).all
+    #     rows = Artist.where(id: id_map.keys).all
     #     Sequel.synchronize_with(eo[:mutex]) do
     #       rows.each do |artist|
     #         if albums = id_map[artist.id]

data/lib/sequel/plugins/dirty.rb

@@ -37,7 +37,7 @@ module Sequel
     #
     # It also saves the previously changed values after an update:
     #
-    #   artist.update(:name=>'Bar')
+    #   artist.update(name: 'Bar')
     #   artist.column_changes        # => {}
     #   artist.previous_changes      # => {:name=>['Foo', 'Bar']}
     #

data/lib/sequel/plugins/finder.rb

@@ -97,7 +97,9 @@ module Sequel
         #   Artist.first_by_name(nil)
         #   # WHERE (name IS NULL)
         #
-        # See Dataset::PlaceholderLiteralizer for additional caveats.
+        # See Dataset::PlaceholderLiteralizer for additional caveats. Note that if the model's
+        # dataset does not support placeholder literalizers, you will not be able to use this
+        # method.
         def finder(meth=OPTS, opts=OPTS, &block)
           if block
             raise Error, "cannot pass both a method name argument and a block of Model.finder" unless meth.is_a?(Hash)

data/lib/sequel/plugins/nested_attributes.rb

@@ -33,7 +33,7 @@ module Sequel
     # objects.  You just need to make sure that the primary key field is filled in for the
     # associated object:
     #
-    #   a.update(:albums_attributes => [{id: 1, name: 'T'}])
+    #   a.update(albums_attributes: [{id: 1, name: 'T'}])
     #
     # Since the primary key field is filled in, the plugin will update the album with id 1 instead
     # of creating a new album.
@@ -42,14 +42,14 @@ module Sequel
     # entry to the hash, and also pass the :destroy option when calling +nested_attributes+:
     #
     #   Artist.nested_attributes :albums, destroy: true
-    #   a.update(:albums_attributes => [{id: 1, _delete: true}])
+    #   a.update(albums_attributes: [{id: 1, _delete: true}])
     #
     # This will delete the related associated object from the database.  If you want to leave the
     # associated object in the database, but just remove it from the association, add a _remove
     # entry in the hash, and also pass the :remove option when calling +nested_attributes+:
     #
     #   Artist.nested_attributes :albums, remove: true
-    #   a.update(:albums_attributes => [{id: 1, _remove: true}])
+    #   a.update(albums_attributes: [{id: 1, _remove: true}])
     #
     # The above example was for a one_to_many association, but the plugin also works similarly
     # for other association types.  For one_to_one and many_to_one associations, you need to
@@ -84,7 +84,7 @@ module Sequel
     # nested attributes options for that association.  This is useful for per-call filtering
     # of the allowed fields:
     #
-    #   a.set_nested_attributes(:albums, params['artist'], :fields=>%w'name')
+    #   a.set_nested_attributes(:albums, params['artist'], fields: %w'name')
     module NestedAttributes
       # Depend on the validate_associated plugin.
       def self.apply(model)

data/lib/sequel/plugins/pg_auto_constraint_validations.rb

@@ -32,7 +32,7 @@ module Sequel
     #
     # Example:
     #
-    #   album = Album.new(:artist_id=>1) # Assume no such artist exists
+    #   album = Album.new(artist_id: 1) # Assume no such artist exists
     #   begin
     #     album.save
     #   rescue Sequel::ValidationFailed

data/lib/sequel/plugins/primary_key_lookup_check_values.rb

@@ -0,0 +1,154 @@
+# frozen-string-literal: true
+
+module Sequel
+  module Plugins
+    # The primary_key_lookup_check_values plugin typecasts given primary key
+    # values before performing a lookup by primary key. If the given primary
+    # key value cannot be typecasted correctly, the lookup returns nil
+    # without issuing a query.  If the schema for the primary key column
+    # includes minimum and maximum values, this also checks the given value
+    # is not outside the range.  If the given value is outside the allowed
+    # range, the lookup returns nil without issuing a query.
+    #
+    # This affects the following Model methods:
+    #
+    # * Model.[] (when called with non-Hash)
+    # * Model.with_pk
+    # * Model.with_pk!
+    #
+    # It also affects the following Model dataset methods:
+    #
+    # * Dataset#[] (when called with Integer)
+    # * Dataset#with_pk
+    # * dataset#with_pk!
+    # 
+    # Note that this can break working code.  The above methods accept
+    # any filter condition by default, not just primary key values.  The
+    # plugin will handle Symbol, Sequel::SQL::Expression, and
+    # Sequel::LiteralString objects, but code such as the following will break:
+    #
+    #   # Return first Album where primary key is one of the given values
+    #   Album.dataset.with_pk([1, 2, 3])
+    #
+    # Usage:
+    #
+    #   # Make all model subclasses support checking primary key values before
+    #   # lookup # (called before loading subclasses)
+    #   Sequel::Model.plugin :primary_key_lookup_check_values
+    #
+    #   # Make the Album class support checking primary key values before lookup
+    #   Album.plugin :primary_key_lookup_check_values
+    module PrimaryKeyLookupCheckValues
+      def self.configure(model)
+        model.instance_exec do
+          setup_primary_key_lookup_check_values if @dataset
+        end
+      end
+
+      module ClassMethods
+        Plugins.after_set_dataset(self, :setup_primary_key_lookup_check_values)
+
+        Plugins.inherited_instance_variables(self,
+          :@primary_key_type=>nil,
+          :@primary_key_value_range=>nil)
+
+        private
+
+        # Check the given primary key value.  Typecast it to the appropriate
+        # database type if the database type is known.  If it cannot be
+        # typecasted, or the typecasted value is outside the range of column
+        # values, return nil.
+        def _check_pk_lookup_value(pk)
+          return if nil == pk
+          case pk
+          when SQL::Expression, LiteralString, Symbol
+            return pk
+          end
+          return pk unless pk_type = @primary_key_type
+
+          if pk_type.is_a?(Array)
+            return unless pk.is_a?(Array)
+            return unless pk.size == pk_type.size
+            return if pk.any?(&:nil?)
+
+            pk_value_range = @primary_key_value_range
+            i = 0
+            pk.map do |v|
+              if type = pk_type[i]
+                v = _typecast_pk_lookup_value(v, type)
+                return if nil == v
+                if pk_value_range
+                  min, max = pk_value_range[i]
+                  return if min && v < min
+                  return if max && v > max
+                end
+              end
+              i += 1
+              v
+            end
+          elsif pk.is_a?(Array)
+            return
+          elsif nil != (pk = _typecast_pk_lookup_value(pk, pk_type))
+            min, max = @primary_key_value_range
+            return if min && pk < min
+            return if max && pk > max
+            pk
+          end
+        end
+
+        # Typecast the value to the appropriate type,
+        # returning nil if it cannot be typecasted.
+        def _typecast_pk_lookup_value(value, type)
+          db.typecast_value(type, value)
+        rescue InvalidValue
+          nil
+        end
+
+        # Skip the primary key lookup if the typecasted and checked
+        # primary key value is nil.
+        def primary_key_lookup(pk)
+          unless nil == (pk = _check_pk_lookup_value(pk))
+            super
+          end
+        end
+
+        # Setup the primary key type and value range used for checking
+        # primary key values during lookup.
+        def setup_primary_key_lookup_check_values
+          if primary_key.is_a?(Array)
+            types = []
+            value_ranges = []
+            primary_key.each do |pk|
+              type, min, max = _type_min_max_values_for_column(pk)
+              types << type
+              value_ranges << ([min, max].freeze if min || max)
+            end
+            @primary_key_type = (types.freeze if types.any?)
+            @primary_key_value_range = (value_ranges.freeze if @primary_key_type && value_ranges.any?)
+          else
+            @primary_key_type, min, max = _type_min_max_values_for_column(primary_key)
+            @primary_key_value_range = ([min, max].freeze if @primary_key_type && (min || max))
+          end
+        end
+
+        # Return the type, min_value, and max_value schema entries
+        # for the column, if they exist.
+        def _type_min_max_values_for_column(column)
+          if schema = db_schema[column]
+            schema.values_at(:type, :min_value, :max_value)
+          end
+        end
+      end
+
+      module DatasetMethods
+        # Skip the primary key lookup if the typecasted and checked
+        # primary key value is nil.
+        def with_pk(pk)
+          unless nil == (pk = model.send(:_check_pk_lookup_value, pk))
+            super
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sequel/plugins/sql_comments.rb

@@ -12,7 +12,7 @@ module Sequel
     #   # SELECT * FROM albums WHERE (id = 1) LIMIT 1
     #   # -- model:Album,method_type:class,method:[]
     #
-    #   album.update(:name=>'A')
+    #   album.update(name: 'A')
     #   # UPDATE albums SET name = 'baz' WHERE (id = 1)
     #   # -- model:Album,method_type:instance,method:update
     #