sequel 4.49.0 → 5.3.0

data/lib/sequel/extensions/pg_array.rb

@@ -32,7 +32,7 @@
 #
 # So if you want to insert an array into an integer[] database column:
 #
-#   DB[:table].insert(:column=>Sequel.pg_array([1, 2, 3]))
+#   DB[:table].insert(column: Sequel.pg_array([1, 2, 3]))
 #
 # To use this extension, first load it into your Sequel::Database instance:
 #
@@ -71,7 +71,6 @@
 
 require 'delegate'
 require 'strscan'
-Sequel.require 'adapters/shared/postgres'
 
 module Sequel
   module Postgres
@@ -79,108 +78,16 @@ module Sequel
     class PGArray < DelegateClass(Array)
       include Sequel::SQL::AliasMethods
 
-      ARRAY = "ARRAY".freeze
-      Sequel::Deprecation.deprecate_constant(self, :ARRAY)
-      DOUBLE_COLON = '::'.freeze
-      Sequel::Deprecation.deprecate_constant(self, :DOUBLE_COLON)
-      EMPTY_ARRAY = "'{}'".freeze
-      Sequel::Deprecation.deprecate_constant(self, :EMPTY_ARRAY)
-      EMPTY_BRACKET = '[]'.freeze
-      Sequel::Deprecation.deprecate_constant(self, :EMPTY_BRACKET)
-      OPEN_BRACKET = '['.freeze
-      Sequel::Deprecation.deprecate_constant(self, :OPEN_BRACKET)
-      CLOSE_BRACKET = ']'.freeze
-      Sequel::Deprecation.deprecate_constant(self, :CLOSE_BRACKET)
-      COMMA = ','.freeze
-      Sequel::Deprecation.deprecate_constant(self, :COMMA)
-      BACKSLASH = '\\'.freeze
-      Sequel::Deprecation.deprecate_constant(self, :BACKSLASH)
-      EMPTY_STRING = ''.freeze
-      Sequel::Deprecation.deprecate_constant(self, :EMPTY_STRING)
-      OPEN_BRACE = '{'.freeze
-      Sequel::Deprecation.deprecate_constant(self, :OPEN_BRACE)
-      CLOSE_BRACE = '}'.freeze
-      Sequel::Deprecation.deprecate_constant(self, :CLOSE_BRACE)
-      NULL = 'NULL'.freeze
-      Sequel::Deprecation.deprecate_constant(self, :NULL)
-      QUOTE = '"'.freeze
-      Sequel::Deprecation.deprecate_constant(self, :QUOTE)
-
-      # SEQUEL5: Remove
-      ARRAY_TYPES = {}
-
-      # SEQUEL5: Remove
-      def self.register(db_type, opts=OPTS, &block)
-        Sequel::Deprecation.deprecate("Sequel::Postgres::PGArray.register", "Use Database#register_array_type on a Database instance using the pg_array extension") unless opts[:skip_deprecation_warning]
-
-        db_type = db_type.to_s
-        type = (opts[:type_symbol] || db_type).to_sym
-        type_procs = opts[:type_procs] || PG__TYPES
-        mod = opts[:typecast_methods_module] || DatabaseMethods
-        typecast_method_map = opts[:typecast_method_map] || ARRAY_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[:scalar_oid]
-          raise Error, "can't provide both a converter and :scalar_oid option to register" if converter 
-          converter = type_procs[soid]
-        end
-
-        array_type = (opts[:array_type] || db_type).to_s.dup.freeze
-        creator = Creator.new(array_type, converter)
-
-        typecast_method_map[db_type] = :"#{type}_array"
-
-        define_array_typecast_method(mod, type, creator, opts.fetch(:scalar_typecast, type))
-
-        if oid = opts[:oid]
-          if opts[:skip_deprecation_warning]
-            def creator.call(s)
-              Sequel::Deprecation.deprecate("Conversion proc for #{type}[] added globally by pg_array or other pg_* extension", "Load the appropriate pg_* extension(s) into the Database instance")
-              super
-            end
-          end
-          type_procs[oid] = creator
-        end
-
-        nil
-      end
-
-      # SEQUEL5: Remove
-      def self.define_array_typecast_method(mod, type, creator, scalar_typecast)
-        mod.class_eval do
-          meth = :"typecast_value_#{type}_array"
-          scalar_typecast_method = :"typecast_value_#{scalar_typecast}"
-          define_method(meth){|v| typecast_value_pg_array(v, creator, scalar_typecast_method)}
-          private meth
-        end
-      end
-      private_class_method :define_array_typecast_method
-
       module DatabaseMethods
