sequel 4.46.0 → 4.49.0

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
 

data/lib/sequel/extensions/pg_range_ops.rb

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