sequel 4.49.0 → 5.3.0

data/lib/sequel/adapters/postgres.rb

@@ -1,6 +1,6 @@
 # frozen-string-literal: true
 
-Sequel.require 'adapters/shared/postgres'
+require_relative 'shared/postgres'
 
 begin 
   require 'pg' 
@@ -26,12 +26,6 @@ end
 
 module Sequel
   module Postgres
-    # SEQUEL5: Remove
-    TYPE_CONVERTOR = Class.new do
-      def bytea(s) ::Sequel::SQL::Blob.new(Adapter.unescape_bytea(s)) end
-    end.new
-    Sequel::Deprecation.deprecate_constant(self, :TYPE_CONVERTOR)
-
     if Sequel::Postgres::USES_PG
       # Whether the given sequel_pg version integer is supported.
       def self.sequel_pg_version_supported?(version)
@@ -39,19 +33,6 @@ module Sequel
       end
     end
 
-    # SEQUEL5: Remove
-    @use_iso_date_format = true
-    class << self
-      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 or postgres-pr driver.
     class Adapter < PGconn
@@ -61,7 +42,7 @@ module Sequel
       if defined?(::PG::ConnectionBad)
         DISCONNECT_ERROR_CLASSES << ::PG::ConnectionBad
       end
-      #DISCONNECT_ERROR_CLASSES.freeze # SEQUEL5
+      DISCONNECT_ERROR_CLASSES.freeze
       
       disconnect_errors = [
         'could not receive data from server',
@@ -89,7 +70,6 @@ module Sequel
         # 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
         
@@ -160,40 +140,25 @@ module Sequel
 
       private
 
-      # Return the PGResult object that is returned by executing the given
-      # sql and args.
+      # Return the PGResult containing the query results.
       def execute_query(sql, args)
         @db.log_connection_yield(sql, self, args){args ? async_exec(sql, args) : async_exec(sql)}
       end
     end
     
-    # Database class for PostgreSQL databases used with Sequel and the
-    # pg, postgres, or postgres-pr driver.
     class Database < Sequel::Database
       include Sequel::Postgres::DatabaseMethods
 
-      INFINITE_TIMESTAMP_STRINGS = ['infinity'.freeze, '-infinity'.freeze].freeze
-      INFINITE_DATETIME_VALUES = ([PLUS_INFINITY, MINUS_INFINITY] + INFINITE_TIMESTAMP_STRINGS).freeze
-      
       set_adapter_scheme :postgresql
       set_adapter_scheme :postgres
 
-      # Whether infinite timestamps/dates should be converted on retrieval.  By default, no
-      # conversion is done, so an error is raised if you attempt to retrieve an infinite
-      # timestamp/date.  You can set this to :nil to convert to nil, :string to leave
-      # as a string, or :float to convert to an infinite float.
-      attr_reader :convert_infinite_timestamps
-
       # Convert given argument so that it can be used directly by pg.  Currently, pg doesn't
-      # handle fractional seconds in Time/DateTime or blobs with "\0", and it won't ever
-      # handle Sequel::SQLTime values correctly.  Only public for use by the adapter, shouldn't
-      # be used by external code.
+      # handle fractional seconds in Time/DateTime or blobs with "\0". Only public for use by
+      # the adapter, shouldn't be used by external code.
       def bound_variable_arg(arg, conn)
         case arg
         when Sequel::SQL::Blob
           {:value=>arg, :type=>17, :format=>1}
-        when Sequel::SQLTime
-          literal(arg)
         when DateTime, Time
           literal(arg)
         else
@@ -230,7 +195,7 @@ 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
+          unless typecast_value_boolean(@opts.fetch(:force_standard_strings, true))
             raise Error, "Cannot create connection using postgres-pr unless force_standard_strings is set"
           end
 
@@ -258,39 +223,21 @@ module Sequel
         conn
       end
       
-      # Set whether to allow infinite timestamps/dates.  Make sure the
-      # conversion proc for date reflects that setting.
-      def convert_infinite_timestamps=(v)
-        @convert_infinite_timestamps = case v
-        when Symbol
-          v
-        when 'nil'
-          :nil
-        when 'string'
-          :string
-        when 'float'
-          :float
-        when String
-          typecast_value_boolean(v)
-        else
-          false
-        end
+      # Always false, support was moved to pg_extended_date_support extension.
+      # Needs to stay defined here so that sequel_pg works.
+      def convert_infinite_timestamps
+        false
+      end
 
-        pr = old_pr = @use_iso_date_format ? TYPE_TRANSLATOR.method(:date) : Sequel.method(:string_to_date)
-        if v
-          pr = lambda do |val|
-            case val
-            when *INFINITE_TIMESTAMP_STRINGS
-              infinite_timestamp_value(val)
-            else
-              old_pr.call(val)
-            end
-          end
+      # Enable pg_extended_date_support extension if symbol or string is given.
+      def convert_infinite_timestamps=(v)
+        case v
+        when Symbol, String, true
+          extension(:pg_extended_date_support)
+          self.convert_infinite_timestamps = v
         end
-        add_conversion_proc(1082, pr)
       end
 
-      # Disconnect given connection
       def disconnect_connection(conn)
         conn.finish
       rescue PGError, IOError
@@ -322,7 +269,6 @@ module Sequel
         end
       end
       
-      # Execute the given SQL with the given args on an available connection.
       def execute(sql, opts=OPTS, &block)
         synchronize(opts[:server]){|conn| check_database_errors{_execute(conn, sql, opts, &block)}}
       end
@@ -340,6 +286,9 @@ module Sequel
         #           a version of PostgreSQL before 9.0, you will probably want to
         #           use a string if you are using any options at all, as the syntax
         #           Sequel uses for options is only compatible with PostgreSQL 9.0+.
+        #           This should be the full COPY statement passed to PostgreSQL, not
+        #           just the SELECT query.  If a string is given, the :format and
+        #           :options options are ignored.
         # Dataset :: Uses a query instead of a table name when copying.
         # other :: Uses a table name (usually a symbol) when copying.
         # 
@@ -490,21 +439,6 @@ module Sequel
         end
       end
 
-      # If convert_infinite_timestamps is true and the value is infinite, return an appropriate
-      # value based on the convert_infinite_timestamps setting.
-      def to_application_timestamp(value)
-        if convert_infinite_timestamps
-          case value
-          when *INFINITE_TIMESTAMP_STRINGS
-            infinite_timestamp_value(value)
-          else
-            super
-          end
-        else
-          super
-        end
-      end
-        
       private
 
       # Execute the given SQL string or prepared statement on the connection object.
@@ -524,7 +458,7 @@ 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.instance_variable_get(:@use_iso_date_format))) # , true)) # SEQUEL5
+        @use_iso_date_format = typecast_value_boolean(@opts.fetch(:use_iso_date_format, true))
         initialize_postgres_adapter
         add_conversion_proc(17, method(:unescape_bytea)) if USES_PG
         add_conversion_proc(1082, TYPE_TRANSLATOR.method(:date)) if @use_iso_date_format
