sequel 5.8.0 → 5.38.0

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,17 +48,65 @@ 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
-    
+
+    # When exiting the transaction block through methods other than an exception
+    # (e.g. normal exit, non-local return, or throw), set the current transaction
+    # to rollback instead of committing.  This is designed for use in cases where
+    # you want to preform a non-local return but also want to rollback instead of
+    # committing.
+    # Options:
+    # :cancel :: Cancel the current rollback_on_exit setting, so exiting will commit instead
+    #            of rolling back.
+    # :savepoint :: Rollback only the current savepoint if inside a savepoint.
+    #               Can also be an positive integer value to rollback that number of enclosing savepoints,
+    #               up to and including the transaction itself.
+    #               If the database does not support savepoints, this option is ignored and the entire
+    #               transaction is affected.
+    # :server :: The server/shard the transaction is being executed on.
+    def rollback_on_exit(opts=OPTS)
+      synchronize(opts[:server]) do |conn|
+        raise Error, "Cannot call Sequel:: Database#rollback_on_exit! unless inside a transaction" unless h = _trans(conn)
+        rollback = !opts[:cancel]
+
+        if supports_savepoints?
+          savepoints = h[:savepoints]
+
+          if level = opts[:savepoint]
+            level = 1 if level == true
+            raise Error, "invalid :savepoint option to Database#rollback_on_exit: #{level.inspect}" unless level.is_a?(Integer)
+            raise Error, "cannot pass nonpositive integer (#{level.inspect}) as :savepoint option to Database#rollback_on_exit" if level < 1
+            level.times do |i|
+              break unless savepoint = savepoints[-1 - i]
+              savepoint[:rollback_on_exit] = rollback
+            end
+          else
+            savepoints[0][:rollback_on_exit] = rollback
+          end
+        else
+          h[:rollback_on_exit] = rollback
+        end
+      end
+
+      nil
+    end
+
     # Return true if already in a transaction given the options,
     # false otherwise.  Respects the :server option for selecting
     # a shard.
@@ -88,7 +142,7 @@ module Sequel
     # :num_retries :: The number of times to retry if the :retry_on option is used.
     #                 The default is 5 times.  Can be set to nil to retry indefinitely,
     #                 but that is not recommended.
-    # :before_retry :: Proc to execute before rertrying if the :retry_on option is used.
+    # :before_retry :: Proc to execute before retrying if the :retry_on option is used.
     #                  Called with two arguments: the number of retry attempts (counting
     #                  the current one) and the error the last attempt failed with.
     # :prepare :: A string to use as the transaction identifier for a
@@ -100,7 +154,7 @@ module Sequel
     #              Note that this should not be used unless the entire transaction
     #              block is idempotent, as otherwise it can cause non-idempotent
     #              behavior to execute multiple times.
-    # :rollback :: Can the set to :reraise to reraise any Sequel::Rollback exceptions
+    # :rollback :: Can be set to :reraise to reraise any Sequel::Rollback exceptions
     #              raised, or :always to always rollback even if no exceptions occur
     #              (useful for testing).
     # :server :: The server to use for the transaction. Set to :default, :read_only, or
@@ -124,19 +178,15 @@ module Sequel
       opts = Hash[opts]
       if retry_on = opts[:retry_on]
         tot_retries = opts.fetch(:num_retries, 5)
-        num_retries = 0 unless tot_retries.nil?
+        num_retries = 0
         begin
           opts[:retry_on] = nil
           opts[:retrying] = true
           transaction(opts, &block)
         rescue *retry_on => e
-          if num_retries
-            num_retries += 1
-            if num_retries <= tot_retries
-              opts[:before_retry].call(num_retries, e) if opts[:before_retry]
-              retry
-            end
-          else
+          num_retries += 1
+          if tot_retries.nil? || num_retries <= tot_retries
+            opts[:before_retry].call(num_retries, e) if opts[:before_retry]
             retry
           end
           raise
