sequel 5.4.0 → 5.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 31c759888ccdeebe39b3d3bd9e953c74d8584bade28bdc1bc2d6e38545c8896d
-  data.tar.gz: dbf22a0e145192f4a50ea421a4e93a8b182472c5430d06061d710f218bd61d24
+  metadata.gz: 34e1f1ee3e3e1b863d4efbc3710cae912ae394a655b6e9fed41325f02d54f23e
+  data.tar.gz: af6f231e63231de19bb7956ea16cff29ec2faebe379a0ba86e12df933af0b91b
 SHA512:
-  metadata.gz: 764c3d3d8856d8be93d5ee7492e331b1a56caeef4a2ad2d8a53a6c781e34650007f44a1ea0d3cb97b03ebf633842da3c67846edcfe0a0a9c7f788e15123403a9
-  data.tar.gz: f0f32cc6e140e46a7cf91f78ace601a0c5bf7c77b87f2fcbfd236fca04090e2bc97e89f579206bb10b9bce84a340215aafe029c9923aec816f33f60aa54da80d
+  metadata.gz: d2f482f59fe3bb9eb19d2fa88a6fccfdf5e259cb23a52e2d21c3bb692f4f3a04339c2011922a03ceb4593b4a2708fbafdd45dbde2a882f7f77d20a3e2048e000
+  data.tar.gz: 19e9f635bcdb299673ab5d042159f7e76dbdee1807fd02b8e897c434e6ad11214113ac252064106507620ae3e9a19d3facb49d181ab28cc08e47c5a5b2ebfa65

data/CHANGELOG

