sequel 5.92.0 → 5.94.0

data/lib/sequel/database/misc.rb

@@ -36,13 +36,13 @@ module Sequel
 
     # Register a hook that will be run when a new Database is instantiated. It is
     # called with the new database handle.
-    def self.after_initialize(&block)
-      raise Error, "must provide block to after_initialize" unless block
+    def self.after_initialize
+      raise Error, "must provide block to after_initialize" unless defined?(yield)
       Sequel.synchronize do
         previous = @initialize_hook
         @initialize_hook = proc do |db|
           previous.call(db)
-          block.call(db)
+          yield(db)
         end
       end
     end

data/lib/sequel/database/query.rb

@@ -269,7 +269,7 @@ module Sequel
     def column_schema_to_ruby_default(default, type)
       return default unless default.is_a?(String)
       if COLUMN_SCHEMA_DATETIME_TYPES.include?(type)
-        if /now|today|CURRENT|getdate|\ADate\(\)\z/i.match(default)
+        if /now|today|CURRENT|getdate|\ADate\(\)\z/i =~ default
           if type == :date
             return Sequel::CURRENT_DATE
           else

data/lib/sequel/database/schema_generator.rb

@@ -126,17 +126,21 @@ module Sequel
       #               (:restrict, :cascade, :set_null, :set_default, :no_action).
       # :primary_key :: Make the column as a single primary key column.  This should not
       #                 be used if you want a single autoincrementing primary key column
-      #                 (use the primary_key method in that case).
-      # :primary_key_constraint_name :: The name to give the primary key constraint
-      # :primary_key_deferrable :: Similar to :deferrable, but for the primary key constraint
-      #                            if :primary_key is used.
+      #                 (use the primary_key method in that case).  Can be a hash to provide
+      #                 options for the constraint:
+      #                 :name :: The name to give the primary key constraint.
+      #                 :deferrable :: Sets whether the primary key constraint is deferrable.
+      # :primary_key_constraint_name :: Older option to name primary key constraint.
+      # :primary_key_deferrable :: Older option to set primary key constraint as deferrable.
       # :type :: Overrides the type given as the argument.  Generally not used by column
       #          itself, but can be passed as an option to other methods that call column.
       # :unique :: Mark the column as unique, generally has the same effect as
-      #            creating a unique index on the column.
-      # :unique_constraint_name :: The name to give the unique key constraint
-      # :unique_deferrable :: Similar to :deferrable, but for the unique constraint if :unique
-      #                       is used.
+      #            creating a unique index on the column. Can be a hash to provide options for
+      #            the constraint:
+      #            :name :: The name to give the unique constraint.
+      #            :deferrable :: Sets whether the unique constraint is deferrable.
+      # :unique_constraint_name :: Older option to name unique constraint.
+      # :unique_deferrable :: Older option to set unique constraint as deferrable.
       #
       # PostgreSQL specific options:
       #
@@ -178,6 +182,7 @@ module Sequel
       # :deferrable :: Whether the CHECK constraint should be marked DEFERRABLE.
       #
       # PostgreSQL specific options:
+      # :not_enforced :: Whether the CHECK constraint should be marked NOT ENFORCED.
       # :not_valid :: Whether the CHECK constraint should be marked NOT VALID.
       def constraint(name, *args, &block)
         opts = name.is_a?(Hash) ? name : {:name=>name}
@@ -197,9 +202,18 @@ module Sequel
       #
       # :foreign_key_constraint_name :: The name to give the foreign key constraint
       #
+      # PostgreSQL specific options:
+      #
+      # :not_enforced :: Whether the foreign key constraint should be marked NOT ENFORCED.
+      #
       # If you want a foreign key constraint without adding a column (usually because it is a