@@ -611,70 +545,19 @@ module Sequel
         end
       end
 
-      # Return an appropriate value for the given infinite timestamp string.
-      def infinite_timestamp_value(value)
-        case convert_infinite_timestamps
-        when :nil
-          nil
-        when :string
-          value
-        else
-          value == 'infinity' ? PLUS_INFINITY : MINUS_INFINITY
-        end
-      end
-      
       # Don't log, since logging is done by the underlying connection.
       def log_connection_execute(conn, sql)
         conn.execute(sql)
       end
 
-      # If the value is an infinite value (either an infinite float or a string returned by
-      # by PostgreSQL for an infinite timestamp), return it without converting it if
-      # convert_infinite_timestamps is set.
-      def typecast_value_date(value)
-        if convert_infinite_timestamps
-          case value
-          when *INFINITE_DATETIME_VALUES
-            value
-          else
-            super
-          end
-        else
-          super
-        end
-      end
-
-      # If the value is an infinite value (either an infinite float or a string returned by
-      # by PostgreSQL for an infinite timestamp), return it without converting it if
-      # convert_infinite_timestamps is set.
-      def typecast_value_datetime(value)
-        if convert_infinite_timestamps
-          case value
-          when *INFINITE_DATETIME_VALUES
-            value
-          else
-            super
-          end
-        else
-          super
-        end
+      def rollback_transaction(conn, opts=OPTS)
+        super unless conn.transaction_status == 0
       end
     end
     
