sequel 4.36.0 → 5.61.0

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

@@ -1,7 +1,7 @@
 # frozen-string-literal: true
 
-Sequel.require 'adapters/shared/sqlanywhere'
-Sequel.require 'adapters/jdbc/transactions'
+require_relative '../shared/sqlanywhere'
+require_relative 'transactions'
 
 module Sequel
   module JDBC
@@ -23,57 +23,45 @@ module Sequel
     Sequel.synchronize do
       DATABASE_SETUP[:sqlanywhere] = proc do |db|
         db.extend(Sequel::JDBC::SqlAnywhere::DatabaseMethods)
+        db.convert_smallint_to_bool = true
         db.dataset_class = Sequel::JDBC::SqlAnywhere::Dataset
         drv
       end
     end
 
-    class TypeConvertor
-      def SqlAnywhereBoolean(r, i)
-        if v = Short(r, i)
-          v != 0
-        end
-      end
-    end
-
     module SqlAnywhere
-      # Database instance methods for Sybase databases accessed via JDBC.
       module DatabaseMethods
-        extend Sequel::Database::ResetIdentifierMangling
         include Sequel::SqlAnywhere::DatabaseMethods
         include Sequel::JDBC::Transactions
 
-        LAST_INSERT_ID = 'SELECT @@IDENTITY'.freeze
-
         private
 
-        # Get the last inserted id.
+        # Use @@IDENTITY to get the last inserted id
         def last_insert_id(conn, opts=OPTS)
           statement(conn) do |stmt|
-            sql = LAST_INSERT_ID
+            sql = 'SELECT @@IDENTITY'
             rs = log_connection_yield(sql, conn){stmt.executeQuery(sql)}
             rs.next
             rs.getLong(1)
           end
         end
-
-        def setup_type_convertor_map
-          super
-          @type_convertor_map[:SqlAnywhereBoolean] = TypeConvertor::INSTANCE.method(:SqlAnywhereBoolean)
-        end
       end
 
-      #Dataset class for Sybase datasets accessed via JDBC.
       class Dataset < JDBC::Dataset
         include Sequel::SqlAnywhere::DatasetMethods
 
         private
 
         SMALLINT_TYPE = Java::JavaSQL::Types::SMALLINT
+        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
-            map[:SqlAnywhereBoolean]
+            BOOLEAN_METHOD
           else
             super
           end

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

@@ -1,7 +1,7 @@
 # frozen-string-literal: true
 
 Sequel::JDBC.load_driver('org.sqlite.JDBC', :SQLite3)
-Sequel.require 'adapters/shared/sqlite'
+require_relative '../shared/sqlite'
 
 module Sequel
   module JDBC
@@ -14,21 +14,34 @@ module Sequel
       end
     end
 
-    # Database and Dataset support for SQLite databases accessed via JDBC.
     module SQLite
-      # Instance methods for SQLite Database objects accessed via JDBC.
+      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
-        extend Sequel::Database::ResetIdentifierMangling
         include Sequel::SQLite::DatabaseMethods
-        LAST_INSERT_ROWID = 'SELECT last_insert_rowid()'.freeze
-        FOREIGN_KEY_ERROR_RE = /query does not return ResultSet/.freeze
         
         # Swallow pointless exceptions when the foreign key list pragma
         # doesn't return any rows.
         def foreign_key_list(table, opts=OPTS)
           super
         rescue Sequel::DatabaseError => e
-          raise unless e.message =~ FOREIGN_KEY_ERROR_RE
+          raise unless foreign_key_error?(e)
           []
         end
 
@@ -37,11 +50,22 @@ module Sequel
         def indexes(table, opts=OPTS)
           super
         rescue Sequel::DatabaseError => e
-          raise unless e.message =~ FOREIGN_KEY_ERROR_RE
+          raise unless foreign_key_error?(e)
           {}
         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
@@ -51,7 +75,7 @@ module Sequel
         # Use last_insert_rowid() to get the last inserted id.
         def last_insert_id(conn, opts=OPTS)
           statement(conn) do |stmt|
-            rs = stmt.executeQuery(LAST_INSERT_ROWID)
+            rs = stmt.executeQuery('SELECT last_insert_rowid()')
             rs.next
             rs.getLong(1)
           end
@@ -72,18 +96,25 @@ module Sequel
           conn
         end
 