-      # composite foreign key), you can provide an array of columns as the first argument, and
-      # you can provide the :name option to name the constraint:
+      # composite foreign key), you can provide an array of columns as the first argument.
+      # This changes the method to accept constraint options instead of column options.
+      # You can provide the :name option to name the constraint.
+      #
+      # PostgreSQL specific options:
+      #
+      # :not_enforced :: Whether the foreign key constraint should be marked NOT ENFORCED.
       #
       #   foreign_key([:artist_name, :artist_location], :artists, name: :artist_fk)
       #   # ADD CONSTRAINT artist_fk FOREIGN KEY (artist_name, artist_location) REFERENCES artists

data/lib/sequel/database/schema_methods.rb

@@ -605,36 +605,63 @@ module Sequel
       end
     end
 
-    # Add primary key SQL fragment to column creation SQL.
+    # Add primary key SQL fragment to column creation SQL if column is a primary key.
     def column_definition_primary_key_sql(sql, column)
-      if column[:primary_key]
-        if name = column[:primary_key_constraint_name]
-          sql << " CONSTRAINT #{quote_identifier(name)}"
-        end
-        sql << " " << primary_key_constraint_sql_fragment(column)
-        constraint_deferrable_sql_append(sql, column[:primary_key_deferrable])
-      end
+      column_definition_add_primary_key_sql(sql, column) if column[:primary_key]
+    end
+
+    # Add primary key SQL fragment to column creation SQL (column should be a primary key).
+    def column_definition_add_primary_key_sql(sql, column)
+      constraint = column_definition_constraint_hash(column, :primary_key)
+      append_named_constraint_prefix_sql(sql, constraint[:name])
+      sql << " " << primary_key_constraint_sql_fragment(constraint)
+      constraint_deferrable_sql_append(sql, constraint[:deferrable])
     end
     
-    # Add foreign key reference SQL fragment to column creation SQL.
+    # Add foreign key reference SQL fragment to column creation SQL if column is a foreign key.
     def column_definition_references_sql(sql, column)
-      if column[:table]
-        if name = column[:foreign_key_constraint_name]
-         sql << " CONSTRAINT #{quote_identifier(name)}"
-        end
-        sql << column_references_column_constraint_sql(column)
-      end
+      column_definition_add_references_sql(sql, column) if column[:table]
+    end
+
+    # Add foreign key reference SQL fragment to column creation SQL (column should be a foreign key).
+    def column_definition_add_references_sql(sql, column)
+      append_named_constraint_prefix_sql(sql, column[:foreign_key_constraint_name])
+      sql << column_references_column_constraint_sql(column)
     end
     
-    # Add unique constraint SQL fragment to column creation SQL.
+    # Add unique constraint SQL fragment to column creation SQL if column has a unique constraint.
     def column_definition_unique_sql(sql, column)
-      if column[:unique]
-        if name = column[:unique_constraint_name]
-          sql << " CONSTRAINT #{quote_identifier(name)}"
-        end
-        sql << ' ' << unique_constraint_sql_fragment(column)
-        constraint_deferrable_sql_append(sql, column[:unique_deferrable])
+      column_definition_add_unique_sql(sql, column) if column[:unique]
+    end
+
+    # Add unique constraint SQL fragment to column creation SQL (column should have unique constraint).
+    def column_definition_add_unique_sql(sql, column)
+      constraint = column_definition_constraint_hash(column, :unique)
+      append_named_constraint_prefix_sql(sql, constraint[:name])
+      sql << ' ' << unique_constraint_sql_fragment(constraint)
+      constraint_deferrable_sql_append(sql, constraint[:deferrable])
+    end
+
+    # Add the name of the constraint to the column creation SQL.
+    def append_named_constraint_prefix_sql(sql, name)
+      sql << " CONSTRAINT #{quote_identifier(name)}" if name
+    end
+
+    # Return a hash of constraint options for the primary key or column
+    # unique constraint.
+    def column_definition_constraint_hash(column, prefix)
+      constraint = column[prefix]
+      constraint = constraint.is_a?(Hash) ? constraint.dup : {}
+
+      if name = column[:"#{prefix}_constraint_name"]
+        constraint[:name] = name
       end
