sequel 4.40.0 → 4.41.0

data/lib/sequel/adapters/jdbc.rb

@@ -223,7 +223,7 @@ module Sequel
               raise(Sequel::DatabaseError, 'driver.new.connect returned nil: probably bad JDBC connection string') unless c
               c
             rescue JavaSQL::SQLException, NativeException, StandardError => e2
-              unless e2.message == e.message
+              if e2.respond_to?(:message=) && e2.message != e.message
                 e2.message = "#{e2.message}\n#{e.class.name}: #{e.message}"
               end
               raise e2

data/lib/sequel/adapters/mysql2.rb

@@ -86,7 +86,6 @@ module Sequel
       if NativePreparedStatements
         # Use a native mysql2 prepared statement to implement prepared statements.
         def execute_prepared_statement(ps_name, opts, &block)
-          args = opts[:arguments]
           ps = prepared_statement(ps_name)
           sql = ps.prepared_sql
 

data/lib/sequel/adapters/shared/db2.rb

@@ -85,6 +85,17 @@ module Sequel
         indexes
       end
 
+      def offset_strategy
+        return @offset_strategy if defined?(@offset_strategy)
+
+        @offset_strategy = case strategy = opts[:offset_strategy].to_s
+        when "limit_offset", "offset_fetch"
+          opts[:offset_strategy] = strategy.to_sym
+        else
+          opts[:offset_strategy] = :emulate
+        end
+      end
+
       # DB2 supports transaction isolation levels.
       def supports_transaction_isolation_levels?
         true
@@ -371,6 +382,13 @@ module Sequel
         EMPTY_FROM_TABLE
       end
 
+      # Emulate offset with row number by default, and also when the limit_offset
+      # strategy is used without a limit, as DB2 doesn't support that syntax with
+      # no limit.
+      def emulate_offset_with_row_number?
+        super && (db.offset_strategy == :emulate || (db.offset_strategy == :limit_offset && !@opts[:limit]))
+      end
+
       # DB2 needs the standard workaround to insert all default values into
       # a table with more than one column.
       def insert_supports_empty_values?
@@ -406,17 +424,19 @@ module Sequel
         false
       end
 
-      # Modify the sql to limit the number of rows returned
-      # Note: 
-      #
-      #     After db2 v9.7, MySQL flavored "LIMIT X OFFSET Y" can be enabled using
-      #
-      #     db2set DB2_COMPATIBILITY_VECTOR=MYSQL
-      #     db2stop
-      #     db2start
-      #
-      #     Support for this feature is not used in this adapter however.
+      # Modify the sql to limit the number of rows returned.
+      # Uses :offset_strategy Database option to determine how to format the
+      # limit and offset.
       def select_limit_sql(sql)
+        strategy = db.offset_strategy
+        return super if strategy == :limit_offset
+
+        if strategy == :offset_fetch && (o = @opts[:offset]) 
+          sql << " OFFSET "
+          literal_append(sql, o)
+          sql << " ROWS"
+        end
+
         if l = @opts[:limit]
           if l == 1
             sql << FETCH_FIRST_ROW_ONLY

data/lib/sequel/adapters/shared/mssql.rb

@@ -405,9 +405,7 @@ module Sequel
 
       # Always quote identifiers in the metadata_dataset, so schema parsing works.
       def metadata_dataset
-        ds = super
-        ds.quote_identifiers = true
-        ds
+        super.with_quote_identifiers(true)
       end
       
       # Use sp_rename to rename the table
@@ -574,7 +572,7 @@ module Sequel
       ROWS_ONLY = " ROWS ONLY".freeze
       FETCH_NEXT = " FETCH NEXT ".freeze
 
-      NON_SQL_OPTIONS = (Dataset::NON_SQL_OPTIONS + [:disable_insert_output]).freeze
+      NON_SQL_OPTIONS = (Dataset::NON_SQL_OPTIONS + [:disable_insert_output, :mssql_unicode_strings]).freeze
 
       Dataset.def_mutation_method(:disable_insert_output, :output, :module=>self)
       Dataset.def_sql_method(self, :delete, %w'with delete from output from2 where')
@@ -582,11 +580,18 @@ module Sequel
       Dataset.def_sql_method(self, :update, [['if is_2005_or_later?', %w'with update limit table set output from where'], ['else', %w'update table set output from where']])
 
       # Allow overriding of the mssql_unicode_strings option at the dataset level.
