sequel 4.49.0 → 5.3.0

data/lib/sequel/extensions/pg_inet.rb

@@ -5,7 +5,7 @@
 #
 # This extension integrates with Sequel's native postgres and jdbc/postgresql
 # adapters, so that when inet/cidr fields are retrieved, they are returned as
-# IPAddr instances
+# IPAddr instances.
 #
 # To use this extension, load it into your database:
 #
@@ -29,7 +29,6 @@
 # Related module: Sequel::Postgres::InetDatabaseMethods
 
 require 'ipaddr'
-Sequel.require 'adapters/shared/postgres'
 
 module Sequel
   module Postgres
@@ -39,7 +38,7 @@ module Sequel
       # it will pick up the inet/cidr converter.  Also, extend the datasets
       # with support for literalizing the IPAddr types.
       def self.extended(db)
-        db.instance_eval do
+        db.instance_exec do
           extend_datasets(InetDatasetMethods)
           meth = IPAddr.method(:new)
           add_conversion_proc(869, meth)
@@ -47,7 +46,7 @@ module Sequel
           if respond_to?(:register_array_type)
             register_array_type('inet', :oid=>1041, :scalar_oid=>869)
             register_array_type('cidr', :oid=>651, :scalar_oid=>650)
-            register_array_type('macaddr', :oid=>1040)
+            register_array_type('macaddr', :oid=>1040, :scalar_oid=>829)
           end
           @schema_type_classes[:ipaddr] = IPAddr
         end
@@ -112,18 +111,6 @@ module Sequel
         end
       end
     end
-
-    # SEQUEL5: Remove
-    meth = IPAddr.method(:new)
-    PG__TYPES[869] = PG__TYPES[650] = lambda do |s|
-      Sequel::Deprecation.deprecate("Conversion proc for inet/cidr added globally by pg_inet extension", "Load the pg_inet extension into the Database instance")
-      IPAddr.new(s)
-    end
-    if defined?(PGArray) && PGArray.respond_to?(:register)
-      PGArray.register('inet', :oid=>1041, :scalar_oid=>869, :skip_deprecation_warning=>true)
-      PGArray.register('cidr', :oid=>651, :scalar_oid=>650, :skip_deprecation_warning=>true)
-      PGArray.register('macaddr', :oid=>1040, :skip_deprecation_warning=>true)
-    end
   end
 
   Database.register_extension(:pg_inet, Postgres::InetDatabaseMethods)

data/lib/sequel/extensions/pg_interval.rb

@@ -33,13 +33,10 @@
 # Related module: Sequel::Postgres::IntervalDatabaseMethods
 
 require 'active_support/duration'
-Sequel.require 'adapters/shared/postgres'
 
 module Sequel
   module Postgres
     module IntervalDatabaseMethods
-      EMPTY_INTERVAL = '0'.freeze
-      Sequel::Deprecation.deprecate_constant(self, :EMPTY_INTERVAL)
       DURATION_UNITS = [:years, :months, :weeks, :days, :hours, :minutes, :seconds].freeze
 
       # Return an unquoted string version of the duration object suitable for
@@ -64,10 +61,6 @@ module Sequel
 
       # Creates callable objects that convert strings into ActiveSupport::Duration instances.
       class Parser
-        # Regexp that parses the full range of PostgreSQL interval type output.
-        PARSER = /\A([+-]?\d+ years?\s?)?([+-]?\d+ mons?\s?)?([+-]?\d+ days?\s?)?(?:(?:([+-])?(\d{2,10}):(\d\d):(\d\d(\.\d+)?))|([+-]?\d+ hours?\s?)?([+-]?\d+ mins?\s?)?([+-]?\d+(\.\d+)? secs?\s?)?)?\z/
-        Sequel::Deprecation.deprecate_constant(self, :PARSER)
-
         # Parse the interval input string into an ActiveSupport::Duration instance.
         def call(string)
           raise(InvalidValue, "invalid or unhandled interval format: #{string.inspect}") unless matches = /\A([+-]?\d+ years?\s?)?([+-]?\d+ mons?\s?)?([+-]?\d+ days?\s?)?(?:(?:([+-])?(\d{2,10}):(\d\d):(\d\d(\.\d+)?))|([+-]?\d+ hours?\s?)?([+-]?\d+ mins?\s?)?([+-]?\d+(\.\d+)? secs?\s?)?)?\z/.match(string)
