sequel 4.45.0 → 4.46.0

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

@@ -186,13 +186,14 @@ module Sequel
       # Dataset subclass used for datasets that connect to PostgreSQL via JDBC.
       class Dataset < JDBC::Dataset
         include Sequel::Postgres::DatasetMethods
-        APOS = Dataset::APOS
+        APOS = "'".freeze
+        Sequel::Deprecation.deprecate_constant(self, :APOS)
         
         private
         
         # Literalize strings similar to the native postgres adapter
         def literal_string_append(sql, v)
-          sql << APOS << db.synchronize(@opts[:server]){|c| c.escape_string(v)} << APOS
+          sql << "'" << db.synchronize(@opts[:server]){|c| c.escape_string(v)} << "'"
         end
 
         # SQL fragment for Sequel::SQLTime, containing just the time part
@@ -202,7 +203,7 @@ module Sequel
 
         STRING_TYPE = Java::JavaSQL::Types::VARCHAR
         ARRAY_TYPE = Java::JavaSQL::Types::ARRAY
-        PG_SPECIFIC_TYPES = [ARRAY_TYPE, Java::JavaSQL::Types::OTHER, Java::JavaSQL::Types::STRUCT]
+        PG_SPECIFIC_TYPES = [ARRAY_TYPE, Java::JavaSQL::Types::OTHER, Java::JavaSQL::Types::STRUCT]#.freeze # SEQUEL5
         HSTORE_TYPE = 'hstore'.freeze
 
         def type_convertor(map, meta, type, i)

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

@@ -43,13 +43,14 @@ module Sequel
         include Sequel::JDBC::Transactions
 
         LAST_INSERT_ID = 'SELECT @@IDENTITY'.freeze
+        Sequel::Deprecation.deprecate_constant(self, :LAST_INSERT_ID)
 
         private
 
         # 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)

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

@@ -20,14 +20,16 @@ module Sequel
       module DatabaseMethods
         include Sequel::SQLite::DatabaseMethods
         LAST_INSERT_ROWID = 'SELECT last_insert_rowid()'.freeze
+        Sequel::Deprecation.deprecate_constant(self, :LAST_INSERT_ROWID)
         FOREIGN_KEY_ERROR_RE = /query does not return ResultSet/.freeze
+        Sequel::Deprecation.deprecate_constant(self, :FOREIGN_KEY_ERROR_RE)
         
         # 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
 
@@ -36,7 +38,7 @@ 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
 
@@ -50,7 +52,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
@@ -71,6 +73,11 @@ 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

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

@@ -14,6 +14,16 @@ module Sequel
       end
     end
 
+    class TypeConvertor
+      def MSSQLRubyTime(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
+    end
+
     # Database and Dataset instance methods for SQLServer specific
     # support via JDBC.
     module SQLServer
@@ -21,6 +31,19 @@ module Sequel
       module DatabaseMethods
         include Sequel::JDBC::MSSQL::DatabaseMethods
 
+        def setup_type_convertor_map
+          super
+          map = @type_convertor_map
+          map[Java::JavaSQL::Types::TIME] = TypeConvertor::INSTANCE.method(:MSSQLRubyTime)
+          if defined?(Java::MicrosoftSql::Types::DATETIMEOFFSET)
+            map[Java::MicrosoftSql::Types::DATETIMEOFFSET] = 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

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

@@ -4,11 +4,17 @@ module Sequel
   module JDBC
     module Transactions
       TRANSACTION_BEGIN = 'Transaction.begin'.freeze
+      Sequel::Deprecation.deprecate_constant(self, :TRANSACTION_BEGIN)
       TRANSACTION_COMMIT = 'Transaction.commit'.freeze
+      Sequel::Deprecation.deprecate_constant(self, :TRANSACTION_COMMIT)
       TRANSACTION_RELEASE_SP = 'Transaction.release_savepoint'.freeze
+      Sequel::Deprecation.deprecate_constant(self, :TRANSACTION_RELEASE_SP)
       TRANSACTION_ROLLBACK = 'Transaction.rollback'.freeze
+      Sequel::Deprecation.deprecate_constant(self, :TRANSACTION_ROLLBACK)
       TRANSACTION_ROLLBACK_SP = 'Transaction.rollback_savepoint'.freeze
+      Sequel::Deprecation.deprecate_constant(self, :TRANSACTION_ROLLBACK_SP)
       TRANSACTION_SAVEPOINT= 'Transaction.savepoint'.freeze
+      Sequel::Deprecation.deprecate_constant(self, :TRANSACTION_SAVEPOINT)
 
       def freeze
         supports_savepoints?
@@ -32,7 +38,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 # SEQUEL5
 
       # Set the transaction isolation level on the given connection using
       # the JDBC API.
@@ -55,14 +61,14 @@ module Sequel
         if supports_savepoints?
           th = _trans(conn)
           if sps = th[:savepoint_objs]
-            sps << log_connection_yield(TRANSACTION_SAVEPOINT, conn){conn.set_savepoint}
+            sps << 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)}
             th[:savepoint_objs] = []
             set_transaction_isolation(conn, opts)
           end
         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
