sequel 5.14.0 → 5.15.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a950f8be723b867d5ecc782005c2374fa84a05a6b54c4ba55652f5442de1c90b
-  data.tar.gz: c5b2c92ee3580933b9fcd0525fdb67a79f5915f8b8e337e4731b9046f771dbf0
+  metadata.gz: 965fa50e6e91a5630a4e484651180b38b9d2eb2c785be8b91dd5b099e3ba5be6
+  data.tar.gz: 3c3c5bd93d51326fff0081272e41a0a23b0dbb47d393603f073cbc0f0486e6c7
 SHA512:
-  metadata.gz: 4671d49935656b0ec907f10d3d4a6b25e29815b328b7661e55d95e4bfabbf84818de2b3550d92d86f444fbd69a561f099c859a5b1156303e10d58a7402641ebc
-  data.tar.gz: 5488428f7290a548344849919a7895dfd1e8d7cbe7990c2b261b4118e2a46845d9bde30b00673928511e2e650b3e4098f81cb2087d8f42227653607d3ae90c6f
+  metadata.gz: a633436d4a066e195e847cffc7dd68d0cd2902915ddca33d5df724dc020aee22dbd95a261f8b15ea1581a73517d5736423a8693f40a3ef59fb27c88b8c24ca01
+  data.tar.gz: bee56c79793138296ced8395deabf2652a68fe2de3bc4f144470d885b253883017e15ca0281e36e04c6064b590b505daed285b23699140e77cae119bddee3914

data/CHANGELOG

