sequel 4.26.0 → 5.37.0

data/lib/sequel/extensions/pg_json_ops.rb

@@ -1,7 +1,9 @@
+# frozen-string-literal: true
+#
 # 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:
 #
@@ -20,10 +22,10 @@
 #  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.expr(:json_column).pg_json
-#   jb = Sequel.expr(:jsonb_column).pg_jsonb
+#   j = Sequel[:json_column].pg_json
+#   jb = Sequel[:jsonb_column].pg_jsonb
 #
 # If you have loaded the {core_extensions extension}[rdoc-ref:doc/core_extensions.rdoc],
 # or you have loaded the core_refinements extension
@@ -50,6 +52,7 @@
 #   j.each_text              # json_each_text(json_column)
 #   j.keys                   # json_object_keys(json_column)
 #   j.typeof                 # json_typeof(json_column)
+#   j.strip_nulls            # json_strip_nulls(json_column)
 #
 #   j.populate(:a)           # json_populate_record(:a, json_column)
 #   j.populate_set(:a)       # json_populate_recordset(:a, json_column)
@@ -58,11 +61,45 @@
 #
 # There are additional methods are are only supported on JSONBOp instances:
 #
-#   j.contain_all(:a)  # (jsonb_column ?& a)
-#   j.contain_any(:a)  # (jsonb_column ?| a)
-#   j.contains(:h)     # (jsonb_column @> h)
-#   j.contained_by(:h) # (jsonb_column <@ h)
-#   j.has_key?('a')    # (jsonb_column ? 'a')
+#   j - 1                     # (jsonb_column - 1)
+#   j.concat(:h)              # (jsonb_column || h)
+#   j.contain_all(:a)         # (jsonb_column ?& a)
+#   j.contain_any(:a)         # (jsonb_column ?| a)
+#   j.contains(:h)            # (jsonb_column @> h)
+#   j.contained_by(:h)        # (jsonb_column <@ h)
+#   j.delete_path(%w'0 a')    # (jsonb_column #- ARRAY['0','a'])
+#   j.has_key?('a')           # (jsonb_column ? 'a')
+#   j.insert(%w'0 a', 'a'=>1) # jsonb_insert(jsonb_column, ARRAY[0, 'a'], '{"a":1}'::jsonb, false)
+#   j.pretty                  # jsonb_pretty(jsonb_column)
+#   j.set(%w'0 a', :h)        # jsonb_set(jsonb_column, ARRAY['0','a'], h, true)
+#
+#   j.set_lax(%w'0 a', :h, false, 'raise_exception')
+#   # jsonb_set_lax(jsonb_column, ARRAY['0','a'], h, false, 'raise_exception')
+#
+# On PostgreSQL 12+ SQL/JSON path functions and operators are supported:
+#
+#   j.path_exists('$.foo')      # (jsonb_column @? '$.foo')
+#   j.path_match('$.foo')       # (jsonb_column @@ '$.foo')
+#
+#   j.path_exists!('$.foo')     # jsonb_path_exists(jsonb_column, '$.foo')
+#   j.path_match!('$.foo')      # jsonb_path_match(jsonb_column, '$.foo')
+#   j.path_query('$.foo')       # jsonb_path_query(jsonb_column, '$.foo')
+#   j.path_query_array('$.foo') # jsonb_path_query_array(jsonb_column, '$.foo')
+#   j.path_query_first('$.foo') # jsonb_path_query_first(jsonb_column, '$.foo')
+#
+# On PostgreSQL 13+ timezone-aware SQL/JSON path functions and operators are supported:
+#
+#   j.path_exists_tz!('$.foo')     # jsonb_path_exists_tz(jsonb_column, '$.foo')
+#   j.path_match_tz!('$.foo')      # jsonb_path_match_tz(jsonb_column, '$.foo')
+#   j.path_query_tz('$.foo')       # jsonb_path_query_tz(jsonb_column, '$.foo')
+#   j.path_query_array_tz('$.foo') # jsonb_path_query_array_tz(jsonb_column, '$.foo')
+#   j.path_query_first_tz('$.foo') # jsonb_path_query_first_tz(jsonb_column, '$.foo')
+#
+# For the PostgreSQL 12+ SQL/JSON path functions, one argument is required (+path+) and
+# two more arguments are optional (+vars+ and +silent+).  +path+ specifies the JSON path.
+# +vars+ specifies a hash or a string in JSON format of named variables to be
+# substituted in +path+. +silent+ specifies whether errors are suppressed. By default,
+# errors are not suppressed.
 #
 # If you are also using the pg_json extension, you should load it before
 # loading this extension.  Doing so will allow you to use the #op method on
