sequel 4.36.0 → 5.61.0

data/lib/sequel/extensions/pg_range.rb

@@ -4,12 +4,9 @@
 # types to Sequel.  PostgreSQL range types are similar to ruby's
 # Range class, representating an array of values.  However, they
 # are more flexible than ruby's ranges, allowing exclusive beginnings
-# and endings (ruby's range only allows exclusive endings), and
-# unbounded beginnings and endings (which ruby's range does not
-# support).
+# and endings (ruby's range only allows exclusive endings).
 #
-# This extension integrates with Sequel's native postgres and jdbc/postgresql adapters, so
-# that when range type values are retrieved, they are parsed and returned
+# When PostgreSQL range values are retreived, they are parsed and returned
 # as instances of Sequel::Postgres::PGRange.  PGRange mostly acts
 # like a Range, but it's not a Range as not all PostgreSQL range
 # type values would be valid ruby ranges.  If the range type value
@@ -19,8 +16,7 @@
 # exception will be raised.
 #
 # In addition to the parser, this extension comes with literalizers
-# for both PGRange and Range that use the standard Sequel literalization
-# callbacks, so they work on all adapters.
+# for PGRange and Range, so they can be used in queries and as bound variables.
 #
 # To turn an existing Range into a PGRange, use Sequel.pg_range:
 #
@@ -40,10 +36,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 +45,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 +58,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,101 +66,13 @@
 #
 # Related module: Sequel::Postgres::PGRange
 
-Sequel.require 'adapters/utils/pg_types'
-
 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.
-      # :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.
-      def self.register(db_type, opts=OPTS, &block)
-        db_type = db_type.to_s.dup.freeze
-
-        type_procs = opts[:type_procs] || PG_TYPES
-        mod = opts[:typecast_methods_module] || DatabaseMethods
-        typecast_method_map = opts[:typecast_method_map] || RANGE_TYPES
-
-        if converter = opts[:converter]
-          raise Error, "can't provide both a block and :converter option to register" if block
-        else
-          converter = block
-        end
-
-        if soid = opts[:subtype_oid]
-          raise Error, "can't provide both a converter and :subtype_oid option to register" if converter 
-          raise Error, "no conversion proc for :subtype_oid=>#{soid.inspect} in PG_TYPES" unless converter = type_procs[soid]
-        end
-
-        parser = Parser.new(db_type, converter)
-
-        typecast_method_map[db_type] = db_type.to_sym
-
-        define_range_typecast_method(mod, db_type, parser)
-
-        if oid = opts[:oid]
-          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.
-      def self.define_range_typecast_method(mod, type, parser)
-        mod.class_eval do
-          meth = :"typecast_value_#{type}"
-          define_method(meth){|v| typecast_value_pg_range(v, parser)}
-          private meth
-        end
-      end
-      private_class_method :define_range_typecast_method
-
       # Creates callable objects that convert strings into PGRange instances.
       class Parser
-        # 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
@@ -197,11 +89,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 +107,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
@@ -235,26 +127,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
 
         # Handle Range and PGRange values in bound variables
@@ -269,21 +173,62 @@ 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.  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 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
 
-          PGRange.register(db_type, opts, &block)
           @schema_type_classes[:"#{opts[:type_symbol] || db_type}"] = PGRange
-          conversion_procs_updated
+          nil
         end
 
         private
@@ -298,28 +243,22 @@ 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 = @pg_range_schema_types[db_type] || RANGE_TYPES[db_type]
-            type
-          else
-            super
+          @pg_range_schema_types[db_type] || super
+        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
 
@@ -343,7 +282,7 @@ module Sequel
           when Range
             PGRange.from_range(value, parser.db_type)
           when String
-            parser.call(value)
+            parser.call(typecast_check_string_length(value, 100))
           else
             raise Sequel::InvalidValue, "invalid value for range type: #{value.inspect}"
           end
@@ -351,6 +290,8 @@ module Sequel
       end
 
       module DatasetMethods
+        private
+
         # Handle literalization of ruby Range objects, treating them as
         # PostgreSQL ranges.
         def literal_other_append(sql, v)
@@ -413,9 +354,9 @@ module Sequel
       def cover?(value)
         return false if empty?
         b = self.begin
-        return false if b && b.send(exclude_begin? ? :>= : :>, value)
+        return false if b && b.public_send(exclude_begin? ? :>= : :>, value)
         e = self.end
-        return false if e && e.send(exclude_end? ? :<= : :<, value)
+        return false if e && e.public_send(exclude_end? ? :<= : :<, value)
         true
       end
 
@@ -449,6 +390,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.
@@ -484,28 +434,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
 
@@ -513,7 +468,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.
@@ -530,9 +485,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
 
