sequel 5.18.0 → 5.20.0

data/lib/sequel/connection_pool.rb

@@ -90,11 +90,6 @@ class Sequel::ConnectionPool
   #                   connection object (and server argument if the callable accepts 2 arguments),
   #                   useful for customizations that you want to apply to all connections.
   # :connect_sqls :: An array of sql strings to execute on each new connection, after :after_connect runs.
-  # :preconnect :: Automatically create the maximum number of connections, so that they don't
-  #                need to be created as needed.  This is useful when connecting takes a long time
-  #                and you want to avoid possible latency during runtime.
-  #                Set to :concurrently to create the connections in separate threads. Otherwise
-  #                they'll be created sequentially.
   def initialize(db, opts=OPTS)
     @db = db
     @after_connect = opts[:after_connect]

data/lib/sequel/database/misc.rb

@@ -106,8 +106,11 @@ module Sequel
     # :log_connection_info :: Whether connection information should be logged when logging queries.
     # :log_warn_duration :: The number of elapsed seconds after which queries should be logged at warn level.
     # :name :: A name to use for the Database object, displayed in PoolTimeout .
-    # :preconnect :: Whether to setup the maximum number of connections during initialization.
-    #                Can use a value of 'concurrently' to preconnect in separate threads.
+    # :preconnect :: Automatically create the maximum number of connections, so that they don't
+    #                need to be created as needed.  This is useful when connecting takes a long time
+    #                and you want to avoid possible latency during runtime.
+    #                Set to :concurrently to create the connections in separate threads. Otherwise
+    #                they'll be created sequentially.
     # :preconnect_extensions :: Similar to the :extensions option, but loads the extensions before the
     #                           connections are made by the :preconnect option.
     # :quote_identifiers :: Whether to quote identifiers.
@@ -115,7 +118,9 @@ module Sequel
     # :single_threaded :: Whether to use a single-threaded connection pool.
     # :sql_log_level :: Method to use to log SQL to a logger, :info by default.
     #
-    # All options given are also passed to the connection pool.
+    # All options given are also passed to the connection pool.  Additional options respected by
+    # the connection pool are :after_connect, :connect_sqls, :max_connections, :pool_timeout,
+    # :servers, and :servers_hash.  See the connection pool documentation for details.
     def initialize(opts = OPTS)
       @opts ||= opts
       @opts = connection_pool_default_options.merge(@opts)
@@ -473,9 +478,7 @@ module Sequel
     
     if RUBY_VERSION >= '2.4'
       # Typecast a string to a BigDecimal
-      def _typecast_value_string_to_decimal(value)
-        BigDecimal(value)
-      end
+      alias _typecast_value_string_to_decimal BigDecimal
     else
       # :nocov:
       def _typecast_value_string_to_decimal(value)
@@ -510,9 +513,7 @@ module Sequel
     end
 
     # Typecast the value to a Float
-    def typecast_value_float(value)
-      Float(value)
-    end
+    alias typecast_value_float Float
 
     # Typecast the value to an Integer
     def typecast_value_integer(value)

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/actions.rb

@@ -18,7 +18,7 @@ module Sequel
       where_all where_each where_single_value
     METHS
 
-    # The clone options to use when retriveing columns for a dataset.
+    # The clone options to use when retrieving columns for a dataset.
     COLUMNS_CLONE_OPTIONS = {:distinct => nil, :limit => 1, :offset=>nil, :where=>nil, :having=>nil, :order=>nil, :row_proc=>nil, :graph=>nil, :eager_graph=>nil}.freeze
 
     # Inserts the given argument into the database.  Returns self so it
@@ -358,7 +358,7 @@ module Sequel
 
     # Inserts values into the associated table.  The returned value is generally
     # the value of the autoincremented primary key for the inserted row, assuming that
-    # the a single row is inserted and the table has an autoincrementing primary key.
+    # a single row is inserted and the table has an autoincrementing primary key.
     #
     # +insert+ handles a number of different argument formats:
     # no arguments or single empty hash :: Uses DEFAULT VALUES
@@ -486,7 +486,7 @@ module Sequel
       import(columns, hashes.map{|h| columns.map{|c| h[c]}}, opts)
     end
 
-    # Yields each row in the dataset, but interally uses multiple queries as needed to
+    # Yields each row in the dataset, but internally uses multiple queries as needed to
     # process the entire result set without keeping all rows in the dataset in memory,
     # even if the underlying driver buffers all query results in memory.
     #
