sequel 4.47.0 → 4.48.0

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

@@ -28,7 +28,8 @@ module Sequel
       end
     end
 
-    class TypeConvertor
+    # SEQUEL5: Remove
+    class Type_Convertor
       def SqlAnywhereBoolean(r, i)
         if v = Short(r, i)
           v != 0
@@ -37,6 +38,11 @@ module Sequel
     end
 
     module SqlAnywhere
+      def self.SqlAnywhereBoolean(r, i)
+        v = r.getShort(i)
+        v != 0 unless r.wasNull
+      end
+
       # Database instance methods for Sybase databases accessed via JDBC.
       module DatabaseMethods
         include Sequel::SqlAnywhere::DatabaseMethods
@@ -56,11 +62,6 @@ module Sequel
             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.
@@ -70,10 +71,11 @@ module Sequel
         private
 
         SMALLINT_TYPE = Java::JavaSQL::Types::SMALLINT
+        BOOLEAN_METHOD = SqlAnywhere.method(:SqlAnywhereBoolean)
 
         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/sqlserver.rb

@@ -14,10 +14,9 @@ module Sequel
       end
     end
 
-    class TypeConvertor
+    # SEQUEL5: Remove
+    class Type_Convertor
       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
@@ -27,6 +26,14 @@ module Sequel
     # Database and Dataset instance methods for SQLServer specific
     # support via JDBC.
     module SQLServer
+      def self.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
+
       # Database instance methods for SQLServer databases accessed via JDBC.
       module DatabaseMethods
         include Sequel::JDBC::MSSQL::DatabaseMethods
@@ -34,7 +41,7 @@ module Sequel
         def setup_type_convertor_map
           super
           map = @type_convertor_map
-          map[Java::JavaSQL::Types::TIME] = TypeConvertor::INSTANCE.method(:MSSQLRubyTime)
+          map[Java::JavaSQL::Types::TIME] = SQLServer.method(:MSSQLRubyTime)
           if defined?(Java::MicrosoftSql::Types::DATETIMEOFFSET)
             map[Java::MicrosoftSql::Types::DATETIMEOFFSET] = lambda do |r, i|
               if v = r.getDateTimeOffset(i)

data/lib/sequel/adapters/mock.rb

@@ -52,7 +52,7 @@ module Sequel
         @autoid = case v
         when Integer
           i = v - 1
-          proc{Sequel.synchronize{i+=1}}
+          proc{@mutex.synchronize{i+=1}}
         else
           v
         end
@@ -128,9 +128,11 @@ module Sequel
       # Return all stored SQL queries, and clear the cache
       # of SQL queries.
       def sqls
-        s = @sqls.dup
-        @sqls.clear
-        s
+        @mutex.synchronize do
+          s = @sqls.dup
+          @sqls.clear
+          s
+        end
       end
 
       # Enable use of savepoints.
@@ -140,21 +142,12 @@ module Sequel
 
       private
 
-      def _autoid(sql, v, ds=nil)
-        if ds
-          ds.send(:cache_set, :_autoid, ds.autoid + 1) if ds.autoid.is_a?(Integer)
-          v
-        else
-          _nextres(v, sql, nil)
-        end
-      end
-
       def _execute(c, sql, opts=OPTS, &block)
         sql += " -- args: #{opts[:arguments].inspect}" if opts[:arguments]
         sql += " -- #{@opts[:append]}" if @opts[:append]
         sql += " -- #{c.server.is_a?(Symbol) ? c.server : c.server.inspect}" if c.server != :default
         log_connection_yield(sql, c){} unless opts[:log] == false
-        @sqls << sql 
+        @mutex.synchronize{@sqls << sql}
 
         ds = opts[:dataset]
         begin
@@ -165,8 +158,15 @@ module Sequel
             if meth == :numrows
               _numrows(sql, (ds.numrows if ds) || @numrows)
             else
