sequel 5.8.0 → 5.38.0

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
 
@@ -54,12 +54,12 @@ module Sequel
         # MySQL 5.1.12 JDBC adapter requires generated keys
         # and previous versions don't mind.
         def execute_statement_insert(stmt, sql)
-          stmt.executeUpdate(sql, JavaSQL::Statement.RETURN_GENERATED_KEYS)
+          stmt.executeUpdate(sql, JavaSQL::Statement::RETURN_GENERATED_KEYS)
         end
 
         # Return generated keys for insert statements.
         def prepare_jdbc_statement(conn, sql, opts)
-          opts[:type] == :insert ? conn.prepareStatement(sql, JavaSQL::Statement.RETURN_GENERATED_KEYS) : super
+          opts[:type] == :insert ? conn.prepareStatement(sql, JavaSQL::Statement::RETURN_GENERATED_KEYS) : super
         end
 
         # Convert tinyint(1) type to boolean

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

@@ -16,19 +16,20 @@ module Sequel
 
     module Oracle
       JAVA_BIG_DECIMAL_CONSTRUCTOR = java.math.BigDecimal.java_class.constructor(Java::long).method(:new_instance)
-
-      def self.OracleDecimal(r, i)
+      ORACLE_DECIMAL = Object.new
+      def ORACLE_DECIMAL.call(r, i)
         if v = r.getBigDecimal(i)
           i = v.long_value
           if v == JAVA_BIG_DECIMAL_CONSTRUCTOR.call(i)
             i
           else
-            BigDecimal.new(v.to_string)
+            ::Kernel::BigDecimal(v.to_string)
           end
         end
       end 
 
-      def self.OracleClob(r, i)
+      ORACLE_CLOB = Object.new
+      def ORACLE_CLOB.call(r, i)
         return unless clob = r.getClob(i)
         str = clob.getSubString(1, clob.length)
         clob.freeTemporary if clob.isTemporary
@@ -110,8 +111,8 @@ module Sequel
 
         def setup_type_convertor_map
           super
-          @type_convertor_map[:OracleDecimal] = Oracle.method(:OracleDecimal)
-          @type_convertor_map[:OracleClob] = Oracle.method(:OracleClob)
+          @type_convertor_map[:OracleDecimal] = ORACLE_DECIMAL
+          @type_convertor_map[:OracleClob] = ORACLE_CLOB
         end
       end
       

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

@@ -14,24 +14,6 @@ module Sequel
     end
 
     module Postgres
-      # Return PostgreSQL array types as ruby Arrays instead of
-      # JDBC PostgreSQL driver-specific array type. Only used if the
-      # database does not have a conversion proc for the type.
-      def self.RubyPGArray(r, i)
-        if v = r.getArray(i)
-          v.array.to_ary
-        end
-      end 
-
-      # Return PostgreSQL hstore types as ruby Hashes instead of
-      # Java HashMaps.  Only used if the database does not have a
-      # conversion proc for the type.
-      def self.RubyPGHstore(r, i)
-        if v = r.getObject(i)
-          v.to_hash
-        end
-      end 
-
       module DatabaseMethods
         include Sequel::Postgres::DatabaseMethods
 
@@ -135,11 +117,6 @@ module Sequel
 
         private
         
-        DATABASE_ERROR_CLASSES = [NativeException].freeze
-        def database_error_classes
-          DATABASE_ERROR_CLASSES
-        end
-
         def disconnect_error?(exception, opts)
           super || exception.message =~ /\A(This connection has been closed\.|FATAL: terminating connection due to administrator command|An I\/O error occurred while sending to the backend\.)\z/
         end
@@ -203,6 +180,12 @@ module Sequel
       
       class Dataset < JDBC::Dataset
         include Sequel::Postgres::DatasetMethods
+
+        # Warn when calling as the fetch size is ignored by the JDBC adapter currently.
+        def with_fetch_size(size)
+          warn("Sequel::JDBC::Postgres::Dataset#with_fetch_size does not currently have an effect.", :uplevel=>1)
+          super
+        end
         
         private
         
@@ -218,9 +201,17 @@ module Sequel
 
         STRING_TYPE = Java::JavaSQL::Types::VARCHAR
         ARRAY_TYPE = Java::JavaSQL::Types::ARRAY
