sequel 5.36.0 → 5.41.0

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

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

@@ -184,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
@@ -1500,9 +1500,11 @@ module Sequel
       # disallowed or there is a size specified, use the varchar type.
       # Otherwise use the text type.
       def type_literal_generic_string(column)
-        if column[:fixed]
+        if column[:text]
+          :text
+        elsif column[:fixed]
           "char(#{column[:size]||255})"
-        elsif column[:text] == false or column[:size]
+        elsif column[:text] == false || column[:size]
           "varchar(#{column[:size]||255})"
         else
           :text

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

data/lib/sequel/database/schema_methods.rb

@@ -240,7 +240,7 @@ module Sequel
       if supports_create_or_replace_view?
         options = options.merge(:replace=>true)
       else
-        drop_view(name) rescue nil
+        swallow_database_error{drop_view(name)}
       end
 
       create_view(name, source, options)
@@ -580,14 +580,14 @@ module Sequel
         sql << ' NULL'
       end
     end
-    
+
     # Add primary key SQL fragment to column creation SQL.
     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'
+        sql << " " << primary_key_constraint_sql_fragment(column)
         constraint_deferrable_sql_append(sql, column[:primary_key_deferrable])
       end
     end
@@ -608,7 +608,7 @@ module Sequel
         if name = column[:unique_constraint_name]
           sql << " CONSTRAINT #{quote_identifier(name)}"
         end
-        sql << ' UNIQUE'
+        sql << ' ' << unique_constraint_sql_fragment(column)
         constraint_deferrable_sql_append(sql, column[:unique_deferrable])
       end
     end
@@ -656,11 +656,11 @@ module Sequel
         check = "(#{check})" unless check[0..0] == '(' && check[-1..-1] == ')'
         sql << "CHECK #{check}"
       when :primary_key
-        sql << "PRIMARY KEY #{literal(constraint[:columns])}"
+        sql << "#{primary_key_constraint_sql_fragment(constraint)} #{literal(constraint[:columns])}"
       when :foreign_key
         sql << column_references_table_constraint_sql(constraint.merge(:deferrable=>nil))
       when :unique
-        sql << "UNIQUE #{literal(constraint[:columns])}"
+        sql << "#{unique_constraint_sql_fragment(constraint)} #{literal(constraint[:columns])}"
       else
         raise Error, "Invalid constraint type #{constraint[:type]}, should be :check, :primary_key, :foreign_key, or :unique"
       end
@@ -892,6 +892,11 @@ module Sequel
       on_delete_clause(action)
     end
     
+    # Add fragment for primary key specification, separated for easier overridding.
+    def primary_key_constraint_sql_fragment(_)
+      'PRIMARY KEY'
+    end
+    
     # Proxy the quote_schema_table method to the dataset
     def quote_schema_table(table)
       schema_utility_dataset.quote_schema_table(table)
@@ -1047,6 +1052,11 @@ module Sequel
       "#{type}#{literal(Array(elements)) if elements}#{' UNSIGNED' if column[:unsigned]}"
     end
 
+    # Add fragment for unique specification, separated for easier overridding.
+    def unique_constraint_sql_fragment(_)
+      'UNIQUE'
+    end
+    
     # Whether clob should be used for String text: true columns.
     def uses_clob_for_text?
       false

data/lib/sequel/database/transactions.rb

@@ -82,7 +82,7 @@ module Sequel
     # :server :: The server/shard the transaction is being executed on.
     def rollback_on_exit(opts=OPTS)
       synchronize(opts[:server]) do |conn|
-        raise Error, "Cannot call Sequel:: Database#rollback_on_exit! unless inside a transaction" unless h = _trans(conn)
+        raise Error, "Cannot call Sequel:: Database#rollback_on_exit unless inside a transaction" unless h = _trans(conn)
         rollback = !opts[:cancel]
 
         if supports_savepoints?

data/lib/sequel/dataset/actions.rb

@@ -607,14 +607,16 @@ module Sequel
     # as_hash, it accepts an optional :hash parameter, into which entries will
     # be merged. 
     #
-    #   DB[:table].select_hash(:id, :name) # SELECT id, name FROM table
+    #   DB[:table].select_hash(:id, :name)
+    #   # SELECT id, name FROM table
     #   # => {1=>'a', 2=>'b', ...}
     #
     # You can also provide an array of column names for either the key_column,
     # the value column, or both:
     #
-    #   DB[:table].select_hash([:id, :foo], [:name, :bar]) # SELECT * FROM table
-    #   # {[1, 3]=>['a', 'c'], [2, 4]=>['b', 'd'], ...}
+    #   DB[:table].select_hash([:id, :foo], [:name, :bar])
+    #   # SELECT id, foo, name, bar FROM table
+    #   # => {[1, 3]=>['a', 'c'], [2, 4]=>['b', 'd'], ...}
     #
     # When using this method, you must be sure that each expression has an alias
     # that Sequel can determine.
@@ -626,14 +628,16 @@ module Sequel
     # Similar to to_hash_groups, but only selects the columns given.  Like to_hash_groups,
     # it accepts an optional :hash parameter, into which entries will be merged. 
     #
-    #   DB[:table].select_hash_groups(:name, :id) # SELECT id, name FROM table
+    #   DB[:table].select_hash_groups(:name, :id)
+    #   # SELECT id, name FROM table
     #   # => {'a'=>[1, 4, ...], 'b'=>[2, ...], ...}
     #
     # You can also provide an array of column names for either the key_column,
     # the value column, or both:
     #
-    #   DB[:table].select_hash_groups([:first, :middle], [:last, :id]) # SELECT * FROM table
-    #   # {['a', 'b']=>[['c', 1], ['d', 2], ...], ...}
+    #   DB[:table].select_hash_groups([:first, :middle], [:last, :id])
+    #   # SELECT first, middle, last, id FROM table
+    #   # => {['a', 'b']=>[['c', 1], ['d', 2], ...], ...}
     #
     # When using this method, you must be sure that each expression has an alias
     # that Sequel can determine.

data/lib/sequel/dataset/features.rb

@@ -51,6 +51,11 @@ module Sequel
       false
     end
 
+    # Whether deleting from joined datasets is supported, false by default.
+    def supports_deleting_joins?
+      supports_modifying_joins?
+    end
+    
     # Whether the database supports derived column lists (e.g.
     # "table_expr AS table_alias(column_alias1, column_alias2, ...)"), true by
     # default.
@@ -178,6 +183,11 @@ module Sequel
       true
     end
     
+    # Whether updating joined datasets is supported, false by default.
+    def supports_updating_joins?
+      supports_modifying_joins?
+    end
+    
     # Whether the dataset supports the WINDOW clause to define windows used by multiple
     # window functions, false by default.
     def supports_window_clause?

data/lib/sequel/dataset/prepared_statements.rb

@@ -201,7 +201,9 @@ module Sequel
         when :insert_pk
           fetch_rows(prepared_sql){|r| return r.values.first}
         when Array
+          # :nocov:
           case prepared_type[0]
+          # :nocov:
           when :map, :as_hash, :to_hash, :to_hash_groups
             public_send(*prepared_type, &block) 
           end