-              v = ds.autoid if ds
-              _autoid(sql, v || @autoid, (ds if v))
+              if ds
+                @mutex.synchronize do
+                  v = ds.autoid
+                  if v.is_a?(Integer)
+                    ds.send(:cache_set, :_autoid, v + 1)
+                  end
+                  v
+                end
+              end || _nextres(@autoid, sql, nil)
             end
           end
         rescue => e
@@ -182,7 +182,7 @@ module Sequel
           if f.all?{|h| h.is_a?(Hash)}
             f.each{|h| yield h.dup}
           else
-            _fetch(sql, f.shift, &block)
+            _fetch(sql, @mutex.synchronize{f.shift}, &block)
           end
         when Proc
           h = f.call(sql)
@@ -209,7 +209,7 @@ module Sequel
         when Integer
           v
         when Array
-          v.empty? ? default : _nextres(v.shift, sql, default)
+          v.empty? ? default : _nextres(@mutex.synchronize{v.shift}, sql, default)
         when Proc
           v.call(sql)
         when Class
@@ -239,6 +239,7 @@ module Sequel
       # :sqls :: The array to store the SQL queries in.
       def adapter_initialize
         opts = @opts
+        @mutex = Mutex.new
         @sqls = opts[:sqls] || []
         @shared_adapter = false
 
@@ -284,7 +285,7 @@ module Sequel
             if cs.all?{|c| c.is_a?(Symbol)}
               ds.columns(*cs)
             else
-              columns(ds, sql, cs.shift)
+              columns(ds, sql, @mutex.synchronize{cs.shift})
             end
           end
         when Proc
@@ -394,6 +395,10 @@ module Sequel
       def execute_insert(sql, opts=OPTS, &block)
         super(sql, opts.merge(:dataset=>self), &block)
       end
+
+      def non_sql_option?(key)
+        super || key == :fetch || key == :numrows || key == :autoid
+      end
     end
   end
 end

data/lib/sequel/adapters/mysql.rb

@@ -16,7 +16,7 @@ module Sequel
       def boolean(s) s.to_i != 0 end
       def integer(s) s.to_i end
       def float(s) s.to_f end
-    end.new
+    end.new#.freeze # SEQUEL5
 
     # Hash with integer keys and callable values for converting MySQL types.
     MYSQL_TYPES = {}
@@ -30,14 +30,18 @@ module Sequel
     end
     # MYSQL_TYPES.freeze # SEQUEL5
 
+    # SEQUEL5: Remove
+    @convert_invalid_date_time = false
     class << self
-      # Whether to convert invalid date time values by default.
-      #
-      # Only applies to Sequel::Database instances created after this
-      # has been set.
-      attr_accessor :convert_invalid_date_time
+      def convert_invalid_date_time
+        Sequel::Deprecation.deprecate("Sequel::MySQL.convert_invalid_date_time", "Call this method on the Database instance")
+        @convert_invalid_date_time
+      end
+      def convert_invalid_date_time=(v)
+        Sequel::Deprecation.deprecate("Sequel::MySQL.convert_invalid_date_time=", "Call this method on the Database instance")
+        @convert_invalid_date_time = v
+      end
     end
-    self.convert_invalid_date_time = false
 
     # Database class for MySQL databases used with Sequel.
     class Database < Sequel::Database
@@ -54,7 +58,7 @@ module Sequel
 
       # Hash of conversion procs for the current database
       attr_reader :conversion_procs
-      #
+
       # Whether to convert tinyint columns to bool for the current database
       attr_reader :convert_tinyint_to_bool
 
@@ -227,8 +231,8 @@ module Sequel
       
       def adapter_initialize
         @conversion_procs = MYSQL_TYPES.dup
-        self.convert_tinyint_to_bool = Sequel::MySQL.convert_tinyint_to_bool
-        self.convert_invalid_date_time = Sequel::MySQL.convert_invalid_date_time
+        self.convert_tinyint_to_bool = Sequel::MySQL.instance_variable_get(:@convert_tinyint_to_bool) # true # SEQUEL5
+        self.convert_invalid_date_time = Sequel::MySQL.instance_variable_get(:@convert_invalid_date_time) # false # SEQUEL5
       end
 
       # Try to get an accurate number of rows matched using the query