-    # Dataset class for PostgreSQL datasets that use the pg, postgres, or
-    # postgres-pr driver.
     class Dataset < Sequel::Dataset
       include Sequel::Postgres::DatasetMethods
 
-      Database::DatasetClass = self
-      Sequel::Deprecation.deprecate_constant(Database, :DatasetClass)
-      APOS = "'".freeze
-      Sequel::Deprecation.deprecate_constant(self, :APOS)
-      DEFAULT_CURSOR_NAME = 'sequel_cursor'.freeze
-      Sequel::Deprecation.deprecate_constant(self, :DEFAULT_CURSOR_NAME)
-      
-      # Yield all rows returned by executing the given SQL and converting
-      # the types.
       def fetch_rows(sql)
         return cursor_fetch_rows(sql){|h| yield h} if @opts[:cursor]
         execute(sql){|res| yield_hash_rows(res, fetch_rows_set_cols(res)){|h| yield h}}
@@ -702,8 +585,8 @@ module Sequel
       # Usage:
       #
       #   DB[:huge_table].use_cursor.each{|row| p row}
-      #   DB[:huge_table].use_cursor(:rows_per_fetch=>10000).each{|row| p row}
-      #   DB[:huge_table].use_cursor(:cursor_name=>'my_cursor').each{|row| p row}      
+      #   DB[:huge_table].use_cursor(rows_per_fetch: 10000).each{|row| p row}
+      #   DB[:huge_table].use_cursor(cursor_name: 'my_cursor').each{|row| p row}      
       #
       # This is untested with the prepared statement/bound variable support,
       # and unlikely to work with either.
@@ -716,15 +599,14 @@ module Sequel
       # large dataset by updating individual rows while processing the dataset
       # via a cursor:
       #
-      #   DB[:huge_table].use_cursor(:rows_per_fetch=>1).each do |row|
-      #     DB[:huge_table].where_current_of.update(:column=>ruby_method(row))
+      #   DB[:huge_table].use_cursor(rows_per_fetch: 1).each do |row|
+      #     DB[:huge_table].where_current_of.update(column: ruby_method(row))
       #   end
       def where_current_of(cursor_name='sequel_cursor')
         clone(:where=>Sequel.lit(['CURRENT OF '], Sequel.identifier(cursor_name)))
       end
 
       if USES_PG
-        
         PREPARED_ARG_PLACEHOLDER = LiteralString.new('$').freeze
         
         # PostgreSQL specific argument mapper used for mapping the named
@@ -789,7 +671,7 @@ module Sequel
         cursor_name = quote_identifier(cursor[:cursor_name] || 'sequel_cursor')
         rows_per_fetch = cursor[:rows_per_fetch].to_i
 
-        db.send(*(hold ? [:synchronize, server_opts[:server]] : [:transaction, server_opts])) do 
+        db.public_send(*(hold ? [:synchronize, server_opts[:server]] : [:transaction, server_opts])) do 
           begin
             execute_ddl("DECLARE #{cursor_name} NO SCROLL CURSOR WITH#{'OUT' unless hold} HOLD FOR #{sql}", server_opts)
             rows_per_fetch = 1000 if rows_per_fetch <= 0
@@ -869,7 +751,3 @@ if Sequel::Postgres::USES_PG && !ENV['NO_SEQUEL_PG']
   rescue LoadError
   end
 end
