sequel 4.36.0 → 5.61.0

data/lib/sequel/extensions/pg_hstore.rb

@@ -30,7 +30,7 @@
 # Since the hstore type only supports strings, non string keys and
 # values are converted to strings
 #
-#   Sequel.hstore(:foo=>1).to_hash # {'foo'=>'1'}
+#   Sequel.hstore(foo: 1).to_hash # {'foo'=>'1'}
 #   v = Sequel.hstore({})
 #   v[:foo] = 1
 #   v # {'foo'=>'1'}
@@ -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
@@ -68,15 +68,18 @@
 #
 # If you want to insert a hash into an hstore database column:
 #
-#   DB[:table].insert(:column=>Sequel.hstore('foo'=>'bar'))
+#   DB[:table].insert(column: Sequel.hstore('foo'=>'bar'))
 #
-# 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
 #
+# This extension integrates with the pg_array extension.  If you plan
+# to use arrays of hstore types, load the pg_array extension before the
+# pg_hstore extension:
+#
+#   DB.extension :pg_array, :pg_hstore
+#
 # See the {schema modification guide}[rdoc-ref:doc/schema_modification.rdoc]
 # for details on using hstore columns in CREATE/ALTER TABLE statements.
 #
@@ -94,14 +97,6 @@ module Sequel
 
       # Parser for PostgreSQL hstore output format.
       class Parser < StringScanner
-        QUOTE_RE = /"/.freeze
-        KV_SEP_RE = /"\s*=>\s*/.freeze
-        NULL_RE = /NULL/.freeze
-        SEP_RE = /,\s*/.freeze
-        QUOTED_RE = /(\\"|[^"])*/.freeze
-        REPLACE_RE = /\\(.)/.freeze
-        REPLACE_WITH = '\1'.freeze
-
         # Parse the output format that PostgreSQL uses for hstore
         # columns.  Note that this does not attempt to parse all
         # input formats that PostgreSQL will accept.  For instance,
@@ -114,17 +109,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,14 +129,14 @@ 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
 
       module DatabaseMethods
         def self.extended(db)
-          db.instance_eval do
-            add_named_conversion_proc(:hstore)
+          db.instance_exec do
+            add_named_conversion_proc(:hstore, &HStore.method(:parse))
             @schema_type_classes[:hstore] = HStore
           end
         end
@@ -165,6 +160,16 @@ module Sequel
           db_type == 'hstore' ? :hstore : super
         end
 
+        # Set the :callable_default value if the default value is recognized as an empty hstore.
+        def schema_post_process(_)
+          super.each do |a|
+            h = a[1]
+            if h[:type] == :hstore && h[:default] =~ /\A''::hstore\z/
+              h[:callable_default] = lambda{HStore.new({})}
+            end
+          end
+        end
+
         # Typecast value correctly to HStore.  If already an
         # HStore instance, return as is.  If a hash, return
         # an HStore version of it.  If a string, assume it is
@@ -187,22 +192,12 @@ module Sequel
       # keys to strings during lookup.
       DEFAULT_PROC = lambda{|h, k| h[k.to_s] unless k.is_a?(String)}
 