@@ -288,7 +292,7 @@ module Sequel
       # The database name when using the native adapter is always stored in
       # the :database option.
       def database_name
-        Sequel::Deprecation.deprecate("Database#database_name", "Instead, use .get{DATABASE{}}")
+        Sequel::Deprecation.deprecate("Database#database_name", "Instead, use .get(Sequel.function(:DATABASE))")
         @opts[:database]
       end
       
@@ -316,8 +320,7 @@ module Sequel
           cps = db.conversion_procs
           cols = r.fetch_fields.map do |f| 
             # Pretend tinyint is another integer type if its length is not 1, to
-            # avoid casting to boolean if Sequel::MySQL.convert_tinyint_to_bool
-            # is set.
+            # avoid casting to boolean if convert_tinyint_to_bool is set.
             type_proc = f.type == 1 && cast_tinyint_integer?(f) ? cps[2] : cps[f.type]
             [output_identifier(f.name), type_proc, i+=1]
           end
@@ -373,9 +376,7 @@ module Sequel
       
       # Handle correct quoting of strings using ::MySQL.quote.
       def literal_string_append(sql, v)
-        sql << "'"
-        sql << ::Mysql.quote(v)
-        sql << "'"
+        sql << "'" << ::Mysql.quote(v) << "'"
       end
       
       # Yield each row of the given result set r with columns cols

data/lib/sequel/adapters/mysql2.rb

@@ -171,7 +171,7 @@ module Sequel
 
       # Set the convert_tinyint_to_bool setting based on the default value.
       def adapter_initialize
-        self.convert_tinyint_to_bool = Sequel::MySQL.convert_tinyint_to_bool
+        self.convert_tinyint_to_bool = Sequel::MySQL.instance_variable_get(:@convert_tinyint_to_bool) # true # SEQUEL5
       end
 
       if NativePreparedStatements
@@ -222,7 +222,7 @@ module Sequel
       # The database name when using the native adapter is always stored in
       # the :database option.
       def database_name
-        Sequel::Deprecation.deprecate("Database#database_name", "Instead, use .get{DATABASE{}}")
+        Sequel::Deprecation.deprecate("Database#database_name", "Instead, use .get(Sequel.function(:DATABASE))")
         @opts[:database]
       end
 
@@ -277,7 +277,7 @@ module Sequel
       private
 
       # Whether to cast tinyint(1) columns to integer instead of boolean.
-      # By default, uses the opposite of the database's convert_tinyint_to_bool
+      # By default, uses the database's convert_tinyint_to_bool
       # setting.  Exists for compatibility with the mysql adapter.
       def convert_tinyint_to_bool?
         @db.convert_tinyint_to_bool
@@ -303,8 +303,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 << "'" << s << "'"
+        sql << "'" << db.synchronize(@opts[:server]){|c| c.escape(v)} << "'"
       end
     end
   end

data/lib/sequel/adapters/oracle.rb

@@ -112,9 +112,9 @@ module Sequel
         @conversion_procs = ORACLE_TYPES.dup
       end
 
-      PS_TYPES = {'string'.freeze=>String, 'integer'.freeze=>Integer, 'float'.freeze=>Float,
-        'decimal'.freeze=>Float, 'date'.freeze=>Time, 'datetime'.freeze=>Time,
-        'time'.freeze=>Time, 'boolean'.freeze=>String, 'blob'.freeze=>OCI8::BLOB}
+      PS_TYPES = {'string'=>String, 'integer'=>Integer, 'float'=>Float,
+        'decimal'=>Float, 'date'=>Time, 'datetime'=>Time,
+        'time'=>Time, 'boolean'=>String, 'blob'=>OCI8::BLOB}#.freeze # SEQUEL5
       def cursor_bind_params(conn, cursor, args)
         i = 0
         args.map do |arg, type|
@@ -129,11 +129,7 @@ module Sequel
           when ::Sequel::SQL::Blob
             arg = ::OCI8::BLOB.new(conn, arg)
           end