@@ -1,3 +1,29 @@
+=== 5.5.0 (2018-01-31)
+
+* Make Database#copy_table in the postgres adapter handle errors that occur while processing rows (jeremyevans) (#1470)
+
+* Cache results of changed_columns method in local variables in many places for better performance (jeremyevans)
+
+* Make modification_detection plugin not break column change detection for new objects (jeremyevans) (#1468)
+
+* Make pg_range extension set :ruby_default schema value for recognized range defaults (jeremyevans)
+
+* Make pg_interval extension set :ruby_default schema value for recognized interval defaults (jeremyevans)
+
+* Make pg_json extension set :callable_default schema value for empty json/jsonb array/hash defaults (jeremyevans)
+
+* Make pg_inet extension set :ruby_default schema value for recognized inet/cidr defaults (jeremyevans)
+
+* Make pg_hstore extension set :callable_default schema value for empty hstore defaults (jeremyevans)
+
+* Make pg_array extension set :callable_default schema value for recognized empty array defaults (jeremyevans) (#1466)
+
+* Make defaults_setter plugin prefer :callable_default db_schema values over :ruby_default db_schema values (jeremyevans)
+
+* Add defaults_setter plugin :cache option for caching default values returned (jeremyevans)
+
+* Freeze string values in hashes returned by Database#schema (jeremyevans)
+
 === 5.4.0 (2018-01-04)
 
 * Enable fractional seconds in timestamps on DB2 (jeremyevans) (#1463)

data/MIT-LICENSE

@@ -1,5 +1,5 @@
 Copyright (c) 2007-2008 Sharon Rosner
-Copyright (c) 2008-2017 Jeremy Evans
+Copyright (c) 2008-2018 Jeremy Evans
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to

data/README.rdoc

@@ -124,7 +124,7 @@ You can also specify optional parameters, such as the connection pool size, or l
 It is also possible to use a hash instead of a connection URL, but make sure to include the :adapter option in this case:
 
   DB = Sequel.connect(adapter: :postgres, user: 'user', password: 'password', host: 'host', port: port,
-    database: 'database_name", max_connections: 10, logger: Logger.new('log/db.log'))
+    database: 'database_name', max_connections: 10, logger: Logger.new('log/db.log'))
 
 You can specify a block to connect, which will disconnect from the database after it completes:
 

data/doc/release_notes/5.5.0.txt

@@ -0,0 +1,61 @@
+= New Features
+
+* The defaults_setter plugin now supports a :cache option, which
+  will cache default values in the model object's values hash:
+
+    Model.plugin :defaults_setter
+    o = Model.new
+    o.column # => 1 # default value
+    o.values # => {}
+
+    Model.plugin :defaults_setter, cache: true
+    o = Model.new
+    o.column # => 1 # default value
+    o.values # => {:column => 1}
+
+* The pg_array extension now sets a :callable_default schema entry
+  for recognized empty array defaults.
+
+* The pg_hstore extension now sets a :callable_default schema entry
+  for recognized empty hstore defaults.
+
+* The pg_json extension now sets a :callable_default schema entry for
+  recognized empty json/jsonb array/hash defaults. 
+
+* The pg_inet extension now sets a :ruby_default schema entry for
+  recognized inet/cidr defaults.
+
+* The pg_range extension now sets a :ruby_default schema entry for
+  recognized range defaults.
+
+* The defaults_setter plugin will now give preference to a
+  :callable_default schema entry over a :ruby_default schema entry.
+  Combined with the other changes listed above, this makes default
+  values recognized by the pg_array, pg_hstore, and pg_json extensions
+  work well if the defaults_setter :cache option is also used.
+
+= Other Improvements
+
+* The modification_detection plugin no longer breaks column change
+  detection for new objects.
+
+* Database#copy_table in the postgres adapter now handles errors that
+  occur when processing rows.  Previously, an exception could be
+  raised on the next query in that case.
+
+* The results of the changed_columns method are now cached in many
+  places internally where they are called in a loop.  This results
+  in better performance, especially if the modification_detection or
+  serialization_modification_detection plugins are used.
+
+= Backwards Compatibility
+
+* The pg_interval extension now sets a :ruby_default schema entry for
+  recognized interval defaults to the same value Sequel would return
+  if the default value was returned.  Previously, Sequel would use a
+  string in the :ruby_schema schema value.
+
+* String values in hashes returned by Database#schema are now frozen
+  to prevent possible thread-safety issues and issues with
+  unintentional modification of a shared string.  The hashes
+  themselves are not frozen and can still be modified.

data/lib/sequel/adapters/postgres.rb

@@ -309,12 +309,18 @@ module Sequel
                 while buf = conn.get_copy_data
                   yield buf
                 end
-                nil
+                b = nil
               else
                 b = String.new
                 b << buf while buf = conn.get_copy_data
-                b
               end
+
+              res = conn.get_last_result
+              if !res || res.result_status != 1
+                raise PG::NotAllCopyDataRetrieved, "Not all COPY data retrieved"
+              end
+
+              b
             rescue => e
               raise_error(e, :disconnect=>true)
             ensure

data/lib/sequel/database/query.rb

@@ -175,6 +175,10 @@ module Sequel
         if !c[:max_length] && c[:type] == :string && (max_length = column_schema_max_length(c[:db_type]))
           c[:max_length] = max_length
         end
+
+        c.each_value do |v|
+          v.freeze if v.is_a?(String)
+        end
       end
       Sequel.synchronize{@schemas[quoted_name] = cols} if cache_schema
       cols

data/lib/sequel/extensions/pg_array.rb

@@ -253,6 +253,17 @@ module Sequel
           end
         end
 
+        # Set the :callable_default value if the default value is recognized as an empty array.
+        def schema_parse_table(*)
+          super.each do |a|
+            h = a[1]
+            if h[:default] =~ /\A(?:'\{\}'|ARRAY\[\])::([\w ]+)\[\]\z/
+              type = $1.freeze
+              h[:callable_default] = lambda{Sequel.pg_array([], type)}
+            end
+          end
+        end
+
         # Convert ruby arrays to PostgreSQL arrays when used as default values.
         def column_definition_default_sql(sql, column)
           if (d = column[:default]) && d.is_a?(Array) && !Sequel.condition_specifier?(d)

data/lib/sequel/extensions/pg_hstore.rb

@@ -154,6 +154,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_parse_table(*)
+          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

data/lib/sequel/extensions/pg_inet.rb

@@ -85,6 +85,16 @@ module Sequel
         end
       end
 
+      # Set the :ruby_default value if the default value is recognized as an ip address.
+      def schema_parse_table(*)
+        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

data/lib/sequel/extensions/pg_interval.rb

@@ -146,6 +146,16 @@ module Sequel
         end
       end
 
+      # Set the :ruby_default value if the default value is recognized as an interval.
+      def schema_parse_table(*)
+        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

data/lib/sequel/extensions/pg_json.rb

@@ -214,6 +214,30 @@ module Sequel
         end
       end
 
+      # Set the :callable_default value if the default value is recognized as an empty json/jsonb array/hash.
+      def schema_parse_table(*)
+        super.each do |a|
+          h = a[1]
+          if (h[:type] == :json || h[:type] == :jsonb) && h[:default] =~ /\A'(\{\}|\[\])'::jsonb?\z/
+            is_array = $1 == '[]'
+
+            klass = if h[:type] == :json
+              if is_array
+                JSONArray
+              else
+                JSONHash
+              end
+            elsif is_array
+              JSONBArray
+            else
+              JSONBHash
+            end
+
+            h[:callable_default] = lambda{klass.new(is_array ? [] : {})}
+          end
+        end
+      end
+
       # Convert the value given to a JSONArray or JSONHash
       def typecast_value_json(value)
         case value

data/lib/sequel/extensions/pg_range.rb

@@ -262,6 +262,20 @@ module Sequel
           end
         end
 
+        # Set the :ruby_default value if the default value is recognized as a range.
+        def schema_parse_table(*)
+          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($1)
+              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

data/lib/sequel/model/base.rb

@@ -1060,7 +1060,7 @@ module Sequel
         @new = true
         @modified = true
         initialize_set(values)
-        changed_columns.clear 
+        _changed_columns.clear
         yield self if block_given?
       end
 
@@ -1137,9 +1137,9 @@ module Sequel
       #   a.name = 'Bob'
       #   a.changed_columns # => [:name]
       def changed_columns
-        @changed_columns ||= []
+        _changed_columns
       end
-  
+
       # Deletes and returns +self+.  Does not run destroy hooks.
       # Look into using +destroy+ instead.
       #
@@ -1212,7 +1212,7 @@ module Sequel
       # errors, or dataset.
       def freeze
         values.freeze
-        changed_columns.freeze
+        _changed_columns.freeze
         unless errors.frozen?
           validate
           errors.freeze
@@ -1316,9 +1316,7 @@ module Sequel
       #   a.modified!(:name)
       #   a.name.gsub!(/[aeou]/, 'i')
       def modified!(column=nil)
-        if column && !changed_columns.include?(column)
-          changed_columns << column
-        end
+        _add_changed_column(column) if column
         @modified = true
       end
 
@@ -1583,6 +1581,17 @@ module Sequel
 
       private
       
+      # Add a column as a changed column.
+      def _add_changed_column(column)
+        cc = _changed_columns
+        cc << column unless cc.include?(column)
+      end
+
+      # Internal changed_columns method that just returns stored array.
+      def _changed_columns
+        @changed_columns ||= []
+      end
+  
       # Do the deletion of the object's dataset, and check that the row
       # was actually deleted.
       def _delete
@@ -1672,7 +1681,7 @@ module Sequel
       # is used for reading newly inserted values from the database
       def _refresh(dataset)
         _refresh_set_values(_refresh_get(dataset) || raise(NoExistingObject, "Record not found"))
-        changed_columns.clear
+        _changed_columns.clear
       end
 
       # Get the row of column data from the database.
@@ -1710,7 +1719,7 @@ module Sequel
               @this = nil
               @new = false
               @modified = false
-              pk ? _save_refresh : changed_columns.clear
+              pk ? _save_refresh : _changed_columns.clear
               after_create
               true
             end
@@ -1721,16 +1730,18 @@ module Sequel
               before_update
               columns = opts[:columns]
               if columns.nil?
-                columns_updated = if opts[:changed]
-                  @values.reject{|k,v| !changed_columns.include?(k)}
+                if opts[:changed]
+                  cc = changed_columns
+                  columns_updated = @values.reject{|k,v| !cc.include?(k)}
+                  cc.clear
                 else
-                  _save_update_all_columns_hash
+                  columns_updated = _save_update_all_columns_hash
+                  _changed_columns.clear
                 end
-                changed_columns.clear
               else # update only the specified columns
                 columns = Array(columns)
                 columns_updated = @values.reject{|k, v| !columns.include?(k)}
-                changed_columns.reject!{|c| columns.include?(c)}
+                _changed_columns.reject!{|c| columns.include?(c)}
               end
               _update_columns(columns_updated)
               @this = nil
@@ -1752,7 +1763,7 @@ module Sequel
       # can be overridden to avoid the refresh.
       def _save_refresh
         _save_set_values(_refresh_get(this.server?(:default)) || raise(NoExistingObject, "Record not found"))
-        changed_columns.clear
+        _changed_columns.clear
       end
 
       # Set values to the provided hash.  Called after a create,
@@ -1769,7 +1780,8 @@ module Sequel
       # to their existing values.
       def _save_update_all_columns_hash
         v = Hash[@values]
-        Array(primary_key).each{|x| v.delete(x) unless changed_columns.include?(x)}
+        cc = changed_columns
+        Array(primary_key).each{|x| v.delete(x) unless cc.include?(x)}
         v
       end
 
@@ -1847,8 +1859,7 @@ module Sequel
 
       # Change the value of the column to given value, recording the change.
       def change_column_value(column, value)
-        cc = changed_columns
-        cc << column unless cc.include?(column)
+        _add_changed_column(column)
         @values[column] = value
       end
 

data/lib/sequel/plugins/defaults_setter.rb

@@ -23,6 +23,24 @@ module Sequel
     #
     #   Album.default_values[:a] = lambda{Date.today}
     #   Album.new.a # => Date.today
+    #
+    # By default, default values returned are not cached:
+    #
+    #   Album.new.a.equal?(Album.new.a) # => false
+    #
+    # However, you can turn on caching of default values:
+    #
+    #   Album.plugin :defaults_setter, cache: true
+    #   Album.new.a.equal?(Album.new.a) # => false
+    #
+    # Note that if the cache is turned on, the cached values are stored in
+    # the values hash:
+    #
+    #   Album.plugin :defaults_setter, cache: true
+    #   album = Album.new
+    #   album.values # => {}
+    #   album.a
+    #   album.values # => {:a => Date.today}
     # 
     # Usage:
     #
@@ -32,22 +50,31 @@ module Sequel
     #   # Make the Album class set defaults 
     #   Album.plugin :defaults_setter
     module DefaultsSetter
-      # Set the default values based on the model schema
-      def self.configure(model)
-        model.send(:set_default_values)
+      # Set the default values based on the model schema. Options:
+      # :cache :: Cache default values returned in the model's values hash.
+      def self.configure(model, opts=OPTS)
+        model.instance_exec do
+          set_default_values
+          @cache_default_values = opts[:cache] if opts.has_key?(:cache)
+        end
       end
 
       module ClassMethods
-        # The default values to set in initialize for this model.  A hash with column symbol
+        # The default values to use for this model.  A hash with column symbol
         # keys and default values.  If the default values respond to +call+, it will be called
         # to get the value, otherwise the value will be used directly.  You can manually modify
         # this hash to set specific default values, by default the ones will be parsed from the database.
         attr_reader :default_values
-        
+
         Plugins.after_set_dataset(self, :set_default_values)
 
-        Plugins.inherited_instance_variables(self, :@default_values=>:dup)
+        Plugins.inherited_instance_variables(self, :@default_values=>:dup, :@cache_default_values=>nil)
 
+        # Whether default values should be cached in the values hash after being retrieved.
+        def cache_default_values?
+          @cache_default_values
+        end
+        
         # Freeze default values when freezing model class
         def freeze
           @default_values.freeze
@@ -59,7 +86,15 @@ module Sequel
         # Parse the cached database schema for this model and set the default values appropriately.
         def set_default_values
           h = {}
-          @db_schema.each{|k, v| h[k] = convert_default_value(v[:ruby_default]) unless v[:ruby_default].nil?} if @db_schema
+          if @db_schema
+            @db_schema.each do |k, v|
+              if v[:callable_default]
+                h[k] = v[:callable_default]
+              elsif !v[:ruby_default].nil?
+                h[k] = convert_default_value(v[:ruby_default])
+              end
+            end
+          end
           @default_values = h.merge!(@default_values || {})
         end
 
@@ -82,7 +117,9 @@ module Sequel
         def [](k)
           if new? && !values.has_key?(k)
             v = model.default_values[k]
-            v.respond_to?(:call) ? v.call : v
+            v = v.call if v.respond_to?(:call)
+            values[k] = v if model.cache_default_values?
+            v
           else
             super
           end

data/lib/sequel/plugins/dirty.rb

@@ -137,7 +137,7 @@ module Sequel
         #   name.gsub(/i/i, 'o')
         #   column_change(:name) # => ['Initial', 'onotoal']
         def will_change_column(column)
-          changed_columns << column unless changed_columns.include?(column)
+          _add_changed_column(column)
           check_missing_initial_value(column)
 
           value = if initial_values.has_key?(column)
@@ -186,7 +186,7 @@ module Sequel
             initial = iv[column]
             super
             if value == initial
-              changed_columns.delete(column) unless missing_initial_values.include?(column)
+              _changed_columns.delete(column) unless missing_initial_values.include?(column)
               iv.delete(column)
             end
           else

data/lib/sequel/plugins/modification_detection.rb

@@ -58,13 +58,20 @@ module Sequel
         # Detect which columns have been modified by comparing the cached hash
         # value to the hash of the current value.
         def changed_columns
-          cc = super
-          changed = []
-          v = @values
+          changed = super
           if vh = @values_hashes
-            (vh.keys - cc).each{|c| changed << c unless v.has_key?(c) && vh[c] == v[c].hash}
+            values = @values
+            changed = changed.dup if frozen?
+            vh.each do |c, v|
+              match = values.has_key?(c) && v == values[c].hash
+              if changed.include?(c)
+                changed.delete(c) if match
+              else
+                changed << c unless match
+              end
+            end
           end
-          cc + changed
+          changed
         end
 
         private

data/lib/sequel/plugins/mssql_optimistic_locking.rb

@@ -75,7 +75,8 @@ module Sequel
         # it to be assigned.
         def _save_update_all_columns_hash
           v = @values.dup
-          Array(primary_key).each{|x| v.delete(x) unless changed_columns.include?(x)}
+          cc = changed_columns
+          Array(primary_key).each{|x| v.delete(x) unless cc.include?(x)}
           v.delete(model.lock_column)
           v
         end

data/lib/sequel/plugins/serialization.rb

@@ -155,8 +155,9 @@ module Sequel
                 end
               end
               define_method("#{column}=") do |v| 
-                if !changed_columns.include?(column) && (new? || get_column_value(column) != v)
-                  changed_columns << column
+                cc = changed_columns
+                if !cc.include?(column) && (new? || get_column_value(column) != v)
+                  cc << column
 
                   will_change_column(column) if respond_to?(:will_change_column)
                 end

data/lib/sequel/plugins/typecast_on_load.rb

@@ -63,7 +63,7 @@ module Sequel
               set_column_value("#{c}=", v)
             end
           end
-          changed_columns.clear
+          _changed_columns.clear
           self
         end
 

data/lib/sequel/plugins/validation_helpers.rb

@@ -252,7 +252,8 @@ module Sequel
           atts.each do |a|
             arr = Array(a)
             next if arr.any?{|x| errors.on(x)}
-            next if opts.fetch(:only_if_modified, true) && !new? && !arr.any?{|x| changed_columns.include?(x)}
+            cc = changed_columns
+            next if opts.fetch(:only_if_modified, true) && !new? && !arr.any?{|x| cc.include?(x)}
             ds = opts[:dataset] || model.dataset
             ds = if where
               where.call(ds, self, arr)

data/lib/sequel/version.rb

@@ -5,7 +5,7 @@ module Sequel
   MAJOR = 5
   # The minor version of Sequel.  Bumped for every non-patch level
   # release, generally around once a month.
-  MINOR = 4
+  MINOR = 5
   # The tiny version of Sequel.  Usually 0, only bumped for bugfix
   # releases that fix regressions from previous versions.
   TINY  = 0

data/spec/adapters/postgres_spec.rb

@@ -523,11 +523,6 @@ describe "A PostgreSQL dataset" do
     @db[:atest].get(Sequel.extract(:year, :t)).must_equal 2010
   end
 
-  it "should be able to parse the default value for an interval type" do
-    @db.create_table!(:atest){interval :t, :default=>'1 week'}
-    @db.schema(:atest).first.last[:ruby_default].must_equal '7 days'
-  end
-
   it "should have #transaction support various types of synchronous options" do
     @db.transaction(:synchronous=>:on){}
     @db.transaction(:synchronous=>true){}
@@ -1877,6 +1872,11 @@ if uses_pg_or_jdbc && DB.server_version >= 90000
       e.wrapped_exception.must_be_kind_of ArgumentError
       e.message.must_include "foo"
     end
+
+    it "should handle errors raised during row processing" do
+      proc{@db.copy_table(@db[:test_copy].select(Sequel[1]/(Sequel[:x] - 3)))}.must_raise Sequel::DatabaseError
+      @db.get(1).must_equal 1
+    end
   end
 end
 
@@ -2362,6 +2362,19 @@ describe 'PostgreSQL array handling' do
     c.where(:i=>o2.i, :f=>o2.f, :d=>o2.d, :t=>o2.t).all.must_equal [o]
   end
 
+  it 'with empty array default values and defaults_setter plugin' do
+    @db.create_table!(:items) do
+      column :n, 'integer[]', :default=>[]
+    end
+    c = Class.new(Sequel::Model(@db[:items]))
+    c.plugin :defaults_setter, :cache=>true
+    o = c.new
+    o.n.class.must_equal(Sequel::Postgres::PGArray)
+    o.n.to_a.must_be_same_as(o.n.to_a)
+    o.n << 1
+    o.save.n.must_equal [1]
+  end
+
   it 'operations/functions with pg_array_ops' do
     Sequel.extension :pg_array_ops
     @db.create_table!(:items){column :i, 'integer[]'; column :i2, 'integer[]'; column :i3, 'integer[]'; column :i4, 'integer[]'; column :i5, 'integer[]'}
@@ -2599,6 +2612,19 @@ describe 'PostgreSQL hstore handling' do
     c.filter(:mtm_items=>c.filter(:id=>o.id)).all.must_equal [o]
   end
 
+  it 'with empty hstore default values and defaults_setter plugin' do
+    @db.create_table!(:items) do
+      hstore :h, :default=>Sequel.hstore({})
+    end
+    c = Class.new(Sequel::Model(@db[:items]))
+    c.plugin :defaults_setter, :cache=>true
+    o = c.new
+    o.h.class.must_equal(Sequel::Postgres::HStore)
+    o.h.to_hash.must_be_same_as(o.h.to_hash)
+    o.h['a'] = 'b'
+    o.save.h.must_equal('a'=>'b')
+  end
+
   it 'operations/functions with pg_hstore_ops' do
     Sequel.extension :pg_hstore_ops, :pg_array_ops
     @db.create_table!(:items){hstore :h1; hstore :h2; hstore :h3; String :t}
@@ -2695,11 +2721,10 @@ describe 'PostgreSQL json type' do
   json_types.each do |json_type|
     json_array_type = "#{json_type}[]"
     pg_json = lambda{|v| Sequel.send(:"pg_#{json_type}", v)}
+    hash_class = json_type == :jsonb ? Sequel::Postgres::JSONBHash : Sequel::Postgres::JSONHash
+    array_class = json_type == :jsonb ? Sequel::Postgres::JSONBArray : Sequel::Postgres::JSONArray
 
     it 'insert and retrieve json values' do
-      hash_class = json_type == :jsonb ? Sequel::Postgres::JSONBHash : Sequel::Postgres::JSONHash
-      array_class = json_type == :jsonb ? Sequel::Postgres::JSONBArray : Sequel::Postgres::JSONArray
-
       @db.create_table!(:items){column :j, json_type}
       @ds.insert(pg_json.call(@h))
       @ds.count.must_equal 1
@@ -2753,6 +2778,25 @@ describe 'PostgreSQL json type' do
       c.create(:h=>pg_json.call(@a)).h.must_equal @a
     end
 
+    it 'with empty json default values and defaults_setter plugin' do
+      @db.create_table!(:items) do
+        column :h, json_type, :default=>hash_class.new({})
+        column :a, json_type, :default=>array_class.new([])
+      end
+      c = Class.new(Sequel::Model(@db[:items]))
+      c.plugin :defaults_setter, :cache=>true
+      o = c.new
+      o.h.class.must_equal(hash_class)
+      o.a.class.must_equal(array_class)
+      o.h.to_hash.must_be_same_as(o.h.to_hash)
+      o.a.to_a.must_be_same_as(o.a.to_a)
+      o.h['a'] = 'b'
+      o.a << 1
+      o.save
+      o.h.must_equal('a'=>'b')
+      o.a.must_equal([1])
+    end
+
     it 'use json in bound variables' do
       @db.create_table!(:items){column :i, json_type}
       @ds.call(:insert, {:i=>pg_json.call(@h)}, {:i=>:$i})
@@ -2956,6 +3000,15 @@ describe 'PostgreSQL inet/cidr types' do
     @ds.filter(:i=>:$i, :c=>:$c, :m=>:$m).call(:delete, :i=>[@ipv4], :c=>[@ipv4nm], :m=>['12:34:56:78:90:ab']).must_equal 1
   end if uses_pg_or_jdbc
 
+  it 'parse default values for schema' do
+    @db.create_table!(:items) do
+      inet :i, :default=>IPAddr.new('127.0.0.1')
+      cidr :c, :default=>IPAddr.new('127.0.0.1')
+    end
+    @db.schema(:items)[0][1][:ruby_default].must_equal IPAddr.new('127.0.0.1')
+    @db.schema(:items)[1][1][:ruby_default].must_equal IPAddr.new('127.0.0.1')
+  end
+
   it 'with models' do
     @db.create_table!(:items) do
       primary_key :id
@@ -3113,6 +3166,15 @@ describe 'PostgreSQL range types' do
     @ds.filter(h).call(:delete, @ra).must_equal 1
   end if uses_pg_or_jdbc
 
+  it 'parse default values for schema' do
+    @db.create_table!(:items) do
+      Integer :j
+      int4range :i, :default=>1..4
+    end
+    @db.schema(:items)[0][1][:ruby_default].must_be_nil
+    @db.schema(:items)[1][1][:ruby_default].must_equal Sequel::Postgres::PGRange.new(1, 5, :exclude_end=>true, :db_type=>'int4range')
+  end
+
   it 'with models' do
     @db.create_table!(:items){primary_key :id; int4range :i4; int8range :i8; numrange :n; daterange :d; tsrange :t; tstzrange :tz}
     c = Class.new(Sequel::Model(@db[:items]))
@@ -3282,6 +3344,15 @@ describe 'PostgreSQL interval types' do
     @ds.filter(:i=>:$i).call(:delete, :i=>[d]).must_equal 1
   end if uses_pg_or_jdbc
 
+  it 'parse default values for schema' do
+    @db.create_table!(:items) do
+      Integer :j
+      interval :i, :default=>ActiveSupport::Duration.new(3*86400, :days=>3)
+    end
+    @db.schema(:items)[0][1][:ruby_default].must_be_nil
+    @db.schema(:items)[1][1][:ruby_default].must_equal ActiveSupport::Duration.new(3*86400, :days=>3)
+  end
+
   it 'with models' do
     @db.create_table!(:items) do
       primary_key :id

data/spec/core/schema_spec.rb

@@ -1619,6 +1619,16 @@ describe "Schema Parser" do
     @db.schema(:x).wont_be_same_as(@db.schema(:x))
   end
 
+  it "should freeze string values in resulting hash" do
+    @db.define_singleton_method(:schema_parse_table) do |t, opts|
+      [[:a, {:oid=>1, :db_type=>'integer'.dup, :default=>"'a'".dup, :ruby_default=>'a'.dup}]]
+    end
+    c = @db.schema(:x)[0][1]
+    c[:db_type].frozen?.must_equal true
+    c[:default].frozen?.must_equal true
+    c[:ruby_default].frozen?.must_equal true
+  end
+
   it "should provide options if given a table name" do
     c = nil
     @db.define_singleton_method(:schema_parse_table) do |t, opts|

data/spec/extensions/defaults_setter_spec.rb

@@ -41,6 +41,15 @@ describe "Sequel::Plugins::DefaultsSetter" do
     (t - Time.now).must_be :<,  1
   end
 
+  it "should handle :callable_default values in schema in preference to :ruby_default" do
+    @db.define_singleton_method(:schema) do |*|
+      [[:id, {:primary_key=>true}],
+       [:a, {:ruby_default => Time.now, :callable_default=>lambda{Date.today}, :primary_key=>false}]]
+    end
+    @c.dataset = @c.dataset
+    @c.new.a.must_equal Date.today
+  end
+
   it "should handle Sequel::CURRENT_TIMESTAMP default by using the current DateTime if Sequel.datetime_class is DateTime" do
     Sequel.datetime_class = DateTime
     t = @pr.call(Sequel::CURRENT_TIMESTAMP).new.a
@@ -60,6 +69,15 @@ describe "Sequel::Plugins::DefaultsSetter" do
     @db.sqls.must_equal ["INSERT INTO foo (a) VALUES (CURRENT_TIMESTAMP)", "SELECT * FROM foo WHERE id = 1"]
   end
 
+  it "should cache default values if :cache plugin option is used" do
+    @c.plugin :defaults_setter, :cache => true
+    @c.default_values[:a] = 'a'
+    o = @c.new
+    o.a.must_equal 'a'
+    o.values[:a].must_equal 'a'
+    o.a.must_be_same_as(o.a)
+  end
+
   it "should not override a given value" do
     @pr.call(2)
     @c.new('a'=>3).a.must_equal 3

data/spec/extensions/modification_detection_spec.rb

@@ -11,6 +11,13 @@ describe "serialization_modification_detection plugin" do
     @ds.db.sqls
   end
   
+  it "should detect setting new column values on new objects" do
+    @o = @c.new
+    @o.changed_columns.must_equal []
+    @o.a = 'c'
+    @o.changed_columns.must_equal [:a]
+  end
+
   it "should only detect columns that have been changed" do
     @o.changed_columns.must_equal []
     @o.a << 'b'
@@ -32,6 +39,12 @@ describe "serialization_modification_detection plugin" do
     @o.changed_columns.must_equal []
   end
   
+  it "should detect columns that have been changed on frozen objects" do
+    @o.freeze
+    @o.a << 'b'
+    @o.changed_columns.must_equal [:a]
+  end
+
   it "should not list a column twice" do
     @o.a = 'b'.dup
     @o.a << 'a'

data/spec/extensions/pg_array_spec.rb

@@ -209,6 +209,17 @@ describe "pg_array extension" do
     @db.schema(:items).map{|e| e[1][:type]}.must_equal [:integer, :integer_array, :real_array, :decimal_array, :string_array]
   end
 
+  it "should set :callable_default schema entries if default value is recognized" do
+    @db.fetch = [{:name=>'id', :db_type=>'integer', :default=>'1'}, {:name=>'t', :db_type=>'text[]', :default=>"'{}'::text[]"}]
+    s = @db.schema(:items)
+    s[0][1][:callable_default].must_be_nil
+    v = s[1][1][:callable_default].call
+    Sequel::Postgres::PGArray.===(v).must_equal true
+    @db.literal(v).must_equal "'{}'::text[]"
+    v << 'a'
+    @db.literal(v).must_equal "ARRAY['a']::text[]"
+  end
+
   it "should support typecasting of the various array types" do
     {
       :integer=>{:class=>Integer, :convert=>['1', 1, '1']},

data/spec/extensions/pg_hstore_spec.rb

@@ -186,6 +186,17 @@ describe "pg_hstore extension" do
     @db.schema(:items).map{|e| e[1][:type]}.must_equal [:integer, :hstore]
   end
 
+  it "should set :callable_default schema entries if default value is recognized" do
+    @db.fetch = [{:name=>'id', :db_type=>'integer', :default=>'1'}, {:name=>'t', :db_type=>'hstore', :default=>"''::hstore"}]
+    s = @db.schema(:items)
+    s[0][1][:callable_default].must_be_nil
+    v = s[1][1][:callable_default].call
+    Sequel::Postgres::HStore.===(v).must_equal true
+    @db.literal(v).must_equal "''::hstore"
+    v['a'] = 'b'
+    @db.literal(v).must_equal "'\"a\"=>\"b\"'::hstore"
+  end
+
   it "should support typecasting for the hstore type" do
     h = Sequel.hstore(1=>2)
     @db.typecast_value(:hstore, h).object_id.must_equal(h.object_id)

data/spec/extensions/pg_inet_spec.rb

@@ -51,6 +51,12 @@ describe "pg_inet extension" do
     @db.schema(:items).map{|e| e[1][:type]}.must_equal [:integer, :ipaddr, :ipaddr]
   end
 
+  it "should set :ruby_default schema entries if default value is recognized" do
+    @db.fetch = [{:name=>'id', :db_type=>'integer', :default=>'1'}, {:name=>'t', :db_type=>'inet', :default=>"'127.0.0.1'::inet"}]
+    s = @db.schema(:items)
+    s[1][1][:ruby_default].must_equal IPAddr.new('127.0.0.1')
+  end
+
   it "should support typecasting for the ipaddr type" do
     ip = IPAddr.new('127.0.0.1')
     @db.typecast_value(:ipaddr, ip).must_be_same_as(ip)

data/spec/extensions/pg_interval_spec.rb

@@ -66,6 +66,12 @@ describe "pg_interval extension" do
     @db.schema(:items).map{|e| e[1][:type]}.must_equal [:integer, :interval]
   end
 
+  it "should set :ruby_default schema entries if default value is recognized" do
+    @db.fetch = [{:name=>'id', :db_type=>'integer', :default=>'1'}, {:name=>'t', :db_type=>'interval', :default=>"'3 days'::interval"}]
+    s = @db.schema(:items)
+    s[1][1][:ruby_default].must_equal ActiveSupport::Duration.new(3*86400, :days=>3)
+  end
+
   it "should support typecasting for the interval type" do
     d = ActiveSupport::Duration.new(31557600 + 2*86400*30 + 3*86400*7 + 4*86400 + 5*3600 + 6*60 + 7, [[:years, 1], [:months, 2], [:days, 25], [:seconds, 18367]])
     @db.typecast_value(:interval, d).object_id.must_equal d.object_id

data/spec/extensions/pg_json_spec.rb

@@ -183,6 +183,35 @@ describe "pg_json extension" do
     @db.schema(:items).map{|e| e[1][:type]}.must_equal [:integer, :jsonb]
   end
 
+  it "should set :callable_default schema entries if default value is recognized" do
+    @db.fetch = [{:name=>'id', :db_type=>'integer', :default=>'1'}, {:name=>'jh', :db_type=>'json', :default=>"'{}'::json"}, {:name=>'ja', :db_type=>'json', :default=>"'[]'::json"}, {:name=>'jbh', :db_type=>'jsonb', :default=>"'{}'::jsonb"}, {:name=>'jba', :db_type=>'jsonb', :default=>"'[]'::jsonb"}]
+    s = @db.schema(:items)
+    s[0][1][:callable_default].must_be_nil
+    v = s[1][1][:callable_default].call
+    Sequel::Postgres::JSONHash.===(v).must_equal true
+    @db.literal(v).must_equal "'{}'::json"
+    v['a'] = 'b'
+    @db.literal(v).must_equal "'{\"a\":\"b\"}'::json"
+
+    v = s[2][1][:callable_default].call
+    Sequel::Postgres::JSONArray.===(v).must_equal true
+    @db.literal(v).must_equal "'[]'::json"
+    v << 1
+    @db.literal(v).must_equal "'[1]'::json"
+
+    v = s[3][1][:callable_default].call
+    Sequel::Postgres::JSONBHash.===(v).must_equal true
+    @db.literal(v).must_equal "'{}'::jsonb"
+    v['a'] = 'b'
+    @db.literal(v).must_equal "'{\"a\":\"b\"}'::jsonb"
+
+    v = s[4][1][:callable_default].call
+    Sequel::Postgres::JSONBArray.===(v).must_equal true
+    @db.literal(v).must_equal "'[]'::jsonb"
+    v << 1
+    @db.literal(v).must_equal "'[1]'::jsonb"
+  end
+
   it "should support typecasting for the json type" do
     h = Sequel.pg_json(1=>2)
     a = Sequel.pg_json([1])

data/spec/extensions/pg_range_spec.rb

@@ -93,6 +93,12 @@ describe "pg_range extension" do
     @db.schema(:items).map{|e| e[1][:type]}.must_equal [:integer, :int4range_array, :int8range_array, :numrange_array, :daterange_array, :tsrange_array, :tstzrange_array]
   end
 
+  it "should set :ruby_default schema entries if default value is recognized" do
+    @db.fetch = [{:name=>'id', :db_type=>'integer', :default=>'1'}, {:oid=>3904, :name=>'t', :db_type=>'int4range', :default=>"'[1,5)'::int4range"}]
+    s = @db.schema(:items)
+    s[1][1][:ruby_default].must_equal Sequel::Postgres::PGRange.new(1, 5, :exclude_end=>true, :db_type=>'int4range')
+  end
+
   describe "database typecasting" do
     before do
       @o = @R.new(1, 2, :db_type=>'int4range')

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sequel
 version: !ruby/object:Gem::Version
-  version: 5.4.0
+  version: 5.5.0
 platform: ruby
 authors:
 - Jeremy Evans
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-01-04 00:00:00.000000000 Z
+date: 2018-01-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest
@@ -255,6 +255,7 @@ extra_rdoc_files:
 - doc/release_notes/5.2.0.txt
 - doc/release_notes/5.3.0.txt
 - doc/release_notes/5.4.0.txt
+- doc/release_notes/5.5.0.txt
 files:
 - CHANGELOG
 - MIT-LICENSE
@@ -404,6 +405,7 @@ files:
 - doc/release_notes/5.2.0.txt
 - doc/release_notes/5.3.0.txt
 - doc/release_notes/5.4.0.txt
+- doc/release_notes/5.5.0.txt
 - doc/schema_modification.rdoc
 - doc/security.rdoc
 - doc/sharding.rdoc