@@ -72,12 +78,12 @@ module Sequel
         if supports_savepoints?
           sps = _trans(conn)[:savepoint_objs]
           if sps.empty?
-            log_connection_yield(TRANSACTION_COMMIT, conn){conn.commit}
+            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}
+            log_connection_yield('Transaction.release_savepoint', conn){supports_releasing_savepoints? ? conn.release_savepoint(sps.last) : sps.last}
           end
         else
-          log_connection_yield(TRANSACTION_COMMIT, conn){conn.commit}
+          log_connection_yield('Transaction.commit', conn){conn.commit}
         end
       end
       
@@ -102,12 +108,12 @@ module Sequel
         if supports_savepoints?
           sps = _trans(conn)[:savepoint_objs]
           if sps.empty?
-            log_connection_yield(TRANSACTION_ROLLBACK, conn){conn.rollback}
+            log_connection_yield('Transaction.rollback', conn){conn.rollback}
           else
-            log_connection_yield(TRANSACTION_ROLLBACK_SP, conn){conn.rollback(sps.last)}
+            log_connection_yield('Transaction.rollback_savepoint', conn){conn.rollback(sps.last)}
           end
         else
-          log_connection_yield(TRANSACTION_ROLLBACK, conn){conn.rollback}
+          log_connection_yield('Transaction.rollback', conn){conn.rollback}
         end
       end
     end

data/lib/sequel/adapters/mock.rb

@@ -296,6 +296,10 @@ module Sequel
         end
       end
 
+      def dataset_class_default
+        Dataset
+      end
+
       def quote_identifiers_default
         shared_adapter? ? super : false
       end
@@ -307,6 +311,7 @@ module Sequel
 
     class Dataset < Sequel::Dataset
       Database::DatasetClass = self
+      Sequel::Deprecation.deprecate_constant(Database, :DatasetClass)
 
       # The autoid setting for this dataset, if it has been overridden
       def autoid

data/lib/sequel/adapters/mysql.rb

@@ -28,6 +28,7 @@ module Sequel
     }.each do |k,v|
       k.each{|n| MYSQL_TYPES[n] = v}
     end
+    # MYSQL_TYPES.freeze # SEQUEL5
 
     class << self
       # Whether to convert invalid date time values by default.
@@ -47,6 +48,7 @@ module Sequel
       # Regular expression used for getting accurate number of rows
       # matched by an update statement.
       AFFECTED_ROWS_RE = /Rows matched:\s+(\d+)\s+Changed:\s+\d+\s+Warnings:\s+\d+/.freeze
+      Sequel::Deprecation.deprecate_constant(self, :AFFECTED_ROWS_RE)
       
       set_adapter_scheme :mysql
 
@@ -234,7 +236,7 @@ module Sequel
       # that may be inaccurate.
       def affected_rows(conn)
         s = conn.info
-        if s && s =~ AFFECTED_ROWS_RE
+        if s && s =~ /Rows matched:\s+(\d+)\s+Changed:\s+\d+\s+Warnings:\s+\d+/
           $1.to_i
         else
           conn.affected_rows
@@ -273,6 +275,10 @@ module Sequel
         exception.sqlstate
       end
 
+      def dataset_class_default
+        Dataset
+      end
+
       # Raise a disconnect error if the exception message matches the list
       # of recognized exceptions.
       def disconnect_error?(e, opts)
@@ -299,6 +305,7 @@ module Sequel
       include Sequel::MySQL::PreparedStatements::DatasetMethods
 
       Database::DatasetClass = self
+      Sequel::Deprecation.deprecate_constant(Database, :DatasetClass)
 
       # Yield all rows matching this dataset.  If the dataset is set to
       # split multiple statements, yield arrays of hashes one per statement

data/lib/sequel/adapters/mysql2.rb