-
-# SEQUEL5: Remove
-SEQUEL_POSTGRES_USES_PG = Sequel::Postgres::USES_PG
-Sequel::Deprecation.deprecate_constant(Object, :SEQUEL_POSTGRES_USES_PG)

data/lib/sequel/adapters/postgresql.rb

@@ -1,3 +1,3 @@
 # frozen-string-literal: true
 
-Sequel.require 'adapters/postgres'
+require_relative 'postgres'

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

@@ -1,6 +1,7 @@
 # frozen-string-literal: true
 
-Sequel.require %w'emulate_offset_with_reverse_and_count unmodified_identifiers', 'adapters/utils'
+require_relative '../utils/emulate_offset_with_reverse_and_count'
+require_relative '../utils/unmodified_identifiers'
 
 module Sequel
   module Access
@@ -9,7 +10,6 @@ module Sequel
     module DatabaseMethods
       include UnmodifiedIdentifiers::DatabaseMethods
 
-      # Access uses type :access as the database_type
       def database_type
         :access
       end
@@ -56,7 +56,6 @@ module Sequel
         DATABASE_ERROR_REGEXPS
       end
 
-      # The SQL to drop an index for the table.
       def drop_index_sql(table, op)
         "DROP INDEX #{quote_identifier(op[:name] || default_index_name(table, op[:columns]))} ON #{quote_schema_table(table)}"
       end
@@ -85,52 +84,12 @@ module Sequel
       include EmulateOffsetWithReverseAndCount
       include UnmodifiedIdentifiers::DatasetMethods
 
-      EXTRACT_MAP = {:year=>"'yyyy'", :month=>"'m'", :day=>"'d'", :hour=>"'h'", :minute=>"'n'", :second=>"'s'"}#.freeze # SEQUEL5
-      #EXTRACT_MAP.each_value(&:freeze) # SEQUEL5
-      OPS = {:'%'=>' Mod '.freeze, :'||'=>' & '.freeze}#.freeze # SEQUEL5
-      CAST_TYPES = {String=>:CStr, Integer=>:CLng, Date=>:CDate, Time=>:CDate, DateTime=>:CDate, Numeric=>:CDec, BigDecimal=>:CDec, File=>:CStr, Float=>:CDbl, TrueClass=>:CBool, FalseClass=>:CBool}#.freeze # SEQUEL5
-
-      DATE_FORMAT = '#%Y-%m-%d#'.freeze
-      Sequel::Deprecation.deprecate_constant(self, :DATE_FORMAT)
-      TIMESTAMP_FORMAT = '#%Y-%m-%d %H:%M:%S#'.freeze
-      Sequel::Deprecation.deprecate_constant(self, :TIMESTAMP_FORMAT)
-      TOP = " TOP ".freeze
-      Sequel::Deprecation.deprecate_constant(self, :TOP)
-      BRACKET_CLOSE =  ']'.freeze
-      Sequel::Deprecation.deprecate_constant(self, :BRACKET_CLOSE)
-      BRACKET_OPEN = '['.freeze
-      Sequel::Deprecation.deprecate_constant(self, :BRACKET_OPEN)
-      COMMA = ', '.freeze
-      Sequel::Deprecation.deprecate_constant(self, :COMMA)
-      PAREN_CLOSE = ')'.freeze
-      Sequel::Deprecation.deprecate_constant(self, :PAREN_CLOSE)
-      PAREN_OPEN = '('.freeze
-      Sequel::Deprecation.deprecate_constant(self, :PAREN_OPEN)
-      INTO = " INTO ".freeze
-      Sequel::Deprecation.deprecate_constant(self, :INTO)
-      FROM = ' FROM '.freeze
-      Sequel::Deprecation.deprecate_constant(self, :FROM)
-      SPACE = ' '.freeze
-      Sequel::Deprecation.deprecate_constant(self, :SPACE)
-      NOT_EQUAL = ' <> '.freeze
-      Sequel::Deprecation.deprecate_constant(self, :NOT_EQUAL)
-      BOOL_FALSE = '0'.freeze
-      Sequel::Deprecation.deprecate_constant(self, :BOOL_FALSE)
-      BOOL_TRUE = '-1'.freeze
-      Sequel::Deprecation.deprecate_constant(self, :BOOL_TRUE)
-      DATE_FUNCTION = 'Date()'.freeze
-      Sequel::Deprecation.deprecate_constant(self, :DATE_FUNCTION)
-      NOW_FUNCTION = 'Now()'.freeze
-      Sequel::Deprecation.deprecate_constant(self, :NOW_FUNCTION)
-      TIME_FUNCTION = 'Time()'.freeze
-      Sequel::Deprecation.deprecate_constant(self, :TIME_FUNCTION)
-      DATEPART_OPEN = "datepart(".freeze
-      Sequel::Deprecation.deprecate_constant(self, :DATEPART_OPEN)
-      EMULATED_FUNCTION_MAP = {:char_length=>:len}
-      Sequel::Deprecation.deprecate_constant(self, :EMULATED_FUNCTION_MAP)
-
-      # Access doesn't support CASE, but it can be emulated with nested
-      # IIF function calls.
+      EXTRACT_MAP = {:year=>"'yyyy'", :month=>"'m'", :day=>"'d'", :hour=>"'h'", :minute=>"'n'", :second=>"'s'"}.freeze
+      EXTRACT_MAP.each_value(&:freeze)
+      OPS = {:'%'=>' Mod '.freeze, :'||'=>' & '.freeze}.freeze
+      CAST_TYPES = {String=>:CStr, Integer=>:CLng, Date=>:CDate, Time=>:CDate, DateTime=>:CDate, Numeric=>:CDec, BigDecimal=>:CDec, File=>:CStr, Float=>:CDbl, TrueClass=>:CBool, FalseClass=>:CBool}.freeze
+
+      # Access doesn't support CASE, so emulate it with nested IIF function calls.
       def case_expression_sql_append(sql, ce)
         literal_append(sql, ce.with_merged_expression.conditions.reverse.inject(ce.default){|exp,(cond,val)| Sequel::SQL::Function.new(:IIF, cond, val, exp)})
       end