-          if t = PS_TYPES[type]
-            cursor.bind_param(i, arg, t)
-          else
-            cursor.bind_param(i, arg, arg.class)
-          end
+          cursor.bind_param(i, arg, PS_TYPES[type] || arg.class)
           arg
         end
       end
@@ -287,7 +283,7 @@ module Sequel
         defaults = begin
           metadata_dataset.from(:all_tab_cols).
             where(:table_name=>im.call(table)).
-            to_hash(:column_name, :data_default)
+            as_hash(:column_name, :data_default)
         rescue DatabaseError
           {}
         end

data/lib/sequel/adapters/postgres.rb

@@ -5,89 +5,20 @@ Sequel.require 'adapters/shared/postgres'
 begin 
   require 'pg' 
 
+  Sequel::Postgres::PGError = PG::Error if defined?(PG::Error)
+  Sequel::Postgres::PGconn = PG::Connection if defined?(PG::Connection)
+  Sequel::Postgres::PGresult = PG::Result if defined?(PG::Result)
+
   # Work around postgres-pr 0.7.0+ which ships with a pg.rb file
-  raise LoadError unless defined?(PGconn::CONNECTION_OK)
+  unless defined?(PG::Connection)
+    raise LoadError unless defined?(PGconn::CONNECTION_OK)
+  end
 
   Sequel::Postgres::USES_PG = true
 rescue LoadError => e 
-  Sequel::Postgres::USES_PG = false
   begin
-    require 'postgres'
-    # Attempt to get uniform behavior for the PGconn object no matter
-    # if pg, postgres, or postgres-pr is used.
-    class PGconn
-      unless method_defined?(:escape_string)
-        if self.respond_to?(:escape)
-          # If there is no escape_string instance method, but there is an
-          # escape class method, use that instead.
-          def escape_string(str)
-            Sequel::Postgres.force_standard_strings ? str.gsub("'", "''") : self.class.escape(str)
-          end
-        else
-          # Raise an error if no valid string escaping method can be found.
-          def escape_string(obj)
-            if Sequel::Postgres.force_standard_strings
-              str.gsub("'", "''")
-            else
-              raise Sequel::Error, "string escaping not supported with this postgres driver.  Try using ruby-pg, ruby-postgres, or postgres-pr."
-            end
-          end
-        end
-      end
-      unless method_defined?(:escape_bytea)
-        if self.respond_to?(:escape_bytea)
-          # If there is no escape_bytea instance method, but there is an
-          # escape_bytea class method, use that instead.
-          def escape_bytea(obj)
-            self.class.escape_bytea(obj)
-          end
-        else
-          begin
-            require 'postgres-pr/typeconv/conv'
-            require 'postgres-pr/typeconv/bytea'
-            extend Postgres::Conversion
-            # If we are using postgres-pr, use the encode_bytea method from
-            # that.
-            def escape_bytea(obj)
-              self.class.encode_bytea(obj)
-            end
-            instance_eval{alias unescape_bytea decode_bytea}
-          rescue
-            # If no valid bytea escaping method can be found, create one that
-            # raises an error
-            def escape_bytea(obj)
-              raise Sequel::Error, "bytea escaping not supported with this postgres driver.  Try using ruby-pg, ruby-postgres, or postgres-pr."
-            end
-            # If no valid bytea unescaping method can be found, create one that
-            # raises an error
-            def self.unescape_bytea(obj)
-              raise Sequel::Error, "bytea unescaping not supported with this postgres driver.  Try using ruby-pg, ruby-postgres, or postgres-pr."
-            end
-          end
-        end
-      end
-      alias_method :finish, :close unless method_defined?(:finish)
-      alias_method :async_exec, :exec unless method_defined?(:async_exec)
-      unless method_defined?(:block)
-        def block(timeout=nil)
-        end
-      end
-      unless defined?(CONNECTION_OK)
-        CONNECTION_OK = -1
-      end
-      unless method_defined?(:status)
-        def status
-          CONNECTION_OK
-        end
-      end
-    end
-    class PGresult 
-      alias_method :nfields, :num_fields unless method_defined?(:nfields) 
-      alias_method :ntuples, :num_tuples unless method_defined?(:ntuples) 
-      alias_method :ftype, :type unless method_defined?(:ftype) 
-      alias_method :fname, :fieldname unless method_defined?(:fname) 
-      alias_method :cmd_tuples, :cmdtuples unless method_defined?(:cmd_tuples) 
-    end 
+    require 'postgres-pr/postgres-compat'
+    Sequel::Postgres::USES_PG = false
   rescue LoadError 
     raise e 
   end 