@@ -72,6 +109,9 @@
 # In order to get the automatic conversion from a ruby array to a PostgreSQL array
 # (as shown in the #[] and #get_text examples above), you need to load the pg_array
 # extension.
+#
+# Related modules: Sequel::Postgres::JSONBaseOp,  Sequel::Postgres::JSONOp,
+# Sequel::Postgres::JSONBOp
 
 #
 module Sequel
@@ -192,6 +232,13 @@ module Sequel
         SQL::Function.new(function_name(:populate_recordset), arg, self)
       end
 
+      # Returns a json value stripped of all internal null values.
+      #
+      #   json_op.strip_nulls # json_strip_nulls(json)
+      def strip_nulls
+        self.class.new(function(:strip_nulls))
+      end
+
       # Builds arbitrary record from json object.  You need to define the
       # structure of the record using #as on the resulting object:
       #
@@ -266,11 +313,31 @@ module Sequel
     #
     #   jsonb_op = Sequel.pg_jsonb(:jsonb)
     class JSONBOp < JSONBaseOp
+      CONCAT = ["(".freeze, " || ".freeze, ")".freeze].freeze
       CONTAIN_ALL = ["(".freeze, " ?& ".freeze, ")".freeze].freeze
       CONTAIN_ANY = ["(".freeze, " ?| ".freeze, ")".freeze].freeze
       CONTAINS = ["(".freeze, " @> ".freeze, ")".freeze].freeze
       CONTAINED_BY = ["(".freeze, " <@ ".freeze, ")".freeze].freeze
+      DELETE_PATH = ["(".freeze, " #- ".freeze, ")".freeze].freeze
       HAS_KEY = ["(".freeze, " ? ".freeze, ")".freeze].freeze
+      PATH_EXISTS = ["(".freeze, " @? ".freeze, ")".freeze].freeze
+      PATH_MATCH = ["(".freeze, " @@ ".freeze, ")".freeze].freeze
+
+      # jsonb expression for deletion of the given argument from the
+      # current jsonb.
+      #
+      #   jsonb_op - "a" # (jsonb - 'a')
+      def -(other)
+        self.class.new(super)
+      end
+
+      # jsonb expression for concatenation of the given jsonb into
+      # the current jsonb.
+      #
+      #   jsonb_op.concat(:h) # (jsonb || h)
+      def concat(other)
+        json_op(CONCAT, wrap_input_jsonb(other))
+      end
 
       # Check if the receiver contains all of the keys in the given array:
       #
@@ -300,6 +367,13 @@ module Sequel
         bool_op(CONTAINED_BY, wrap_input_jsonb(other))
       end
 
+      # Removes the given path from the receiver.
+      #
+      #   jsonb_op.delete_path(:h) # (jsonb #- h)
+      def delete_path(other)
+        json_op(DELETE_PATH, wrap_input_array(other))
+      end
+
       # Check if the receiver contains the given key:
       #
       #   jsonb_op.has_key?('a') # (jsonb ? 'a')
@@ -308,13 +382,176 @@ module Sequel
       end
       alias include? has_key?
 