-        ARRAY_METHOD = Postgres.method(:RubyPGArray)
-        PG_SPECIFIC_TYPES = [ARRAY_TYPE, Java::JavaSQL::Types::OTHER, Java::JavaSQL::Types::STRUCT].freeze
-        HSTORE_METHOD = Postgres.method(:RubyPGHstore)
+        PG_SPECIFIC_TYPES = [Java::JavaSQL::Types::ARRAY, Java::JavaSQL::Types::OTHER, Java::JavaSQL::Types::STRUCT, Java::JavaSQL::Types::TIME_WITH_TIMEZONE, Java::JavaSQL::Types::TIME].freeze
+
+        # Return PostgreSQL hstore types as ruby Hashes instead of
+        # Java HashMaps.  Only used if the database does not have a
+        # conversion proc for the type.
+        HSTORE_METHOD = Object.new
+        def HSTORE_METHOD.call(r, i)
+          if v = r.getObject(i)
+            v.to_hash
+          end
+        end 
 
         def type_convertor(map, meta, type, i)
           case type
@@ -228,8 +219,6 @@ module Sequel
             oid = meta.getField(i).getOID
             if pr = db.oid_convertor_proc(oid)
               pr
-            elsif type == ARRAY_TYPE
-              ARRAY_METHOD
             elsif oid == 2950 # UUID
               map[STRING_TYPE]
             elsif meta.getPGType(i) == 'hstore'

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

@@ -30,11 +30,6 @@ module Sequel
     end
 
     module SqlAnywhere
-      def self.SqlAnywhereBoolean(r, i)
-        v = r.getShort(i)
-        v != 0 unless r.wasNull
-      end
-
       module DatabaseMethods
         include Sequel::SqlAnywhere::DatabaseMethods
         include Sequel::JDBC::Transactions
@@ -58,7 +53,11 @@ module Sequel
         private
 
         SMALLINT_TYPE = Java::JavaSQL::Types::SMALLINT
-        BOOLEAN_METHOD = SqlAnywhere.method(:SqlAnywhereBoolean)
+        BOOLEAN_METHOD = Object.new
+        def BOOLEAN_METHOD.call(r, i)
+          v = r.getShort(i)
+          v != 0 unless r.wasNull
+        end
 
         def type_convertor(map, meta, type, i)
           if convert_smallint_to_bool && type == SMALLINT_TYPE

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

@@ -15,6 +15,24 @@ module Sequel
     end
 
     module SQLite
+      module ForeignKeyListPragmaConvertorFix
+        # For the use of the convertor for String, working around a bug
+        # in jdbc-sqlite3 that reports fields are of type
+        # java.sql.types.NUMERIC even though they contain non-numeric data.
+        def type_convertor(_, _, _, i)
+          i > 2 ? TypeConvertor::CONVERTORS[:String] : super
+        end
+      end
+
+      module TableInfoPragmaConvertorFix
+        # For the use of the convertor for String, working around a bug
+        # in jdbc-sqlite3 that reports dflt_value field is of type
+        # java.sql.types.NUMERIC even though they contain string data.
+        def type_convertor(_, _, _, i)
+          i == 5 ? TypeConvertor::CONVERTORS[:String] : super
+        end
+      end
+
       module DatabaseMethods
         include Sequel::SQLite::DatabaseMethods
         
@@ -37,6 +55,17 @@ module Sequel
         end
 
         private
+
+
+        # Add workaround for bug when running foreign_key_list pragma
+        def _foreign_key_list_ds(_)
+          super.with_extend(ForeignKeyListPragmaConvertorFix)
+        end
+
+        # Add workaround for bug when running table_info pragma
+        def _parse_pragma_ds(_, _)
+          super.with_extend(TableInfoPragmaConvertorFix)
+        end
         
         DATABASE_ERROR_REGEXPS = Sequel::SQLite::DatabaseMethods::DATABASE_ERROR_REGEXPS.merge(/Abort due to constraint violation/ => ConstraintViolation).freeze
         def database_error_regexps
@@ -78,12 +107,14 @@ module Sequel
           super
           @type_convertor_map[Java::JavaSQL::Types::INTEGER] = @type_convertor_map[Java::JavaSQL::Types::BIGINT]
           @basic_type_convertor_map[Java::JavaSQL::Types::INTEGER] = @basic_type_convertor_map[Java::JavaSQL::Types::BIGINT]
-          @type_convertor_map[Java::JavaSQL::Types::DATE] = lambda do |r, i|
+          x = @type_convertor_map[Java::JavaSQL::Types::DATE] = Object.new
+          def x.call(r, i)
             if v = r.getString(i)
               Sequel.string_to_date(v)
             end
           end
-          @type_convertor_map[Java::JavaSQL::Types::BLOB] = lambda do |r, i|
+          x = @type_convertor_map[Java::JavaSQL::Types::BLOB] = Object.new
+          def x.call(r, i)
             if v = r.getBytes(i)
               Sequel::SQL::Blob.new(String.from_java_bytes(v))
             elsif !r.wasNull

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

@@ -15,7 +15,8 @@ module Sequel
     end
 
     module SQLServer