+        # Whether the given exception is due to a foreign key error.
+        def foreign_key_error?(exception)
+          exception.message =~ /query does not return ResultSet/
+        end
+
         # Use getLong instead of getInt for converting integers on SQLite, since SQLite does not enforce a limit of 2**32.
         # Work around regressions in jdbc-sqlite 3.8.7 for date and blob types.
         def setup_type_convertor_map
           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
@@ -91,6 +122,11 @@ module Sequel
             end
           end
         end
+
+        # The result code for the exception, if the jdbc driver supports result codes for exceptions.
+        def sqlite_error_code(exception)
+          exception.resultCode.code if exception.respond_to?(:resultCode)
+        end
       end
     end
   end

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

@@ -1,7 +1,7 @@
 # frozen-string-literal: true
 
 Sequel::JDBC.load_driver('com.microsoft.sqlserver.jdbc.SQLServerDriver')
-Sequel.require 'adapters/jdbc/mssql'
+require_relative 'mssql'
 
 module Sequel
   module JDBC
@@ -14,14 +14,39 @@ module Sequel
       end
     end
 
-    # Database and Dataset instance methods for SQLServer specific
-    # support via JDBC.
     module SQLServer
-      # Database instance methods for SQLServer databases accessed via JDBC.
+      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)
+          Sequel.string_to_time("#{v}")
+        end
+      end
+
       module DatabaseMethods
-        extend Sequel::Database::ResetIdentifierMangling
         include Sequel::JDBC::MSSQL::DatabaseMethods
 
+        def setup_type_convertor_map
+          super
+          map = @type_convertor_map
+          map[Java::JavaSQL::Types::TIME] = MSSQL_RUBY_TIME
+
+          # Work around constant lazy loading in some drivers
+          begin
+            dto = Java::MicrosoftSql::Types::DATETIMEOFFSET
+          rescue NameError
+          end
+
+          if dto
+            map[dto] = lambda do |r, i|
+              if v = r.getDateTimeOffset(i)
+                to_application_timestamp(v.to_s)
+              end
+            end
+          end
+        end
+
         # Work around a bug in SQL Server JDBC Driver 3.0, where the metadata
         # for the getColumns result set specifies an incorrect type for the
         # IS_AUTOINCREMENT column. The column is a string, but the type is
@@ -48,12 +73,12 @@ module Sequel
           end
         end
         
-        def metadata_dataset
-          super.extend(MetadataDatasetMethods)
-        end
-
         private
 
+        def _metadata_dataset
+          super.with_extend(MetadataDatasetMethods)
+        end
+
         def disconnect_error?(exception, opts)
           super || (exception.message =~ /connection is closed/)
         end

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

@@ -3,12 +3,10 @@
 module Sequel
   module JDBC
     module Transactions
-      TRANSACTION_BEGIN = 'Transaction.begin'.freeze
-      TRANSACTION_COMMIT = 'Transaction.commit'.freeze
-      TRANSACTION_RELEASE_SP = 'Transaction.release_savepoint'.freeze
-      TRANSACTION_ROLLBACK = 'Transaction.rollback'.freeze
-      TRANSACTION_ROLLBACK_SP = 'Transaction.rollback_savepoint'.freeze
-      TRANSACTION_SAVEPOINT= 'Transaction.savepoint'.freeze
+      def freeze
+        supports_savepoints?
+        super
+      end
 
       # Check the JDBC DatabaseMetaData for savepoint support
       def supports_savepoints?
@@ -27,7 +25,7 @@ module Sequel
       JDBC_TRANSACTION_ISOLATION_LEVELS = {:uncommitted=>JavaSQL::Connection::TRANSACTION_READ_UNCOMMITTED,
         :committed=>JavaSQL::Connection::TRANSACTION_READ_COMMITTED,
         :repeatable=>JavaSQL::Connection::TRANSACTION_REPEATABLE_READ,
-        :serializable=>JavaSQL::Connection::TRANSACTION_SERIALIZABLE}
+        :serializable=>JavaSQL::Connection::TRANSACTION_SERIALIZABLE}.freeze
 
       # Set the transaction isolation level on the given connection using
       # the JDBC API.
@@ -45,47 +43,38 @@ 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)}
+          log_connection_yield('Transaction.begin', conn){conn.setAutoCommit(false)}
           set_transaction_isolation(conn, opts)
         end
       end
       
       # 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_SP, 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}
+          log_connection_yield('Transaction.commit', conn){conn.commit}
         end
       end
       
       # 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
@@ -94,15 +83,10 @@ 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_SP, 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}
+          log_connection_yield('Transaction.rollback', conn){conn.rollback}
         end
       end
     end