+      # Inserts the given jsonb value at the given path in the receiver.
+      # The default is to insert the value before the given path, but
+      # insert_after can be set to true to insert it after the given path.
+      #
+      #   jsonb_op.insert(['a', 'b'], h) # jsonb_insert(jsonb, ARRAY['a', 'b'], h, false)
+      #   jsonb_op.insert(['a', 'b'], h, true) # jsonb_insert(jsonb, ARRAY['a', 'b'], h, true)
+      def insert(path, other, insert_after=false)
+        self.class.new(function(:insert, wrap_input_array(path), wrap_input_jsonb(other), insert_after))
+      end
+
+      # Returns whether the JSON path returns any item for the json object.
+      #
+      #   json_op.path_exists("$.foo") # (json @? '$.foo')
+      def path_exists(path)
+        bool_op(PATH_EXISTS, path)
+      end
+
+      # Returns whether the JSON path returns any item for the json object.
+      #
+      #   json_op.path_exists!("$.foo")
+      #   # jsonb_path_exists(json, '$.foo')
+      #
+      #   json_op.path_exists!("$.foo ? ($ > $x)", x: 2)
+      #   # jsonb_path_exists(json, '$.foo ? ($ > $x)', '{"x":2}')
+      #
+      #   json_op.path_exists!("$.foo ? ($ > $x)", {x: 2}, true)
+      #   # jsonb_path_exists(json, '$.foo ? ($ > $x)', '{"x":2}', true)
+      def path_exists!(path, vars=nil, silent=nil)
+        Sequel::SQL::BooleanExpression.new(:NOOP, _path_function(:jsonb_path_exists, path, vars, silent))
+      end
+
+      # The same as #path_exists!, except that timezone-aware conversions are used for date/time values.
+      def path_exists_tz!(path, vars=nil, silent=nil)
+        Sequel::SQL::BooleanExpression.new(:NOOP, _path_function(:jsonb_path_exists_tz, path, vars, silent))
+      end
+
+      # Returns the first item of the result of JSON path predicate check for the json object.
+      # Returns nil if the first item is not true or false.
+      #
+      #   json_op.path_match("$.foo") # (json @@ '$.foo')
+      def path_match(path)
+        bool_op(PATH_MATCH, path)
+      end
+
+      # Returns the first item of the result of JSON path predicate check for the json object.
+      # Returns nil if the first item is not true or false and silent is true.
+      #
+      #   json_op.path_match!("$.foo")
+      #   # jsonb_path_match(json, '$.foo')
+      #
+      #   json_op.path_match!("$.foo ? ($ > $x)", x: 2)
+      #   # jsonb_path_match(json, '$.foo ? ($ > $x)', '{"x":2}')
+      #
+      #   json_op.path_match!("$.foo ? ($ > $x)", {x: 2}, true)
+      #   # jsonb_path_match(json, '$.foo ? ($ > $x)', '{"x":2}', true)
+      def path_match!(path, vars=nil, silent=nil)
+        Sequel::SQL::BooleanExpression.new(:NOOP, _path_function(:jsonb_path_match, path, vars, silent))
+      end
+
+      # The same as #path_match!, except that timezone-aware conversions are used for date/time values.
+      def path_match_tz!(path, vars=nil, silent=nil)
+        Sequel::SQL::BooleanExpression.new(:NOOP, _path_function(:jsonb_path_match_tz, path, vars, silent))
+      end
+
+      # Returns a set of all jsonb values specified by the JSON path
+      # for the json object.
+      #
+      #   json_op.path_query("$.foo")
+      #   # jsonb_path_query(json, '$.foo')
+      #
+      #   json_op.path_query("$.foo ? ($ > $x)", x: 2)
+      #   # jsonb_path_query(json, '$.foo ? ($ > $x)', '{"x":2}')
+      #
+      #   json_op.path_query("$.foo ? ($ > $x)", {x: 2}, true)
+      #   # jsonb_path_query(json, '$.foo ? ($ > $x)', '{"x":2}', true)
+      def path_query(path, vars=nil, silent=nil)
+        _path_function(:jsonb_path_query, path, vars, silent)
+      end
+
+      # The same as #path_query, except that timezone-aware conversions are used for date/time values.
+      def path_query_tz(path, vars=nil, silent=nil)
+        _path_function(:jsonb_path_query_tz, path, vars, silent)
+      end
+
+      # Returns a jsonb array of all values specified by the JSON path
+      # for the json object.
+      #
+      #   json_op.path_query_array("$.foo")
+      #   # jsonb_path_query_array(json, '$.foo')
+      #
+      #   json_op.path_query_array("$.foo ? ($ > $x)", x: 2)
+      #   # jsonb_path_query_array(json, '$.foo ? ($ > $x)', '{"x":2}')
+      #
+      #   json_op.path_query_array("$.foo ? ($ > $x)", {x: 2}, true)
+      #   # jsonb_path_query_array(json, '$.foo ? ($ > $x)', '{"x":2}', true)
+      def path_query_array(path, vars=nil, silent=nil)
+        JSONBOp.new(_path_function(:jsonb_path_query_array, path, vars, silent))
+      end
+
+      # The same as #path_query_array, except that timezone-aware conversions are used for date/time values.
+      def path_query_array_tz(path, vars=nil, silent=nil)
+        JSONBOp.new(_path_function(:jsonb_path_query_array_tz, path, vars, silent))
+      end
+
+      # Returns the first item of the result specified by the JSON path
+      # for the json object.
+      #
+      #   json_op.path_query_first("$.foo")
+      #   # jsonb_path_query_first(json, '$.foo')
+      #
+      #   json_op.path_query_first("$.foo ? ($ > $x)", x: 2)
+      #   # jsonb_path_query_first(json, '$.foo ? ($ > $x)', '{"x":2}')
+      #
+      #   json_op.path_query_first("$.foo ? ($ > $x)", {x: 2}, true)
+      #   # jsonb_path_query_first(json, '$.foo ? ($ > $x)', '{"x":2}', true)
+      def path_query_first(path, vars=nil, silent=nil)
+        JSONBOp.new(_path_function(:jsonb_path_query_first, path, vars, silent))
+      end
+
+      # The same as #path_query_first, except that timezone-aware conversions are used for date/time values.
+      def path_query_first_tz(path, vars=nil, silent=nil)
+        JSONBOp.new(_path_function(:jsonb_path_query_first_tz, path, vars, silent))
+      end
+
       # Return the receiver, since it is already a JSONBOp.
       def pg_jsonb
         self
       end
 