-      attr_writer :mssql_unicode_strings
+      def mssql_unicode_strings=(v)
+        @opts[:mssql_unicode_strings] = v
+      end
 
       # Use the database's mssql_unicode_strings setting if the dataset hasn't overridden it.
       def mssql_unicode_strings
-        defined?(@mssql_unicode_strings) ? @mssql_unicode_strings : (@mssql_unicode_strings = db.mssql_unicode_strings)
+        opts.has_key?(:mssql_unicode_strings) ? opts[:mssql_unicode_strings] : db.mssql_unicode_strings
+      end
+
+      # Return a cloned dataset with the mssql_unicode_strings option set.
+      def with_mssql_unicode_strings(v)
+        clone(:mssql_unicode_strings=>v)
       end
 
       # MSSQL uses + for string concatenation, and LIKE is case insensitive by default.

data/lib/sequel/database/query.rb

@@ -291,12 +291,9 @@ module Sequel
     # for this database.  Used when parsing metadata so that column symbols are
     # returned as expected.
     def metadata_dataset
-      @metadata_dataset ||= (
-        ds = dataset;
-        ds.identifier_input_method = identifier_input_method_default;
-        ds.identifier_output_method = identifier_output_method_default;
-        ds
-      )
+      @metadata_dataset ||= dataset.
+        with_identifier_input_method(identifier_input_method_default).
+        with_identifier_output_method(identifier_output_method_default)
     end
 
     # Return a Method object for the dataset's output_identifier_method.

data/lib/sequel/database/schema_generator.rb

@@ -18,7 +18,7 @@ module Sequel
     # the {"Schema Modification" guide}[rdoc-ref:doc/schema_modification.rdoc].
     class CreateTableGenerator
       # Classes specifying generic types that Sequel will convert to database-specific types.
-      GENERIC_TYPES=%w'String Integer Fixnum Float Numeric BigDecimal Date DateTime Time File TrueClass FalseClass'
+      GENERIC_TYPES=%w'String Integer Float Numeric BigDecimal Date DateTime Time File TrueClass FalseClass'.freeze
       
       # Return the column hashes created by this generator
       attr_reader :columns
@@ -47,6 +47,12 @@ module Sequel
         column(name, :Bignum, opts)
       end
       
+      # Use custom Fixnum method to use Integer instead of Fixnum class, to avoid 
+      # warnings on ruby 2.4+.
+      def Fixnum(name, opts=OPTS)
+        column(name, Integer, opts)
+      end
+
       # Add a method for each of the given types that creates a column
       # with that type as a constant.  Types given should either already
       # be constants/classes or a capitalized string/symbol with the same name

data/lib/sequel/database/schema_methods.rb

@@ -937,12 +937,6 @@ module Sequel
       type_literal_generic_numeric(column)
     end
 
-    # Sequel uses the bigint type by default for Bignums.
-    def type_literal_generic_bignum(column)
-      Sequel::Deprecation.deprecate("Using the Bignum class as a generic type is deprecated and will be removed in Sequel 4.41.0, as the behavior will change in ruby 2.4. Switch to using the :Bignum symbol.")
-      type_literal_generic_bignum_symbol(column)
-    end
-
     # Sequel uses the bigint type by default for :Bignum symbol.
     def type_literal_generic_bignum_symbol(column)
       :bigint

data/lib/sequel/dataset/actions.rb

@@ -135,8 +135,8 @@ module Sequel
     # running queries inside the block, you should use +all+ instead of +each+
     # for the outer queries, or use a separate thread or shard inside +each+.
     def each
-      if row_proc = @row_proc
-        fetch_rows(select_sql){|r| yield row_proc.call(r)}
+      if rp = row_proc
+        fetch_rows(select_sql){|r| yield rp.call(r)}
       else
         fetch_rows(select_sql){|r| yield r}
       end
@@ -847,8 +847,8 @@ module Sequel
     # This method should not be called on a shared dataset if the columns selected
     # in the given SQL do not match the columns in the receiver.
     def with_sql_each(sql)
-      if row_proc = @row_proc
-        fetch_rows(sql){|r| yield row_proc.call(r)}
+      if rp = row_proc
+        fetch_rows(sql){|r| yield rp.call(r)}
       else
         fetch_rows(sql){|r| yield r}
       end

data/lib/sequel/dataset/graph.rb

@@ -117,7 +117,7 @@ module Sequel
       add_columns = !ds.opts.include?(:graph_aliases)
 
       if graph = opts[:graph]