-        APOS = "'".freeze
-        Sequel::Deprecation.deprecate_constant(self, :APOS)
-        DOUBLE_APOS = "''".freeze
-        Sequel::Deprecation.deprecate_constant(self, :DOUBLE_APOS)
-        ESCAPE_RE = /("|\\)/.freeze
-        Sequel::Deprecation.deprecate_constant(self, :ESCAPE_RE)
-        ESCAPE_REPLACEMENT = '\\\\\1'.freeze
-        Sequel::Deprecation.deprecate_constant(self, :ESCAPE_REPLACEMENT)
-
         BLOB_RANGE = 1...-1
 
         # Create the local hash of database type strings to schema type symbols,
         # used for array types local to this database.
         def self.extended(db)
-          db.instance_eval do
+          db.instance_exec do
             @pg_array_schema_types ||= {}
-            procs = conversion_procs
-            add_conversion_proc(1115, Creator.new("timestamp without time zone", procs[1114]))
-            add_conversion_proc(1185, Creator.new("timestamp with time zone", procs[1184]))
+            register_array_type('timestamp without time zone', :oid=>1115, :scalar_oid=>1114, :type_symbol=>:datetime)
+            register_array_type('timestamp with time zone', :oid=>1185, :scalar_oid=>1184, :type_symbol=>:datetime_timezone, :scalar_typecast=>:datetime)
 
             register_array_type('text', :oid=>1009, :scalar_oid=>25, :type_symbol=>:string)
             register_array_type('integer', :oid=>1007, :scalar_oid=>23)
@@ -220,6 +127,15 @@ module Sequel
           end
         end
 
+        def add_named_conversion_proc(name, &block)
+          ret = super
+          name = name.to_s if name.is_a?(Symbol)
+          from(:pg_type).where(:typname=>name).select_map([:oid, :typarray]).each do |scalar_oid, array_oid|
+            register_array_type(name, :oid=>array_oid.to_i, :scalar_oid=>scalar_oid.to_i)
+          end
+          ret
+        end
+
         # Handle arrays in bound variables
         def bound_variable_arg(arg, conn)
           case arg
@@ -260,9 +176,6 @@ module Sequel
         #
         # If a block is given, it is treated as the :converter option.
         def register_array_type(db_type, opts=OPTS, &block)
-          # Only for convert_named_procs_to_procs usage
-          type_procs = opts[:type_procs] || conversion_procs # SEQUEL5: Remove
-
           oid = opts[:oid]
           soid = opts[:scalar_oid]
 
@@ -286,17 +199,16 @@ module Sequel
 
           if soid
             raise Error, "can't provide both a converter and :scalar_oid option to register" if has_converter 
-            converter = type_procs[soid] # SEQUEL5: conversion_procs[soid]
+            converter = conversion_procs[soid]
           end
 
           array_type = (opts[:array_type] || db_type).to_s.dup.freeze
           creator = Creator.new(array_type, converter)
-          type_procs[oid] = creator # SEQUEL5: Remove
-          #add_conversion_proc(oid, creator) # SEQUEL5
+          add_conversion_proc(oid, creator)
 
           typecast_method_map[db_type] = :"#{type}_array"
 
-          (class << self; self end).class_eval do # singleton_class.class_eval do # SEQUEL5
+          singleton_class.class_eval do
             meth = :"typecast_value_#{type}_array"
             scalar_typecast_method = :"typecast_value_#{opts.fetch(:scalar_typecast, type)}"
             define_method(meth){|v| typecast_value_pg_array(v, creator, scalar_typecast_method)}
@@ -304,15 +216,9 @@ module Sequel
           end
 
           @schema_type_classes[:"#{type}_array"] = PGArray
-          conversion_procs_updated # SEQUEL5: Remove
           nil
         end
 
-        # SEQUEL5: Remove
-        def schema_type_class(type)
-          super || (ARRAY_TYPES.each_value{|v| return PGArray if type == v}; nil)
-        end
-
         private
 
         # Format arrays used in bound variables.
@@ -331,32 +237,11 @@ module Sequel
           end
         end
 
-        # Automatically handle array types for the given named types. 
-        def convert_named_procs_to_procs(named_procs)
-          h = super
-          unless h.empty?
-            from(:pg_type).where(:oid=>h.keys).select_map([:typname, :oid, :typarray]).each do |name, scalar_oid, array_oid|
-              register_array_type(name, :type_procs=>h, :oid=>array_oid.to_i, :scalar_oid=>scalar_oid.to_i)
-            end
-          end
-          h
-        end
-
-        # SEQUEL5: Remove
-        def get_conversion_procs
-          procs = super
-
-          procs[1115] = Creator.new("timestamp without time zone", procs[1114])
-          procs[1185] = Creator.new("timestamp with time zone", procs[1184])
-
-          procs
-        end
-
         # Look into both the current database's array schema types and the global
         # array schema types to get the type symbol for the given database type
         # string.
         def pg_array_schema_type(type)
-          @pg_array_schema_types[type] || ARRAY_TYPES[type] # SEQUEL5: Remove || ARRAY_TYPES[type] 
+          @pg_array_schema_types[type]
         end
 
         # Make the column type detection handle registered array types.
@@ -408,15 +293,6 @@ module Sequel
       # Note that does not handle all forms out input that PostgreSQL will
       # accept, and it will not raise an error for all forms of invalid input.
       class Parser < StringScanner
-        UNQUOTED_RE = /[{}",]|[^{}",]+/
-        Sequel::Deprecation.deprecate_constant(self, :UNQUOTED_RE)
-        QUOTED_RE = /["\\]|[^"\\]+/
-        Sequel::Deprecation.deprecate_constant(self, :QUOTED_RE)
-        NULL_RE = /NULL",/
-        Sequel::Deprecation.deprecate_constant(self, :NULL_RE)
-        OPEN_RE = /((\[\d+:\d+\])+=)?\{/
-        Sequel::Deprecation.deprecate_constant(self, :OPEN_RE)
-
         # Set the source for the input, and any converter callable
         # to call with objects to be created.  For nested parsers
         # the source may contain text after the end current parse,
@@ -425,8 +301,8 @@ module Sequel
           super(source)
           @converter = converter 
           @stack = [[]]
-          @recorded = new_entry_buffer
-          #@encoding = string.encoding # SEQUEL5
+          @encoding = string.encoding
+          @recorded = String.new.force_encoding(@encoding)
         end
 
         # Take the buffer of recorded characters and add it to the array
@@ -440,7 +316,7 @@ module Sequel
               entry = @converter.call(entry)
             end
             @stack.last.push(entry)
-            @recorded = new_entry_buffer
+            @recorded = String.new.force_encoding(@encoding)
           end
         end
 
@@ -499,21 +375,6 @@ module Sequel
 
           raise Sequel::Error, "array parsing finished with array unclosed"
         end
-
-        private
-
-        if RUBY_VERSION < '1.9.0'
-          # :nocov:
-          def new_entry_buffer
-            String.new
-          end
-          # :nocov:
-        else
-          def new_entry_buffer
-            String.new.force_encoding(string.encoding)
-            #String.new.force_encoding(@encoding) # SEQUEL5
-          end
-        end
       end unless Sequel::Postgres.respond_to?(:parse_pg_array)
 
       # Callable object that takes the input string and parses it using Parser.
@@ -596,36 +457,6 @@ module Sequel
         end
         sql << ']'
       end
-
-      # SEQUEL5: Remove
-      register('text', :oid=>1009, :scalar_oid=>25, :type_symbol=>:string, :skip_deprecation_warning=>true)
-      register('integer', :oid=>1007, :scalar_oid=>23, :skip_deprecation_warning=>true)
-      register('bigint', :oid=>1016, :scalar_oid=>20, :scalar_typecast=>:integer, :skip_deprecation_warning=>true)
-      register('numeric', :oid=>1231, :scalar_oid=>1700, :type_symbol=>:decimal, :skip_deprecation_warning=>true)
-      register('double precision', :oid=>1022, :scalar_oid=>701, :type_symbol=>:float, :skip_deprecation_warning=>true)
-      register('boolean', :oid=>1000, :scalar_oid=>16, :skip_deprecation_warning=>true)
-      register('bytea', :oid=>1001, :scalar_oid=>17, :type_symbol=>:blob, :skip_deprecation_warning=>true)
-      register('date', :oid=>1182, :scalar_oid=>1082, :skip_deprecation_warning=>true)
-      register('time without time zone', :oid=>1183, :scalar_oid=>1083, :type_symbol=>:time, :skip_deprecation_warning=>true)
-      register('timestamp without time zone', :oid=>1115, :scalar_oid=>1114, :type_symbol=>:datetime, :skip_deprecation_warning=>true)
-      register('time with time zone', :oid=>1270, :scalar_oid=>1083, :type_symbol=>:time_timezone, :scalar_typecast=>:time, :skip_deprecation_warning=>true)
-      register('timestamp with time zone', :oid=>1185, :scalar_oid=>1184, :type_symbol=>:datetime_timezone, :scalar_typecast=>:datetime, :skip_deprecation_warning=>true)
-      register('smallint', :oid=>1005, :scalar_oid=>21, :scalar_typecast=>:integer, :skip_deprecation_warning=>true)
-      register('oid', :oid=>1028, :scalar_oid=>26, :scalar_typecast=>:integer, :skip_deprecation_warning=>true)
-      register('real', :oid=>1021, :scalar_oid=>700, :scalar_typecast=>:float, :skip_deprecation_warning=>true)
-      register('character', :oid=>1014, :array_type=>:text, :scalar_typecast=>:string, :skip_deprecation_warning=>true)
-      register('character varying', :oid=>1015, :scalar_typecast=>:string, :type_symbol=>:varchar, :skip_deprecation_warning=>true)
-      register('xml', :oid=>143, :scalar_oid=>142, :skip_deprecation_warning=>true)
-      register('money', :oid=>791, :scalar_oid=>790, :skip_deprecation_warning=>true)
-      register('bit', :oid=>1561, :scalar_oid=>1560, :skip_deprecation_warning=>true)
-      register('bit varying', :oid=>1563, :scalar_oid=>1562, :type_symbol=>:varbit, :skip_deprecation_warning=>true)
-      register('uuid', :oid=>2951, :scalar_oid=>2950, :skip_deprecation_warning=>true)
-      register('xid', :oid=>1011, :scalar_oid=>28, :skip_deprecation_warning=>true)
-      register('cid', :oid=>1012, :scalar_oid=>29, :skip_deprecation_warning=>true)
-      register('name', :oid=>1003, :scalar_oid=>19, :skip_deprecation_warning=>true)
-      register('tid', :oid=>1010, :scalar_oid=>27, :skip_deprecation_warning=>true)
-      register('int2vector', :oid=>1006, :scalar_oid=>22, :skip_deprecation_warning=>true)
-      register('oidvector', :oid=>1013, :scalar_oid=>30, :skip_deprecation_warning=>true)
     end
   end
 

data/lib/sequel/extensions/pg_extended_date_support.rb

@@ -0,0 +1,230 @@
+# frozen-string-literal: true
+#
+# The pg_extended_date_support extension allows support
+# for BC dates/timestamps by default, and infinite
+# dates/timestamps if configured.  Without this extension,
+# BC and infinite dates/timestamps will be handled incorrectly
+# or raise an error.  This behavior isn't the default because
+# it can hurt performance, and few users need support for BC
+# and infinite dates/timestamps.
+#
+# To load the extension into the database:
+#
+#   DB.extension :pg_extended_date_support
+#
+# To enable support for infinite dates/timestamps:
+#
+#   DB.convert_infinite_timestamps = 'string' # or 'nil' or 'float'
+#
+# Related module: Sequel::Postgres::ExtendedDateSupport
+
+#
+module Sequel
+  module Postgres
+    module ExtendedDateSupport
+      DATE_YEAR_1 = Date.new(1)
+      DATETIME_YEAR_1 = DateTime.new(1)
+      TIME_YEAR_1 = Time.at(-62135596800).utc
+      INFINITE_TIMESTAMP_STRINGS = ['infinity'.freeze, '-infinity'.freeze].freeze
+      INFINITE_DATETIME_VALUES = ([PLUS_INFINITY, MINUS_INFINITY] + INFINITE_TIMESTAMP_STRINGS).freeze
+      PLUS_DATE_INFINITY = Date::Infinity.new
+      MINUS_DATE_INFINITY = -PLUS_DATE_INFINITY
+
+      # Add dataset methods and update the conversion proces for dates and timestamps.
+      def self.extended(db)
+        db.extend_datasets(DatasetMethods)
+        procs = db.conversion_procs
+        procs[1082] = ::Sequel.method(:string_to_date)
+        procs[1184] = procs[1114] = db.method(:to_application_timestamp)
+      end
+
+      # 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
+
+      # 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 'date'
+          :date
+        when 'float'
+          :float
+        when String, true
+          typecast_value_boolean(v)
+        else
+          false
+        end
+
+        pr = old_pr = Sequel.method(:string_to_date)
+        if @convert_infinite_timestamps
+          pr = lambda do |val|
+            case val
+            when *INFINITE_TIMESTAMP_STRINGS
+              infinite_timestamp_value(val)
+            else
+              old_pr.call(val)
+            end
+          end
+        end
+        add_conversion_proc(1082, pr)
+      end
+
+      # Handle BC dates in timestamps by moving the BC from after the time to
+      # after the date, to appease ruby's date parser.
+      # 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 value.is_a?(String) && (m = value.match(/(?:(?:[-+]\d\d:\d\d)(:\d\d)?)?( BC)?\z/)) && (m[1] || m[2])
+          if m[2]
+            value = value.sub(' BC', '').sub(' ', ' BC ')
+          end
+          if m[1]
+            dt = DateTime.parse(value)
+            dt = dt.to_time unless Sequel.datetime_class == DateTime
+            Sequel.convert_output_timestamp(dt, Sequel.application_timezone)
+          else
+            super(value)
+          end
+        elsif convert_infinite_timestamps
+          case value
+          when *INFINITE_TIMESTAMP_STRINGS
+            infinite_timestamp_value(value)
+          else
+            super
+          end
+        else
+          super
+        end
+      end
+
+      private
+      
+      # 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
+        when :date
+          value == 'infinity' ? PLUS_DATE_INFINITY : MINUS_DATE_INFINITY
+        else
+          value == 'infinity' ? PLUS_INFINITY : MINUS_INFINITY
+        end
+      end
+      
+      # If the value is an infinite value (either an infinite float or a string returned by
+      # by PostgreSQL for an infinite date), 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
+      end
+        
+      module DatasetMethods
+        private
+
+        # Handle BC Date objects.
+        def literal_date(date)
+          if date < DATE_YEAR_1
+            date <<= ((date.year) * 24 - 12)
+            date.strftime("'%Y-%m-%d BC'")
+          else
+            super
+          end
+        end
+
+        # Handle BC DateTime objects.
+        def literal_datetime(date)
+          if date < DATETIME_YEAR_1
+            date <<= ((date.year) * 24 - 12)
+            date = db.from_application_timestamp(date)
+            minutes = (date.is_a?(DateTime) ? date.offset * 1440 : date.utc_offset/60).to_i
+            date.strftime("'%Y-%m-%d %H:%M:%S.%N#{format_timestamp_offset(*minutes.divmod(60))} BC'")
+          else
+            super
+          end
+        end
+
+        # Handle Date::Infinity values
+        def literal_other_append(sql, v)
+          if v.is_a?(Date::Infinity)
+            sql << (v > 0 ? "'infinity'" : "'-infinity'")
+          else
+            super
+          end
+        end
+
+        if RUBY_ENGINE == 'jruby'
+          # :nocov:
+
+          # Work around JRuby bug #4822 in Time#to_datetime for times before date of calendar reform
+          def literal_time(time)
+            if time < TIME_YEAR_1
+              literal_datetime(DateTime.parse(super))
+            else
+              super
+            end
+          end
+
+          ExtendedDateSupport::CONVERT_TYPES = [Java::JavaSQL::Types::DATE, Java::JavaSQL::Types::TIMESTAMP]
+
+          # Use non-JDBC parsing as JDBC parsing doesn't work for BC dates/timestamps.
+          def type_convertor(map, meta, type, i)
+            case type
+            when *CONVERT_TYPES
+              db.oid_convertor_proc(meta.getField(i).getOID)
+            else
+              super
+            end
+          end
+          # :nocov:
+        else
+          # Handle BC Time objects.
+          def literal_time(time)
+            if time < TIME_YEAR_1
+              literal_datetime(time.to_datetime)
+            else
+              super
+            end
+          end
+        end
+      end
+    end
+  end
+
+  Database.register_extension(:pg_extended_date_support, Postgres::ExtendedDateSupport)
+end

data/lib/sequel/extensions/pg_hstore.rb

@@ -30,7 +30,7 @@
 # Since the hstore type only supports strings, non string keys and
 # values are converted to strings
 #
-#   Sequel.hstore(:foo=>1).to_hash # {'foo'=>'1'}
+#   Sequel.hstore(foo: 1).to_hash # {'foo'=>'1'}
 #   v = Sequel.hstore({})
 #   v[:foo] = 1
 #   v # {'foo'=>'1'}
@@ -68,7 +68,7 @@
 #
 # If you want to insert a hash into an hstore database column:
 #
-#   DB[:table].insert(:column=>Sequel.hstore('foo'=>'bar'))
+#   DB[:table].insert(column: Sequel.hstore('foo'=>'bar'))
 #
 # To use this extension, first load it into your Sequel::Database instance:
 #
@@ -91,21 +91,6 @@ module Sequel
 
       # Parser for PostgreSQL hstore output format.
       class Parser < StringScanner
-        QUOTE_RE = /"/.freeze
-        Sequel::Deprecation.deprecate_constant(self, :QUOTE_RE)
-        KV_SEP_RE = /"\s*=>\s*/.freeze
-        Sequel::Deprecation.deprecate_constant(self, :KV_SEP_RE)
-        NULL_RE = /NULL/.freeze
-        Sequel::Deprecation.deprecate_constant(self, :NULL_RE)
-        SEP_RE = /,\s*/.freeze
-        Sequel::Deprecation.deprecate_constant(self, :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'.freeze
-        Sequel::Deprecation.deprecate_constant(self, :REPLACE_WITH)
-
         # Parse the output format that PostgreSQL uses for hstore
         # columns.  Note that this does not attempt to parse all
         # input formats that PostgreSQL will accept.  For instance,
@@ -144,7 +129,7 @@ module Sequel
 
       module DatabaseMethods
         def self.extended(db)
-          db.instance_eval do
+          db.instance_exec do
             add_named_conversion_proc(:hstore, &HStore.method(:parse))
             @schema_type_classes[:hstore] = HStore
           end
@@ -162,13 +147,6 @@ module Sequel
           end
         end
 
-        # SEQUEL5: Remove
-        def reset_conversion_procs
-          procs = super
-          add_named_conversion_proc(:hstore, &HStore.method(:parse))
-          procs 
-        end
-
         private
 
         # Recognize the hstore database type.
@@ -198,29 +176,12 @@ module Sequel
       # keys to strings during lookup.
       DEFAULT_PROC = lambda{|h, k| h[k.to_s] unless k.is_a?(String)}
 
-      QUOTE = '"'.freeze
-      Sequel::Deprecation.deprecate_constant(self, :QUOTE)
-      COMMA = ",".freeze
-      Sequel::Deprecation.deprecate_constant(self, :COMMA)
-      KV_SEP = "=>".freeze
-      Sequel::Deprecation.deprecate_constant(self, :KV_SEP)
-      NULL = "NULL".freeze
-      Sequel::Deprecation.deprecate_constant(self, :NULL)
-      ESCAPE_RE = /("|\\)/.freeze
-      Sequel::Deprecation.deprecate_constant(self, :ESCAPE_RE)
-      ESCAPE_REPLACE = '\\\\\1'.freeze
-      Sequel::Deprecation.deprecate_constant(self, :ESCAPE_REPLACE)
-      HSTORE_CAST = '::hstore'.freeze
-      Sequel::Deprecation.deprecate_constant(self, :HSTORE_CAST)
-
-      if RUBY_VERSION >= '1.9'
-        # Undef 1.9 marshal_{dump,load} methods in the delegate class,
-        # so that ruby 1.9 uses the old style _dump/_load methods defined
-        # in the delegate class, instead of the marshal_{dump,load} methods
-        # in the Hash class.
-        undef_method :marshal_load
-        undef_method :marshal_dump
-      end
+      # Undef marshal_{dump,load} methods in the delegate class,
+      # so that ruby uses the old style _dump/_load methods defined
+      # in the delegate class, instead of the marshal_{dump,load} methods
+      # in the Hash class.
+      undef_method :marshal_load
+      undef_method :marshal_dump
 
       # Use custom marshal loading, since underlying hash uses a default proc.
       def self._load(args)
@@ -234,12 +195,12 @@ module Sequel
       end
 
       # Override methods that accept key argument to convert to string.
-      (%w'[] delete has_key? include? key? member?' + Array((%w'assoc' if RUBY_VERSION >= '1.9.0'))).each do |m|
+      %w'[] delete has_key? include? key? member? assoc'.each do |m|
         class_eval("def #{m}(k) super(k.to_s) end", __FILE__, __LINE__)
       end
 
       # Override methods that accept value argument to convert to string unless nil.
-      (%w'has_value? value?' + Array((%w'key rassoc' if RUBY_VERSION >= '1.9.0'))).each do |m|
+      %w'has_value? value? key rassoc'.each do |m|
         class_eval("def #{m}(v) super(convert_value(v)) end", __FILE__, __LINE__)
       end
 

data/lib/sequel/extensions/pg_hstore_ops.rb

@@ -57,10 +57,10 @@
 # Here are a couple examples for updating an existing hstore column:
 #
 #   # Add a key, or update an existing key with a new value
-#   DB[:tab].update(:h=>Sequel.hstore_op(:h).concat('c'=>3))
+#   DB[:tab].update(h: Sequel.hstore_op(:h).concat('c'=>3))
 # 
 #   # Delete a key
-#   DB[:tab].update(:h=>Sequel.hstore_op(:h).delete('k1'))
+#   DB[:tab].update(h: Sequel.hstore_op(:h).delete('k1'))
 #  
 # See the PostgreSQL hstore function and operator documentation for more
 # details on what these functions and operators do.