+
+      if column.has_key?(:"#{prefix}_deferrable")
+        constraint[:deferrable] = column[:"#{prefix}_deferrable"]
+      end
+
+      constraint
     end
     
     # SQL for all given columns, used inside a CREATE TABLE block.
@@ -677,7 +704,7 @@ module Sequel
         check = constraint[:check]
         check = check.first if check.is_a?(Array) && check.length == 1
         check = filter_expr(check)
-        check = "(#{check})" unless check[0..0] == '(' && check[-1..-1] == ')'
+        check = "(#{check})" unless check.start_with?('(') && check.end_with?(')')
         sql << "CHECK #{check}"
       when :primary_key
         sql << "#{primary_key_constraint_sql_fragment(constraint)} #{literal(constraint[:columns])}"
@@ -733,17 +760,24 @@ module Sequel
     def create_table_sql(name, generator, options)
       unless supports_named_column_constraints?
         # Split column constraints into table constraints if they have a name
+        fk_opt_keys = [:key, :on_delete, :on_update, :deferrable]
         generator.columns.each do |c|
           if (constraint_name = c.delete(:foreign_key_constraint_name)) && (table = c.delete(:table))
             opts = {}
             opts[:name] = constraint_name
-            [:key, :on_delete, :on_update, :deferrable].each{|k| opts[k] = c[k]}
+            fk_opt_keys.each{|k| opts[k] = c[k]}
             generator.foreign_key([c[:name]], table, opts)
           end
-          if (constraint_name = c.delete(:unique_constraint_name)) && c.delete(:unique)
+
+          if c[:unique].is_a?(Hash) && c[:unique][:name]
+            generator.unique(c[:name], c.delete(:unique))
+          elsif (constraint_name = c.delete(:unique_constraint_name)) && c.delete(:unique)
             generator.unique(c[:name], :name=>constraint_name)
           end
-          if (constraint_name = c.delete(:primary_key_constraint_name)) && c.delete(:primary_key)
+
+          if c[:primary_key].is_a?(Hash) && c[:primary_key][:name]
+            generator.primary_key([c[:name]], c.delete(:primary_key))
+          elsif (constraint_name = c.delete(:primary_key_constraint_name)) && c.delete(:primary_key)
             generator.primary_key([c[:name]], :name=>constraint_name)
           end
         end

data/lib/sequel/dataset/prepared_statements.rb

@@ -91,8 +91,14 @@ module Sequel
         @opts[:log_sql]
       end
       
-      # The type of prepared statement, should be one of :select, :first,
-      # :insert, :update, :delete, or :single_value
+      # The type of SQL to generate for the prepared statement.  Generally
+      # the same as #prepared_type, but can be different.
+      def prepared_sql_type
+        @opts[:prepared_sql_type] || prepared_type
+      end
+      
+      # The type of prepared statement, which controls how the prepared statement
+      # handles results from the database.
       def prepared_type
         @opts[:prepared_type]
       end
@@ -141,7 +147,7 @@ module Sequel
       # Returns the SQL for the prepared statement, depending on
       # the type of the statement and the prepared_modify_values.
       def prepared_sql
-        case prepared_type
+        case prepared_sql_type
         when :select, :all, :each
           # Most common scenario, so listed first.
           select_sql
@@ -182,34 +188,30 @@ module Sequel
       
       # Run the method based on the type of prepared statement.
       def run(&block)
-        case prepared_type
+        case type = prepared_type
         when :select, :all
-          all(&block)
+          with_sql_all(prepared_sql, &block)
         when :each
-          each(&block)
-        when :insert_select
-          with_sql(prepared_sql).first
-        when :first
-          first
+          with_sql_each(prepared_sql, &block)
+        when :insert_select, :first
+          with_sql_first(prepared_sql)
         when :insert, :update, :delete
           if opts[:returning] && supports_returning?(prepared_type)
             returning_fetch_rows(prepared_sql)
-          elsif prepared_type == :delete
-            delete
+          elsif type == :delete
+            with_sql_delete(prepared_sql)
           else