@@ -512,7 +512,7 @@ module Sequel
     #              NULLs.  Note that some Sequel adapters have optimized implementations that will
     #              use cursors or streaming regardless of the :strategy option used.
     # :filter_values :: If the strategy: :filter option is used, this option should be a proc
-    #                   that accepts the last retreived row for the previous page and an array of
+    #                   that accepts the last retrieved row for the previous page and an array of
     #                   ORDER BY expressions, and returns an array of values relating to those
     #                   expressions for the last retrieved row.  You will need to use this option
     #                   if your ORDER BY expressions are not simple columns, if they contain
@@ -971,7 +971,8 @@ module Sequel
     # separate insert commands for each row.  Otherwise, call #multi_insert_sql
     # and execute each statement it gives separately.
     def _import(columns, values, opts)
-      trans_opts = Hash[opts].merge!(:server=>@opts[:server])
+      trans_opts = Hash[opts]
+      trans_opts[:server] = @opts[:server]
       if opts[:return] == :primary_key
         @db.transaction(trans_opts){values.map{|v| insert(columns, v)}}
       else

data/lib/sequel/dataset/graph.rb

@@ -21,7 +21,7 @@ module Sequel
         raise Error, "cannot call add_graph_aliases on a dataset that has not been called with graph or set_graph_aliases"
       end
       columns, graph_aliases = graph_alias_columns(graph_aliases)
-      select_append(*columns).clone(:graph => Hash[graph].merge!(:column_aliases=>Hash[ga].merge!(graph_aliases).freeze).freeze)
+      select_append(*columns).clone(:graph => graph.merge(:column_aliases=>ga.merge(graph_aliases).freeze).freeze)
     end
 
     # Similar to Dataset#join_table, but uses unambiguous aliases for selected
@@ -244,7 +244,7 @@ module Sequel
     def set_graph_aliases(graph_aliases)
       columns, graph_aliases = graph_alias_columns(graph_aliases)
       if graph = opts[:graph]
-        select(*columns).clone(:graph => Hash[graph].merge!(:column_aliases=>graph_aliases.freeze).freeze)
+        select(*columns).clone(:graph => graph.merge(:column_aliases=>graph_aliases.freeze).freeze)
       else
         raise Error, "cannot call #set_graph_aliases on an ungraphed dataset"
       end

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/prepared_statements.rb

@@ -329,7 +329,7 @@ module Sequel
     #   # => {:id=>1}
     def bind(bind_vars=OPTS)
       bind_vars = if bv = @opts[:bind_vars]
-        Hash[bv].merge!(bind_vars).freeze
+        bv.merge(bind_vars).freeze
       else
         if bind_vars.frozen?
           bind_vars

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/constraint_validations.rb

@@ -130,6 +130,10 @@
 #   readd all constraints you want to use inside the alter table block,
 #   making no other changes inside the alter_table block.
 #
+# Dropping a table will automatically delete all constraint validations for
+# that table.  However, altering a table (e.g. to drop a column) will not
+# currently make any changes to the constraint validations metadata.
+#
 # Related module: Sequel::ConstraintValidations
 
 #
@@ -264,6 +268,16 @@ module Sequel
       end
     end
 
+    # Drop all constraint validations for a table if dropping the table.
+    def drop_table(*names)
+      names.each do |name|
+        if !name.is_a?(Hash) && table_exists?(constraint_validations_table)
+          drop_constraint_validations_for(:table=>name)
+        end
+      end
+      super
+    end
+
     # Drop the constraint validations table.
     def drop_constraint_validations_table
       drop_table(constraint_validations_table)

data/lib/sequel/extensions/pg_enum.rb

@@ -17,6 +17,12 @@
 #
 #   DB.rename_enum(:enum_type_name, :enum_type_another_name)
 #
+# If you want to rename an enum value, you can use rename_enum_value:
+#
+#   DB.rename_enum_value(
+#     :enum_type_name, :enum_value_name, :enum_value_another_name
+#   )
+#
 # If you want to drop an enum type, you can use drop_enum:
 #
 #   DB.drop_enum(:enum_type_name)
@@ -86,26 +92,24 @@ module Sequel
         elsif v = opts[:after]
           sql << " AFTER #{literal(v.to_s)}"
         end
-        run sql
-        parse_enum_labels
-        nil
+        _process_enum_change_sql(sql)
       end
 
       # Run the SQL to create an enum type with the given name and values.
       def create_enum(enum, values)