@@ -121,7 +114,7 @@ module Sequel
       # Reset the conversion procs if using the native postgres adapter,
       # and extend the datasets to correctly literalize ActiveSupport::Duration values.
       def self.extended(db)
-        db.instance_eval do
+        db.instance_exec do
           extend_datasets(IntervalDatasetMethods)
           add_conversion_proc(1186, Postgres::IntervalDatabaseMethods::PARSER)
           if respond_to?(:register_array_type)
@@ -175,9 +168,6 @@ module Sequel
     end
 
     module IntervalDatasetMethods
-      CAST_INTERVAL = '::interval'.freeze
-      Sequel::Deprecation.deprecate_constant(self, :CAST_INTERVAL)
-
       # Handle literalization of ActiveSupport::Duration objects, treating them as
       # PostgreSQL intervals.
       def literal_other_append(sql, v)
@@ -190,15 +180,6 @@ module Sequel
         end
       end
     end
-
-    # SEQUEL5: Remove
-    PG__TYPES[1186] = lambda do |s|
-      Sequel::Deprecation.deprecate("Conversion proc for interval added globally by pg_interval extension", "Load the pg_interval extension into the Database instance")
-      Postgres::IntervalDatabaseMethods::PARSER.call(s)
-    end
-    if defined?(PGArray) && PGArray.respond_to?(:register)
-      PGArray.register('interval', :oid=>1187, :scalar_oid=>1186, :skip_deprecation_warning=>true)
-    end
   end
 
   Database.register_extension(:pg_interval, Postgres::IntervalDatabaseMethods)

data/lib/sequel/extensions/pg_json.rb

@@ -8,7 +8,7 @@
 # PostgreSQL json values that are not arrays or objects, but support
 # is fairly limited and the values do not roundtrip.
 #
-# This extension integrates with Sequel's native postgres adapter, so
+# This extension integrates with Sequel's native postgres and jdbc/postgresql adapters, so
 # that when json fields are retrieved, they are parsed and returned
 # as instances of Sequel::Postgres::JSONArray or
 # Sequel::Postgres::JSONHash (or JSONBArray or JSONBHash for jsonb
@@ -35,8 +35,8 @@
 #
 # So if you want to insert an array or hash into an json database column:
 #
-#   DB[:table].insert(:column=>Sequel.pg_json([1, 2, 3]))
-#   DB[:table].insert(:column=>Sequel.pg_json({'a'=>1, 'b'=>2}))
+#   DB[:table].insert(column: Sequel.pg_json([1, 2, 3]))
+#   DB[:table].insert(column: Sequel.pg_json({'a'=>1, 'b'=>2}))
 #
 # To use this extension, please load it into the Database instance:
 #
@@ -62,15 +62,9 @@
 
 require 'delegate'
 require 'json'
-Sequel.require 'adapters/shared/postgres'
 
 module Sequel
   module Postgres
-    CAST_JSON = '::json'.freeze
-    Sequel::Deprecation.deprecate_constant(self, :CAST_JSON)
-    CAST_JSONB = '::jsonb'.freeze
-    Sequel::Deprecation.deprecate_constant(self, :CAST_JSONB)
-
     # Class representing PostgreSQL JSON/JSONB column array values.
     class JSONArrayBase < DelegateClass(Array)
       include Sequel::SQL::AliasMethods
@@ -133,7 +127,7 @@ module Sequel
     # Methods enabling Database object integration with the json type.
     module JSONDatabaseMethods
       def self.extended(db)
-        db.instance_eval do
+        db.instance_exec do
           add_conversion_proc(114, JSONDatabaseMethods.method(:db_parse_json))
           add_conversion_proc(3802, JSONDatabaseMethods.method(:db_parse_jsonb))
           if respond_to?(:register_array_type)
@@ -186,7 +180,7 @@ module Sequel
         end
       end
 
-      # Handle JSONArray and JSONHash in bound variables
+      # Handle json and jsonb types in bound variables
       def bound_variable_arg(arg, conn)
         case arg
         when JSONArrayBase, JSONHashBase
@@ -198,7 +192,7 @@ module Sequel
 
       private
 
-      # Handle json[] types in bound variables.
+      # Handle json[] and jsonb[] types in bound variables.
       def bound_variable_array(a)
         case a
         when JSONHashBase, JSONArrayBase