-      def self.MSSQLRubyTime(r, i)
+      MSSQL_RUBY_TIME = Object.new
+      def MSSQL_RUBY_TIME.call(r, i)
         # MSSQL-Server TIME should be fetched as string to keep the precision intact, see:
         # https://docs.microsoft.com/en-us/sql/t-sql/data-types/time-transact-sql#a-namebackwardcompatibilityfordownlevelclientsa-backward-compatibility-for-down-level-clients
         if v = r.getString(i)
@@ -29,7 +30,7 @@ module Sequel
         def setup_type_convertor_map
           super
           map = @type_convertor_map
-          map[Java::JavaSQL::Types::TIME] = SQLServer.method(:MSSQLRubyTime)
+          map[Java::JavaSQL::Types::TIME] = MSSQL_RUBY_TIME
 
           # Work around constant lazy loading in some drivers
           begin
@@ -75,7 +76,7 @@ module Sequel
         private
 
         def _metadata_dataset
-          super.extend(MetadataDatasetMethods)
+          super.with_extend(MetadataDatasetMethods)
         end
 
         def disconnect_error?(exception, opts)

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

@@ -43,17 +43,15 @@ module Sequel
         true
       end
 
+      # JDBC savepoint object for the current savepoint for the connection.
+      def savepoint_obj(conn)
+        _trans(conn)[:savepoints][-1][:obj]
+      end
+
       # Use JDBC connection's setAutoCommit to false to start transactions
       def begin_transaction(conn, opts=OPTS)
-        if supports_savepoints?
-          th = _trans(conn)
-          if sps = th[:savepoint_objs]
-            sps << log_connection_yield('Transaction.savepoint', conn){conn.set_savepoint}
-          else
-            log_connection_yield('Transaction.begin', conn){conn.setAutoCommit(false)}
-            th[:savepoint_objs] = []
-            set_transaction_isolation(conn, opts)
-          end
+        if in_savepoint?(conn)
+          _trans(conn)[:savepoints][-1][:obj] = log_connection_yield('Transaction.savepoint', conn){conn.set_savepoint}
         else
           log_connection_yield('Transaction.begin', conn){conn.setAutoCommit(false)}
           set_transaction_isolation(conn, opts)
@@ -62,12 +60,9 @@ module Sequel
       
       # Use JDBC connection's commit method to commit transactions
       def commit_transaction(conn, opts=OPTS)
-        if supports_savepoints?
-          sps = _trans(conn)[:savepoint_objs]
-          if sps.empty?
-            log_connection_yield('Transaction.commit', conn){conn.commit}
-          elsif supports_releasing_savepoints?
-            log_connection_yield('Transaction.release_savepoint', conn){supports_releasing_savepoints? ? conn.release_savepoint(sps.last) : sps.last}
+        if in_savepoint?(conn)
+          if supports_releasing_savepoints?
+            log_connection_yield('Transaction.release_savepoint', conn){conn.release_savepoint(savepoint_obj(conn))}
           end
         else
           log_connection_yield('Transaction.commit', conn){conn.commit}
@@ -77,13 +72,9 @@ module Sequel
       # Use JDBC connection's setAutoCommit to true to enable non-transactional behavior
       def remove_transaction(conn, committed)
         if jdbc_level = _trans(conn)[:original_jdbc_isolation_level]
-          conn.setTransactionIsolation(jdbc_level)
+          log_connection_yield("Transaction.restore_isolation_level", conn){conn.setTransactionIsolation(jdbc_level)}
         end
-        if supports_savepoints?
-          sps = _trans(conn)[:savepoint_objs]
-          conn.setAutoCommit(true) if sps.empty?
-          sps.pop
-        else
+        unless in_savepoint?(conn)
           conn.setAutoCommit(true)
         end
       ensure
@@ -92,13 +83,8 @@ module Sequel
       
       # Use JDBC connection's rollback method to rollback transactions
       def rollback_transaction(conn, opts=OPTS)
-        if supports_savepoints?
-          sps = _trans(conn)[:savepoint_objs]
-          if sps.empty?
-            log_connection_yield('Transaction.rollback', conn){conn.rollback}
-          else
-            log_connection_yield('Transaction.rollback_savepoint', conn){conn.rollback(sps.last)}
-          end
+        if in_savepoint?(conn)
+          log_connection_yield('Transaction.rollback_savepoint', conn){conn.rollback(savepoint_obj(conn))}
         else
           log_connection_yield('Transaction.rollback', conn){conn.rollback}
         end

data/lib/sequel/adapters/mysql.rb

@@ -1,10 +1,6 @@
 # frozen-string-literal: true
 