@@ -189,7 +148,7 @@ module Sequel
         end
       end
 
-      # Use Date() and Now() for CURRENT_DATE and CURRENT_TIMESTAMP
+      # Use Date(), Now(), and Time() for CURRENT_DATE, CURRENT_TIMESTAMP, and CURRENT_TIME
       def constant_sql_append(sql, constant)
         case constant
         when :CURRENT_DATE
@@ -317,7 +276,8 @@ module Sequel
         end
       end
 
-      # Access uses [] for quoting identifiers
+      # Access uses [] for quoting identifiers, and can't handle
+      # ] inside identifiers.
       def quoted_identifier_append(sql, v)
         sql << '[' << v.to_s << ']'
       end

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

@@ -1,43 +1,15 @@
 # frozen-string-literal: true
 
-Sequel.require 'adapters/utils/emulate_offset_with_row_number'
+require_relative '../utils/emulate_offset_with_row_number'
 
 module Sequel
   module DB2
     Sequel::Database.set_shared_adapter_scheme(:db2, self)
 
-    # SEQUEL5: Remove
-    @use_clob_as_blob = false
-    class << self
-      def use_clob_as_blob
-        Sequel::Deprecation.deprecate("Sequel::DB2.use_clob_as_blob", "Call this method on the Database instance")
-        @use_clob_as_blob
-      end
-      def use_clob_as_blob=(v)
-        Sequel::Deprecation.deprecate("Sequel::DB2.use_clob_as_blob=", "Call this method on the Database instance")
-        @use_clob_as_blob = v
-      end
-    end
-
     module DatabaseMethods