-      QUOTE = '"'.freeze
-      COMMA = ",".freeze
-      KV_SEP = "=>".freeze
-      NULL = "NULL".freeze
-      ESCAPE_RE = /("|\\)/.freeze
-      ESCAPE_REPLACE = '\\\\\1'.freeze
-      HSTORE_CAST = '::hstore'.freeze
-
-      if RUBY_VERSION >= '1.9'
-        # Undef 1.9 marshal_{dump,load} methods in the delegate class,
-        # so that ruby 1.9 uses the old style _dump/_load methods defined
-        # in the delegate class, instead of the marshal_{dump,load} methods
-        # in the Hash class.
-        undef_method :marshal_load
-        undef_method :marshal_dump
-      end
+      # Undef marshal_{dump,load} methods in the delegate class,
+      # so that ruby uses the old style _dump/_load methods defined
+      # in the delegate class, instead of the marshal_{dump,load} methods
+      # in the Hash class.
+      undef_method :marshal_load
+      undef_method :marshal_dump
 
       # Use custom marshal loading, since underlying hash uses a default proc.
       def self._load(args)
@@ -216,12 +211,12 @@ module Sequel
       end
 
       # Override methods that accept key argument to convert to string.
-      (%w'[] delete has_key? include? key? member?' + Array((%w'assoc' if RUBY_VERSION >= '1.9.0'))).each do |m|
+      %w'[] delete has_key? include? key? member? assoc'.each do |m|
         class_eval("def #{m}(k) super(k.to_s) end", __FILE__, __LINE__)
       end
 
       # Override methods that accept value argument to convert to string unless nil.
-      (%w'has_value? value?' + Array((%w'key rassoc' if RUBY_VERSION >= '1.9.0'))).each do |m|
+      %w'has_value? value? key rassoc'.each do |m|
         class_eval("def #{m}(v) super(convert_value(v)) end", __FILE__, __LINE__)
       end
 
@@ -258,7 +253,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 +262,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,13 +298,9 @@ 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
-
-    PG_NAMED_TYPES = {} unless defined?(PG_NAMED_TYPES)
-    # Associate the named types by default.
-    PG_NAMED_TYPES[:hstore] = HStore.method(:parse)
   end
 
   module SQL::Builders

data/lib/sequel/extensions/pg_hstore_ops.rb

@@ -20,7 +20,7 @@
 # Also, on most Sequel expression objects, you can call the hstore 
 # method:
 #
-#   h = Sequel.expr(:hstore_column).hstore
+#   h = Sequel[:hstore_column].hstore
 #
 # If you have loaded the {core_extensions extension}[rdoc-ref:doc/core_extensions.rdoc],
 # or you have loaded the core_refinements extension
@@ -57,11 +57,24 @@
 # Here are a couple examples for updating an existing hstore column:
 #
 #   # Add a key, or update an existing key with a new value
-#   DB[:tab].update(:h=>Sequel.hstore_op(:h).concat('c'=>3))
+#   DB[:tab].update(h: Sequel.hstore_op(:h).concat('c'=>3))
 # 
 #   # Delete a key
-#   DB[:tab].update(:h=>Sequel.hstore_op(:h).delete('k1'))
+#   DB[:tab].update(h: Sequel.hstore_op(:h).delete('k1'))
 #  
+# On PostgreSQL 14+, The hstore <tt>[]</tt> method will use subscripts instead of being
+# the same as +get+, if the value being wrapped is an identifer:
+#
+#   Sequel.hstore_op(:hstore_column)['a']    # hstore_column['a']
+#   Sequel.hstore_op(Sequel[:h][:s])['a']      # h.s['a']
+#
+# This support allows you to use hstore subscripts in UPDATE statements to update only
+# part of a column:
+#
+#   h = Sequel.hstore_op(:h)
+#   DB[:t].update(h['key1'] => 'val1', h['key2'] => 'val2')
+#   #  UPDATE "t" SET "h"['key1'] = 'val1', "h"['key2'] = 'val2'
+#
 # See the PostgreSQL hstore function and operator documentation for more
 # details on what these functions and operators do.
 #
@@ -114,10 +127,15 @@ module Sequel
       #
       #   hstore_op['a'] # (hstore -> 'a')
       def [](key)
-        v = Sequel::SQL::PlaceholderLiteralString.new(LOOKUP, [value, wrap_input_array(key)])
         if key.is_a?(Array) || (defined?(Sequel::Postgres::PGArray) && key.is_a?(Sequel::Postgres::PGArray)) || (defined?(Sequel::Postgres::ArrayOp) && key.is_a?(Sequel::Postgres::ArrayOp))
-          wrap_output_array(v)
+          wrap_output_array(Sequel::SQL::PlaceholderLiteralString.new(LOOKUP, [value, wrap_input_array(key)]))
         else
+          v = case @value
+          when Symbol, SQL::Identifier, SQL::QualifiedIdentifier
+            HStoreSubscriptOp.new(self, key)
+          else
+            Sequel::SQL::PlaceholderLiteralString.new(LOOKUP, [value, key])
+          end
           Sequel::SQL::StringExpression.new(:NOOP, v)
         end
       end
@@ -304,6 +322,38 @@ module Sequel
       end
     end
 
+    # Represents hstore subscripts. This is abstracted because the
+    # subscript support depends on the database version.
+    class HStoreSubscriptOp < SQL::Expression
+      SUBSCRIPT = ["".freeze, "[".freeze, "]".freeze].freeze
+
+      # The expression being subscripted
+      attr_reader :expression
+
+      # The subscript to use
+      attr_reader :sub
+
+      # Set the expression and subscript to the given arguments
+      def initialize(expression, sub)
+        @expression = expression
+        @sub = sub
+        freeze
+      end
+
+      # Use subscripts instead of -> operator on PostgreSQL 14+
+      def to_s_append(ds, sql)
+        server_version = ds.db.server_version
+        frag = server_version && server_version >= 140000 ? SUBSCRIPT : HStoreOp::LOOKUP
+        ds.literal_append(sql, Sequel::SQL::PlaceholderLiteralString.new(frag, [@expression, @sub]))
+      end
+
+      # Support transforming of hstore subscripts
+      def sequel_ast_transform(transformer)
+        self.class.new(transformer.call(@expression), transformer.call(@sub))
+      end
+    end
+
+
     module HStoreOpMethods
       # Wrap the receiver in an HStoreOp so you can easily use the PostgreSQL
       # hstore functions and operators with it.
@@ -312,7 +362,9 @@ module Sequel
       end
     end
 
+    # :nocov:
     if defined?(HStore)
+    # :nocov:
       class HStore
         # Wrap the receiver in an HStoreOp so you can easily use the PostgreSQL
         # hstore functions and operators with it.
@@ -354,7 +406,7 @@ end
 if defined?(Sequel::CoreRefinements)
   module Sequel::CoreRefinements
     refine Symbol do
-      include Sequel::Postgres::HStoreOpMethods
+      send INCLUDE_METH, Sequel::Postgres::HStoreOpMethods
     end
   end
 end

data/lib/sequel/extensions/pg_inet.rb

@@ -5,7 +5,7 @@
 #
 # This extension integrates with Sequel's native postgres and jdbc/postgresql
 # adapters, so that when inet/cidr fields are retrieved, they are returned as
-# IPAddr instances
+# IPAddr instances.
 #
 # To use this extension, load it into your database:
 #
@@ -29,7 +29,6 @@
 # Related module: Sequel::Postgres::InetDatabaseMethods
 
 require 'ipaddr'
-Sequel.require 'adapters/utils/pg_types'
 
 module Sequel
   module Postgres
@@ -39,9 +38,26 @@ module Sequel
       # it will pick up the inet/cidr converter.  Also, extend the datasets
       # with support for literalizing the IPAddr types.
       def self.extended(db)
-        db.instance_eval do
+        db.instance_exec do
           extend_datasets(InetDatasetMethods)
-          copy_conversion_procs([869, 650, 1041, 651, 1040])
+
+          # :nocov:
+          if !defined?(SEQUEL_PG_VERSION_INTEGER) || SEQUEL_PG_VERSION_INTEGER >= 11300
+          # :nocov:
+            # sequel_pg 1.13.0+ will use inet/cidr conversion procs, but doing so is
+            # slower, so don't add the conversion procs if using sequel_pg 1.13.0+.
+            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)
+            end
+          end
+
+          if respond_to?(:register_array_type)
+            register_array_type('macaddr', :oid=>1040, :scalar_oid=>829)
+          end
           @schema_type_classes[:ipaddr] = IPAddr
         end
       end