@@ -95,14 +26,11 @@ end
 
 module Sequel
   module Postgres
-    CONVERTED_EXCEPTIONS << PGError
-
+    # SEQUEL5: Remove
     TYPE_CONVERTOR = Class.new do
       def bytea(s) ::Sequel::SQL::Blob.new(Adapter.unescape_bytea(s)) end
     end.new
-
-    # SEQUEL5: Remove
-    PG_TYPES[17] = TYPE_CONVERTOR.method(:bytea)
+    Sequel::Deprecation.deprecate_constant(self, :TYPE_CONVERTOR)
 
     if Sequel::Postgres::USES_PG
       # Whether the given sequel_pg version integer is supported.
@@ -111,18 +39,22 @@ module Sequel
       end
     end
 
+    # SEQUEL5: Remove
     @use_iso_date_format = true
-
     class << self
-      # As an optimization, Sequel sets the date style to ISO, so that PostgreSQL provides
-      # the date in a known format that Sequel can parse faster.  This can be turned off
-      # if you require a date style other than ISO.
-      attr_accessor :use_iso_date_format
+      def use_iso_date_format
+        Sequel::Deprecation.deprecate("Sequel::Postgres.use_iso_date_format", "Use the :use_iso_date_format Database option instead")
+        @use_iso_date_format
+      end
+      def use_iso_date_format=(v)
+        Sequel::Deprecation.deprecate("Sequel::Postgres.use_iso_date_format=", "Use the :use_iso_date_format Database option instead")
+        @use_iso_date_format = v
+      end
     end
 
     # PGconn subclass for connection specific methods used with the
-    # pg, postgres, or postgres-pr driver.
-    class Adapter < ::PGconn
+    # pg or postgres-pr driver.
+    class Adapter < PGconn
       # The underlying exception classes to reraise as disconnect errors
       # instead of regular database errors.
       DISCONNECT_ERROR_CLASSES = [IOError, Errno::EPIPE, Errno::ECONNRESET]
@@ -145,10 +77,49 @@ module Sequel
       # errors.
       DISCONNECT_ERROR_RE = /\A#{Regexp.union(disconnect_errors)}/
       
-      # Hash of prepared statements for this connection.  Keys are
-      # string names of the server side prepared statement, and values
-      # are SQL strings.
-      attr_reader(:prepared_statements) if USES_PG
+      if USES_PG
+        # Hash of prepared statements for this connection.  Keys are
+        # string names of the server side prepared statement, and values
+        # are SQL strings.
+        attr_reader :prepared_statements
+      else
+        # Make postgres-pr look like pg
+        CONNECTION_OK = -1
+
+        # Escape bytea values.  Uses historical format instead of hex
+        # format for maximum compatibility.
+        def escape_bytea(str)
+          # each_byte used instead of [] for 1.9 compatibility
+          str.gsub(/[\000-\037\047\134\177-\377]/n){|b| "\\#{sprintf('%o', b.each_byte{|x| break x}).rjust(3, '0')}"}
+        end
+        
+        # Escape strings by doubling apostrophes.  This only works if standard
+        # conforming strings are used.
+        def escape_string(str)
+          str.gsub("'", "''")
+        end
+
+        alias finish close
+
+        def async_exec(sql)
+          PGresult.new(@conn.query(sql))
+        end
+
+        def block(timeout=nil)
+        end
+
+        def status
+          CONNECTION_OK
+        end
+
+        class PGresult < ::PGresult
+          alias nfields num_fields
+          alias ntuples num_tuples
+          alias ftype type
+          alias fname fieldname
+          alias cmd_tuples cmdtuples
+        end 
+      end
       
       # Raise a Sequel::DatabaseDisconnectError if a one of the disconnect
       # error classes is raised, or a PGError is raised and the connection