@@ -1,3 +1,21 @@
+=== 5.15.0 (2018-12-01)
+
+* Add :conn_str option in the postgres adapter for PostgreSQL connection strings, if the pg driver is used (graywolf) (#1572)
+
+* Add :qualify_tables option to class_table_inheritance plugin to automatically qualify subclass tables with superclass qualifier (benalavi) (#1571)
+
+* Access already allocated connections in a thread safe manner when checking out connections in the sharded threaded connection pool (jeremyevans)
+
+* Automatically support datasets using qualified tables in the class_table_inheritance plugin without having to use the :alias option (benalavi) (#1565)
+
+* Support rename_column without emulation on SQLite 3.25+ (jeremyevans)
+
+* Do not remove currently cached many_to_one associated objects when changing the related foreign key value from nil to non-nil (jeremyevans)
+
+* Do not validate new *_to_many associated objects twice when saving in the nested_attributes plugin (jeremyevans)
+
+* Add Model#skip_validation_on_next_save! for skipping validation on next save call (jeremyevans)
+
 === 5.14.0 (2018-11-01)
 
 * Drop defaulting the :port option to 5432 in the postgres adapter, so that setting the :service option in :driver_options works (jeremyevans) (#1558)

data/doc/opening_databases.rdoc

@@ -309,6 +309,10 @@ The following additional options are supported:
                                 conversion is done, so an error is raised if you attempt to retrieve an infinite
                                 timestamp/date.  You can set this to :nil to convert to nil, :string to leave
                                 as a string, or :float to convert to an infinite float.
+:conn_str :: Use connection string (in form of `host=x port=y ...`). Ignores all other options, only supported with pg
+             library. See https://www.postgresql.org/docs/current/libpq-connect.html#LIBPQ-CONNSTRING and 
+             https://www.postgresql.org/docs/current/libpq-connect.html#LIBPQ-PARAMKEYWORDS for format and list of supported
+             options.
 :connect_timeout :: Set the number of seconds to wait for a connection (default 20, only respected
                     if using the pg library).
 :driver_options :: A hash of options to pass to the underlying driver (only respected if using the pg library)

data/doc/release_notes/5.15.0.txt

@@ -0,0 +1,39 @@
+= New Features
+
+* A :qualify_tables option has been added to the
+  class_table_inheritance plugin, which will automatically qualify
+  subclass tables with the same qualifier as the superclass table
+  if the superclass table is qualified.
+
+* Model#save_validation_on_next_save! has been added, which skips all
+  validation on the next save to the object, including the running
+  of validation related hooks.  This method is designed for use only
+  when Model#valid? is called on the object before saving, to avoid
+  running validations on the object twice.  This method takes
+  precedence even over an explicit validate: true option passed to
+  Model#save, and as such should be used with care.
+
+* The postgres adapter now supports a :conn_str Database option to
+  use a PostgreSQL connection string (e.g. "host=foo port=2442") when
+  connecting.  This option has preference over other connection
+  related options if it is present.
+
+= Other Improvements
+
+* If a foreign key for a model object is changed from a nil value to
+  a non-nil value, any cached associated objects related to the
+  foreign key are no longer removed.  Such associated objects could
+  only be set manually, and if they have been set manually, it is
+  probably not a good idea to remove them automatically.
+
+* When using the nested_attributes plugin, new *_to_many associated
+  objects are not validated twice when saving.
+
+* The default table alias when using the class_table_inheritance
+  plugin now correctly handles qualified tables.
+
+* A theoretical thread safety issue when assigning connections
+  in the threaded connection pools has been fixed.
+
+* Renaming columns is now supported without emulation when using
+  SQLite 3.25+.

data/doc/validations.rdoc

@@ -535,7 +535,7 @@ Note that the column names used in the errors are used verbatim in the error mes
   errors.full_messages
   # => ["Album name is not valid"]
 
-Alternatively, feel free to override Sequel::Model::Errors#full_messages.  As long as it returns an array of strings, overridding it is completely safe.
+Alternatively, feel free to override Sequel::Model::Errors#full_messages.  As long as it returns an array of strings, overriding it is completely safe.
 
 === +count+
 

data/lib/sequel/adapters/postgres.rb

@@ -203,7 +203,7 @@ module Sequel
             :sslrootcert => opts[:sslrootcert]
           }.delete_if { |key, value| blank_object?(value) }
           connection_params.merge!(opts[:driver_options]) if opts[:driver_options]
-          conn = Adapter.connect(connection_params)
+          conn = Adapter.connect(opts[:conn_str] || connection_params)
 
           conn.instance_variable_set(:@prepared_statements, {})
 

data/lib/sequel/adapters/shared/mssql.rb

@@ -40,6 +40,12 @@ module Sequel
       # :numrows :: The number of rows affected by the stored procedure
       # output params :: Values for any output paramters, using the name given for the output parameter
       #
+      # Because Sequel datasets only support a single result set per query, and retrieving 
+      # the result code and number of rows requires a query, this does not support
+      # stored procedures which also return result sets.  To handle such stored procedures,
+      # you should drop down to the connection/driver level by using Sequel::Database#synchronize
+      # to get access to the underlying connection object.
+      #
       # Examples:
       #
       #     DB.call_mssql_sproc(:SequelTest, {args: ['input arg', :output]})

data/lib/sequel/adapters/shared/sqlite.rb

@@ -217,8 +217,12 @@ module Sequel
           ocp = lambda{|oc| oc.delete_if{|c| c.to_s == op[:name].to_s}}
           duplicate_table(table, :old_columns_proc=>ocp){|columns| columns.delete_if{|s| s[:name].to_s == op[:name].to_s}}
         when :rename_column
-          ncp = lambda{|nc| nc.map!{|c| c.to_s == op[:name].to_s ? op[:new_name] : c}}
-          duplicate_table(table, :new_columns_proc=>ncp){|columns| columns.each{|s| s[:name] = op[:new_name] if s[:name].to_s == op[:name].to_s}}
+          if sqlite_version >= 32500
+            super
+          else
+            ncp = lambda{|nc| nc.map!{|c| c.to_s == op[:name].to_s ? op[:new_name] : c}}
+            duplicate_table(table, :new_columns_proc=>ncp){|columns| columns.each{|s| s[:name] = op[:new_name] if s[:name].to_s == op[:name].to_s}}
+          end
         when :set_column_default
           duplicate_table(table){|columns| columns.each{|s| s[:default] = op[:default] if s[:name].to_s == op[:name].to_s}}
         when :set_column_null

data/lib/sequel/connection_pool/sharded_threaded.rb

@@ -46,6 +46,7 @@ class Sequel::ShardedThreadedConnectionPool < Sequel::ThreadedConnectionPool
   # A hash of connections currently being used for the given server, key is the
   # Thread, value is the connection.  Nonexistent servers will return nil.  Treat
   # this as read only, do not modify the resulting object.
+  # The calling code should already have the mutex before calling this.
   def allocated(server=:default)
     @allocated[server]
   end
@@ -70,13 +71,14 @@ class Sequel::ShardedThreadedConnectionPool < Sequel::ThreadedConnectionPool
   # An array of connections opened but not currently used, for the given
   # server. Nonexistent servers will return nil. Treat this as read only, do
   # not modify the resulting object.
+  # The calling code should already have the mutex before calling this.
   def available_connections(server=:default)
     @available_connections[server]
   end
   
   # The total number of connections opened for the given server.
   # Nonexistent servers will return the created count of the default server.
-  # The calling code should not have the mutex before calling this.
+  # The calling code should NOT have the mutex before calling this.
   def size(server=:default)
     @mutex.synchronize{_size(server)}
   end
@@ -221,10 +223,11 @@ class Sequel::ShardedThreadedConnectionPool < Sequel::ThreadedConnectionPool
   # Assign a connection to the thread, or return nil if one cannot be assigned.
   # The caller should NOT have the mutex before calling this.
   def assign_connection(thread, server)
-    alloc = allocated(server)
+    alloc = nil
 
     do_make_new = false
     sync do
+      alloc = allocated(server)
       if conn = next_available(server)
         alloc[thread] = conn
         return conn
@@ -286,7 +289,7 @@ class Sequel::ShardedThreadedConnectionPool < Sequel::ThreadedConnectionPool
   end
 
   # Disconnect all available connections immediately, and schedule currently allocated connections for disconnection
-  # as soon as they are returned to the pool. The calling code should not
+  # as soon as they are returned to the pool. The calling code should NOT
   # have the mutex before calling this.
   def disconnect_connections(conns)
     conns.each{|conn| disconnect_connection(conn)}

data/lib/sequel/connection_pool/threaded.rb

@@ -11,10 +11,11 @@ class Sequel::ThreadedConnectionPool < Sequel::ConnectionPool
   attr_reader :max_size
   
   # An array of connections that are available for use by the pool.
+  # The calling code should already have the mutex before calling this.
   attr_reader :available_connections
   
-  # A hash with thread keys and connection values for currently allocated
-  # connections.
+  # A hash with thread keys and connection values for currently allocated connections.
+  # The calling code should already have the mutex before calling this.
   attr_reader :allocated
 
   # The following additional options are respected:
@@ -171,6 +172,8 @@ class Sequel::ThreadedConnectionPool < Sequel::ConnectionPool
   # Assign a connection to the thread, or return nil if one cannot be assigned.
   # The caller should NOT have the mutex before calling this.
   def assign_connection(thread)
+    # Thread safe as instance variable is only assigned to local variable
+    # and not operated on outside mutex.
     allocated = @allocated
     do_make_new = false
     to_disconnect = nil
@@ -183,7 +186,7 @@ class Sequel::ThreadedConnectionPool < Sequel::ConnectionPool
       if (n = _size) >= (max = @max_size)
         allocated.keys.each do |t|
           unless t.alive?
-            (to_disconnect ||= []) << @allocated.delete(t)
+            (to_disconnect ||= []) << allocated.delete(t)
           end
         end
         n = nil

data/lib/sequel/model/associations.rb

@@ -2406,15 +2406,32 @@ module Sequel
         # cached associations.
         def change_column_value(column, value)
           if assocs = model.autoreloading_associations[column]
+            vals = @values
             if new?
               # Do deeper checking for new objects, so that associations are
               # not deleted when values do not change.  This code is run at
               # a higher level for existing objects.
-              vals = @values
-              return super unless !vals.include?(column) || value != (c = vals[column]) || value.class != c.class
+              if value == (c = vals[column]) && value.class == c.class
+                # If the value is the same, there is no reason to delete
+                # the related associations, so exit early in that case.
+                return super
+              end
+
+              only_delete_nil = c.nil?
+            elsif vals[column].nil?
+              only_delete_nil = true
             end
 
-            assocs.each{|a| associations.delete(a)}
+            if only_delete_nil
+              # If the current foreign key value is nil, but the association
+              # is already present in the cache, it was probably added to the
+              # cache for a reason, and we do not want to delete it in that case.
+              # However, we still want to delete associations with nil values
+              # to remove the cached false negative.
+              assocs.each{|a| associations.delete(a) if associations[a].nil?}
+            else
+              assocs.each{|a| associations.delete(a)}
+            end
           end
           super
         end

data/lib/sequel/model/base.rb

@@ -1456,7 +1456,7 @@ module Sequel
       def save(opts=OPTS)
         raise Sequel::Error, "can't save frozen object" if frozen?
         set_server(opts[:server]) if opts[:server] 
-        unless checked_save_failure(opts){_valid?(opts)}
+        unless _save_valid?(opts)
           raise(ValidationFailed.new(self)) if raise_on_failure?(opts)
           return
         end
@@ -1551,6 +1551,15 @@ module Sequel
         super
       end
   
+      # Skip all validation of the object on the next call to #save,
+      # including the running of validation hooks. This is designed for
+      # and should only be used in cases where #valid? is called before
+      # saving and the <tt>validate: false</tt> option cannot be passed to
+      # #save.
+      def skip_validation_on_next_save!
+        @skip_validation_on_next_save = true
+      end
+
       # Returns (naked) dataset that should return only this instance.
       #
       #   Artist[1].this
@@ -1809,6 +1818,19 @@ module Sequel
         v
       end
 
+      # Validate the object if validating on save. Skips validation
+      # completely (including validation hooks) if
+      # skip_validation_on_save! has been called on the object,
+      # resetting the flag so that future saves will validate.
+      def _save_valid?(opts)
+        if @skip_validation_on_next_save
+          @skip_validation_on_next_save = false
+          return true
+        end
+
+        checked_save_failure(opts){_valid?(opts)}
+      end
+
       # Call _update with the given columns, if any are present.
       # Plugins can override this method in order to update with
       # additional columns, even when the column hash is initially empty.

data/lib/sequel/plugins/class_table_inheritance.rb

@@ -198,6 +198,9 @@ module Sequel
       #               Overrides implicit table names.
       # :ignore_subclass_columns :: Array with column names as symbols that are ignored
       #                             on all sub-classes.
+      # :qualify_tables :: Boolean true to qualify automatically determined
+      #                    subclass tables with the same qualifier as their
+      #                    superclass.
       def self.configure(model, opts = OPTS)
         SingleTableInheritance.configure model, opts[:key], opts
 
@@ -207,8 +210,14 @@ module Sequel
           @cti_instance_dataset = @instance_dataset
           @cti_table_columns = columns
           @cti_table_map = opts[:table_map] || {}
-          @cti_alias = opts[:alias] || @dataset.first_source
+          @cti_alias = opts[:alias] || case source = @dataset.first_source
+          when SQL::QualifiedIdentifier
+            @dataset.unqualified_column_for(source)
+          else
+            source
+          end
           @cti_ignore_subclass_columns = opts[:ignore_subclass_columns] || []
+          @cti_qualify_tables = !!opts[:qualify_tables]
         end
       end
 
@@ -239,6 +248,13 @@ module Sequel
         # primary key column is always allowed to be duplicated
         attr_reader :cti_ignore_subclass_columns
 
+        # A boolean indicating whether or not to automatically qualify tables
+        # backing subclasses with the same qualifier as their superclass, if
+        # the superclass is qualified. Specified with the :qualify_tables
+        # option to the plugin and only applied to automatically determined
+        # table names (not to the :table_map option).
+        attr_reader :cti_qualify_tables
+
         # Freeze CTI information when freezing model class.
         def freeze
           @cti_models.freeze
@@ -250,7 +266,7 @@ module Sequel
           super
         end
 
-        Plugins.inherited_instance_variables(self, :@cti_models=>nil, :@cti_tables=>nil, :@cti_table_columns=>nil, :@cti_instance_dataset=>nil, :@cti_table_map=>nil, :@cti_alias=>nil, :@cti_ignore_subclass_columns=>nil)
+        Plugins.inherited_instance_variables(self, :@cti_models=>nil, :@cti_tables=>nil, :@cti_table_columns=>nil, :@cti_instance_dataset=>nil, :@cti_table_map=>nil, :@cti_alias=>nil, :@cti_ignore_subclass_columns=>nil, :@cti_qualify_tables=>nil)
 
         def inherited(subclass)
           ds = sti_dataset
@@ -267,7 +283,11 @@ module Sequel
             if table = cti_table_map[n.to_sym]
               columns = db.from(table).columns
             else
-              table = subclass.implicit_table_name
+              table = if cti_qualify_tables && (schema = dataset.schema_and_table(table_name).first)
+                SQL::QualifiedIdentifier.new(schema, subclass.implicit_table_name)
+              else
+                subclass.implicit_table_name
+              end
               columns = check_non_connection_error(false){db.from(table).columns}
               table = nil if !columns || columns.empty?
             end

data/lib/sequel/plugins/nested_attributes.rb

@@ -176,6 +176,7 @@ module Sequel
           delay_validate_associated_object(reflection, obj)
           if reflection.returns_array?
             public_send(reflection[:name]) << obj
+            obj.skip_validation_on_next_save!
             after_save_hook{public_send(reflection[:add_method], obj)}
           else
             associations[reflection[:name]] = obj

data/lib/sequel/version.rb

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

data/spec/extensions/class_table_inheritance_spec.rb

@@ -566,3 +566,119 @@ describe "class_table_inheritance plugin with duplicate columns" do
   end
 end
 
+describe "class_table_inheritance plugin with dataset defined with QualifiedIdentifier" do
+  before do
+    @db = Sequel.mock(:numrows=>1, :autoid=>proc{|sql| 1})
+    def @db.supports_schema_parsing?() true end
+    def @db.schema(table, opts={})
+      {Sequel[:hr][:employees]=>[[:id, {:primary_key=>true, :type=>:integer}], [:name, {:type=>:string}], [:kind, {:type=>:string}]],
+       Sequel[:hr][:managers]=>[[:id, {:type=>:integer}]],
+       Sequel[:hr][:staff]=>[[:id, {:type=>:integer}], [:manager_id, {:type=>:integer}]],
+      }[table.is_a?(Sequel::Dataset) ? table.first_source_table : table]
+    end
+    @db.extend_datasets do
+      def columns
+        {[Sequel[:hr][:employees]]=>[:id, :name, :kind],
+         [Sequel[:hr][:managers]]=>[:id],
+         [Sequel[:hr][:staff]]=>[:id, :manager_id],
+         [Sequel[:hr][:employees], Sequel[:hr][:managers]]=>[:id, :name, :kind],
+         [Sequel[:hr][:employees], Sequel[:hr][:staff]]=>[:id, :name, :kind, :manager_id],
+        }[opts[:from] + (opts[:join] || []).map{|x| x.table}]
+      end
+    end
+  end
+  after do
+    [:Manager, :Staff, :Employee].each{|s| Object.send(:remove_const, s) if Object.const_defined?(s)}
+  end
+
+  describe "with table_map used to qualify subclasses" do
+    before do
+      ::Employee = Class.new(Sequel::Model)
+      ::Employee.db = @db
+      ::Employee.set_dataset(Sequel[:hr][:employees])
+      class ::Employee
+        def _save_refresh; @values[:id] = 1 end
+        def self.columns
+          dataset.columns || dataset.opts[:from].first.expression.columns
+        end
+        plugin :class_table_inheritance, :table_map=>{:Manager=>Sequel[:hr][:managers],:Staff=>Sequel[:hr][:staff]}
+      end
+      class ::Manager < Employee
+        one_to_many :staff_members, :class=>:Staff
+      end
+      class ::Staff < Employee
+        many_to_one :manager
+      end
+    end
+
+    it "should handle many_to_one relationships correctly" do
+      Manager.dataset = Manager.dataset.with_fetch(:id=>3, :name=>'E')
+      Staff.load(:manager_id=>3).manager.must_equal Manager.load(:id=>3, :name=>'E')
+      @db.sqls.must_equal ['SELECT * FROM (SELECT hr.employees.id, hr.employees.name, hr.employees.kind FROM hr.employees INNER JOIN hr.managers ON (hr.managers.id = hr.employees.id)) AS employees WHERE (id = 3) LIMIT 1']
+    end
+
+    it "should handle one_to_many relationships correctly" do
+      Staff.dataset = Staff.dataset.with_fetch(:id=>1, :name=>'S', :manager_id=>3)
+      Manager.load(:id=>3).staff_members.must_equal [Staff.load(:id=>1, :name=>'S', :manager_id=>3)]
+      @db.sqls.must_equal ['SELECT * FROM (SELECT hr.employees.id, hr.employees.name, hr.employees.kind, hr.staff.manager_id FROM hr.employees INNER JOIN hr.staff ON (hr.staff.id = hr.employees.id)) AS employees WHERE (employees.manager_id = 3)']
+    end
+  end
+
+  describe "without table_map or qualify_tables set" do
+    it "should use a non-qualified subquery in subclasses" do
+      def @db.schema(table, opts={})
+        {Sequel[:hr][:employees]=>[[:id, {:primary_key=>true, :type=>:integer}], [:name, {:type=>:string}], [:kind, {:type=>:string}]],
+         :managers=>[[:id, {:type=>:integer}]],
+        }[table.is_a?(Sequel::Dataset) ? table.first_source_table : table]
+      end
+      @db.extend_datasets do
+        def columns
+          {[Sequel[:hr][:employees]]=>[:id, :name, :kind],
+           [:managers]=>[:id],
+           [Sequel[:hr][:employees], :managers]=>[:id, :name, :kind]
+          }[opts[:from] + (opts[:join] || []).map{|x| x.table}]
+        end
+      end
+      ::Employee = Class.new(Sequel::Model)
+      ::Employee.db = @db
+      ::Employee.set_dataset(Sequel[:hr][:employees])
+      class ::Employee
+        def _save_refresh; @values[:id] = 1 end
+        def self.columns
+          dataset.columns || dataset.opts[:from].first.expression.columns
+        end
+        plugin :class_table_inheritance
+      end
+      class ::Manager < ::Employee
+      end
+
+      Employee.dataset.sql.must_equal 'SELECT * FROM hr.employees'
+      Manager.dataset.sql.must_equal 'SELECT * FROM (SELECT hr.employees.id, hr.employees.name, hr.employees.kind FROM hr.employees INNER JOIN managers ON (managers.id = hr.employees.id)) AS employees'
+    end
+  end
+
+  describe "with qualify_tables option set" do
+    it "should use a subquery with the same qualifier in subclasses" do
+      ::Employee = Class.new(Sequel::Model)
+      ::Employee.db = @db
+      ::Employee.set_dataset(Sequel[:hr][:employees])
+      class ::Employee
+        def _save_refresh; @values[:id] = 1 end
+        def self.columns
+          dataset.columns || dataset.opts[:from].first.expression.columns
+        end
+        plugin :class_table_inheritance, :table_map=>{:Staff=>Sequel[:hr][:staff]}, qualify_tables: true
+      end
+      class ::Manager < ::Employee
+        one_to_many :staff_members, :class=>:Staff
+      end
+      class ::Staff < ::Employee
+        many_to_one :manager
+      end
+
+      Employee.dataset.sql.must_equal 'SELECT * FROM hr.employees'
+      Manager.dataset.sql.must_equal 'SELECT * FROM (SELECT hr.employees.id, hr.employees.name, hr.employees.kind FROM hr.employees INNER JOIN hr.managers ON (hr.managers.id = hr.employees.id)) AS employees'
+      Staff.dataset.sql.must_equal 'SELECT * FROM (SELECT hr.employees.id, hr.employees.name, hr.employees.kind, hr.staff.manager_id FROM hr.employees INNER JOIN hr.staff ON (hr.staff.id = hr.employees.id)) AS employees'
+    end
+  end
+end

data/spec/extensions/constant_sql_override_spec.rb

@@ -11,8 +11,14 @@ describe "constant_sql_override extension" do
     @db.sqls.must_equal ["SELECT * FROM tbl WHERE (foo = CURRENT TIMESTAMP AT TIME ZONE 'UTC') LIMIT 1"]
   end
 
-  it 'freezes the constant_sqls hash' do
+  it 'does not change behavior for unconfigured constants' do
+    @db[:tbl].where(foo: Sequel::CURRENT_TIMESTAMP).first
+    @db.sqls.must_equal ["SELECT * FROM tbl WHERE (foo = CURRENT_TIMESTAMP) LIMIT 1"]
+  end
+
+  it 'freezes the constant_sqls hash when frozen' do
     @db.freeze
     @db.constant_sqls.frozen?.must_equal true
+    proc{@db.set_constant_sql(Sequel::CURRENT_TIMESTAMP, "CURRENT TIMESTAMP AT TIME ZONE 'UTC'")}.must_raise RuntimeError
   end
 end

data/spec/extensions/nested_attributes_spec.rb

@@ -492,6 +492,24 @@ describe "NestedAttributes plugin" do
     @db.sqls.must_equal ["UPDATE artists SET name = 'Ar' WHERE (id = 10)"]
   end
 
+  it "should not attempt to validate nested attributes twice for one_to_many associations when creating them" do
+    @Artist.nested_attributes :albums
+    validated = []
+    @Album.class_eval do
+      define_method(:validate) do
+        super()
+        validated << self
+      end
+    end
+    a = @Artist.new(:name=>'Ar', :albums_attributes=>[{:name=>'Al'}])
+    @db.sqls.must_equal []
+    validated.length.must_equal 0
+    a.save
+    validated.length.must_equal 1
+    check_sql_array("INSERT INTO artists (name) VALUES ('Ar')",
+      ["INSERT INTO albums (artist_id, name) VALUES (1, 'Al')", "INSERT INTO albums (name, artist_id) VALUES ('Al', 1)"])
+  end
+  
   it "should not save if nested attribute is not valid and should include nested attribute validation errors in the main object's validation errors" do
     @Artist.class_eval do
       def validate

data/spec/model/associations_spec.rb

@@ -189,6 +189,68 @@ describe Sequel::Model, "associate" do
     o.associations.must_equal(:c=>1)
   end
 
+  it "should not autoreload associations when the current foreign key value is nil" do
+    c = Class.new(Sequel::Model(Sequel::Model.db[:c]))
+    c.many_to_one :c
+    o = c.new
+    o.associations[:c] = 1
+    o[:c_id] = 2
+    o.associations[:c].must_equal 1
+
+    o = c.load({})
+    o.associations[:c] = 1
+    o[:c_id] = 2
+    o.associations[:c].must_equal 1
+  end
+
+  it "should autoreload associations when the current foreign key is nil and the current associated value is nil" do
+    c = Class.new(Sequel::Model(Sequel::Model.db[:c]))
+    c.many_to_one :c
+    o = c.new
+    o.associations[:c] = nil
+    o[:c_id] = 2
+    o.associations.must_be_empty
+
+    o = c.load({})
+    o.associations[:c] = nil
+    o[:c_id] = 2
+    o.associations.must_be_empty
+  end
+
+  it "should handle autoreloading for multiple associations when the current foreign key is nil" do
+    c = Class.new(Sequel::Model(Sequel::Model.db[:c]))
+    c.many_to_one :c
+    c.many_to_one :d, :key=>:c_id
+    o = c.new
+    o.associations[:c] = nil
+    o.associations[:d] = 1
+    o[:c_id] = nil
+    o.associations.must_equal(:c=>nil, :d=>1)
+
+    o[:c_id] = 2
+    o.associations.must_equal(:d=>1)
+
+    o[:c_id] = 2
+    o.associations.must_equal(:d=>1)
+
+    o[:c_id] = nil
+    o.associations.must_be_empty
+
+    o = c.load({:c_id=>nil})
+    o.associations[:c] = nil
+    o.associations[:d] = 1
+    o[:c_id] = nil
+    o.associations.must_equal(:c=>nil, :d=>1)
+
+    o[:c_id] = 2
+    o.associations.must_equal(:d=>1)
+
+    o[:c_id] = 2
+    o.associations.must_equal(:d=>1)
+
+    o[:c_id] = nil
+    o.associations.must_be_empty
+  end
 end
 
 describe Sequel::Model, "many_to_one" do

data/spec/model/validations_spec.rb

@@ -170,6 +170,33 @@ describe "Model#save" do
     DB.sqls.must_equal ['UPDATE people SET x = 6 WHERE (id = 4)']
   end
 
+  it "should skip validations if the skip_validation_on_save! method is used" do
+    @m.raise_on_save_failure = false
+    @m.wont_be :valid?
+    @m.skip_validation_on_next_save!
+    @m.save
+    DB.sqls.must_equal ['UPDATE people SET x = 6 WHERE (id = 4)']
+  end
+
+  it "should not skip future validations if the skip_validation_on_save! method is used" do
+    @m.wont_be :valid?
+    @m.skip_validation_on_next_save!
+    @m.save
+    DB.sqls.must_equal ['UPDATE people SET x = 6 WHERE (id = 4)']
+    proc{@m.save}.must_raise Sequel::ValidationFailed
+
+    @m.skip_validation_on_next_save!
+    @m.save
+    DB.sqls.must_equal ['UPDATE people SET x = 6 WHERE (id = 4)']
+  end
+
+  it "should skip validations if the skip_validation_on_save! method is used and :validate=>true option is used" do
+    @m.wont_be :valid?
+    @m.skip_validation_on_next_save!
+    @m.save(:validate=>true)
+    DB.sqls.must_equal ['UPDATE people SET x = 6 WHERE (id = 4)']
+  end
+
   it "should raise error if validations fail and raise_on_save_failure is true" do
     begin
       @m.save

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sequel
 version: !ruby/object:Gem::Version
-  version: 5.14.0
+  version: 5.15.0
 platform: ruby
 authors:
 - Jeremy Evans
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-11-01 00:00:00.000000000 Z
+date: 2018-12-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest
@@ -131,8 +131,8 @@ extra_rdoc_files:
 - doc/schema_modification.rdoc
 - doc/sharding.rdoc
 - doc/testing.rdoc
-- doc/transactions.rdoc
 - doc/validations.rdoc
+- doc/transactions.rdoc
 - doc/release_notes/4.0.0.txt
 - doc/release_notes/4.1.0.txt
 - doc/release_notes/4.10.0.txt
@@ -198,6 +198,7 @@ extra_rdoc_files:
 - doc/release_notes/5.12.0.txt
 - doc/release_notes/5.13.0.txt
 - doc/release_notes/5.14.0.txt
+- doc/release_notes/5.15.0.txt
 files:
 - CHANGELOG
 - MIT-LICENSE
@@ -282,6 +283,7 @@ files:
 - doc/release_notes/5.12.0.txt
 - doc/release_notes/5.13.0.txt
 - doc/release_notes/5.14.0.txt
+- doc/release_notes/5.15.0.txt
 - doc/release_notes/5.2.0.txt
 - doc/release_notes/5.3.0.txt
 - doc/release_notes/5.4.0.txt