-            public_send(prepared_type, *prepared_modify_values)
+            force_prepared_sql.public_send(type, *prepared_modify_values)
           end
-        when :insert_pk
-          fetch_rows(prepared_sql){|r| return r.values.first}
+        when :insert_pk, :single_value
+          with_sql_single_value(prepared_sql)
         when Array
           # :nocov:
-          case prepared_type[0]
+          case type[0]
           # :nocov:
           when :map, :as_hash, :to_hash, :to_hash_groups
-            public_send(*prepared_type, &block) 
+            force_prepared_sql.public_send(*type, &block) 
           end
-        when :single_value
-          single_value
         else
           raise Error, "unsupported prepared statement type used: #{prepared_type.inspect}"
         end
@@ -217,6 +219,16 @@ module Sequel
       
       private
       
+      # If the prepared_sql_type does not match the prepared statement, return a clone that
+      # with the prepared SQL, to ensure the prepared_sql_type is respected.
+      def force_prepared_sql
+        if prepared_sql_type != prepared_type
+          with_sql(prepared_sql)
+        else
+          self
+        end
+      end
+      
       # Returns the value of the prepared_args hash for the given key.
       def prepared_arg(k)
         @opts[:bind_vars][k]
@@ -294,11 +306,12 @@ module Sequel
         prepared_sql, frags = Sequel::Dataset::PlaceholderLiteralizer::Recorder.new.send(:prepared_sql_and_frags, self, prepared_args) do |pl, ds|
           ds = ds.clone(:recorder=>pl)
 
-          case type
+          sql_type = prepared_sql_type || type
+          case sql_type
           when :first, :single_value
             ds.limit(1)
           when :update, :insert, :insert_select, :delete
-            ds.with_sql(:"#{type}_sql", *values)
+            ds.with_sql(:"#{sql_type}_sql", *values)
           when :insert_pk
             ds.with_sql(:insert_sql, *values)
           else
@@ -344,13 +357,23 @@ module Sequel
       clone(:bind_vars=>bind_vars)
     end
     
-    # For the given type (:select, :first, :insert, :insert_select, :update, :delete, or :single_value),
-    # run the sql with the bind variables specified in the hash.  +values+ is a hash passed to
-    # insert or update (if one of those types is used), which may contain placeholders.
+    # For the given type, run the sql with the bind variables specified in the hash.
+    # +values+ is a hash passed to insert or update (if one of those types is used),
+    # which may contain placeholders.
+    #
+    # The following types are supported:
+    # 
+    # * :select, :all, :each, :first, :single_value, :insert, :insert_select, :insert_pk, :update, :delete
+    # * Array where first element is :map, :as_hash, :to_hash, :to_hash_groups (remaining elements
+    #   are passed to the related method)
     #
     #   DB[:table].where(id: :$id).call(:first, id: 1)
     #   # SELECT * FROM table WHERE id = ? LIMIT 1 -- (1)
     #   # => {:id=>1}
+    #
+    #   DB[:table].where(id: :$id).call(:update, {c: 1, id: 2}, col: :$c)
+    #   # UPDATE table WHERE id = ? SET col = ? -- (2, 1)
+    #   # => 1
     def call(type, bind_variables=OPTS, *values, &block)
       to_prepared_statement(type, values, :extend=>bound_variable_modules).call(bind_variables, &block)
     end
@@ -371,6 +394,14 @@ module Sequel
     #   # => {:id=>1, :name=>'Blah'}
     #
     #   DB.call(:select_by_name, name: 'Blah') # Same thing
+    #
+    # +values+ given are passed to +insert+ or +update+ if they are used:
+    #
+    #   ps = DB[:table].where(id: :$i).prepare(:update, :update_name, name: :$n)
+    #
+    #   ps.call(i: 1, n: 'Blah')
+    #   # UPDATE table WHERE id = ? SET name = ? -- (1, 'Blah')
+    #   # => 1
     def prepare(type, name, *values)
       ps = to_prepared_statement(type, values, :name=>name, :extend=>prepared_statement_modules, :no_delayed_evaluations=>true)
 