@@ -204,6 +204,10 @@ module Sequel
         exception.sql_state
       end
 
+      def dataset_class_default
+        Dataset
+      end
+
       # If a connection object is available, try pinging it.  Otherwise, if the
       # error is a Mysql2::Error, check the SQL state and exception message for
       # disconnects.
@@ -236,6 +240,7 @@ module Sequel
       STREAMING_SUPPORTED = ::Mysql2::VERSION >= '0.3.12'
 
       Database::DatasetClass = self
+      Sequel::Deprecation.deprecate_constant(Database, :DatasetClass)
 
       if NativePreparedStatements
         PreparedStatementMethods = prepared_statements_module(
@@ -299,7 +304,7 @@ module Sequel
       # Handle correct quoting of strings using ::Mysql2::Client#escape.
       def literal_string_append(sql, v)
         s = db.synchronize(@opts[:server]){|c| c.escape(v)}
-        sql << APOS << s << APOS
+        sql << "'" << s << "'"
       end
     end
   end

data/lib/sequel/adapters/odbc.rb

@@ -12,8 +12,11 @@ module Sequel
       set_adapter_scheme :odbc
 
       GUARDED_DRV_NAME = /^\{.+\}$/.freeze
+      Sequel::Deprecation.deprecate_constant(self, :GUARDED_DRV_NAME)
       DRV_NAME_GUARDS = '{%s}'.freeze
+      Sequel::Deprecation.deprecate_constant(self, :DRV_NAME_GUARDS)
       DISCONNECT_ERRORS = /\A08S01/.freeze 
+      Sequel::Deprecation.deprecate_constant(self, :DISCONNECT_ERRORS)
 
       def connect(server)
         opts = server_opts(server)
@@ -23,8 +26,8 @@ module Sequel
           drv = ::ODBC::Driver.new
           drv.name = 'Sequel ODBC Driver130'
           opts.each do |param, value|
-            if :driver == param and not (value =~ GUARDED_DRV_NAME)
-              value = DRV_NAME_GUARDS % value
+            if :driver == param && value !~ /\A\{.+\}\z/
+              value = "{#{value}}"
             end
             drv.attrs[param.to_s.upcase] = value.to_s
           end
@@ -80,24 +83,33 @@ module Sequel
         [::ODBC::Error]
       end
 
+      def dataset_class_default
+        Dataset
+      end
+
       def disconnect_error?(e, opts)
-        super || (e.is_a?(::ODBC::Error) && DISCONNECT_ERRORS.match(e.message))
+        super || (e.is_a?(::ODBC::Error) && /\A08S01/.match(e.message))
       end
     end
     
     class Dataset < Sequel::Dataset
       BOOL_TRUE = '1'.freeze
+      Sequel::Deprecation.deprecate_constant(self, :BOOL_TRUE)
       BOOL_FALSE = '0'.freeze
+      Sequel::Deprecation.deprecate_constant(self, :BOOL_FALSE)
       ODBC_DATE_FORMAT = "{d '%Y-%m-%d'}".freeze
+      Sequel::Deprecation.deprecate_constant(self, :ODBC_DATE_FORMAT)
       TIMESTAMP_FORMAT="{ts '%Y-%m-%d %H:%M:%S'}".freeze
+      Sequel::Deprecation.deprecate_constant(self, :TIMESTAMP_FORMAT)
 
       Database::DatasetClass = self
+      Sequel::Deprecation.deprecate_constant(Database, :DatasetClass)
 
       def fetch_rows(sql)
         execute(sql) do |s|
           i = -1
           cols = s.columns(true).map{|c| [output_identifier(c.name), c.type, i+=1]}
-          columns = cols.map{|c| c.at(0)}
+          columns = cols.map{|c| c[0]}
           self.columns = columns
           if rows = s.fetch_all
             rows.each do |row|
@@ -136,19 +148,19 @@ module Sequel
       end
       
       def default_timestamp_format
-        TIMESTAMP_FORMAT
+        "{ts '%Y-%m-%d %H:%M:%S'}"
       end
 
       def literal_date(v)
-        v.strftime(ODBC_DATE_FORMAT)
+        v.strftime("{d '%Y-%m-%d'}")
       end
       
       def literal_false
-        BOOL_FALSE
+        '0'
       end
       
       def literal_true
-        BOOL_TRUE
+        '1'
       end
     end
   end

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

@@ -18,6 +18,7 @@ module Sequel
       module DatabaseMethods
         include Sequel::MSSQL::DatabaseMethods
         LAST_INSERT_ID_SQL='SELECT SCOPE_IDENTITY()'.freeze
+        Sequel::Deprecation.deprecate_constant(self, :LAST_INSERT_ID_SQL)
         
         # Return the last inserted identity value.
         def execute_insert(sql, opts=OPTS)
@@ -25,7 +26,8 @@ module Sequel
             begin
               log_connection_yield(sql, conn){conn.do(sql)}
               begin
-                s = log_connection_yield(LAST_INSERT_ID_SQL, conn){conn.run(LAST_INSERT_ID_SQL)}
+                last_insert_id_sql = 'SELECT SCOPE_IDENTITY()'
+                s = log_connection_yield(last_insert_id_sql, conn){conn.run(last_insert_id_sql)}
                 if (rows = s.fetch_all) and (row = rows.first) and (v = row.first)
                   Integer(v)
                 end
@@ -44,17 +46,18 @@ module Sequel
         # Use ODBC format, not Microsoft format, as the ODBC layer does
         # some translation.  MSSQL version is over-ridden to allow 3 millisecond decimal places        
         TIMESTAMP_FORMAT="{ts '%Y-%m-%d %H:%M:%S%N'}".freeze
+        Sequel::Deprecation.deprecate_constant(self, :TIMESTAMP_FORMAT)
 
         private
 
         def default_timestamp_format
-          TIMESTAMP_FORMAT
+          "{ts '%Y-%m-%d %H:%M:%S%N'}"
         end
 
         # Use ODBC format, not Microsoft format, as the ODBC layer does
         # some translation.
         def literal_date(v)
-          v.strftime(ODBC_DATE_FORMAT)
+          v.strftime("{d '%Y-%m-%d'}")
         end
       end
     end

data/lib/sequel/adapters/oracle.rb

@@ -13,12 +13,12 @@ module Sequel
       # ORA-01012: not logged on
       # ORA-03113: end-of-file on communication channel
       # ORA-03114: not connected to ORACLE
-      CONNECTION_ERROR_CODES = [ 28, 1012, 3113, 3114 ]      
+      CONNECTION_ERROR_CODES = [ 28, 1012, 3113, 3114 ]#.freeze # SEQUEL5
       
       ORACLE_TYPES = {
         :blob=>lambda{|b| Sequel::SQL::Blob.new(b.read)},
         :clob=>lambda(&:read)
-      }
+      }#.freeze # SEQUEL5
 
       # Hash of conversion procs for this database.
       attr_reader :conversion_procs