-        opts[:graph] = graph = graph.dup
+        graph = graph.dup
         select = opts[:select].dup
         [:column_aliases, :table_aliases, :column_alias_num].each{|k| graph[k] = graph[k].dup}
       else
@@ -127,7 +127,7 @@ module Sequel
         raise_alias_error.call if master == table_alias
 
         # Master hash storing all .graph related information
-        graph = opts[:graph] = {}
+        graph = {}
 
         # Associates column aliases back to tables and columns
         column_aliases = graph[:column_aliases] = {}
@@ -200,6 +200,7 @@ module Sequel
           select.push(identifier)
         end
       end
+      ds = ds.clone(:graph=>graph)
       add_columns ? ds.select(*select) : ds
     end
 

data/lib/sequel/dataset/misc.rb

@@ -248,6 +248,29 @@ module Sequel
       end
     end
 
+    # Return a modified dataset with quote_identifiers set.
+    def with_quote_identifiers(v)
+      c = clone
+      c.send(:skip_symbol_cache!)
+      c.instance_variable_set(:@quote_identifiers, v)
+      c
+    end
+    
+    # Return a modified dataset with identifier_input_method set.
+    def with_identifier_input_method(meth)
+      c = clone
+      c.send(:skip_symbol_cache!)
+      c.instance_variable_set(:@identifier_input_method, meth)
+      c
+    end
+    
+    # Return a modified dataset with identifier_output_method set.
+    def with_identifier_output_method(meth)
+      c = clone
+      c.instance_variable_set(:@identifier_output_method, meth)
+      c
+    end
+
     private
 
     # Internal recursive version of unqualified_column_for, handling Strings inside

data/lib/sequel/dataset/mutation.rb

@@ -32,22 +32,10 @@ module Sequel
     # a single hash argument and returns the object you want #each to return.
     attr_reader :row_proc
     
-    # Load an extension into the receiver.  In addition to requiring the extension file, this
-    # also modifies the dataset to work with the extension (usually extending it with a
-    # module defined in the extension file).  If no related extension file exists or the
-    # extension does not have specific support for Database objects, an Error will be raised.
-    # Returns self.
+    # Like #extension, but modifies and returns the receiver instead of returning a modified clone.
     def extension!(*exts)
       raise_if_frozen!
-      Sequel.extension(*exts)
-      exts.each do |ext|
-        if pr = Sequel.synchronize{EXTENSIONS[ext]}
-          pr.call(self)
-        else
-          raise(Error, "Extension #{ext} does not have specific support handling individual datasets (try: Sequel.extension #{ext.inspect})")
-        end
-      end
-      self
+      _extension!(exts)
     end
 
     # Avoid self-referential dataset by cloning.
@@ -92,6 +80,19 @@ module Sequel
     
     private
     
+    # Load the extensions into the receiver, without checking if the receiver is frozen.
+    def _extension!(exts)
+      Sequel.extension(*exts)
+      exts.each do |ext|
+        if pr = Sequel.synchronize{EXTENSIONS[ext]}
+          pr.call(self)
+        else
+          raise(Error, "Extension #{ext} does not have specific support handling individual datasets (try: Sequel.extension #{ext.inspect})")
+        end
+      end
+      self
+    end
+
     # Modify the receiver with the results of sending the meth, args, and block
     # to the receiver and merging the options of the resulting dataset into
     # the receiver's options.

data/lib/sequel/dataset/query.rb

@@ -148,9 +148,13 @@ module Sequel
       exclude(*cond, &block)
     end
 
-    # Return a clone of the dataset loaded with the extensions, see #extension!.
+    # Return a clone of the dataset loaded with the given dataset extensions.
+    # If no related extension file exists or the extension does not have
+    # specific support for Dataset objects, an Error will be raised.
     def extension(*exts)
-      clone.extension!(*exts)
+      c = clone
+      c.send(:_extension!, exts)
+      c
     end
 
     # Alias for where.
@@ -611,9 +615,7 @@ module Sequel
     #   ds.all # => [{2=>:id}]
     #   ds.naked.all # => [{:id=>2}]
     def naked
-      ds = clone
-      ds.row_proc = nil
-      ds
+      with_row_proc(nil)
     end
 
     # Returns a copy of the dataset with a specified order. Can be safely combined with limit.
@@ -1001,6 +1003,24 @@ module Sequel
       end
     end
     
