sequel 4.47.0 → 4.48.0

data/lib/sequel/extensions/pg_hstore.rb

@@ -49,18 +49,18 @@
 #
 # * \[\]
 # * \[\]=
-# * assoc (ruby 1.9 only)
+# * assoc
 # * delete
 # * fetch
 # * has_key?
 # * has_value?
 # * include?
-# * key (ruby 1.9 only)
+# * key
 # * key?
 # * member?
 # * merge
 # * merge!
-# * rassoc (ruby 1.9 only)
+# * rassoc
 # * replace
 # * store
 # * update
@@ -70,10 +70,7 @@
 #
 #   DB[:table].insert(:column=>Sequel.hstore('foo'=>'bar'))
 #
-# If you would like to use hstore columns in your model objects, you
-# probably want to modify the schema parsing/typecasting so that it
-# recognizes and correctly handles the hstore columns, which you can
-# do by:
+# To use this extension, first load it into your Sequel::Database instance:
 #
 #   DB.extension :pg_hstore
 #
@@ -95,12 +92,19 @@ 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
@@ -114,17 +118,17 @@ module Sequel
           return @result if @result
           hash = {}
           while !eos?
-            skip(QUOTE_RE)
+            skip(/"/)
             k = parse_quoted
-            skip(KV_SEP_RE)
-            if skip(QUOTE_RE)
+            skip(/"\s*=>\s*/)
+            if skip(/"/)
               v = parse_quoted
-              skip(QUOTE_RE)
+              skip(/"/)
             else
-              scan(NULL_RE)
+              scan(/NULL/)
               v = nil
             end
-            skip(SEP_RE)
+            skip(/,\s*/)
             hash[k] = v
           end
           @result = hash
@@ -134,7 +138,7 @@ module Sequel
 
         # Parse and unescape a quoted key/value.
         def parse_quoted
-          scan(QUOTED_RE).gsub(REPLACE_RE, REPLACE_WITH)
+          scan(/(\\"|[^"])*/).gsub(/\\(.)/, '\1')
         end
       end
 
@@ -158,6 +162,13 @@ 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.
@@ -188,12 +199,19 @@ module Sequel
       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,
@@ -258,7 +276,7 @@ module Sequel
       # Append a literalize version of the hstore to the sql.
       def sql_literal_append(ds, sql)
         ds.literal_append(sql, unquoted_literal)
-        sql << HSTORE_CAST
+        sql << '::hstore'
       end
 
       # Return a string containing the unquoted, unstring-escaped
@@ -267,10 +285,10 @@ module Sequel
       def unquoted_literal
         str = String.new
         comma = false
-        commas = COMMA
-        quote = QUOTE
-        kv_sep = KV_SEP
-        null = NULL
+        commas = ","
+        quote = '"'
+        kv_sep = "=>"
+        null = "NULL"
         each do |k, v|
           str << commas if comma
           str << quote << escape_value(k) << quote
@@ -303,7 +321,7 @@ module Sequel
       # Escape key/value strings when literalizing to
       # correctly handle backslash and quote characters.
       def escape_value(k)
-        k.to_s.gsub(ESCAPE_RE, ESCAPE_REPLACE)
+        k.to_s.gsub(/("|\\)/, '\\\\\1')
       end
     end
   end

data/lib/sequel/extensions/pg_inet.rb

@@ -29,7 +29,7 @@
 # Related module: Sequel::Postgres::InetDatabaseMethods
 
 require 'ipaddr'
-Sequel.require 'adapters/utils/pg_types'
+Sequel.require 'adapters/shared/postgres'
 
 module Sequel
   module Postgres
@@ -41,7 +41,14 @@ module Sequel
       def self.extended(db)
         db.instance_eval do
           extend_datasets(InetDatasetMethods)
-          copy_conversion_procs([869, 650, 1041, 651, 1040])
+          meth = IPAddr.method(:new)
+          add_conversion_proc(869, meth)
+          add_conversion_proc(650, meth)
+          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)
+          end
           @schema_type_classes[:ipaddr] = IPAddr
         end
       end
@@ -106,11 +113,16 @@ module Sequel
       end
     end
 
-    PG_TYPES[869] = PG_TYPES[650] = IPAddr.method(:new)
+    # 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)
-      PGArray.register('cidr', :oid=>651, :scalar_oid=>650)
-      PGArray.register('macaddr', :oid=>1040)
+      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
 

data/lib/sequel/extensions/pg_interval.rb

@@ -10,10 +10,7 @@
 # ActiveSupport::Duration that use the standard Sequel literalization
 # callbacks, so they work on all adapters.
 #
-# If you would like to use interval columns in your model objects, you
-# probably want to modify the typecasting so that it
-# recognizes and correctly handles the interval columns, which you can
-# do by:
+# To use this extension, load it into the Database instance:
 #
 #   DB.extension :pg_interval
 #
@@ -36,12 +33,13 @@
 # Related module: Sequel::Postgres::IntervalDatabaseMethods
 
 require 'active_support/duration'
-Sequel.require 'adapters/utils/pg_types'
+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
@@ -58,7 +56,7 @@ module Sequel
         end
 
         if s.empty?
-          EMPTY_INTERVAL
+          '0'
         else
           s
         end
@@ -67,11 +65,12 @@ 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/o
+        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 = PARSER.match(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)
 
           value = 0
           parts = []
@@ -124,7 +123,10 @@ module Sequel
       def self.extended(db)
         db.instance_eval do
           extend_datasets(IntervalDatasetMethods)
-          copy_conversion_procs([1186, 1187])
+          add_conversion_proc(1186, Postgres::IntervalDatabaseMethods::PARSER)
+          if respond_to?(:register_array_type)
+            register_array_type('interval', :oid=>1187, :scalar_oid=>1186)
+          end
           @schema_type_classes[:interval] = ActiveSupport::Duration
         end
       end
@@ -174,6 +176,7 @@ module Sequel
 
     module IntervalDatasetMethods
       CAST_INTERVAL = '::interval'.freeze
+      Sequel::Deprecation.deprecate_constant(self, :CAST_INTERVAL)
 
       # Handle literalization of ActiveSupport::Duration objects, treating them as
       # PostgreSQL intervals.
@@ -181,16 +184,20 @@ module Sequel
         case v
         when ActiveSupport::Duration
           literal_append(sql, IntervalDatabaseMethods.literal_duration(v))
-          sql << CAST_INTERVAL
+          sql << '::interval'
         else
           super
         end
       end
     end
 
-    PG_TYPES[1186] = Postgres::IntervalDatabaseMethods::PARSER
+    # 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)
+      PGArray.register('interval', :oid=>1187, :scalar_oid=>1186, :skip_deprecation_warning=>true)
     end
   end
 

data/lib/sequel/extensions/pg_json.rb

@@ -38,10 +38,7 @@
 #   DB[:table].insert(:column=>Sequel.pg_json([1, 2, 3]))
 #   DB[:table].insert(:column=>Sequel.pg_json({'a'=>1, 'b'=>2}))
 #
-# If you would like to use PostgreSQL json columns in your model
-# objects, you probably want to modify the schema parsing/typecasting
-# so that it recognizes and correctly handles the json type, which
-# you can do by:
+# To use this extension, please load it into the Database instance:
 #
 #   DB.extension :pg_json
 #
@@ -65,12 +62,14 @@
 
 require 'delegate'
 require 'json'
-Sequel.require 'adapters/utils/pg_types'
+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)
@@ -88,7 +87,7 @@ module Sequel
       # Cast as json
       def sql_literal_append(ds, sql)
         super
-        sql << CAST_JSON
+        sql << '::json'
       end
     end
 
@@ -96,7 +95,7 @@ module Sequel
       # Cast as jsonb
       def sql_literal_append(ds, sql)
         super
-        sql << CAST_JSONB
+        sql << '::jsonb'
       end
     end
 
@@ -119,7 +118,7 @@ module Sequel
       # Cast as json
       def sql_literal_append(ds, sql)
         super
-        sql << CAST_JSON
+        sql << '::json'
       end
     end
 
@@ -127,7 +126,7 @@ module Sequel
       # Cast as jsonb
       def sql_literal_append(ds, sql)
         super
-        sql << CAST_JSONB
+        sql << '::jsonb'
       end
     end
 
@@ -135,7 +134,12 @@ module Sequel
     module JSONDatabaseMethods
       def self.extended(db)
         db.instance_eval do
-          copy_conversion_procs([114, 199, 3802, 3807])
+          add_conversion_proc(114, JSONDatabaseMethods.method(:db_parse_json))
+          add_conversion_proc(3802, JSONDatabaseMethods.method(:db_parse_jsonb))
+          if respond_to?(:register_array_type)
+            register_array_type('json', :oid=>199, :scalar_oid=>114)
+            register_array_type('jsonb', :oid=>3807, :scalar_oid=>3802)
+          end
           @schema_type_classes[:json] = [JSONHash, JSONArray]
           @schema_type_classes[:jsonb] = [JSONBHash, JSONBArray]
         end
@@ -257,11 +261,18 @@ module Sequel
       end
     end
 
-    PG_TYPES[114] = JSONDatabaseMethods.method(:db_parse_json)
-    PG_TYPES[3802] = JSONDatabaseMethods.method(:db_parse_jsonb)
+    # 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)
-      PGArray.register('jsonb', :oid=>3807, :scalar_oid=>3802)
+      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
 

data/lib/sequel/extensions/pg_json_ops.rb

@@ -3,7 +3,7 @@
 # The pg_json_ops extension adds support to Sequel's DSL to make
 # it easier to call PostgreSQL JSON functions and operators (added
 # first in PostgreSQL 9.3).  It also supports the JSONB functions
-# and operators added in PostgreSQL 9.4).
+# and operators added in PostgreSQL 9.4.
 #
 # To load the extension:
 #
@@ -22,7 +22,7 @@
 #  jb = Sequel.pg_jsonb(:jsonb_column)
 #
 # Also, on most Sequel expression objects, you can call the pg_json
-# or pg_jsonb # method:
+# or pg_jsonb method:
 #
 #   j = Sequel[:json_column].pg_json
 #   jb = Sequel[:jsonb_column].pg_jsonb

data/lib/sequel/extensions/pg_range.rb

@@ -40,10 +40,7 @@
 # If you specify the range database type, Sequel will automatically cast
 # the value to that type when literalizing.
 #
-# If you would like to use range columns in your model objects, you
-# probably want to modify the schema parsing/typecasting so that it
-# recognizes and correctly handles the range type columns, which you can
-# do by:
+# To use this extension, load it into the Database instance:
 #
 #   DB.extension :pg_range
 #
@@ -52,11 +49,10 @@
 #
 # This extension makes it easy to add support for other range types.  In
 # general, you just need to make sure that the subtype is handled and has the
-# appropriate converter installed in Sequel::Postgres::PG_TYPES or the Database
-# instance's conversion_procs usingthe appropriate type OID.  For user defined
+# appropriate converter installed.  For user defined
 # types, you can do this via:
 #
-#   DB.conversion_procs[subtype_oid] = lambda{|string| }
+#   DB.add_conversion_proc(subtype_oid){|string| }
 #
 # Then you can call
 # Sequel::Postgres::PGRange::DatabaseMethods#register_range_type
@@ -66,18 +62,6 @@
 #
 #   DB.register_range_type('timerange')
 #
-# You can also register range types on a global basis using
-# Sequel::Postgres::PGRange.register.  In this case, you'll have
-# to specify the type oids:
-#
-#   Sequel::Postgres::PG_TYPES[1234] = lambda{|string| }
-#   Sequel::Postgres::PGRange.register('foo', :oid=>4321, :subtype_oid=>1234)
-#
-# Both Sequel::Postgres::PGRange::DatabaseMethods#register_range_type
-# and Sequel::Postgres::PGRange.register support many options to
-# customize the range type handling.  See the Sequel::Postgres::PGRange.register
-# method documentation.
-#
 # This extension integrates with the pg_array extension.  If you plan
 # to use arrays of range types, load the pg_array extension before the
 # pg_range extension:
@@ -86,54 +70,45 @@
 #
 # Related module: Sequel::Postgres::PGRange
 
-Sequel.require 'adapters/utils/pg_types'
+Sequel.require 'adapters/shared/postgres'
 
 module Sequel
   module Postgres
     class PGRange
       include Sequel::SQL::AliasMethods
 
-      # Map of string database type names to type symbols (e.g. 'int4range' => :int4range),
-      # used in the schema parsing.
+      # 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)
 
-      # Registers a range type that the extension should handle.  Makes a Database instance that
-      # has been extended with DatabaseMethods recognize the range type given and set up the
-      # appropriate typecasting.  Also sets up automatic typecasting for the native postgres
-      # adapter, so that on retrieval, the values are automatically converted to PGRange instances.
-      # The db_type argument should be the name of the range type. Accepts the following options:
-      #
-      # :converter :: A callable object (e.g. Proc), that is called with the start or end of the range
-      #               (usually a string), and should return the appropriate typecasted object.
-      # :oid :: The PostgreSQL OID for the range type.  This is used by the Sequel postgres adapter
-      #         to set up automatic type conversion on retrieval from the database.
-      # :subtype_oid :: Should be the PostgreSQL OID for the range's subtype. If given,
-      #                 automatically sets the :converter option by looking for scalar conversion
-      #                 proc.
-      # :type_procs :: A hash mapping oids to conversion procs, used for setting the default :converter
-      #                for :subtype_oid.  Defaults to the global Sequel::Postgres::PG_TYPES.
-      # :typecast_method_map :: The map in which to place the database type string to type symbol mapping.
-      #                         Defaults to RANGE_TYPES.
-      # :typecast_methods_module :: If given, a module object to add the typecasting method to.  Defaults
-      #                             to DatabaseMethods.
-      #
-      # If a block is given, it is treated as the :converter option.
+      # 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
+        type_procs = opts[:type_procs] || PG__TYPES
         mod = opts[:typecast_methods_module] || DatabaseMethods
         typecast_method_map = opts[:typecast_method_map] || RANGE_TYPES
 
@@ -155,14 +130,19 @@ module Sequel
         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
 
-      # Define a private range typecasting method for the given type that uses
-      # the parser argument to do the type conversion.
+      # SEQUEL5: Remove
       def self.define_range_typecast_method(mod, type, parser)
         mod.class_eval do
           meth = :"typecast_value_#{type}"
@@ -174,12 +154,12 @@ module Sequel
 
       # Creates callable objects that convert strings into PGRange instances.
       class Parser
-        # Regexp that parses the full range of PostgreSQL range type output,
-        # except for empty ranges.
-        PARSER = /\A(\[|\()("((?:\\"|[^"])*)"|[^"]*),("((?:\\"|[^"])*)"|[^"]*)(\]|\))\z/o
-
+        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.
@@ -197,11 +177,11 @@ module Sequel
 
         # Parse the range type input string into a PGRange value.
         def call(string)
-          if string == EMPTY
+          if string == 'empty'
             return PGRange.empty(db_type)
           end
 
-          raise(InvalidValue, "invalid or unhandled range format: #{string.inspect}") unless matches = PARSER.match(string)
+          raise(InvalidValue, "invalid or unhandled range format: #{string.inspect}") unless matches = /\A(\[|\()("((?:\\"|[^"])*)"|[^"]*),("((?:\\"|[^"])*)"|[^"]*)(\]|\))\z/.match(string)
 
           exclude_begin = matches[1] == '('
           exclude_end = matches[6] == ')'
@@ -215,12 +195,12 @@ module Sequel
           # to always use the quoted output form when characters need to be escaped, so
           # there isn't a need to unescape unquoted output.
           if beg = matches[3]
-            beg.gsub!(REPLACE_RE, REPLACE_WITH)
+            beg.gsub!(/\\(.)/, '\1')
           else
             beg = matches[2] unless matches[2].empty?
           end
           if en = matches[5]
-            en.gsub!(REPLACE_RE, REPLACE_WITH)
+            en.gsub!(/\\(.)/, '\1')
           else
             en = matches[4] unless matches[4].empty?
           end
@@ -241,20 +221,32 @@ module Sequel
           db.instance_eval do
             @pg_range_schema_types ||= {}
             extend_datasets(DatasetMethods)
-            copy_conversion_procs([3904, 3906, 3912, 3926, 3905, 3907, 3913, 3927])
+            register_range_type('int4range', :oid=>3904, :subtype_oid=>23)
+            register_range_type('numrange', :oid=>3906, :subtype_oid=>1700)
+            register_range_type('tsrange', :oid=>3908, :subtype_oid=>1114)
+            register_range_type('tstzrange', :oid=>3910, :subtype_oid=>1184)
+            register_range_type('daterange', :oid=>3912, :subtype_oid=>1082)
+            register_range_type('int8range', :oid=>3926, :subtype_oid=>20)
+            if respond_to?(:register_array_type)
+              register_array_type('int4range', :oid=>3905, :scalar_oid=>3904, :scalar_typecast=>:int4range)
+              register_array_type('numrange', :oid=>3907, :scalar_oid=>3906, :scalar_typecast=>:numrange)
+              register_array_type('tsrange', :oid=>3909, :scalar_oid=>3908, :scalar_typecast=>:tsrange)
+              register_array_type('tstzrange', :oid=>3911, :scalar_oid=>3910, :scalar_typecast=>:tstzrange)
+              register_array_type('daterange', :oid=>3913, :scalar_oid=>3912, :scalar_typecast=>:daterange)
+              register_array_type('int8range', :oid=>3927, :scalar_oid=>3926, :scalar_typecast=>:int8range)
+            end
             [:int4range, :numrange, :tsrange, :tstzrange, :daterange, :int8range].each do |v|
               @schema_type_classes[v] = PGRange
             end
-          end
 
-          procs = db.conversion_procs
-          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])
+            procs = conversion_procs
+            add_conversion_proc(3908, Parser.new("tsrange", procs[1114]))
+            add_conversion_proc(3910, Parser.new("tstzrange", procs[1184]))
+            if defined?(PGArray::Creator)
+              add_conversion_proc(3909, PGArray::Creator.new("tsrange", procs[3908]))
+              add_conversion_proc(3911, PGArray::Creator.new("tstzrange", procs[3910]))
+            end
           end
-
         end
 
         # Handle Range and PGRange values in bound variables
@@ -276,20 +268,62 @@ module Sequel
         end
 
         # Register a database specific range type.  This can be used to support
-        # different range types per Database.  Use of this method does not
-        # affect global state, unlike PGRange.register.  See PGRange.register for
-        # possible options.
+        # different range types per Database.  Options:
+        #
+        # :converter :: A callable object (e.g. Proc), that is called with the start or end of the range
+        #               (usually a string), and should return the appropriate typecasted object.
+        # :oid :: The PostgreSQL OID for the range type.  This is used by the Sequel postgres adapter
+        #         to set up automatic type conversion on retrieval from the database.
+        # :subtype_oid :: Should be the PostgreSQL OID for the range's subtype. If given,
+        #                 automatically sets the :converter option by looking for scalar conversion
+        #                 proc.
+        #
+        # If a block is given, it is treated as the :converter option.
         def register_range_type(db_type, opts=OPTS, &block)
-          opts = {:type_procs=>conversion_procs, :typecast_method_map=>@pg_range_schema_types, :typecast_methods_module=>(class << self; self; end)}.merge!(opts)
-          unless (opts.has_key?(:subtype_oid) || block) && opts.has_key?(:oid)
+          oid = opts[:oid]
+          soid = opts[:subtype_oid]
+
+          if has_converter = opts.has_key?(:converter)
+            raise Error, "can't provide both a block and :converter option to register_range_type" if block
+            converter = opts[:converter]
+          else
+            has_converter = true if block
+            converter = block
+          end
+
+          unless (soid || has_converter) && oid
             range_oid, subtype_oid = from(:pg_range).join(:pg_type, :oid=>:rngtypid).where(:typname=>db_type.to_s).get([:rngtypid, :rngsubtype])
-            opts[:subtype_oid] = subtype_oid unless opts.has_key?(:subtype_oid) || block
-            opts[:oid] = range_oid unless opts.has_key?(:oid)
+            soid ||= subtype_oid unless has_converter
+            oid ||= range_oid
+          end
+
+          db_type = db_type.to_s.dup.freeze
+
+          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
+            raise Error, "can't provide both a converter and :subtype_oid option to register" if has_converter 
+            raise Error, "no conversion proc for :subtype_oid=>#{soid.inspect} in conversion_procs" unless converter = conversion_procs[soid]
+          end
+
+          parser = Parser.new(db_type, converter)
+          add_conversion_proc(oid, parser)
+
+          @pg_range_schema_types[db_type] = db_type.to_sym
+
+          (class << self; self end).class_eval do
+            meth = :"typecast_value_#{db_type}"
+            define_method(meth){|v| typecast_value_pg_range(v, parser)}
+            private meth
           end
 
-          PGRange.register(db_type, opts, &block)
           @schema_type_classes[:"#{opts[:type_symbol] || db_type}"] = PGRange
-          conversion_procs_updated
+          conversion_procs_updated # SEQUEL5: Remove
+          nil
         end
 
         private
@@ -304,9 +338,7 @@ module Sequel
           end
         end
 
-        # Manually override the typecasting for tsrange and tstzrange types so that
-        # they use the database's timezone instead of the global Sequel
-        # timezone.
+        # SEQUEL5: Remove
         def get_conversion_procs
           procs = super
 
@@ -322,7 +354,7 @@ module Sequel
 
         # Recognize the registered database range types.
         def schema_column_type(db_type)
-          if type = @pg_range_schema_types[db_type] || RANGE_TYPES[db_type]
+          if type = @pg_range_schema_types[db_type] || RANGE_TYPES[db_type] # SEQUEL5: Remove || RANGE_TYPES[db_type]
             type
           else
             super
@@ -490,17 +522,17 @@ module Sequel
       # Append a literalize version of the receiver to the sql.
       def sql_literal_append(ds, sql)
         if (s = @db_type) && !empty?
-          sql << s.to_s << OPEN_PAREN
+          sql << s.to_s << "("
           ds.literal_append(sql, self.begin)
-          sql << COMMA
+          sql << ','
           ds.literal_append(sql, self.end)
-          sql << COMMA
-          ds.literal_append(sql, "#{exclude_begin? ? OPEN_PAREN : OPEN_BRACKET}#{exclude_end? ? CLOSE_PAREN : CLOSE_BRACKET}")
-          sql << CLOSE_PAREN
+          sql << ','
+          ds.literal_append(sql, "#{exclude_begin? ? "(" : "["}#{exclude_end? ? ")" : "]"}")
+          sql << ")"
         else
           ds.literal_append(sql, unquoted_literal(ds))
           if s
-            sql << CAST << s.to_s
+            sql << '::' << s.to_s
           end
         end
       end
@@ -536,9 +568,9 @@ module Sequel
       # Separated out for use by the bound argument code.
       def unquoted_literal(ds)
         if empty?
-          EMPTY
+          'empty'
         else
-          "#{exclude_begin? ? OPEN_PAREN : OPEN_BRACKET}#{escape_value(self.begin, ds)},#{escape_value(self.end, ds)}#{exclude_end? ? CLOSE_PAREN : CLOSE_BRACKET}"
+          "#{exclude_begin? ? "(" : "["}#{escape_value(self.begin, ds)},#{escape_value(self.end, ds)}#{exclude_end? ? ")" : "]"}"
         end
       end
 
@@ -549,7 +581,7 @@ module Sequel
       def escape_value(k, ds)
         case k
         when nil
-          EMPTY_STRING
+          ''
         when Date, Time
           ds.literal(k)[1...-1]
         when Integer, Float
@@ -560,29 +592,30 @@ module Sequel
           k
         when String
           if k.empty?
-            QUOTED_EMPTY_STRING
+            '""'
           else
-            k.gsub(ESCAPE_RE, ESCAPE_REPLACE)
+            k.gsub(/("|,|\\|\[|\]|\(|\))/, '\\\\\1')
           end
         else
-          ds.literal(k).gsub(ESCAPE_RE, ESCAPE_REPLACE)
+          ds.literal(k).gsub(/("|,|\\|\[|\]|\(|\))/, '\\\\\1')
         end
       end
     end
 
-    PGRange.register('int4range', :oid=>3904, :subtype_oid=>23)
-    PGRange.register('numrange', :oid=>3906, :subtype_oid=>1700)
-    PGRange.register('tsrange', :oid=>3908, :subtype_oid=>1114)
-    PGRange.register('tstzrange', :oid=>3910, :subtype_oid=>1184)
-    PGRange.register('daterange', :oid=>3912, :subtype_oid=>1082)
-    PGRange.register('int8range', :oid=>3926, :subtype_oid=>20)
+    # 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)
-      PGArray.register('numrange', :oid=>3907, :scalar_oid=>3906, :scalar_typecast=>:numrange)
-      PGArray.register('tsrange', :oid=>3909, :scalar_oid=>3908, :scalar_typecast=>:tsrange)
-      PGArray.register('tstzrange', :oid=>3911, :scalar_oid=>3910, :scalar_typecast=>:tstzrange)
-      PGArray.register('daterange', :oid=>3913, :scalar_oid=>3912, :scalar_typecast=>:daterange)
-      PGArray.register('int8range', :oid=>3927, :scalar_oid=>3926, :scalar_typecast=>:int8range)
+      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