@@ -208,7 +202,7 @@ module Sequel
         end
       end
 
-      # Make the column type detection recognize the json type.
+      # Make the column type detection recognize the json types.
       def schema_column_type(db_type)
         case db_type
         when 'json'
@@ -260,20 +254,6 @@ module Sequel
         end
       end
     end
-
-    # SEQUEL5: Remove
-    PG__TYPES[114] = lambda do |s|
-      Sequel::Deprecation.deprecate("Conversion proc for json added globally by pg_json extension", "Load the pg_json extension into the Database instance")
-      JSONDatabaseMethods.db_parse_json(s)
-    end
-    PG__TYPES[3802] = lambda do |s|
-      Sequel::Deprecation.deprecate("Conversion proc for jsonb added globally by pg_json extension", "Load the pg_json extension into the Database instance")
-      JSONDatabaseMethods.db_parse_jsonb(s)
-    end
-    if defined?(PGArray) && PGArray.respond_to?(:register)
-      PGArray.register('json', :oid=>199, :scalar_oid=>114, :skip_deprecation_warning=>true)
-      PGArray.register('jsonb', :oid=>3807, :scalar_oid=>3802, :skip_deprecation_warning=>true)
-    end
   end
 
   module SQL::Builders

data/lib/sequel/extensions/pg_loose_count.rb

@@ -8,7 +8,7 @@
 #
 # It can also support schema qualified tables:
 #
-#   DB.loose_count(:schema__table) # => 123456
+#   DB.loose_count(Sequel[:schema][:table]) # => 123456
 #
 # How accurate this count is depends on the number of rows
 # added/deleted from the table since the last time it was

data/lib/sequel/extensions/pg_range.rb

@@ -70,97 +70,13 @@
 #
 # Related module: Sequel::Postgres::PGRange
 
-Sequel.require 'adapters/shared/postgres'
-
 module Sequel
   module Postgres
     class PGRange
       include Sequel::SQL::AliasMethods
 