+      # Return a pretty printed version of the receiver as a string expression.
+      #
+      #   jsonb_op.pretty # jsonb_pretty(jsonb)
+      def pretty
+        Sequel::SQL::StringExpression.new(:NOOP, function(:pretty))
+      end
+
+      # Set the given jsonb value at the given path in the receiver.
+      # By default, this will create the value if it does not exist, but
+      # create_missing can be set to false to not create a new value.
+      #
+      #   jsonb_op.set(['a', 'b'], h) # jsonb_set(jsonb, ARRAY['a', 'b'], h, true)
+      #   jsonb_op.set(['a', 'b'], h, false) # jsonb_set(jsonb, ARRAY['a', 'b'], h, false)
+      def set(path, other, create_missing=true)
+        self.class.new(function(:set, wrap_input_array(path), wrap_input_jsonb(other), create_missing))
+      end
+
+      # The same as #set, except if +other+ is +nil+, then behaves according to +null_value_treatment+,
+      # which can be one of 'raise_exception', 'use_json_null' (default), 'delete_key', or 'return_target'.
+      def set_lax(path, other, create_missing=true, null_value_treatment='use_json_null')
+        self.class.new(function(:set_lax, wrap_input_array(path), wrap_input_jsonb(other), create_missing, null_value_treatment))
+      end
+
       private
 
+      # Internals of the jsonb SQL/JSON path functions.
+      def _path_function(func, path, vars, silent)
+        args = []
+        if vars
+          if vars.is_a?(Hash)
+            vars = vars.to_json
+          end
+          args << vars
+
+          unless silent.nil?
+            args << silent
+          end
+        end
+        SQL::Function.new(func, self, path, *args)
+      end
+
       # Return a placeholder literal with the given str and args, wrapped
       # in a boolean expression, used by operators that return booleans.
       def bool_op(str, other)
@@ -359,7 +596,9 @@ module Sequel
       end
     end
 
+    # :nocov:
     if defined?(JSONArray)
+    # :nocov:
       class JSONArray
         # Wrap the JSONArray instance in an JSONOp, allowing you to easily use
         # the PostgreSQL json functions and operators with literal jsons.

data/lib/sequel/extensions/pg_loose_count.rb

@@ -1,3 +1,5 @@
+# frozen-string-literal: true
+#
 # The pg_loose_count extension looks at the table statistics
 # in the PostgreSQL system tables to get a fast approximate
 # count of the number of rows in a given table:
@@ -6,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
@@ -15,6 +17,8 @@
 # To load the extension into the database:
 #
 #   DB.extension :pg_loose_count
+#
+# Related module: Sequel::Postgres::LooseCount
 
 #
 module Sequel