@@ -258,6 +229,10 @@ module Sequel
             conn.set_notice_receiver(&receiver)
           end
         else
+          unless typecast_value_boolean(@opts.fetch(:force_standard_strings, Postgres.instance_variable_get(:@force_standard_strings))) # , true)) # SEQUEL5
+            raise Error, "Cannot create connection using postgres-pr unless force_standard_strings is set"
+          end
+
           conn = Adapter.connect(
             (opts[:host] unless blank_object?(opts[:host])),
             opts[:port] || 5432,
@@ -311,7 +286,7 @@ module Sequel
             end
           end
         end
-        conversion_procs[1082] = pr
+        add_conversion_proc(1082, pr)
       end
 
       # Disconnect given connection
@@ -390,8 +365,12 @@ module Sequel
                 b << buf while buf = conn.get_copy_data
                 b
               end
+            rescue => e
+              raise_error(e, :disconnect=>true)
             ensure
-              raise DatabaseDisconnectError, "disconnecting as a partial COPY may leave the connection in an unusable state" if buf
+              if buf && !e
+                raise DatabaseDisconnectError, "disconnecting as a partial COPY may leave the connection in an unusable state"
+              end
             end
           end 
         end
@@ -544,10 +523,10 @@ module Sequel
       # Add the primary_keys and primary_key_sequences instance variables,
       # so we can get the correct return values for inserted rows.
       def adapter_initialize
-        @use_iso_date_format = typecast_value_boolean(@opts.fetch(:use_iso_date_format, Postgres.use_iso_date_format))
+        @use_iso_date_format = typecast_value_boolean(@opts.fetch(:use_iso_date_format, Postgres.instance_variable_get(:@use_iso_date_format))) # , true)) # SEQUEL5
         initialize_postgres_adapter
-        conversion_procs[17] = TYPE_CONVERTOR.method(:bytea)
-        conversion_procs[1082] = TYPE_TRANSLATOR.method(:date) if @use_iso_date_format
+        add_conversion_proc(17, method(:unescape_bytea)) if USES_PG
+        add_conversion_proc(1082, TYPE_TRANSLATOR.method(:date)) if @use_iso_date_format
         self.convert_infinite_timestamps = @opts[:convert_infinite_timestamps]
       end
 
@@ -556,7 +535,7 @@ module Sequel
         begin
           yield
         rescue => e
-          raise_error(e, :classes=>CONVERTED_EXCEPTIONS)
+          raise_error(e, :classes=>database_error_classes)
         end
       end
 
@@ -567,8 +546,15 @@ module Sequel
         sqls
       end
 
+      if USES_PG
+        def unescape_bytea(s)
+          ::Sequel::SQL::Blob.new(Adapter.unescape_bytea(s))
+        end
+      end
+
+      DATABASE_ERROR_CLASSES = [PGError].freeze
       def database_error_classes
-        [PGError]
+        DATABASE_ERROR_CLASSES
       end
 
       def disconnect_error?(exception, opts)
@@ -579,7 +565,7 @@ module Sequel
 
       def database_exception_sqlstate(exception, opts)
         if exception.respond_to?(:result) && (result = exception.result)
-          result.error_field(::PGresult::PG_DIAG_SQLSTATE)
+          result.error_field(PGresult::PG_DIAG_SQLSTATE)
         end
       end
 
@@ -885,3 +871,4 @@ end
 
 # SEQUEL5: Remove
 SEQUEL_POSTGRES_USES_PG = Sequel::Postgres::USES_PG
+Sequel::Deprecation.deprecate_constant(Object, :SEQUEL_POSTGRES_USES_PG)