@@ -155,6 +205,10 @@ module Sequel
             end
           end
 
+          if opts[:savepoint] && !supports_savepoints?
+            raise Sequel::InvalidOperation, "savepoints not supported on #{database_type}"
+          end
+
           if already_in_transaction?(conn, opts)
             if opts[:rollback] == :always && !opts.has_key?(:savepoint)
               if supports_savepoints? 
@@ -164,7 +218,7 @@ module Sequel
               end
             end
 
-            if opts[:savepoint] != false && (stack = _trans(conn)[:savepoints]) && stack.last
+            if opts[:savepoint] != false && (stack = _trans(conn)[:savepoints]) && stack.last[:auto_savepoint]
               opts[:savepoint] = true
             end
 
@@ -242,10 +296,10 @@ module Sequel
 
       if supports_savepoints?
         if t = _trans(conn)
-          t[:savepoints].push(opts[:auto_savepoint])
+          t[:savepoints].push({:auto_savepoint=>opts[:auto_savepoint]})
           return
         else
-          hash[:savepoints] = [opts[:auto_savepoint]]
+          hash[:savepoints] = [{:auto_savepoint=>opts[:auto_savepoint]}]
           if (prep = opts[:prepare]) && supports_prepared_transactions?
             hash[:prepare] = prep
           end
@@ -257,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)
@@ -293,12 +354,8 @@ module Sequel
 
     # Start a new database transaction or a new savepoint on the given connection.
     def begin_transaction(conn, opts=OPTS)
-      if supports_savepoints?
-        if savepoint_level(conn) > 1
-          begin_savepoint(conn, opts)
-        else
-          begin_new_transaction(conn, opts)
-        end
+      if in_savepoint?(conn)
+        begin_savepoint(conn, opts)
       else
         begin_new_transaction(conn, opts)
       end
@@ -318,7 +375,7 @@ module Sequel
       if exception
         false
       else
-        if Thread.current.status == 'aborting'
+        if rollback_on_transaction_exit?(conn, opts)
           rollback_transaction(conn, opts)
           false
         else
@@ -359,10 +416,22 @@ module Sequel
       []
     end
 
+    # Whether the connection is currently inside a savepoint.
+    def in_savepoint?(conn)
+      supports_savepoints? && savepoint_level(conn) > 1
+    end
+
+    # Retrieve the savepoint hooks that should be run for the given
+    # connection and commit status.  This expacts that you are
+    # already inside a savepoint when calling.
+    def savepoint_hooks(conn, committed)
+      _trans(conn)[:savepoints].last[committed ? :after_commit : :after_rollback]
+    end
+
     # Retrieve the transaction hooks that should be run for the given
     # connection and commit status.
     def transaction_hooks(conn, committed)
-      if !supports_savepoints? || savepoint_level(conn) == 1
+      unless in_savepoint?(conn)
         _trans(conn)[committed ? :after_commit : :after_rollback]
       end
     end
@@ -370,12 +439,36 @@ 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
+      end
 
       if transaction_finished?(conn)
-        h = @transactions[conn]
+        h = _trans(conn)
         rolled_back = !committed
         Sequel.synchronize{h[:rolled_back] = rolled_back}
         Sequel.synchronize{@transactions.delete(conn)}
+      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
@@ -386,6 +479,17 @@ module Sequel
       "ROLLBACK TO SAVEPOINT autopoint_#{depth}"
     end
 
+    # Whether to rollback the transaction when exiting the transaction.
+    def rollback_on_transaction_exit?(conn, opts)
+      return true if Thread.current.status == 'aborting'
+      h = _trans(conn)
+      if supports_savepoints?
+        h[:savepoints].last[:rollback_on_exit]
+      else
+        h[:rollback_on_exit]
+      end
+    end
+
     # Rollback the active transaction on the connection
     def rollback_transaction(conn, opts=OPTS)
       if supports_savepoints?

data/lib/sequel/dataset.rb

