sequel 5.19.0 → 5.20.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 96bc5f24c2b61f558037958fedfa152895eaef5e66b50999e7da139763bf0436
-  data.tar.gz: c8376d13d1204c5c2ba969ed18d60c72fdbabd3dd9a7aa8c7729240b33678e84
+  metadata.gz: e092b5439a78eec1bb50a0bbc8a62c1d84ee5b27b9c5f034c250b632d03e17af
+  data.tar.gz: 231708d52405407b11113c55d5fdcd95e7d6155b0a8283f736876569ced6e4b1
 SHA512:
-  metadata.gz: 1f2153dde7f8e53f24ba06dcb45155ed822d3b2a25485d03dcda52df80e2fa35a0b8f42e08cb2854db838585992226a90830ce4b37ef89939c7cbbffbf308abe
-  data.tar.gz: af2107662ee35e87fa0089f1a66c8e621c5ab738ff53e1a35fbb7572c5137fae4bce53c2b716ec1b72b873a9415a4458eb96dd01e08be421a1b23f7d3fd4d111
+  metadata.gz: 4c2d7e19056e53f2d780f57f5da3c4675531f9678c6a54e922e0d59895bd2e485f12ee0b2644ed801c832a53653f75531d849cb7d60dcd9fb6a4edbfa8cb4c0b
+  data.tar.gz: 701b041185cc57c1966ea3b4be040e26a9e0aabfd6df45f0192f5b0b51133bfb94629f0634fa6edfc513a1c9193d455cb6222b388683d638e474b344e663ca50

data/CHANGELOG