data/lib/sequel/extensions/pg_range.rb

@@ -1,3 +1,5 @@
+# frozen-string-literal: true
+#
 # The pg_range extension adds support for the PostgreSQL 9.2+ range
 # types to Sequel.  PostgreSQL range types are similar to ruby's
 # Range class, representating an array of values.  However, they
@@ -38,100 +40,43 @@
 # 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
 #
-# If you are not using the native postgres or jdbc/postgresql adapters and are using range
-# types as model column values you probably should use the
-# pg_typecast_on_load plugin if the column values are returned as a string.
-#
 # See the {schema modification guide}[rdoc-ref:doc/schema_modification.rdoc]
 # for details on using range type columns in CREATE/ALTER TABLE statements.
 #
+# 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.  For user defined
+# types, you can do this via:
+#
+#   DB.add_conversion_proc(subtype_oid){|string| }
+#
+# Then you can call
+# Sequel::Postgres::PGRange::DatabaseMethods#register_range_type
+# to automatically set up a handler for the range type.  So if you
+# want to support the timerange type (assuming the time type is already
+# supported):
+#
+#   DB.register_range_type('timerange')
+#
 # 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:
 #
 #   DB.extension :pg_array, :pg_range
-
-Sequel.require 'adapters/utils/pg_types'
+#
+# Related module: Sequel::Postgres::PGRange
 
 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.
-      RANGE_TYPES = {}
-
-      EMPTY = 'empty'.freeze
-      EMPTY_STRING = ''.freeze
-      COMMA = ','.freeze
-      QUOTED_EMPTY_STRING = '""'.freeze
-      OPEN_PAREN = "(".freeze
-      CLOSE_PAREN = ")".freeze
-      OPEN_BRACKET = "[".freeze
-      CLOSE_BRACKET = "]".freeze
-      ESCAPE_RE = /("|,|\\|\[|\]|\(|\))/.freeze
-      ESCAPE_REPLACE = '\\\\\1'.freeze
-      CAST = '::'.freeze
-
-      # 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.
-      #
-      # If a block is given, it is treated as the :converter option.
-      def self.register(db_type, opts=OPTS, &block)
-        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 = opts[:subtype_oid]
-          raise Error, "can't provide both a converter and :scalar_oid option to register" if converter 
-          raise Error, "no conversion proc for :scalar_oid=>#{soid.inspect} in PG_TYPES" unless converter = PG_TYPES[soid]
-        end
-
-        parser = Parser.new(db_type, converter)
-
-        RANGE_TYPES[db_type] = db_type.to_sym
-
-        DatabaseMethods.define_range_typecast_method(db_type, parser)
-
-        if oid = opts[:oid]
-          Sequel::Postgres::PG_TYPES[oid] = parser
-        end
-
-        nil
-      end
-
       # 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
-
-        REPLACE_RE = /\\(.)/.freeze
-        REPLACE_WITH = '\1'.freeze
-
         # The database range type for this parser (e.g. 'int4range'),
         # automatically setting the db_type for the returned PGRange instances.
         attr_reader :db_type
@@ -148,11 +93,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] == ')'
@@ -166,12 +111,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
@@ -186,33 +131,38 @@ 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)
-            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 respond_to?(:register_array_type) && 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
-
-        # Define a private range typecasting method for the given type that uses
-        # the parser argument to do the type conversion.
-        def self.define_range_typecast_method(type, parser)
-          meth = :"typecast_value_#{type}"
-          define_method(meth){|v| typecast_value_pg_range(v, parser)}
-          private meth
         end
 
         # Handle Range and PGRange values in bound variables
@@ -227,6 +177,64 @@ module Sequel
           end
         end
 
+        # Freeze the pg range schema types to prevent adding new ones.
+        def freeze
+          @pg_range_schema_types.freeze
+          super
+        end
+
+        # Register a database specific range type.  This can be used to support
+        # 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)
+          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])
+            soid ||= subtype_oid unless has_converter
+            oid ||= range_oid
+          end
+
+          db_type = db_type.to_s.dup.freeze
+
+          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
+
+          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
+          nil
+        end
+
         private
 
         # Handle arrays of range types in bound variables.