@@ -79,13 +95,23 @@ module Sequel
         end
       end
 
+      # Set the :ruby_default value if the default value is recognized as an ip address.
+      def schema_post_process(_)
+        super.each do |a|
+          h = a[1]
+          if h[:type] == :ipaddr && h[:default] =~ /\A'([:a-fA-F0-9\.\/]+)'::(?:inet|cidr)\z/
+            h[:ruby_default] = IPAddr.new($1)
+          end
+        end
+      end
+
       # Typecast the given value to an IPAddr object.
       def typecast_value_ipaddr(value)
         case value
         when IPAddr
           value
         when String
-          IPAddr.new(value)
+          IPAddr.new(typecast_check_string_length(value, 100))
         else
           raise Sequel::InvalidValue, "invalid value for inet/cidr: #{value.inspect}"
         end
@@ -105,13 +131,6 @@ module Sequel
         end
       end
     end
-
-    PG_TYPES[869] = PG_TYPES[650] = IPAddr.method(:new)
-    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)
-    end
   end
 
   Database.register_extension(:pg_inet, Postgres::InetDatabaseMethods)

data/lib/sequel/extensions/pg_inet_ops.rb

@@ -14,7 +14,7 @@
 # Also, on most Sequel expression objects, you can call the pg_inet
 # method:
 #
-#   r = Sequel.expr(:ip).pg_inet
+#   r = Sequel[:ip].pg_inet
 #
 # If you have loaded the {core_extensions extension}[rdoc-ref:doc/core_extensions.rdoc],
 # or you have loaded the core_refinements extension
@@ -197,7 +197,7 @@ end
 if defined?(Sequel::CoreRefinements)
   module Sequel::CoreRefinements
     refine Symbol do
-      include Sequel::Postgres::InetOpMethods
+      send INCLUDE_METH, Sequel::Postgres::InetOpMethods
     end
   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
 #
@@ -35,14 +32,20 @@
 #
 # Related module: Sequel::Postgres::IntervalDatabaseMethods
 
+require 'active_support'
 require 'active_support/duration'