-      # SEQUEL5: Remove
-      RANGE_TYPES = {}
-
-      EMPTY = 'empty'.freeze
-      Sequel::Deprecation.deprecate_constant(self, :EMPTY)
-      EMPTY_STRING = ''.freeze
-      Sequel::Deprecation.deprecate_constant(self, :EMPTY_STRING)
-      COMMA = ','.freeze
-      Sequel::Deprecation.deprecate_constant(self, :COMMA)
-      QUOTED_EMPTY_STRING = '""'.freeze
-      Sequel::Deprecation.deprecate_constant(self, :QUOTED_EMPTY_STRING)
-      OPEN_PAREN = "(".freeze
-      Sequel::Deprecation.deprecate_constant(self, :OPEN_PAREN)
-      CLOSE_PAREN = ")".freeze
-      Sequel::Deprecation.deprecate_constant(self, :CLOSE_PAREN)
-      OPEN_BRACKET = "[".freeze
-      Sequel::Deprecation.deprecate_constant(self, :OPEN_BRACKET)
-      CLOSE_BRACKET = "]".freeze
-      Sequel::Deprecation.deprecate_constant(self, :CLOSE_BRACKET)
-      ESCAPE_RE = /("|,|\\|\[|\]|\(|\))/.freeze
-      Sequel::Deprecation.deprecate_constant(self, :ESCAPE_RE)
-      ESCAPE_REPLACE = '\\\\\1'.freeze
-      Sequel::Deprecation.deprecate_constant(self, :ESCAPE_REPLACE)
-      CAST = '::'.freeze
-      Sequel::Deprecation.deprecate_constant(self, :CAST)
-
-      # SEQUEL5: Remove
-      def self.register(db_type, opts=OPTS, &block)
-        Sequel::Deprecation.deprecate("Sequel::Postgres::PGRange.register", "Use Database#register_range_type on a Database instance using the pg_range extension") unless opts[:skip_deprecation_warning]
-        db_type = db_type.to_s.dup.freeze
-
-        type_procs = opts[:type_procs] || PG__TYPES
-        mod = opts[:typecast_methods_module] || DatabaseMethods
-        typecast_method_map = opts[:typecast_method_map] || RANGE_TYPES
-
-        if converter = opts[:converter]
-          raise Error, "can't provide both a block and :converter option to register" if block
-        else
-          converter = block
-        end
-
-        if soid = opts[:subtype_oid]
-          raise Error, "can't provide both a converter and :subtype_oid option to register" if converter 
-          raise Error, "no conversion proc for :subtype_oid=>#{soid.inspect} in PG_TYPES" unless converter = type_procs[soid]
-        end
-
-        parser = Parser.new(db_type, converter)
-
-        typecast_method_map[db_type] = db_type.to_sym
-
-        define_range_typecast_method(mod, db_type, parser)
-
-        if oid = opts[:oid]
-          if opts[:skip_deprecation_warning]
-            def parser.call(s)
-              Sequel::Deprecation.deprecate("Conversion proc for #{db_type} added globally by pg_range extension", "Load the pg_range extension into the Database instance")
-              super
-            end
-          end
-          type_procs[oid] = parser
-        end
-
-        nil
-      end
-
-      # SEQUEL5: Remove
-      def self.define_range_typecast_method(mod, type, parser)
-        mod.class_eval do
-          meth = :"typecast_value_#{type}"
-          define_method(meth){|v| typecast_value_pg_range(v, parser)}
-          private meth
-        end
-      end
-      private_class_method :define_range_typecast_method
-
       # Creates callable objects that convert strings into PGRange instances.
       class Parser
-        PARSER = /\A(\[|\()("((?:\\"|[^"])*)"|[^"]*),("((?:\\"|[^"])*)"|[^"]*)(\]|\))\z/
-        Sequel::Deprecation.deprecate_constant(self, :PARSER)
-        REPLACE_RE = /\\(.)/.freeze
-        Sequel::Deprecation.deprecate_constant(self, :REPLACE_RE)
-        REPLACE_WITH = '\1'.freeze
-        Sequel::Deprecation.deprecate_constant(self, :REPLACE_WITH)
-
         # The database range type for this parser (e.g. 'int4range'),
         # automatically setting the db_type for the returned PGRange instances.
         attr_reader :db_type
@@ -215,10 +131,10 @@ module Sequel
       end
 
       module DatabaseMethods
-        # Reset the conversion procs if using the native postgres adapter,
+        # Add the conversion procs to the database
         # and extend the datasets to correctly literalize ruby Range values.
         def self.extended(db)
-          db.instance_eval do
+          db.instance_exec do
             @pg_range_schema_types ||= {}
             extend_datasets(DatasetMethods)
             register_range_type('int4range', :oid=>3904, :subtype_oid=>23)
@@ -315,14 +231,13 @@ module Sequel
 
           @pg_range_schema_types[db_type] = db_type.to_sym
 
-          (class << self; self end).class_eval do
+          singleton_class.class_eval do
             meth = :"typecast_value_#{db_type}"
             define_method(meth){|v| typecast_value_pg_range(v, parser)}
             private meth
           end
 
           @schema_type_classes[:"#{opts[:type_symbol] || db_type}"] = PGRange
-          conversion_procs_updated # SEQUEL5: Remove
           nil
         end
 
@@ -338,23 +253,9 @@ module Sequel
           end
         end
 
-        # SEQUEL5: Remove
-        def get_conversion_procs
-          procs = super
-
-          procs[3908] = Parser.new("tsrange", procs[1114])
-          procs[3910] = Parser.new("tstzrange", procs[1184])
-          if defined?(PGArray::Creator)
-            procs[3909] = PGArray::Creator.new("tsrange", procs[3908])
-            procs[3911] = PGArray::Creator.new("tstzrange", procs[3910])
-          end
-
-          procs
-        end
-
         # Recognize the registered database range types.
         def schema_column_type(db_type)
-          if type = @pg_range_schema_types[db_type] || RANGE_TYPES[db_type] # SEQUEL5: Remove || RANGE_TYPES[db_type]
+          if type = @pg_range_schema_types[db_type]
             type
           else
             super
@@ -451,9 +352,9 @@ module Sequel
       def cover?(value)
         return false if empty?
         b = self.begin
-        return false if b && b.send(exclude_begin? ? :>= : :>, value)
+        return false if b && b.public_send(exclude_begin? ? :>= : :>, value)
         e = self.end
-        return false if e && e.send(exclude_end? ? :<= : :<, value)
+        return false if e && e.public_send(exclude_end? ? :<= : :<, value)
         true
       end
 
@@ -601,22 +502,6 @@ module Sequel
         end
       end
     end
-
-    # SEQUEL5: Remove
-    PGRange.register('int4range', :oid=>3904, :subtype_oid=>23, :skip_deprecation_warning=>true)
-    PGRange.register('numrange', :oid=>3906, :subtype_oid=>1700, :skip_deprecation_warning=>true)
-    PGRange.register('tsrange', :oid=>3908, :subtype_oid=>1114, :skip_deprecation_warning=>true)
-    PGRange.register('tstzrange', :oid=>3910, :subtype_oid=>1184, :skip_deprecation_warning=>true)
-    PGRange.register('daterange', :oid=>3912, :subtype_oid=>1082, :skip_deprecation_warning=>true)
-    PGRange.register('int8range', :oid=>3926, :subtype_oid=>20, :skip_deprecation_warning=>true)
-    if defined?(PGArray) && PGArray.respond_to?(:register)
-      PGArray.register('int4range', :oid=>3905, :scalar_oid=>3904, :scalar_typecast=>:int4range, :skip_deprecation_warning=>true)
-      PGArray.register('numrange', :oid=>3907, :scalar_oid=>3906, :scalar_typecast=>:numrange, :skip_deprecation_warning=>true)
-      PGArray.register('tsrange', :oid=>3909, :scalar_oid=>3908, :scalar_typecast=>:tsrange, :skip_deprecation_warning=>true)
-      PGArray.register('tstzrange', :oid=>3911, :scalar_oid=>3910, :scalar_typecast=>:tstzrange, :skip_deprecation_warning=>true)
-      PGArray.register('daterange', :oid=>3913, :scalar_oid=>3912, :scalar_typecast=>:daterange, :skip_deprecation_warning=>true)
-      PGArray.register('int8range', :oid=>3927, :scalar_oid=>3926, :scalar_typecast=>:int8range, :skip_deprecation_warning=>true)
-    end
   end
 
   module SQL::Builders

data/lib/sequel/extensions/pg_range_ops.rb

@@ -75,9 +75,7 @@ module Sequel
         :starts_after => ["(".freeze, " &> ".freeze, ")".freeze].freeze,
         :adjacent_to => ["(".freeze, " -|- ".freeze, ")".freeze].freeze,
         :overlaps => ["(".freeze, " && ".freeze, ")".freeze].freeze,
-      }#.freeze # SEQUEL5
-      FUNCTIONS = %w'lower upper isempty lower_inc upper_inc lower_inf upper_inf'
-      Sequel::Deprecation.deprecate_constant(self, :FUNCTIONS)
+      }.freeze
 
       %w'lower upper isempty lower_inc upper_inc lower_inf upper_inf'.each do |f|
         class_eval("def #{f}; function(:#{f}) end", __FILE__, __LINE__)