@@ -239,31 +247,29 @@ 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.
-        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 = RANGE_TYPES[db_type]
+          if type = @pg_range_schema_types[db_type]
             type
           else
             super
           end
         end
 
+        # Set the :ruby_default value if the default value is recognized as a range.
+        def schema_post_process(_)
+          super.each do |a|
+            h = a[1]
+            db_type = h[:db_type]
+            if @pg_range_schema_types[db_type] && h[:default] =~ /\A'([^']+)'::#{db_type}\z/
+              default = $1
+              if convertor = conversion_procs[h[:oid]]
+                h[:ruby_default] = convertor.call(default)
+              end
+            end
+          end
+        end
+
         # Typecast value correctly to a PGRange.  If already an
         # PGRange instance with the same db_type, return as is.
         # If a PGRange with a different subtype, return a new
@@ -292,6 +298,8 @@ module Sequel
       end
 
       module DatasetMethods
+        private
+
         # Handle literalization of ruby Range objects, treating them as
         # PostgreSQL ranges.
         def literal_other_append(sql, v)
@@ -346,11 +354,20 @@ module Sequel
 
       # Delegate to the ruby range object so that the object mostly acts like a range.
       range_methods = %w'each last first step'
-      range_methods << 'cover?' if RUBY_VERSION >= '1.9'
       range_methods.each do |m|
         class_eval("def #{m}(*a, &block) to_range.#{m}(*a, &block) end", __FILE__, __LINE__)
       end
 
+      # Return whether the value is inside the range.
+      def cover?(value)
+        return false if empty?
+        b = self.begin
+        return false if b && b.public_send(exclude_begin? ? :>= : :>, value)
+        e = self.end
+        return false if e && e.public_send(exclude_end? ? :<= : :<, value)
+        true
+      end
+
       # Consider the receiver equal to other PGRange instances with the
       # same beginning, ending, exclusions, and database type.  Also consider
       # it equal to Range instances if this PGRange can be converted to a
@@ -381,6 +398,15 @@ module Sequel
       end
       alias == eql?
 
+      # Make sure equal ranges have the same hash.
+      def hash
+        if @empty
+          @db_type.hash
+        else
+          [@begin, @end, @exclude_begin, @exclude_end, @db_type].hash
+        end
+      end
+
       # Allow PGRange values in case statements, where they return true if they
       # are equal to each other using eql?, or if this PGRange can be converted
       # to a Range, delegating to that range.
@@ -416,28 +442,33 @@ 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
 
+      ENDLESS_RANGE_NOT_SUPPORTED = RUBY_VERSION < '2.6'
+      STARTLESS_RANGE_NOT_SUPPORTED = RUBY_VERSION < '2.7'
+
       # Return a ruby Range object for this instance, if one can be created.
       def to_range
         return @range if @range
         raise(Error, "cannot create ruby range for an empty PostgreSQL range") if empty?
         raise(Error, "cannot create ruby range when PostgreSQL range excludes beginning element") if exclude_begin?
-        raise(Error, "cannot create ruby range when PostgreSQL range has unbounded beginning") unless self.begin
-        raise(Error, "cannot create ruby range when PostgreSQL range has unbounded ending") unless self.end
+        # :nocov:
+        raise(Error, "cannot create ruby range when PostgreSQL range has unbounded beginning") if STARTLESS_RANGE_NOT_SUPPORTED && !self.begin
+        raise(Error, "cannot create ruby range when PostgreSQL range has unbounded ending") if ENDLESS_RANGE_NOT_SUPPORTED && !self.end
+        # :nocov:
         @range = Range.new(self.begin, self.end, exclude_end?)
       end
 
@@ -445,7 +476,7 @@ module Sequel
       # it must have a beginning and an ending (no unbounded ranges), and it cannot exclude
       # the beginning element.
       def valid_ruby_range?
-        !(empty? || exclude_begin? || !self.begin || !self.end)
+        !(empty? || exclude_begin? || (STARTLESS_RANGE_NOT_SUPPORTED && !self.begin) || (ENDLESS_RANGE_NOT_SUPPORTED && !self.end))
       end
 
       # Whether the beginning of the range is unbounded.
@@ -462,9 +493,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
 
@@ -475,7 +506,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
@@ -486,30 +517,15 @@ 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)
-    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)
-    end
   end
 
   module SQL::Builders