sequel 4.26.0 → 5.37.0

data/lib/sequel/extensions/pg_hstore.rb

@@ -1,3 +1,5 @@
+# frozen-string-literal: true
+#
 # The pg_hstore extension adds support for the PostgreSQL hstore type
 # to Sequel.  hstore is an extension that ships with PostgreSQL, and
 # the hstore type stores an arbitrary key-value table, where the keys
@@ -28,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'}
@@ -47,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
@@ -66,23 +68,24 @@
 #
 # 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_interval 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.
 #
-# If you are not using the native postgres or jdbc/postgresql adapters and are using hstore
-# types as model column values you probably should use the
-# pg_typecast_on_load plugin if the column values are returned as a string.
-#
 # This extension requires the delegate and strscan libraries.
+#
+# Related module: Sequel::Postgres::HStore
 
 require 'delegate'
 require 'strscan'
@@ -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,19 +253,19 @@ 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
       # literal version of the hstore.  Separated out for use by
       # the bound argument code.
       def unquoted_literal
-        str = ''
+        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

@@ -1,3 +1,5 @@
+# frozen-string-literal: true
+#
 # The pg_hstore_ops extension adds support to Sequel's DSL to make
 # it easier to call PostgreSQL hstore functions and operators.
 #
@@ -18,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
@@ -55,10 +57,10 @@
 # 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'))
 #  
 # See the PostgreSQL hstore function and operator documentation for more
 # details on what these functions and operators do.
@@ -73,6 +75,8 @@
 # pg_hstore extension is loaded.  Methods representing expressions that return
 # PostgreSQL arrays will have the returned expression automatically wrapped in a
 # Postgres::ArrayOp if the pg_array_ops extension is loaded.
+#
+# Related module: Sequel::Postgres::HStoreOp
 
 #
 module Sequel
@@ -308,7 +312,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.

data/lib/sequel/extensions/pg_inet.rb

@@ -1,18 +1,16 @@
+# frozen-string-literal: true
+#
 # The pg_inet extension adds support for Sequel to handle
 # PostgreSQL's inet and cidr types using ruby's IPAddr class.
 #
 # 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:
 #
 #   DB.extension :pg_inet
 #
-# If you are not using the native postgres or jdbc/postgresql adapters and are using inet/cidr
-# types as model column values you probably should use the
-# pg_typecast_on_load plugin if the column values are returned as a string.
-#
 # This extension integrates with the pg_array extension.  If you plan
 # to use the inet[] or cidr[] types, load the pg_array extension before
 # the pg_inet extension:
@@ -27,9 +25,10 @@
 #
 # See the {schema modification guide}[rdoc-ref:doc/schema_modification.rdoc]
 # for details on using inet/cidr columns in CREATE/ALTER TABLE statements.
+#
+# 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,6 +95,16 @@ 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
@@ -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

@@ -1,3 +1,5 @@
+# frozen-string-literal: true
+#
 # The pg_inet_ops extension adds support to Sequel's DSL to make
 # it easier to call PostgreSQL inet functions and operators.
 #
@@ -12,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
@@ -54,6 +56,8 @@
 #
 # See the PostgreSQL network function and operator documentation for more
 # details on what these functions and operators do.
+#
+# Related module: Sequel::Postgres::InetOp
 
 require 'ipaddr'
 

data/lib/sequel/extensions/pg_interval.rb

@@ -1,3 +1,5 @@
+# frozen-string-literal: true
+#
 # The pg_interval extension adds support for PostgreSQL's interval type.
 #
 # This extension integrates with Sequel's native postgres and jdbc/postgresql
@@ -8,17 +10,10 @@
 # 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
 #
-# If you are not using the native postgres or jdbc/postgresql adapters and are using interval
-# types as model column values you probably should use the
-# pg_typecast_on_load plugin if the column values are returned as a string.
-#
 # This extension integrates with the pg_array extension.  If you plan
 # to use arrays of interval types, load the pg_array extension before the
 # pg_interval extension:
@@ -34,22 +29,22 @@
 #
 # See the {schema modification guide}[rdoc-ref:doc/schema_modification.rdoc]
 # for details on using interval columns in CREATE/ALTER TABLE statements.
+#
+# Related module: Sequel::Postgres::IntervalDatabaseMethods
 
 require 'active_support/duration'
-Sequel.require 'adapters/utils/pg_types'
 
 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.
       def self.literal_duration(duration)
         h = Hash.new(0)
         duration.parts.each{|unit, value| h[unit] += value}
-        s = ''
+        s = String.new
 
         DURATION_UNITS.each do |unit|
           if (v = h[unit]) != 0
@@ -58,7 +53,7 @@ module Sequel
         end
 
         if s.empty?
-          EMPTY_INTERVAL
+          '0'
         else
           s
         end
@@ -66,12 +61,9 @@ 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
-
         # 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 = []
@@ -122,9 +114,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 +146,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
@@ -173,7 +178,7 @@ module Sequel
     end
 
     module IntervalDatasetMethods
-      CAST_INTERVAL = '::interval'.freeze
+      private
 
       # Handle literalization of ActiveSupport::Duration objects, treating them as
       # PostgreSQL intervals.
@@ -181,17 +186,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)