data/lib/sequel/extensions/pg_row.rb

@@ -64,12 +64,12 @@
 #
 # You can also use a hash:
 #
-#   DB.row_type(:address, :street=>'123 Sesame St.', :city=>'Some City', :zip=>'12345')
+#   DB.row_type(:address, street: '123 Sesame St.', city: 'Some City', zip: '12345')
 #
 # So if you have a person table that has an address column, here's how you
 # could insert into the column:
 #
-#   DB[:table].insert(:address=>DB.row_type(:address, :street=>'123 Sesame St.', :city=>'Some City', :zip=>'12345'))
+#   DB[:table].insert(address: DB.row_type(:address, street: '123 Sesame St.', city: 'Some City', zip: '12345'))
 #
 # Note that registering row types without providing an explicit :converter option
 # creates anonymous classes.  This results in ruby being unable to Marshal such
@@ -88,16 +88,10 @@
 
 require 'delegate'
 require 'strscan'
-Sequel.require 'adapters/shared/postgres'
 
 module Sequel
   module Postgres
     module PGRow
-      ROW = 'ROW'.freeze
-      Sequel::Deprecation.deprecate_constant(self, :ROW)
-      CAST = '::'.freeze
-      Sequel::Deprecation.deprecate_constant(self, :CAST)
-
       # Class for row-valued/composite types that are treated as arrays. By default,
       # this is only used for generic PostgreSQL record types, as registered
       # types use HashRow by default.
@@ -216,7 +210,7 @@ module Sequel
         end
       end
 