-      AUTOINCREMENT = 'GENERATED ALWAYS AS IDENTITY'.freeze
-      Sequel::Deprecation.deprecate_constant(self, :AUTOINCREMENT)
-      NOT_NULL      = ' NOT NULL'.freeze
-      Sequel::Deprecation.deprecate_constant(self, :NOT_NULL)
-      NULL          = ''.freeze
-      Sequel::Deprecation.deprecate_constant(self, :NULL)
-
       # Whether to use clob as the generic File type, false by default.
-      #attr_accessor :use_clob_as_blob # SEQUEL5
+      attr_accessor :use_clob_as_blob
 
-      # SEQUEL5: Remove
-      attr_writer :use_clob_as_blob
-      def use_clob_as_blob
-        v = @use_clob_as_blob
-        v.nil? ? Sequel::DB2.instance_variable_get(:@use_clob_as_blob) : v
-      end
-    
-      # DB2 always uses :db2 as it's database type
       def database_type
         :db2
       end
@@ -145,7 +117,6 @@ module Sequel
 
       private
 
-      # Handle DB2 specific alter table operations.
       def alter_table_sql(table, op)
         case op[:op]
         when :add_column
@@ -302,36 +273,7 @@ module Sequel
     module DatasetMethods
       include EmulateOffsetWithRowNumber
 
-      BITWISE_METHOD_MAP = {:& =>:BITAND, :| => :BITOR, :^ => :BITXOR, :'B~'=>:BITNOT}#.freeze # SEQUEL5
-
-      PAREN_CLOSE = ')'.freeze
-      Sequel::Deprecation.deprecate_constant(self, :PAREN_CLOSE)
-      PAREN_OPEN = '('.freeze
-      Sequel::Deprecation.deprecate_constant(self, :PAREN_OPEN)
-      BOOL_TRUE = '1'.freeze
-      Sequel::Deprecation.deprecate_constant(self, :BOOL_TRUE)
-      BOOL_FALSE = '0'.freeze
-      Sequel::Deprecation.deprecate_constant(self, :BOOL_FALSE)
-      CAST_STRING_OPEN = "RTRIM(CHAR(".freeze
-      Sequel::Deprecation.deprecate_constant(self, :CAST_STRING_OPEN)
-      CAST_STRING_CLOSE = "))".freeze
-      Sequel::Deprecation.deprecate_constant(self, :CAST_STRING_CLOSE)
-      FETCH_FIRST_ROW_ONLY = " FETCH FIRST ROW ONLY".freeze
-      Sequel::Deprecation.deprecate_constant(self, :FETCH_FIRST_ROW_ONLY)
-      FETCH_FIRST = " FETCH FIRST ".freeze
-      Sequel::Deprecation.deprecate_constant(self, :FETCH_FIRST)
-      ROWS_ONLY = " ROWS ONLY".freeze
-      Sequel::Deprecation.deprecate_constant(self, :ROWS_ONLY)
-      EMPTY_FROM_TABLE = ' FROM "SYSIBM"."SYSDUMMY1"'.freeze
-      Sequel::Deprecation.deprecate_constant(self, :EMPTY_FROM_TABLE)
-      HSTAR = "H*".freeze
-      Sequel::Deprecation.deprecate_constant(self, :HSTAR)
-      BLOB_OPEN = "BLOB(X'".freeze
-      Sequel::Deprecation.deprecate_constant(self, :BLOB_OPEN)
-      BLOB_CLOSE = "')".freeze
-      Sequel::Deprecation.deprecate_constant(self, :BLOB_CLOSE)
-      EMULATED_FUNCTION_MAP = {:char_length=>'length'.freeze}
-      Sequel::Deprecation.deprecate_constant(self, :EMULATED_FUNCTION_MAP)
+      BITWISE_METHOD_MAP = {:& =>:BITAND, :| => :BITOR, :^ => :BITXOR, :'B~'=>:BITNOT}.freeze
 
       # DB2 casts strings using RTRIM and CHAR instead of VARCHAR.
       def cast_sql_append(sql, expr, type)