sequel 5.34.0 → 5.39.0

data/doc/release_notes/5.37.0.txt

@@ -0,0 +1,30 @@
+= New Features
+
+* Model#column_previously_was and #column_previously_changed? have
+  been added to the dirty plugin, for getting the previous values
+  of the column before saving and for whether there were changes
+  before saving.
+  
+  Model#column_previously_changed? accepts :from and :to options
+  to allow you to more easily determine if the value changed from
+  and/or to specific values.
+
+  This information was previously obtainable via
+  Model#previous_changes, but these new methods offer a friendlier
+  interface.
+
+* Postgres::PGRow::{Array,Hash}Row#op has been added to the
+  pg_row_ops extension if the pg_row extension is loaded.  This
+  is similar to how the pg_array_ops, pg_hstore_ops, and
+  pg_json_ops and #op method to their objects.  This makes it
+  easier to perform row operations on literal rows.
+
+= Other Improvements
+
+* The schema_dumper extension now supports more unsigned numeric
+  types, such as "decimal(7,2) unsigned" and "real unsigned".
+
+* IntegerMigrator now raises an Migrator::Error if attempting to
+  migrate down when there are migration files missing and needed for
+  the down migration.  Previously, IntegerMigrator would not raise an
+  exception and would make no database changes in this case.

data/doc/release_notes/5.38.0.txt

@@ -0,0 +1,28 @@
+= New Features
+
+* The jdbc/mysql adapter now supports the newer
+  com.mysql.cj.jdbc.Driver driver.  The adapter will still attempt to
+  load the older com.mysql.jdbc.Driver if the com.mysql.cj.jdbc.Driver
+  is not found.
+
+= Other Improvements
+
+* When testing a connection after creating a new Database instance
+  raises an exception, the Database instance is removed from
+  Sequel::DATABASES.
+
+* The single_table_inheritance and prepared_statements plugins now
+  work correctly if loaded into the same class.
+
+* Database connect and disconnect errors are no longer swallowed when
+  calling Database#create_or_replace_view, Database#server_version
+  on PostgreSQL, or Database#create_table* on Oracle.
+
+= Backwards Compatibility
+
+* Previously, instantiating a new Database instance directly using
+  Sequel::Database.new did not test the connection by default.  That
+  was instead handled by Sequel::Database.connect.  The test
+  connection now happens inside Database#initialize.  This should only
+  affect backwards compatibility for code that is calling
+  Sequel::Database.new directly.

data/doc/release_notes/5.39.0.txt

@@ -0,0 +1,19 @@
+= New Features
+
+* On Microsoft SQL Server, the :clustered option is now supported
+  for primary key and unique constraints.  You can use a true value
+  for CLUSTERED and a false value for NONCLUSTERED.
+
+= Other Improvements
+
+* Partitioned tables are now included in the result of
+  Database#tables on PostgreSQL.
+
+* alter_table set_column_allow_null no longer drops the size of
+  binary columns on Microsoft SQL Server.
+
+* In the tree plugin, the roots_dataset method now works correctly
+  with queries using joins by qualifying the parent column.
+
+* A fork safety guide has been added, discussing fork safety issues
+  when using Sequel.

data/doc/transactions.rdoc

@@ -143,14 +143,6 @@ If you want the current savepoint to be rolled back when the savepoint block exi
     end # RELEASE SAVEPOINT
   end # COMMIT
 
-If you want the current savepoint to be rolled back when the savepoint block exits (even if an exception is not raised), use <tt>Database#rollback_on_exit(:savepoint=>true)</tt>
-
-  DB.transaction do # BEGIN
-    DB.transaction(savepoint: true) do # SAVEPOINT
-      DB.rollback_on_exit(:savepoint=>true)
-    end # ROLLBACK TO SAVEPOINT
-  end # COMMIT
-
 If you want the current savepoint and potentially enclosing savepoints to be rolled back when the savepoint blocks exit  (even if an exception is not raised), use <tt>Database#rollback_on_exit(:savepoint=>integer)</tt>
 
   DB.transaction do # BEGIN

data/doc/validations.rdoc

@@ -232,7 +232,7 @@ These methods check that the specified attributes can be valid integers or valid
 
 === +validates_operator+
 
-+validates_operator+ checks that a given +operator+ method returns a truthy value when called on attribute with a specified value for comparison.  Generally, this is used for inequality checks (>, >=, etc) but any method that can be called on the attribute that accepts an argument and returns a truthy value may be used.
++validates_operator+ checks that a given +operator+ method returns a truthy value when called on attribute with a specified value for comparison.  Generally, this is used for inequality checks (>, >=, etc.) but any method that can be called on the attribute that accepts an argument and returns a truthy value may be used.
 
   class Album < Sequel::Model
     def validate