+    # Return a clone of the dataset extended with the given modules.
+    def with_extend(*mods)
+      c = clone
+      c.extend(*mods)
+      c
+    end
+
+    # Returns a cloned dataset with the given row_proc.
+    #
+    #   ds = DB[:items]
+    #   ds.all # => [{:id=>2}]
+    #   ds.with_row_proc(proc(&:invert)).all # => [{2=>:id}]
+    def with_row_proc(callable)
+      c = clone
+      c.instance_variable_set(:@row_proc, callable)
+      c
+    end
+
     # Returns a copy of the dataset with the static SQL used.  This is useful if you want
     # to keep the same row_proc/graph, but change the SQL used to custom SQL.
     #

data/lib/sequel/extensions/constraint_validations.rb

@@ -343,9 +343,7 @@ module Sequel
     # This allows the code to handle schema qualified tables,
     # without quoting all table names.
     def constraint_validations_literal_table(table)
-      ds = dataset
-      ds.quote_identifiers = false
-      ds.literal(table)
+      dataset.with_quote_identifiers(false).literal(table)
     end
 
     # Before creating the table, add constraints for all of the

data/lib/sequel/extensions/sql_comments.rb

@@ -71,7 +71,12 @@ module Sequel
           # SQL is appened to the query after the comment is added,
           # it will become part of the comment unless it is preceded
           # by a newline.
-          sql << comment
+          if sql.frozen?
+            sql += comment
+            sql.freeze
+          else
+            sql << comment
+          end
         end
         sql
       end

data/lib/sequel/model/associations.rb

@@ -197,7 +197,13 @@ module Sequel
         # Return an dataset that will load the appropriate associated objects for
         # the given object using this association.
         def association_dataset_for(object)
-          associated_dataset.where(predicate_keys.zip(predicate_key_values(object)))
+          condition = if can_have_associated_objects?(object)
+            predicate_keys.zip(predicate_key_values(object))
+          else
+            false
+          end
+
+          associated_dataset.where(condition)
         end
 
         ASSOCIATION_DATASET_PROC = proc{|r| r.association_dataset_for(self)}

data/lib/sequel/model/base.rb

@@ -1043,7 +1043,7 @@ module Sequel
             set_columns(cols)
             # Also set the columns for the dataset, so the dataset
             # doesn't have to do a query to get them.
-            dataset.instance_variable_set(:@columns, cols)
+            dataset.send(:columns=, cols)
           end
         else
           # If the dataset uses multiple tables or custom sql or getting

data/lib/sequel/plugins/class_table_inheritance.rb

@@ -88,7 +88,7 @@ module Sequel
     #
     #   a = Employee.first
     #   a.values # {:id=>1, name=>'S', :kind=>'CEO'}
-    #   a.refresh.values # {:id=>1, name=>'S', :kind=>'Executive', :num_staff=>4, :num_managers=>2}
+    #   a.refresh.values # {:id=>1, name=>'S', :kind=>'CEO', :num_staff=>4, :num_managers=>2}
     #
     # You can also load directly from a subclass:
     #
@@ -315,6 +315,11 @@ module Sequel
           self
         end
 
+        # Don't allow use of prepared statements.
+        def use_prepared_statements_for?(type)
+          false
+        end
+
         private
 
         def cti_this(model)
@@ -360,11 +365,6 @@ module Sequel
             cti_this(m).update(h) unless h.empty?
           end
         end
-
-        # Don't allow use of prepared statements.
-        def use_prepared_statements_for?(type)
-          false
-        end
       end
     end
   end

data/lib/sequel/plugins/hook_class_methods.rb

@@ -126,7 +126,7 @@ module Sequel
           super
           model.hook_blocks(:after_destroy){|b| instance_eval(&b)}
           if model.has_hooks?(:after_destroy_commit)
-            db.after_rollback{model.hook_blocks(:after_destroy_commit){|b| instance_eval(&b)}}
+            db.after_commit{model.hook_blocks(:after_destroy_commit){|b| instance_eval(&b)}}
           end
         end
 
@@ -134,7 +134,7 @@ module Sequel
           super
           model.hook_blocks(:after_save){|b| instance_eval(&b)}
           if model.has_hooks?(:after_commit)
-            db.after_rollback{model.hook_blocks(:after_commit){|b| instance_eval(&b)}}
+            db.after_commit{model.hook_blocks(:after_commit){|b| instance_eval(&b)}}
           end
         end