-        sql = "CREATE TYPE #{quote_schema_table(enum)} AS ENUM (#{values.map{|v| literal(v.to_s)}.join(', ')})"
-        run sql
-        parse_enum_labels
-        nil
+        _process_enum_change_sql("CREATE TYPE #{quote_schema_table(enum)} AS ENUM (#{values.map{|v| literal(v.to_s)}.join(', ')})")
       end
 
       # Run the SQL to rename the enum type with the given name
       # to the another given name.
       def rename_enum(enum, new_name)
-        sql = "ALTER TYPE #{quote_schema_table(enum)} RENAME TO #{quote_schema_table(new_name)}"
-        run sql
-        parse_enum_labels
-        nil
+        _process_enum_change_sql("ALTER TYPE #{quote_schema_table(enum)} RENAME TO #{quote_schema_table(new_name)}")
+      end
+
+      # Run the SQL to rename the enum value with the given name
+      # to the another given name.
+      def rename_enum_value(enum, old_name, new_name)
+        _process_enum_change_sql("ALTER TYPE #{quote_schema_table(enum)} RENAME VALUE #{literal(old_name.to_s)} TO #{literal(new_name.to_s)}")
       end
 
       # Run the SQL to drop the enum type with the given name.
@@ -113,14 +117,18 @@ module Sequel
       # :if_exists :: Do not raise an error if the enum type does not exist
       # :cascade :: Also drop other objects that depend on the enum type
       def drop_enum(enum, opts=OPTS)
-        sql = "DROP TYPE#{' IF EXISTS' if opts[:if_exists]} #{quote_schema_table(enum)}#{' CASCADE' if opts[:cascade]}"
-        run sql
-        parse_enum_labels
-        nil
+        _process_enum_change_sql("DROP TYPE#{' IF EXISTS' if opts[:if_exists]} #{quote_schema_table(enum)}#{' CASCADE' if opts[:cascade]}")
       end
 
       private
 
+      # Run the SQL on the database, reparsing the enum labels after it is run.
+      def _process_enum_change_sql(sql)
+        run(sql)
+        parse_enum_labels
+        nil
+      end
+
       # Parse the pg_enum table to get enum values, and
       # the pg_type table to get names and array oids for
       # enums.

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]
@@ -2129,7 +2137,7 @@ module Sequel
           graph_cks = opts[:graph_keys]
           opts[:eager_grapher] ||= proc do |eo|
             ds = eo[:self]
-            ds.graph(eager_graph_dataset(opts, eo), use_only_conditions ? only_conditions : opts.primary_keys.zip(graph_cks) + conditions, Hash[eo].merge!(:select=>select, :join_type=>eo[:join_type]||join_type, :qualify=>:deep, :from_self_alias=>eo[:from_self_alias]), &graph_block)
+            ds.graph(eager_graph_dataset(opts, eo), use_only_conditions ? only_conditions : opts.primary_keys.zip(graph_cks) + conditions, eo.merge(:select=>select, :join_type=>eo[:join_type]||join_type, :qualify=>:deep), &graph_block)
           end
       
           return if opts[:read_only]
@@ -2189,7 +2197,7 @@ module Sequel
           graph_block = opts[:graph_block]
           opts[:eager_grapher] ||= proc do |eo|
             ds = eo[:self]
-            ds = ds.graph(opts.apply_eager_graph_limit_strategy(eo[:limit_strategy], eager_graph_dataset(opts, eo)), use_only_conditions ? only_conditions : cks.zip(pkcs) + conditions, Hash[eo].merge!(:select=>select, :join_type=>eo[:join_type]||join_type, :qualify=>:deep, :from_self_alias=>eo[:from_self_alias]), &graph_block)
+            ds = ds.graph(opts.apply_eager_graph_limit_strategy(eo[:limit_strategy], eager_graph_dataset(opts, eo)), use_only_conditions ? only_conditions : cks.zip(pkcs) + conditions, eo.merge(:select=>select, :join_type=>eo[:join_type]||join_type, :qualify=>:deep), &graph_block)
             # We only load reciprocals for one_to_many associations, as other reciprocals don't make sense
             ds.opts[:eager_graph][:reciprocals][eo[:table_alias]] = opts.reciprocal
             ds
@@ -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
@@ -2908,7 +2934,7 @@ module Sequel
         def eager(*associations)
           opts = @opts[:eager]
           association_opts = eager_options_for_associations(associations)
-          opts = opts ? Hash[opts].merge!(association_opts) : association_opts
+          opts = opts ? opts.merge(association_opts) : association_opts
           clone(:eager=>opts.freeze)
         end