data/lib/sequel/adapters/jdbc.rb

@@ -51,7 +51,19 @@ module Sequel
     # Raise a Sequel::AdapterNotFound if evaluating the class name raises a NameError.
     def self.load_driver(drv, gem=nil)
       load_gem(gem) if gem
-      eval drv
+      if drv.is_a?(String)
+        eval drv
+      else
+        *try, last = drv
+        try.each do |try_drv|
+          begin
+            return eval(try_drv)
+          rescue NameError
+          end
+        end
+
+        eval last
+      end
     rescue NameError
       raise Sequel::AdapterNotFound, "#{drv} not loaded#{", try installing jdbc-#{gem.to_s.downcase} gem" if gem}"
     end

data/lib/sequel/adapters/jdbc/mysql.rb

@@ -1,15 +1,15 @@
 # frozen-string-literal: true
 
-Sequel::JDBC.load_driver('com.mysql.jdbc.Driver', :MySQL)
-require_relative '../shared/mysql'
-
 module Sequel
   module JDBC
+    driver = Sequel::JDBC.load_driver(%w'com.mysql.cj.jdbc.Driver com.mysql.jdbc.Driver', :MySQL)
+    require_relative '../shared/mysql'
+
     Sequel.synchronize do
       DATABASE_SETUP[:mysql] = proc do |db|
         db.extend(Sequel::JDBC::MySQL::DatabaseMethods)
         db.extend_datasets Sequel::MySQL::DatasetMethods
-        com.mysql.jdbc.Driver
+        driver
       end
     end
 

data/lib/sequel/adapters/odbc.rb

@@ -92,12 +92,10 @@ module Sequel
           cols = s.columns(true).map{|c| [output_identifier(c.name), c.type, i+=1]}
           columns = cols.map{|c| c[0]}
           self.columns = columns
-          if rows = s.fetch_all
-            rows.each do |row|
-              hash = {}
-              cols.each{|n,t,j| hash[n] = convert_odbc_value(row[j], t)}
-              yield hash
-            end
+          s.each do |row|
+            hash = {}
+            cols.each{|n,t,j| hash[n] = convert_odbc_value(row[j], t)}
+            yield hash
           end
         end
         self

data/lib/sequel/adapters/oracle.rb

@@ -14,7 +14,8 @@ module Sequel
       # ORA-02396: exceeded maximum idle time, please connect again
       # ORA-03113: end-of-file on communication channel
       # ORA-03114: not connected to ORACLE