-begin
-  require "mysqlplus"
-rescue LoadError
-  require 'mysql'
-end
+require 'mysql'
 raise(LoadError, "require 'mysql' did not define Mysql::CLIENT_MULTI_RESULTS!\n  You are probably using the pure ruby mysql.rb driver,\n  which Sequel does not support. You need to install\n  the C based adapter, and make sure that the mysql.so\n  file is loaded instead of the mysql.rb file.\n") unless defined?(Mysql::CLIENT_MULTI_RESULTS)
 
 require_relative 'utils/mysql_mysql2'
@@ -12,19 +8,22 @@ require_relative 'utils/mysql_prepared_statements'
 
 module Sequel
   module MySQL
-    TYPE_TRANSLATOR = tt = Class.new do
-      def boolean(s) s.to_i != 0 end
-      def integer(s) s.to_i end
-      def float(s) s.to_f end
-    end.new.freeze
+    boolean = Object.new
+    def boolean.call(s) s.to_i != 0 end
+    TYPE_TRANSLATOR_BOOLEAN = boolean.freeze
+    integer = Object.new
+    def integer.call(s) s.to_i end
+    TYPE_TRANSLATOR_INTEGER = integer.freeze
+    float = Object.new
+    def float.call(s) s.to_f end
 
     # Hash with integer keys and callable values for converting MySQL types.
     MYSQL_TYPES = {}
     {
-      [0, 246] => ::BigDecimal.method(:new),
-      [2, 3, 8, 9, 13, 247, 248] => tt.method(:integer),
-      [4, 5] => tt.method(:float),
-      [249, 250, 251, 252] => ::Sequel::SQL::Blob.method(:new)
+      [0, 246] => ::Kernel.method(:BigDecimal),
+      [2, 3, 8, 9, 13, 247, 248] => integer,
+      [4, 5] => float,
+      [249, 250, 251, 252] => ::Sequel::SQL::Blob
     }.each do |k,v|
       k.each{|n| MYSQL_TYPES[n] = v}
     end
@@ -135,7 +134,7 @@ module Sequel
       # Modify the type translator used for the tinyint type based
       # on the value given.
       def convert_tinyint_to_bool=(v)
-        @conversion_procs[1] = TYPE_TRANSLATOR.method(v ? :boolean : :integer)
+        @conversion_procs[1] = v ? TYPE_TRANSLATOR_BOOLEAN : TYPE_TRANSLATOR_INTEGER
         @convert_tinyint_to_bool = v
       end
 

data/lib/sequel/adapters/mysql2.rb

@@ -36,7 +36,6 @@ module Sequel
       # options such as :local_infile.
       def connect(server)
         opts = server_opts(server)
-        opts[:host] ||= 'localhost'
         opts[:username] ||= opts.delete(:user)
         opts[:flags] ||= 0
         opts[:flags] |= ::Mysql2::Client::FOUND_ROWS if ::Mysql2::Client.const_defined?(:FOUND_ROWS)
@@ -78,8 +77,8 @@ module Sequel
       end
 
       # Return the version of the MySQL server to which we are connecting.
-      def server_version(server=nil)
-        @server_version ||= (synchronize(server){|conn| conn.server_info[:id]} || super)
+      def server_version(_server=nil)
+        @server_version ||= super()
       end
 
       private
@@ -245,6 +244,9 @@ module Sequel
       # it hasn't been disabled.
       def paged_each(opts=OPTS, &block)
         if STREAMING_SUPPORTED && opts[:stream] != false
+          unless block_given?
+            return enum_for(:paged_each, opts)
+          end
           stream.each(&block)
         else
           super

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)},
@@ -115,7 +116,7 @@ module Sequel
 
       PS_TYPES = {'string'=>String, 'integer'=>Integer, 'float'=>Float,
         'decimal'=>Float, 'date'=>Time, 'datetime'=>Time,
-        'time'=>Time, 'boolean'=>String, 'blob'=>OCI8::BLOB}.freeze
+        'time'=>Time, 'boolean'=>String, 'blob'=>OCI8::BLOB, 'clob'=>OCI8::CLOB}.freeze
       def cursor_bind_params(conn, cursor, args)
         i = 0
         args.map do |arg, type|
@@ -129,6 +130,10 @@ module Sequel
             arg = arg.to_f
           when ::Sequel::SQL::Blob
             arg = ::OCI8::BLOB.new(conn, arg)
+          when String
+            if type == 'clob'
+              arg = ::OCI8::CLOB.new(conn, arg)
+            end
           end
           cursor.bind_param(i, arg, PS_TYPES[type] || arg.class)
           arg
@@ -347,11 +352,6 @@ module Sequel
           i = prepared_args.length
           LiteralString.new(":#{i}")
         end
-
-        # Always assume a prepared argument.
-        def prepared_arg?(k)
-          true
-        end
       end
       
       BindArgumentMethods = prepared_statements_module(:bind, ArgumentMapper)