@@ -387,6 +418,19 @@ module Sequel
       ps
     end
     
+    # Set the type of SQL to use for prepared statements based on this
+    # dataset.  Prepared statements default to using the same SQL type
+    # as the type that is passed to #prepare/#call, but there are cases
+    # where it is helpful to use a different SQL type.
+    #
+    # Available types are: :select, :first, :single_value, :update,
+    # :delete, :insert, :insert_select, :insert_pk
+    #
+    # Other types are treated as :select.
+    def prepare_sql_type(type)
+      clone(:prepared_sql_type => type)
+    end
+
     protected
     
     # Return a cloned copy of the current dataset extended with

data/lib/sequel/dataset/query.rb

@@ -231,8 +231,7 @@ module Sequel
     #
     #   DB[:table].for_update # SELECT * FROM table FOR UPDATE
     def for_update
-       return self if opts[:lock] == :update
-      cached_dataset(:_for_update_ds){lock_style(:update)}
+      cached_lock_style_dataset(:_for_update_ds, :update)
     end
 
     # Returns a copy of the dataset with the source changed. If no
@@ -1462,6 +1461,15 @@ module Sequel
       end
     end
 
+    # Internals of for_update and adapter-specific lock methods.
+    # Returns receiver if it already uses this lock style, and a cached
+    # dataset using the given key otherwise. The key could be derived from
+    # the style, but doing so would require allocation, so pass it in as
+    # an argument.
+    def cached_lock_style_dataset(key, style)
+      opts[:lock] == style ? self : cached_dataset(key){lock_style(style)}
+    end
+
     # The default :qualify option to use for join tables if one is not specified.
     def default_join_table_qualification
       :symbol

data/lib/sequel/dataset/sql.rb

@@ -685,10 +685,10 @@ module Sequel
     # being quoted, returns name as a string.  If identifiers are being quoted
     # quote the name with quoted_identifier.
     def quote_identifier_append(sql, name)
+      name = name.value if name.is_a?(SQL::Identifier)
       if name.is_a?(LiteralString)
         sql << name
       else
-        name = name.value if name.is_a?(SQL::Identifier)
         name = input_identifier(name)
         if quote_identifiers?
           quoted_identifier_append(sql, name)
@@ -700,11 +700,14 @@ module Sequel
 
     # Append literalization of identifier or unqualified identifier to SQL string.
     def quote_schema_table_append(sql, table)
-      schema, table = schema_and_table(table)
-      if schema
-        quote_identifier_append(sql, schema)
+      qualifiers = split_qualifiers(table)
+      table = qualifiers.pop
+
+      qualifiers.each do |q|
+        quote_identifier_append(sql, q)
         sql << '.'
       end
+
       quote_identifier_append(sql, table)
     end
 
@@ -1336,7 +1339,7 @@ module Sequel
     # SQL fragment specifying a JOIN type, converts underscores to
     # spaces and upcases.
     def join_type_sql(join_type)
-      "#{join_type.to_s.gsub('_', ' ').upcase} JOIN"
+      "#{join_type.to_s.tr('_', ' ').upcase} JOIN"
     end
 
     # Append USING clause for JOIN USING

data/lib/sequel/extensions/async_thread_pool.rb

@@ -357,7 +357,7 @@ module Sequel
           define_singleton_method(:async_job_class){proxy_klass}
 
           queue = @async_thread_queue = Queue.new
-          pool = @async_thread_pool = num_async_threads.times.map{JobProcessor.new(queue)}
+          pool = @async_thread_pool = Array.new(num_async_threads){JobProcessor.new(queue)}
           ObjectSpace.define_finalizer(db, JobProcessor.create_finalizer(queue, pool))
 
           extend_datasets(DatasetMethods)

data/lib/sequel/extensions/caller_logging.rb