@@ -20,8 +20,10 @@ module Sequel
   #   old_posts = posts.where{stamp < Date.today - 7}
   #   davids_old_posts = davids_posts.where{stamp < Date.today - 7}
   #
-  # Datasets are Enumerable objects, so they can be manipulated using any
-  # of the Enumerable methods, such as map, inject, etc.
+  # Datasets are Enumerable objects, so they can be manipulated using many
+  # of the Enumerable methods, such as +map+ and +inject+.  Note that there are some methods
+  # that Dataset defines that override methods defined in Enumerable and result in different
+  # behavior, such as +select+ and +group_by+.
   #
   # For more information, see the {"Dataset Basics" guide}[rdoc-ref:doc/dataset_basics.rdoc].
   class Dataset

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
@@ -58,7 +58,8 @@ module Sequel
     #   # => 3
     #   DB[:table].avg{function(column)} # SELECT avg(function(column)) FROM table LIMIT 1
     #   # => 1
-    def avg(arg=Sequel.virtual_row(&Proc.new))
+    def avg(arg=(no_arg = true), &block)
+      arg = Sequel.virtual_row(&block) if no_arg
       _aggregate(:avg, arg)
     end
   
@@ -231,10 +232,11 @@ module Sequel
 
           return res
         end
+        where_args = args
         args = arg
       end
 
-      if loader = cached_placeholder_literalizer(:_first_cond_loader) do |pl|
+      if loader = cached_where_placeholder_literalizer(where_args||args, block, :_first_cond_loader) do |pl|
           _single_record_ds.where(pl.arg)
         end
 
@@ -331,6 +333,7 @@ module Sequel
     #                  after every 50 records.
     # :return :: When this is set to :primary_key, returns an array of
     #            autoincremented primary key values for the rows inserted.
+    #            This does not have an effect if +values+ is a Dataset.
     # :server :: Set the server/shard to use for the transaction and insert
     #            queries.
     # :slice :: Same as :commit_every, :commit_every takes precedence.
@@ -356,7 +359,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
@@ -449,7 +452,8 @@ module Sequel
     #   # => 10
     #   DB[:table].max{function(column)} # SELECT max(function(column)) FROM table LIMIT 1
     #   # => 7
-    def max(arg=Sequel.virtual_row(&Proc.new))
+    def max(arg=(no_arg = true), &block)
+      arg = Sequel.virtual_row(&block) if no_arg
       _aggregate(:max, arg)
     end
 
@@ -460,7 +464,8 @@ module Sequel
     #   # => 1
     #   DB[:table].min{function(column)} # SELECT min(function(column)) FROM table LIMIT 1
     #   # => 0
-    def min(arg=Sequel.virtual_row(&Proc.new))
+    def min(arg=(no_arg = true), &block)
+      arg = Sequel.virtual_row(&block) if no_arg
       _aggregate(:min, arg)
     end
 
@@ -482,7 +487,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.
     #
@@ -508,7 +513,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
@@ -602,14 +607,16 @@ module Sequel
     # as_hash, it accepts an optional :hash parameter, into which entries will
     # be merged. 
     #
-    #   DB[:table].select_hash(:id, :name) # SELECT id, name FROM table
+    #   DB[:table].select_hash(:id, :name)
+    #   # SELECT id, name FROM table
     #   # => {1=>'a', 2=>'b', ...}
     #
     # You can also provide an array of column names for either the key_column,
     # the value column, or both:
     #
-    #   DB[:table].select_hash([:id, :foo], [:name, :bar]) # SELECT * FROM table
-    #   # {[1, 3]=>['a', 'c'], [2, 4]=>['b', 'd'], ...}
+    #   DB[:table].select_hash([:id, :foo], [:name, :bar])
+    #   # SELECT id, foo, name, bar FROM table
+    #   # => {[1, 3]=>['a', 'c'], [2, 4]=>['b', 'd'], ...}
     #
     # When using this method, you must be sure that each expression has an alias
     # that Sequel can determine.