-      CONNECTION_ERROR_CODES = [ 28, 1012, 2396, 3113, 3114 ].freeze
+      # ORA-03135: connection lost contact
+      CONNECTION_ERROR_CODES = [ 28, 1012, 2396, 3113, 3114, 3135 ].freeze
       
       ORACLE_TYPES = {
         :blob=>lambda{|b| Sequel::SQL::Blob.new(b.read)},

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

@@ -244,6 +244,16 @@ module Sequel
       
       private
       
+      # Add CLUSTERED or NONCLUSTERED as needed
+      def add_clustered_sql_fragment(sql, opts)
+        clustered = opts[:clustered]
+        unless clustered.nil?
+          sql += " #{'NON' unless clustered}CLUSTERED"
+        end
+
+        sql
+      end
+    
       # Add dropping of the default constraint to the list of SQL queries.
       # This is necessary before dropping the column or changing its type.
       def add_drop_default_constraint_sql(sqls, table, column)
@@ -284,7 +294,7 @@ module Sequel
         when :set_column_null
           sch = schema(table).find{|k,v| k.to_s == op[:name].to_s}.last
           type = sch[:db_type]
-          if [:string, :decimal].include?(sch[:type]) && !["text", "ntext"].include?(type) && (size = (sch[:max_chars] || sch[:column_size]))
+          if [:string, :decimal, :blob].include?(sch[:type]) && !["text", "ntext"].include?(type) && (size = (sch[:max_chars] || sch[:column_size]))
             size = "MAX" if size == -1
             type += "(#{size}#{", #{sch[:scale]}" if sch[:scale] && sch[:scale].to_i > 0})"
           end
@@ -396,6 +406,11 @@ module Sequel
         super.with_quote_identifiers(true)
       end
       
+      # Handle clustered and nonclustered primary keys
+      def primary_key_constraint_sql_fragment(opts)
+        add_clustered_sql_fragment(super, opts)
+      end
+      
       # Use sp_rename to rename the table
       def rename_table_sql(name, new_name)
         "sp_rename #{literal(quote_schema_table(name))}, #{quote_identifier(schema_and_table(new_name).pop)}"
@@ -492,6 +507,11 @@ module Sequel
         :'varbinary(max)'
       end
       
+      # Handle clustered and nonclustered unique constraints
+      def unique_constraint_sql_fragment(opts)
+        add_clustered_sql_fragment(super, opts)
+      end
+
       # MSSQL supports views with check option, but not local.
       def view_with_check_option_support
         true
@@ -659,11 +679,11 @@ module Sequel
       # case by default, and that also adds a default order, so it's better to just
       # avoid the subquery.
       def select_sql
-        if @opts[:offset] && !@opts[:order] && is_2012_or_later?
-          order(1).select_sql
-        else
-          super
+        if @opts[:offset]
+          raise(Error, "Using with_ties is not supported with an offset on Microsoft SQL Server") if @opts[:limit_with_ties]
+          return order(1).select_sql if is_2012_or_later? && !@opts[:order]
         end
+        super
       end
 
       # The version of the database server.
@@ -755,6 +775,12 @@ module Sequel
         false
       end
       
+      # Use WITH TIES when limiting the result set to also include additional
+      # rows matching the last row.
+      def with_ties
+        clone(:limit_with_ties=>true)
+      end
+
       protected
       
       # If returned primary keys are requested, use OUTPUT unless already set on the
@@ -959,6 +985,10 @@ module Sequel
           sql << " TOP "
           literal_append(sql, l)
         end
+
+        if @opts[:limit_with_ties]
+          sql << " WITH TIES"
+        end
       end
 
       def update_limit_sql(sql)

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

@@ -103,12 +103,18 @@ module Sequel
           map{|r| m.call(r[:view_name])}
       end 
  
-      def view_exists?(name) 
-        m = input_identifier_meth
-        metadata_dataset.from(:all_views).
-          exclude(:owner=>IGNORE_OWNERS).
-          where(:view_name=>m.call(name)).
-          count > 0
+      # Whether a view with a given name exists.  By default, looks in all schemas other than system
+      # schemas.  If the :current_schema option is given, looks in the schema for the current user.
+      def view_exists?(name, opts=OPTS) 
+        ds = metadata_dataset.from(:all_views).where(:view_name=>input_identifier_meth.call(name))
+        
+        if opts[:current_schema]
+          ds = ds.where(:owner=>Sequel.function(:SYS_CONTEXT, 'userenv', 'current_schema'))
+        else
+          ds = ds.exclude(:owner=>IGNORE_OWNERS)
+        end
+
+        ds.count > 0
       end 
 
       # The version of the Oracle server, used for determining capability.
@@ -178,7 +184,7 @@ module Sequel
 
       def create_table_from_generator(name, generator, options)
         drop_statement, create_statements = create_table_sql_list(name, generator, options)
-        (execute_ddl(drop_statement) rescue nil) if drop_statement
+        swallow_database_error{execute_ddl(drop_statement)} if drop_statement
         create_statements.each{|sql| execute_ddl(sql)}
       end
 

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

@@ -781,7 +781,7 @@ module Sequel
         return @server_version if @server_version
         ds = dataset
         ds = ds.server(server) if server
-        @server_version ||= ds.with_sql("SELECT CAST(current_setting('server_version_num') AS integer) AS v").single_value rescue 0
+        @server_version = swallow_database_error{ds.with_sql("SELECT CAST(current_setting('server_version_num') AS integer) AS v").single_value} || 0
       end
 
       # PostgreSQL supports CREATE TABLE IF NOT EXISTS on 9.1+
@@ -846,7 +846,7 @@ module Sequel
       # :schema :: The schema to search
       # :server :: The server to use
       def tables(opts=OPTS, &block)
-        pg_class_relname('r', opts, &block)
+        pg_class_relname(['r', 'p'], opts, &block)
       end
 
       # Check whether the given type name string/symbol (e.g. :hstore) is supported by
@@ -1885,6 +1885,13 @@ module Sequel
         end
       end
 
+      # Use WITH TIES when limiting the result set to also include additional
+      # rules that have the same results for the order column as the final row.
+      # Requires PostgreSQL 13.
+      def with_ties
+        clone(:limit_with_ties=>true)
+      end
+
       protected
 
       # If returned primary keys are requested, use RETURNING unless already set on the
@@ -2071,6 +2078,37 @@ module Sequel
         false
       end
 
+      # Support FETCH FIRST WITH TIES on PostgreSQL 13+.
+      def select_limit_sql(sql)
+        l = @opts[:limit]
+        o = @opts[:offset]
+
+        return unless l || o
+
+        if @opts[:limit_with_ties]
+          if o
+            sql << " OFFSET "
+            literal_append(sql, o)
+          end
+
+          if l
+            sql << " FETCH FIRST "
+            literal_append(sql, l)
+            sql << " ROWS WITH TIES"
+          end
+        else
+          if l
+            sql << " LIMIT "
+            literal_append(sql, l)
+          end
+
+          if o
+            sql << " OFFSET "
+            literal_append(sql, o)
+          end
+        end
+      end
+
       # Support FOR SHARE locking when using the :share lock style.
       # Use SKIP LOCKED if skipping locked rows.
       def select_lock_sql(sql)

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

@@ -269,6 +269,8 @@ module Sequel
             else
               duplicate_table(table, :no_foreign_keys=>true)
             end
+          when :unique
+            duplicate_table(table, :no_unique=>true)
           else
             duplicate_table(table)
           end
@@ -422,8 +424,12 @@ module Sequel
         skip_indexes = []
         indexes(table, :only_autocreated=>true).each do |name, h|
           skip_indexes << name
-          if h[:columns].length == 1 && h[:unique]
-            unique_columns.concat(h[:columns])
+          if h[:unique]
+            if h[:columns].length == 1
+              unique_columns.concat(h[:columns])
+            elsif h[:columns].map(&:to_s) != pks && !opts[:no_unique]
+              constraints << {:type=>:unique, :columns=>h[:columns]}
+            end
           end
         end
         unique_columns -= pks

data/lib/sequel/adapters/tinytds.rb

@@ -16,6 +16,7 @@ module Sequel
         c = TinyTds::Client.new(opts)
         c.query_options.merge!(:cache_rows=>false)
 
+        # SEQUEL6: Default to ansi: true
         if opts[:ansi]
           sql = %w(
             ANSI_NULLS

data/lib/sequel/adapters/utils/mysql_mysql2.rb

@@ -18,6 +18,7 @@ module Sequel
         This connection is still waiting for a result, try again once you have the result
         closed MySQL connection
         The MySQL server is running with the --read-only option so it cannot execute this statement
+        Connection was killed
         END
         # Error messages for mysql and mysql2 that indicate the current connection should be disconnected
         MYSQL_DATABASE_DISCONNECT_ERRORS = /\A#{Regexp.union(disconnect_errors)}/

data/lib/sequel/core.rb

@@ -52,13 +52,12 @@ module Sequel
     #
     #   Sequel.datetime_class = DateTime
     #
-    # Note that +Time+ and +DateTime+ objects
-    # have a different API, and in cases where they implement the same methods,
-    # they often implement them differently (e.g. + using seconds on +Time+ and
-    # days on +DateTime+).
+    # Note that +Time+ and +DateTime+ objects have a different API, and in
+    # cases where they implement the same methods, they often implement them
+    # differently (e.g. + using seconds on +Time+ and days on +DateTime+).
     attr_accessor :datetime_class
 
-    # Set whether Sequel is being used in single threaded mode. by default,
+    # Set whether Sequel is being used in single threaded mode. By default,
     # Sequel uses a thread-safe connection pool, which isn't as fast as the
     # single threaded connection pool, and also has some additional thread
     # safety checks.  If your program will only have one thread,
@@ -67,7 +66,7 @@ module Sequel
     #   Sequel.single_threaded = true
     attr_accessor :single_threaded
 
-    # Alias of original require method, as Sequel.require is does a relative
+    # Alias of original require method, as Sequel.require does a relative
     # require for backwards compatibility.
     alias orig_require require
     private :orig_require

data/lib/sequel/database/connecting.rb

@@ -55,7 +55,6 @@ module Sequel
 
       begin
         db = c.new(opts)
-        db.test_connection if db.send(:typecast_value_boolean, opts.fetch(:test, true))
         if block_given?
           return yield(db)
         end

data/lib/sequel/database/misc.rb

@@ -166,6 +166,7 @@ module Sequel
         end
 
         initialize_load_extensions(:extensions)
+        test_connection if typecast_value_boolean(@opts.fetch(:test, true)) && respond_to?(:connect, true)
       rescue
         Sequel.synchronize{::Sequel::DATABASES.delete(self)} if keep_reference
         raise
@@ -446,6 +447,19 @@ module Sequel
       end
     end
 
+    # Swallow database errors, unless they are connect/disconnect errors.
+    def swallow_database_error
+      yield
+    rescue Sequel::DatabaseDisconnectError, DatabaseConnectionError
+      # Always raise disconnect errors
+      raise
+    rescue Sequel::DatabaseError
+      # Don't raise other database errors.
+      nil
+    # else
+    #   Don't rescue other exceptions, they will be raised normally.
+    end
+
     # Typecast the value to an SQL::Blob
     def typecast_value_blob(value)
       value.is_a?(Sequel::SQL::Blob) ? value : Sequel::SQL::Blob.new(value)