@@ -164,6 +164,10 @@ module Sequel
         end
       end
 
+      def dataset_class_default
+        Dataset
+      end
+
       def execute_prepared_statement(conn, type, name, opts)
         ps = prepared_statement(name)
         sql = ps.prepared_sql
@@ -216,12 +220,12 @@ module Sequel
       end
 
       def begin_transaction(conn, opts=OPTS)
-        log_connection_yield(TRANSACTION_BEGIN, conn){conn.autocommit = false}
+        log_connection_yield('Transaction.begin', conn){conn.autocommit = false}
         set_transaction_isolation(conn, opts)
       end
       
       def commit_transaction(conn, opts=OPTS)
-        log_connection_yield(TRANSACTION_COMMIT, conn){conn.commit}
+        log_connection_yield('Transaction.commit', conn){conn.commit}
       end
 
       def disconnect_error?(e, opts)
@@ -253,7 +257,7 @@ module Sequel
       end
       
       def rollback_transaction(conn, opts=OPTS)
-        log_connection_yield(TRANSACTION_ROLLBACK, conn){conn.rollback}
+        log_connection_yield('Transaction.rollback', conn){conn.rollback}
       end
 
       def schema_parse_table(table, opts=OPTS)
@@ -325,8 +329,10 @@ module Sequel
       include DatasetMethods
 
       Database::DatasetClass = self
+      Sequel::Deprecation.deprecate_constant(Database, :DatasetClass)
 
       PREPARED_ARG_PLACEHOLDER = ':'.freeze
+      Sequel::Deprecation.deprecate_constant(self, :PREPARED_ARG_PLACEHOLDER)
       
       # Oracle already supports named bind arguments, so use directly.
       module ArgumentMapper
@@ -398,7 +404,7 @@ module Sequel
       end
 
       def prepared_arg_placeholder
-        PREPARED_ARG_PLACEHOLDER
+        ':'
       end
 
       def bound_variable_modules