@@ -621,14 +628,16 @@ module Sequel
     # Similar to to_hash_groups, but only selects the columns given.  Like to_hash_groups,
     # it accepts an optional :hash parameter, into which entries will be merged. 
     #
-    #   DB[:table].select_hash_groups(:name, :id) # SELECT id, name FROM table
+    #   DB[:table].select_hash_groups(:name, :id)
+    #   # SELECT id, name FROM table
     #   # => {'a'=>[1, 4, ...], 'b'=>[2, ...], ...}
     #
     # You can also provide an array of column names for either the key_column,
     # the value column, or both:
     #
-    #   DB[:table].select_hash_groups([:first, :middle], [:last, :id]) # SELECT * FROM table
-    #   # {['a', 'b']=>[['c', 1], ['d', 2], ...], ...}
+    #   DB[:table].select_hash_groups([:first, :middle], [:last, :id])
+    #   # SELECT first, middle, last, id FROM table
+    #   # => {['a', 'b']=>[['c', 1], ['d', 2], ...], ...}
     #
     # When using this method, you must be sure that each expression has an alias
     # that Sequel can determine.
@@ -732,7 +741,8 @@ module Sequel
     #   # => 55
     #   DB[:table].sum{function(column)} # SELECT sum(function(column)) FROM table LIMIT 1
     #   # => 10
-    def sum(arg=Sequel.virtual_row(&Proc.new))
+    def sum(arg=(no_arg = true), &block)
+      arg = Sequel.virtual_row(&block) if no_arg
       _aggregate(:sum, arg)
     end
 
@@ -875,7 +885,7 @@ module Sequel
     #   DB[:table].where_all(id: [1,2,3])
     #   # SELECT * FROM table WHERE (id IN (1, 2, 3))
     def where_all(cond, &block)
-      if loader = _where_loader
+      if loader = _where_loader([cond], nil)
         loader.all(filter_expr(cond), &block)
       else
         where(cond).all(&block)
@@ -889,7 +899,7 @@ module Sequel
     #   DB[:table].where_each(id: [1,2,3]){|row| p row}
     #   # SELECT * FROM table WHERE (id IN (1, 2, 3))
     def where_each(cond, &block)
-      if loader = _where_loader
+      if loader = _where_loader([cond], nil)
         loader.each(filter_expr(cond), &block)
       else
         where(cond).each(&block)
@@ -904,7 +914,7 @@ module Sequel
     #   DB[:table].select(:name).where_single_value(id: 1)
     #   # SELECT name FROM table WHERE (id = 1) LIMIT 1
     def where_single_value(cond)
-      if loader = cached_placeholder_literalizer(:_where_single_value_loader) do |pl|
+      if loader = cached_where_placeholder_literalizer([cond], nil, :_where_single_value_loader) do |pl|
           single_value_ds.where(pl.arg)
         end
 
@@ -966,7 +976,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
@@ -1039,8 +1050,8 @@ module Sequel
     end
 
     # Loader used for where_all and where_each.
-    def _where_loader
-      cached_placeholder_literalizer(:_where_loader) do |pl|
+    def _where_loader(where_args, where_block)
+      cached_where_placeholder_literalizer(where_args, where_block, :_where_loader) do |pl|
         where(pl.arg)
       end
     end
@@ -1063,7 +1074,7 @@ module Sequel
 
     # Set the server to use to :default unless it is already set in the passed opts
     def default_server_opts(opts)
-      if @db.sharded?
+      if @db.sharded? && !opts.has_key?(:server)
         opts = Hash[opts]
         opts[:server] = @opts[:server] || :default
       end
@@ -1074,7 +1085,7 @@ module Sequel
     # :read_only server unless a specific server is set.
     def execute(sql, opts=OPTS, &block)
       db = @db
-      if db.sharded?
+      if db.sharded? && !opts.has_key?(:server)
         opts = Hash[opts]
         opts[:server] = @opts[:server] || (@opts[:lock] ? :default : :read_only)
         opts