@@ -60,9 +60,7 @@ module Sequel
     def external_caller_for_log
       ignore = caller_logging_ignore
       c = caller.find do |line|
-        !(line.start_with?(SEQUEL_LIB_PATH) ||
-          line.start_with?(RUBY_STDLIB) ||
-          line.start_with?(INTERNAL) ||
+        !(line.start_with?(SEQUEL_LIB_PATH, RUBY_STDLIB, INTERNAL) ||
           (ignore && line =~ ignore))
       end
 

data/lib/sequel/extensions/eval_inspect.rb

@@ -66,7 +66,7 @@ module Sequel
         # in the order they were defined.
         klass = self.class
         args = inspect_args.map do |arg|
-          if arg.is_a?(String) && arg =~ /\A\*/
+          if arg.is_a?(String) && arg.start_with?('*')
             # Special case string arguments starting with *, indicating that
             # they should return an array to be splatted as the remaining arguments.
             # Allow calling private methods to get inspect output.

data/lib/sequel/extensions/inflector.rb

@@ -159,7 +159,7 @@ class String
   # Example
   #   "puni_puni".dasherize #=> "puni-puni"
   def dasherize
-    gsub('_', '-')
+    tr('_', '-')
   end
 
   # Removes the module part from the expression in the string
@@ -189,7 +189,7 @@ class String
   #   "employee_salary" #=> "Employee salary"
   #   "author_id" #=> "Author"
   def humanize
-    gsub(/_id$/, "").gsub('_', " ").capitalize
+    gsub(/_id$/, "").tr('_', " ").capitalize
   end
 
   # Returns the plural form of the word in the string.

data/lib/sequel/extensions/migration.rb

@@ -845,7 +845,7 @@ module Sequel
         begin
           db.create_table(table){String c, :primary_key=>true}
         rescue Sequel::DatabaseError => e
-          if db.database_type == :mysql && e.message =~ /max key length/
+          if db.database_type == :mysql && e.message.include?('max key length')
             # Handle case where MySQL is used with utf8mb4 charset default, which
             # only allows a maximum length of about 190 characters for string
             # primary keys due to InnoDB limitations.

data/lib/sequel/extensions/pg_auto_parameterize.rb

@@ -463,6 +463,11 @@ module Sequel
           @opts[:no_auto_parameterize] ? super : QueryString.new
         end
 
+        # A mutable string used as the prefix when explaining a query.
+        def explain_sql_string_origin(opts)
+          @opts[:no_auto_parameterize] ? super : (QueryString.new << super)
+        end
+
         # If subquery uses with_sql with a method name symbol, get the dataset
         # with_sql was called on, and use that as the subquery, recording the
         # arguments to with_sql that will be used to calculate the sql.

data/lib/sequel/extensions/pg_hstore.rb

@@ -136,7 +136,7 @@ module Sequel
       module DatabaseMethods
         def self.extended(db)
           db.instance_exec do
-            add_named_conversion_proc(:hstore, &HStore.method(:parse))
+            add_named_conversion_proc(:hstore){|v| HStore.parse(v)}
             @schema_type_classes[:hstore] = HStore
           end
         end

data/lib/sequel/extensions/provenance.rb

@@ -97,9 +97,7 @@ module Sequel
       def provenance_source
         ignore = db.opts[:provenance_caller_ignore]
         caller.find do |line|
-          !(line.start_with?(SEQUEL_LIB_PATH) ||
-            line.start_with?(RUBY_STDLIB) ||
-            line.start_with?(INTERNAL) ||
+          !(line.start_with?(SEQUEL_LIB_PATH, RUBY_STDLIB, INTERNAL) ||
             (ignore && line =~ ignore))
         end
       end

data/lib/sequel/extensions/schema_dumper.rb

@@ -221,7 +221,7 @@ END_MIG
       else
         col_opts = if options[:same_db]
           h = {:type=>schema[:db_type]}
-          if database_type == :mysql && h[:type] =~ /\Atimestamp/
+          if database_type == :mysql && h[:type].start_with?("timestamp")
             h[:null] = true
           end
           if database_type == :mssql && schema[:max_length]

data/lib/sequel/plugins/constraint_validations.rb

@@ -164,7 +164,7 @@ module Sequel
             arg = constraint_validation_int_range(arg)
             type = :includes
           when *OPERATOR_MAP.keys
-            arg = arg.to_i if type.to_s =~ /\Aint_/
+            arg = arg.to_i if type.to_s.start_with?('int_')
             operator = OPERATOR_MAP[type]
             type = :operator
           end

data/lib/sequel/plugins/json_serializer.rb

@@ -370,9 +370,9 @@ module Sequel
         end
 
         # Convert the receiver to a JSON data structure using the given arguments.
-        def to_json_data(*args, &block)
-          if block
-            to_json(*args){|x| return block.call(x)}
+        def to_json_data(*args)
+          if defined?(yield)
+            to_json(*args){|x| return yield(x)}
           else
             to_json(*args){|x| return x}
           end

data/lib/sequel/plugins/unused_associations.rb

@@ -347,6 +347,8 @@ module Sequel
           coverage_data = options[:coverage_data] || Sequel.parse_json(File.binread(@unused_associations_coverage_file))
 
           unused_associations_data = {}
+          to_many_modification_methods = [:adder, :remover, :clearer]
+          modification_methods = [:setter, :adder, :remover, :clearer]
 
           ([self] + descendants).each do |sc|
             next unless cov_data = coverage_data[sc.name]
@@ -383,8 +385,8 @@ module Sequel
               if !info[:used]
                 (unused_associations_data[sc.name] ||= {})[assoc.to_s] = 'unused'
               elsif unused = info[:unused]
-                if unused.include?(:setter) || [:adder, :remover, :clearer].all?{|k| unused.include?(k)}
-                  [:setter, :adder, :remover, :clearer].each do |k|
+                if unused.include?(:setter) || to_many_modification_methods.all?{|k| unused.include?(k)}
+                  modification_methods.each do |k|
                     unused.delete(k)
                   end
                   unused << :read_only

data/lib/sequel/plugins/validation_class_methods.rb

@@ -208,7 +208,7 @@ module Sequel
               next if an && Array(v).all?(&:nil?)
               next if ab && Array(v).all?(&blank_meth)
               next if am && Array(a).all?{|x| !o.values.has_key?(x)}
-              block.call(o,a,v)
+              yield(o, a, v)
             end
           else
             block

data/lib/sequel/sql.rb

@@ -1733,12 +1733,11 @@ module Sequel
 
       # Automatically convert SQL::Identifiers to strings
       def convert_identifier(identifier)
-        case identifier
-        when SQL::Identifier
-          identifier.value.to_s
-        else
-          identifier
+        if identifier.is_a?(SQL::Identifier)
+          identifier = identifier.value
+          identifier = identifier.to_s unless identifier.is_a?(LiteralString)
         end
+        identifier
       end
     end
     
@@ -2053,6 +2052,9 @@ module Sequel
     end
   end
   
+  SQL::Constants::OLD = SQL::Identifier.new(LiteralString.new("OLD").freeze)
+  SQL::Constants::NEW = SQL::Identifier.new(LiteralString.new("NEW").freeze)
+
   include SQL::Constants
   extend SQL::Builders
   extend SQL::OperatorBuilders

data/lib/sequel/version.rb

@@ -6,7 +6,7 @@ module Sequel
 
   # The minor version of Sequel.  Bumped for every non-patch level
   # release, generally around once a month.
-  MINOR = 92
+  MINOR = 94
 
   # The tiny version of Sequel.  Usually 0, only bumped for bugfix
   # releases that fix regressions from previous versions.

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: sequel
 version: !ruby/object:Gem::Version
-  version: 5.92.0
+  version: 5.94.0
 platform: ruby
 authors:
 - Jeremy Evans