-Sequel.require 'adapters/utils/pg_types'
+
+# :nocov:
+begin
+  require 'active_support/version'
+rescue LoadError
+end
+# :nocov:
 
 module Sequel
   module Postgres
     module IntervalDatabaseMethods
-      EMPTY_INTERVAL = '0'.freeze
-      DURATION_UNITS = [:years, :months, :days, :minutes, :seconds].freeze
+      DURATION_UNITS = [:years, :months, :weeks, :days, :hours, :minutes, :seconds].freeze
 
       # Return an unquoted string version of the duration object suitable for
       # use as a bound variable.
@@ -58,7 +61,7 @@ module Sequel
         end
 
         if s.empty?
-          EMPTY_INTERVAL
+          '0'
         else
           s
         end
@@ -66,37 +69,47 @@ 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
+        # Whether ActiveSupport::Duration.new takes parts as array instead of hash
+        USE_PARTS_ARRAY = !defined?(ActiveSupport::VERSION::STRING) || ActiveSupport::VERSION::STRING < '5.1'
+
+        if defined?(ActiveSupport::Duration::SECONDS_PER_MONTH)
+          SECONDS_PER_MONTH = ActiveSupport::Duration::SECONDS_PER_MONTH
+          SECONDS_PER_YEAR = ActiveSupport::Duration::SECONDS_PER_YEAR
+        # :nocov:
+        else
+          SECONDS_PER_MONTH = 2592000
+          SECONDS_PER_YEAR = 31557600
+        # :nocov:
+        end
 
         # 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 = []
+          parts = {}
 
           if v = matches[1]
             v = v.to_i
-            value += 31557600 * v
-            parts << [:years, v]
+            value += SECONDS_PER_YEAR * v
+            parts[:years] = v
           end
           if v = matches[2]
             v = v.to_i
-            value += 2592000 * v
-            parts << [:months, v]
+            value += SECONDS_PER_MONTH * v
+            parts[:months] = v
           end
           if v = matches[3]
             v = v.to_i
             value += 86400 * v
-            parts << [:days, v]
+            parts[:days] = v
           end
           if matches[5]
             seconds = matches[5].to_i * 3600 + matches[6].to_i * 60
             seconds += matches[8] ? matches[7].to_f : matches[7].to_i
             seconds *= -1 if matches[4] == '-'
             value += seconds
-            parts << [:seconds, seconds]
+            parts[:seconds] = seconds
           elsif matches[9] || matches[10] || matches[11]
             seconds = 0
             if v = matches[9]
@@ -109,8 +122,14 @@ module Sequel
               seconds += matches[12] ? v.to_f : v.to_i
             end
             value += seconds
-            parts << [:seconds, seconds]
+            parts[:seconds] = seconds
+          end
+
+          # :nocov:
+          if USE_PARTS_ARRAY
+            parts = parts.to_a
           end
+          # :nocov:
 
           ActiveSupport::Duration.new(value, parts)
         end
@@ -122,9 +141,12 @@ module Sequel
       # Reset the conversion procs if using the native postgres adapter,
       # and extend the datasets to correctly literalize ActiveSupport::Duration values.
       def self.extended(db)
-        db.instance_eval do
+        db.instance_exec 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
@@ -151,6 +173,16 @@ module Sequel
         end
       end
 
+      # Set the :ruby_default value if the default value is recognized as an interval.
+      def schema_post_process(_)
+        super.each do |a|
+          h = a[1]
+          if h[:type] == :interval && h[:default] =~ /\A'([\w ]+)'::interval\z/
+            h[:ruby_default] = PARSER.call($1)
+          end
+        end
+      end
+
       # Typecast value correctly to an ActiveSupport::Duration instance.
       # If already an ActiveSupport::Duration, return it. 
       # If a numeric argument is given, assume it represents a number
@@ -165,7 +197,7 @@ module Sequel
         when Numeric
           ActiveSupport::Duration.new(value, [[:seconds, value]])
         when String
-          PARSER.call(value)
+          PARSER.call(typecast_check_string_length(value, 1000))
         else
           raise Sequel::InvalidValue, "invalid value for interval type: #{value.inspect}"
         end
@@ -173,7 +205,7 @@ module Sequel
     end
 
     module IntervalDatasetMethods
-      CAST_INTERVAL = '::interval'.freeze
+      private
 
       # Handle literalization of ActiveSupport::Duration objects, treating them as
       # PostgreSQL intervals.
@@ -181,17 +213,12 @@ 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
-    if defined?(PGArray) && PGArray.respond_to?(:register)
-      PGArray.register('interval', :oid=>1187, :scalar_oid=>1186)
-    end
   end
 
   Database.register_extension(:pg_interval, Postgres::IntervalDatabaseMethods)