@@ -543,7 +498,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
@@ -554,30 +509,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

data/lib/sequel/extensions/pg_range_ops.rb

@@ -1,7 +1,7 @@
 # frozen-string-literal: true
 #
 # The pg_range_ops extension adds support to Sequel's DSL to make
-# it easier to call PostgreSQL range functions and operators.
+# it easier to call PostgreSQL range and multirange functions and operators.
 #
 # To load the extension:
 #
@@ -11,15 +11,16 @@
 #
 #   r = Sequel.pg_range_op(:range)
 #
-# If you have also loaded the pg_range extension, you can use
-# Sequel.pg_range as well:
+# If you have also loaded the pg_range or pg_multirange extensions, you can use
+# Sequel.pg_range or Sequel.pg_multirange as well:
 #
 #   r = Sequel.pg_range(:range)
+#   r = Sequel.pg_multirange(:range)
 #
 # Also, on most Sequel expression objects, you can call the pg_range
 # method:
 #
-#   r = Sequel.expr(:range).pg_range
+#   r = Sequel[:range].pg_range
 #
 # If you have loaded the {core_extensions extension}[rdoc-ref:doc/core_extensions.rdoc],
 # or you have loaded the core_refinements extension
@@ -46,13 +47,25 @@
 #   r.upper_inc        # upper_inc(range)
 #   r.lower_inf        # lower_inf(range)
 #   r.upper_inf        # upper_inf(range)
+#
+# All of the above methods work for both ranges and multiranges, as long
+# as PostgreSQL supports the operation. The following methods are also
+# supported:
+#
+#   r.range_merge      # range_merge(range)
+#   r.unnest           # unnest(range)
+#   r.multirange       # multirange(range)
+#
+# +range_merge+ and +unnest+ expect the receiver to represent a multirange
+# value, while +multi_range+ expects the receiver to represent a range value.
 #   
-# See the PostgreSQL range function and operator documentation for more
+# See the PostgreSQL range and multirange function and operator documentation for more
 # details on what these functions and operators do.
 #
-# If you are also using the pg_range extension, you should load it before
-# loading this extension.  Doing so will allow you to use PGArray#op to get
-# an RangeOp, allowing you to perform range operations on range literals.
+# If you are also using the pg_range or pg_multirange extension, you should
+# load them before loading this extension.  Doing so will allow you to use
+# PGRange#op and PGMultiRange#op to get a RangeOp, allowing you to perform
+# range operations on range literals.
 #
 # Related module: Sequel::Postgres::RangeOp
 
@@ -75,13 +88,15 @@ module Sequel
         :starts_after => ["(".freeze, " &> ".freeze, ")".freeze].freeze,
         :adjacent_to => ["(".freeze, " -|- ".freeze, ")".freeze].freeze,
         :overlaps => ["(".freeze, " && ".freeze, ")".freeze].freeze,
-      }
-      FUNCTIONS = %w'lower upper isempty lower_inc upper_inc lower_inf upper_inf'
+      }.freeze
 
-      FUNCTIONS.each do |f|
+      %w'lower upper isempty lower_inc upper_inc lower_inf upper_inf unnest'.each do |f|
         class_eval("def #{f}; function(:#{f}) end", __FILE__, __LINE__)
       end
-      OPERATORS.keys.each do |f|
+      %w'range_merge multirange'.each do |f|
+        class_eval("def #{f}; RangeOp.new(function(:#{f})) end", __FILE__, __LINE__)
+      end
+      OPERATORS.each_key do |f|
         class_eval("def #{f}(v); operator(:#{f}, v) end", __FILE__, __LINE__)
       end
 
@@ -117,7 +132,9 @@ module Sequel
       end
     end
 
+    # :nocov:
     if defined?(PGRange)
+    # :nocov:
       class PGRange
         # Wrap the PGRange instance in an RangeOp, allowing you to easily use
         # the PostgreSQL range functions and operators with literal ranges.
@@ -126,6 +143,18 @@ module Sequel
         end
       end
     end
+
+    # :nocov:
+    if defined?(PGMultiRange)
+    # :nocov:
+      class PGMultiRange
+        # Wrap the PGRange instance in an RangeOp, allowing you to easily use
+        # the PostgreSQL range functions and operators with literal ranges.
+        def op
+          RangeOp.new(self)
+        end
+      end
+    end
   end
 
   module SQL::Builders
@@ -159,7 +188,7 @@ end
 if defined?(Sequel::CoreRefinements)
   module Sequel::CoreRefinements
     refine Symbol do
-      include Sequel::Postgres::RangeOpMethods
+      send INCLUDE_METH, Sequel::Postgres::RangeOpMethods
     end
   end
 end