sequel 5.35.0 → 5.40.0

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
@@ -59,11 +71,11 @@ module Sequel
     class TypeConvertor
       CONVERTORS = convertors = {}
       %w'Boolean Float Double Int Long Short'.each do |meth|
-        x = convertors[meth.to_sym] = Object.new
+        x = x = convertors[meth.to_sym] = Object.new
         class_eval("def x.call(r, i) v = r.get#{meth}(i); v unless r.wasNull end", __FILE__, __LINE__)
       end
       %w'Object Array String Time Date Timestamp BigDecimal Blob Bytes Clob'.each do |meth|
-        x = convertors[meth.to_sym] = Object.new
+        x = x = convertors[meth.to_sym] = Object.new
         class_eval("def x.call(r, i) r.get#{meth}(i) end", __FILE__, __LINE__)
       end
       x = convertors[:RubyTime] = Object.new

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/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

@@ -561,7 +561,7 @@ module Sequel
       Dataset.def_sql_method(self, :delete, [['if db.sqlite_version >= 30803', %w'with delete from where'], ["else", %w'delete from where']])
       Dataset.def_sql_method(self, :insert, [['if db.sqlite_version >= 30803', %w'with insert conflict into columns values on_conflict'], ["else", %w'insert conflict into columns values']])
       Dataset.def_sql_method(self, :select, [['if opts[:values]', %w'with values compounds'], ['else', %w'with select distinct columns from join where group having window compounds order limit lock']])
-      Dataset.def_sql_method(self, :update, [['if db.sqlite_version >= 30803', %w'with update table set where'], ["else", %w'update table set where']])
+      Dataset.def_sql_method(self, :update, [['if db.sqlite_version >= 33300', %w'with update table set from where'], ['elsif db.sqlite_version >= 30803', %w'with update table set where'], ["else", %w'update table set where']])
 
       def cast_sql_append(sql, expr, type)
         if type == Time or type == DateTime
@@ -753,6 +753,11 @@ module Sequel
         false
       end
 
+      # SQLite does not support deleting from a joined dataset
+      def supports_deleting_joins?
+        false
+      end
+
       # SQLite does not support INTERSECT ALL or EXCEPT ALL
       def supports_intersect_except_all?
         false
@@ -763,6 +768,11 @@ module Sequel
         false
       end
       
+      # SQLite 3.33.0 supports modifying joined datasets
+      def supports_modifying_joins?
+        db.sqlite_version >= 33300
+      end
+
       # SQLite does not support multiple columns for the IN/NOT IN operators
       def supports_multiple_column_in?
         false
@@ -825,6 +835,13 @@ module Sequel
         end
       end
 
+      # Raise an InvalidOperation exception if insert is not allowed for this dataset.
+      def check_insert_allowed!
+        raise(InvalidOperation, "Grouped datasets cannot be modified") if opts[:group]
+        raise(InvalidOperation, "Joined datasets cannot be modified") if joined_dataset?
+      end
+      alias check_delete_allowed! check_insert_allowed!
+
       # SQLite supports a maximum of 500 rows in a VALUES clause.
       def default_import_slice
         500
@@ -944,6 +961,23 @@ module Sequel
       def _truncate_sql(table)
         "DELETE FROM #{table}"
       end
+
+      # Use FROM to specify additional tables in an update query
+      def update_from_sql(sql)
+        if(from = @opts[:from][1..-1]).empty?
+          raise(Error, 'Need multiple FROM tables if updating/deleting a dataset with JOINs') if @opts[:join]
+        else
+          sql << ' FROM '
+          source_list_append(sql, from)
+          select_join_sql(sql)
+        end
+      end
+
+      # Only include the primary table in the main update clause
+      def update_table_sql(sql)
+        sql << ' '
+        source_list_append(sql, @opts[:from][0..0])
+      end
     end
   end
 end

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)

data/lib/sequel/database/schema_generator.rb

@@ -143,8 +143,14 @@ module Sequel
       # :identity :: Create an identity column.
       #
       # MySQL specific options:
+      #
       # :generated_type :: Set the type of column when using :generated_always_as,
       #                    should be :virtual or :stored to force a type.
+      #
+      # Microsoft SQL Server specific options:
+      #
+      # :clustered :: When using :primary_key or :unique, marks the primary key or unique
+      #               constraint as CLUSTERED (if true), or NONCLUSTERED (if false).
       def column(name, type, opts = OPTS)
         columns << {:name => name, :type => type}.merge!(opts)
         if index_opts = opts[:index]