@@ -1,3 +1,27 @@
+=== 5.20.0 (2019-05-01)
+
+* Fix reversing of alter_table add_foreign_key when :type option is used (jeremyevans) (#1615)
+
+* Switch from using instance_exec to define_method for model associations and in some plugins (jeremyevans)
+
+* Fix Database#server_version when using mysql2 adapter with mysql driver on MariaDB 10+ database (v-kolesnikov) (#1614)
+
+* Make one_to_one setter method handle models that use joined datasets (jeremyevans) (#1612)
+
+* Make auto_validations plugin work with the class_table_inheritance plugin (jeremyevans) (#1611)
+
+* Avoid use of instance_exec for PlaceholderLiteralString#with_dataset (jeremyevans)
+
+* Recognize float unsigned database types as float (keeguon, jeremyevans) (#1609)
+
+* Support :savepoint options to Database#{after_commit,after_rollback} for making the hooks handle savepoints (jeremyevans)
+
+* Avoid use of instance_exec in association_dependencies plugin (jeremyevans)
+
+* Add pg_auto_constraint_validation_override to the pg_auto_constraint_validations plugin, for customizing columns and error message per constraint (jeremyevans)
+
+* Make Database#check_constraints on PostgreSQL also include constraints where the related columns are not known (jeremyevans)
+
 === 5.19.0 (2019-04-02)
 
 * Use more optimized approach to merging hashes in ruby 2.5+ (jeremyevans)

data/doc/release_notes/5.20.0.txt

@@ -0,0 +1,89 @@
+= New Features
+
+* Database#after_commit and #after_rollback transaction hook methods
+  now support a :savepoint option.  Using the :savepoint option makes
+  the hooks savepoint-aware, so after_commit will only be called if
+  all enclosing savepoints and the transaction are committed, and
+  after_rollback will be called when any of the enclosing savepoints
+  are rolled back (which may be before transaction commit/rollback).
+  Examples:
+
+    x = nil
+    DB.transaction do # BEGIN
+      DB.transaction(savepoint: true) do # SAVEPOINT
+        DB.after_commit(savepoint: true){x = 1}
+        DB.after_rollback(savepoint: true){x = 2}
+        x # nil
+      end # RELEASE SAVEPOINT
+      x # nil
+    end # COMMIT
+    x # 1
+
+    x = nil
+    DB.transaction do  # BEGIN
+      DB.transaction(savepoint: true) do # SAVEPOINT
+        DB.after_commit(savepoint: true){x = 1}
+        DB.after_rollback(savepoint: true){x = 2}
+        x # nil
+        raise Sequel::Rollback
+      end # ROLLBACK TO SAVEPOINT
+      x # 2
+    end # COMMIT
+    x # 2
+  
+    x = nil
+    DB.transaction do # BEGIN
+      DB.transaction(savepoint: true) do # SAVEPOINT
+        DB.after_commit(savepoint: true){x = 1}
+        DB.after_rollback(savepoint: true){x = 2}
+      end # RELEASE SAVEPOINT
+      x # nil
+      raise Sequel::Rollback
+    end
+    x # 2
+
+* The pg_auto_constraint_validations plugin now supports a
+  pg_auto_constraint_validation_override method for overriding
+  the columns and message for a specific constraint.  This is
+  useful if the database cannot determine the columns (due
+  to the constraint containing a database function call), or
+  if you would like to customize the message per constraint.
+
+= Other Improvements
+
+* The one_to_one association setter now works with models that use
+  joined datasets, such as child models when using the
+  class_table_inheritance plugin.
+
+* Database#check_constraints on PostgreSQL now also includes CHECK
+  constraints where the related columns are not known.  The :columns
+  entry in the hash will be an empty array in such cases.  The
+  exclusion of such constraints in previous versions was not
+  intentional, and the documentation implied that all CHECK
+  constraints were returned.
+
+* Many cases where instance_exec was previously used on model
+  instances have been changed so that instance methods are defined
+  and called instead.  This avoids the creation of singleton classes
+  for model instances, and can significantly improve performance in
+  some cases.  This affects all associations as well as the
+  following plugins:
+
+  * composition
+  * hook_class_methods
+  * validation_class_methods
+
+  Other cases where instance_exec is now avoided and a different
+  approach is used:
+
+  * association_dependencies plugin
+  * PlaceholderLiteralString#with_dataset
+
+* The auto_validations plugin now works with child models when using
+  the class_table_inheritance plugin.
+
+* Database#server_version now works correctly in the mysql2 adapter
+  when using the MySQL driver with MariaDB 10+.
+
+* The float unsigned type is now recognized and supported in the
+  schema parser and schema_dumper extension.

data/doc/transactions.rdoc

@@ -169,6 +169,44 @@ If you want the current savepoint and potentially enclosing savepoints to be rol
     end # ROLLBACK TO SAVEPOINT
   end # ROLLBACK
 
+=== Savepoint Hooks
+
+When using savepoints, you can use the +:savepoint+ option to +after_commit+ or +after_rollback+ to use a savepoint hook.  For +after_commit+, this will only run the hook after transaction commit if all enclosing savepoints are released (not rolled back). For +after_rollback+, this will run the hook after any enclosing savepoint is rolled back (before transaction commit), or after the transaction is rolled back if all enclosing savepoints are released:
+
+  x = nil
+  DB.transaction do # BEGIN
+    DB.transaction(savepoint: true) do # SAVEPOINT
+      DB.after_commit(savepoint: true){x = 1}
+      DB.after_rollback(savepoint: true){x = 2}
+      x # nil
+    end # RELEASE SAVEPOINT
+    x # nil
+  end # COMMIT
+  x # 1
+  
+  x = nil
+  DB.transaction do  # BEGIN
+    DB.transaction(savepoint: true) do # SAVEPOINT
+      DB.after_commit(savepoint: true){x = 1}
+      DB.after_rollback(savepoint: true){x = 2}
+      x # nil
+      raise Sequel::Rollback
+    end # ROLLBACK TO SAVEPOINT
+    x # 2
+  end # COMMIT
+  x # 2
+  
+  x = nil
+  DB.transaction do # BEGIN
+    DB.transaction(savepoint: true) do # SAVEPOINT
+      DB.after_commit(savepoint: true){x = 1}
+      DB.after_rollback(savepoint: true){x = 2}
+    end # RELEASE SAVEPOINT
+    x # nil
+    raise Sequel::Rollback
+  end
+  x # 2
+
 == Prepared Transactions / Two-Phase Commit
 
 Sequel supports database prepared transactions on PostgreSQL, MySQL, and H2.  With prepared transactions, at the end of the transaction, the transaction is not immediately committed (it acts like a rollback).  Later, you can call +commit_prepared_transaction+ to commit the transaction or +rollback_prepared_transaction+ to roll the transaction back.  Prepared transactions are usually used with distributed databases to make sure all databases commit the same transaction or none of them do.

data/lib/sequel/adapters/mysql2.rb

@@ -78,8 +78,8 @@ module Sequel
       end
 
       # Return the version of the MySQL server to which we are connecting.
-      def server_version(server=nil)
-        @server_version ||= (synchronize(server){|conn| conn.server_info[:id]} || super)
+      def server_version(_server=nil)
+        @server_version ||= super()
       end
 
       private

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

@@ -220,24 +220,22 @@ module Sequel
       # A hash of metadata for CHECK constraints on the table.
       # Keys are CHECK constraint name symbols.  Values are hashes with the following keys:
       # :definition :: An SQL fragment for the definition of the constraint
-      # :columns :: An array of column symbols for the columns referenced in the constraint
+      # :columns :: An array of column symbols for the columns referenced in the constraint,
+      #             can be an empty array if the database cannot deteremine the column symbols.
       def check_constraints(table)
         m = output_identifier_meth
 
         rows = metadata_dataset.
           from{pg_constraint.as(:co)}.
-          join(Sequel[:pg_attribute].as(:att), :attrelid=>:conrelid, :attnum=>SQL::Function.new(:ANY, Sequel[:co][:conkey])).
+          left_join(Sequel[:pg_attribute].as(:att), :attrelid=>:conrelid, :attnum=>SQL::Function.new(:ANY, Sequel[:co][:conkey])).
           where(:conrelid=>regclass_oid(table), :contype=>'c').
           select{[co[:conname].as(:constraint), att[:attname].as(:column), pg_get_constraintdef(co[:oid]).as(:definition)]}
 
         hash = {}
         rows.each do |row|
           constraint = m.call(row[:constraint])
-          if entry = hash[constraint]
-            entry[:columns] << m.call(row[:column])
-          else
-            hash[constraint] = {:definition=>row[:definition], :columns=>[m.call(row[:column])]}
-          end
+          entry = hash[constraint] ||= {:definition=>row[:definition], :columns=>[]}
+          entry[:columns] << m.call(row[:column]) if row[:column]
         end
         
         hash

data/lib/sequel/database/query.rb

@@ -331,7 +331,7 @@ module Sequel
         :time
       when /\A(bool(ean)?)\z/io
         :boolean
-      when /\A(real|float|double( precision)?|double\(\d+,\d+\)( unsigned)?)\z/io
+      when /\A(real|float( unsigned)?|double( precision)?|double\(\d+,\d+\)( unsigned)?)\z/io
         :float
       when /\A(?:(?:(?:num(?:ber|eric)?|decimal)(?:\(\d+,\s*(\d+|false|true)\))?))\z/io
         $1 && ['0', 'false'].include?($1) ? :integer : :decimal

data/lib/sequel/database/schema_generator.rb

@@ -634,7 +634,7 @@ module Sequel
 
       # Drop a composite foreign key constraint
       def drop_composite_foreign_key(columns, opts)
-        @operations << {:op => :drop_constraint, :type => :foreign_key, :columns => columns}.merge!(opts)
+        @operations << opts.merge(:op => :drop_constraint, :type => :foreign_key, :columns => columns)
         nil
       end
     end

data/lib/sequel/database/transactions.rb

@@ -25,13 +25,19 @@ module Sequel
     # Otherwise, add the block to the list of blocks to call after the currently
     # in progress transaction commits (and only if it commits).
     # Options:
+    # :savepoint :: If currently inside a savepoint, only run this hook on transaction
+    #               commit if all enclosing savepoints have been released.
     # :server :: The server/shard to use.
     def after_commit(opts=OPTS, &block)
       raise Error, "must provide block to after_commit" unless block
       synchronize(opts[:server]) do |conn|
         if h = _trans(conn)
           raise Error, "cannot call after_commit in a prepared transaction" if h[:prepare]
-          add_transaction_hook(conn, :after_commit, block)
+          if opts[:savepoint] && in_savepoint?(conn)
+            add_savepoint_hook(conn, :after_commit, block)
+          else
+            add_transaction_hook(conn, :after_commit, block)
+          end
         else
           yield
         end
@@ -42,13 +48,20 @@ module Sequel
     # Otherwise, add the block to the list of the blocks to call after the currently
     # in progress transaction rolls back (and only if it rolls back).
     # Options:
+    # :savepoint :: If currently inside a savepoint, run this hook immediately when
+    #               any enclosing savepoint is rolled back, which may be before the transaction
+    #               commits or rollsback.
     # :server :: The server/shard to use.
     def after_rollback(opts=OPTS, &block)
       raise Error, "must provide block to after_rollback" unless block
       synchronize(opts[:server]) do |conn|
         if h = _trans(conn)
           raise Error, "cannot call after_rollback in a prepared transaction" if h[:prepare]
-          add_transaction_hook(conn, :after_rollback, block)
+          if opts[:savepoint] && in_savepoint?(conn)
+            add_savepoint_hook(conn, :after_rollback, block)
+          else
+            add_transaction_hook(conn, :after_rollback, block)
+          end
         end
       end
     end
@@ -298,6 +311,13 @@ module Sequel
       Sequel.synchronize{@transactions[conn] = hash}
     end    
 
+    # Set the given callable as a hook to be called. Type should be either
+    # :after_commit or :after_rollback.
+    def add_savepoint_hook(conn, type, block)
+      savepoint = _trans(conn)[:savepoints].last
+      (savepoint[type] ||= []) << block
+    end
+
     # Set the given callable as a hook to be called. Type should be either
     # :after_commit or :after_rollback.
     def add_transaction_hook(conn, type, block)
@@ -401,6 +421,14 @@ module Sequel
       supports_savepoints? && savepoint_level(conn) > 1
     end
 
+    # Retrieve the savepoint hooks that should be run for the given
+    # connection and commit status.
+    def savepoint_hooks(conn, committed)
+      if in_savepoint?(conn)
+        _trans(conn)[:savepoints].last[committed ? :after_commit : :after_rollback]
+      end
+    end
+
     # Retrieve the transaction hooks that should be run for the given
     # connection and commit status.
     def transaction_hooks(conn, committed)
@@ -411,16 +439,40 @@ module Sequel
 
     # Remove the current thread from the list of active transactions
     def remove_transaction(conn, committed)
-      callbacks = transaction_hooks(conn, committed)
+      if in_savepoint?(conn)
+        savepoint_callbacks = savepoint_hooks(conn, committed)
+        if committed
+          savepoint_rollback_callbacks = savepoint_hooks(conn, false)
+        end
+      else
+        callbacks = transaction_hooks(conn, committed)
+      end
 
       if transaction_finished?(conn)
         h = _trans(conn)
         rolled_back = !committed
         Sequel.synchronize{h[:rolled_back] = rolled_back}
         Sequel.synchronize{@transactions.delete(conn)}
+        callbacks.each(&:call) if callbacks
+      elsif savepoint_callbacks || savepoint_rollback_callbacks
+        if committed
+          meth = in_savepoint?(conn) ? :add_savepoint_hook : :add_transaction_hook 
+
+          if savepoint_callbacks
+            savepoint_callbacks.each do |block|
+              send(meth, conn, :after_commit, block)
+            end
+          end
+          
+          if savepoint_rollback_callbacks
+            savepoint_rollback_callbacks.each do |block|
+              send(meth, conn, :after_rollback, block)
+            end
+          end
+        else
+          savepoint_callbacks.each(&:call)
+        end
       end
-
-      callbacks.each(&:call) if callbacks
     end
 
     # SQL to rollback to a savepoint

data/lib/sequel/dataset/placeholder_literalizer.rb

@@ -170,7 +170,10 @@ module Sequel
       # receiver's dataset to the block, and the block should return the new dataset
       # to use.
       def with_dataset
-        dup.instance_exec{@dataset = yield @dataset; self}.freeze
+        dataset = yield @dataset
+        other = dup
+        other.instance_variable_set(:@dataset, dataset)
+        other.freeze
       end
 
       # Return an array of all objects by running the SQL query for the given arguments.

data/lib/sequel/dataset/query.rb

@@ -1091,7 +1091,7 @@ module Sequel
     #   #   SELECT i1.id, i1.parent_id FROM i1 INNER JOIN t ON (t.id = i1.parent_id)
     #   # ) SELECT * FROM t
     def with_recursive(name, nonrecursive, recursive, opts=OPTS)
-      raise(Error, 'This datatset does not support common table expressions') unless supports_cte?
+      raise(Error, 'This dataset does not support common table expressions') unless supports_cte?
       if hoist_cte?(nonrecursive)
         s, ds = hoist_cte(nonrecursive)
         s.with_recursive(name, ds, recursive, opts)

data/lib/sequel/extensions/schema_dumper.rb

@@ -37,7 +37,7 @@ module Sequel
         {:type =>schema[:type] == :boolean ? TrueClass : Integer}
       when /\Abigint(?:\((?:\d+)\))?(?: unsigned)?\z/
         {:type=>:Bignum}
-      when /\A(?:real|float|double(?: precision)?|double\(\d+,\d+\)(?: unsigned)?)\z/
+      when /\A(?:real|float(?: unsigned)?|double(?: precision)?|double\(\d+,\d+\)(?: unsigned)?)\z/
         {:type=>Float}
       when 'boolean', 'bit', 'bool'
         {:type=>TrueClass}

data/lib/sequel/model/associations.rb

@@ -1617,9 +1617,10 @@ module Sequel
         #                is hash or array of two element arrays.  Consider also specifying the :graph_block
         #                option if the value for this option is not a hash or array of two element arrays
         #                and you plan to use this association in eager_graph or association_join.
-        # :dataset :: A proc that is instance_execed to get the base dataset to use (before the other
+        # :dataset :: A proc that is used to define the method to get the base dataset to use (before the other
         #             options are applied).  If the proc accepts an argument, it is passed the related
-        #             association reflection.
+        #             association reflection.  It is a best practice to always have the dataset accept an argument
+        #             and use the argument to return the appropriate dataset.
         # :distinct :: Use the DISTINCT clause when selecting associating object, both when
         #              lazy loading and eager loading via .eager (but not when using .eager_graph).
         # :eager :: The associations to eagerly load via +eager+ when loading the associated object(s).
@@ -1909,7 +1910,7 @@ module Sequel
         # can be easily overridden in the class itself while allowing for
         # super to be called.
         def association_module_def(name, opts=OPTS, &block)
-          association_module(opts).module_eval{define_method(name, &block)}
+          association_module(opts).send(:define_method, name, &block)
         end
       
         # Add a private method to the module included in the class.
@@ -1944,6 +1945,13 @@ module Sequel
           end
 
           association_module_def(opts.dataset_method, opts){_dataset(opts)}
+          if opts[:block]
+            opts[:block_method] = Plugins.def_sequel_method(association_module(opts), "#{opts[:name]}_block", 1, &opts[:block])
+          end
+          if opts[:dataset]
+            opts[:dataset_opt_arity] = opts[:dataset].arity == 0 ? 0 : 1
+            opts[:dataset_opt_method] = Plugins.def_sequel_method(association_module(opts), "#{opts[:name]}_dataset_opt", opts[:dataset_opt_arity], &opts[:dataset])
+          end
           def_association_method(opts)
 
           return if opts[:read_only]
@@ -2204,12 +2212,28 @@ module Sequel
           if one_to_one
             opts[:setter] ||= proc do |o|
               up_ds = _apply_association_options(opts, opts.associated_dataset.where(cks.zip(cpks.map{|k| get_column_value(k)})))
+
+              if (froms = up_ds.opts[:from]) && (from = froms[0]) && (from.is_a?(Sequel::Dataset) || (from.is_a?(Sequel::SQL::AliasedExpression) && from.expression.is_a?(Sequel::Dataset)))
+                if old = up_ds.first
+                  cks.each{|k| old.set_column_value(:"#{k}=", nil)}
+                end
+                save_old = true
+              end
+
               if o
-                up_ds = up_ds.exclude(o.pk_hash) unless o.new?
+                if !o.new? && !save_old
+                  up_ds = up_ds.exclude(o.pk_hash)
+                end
                 cks.zip(cpks).each{|k, pk| o.set_column_value(:"#{k}=", get_column_value(pk))}
               end
+
               checked_transaction do
-                up_ds.skip_limit_check.update(ck_nil_hash)
+                if save_old
+                  old.save(save_opts) || raise(Sequel::Error, "invalid previously associated object, cannot save") if old
+                else
+                  up_ds.skip_limit_check.update(ck_nil_hash)
+                end
+
                 o.save(save_opts) || raise(Sequel::Error, "invalid associated object, cannot save") if o
               end
             end
@@ -2287,7 +2311,8 @@ module Sequel
           end
           ds = ds.clone(:model_object => self)
           ds = ds.eager_graph(opts[:eager_graph]) if opts[:eager_graph] && opts.eager_graph_lazy_dataset?
-          ds = instance_exec(ds, &opts[:block]) if opts[:block]
+          # block method is private
+          ds = send(opts[:block_method], ds) if opts[:block_method]
           ds
         end
 
@@ -2310,10 +2335,11 @@ module Sequel
         # Return an association dataset for the given association reflection
         def _dataset(opts)
           raise(Sequel::Error, "model object #{inspect} does not have a primary key") if opts.dataset_need_primary_key? && !pk
-          ds = if opts[:dataset].arity == 1
-            instance_exec(opts, &opts[:dataset])
+          ds = if opts[:dataset_opt_arity] == 1
+            # dataset_opt_method is private
+            send(opts[:dataset_opt_method], opts)
           else
-            instance_exec(&opts[:dataset])
+            send(opts[:dataset_opt_method])
           end
           _apply_association_options(opts, ds)
         end