-      ROW_TYPE_CLASSES = [HashRow, ArrayRow]#.freeze # SEQUEL5
+      ROW_TYPE_CLASSES = [HashRow, ArrayRow].freeze
 
       # This parser-like class splits the PostgreSQL
       # row-valued/composite type output string format
@@ -225,25 +219,6 @@ module Sequel
       # will accept, it only handles the output format that
       # PostgreSQL uses.
       class Splitter < StringScanner
-        OPEN_PAREN = /\(/.freeze
-        Sequel::Deprecation.deprecate_constant(self, :OPEN_PAREN)
-        CLOSE_PAREN = /\)/.freeze
-        Sequel::Deprecation.deprecate_constant(self, :CLOSE_PAREN)
-        UNQUOTED_RE = /[^,)]*/.freeze
-        Sequel::Deprecation.deprecate_constant(self, :UNQUOTED_RE)
-        SEP_RE = /[,)]/.freeze
-        Sequel::Deprecation.deprecate_constant(self, :SEP_RE)
-        QUOTE_RE = /"/.freeze
-        Sequel::Deprecation.deprecate_constant(self, :QUOTE_RE)
-        QUOTE_SEP_RE = /"[,)]/.freeze
-        Sequel::Deprecation.deprecate_constant(self, :QUOTE_SEP_RE)
-        QUOTED_RE = /(\\.|""|[^"])*/.freeze
-        Sequel::Deprecation.deprecate_constant(self, :QUOTED_RE)
-        REPLACE_RE = /\\(.)|"(")/.freeze
-        Sequel::Deprecation.deprecate_constant(self, :REPLACE_RE)
-        REPLACE_WITH = '\1\2'.freeze
-        Sequel::Deprecation.deprecate_constant(self, :REPLACE_WITH)
-
         # Split the stored string into an array of strings, handling
         # the different types of quoting.
         def parse
@@ -387,13 +362,6 @@ module Sequel
       end
 
       module DatabaseMethods
-        ESCAPE_RE = /("|\\)/.freeze
-        Sequel::Deprecation.deprecate_constant(self, :ESCAPE_RE)
-        ESCAPE_REPLACEMENT = '\\\\\1'.freeze
-        Sequel::Deprecation.deprecate_constant(self, :ESCAPE_REPLACEMENT)
-        COMMA = ','.freeze
-        Sequel::Deprecation.deprecate_constant(self, :COMMA)
-
         # A hash mapping row type keys (usually symbols), to option
         # hashes.  At the least, the values will contain the :parser
         # option for the Parser instance that the type will use.
@@ -401,7 +369,7 @@ module Sequel
 
         # Do some setup for the data structures the module uses.
         def self.extended(db)
-          db.instance_eval do
+          db.instance_exec do
             @row_types = {}
             @row_schema_types = {}
             extend(@row_type_method_module = Module.new)
@@ -433,8 +401,6 @@ module Sequel
           super
         end
 
-        STRING_TYPES = [18, 19, 25, 1042, 1043].freeze
-
         # Register a new row type for the Database instance. db_type should be the type
         # symbol.  This parses the PostgreSQL system tables to get information the
         # composite type, and by default has the type return instances of a subclass
@@ -487,23 +453,7 @@ module Sequel
 
           # Using the conversion_procs, lookup converters for each member of the composite type
           parser_opts[:column_converters] = parser_opts[:column_oids].map do |oid|
-            # procs[oid] # SEQUEL5
-
-            # SEQUEL5: Remove
-            if pr = procs[oid]
-              pr
-            elsif !STRING_TYPES.include?(oid)
-              # It's not a string type, and it's possible a conversion proc for this
-              # oid will be added later, so do a runtime check for it.
-              lambda do |s|
-                if (pr = procs[oid])
-                  Sequel::Deprecation.deprecate("Calling conversion proc for subtype (oid: #{oid}) of composite type (oid: #{parser_opts[:oid]}) not added until after composite type registration", "Register subtype conversion procs before registering composite type")
-                  pr.call(s)
-                else
-                  s
-                end
-              end
-            end
+            procs[oid]
           end
 
           # Setup the converter and typecaster
@@ -533,21 +483,9 @@ module Sequel
             private meth
           end
 
-          conversion_procs_updated # SEQUEL5: Remove
           nil
         end
 
-        # SEQUEL5: Remove
-        def reset_conversion_procs
-          procs = super
-
-          row_types.values.each do |opts|
-            register_row_type(opts[:type], opts)
-          end
-
-          procs
-        end
-
         # Handle typecasting of the given object to the given database type.
         # In general, the given database type should already be registered,
         # but if obj is an array, this will handled unregistered types.
@@ -602,16 +540,6 @@ module Sequel
         end
       end
     end
-
-    # SEQUEL5: Remove
-    parser = PGRow::Parser.new(:converter=>PGRow::ArrayRow)
-    PG__TYPES[2249] = lambda do |s|
-      Sequel::Deprecation.deprecate("Conversion proc for record added globally by pg_row extension", "Load the pg_row extension into the Database instance")
-      parser.call(s)
-    end
-    if defined?(PGArray) && PGArray.respond_to?(:register)
-      PGArray.register('record', :oid=>2287, :scalar_oid=>2249, :skip_deprecation_warning=>true)
-    end
   end
 
   module SQL::Builders

data/lib/sequel/extensions/pg_row_ops.rb

@@ -76,8 +76,8 @@
 #
 # This feature is mostly useful for a different way to graph tables:
 #
-#   DB[:a].join(:b, :id=>:b_id).select(Sequel.pg_row_op(:a).splat(:a),
-#                                      Sequel.pg_row_op(:b).splat(:b))
+#   DB[:a].join(:b, id: :b_id).select(Sequel.pg_row_op(:a).splat(:a),
+#                                     Sequel.pg_row_op(:b).splat(:b))
 #   # SELECT (a.*)::a, (b.*)::b FROM a INNER JOIN b ON (b.id = a.b_id)
 #   # => {:a=>{:id=>1, :b_id=>2}, :b=>{:id=>2}}
 #
@@ -88,17 +88,6 @@ module Sequel
   module Postgres
     # This class represents a composite type expression reference.
     class PGRowOp < SQL::PlaceholderLiteralString
-      OPEN = '('.freeze
-      Sequel::Deprecation.deprecate_constant(self, :OPEN)
-      CLOSE_DOT = ').'.freeze
-      Sequel::Deprecation.deprecate_constant(self, :CLOSE_DOT)
-      CLOSE_STAR = '.*)'.freeze
-      Sequel::Deprecation.deprecate_constant(self, :CLOSE_STAR)
-      CLOSE_STAR_CAST = '.*)::'.freeze
-      Sequel::Deprecation.deprecate_constant(self, :CLOSE_STAR_CAST)
-      EMPTY = "".freeze
-      Sequel::Deprecation.deprecate_constant(self, :EMPTY)
-
       ROW = ['(', '.*)'].freeze.each(&:freeze)
       ROW_CAST = ['(', '.*)::'].freeze.each(&:freeze)
       QUALIFY = ['(', ').'].freeze.each(&:freeze)

data/lib/sequel/extensions/query.rb

@@ -37,11 +37,9 @@ module Sequel
   end
 
   module DatasetQuery
-    Dataset.def_mutation_method(:query, :module=>self)
-
     # Translates a query block into a dataset. Query blocks are an
     # alternative to Sequel's usual method chaining, by using
-    # instance_eval with a proxy object:
+    # instance_exec with a proxy object:
     #
     #   dataset = DB[:items].query do
     #     select :x, :y, :z
@@ -54,7 +52,7 @@ module Sequel
     #  dataset = DB[:items].select(:x, :y, :z).where{(x > 1) & (y > 2)}.reverse(:z)
     def query(&block)
       query = Dataset::Query.new(self)
-      query.instance_eval(&block)
+      query.instance_exec(&block)
       query.dataset
     end
   end
@@ -71,6 +69,7 @@ module Sequel
 
       # Replace the query's dataset with dataset returned by the method call.
       def method_missing(method, *args, &block)
+        # Allow calling private methods, so things like raise works
         @dataset = @dataset.send(method, *args, &block)
         raise(Sequel::Error, "method #{method.inspect} did not return a dataset") unless @dataset.is_a?(Dataset)
         self

data/lib/sequel/extensions/round_timestamps.rb

@@ -25,12 +25,6 @@
 #
 # Related module: Sequel::Dataset::RoundTimestamps
 
-unless RUBY_VERSION >= '1.9'
-  # :nocov:
-  raise LoadError, 'the round_timestamps extension only works on ruby 1.9+'
-  # :nocov:
-end
-
 module Sequel
   class Dataset
     module RoundTimestamps