sequel 4.38.0 → 4.39.0

data/lib/sequel/database/query.rb

@@ -88,7 +88,7 @@ module Sequel
     # :schema :: An explicit schema to use.  It may also be implicitly provided
     #            via the table name.
     #
-    # If schema parsing is supported by the database, the column information should hash at least contain the
+    # If schema parsing is supported by the database, the column information hash should contain at least the
     # following entries:
     #
     # :allow_null :: Whether NULL is an allowed value for the column.

data/lib/sequel/database/schema_generator.rb

@@ -336,6 +336,15 @@ module Sequel
       # See CreateTableGenerator#column for the available options.
       #
       #   add_column(:name, String) # ADD COLUMN name varchar(255)
+      #
+      # PostgreSQL specific options:
+      #
+      # :if_not_exists :: Set to true to not add the column if it already exists (PostgreSQL 9.6+)
+      #
+      # MySQL specific options:
+      #
+      # :after :: The name of an existing column that the new column should be positioned after
+      # :first :: Create this new column before all other existing columns
       def add_column(name, type, opts = OPTS)
         @operations << {:op => :add_column, :name => name, :type => type}.merge!(opts)
       end

data/lib/sequel/database/transactions.rb

@@ -32,6 +32,58 @@ module Sequel
     # on the same connection.
     attr_accessor :transaction_isolation_level
 
+    # If a transaction is not currently in process, yield to the block immediately.
+    # Otherwise, add the block to the list of blocks to call after the currently
+    # in progress transaction commits (and only if it commits).
+    # Options:
+    # :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)
+        else
+          yield
+        end
+      end
+    end
+    
+    # If a transaction is not currently in progress, ignore the block.
+    # 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:
+    # :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)
+        end
+      end
+    end
+    
+    # Return true if already in a transaction given the options,
+    # false otherwise.  Respects the :server option for selecting
+    # a shard.
+    def in_transaction?(opts=OPTS)
+      synchronize(opts[:server]){|conn| !!_trans(conn)}
+    end
+
+    # Returns a proc that you can call to check if the transaction
+    # has been rolled back.  The proc will return nil if the
+    # transaction is still in progress, true if the transaction was
+    # rolled back, and false if it was committed.  Raises an
+    # Error if called outside a transaction.  Respects the :server
+    # option for selecting a shard.
+    def rollback_checker(opts=OPTS)
+      synchronize(opts[:server]) do |conn|
+        raise Error, "not in a transaction" unless t = _trans(conn)
+        t[:rollback_checker] ||= proc{t[:rolled_back]}
+      end
+    end
+
     # Starts a database transaction.  When a database transaction is used,
     # either all statements are successful or none of the statements are
     # successful.  Note that MySQL MyISAM tables do not support transactions.
@@ -215,6 +267,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_transaction_hook(conn, type, block)
+      hooks = _trans(conn)[type] ||= []
+      hooks << block
+    end
+
     # Whether the current thread/connection is already inside a transaction
     def already_in_transaction?(conn, opts)
       _trans(conn) && (!supports_savepoints? || !opts[:savepoint])
@@ -305,6 +364,11 @@ module Sequel
       :execute
     end
 
+    # Which transaction errors to translate, blank by default.
+    def database_error_classes
+      []
+    end
+
     # Retrieve the transaction hooks that should be run for the given
     # connection and commit status.
     def transaction_hooks(conn, committed)
@@ -318,6 +382,7 @@ module Sequel
       callbacks = transaction_hooks(conn, committed)
 
       if transaction_finished?(conn)
+        @transactions[conn][:rolled_back] = !committed
         Sequel.synchronize{@transactions.delete(conn)}
       end
 

data/lib/sequel/dataset/actions.rb

@@ -817,7 +817,7 @@ module Sequel
     #   DB[:table].update(:x=>nil) # UPDATE table SET x = NULL
     #   # => 10
     #
-    #   DB[:table].update(:x=>Sequel.expr(:x)+1, :y=>0) # UPDATE table SET x = (x + 1), y = 0
+    #   DB[:table].update(:x=>Sequel[:x]+1, :y=>0) # UPDATE table SET x = (x + 1), y = 0
     #   # => 10
     def update(values=OPTS, &block)
       sql = update_sql(values)

data/lib/sequel/extensions/constraint_validations.rb

@@ -444,7 +444,7 @@ module Sequel
     # for all columns unless the :allow_nil option is given.
     def generator_add_constraint_from_validation(generator, val, cons)
       if val[:allow_nil]
-        nil_cons = Sequel.expr(val[:columns].map{|c| [c, nil]})
+        nil_cons = Sequel[val[:columns].map{|c| [c, nil]}]
         cons = Sequel.|(nil_cons, cons) if cons
       else
         nil_cons = Sequel.negate(val[:columns].map{|c| [c, nil]})

data/lib/sequel/extensions/core_extensions.rb

@@ -58,7 +58,7 @@ class Array
   #   [[:a, true]].sql_expr # SQL: a IS TRUE
   #   [[:a, 1], [:b, [2, 3]]].sql_expr # SQL: a = 1 AND b IN (2, 3)
   def sql_expr
-    Sequel.expr(self)
+    Sequel[self]
   end
 
   # Return a <tt>Sequel::SQL::BooleanExpression</tt> created from this array, matching none

data/lib/sequel/extensions/core_refinements.rb

@@ -55,7 +55,7 @@ module Sequel::CoreRefinements
     #   [[:a, true]].sql_expr # SQL: a IS TRUE
     #   [[:a, 1], [:b, [2, 3]]].sql_expr # SQL: a = 1 AND b IN (2, 3)
     def sql_expr
-      Sequel.expr(self)
+      Sequel[self]
     end
 
     # Return a <tt>Sequel::SQL::BooleanExpression</tt> created from this array, matching none

data/lib/sequel/extensions/migration.rb

@@ -387,6 +387,8 @@ module Sequel
     # :column :: The column in the :table argument storing the migration version (default: :version).
     # :current :: The current version of the database.  If not given, it is retrieved from the database
     #             using the :table and :column options.
+    # :relative :: Run the given number of migrations, with a positive number being migrations to migrate
+    #              up, and a negative number being migrations to migrate down (IntegerMigrator only).
     # :table :: The table containing the schema version (default: :schema_info).
     # :target :: The target version to which to migrate.  If not given, migrates to the maximum version.
     #
@@ -520,8 +522,22 @@ module Sequel
     # Set up all state for the migrator instance
     def initialize(db, directory, opts=OPTS)
       super
-      @target = opts[:target] || latest_migration_version
       @current = opts[:current] || current_migration_version
+      latest_version = latest_migration_version
+
+      @target = if opts[:target]
+        opts[:target]
+      elsif opts[:relative]
+        @current + opts[:relative]
+      else
+        latest_version
+      end
+
+      if @target > latest_version
+        @target = latest_version
+      elsif @target < 0
+        @target = 0
+      end
 
       raise(Error, "No current version available") unless current
       raise(Error, "No target version available, probably because no migration files found or filenames don't follow the migration filename convention") unless target

data/lib/sequel/extensions/no_auto_literal_strings.rb

@@ -40,7 +40,7 @@
 #
 # or construct the same SQL using a non-string based approach:
 #
-#   DB[:table].update(:column => Sequel.expr(:column) + 1)
+#   DB[:table].update(:column => Sequel[:column] + 1)
 #
 # Related module: Sequel::Dataset::NoAutoLiteralStrings
 

data/lib/sequel/extensions/pg_array_ops.rb

@@ -19,7 +19,7 @@
 # Also, on most Sequel expression objects, you can call the pg_array
 # method:
 #
-#   ia = Sequel.expr(:int_array_column).pg_array
+#   ia = Sequel[:int_array_column].pg_array
 #
 # If you have loaded the {core_extensions extension}[rdoc-ref:doc/core_extensions.rdoc],
 # or you have loaded the core_refinements extension

data/lib/sequel/extensions/pg_hstore_ops.rb

@@ -20,7 +20,7 @@
 # Also, on most Sequel expression objects, you can call the hstore 
 # method:
 #
-#   h = Sequel.expr(:hstore_column).hstore
+#   h = Sequel[:hstore_column].hstore
 #
 # If you have loaded the {core_extensions extension}[rdoc-ref:doc/core_extensions.rdoc],
 # or you have loaded the core_refinements extension

data/lib/sequel/extensions/pg_inet_ops.rb

@@ -14,7 +14,7 @@
 # Also, on most Sequel expression objects, you can call the pg_inet
 # method:
 #
-#   r = Sequel.expr(:ip).pg_inet
+#   r = Sequel[:ip].pg_inet
 #
 # If you have loaded the {core_extensions extension}[rdoc-ref:doc/core_extensions.rdoc],
 # or you have loaded the core_refinements extension

data/lib/sequel/extensions/pg_interval.rb

@@ -42,7 +42,7 @@ module Sequel
   module Postgres
     module IntervalDatabaseMethods
       EMPTY_INTERVAL = '0'.freeze
-      DURATION_UNITS = [:years, :months, :days, :minutes, :seconds].freeze
+      DURATION_UNITS = [:years, :months, :weeks, :days, :hours, :minutes, :seconds].freeze
 
       # Return an unquoted string version of the duration object suitable for
       # use as a bound variable.

data/lib/sequel/extensions/pg_json_ops.rb

@@ -24,8 +24,8 @@
 # Also, on most Sequel expression objects, you can call the pg_json
 # or pg_jsonb # method:
 #
-#   j = Sequel.expr(:json_column).pg_json
-#   jb = Sequel.expr(:jsonb_column).pg_jsonb
+#   j = Sequel[:json_column].pg_json
+#   jb = Sequel[:jsonb_column].pg_jsonb
 #
 # If you have loaded the {core_extensions extension}[rdoc-ref:doc/core_extensions.rdoc],
 # or you have loaded the core_refinements extension
@@ -61,16 +61,17 @@
 #
 # There are additional methods are are only supported on JSONBOp instances:
 #
-#   j - 1                  # (jsonb_column - 1)
-#   j.concat(:h)           # (jsonb_column || h)
-#   j.contain_all(:a)      # (jsonb_column ?& a)
-#   j.contain_any(:a)      # (jsonb_column ?| a)
-#   j.contains(:h)         # (jsonb_column @> h)
-#   j.contained_by(:h)     # (jsonb_column <@ h)
-#   j.delete_path(%w'0 a') # (jsonb_column #- ARRAY['0','a'])
-#   j.has_key?('a')        # (jsonb_column ? 'a')
-#   j.pretty               # jsonb_pretty(jsonb_column)
-#   j.set(%w'0 a', :h)     # jsonb_set(jsonb_column, ARRAY['0','a'], h, true)
+#   j - 1                     # (jsonb_column - 1)
+#   j.concat(:h)              # (jsonb_column || h)
+#   j.contain_all(:a)         # (jsonb_column ?& a)
+#   j.contain_any(:a)         # (jsonb_column ?| a)
+#   j.contains(:h)            # (jsonb_column @> h)
+#   j.contained_by(:h)        # (jsonb_column <@ h)
+#   j.delete_path(%w'0 a')    # (jsonb_column #- ARRAY['0','a'])
+#   j.has_key?('a')           # (jsonb_column ? 'a')
+#   j.insert(%w'0 a', 'a'=>1) # jsonb_insert(jsonb_column, ARRAY[0, 'a'], '{"a":1}'::jsonb, false)
+#   j.pretty                  # jsonb_pretty(jsonb_column)
+#   j.set(%w'0 a', :h)        # jsonb_set(jsonb_column, ARRAY['0','a'], h, true)
 #
 # If you are also using the pg_json extension, you should load it before
 # loading this extension.  Doing so will allow you to use the #op method on
@@ -336,7 +337,7 @@ module Sequel
         bool_op(CONTAINED_BY, wrap_input_jsonb(other))
       end
 
-      # Check if the other jsonb contains all entries in the receiver:
+      # Removes the given path from the receiver.
       #
       #   jsonb_op.delete_path(:h) # (jsonb #- h)
       def delete_path(other)
@@ -351,19 +352,31 @@ module Sequel
       end
       alias include? has_key?
 
+      # Inserts the given jsonb value at the given path in the receiver.
+      # The default is to insert the value before the given path, but
+      # insert_after can be set to true to insert it after the given path.
+      #
+      #   jsonb_op.insert(['a', 'b'], h) # jsonb_insert(jsonb, ARRAY['a', 'b'], h, false)
+      #   jsonb_op.insert(['a', 'b'], h, true) # jsonb_insert(jsonb, ARRAY['a', 'b'], h, true)
+      def insert(path, other, insert_after=false)
+        self.class.new(function(:insert, wrap_input_array(path), wrap_input_jsonb(other), insert_after))
+      end
+
       # Return the receiver, since it is already a JSONBOp.
       def pg_jsonb
         self
       end
 
-      # Returns a json value for the object at the given path.
+      # Return a pretty printed version of the receiver as a string expression.
       #
       #   jsonb_op.pretty # jsonb_pretty(jsonb)
       def pretty
         Sequel::SQL::StringExpression.new(:NOOP, function(:pretty))
       end
 
-      # Returns a json value for the object at the given path.
+      # Set the given jsonb value at the given path in the receiver.
+      # By default, this will create the value if it does not exist, but
+      # create_missing can be set to false to not create a new value.
       #
       #   jsonb_op.set(['a', 'b'], h) # jsonb_set(jsonb, ARRAY['a', 'b'], h, true)
       #   jsonb_op.set(['a', 'b'], h, false) # jsonb_set(jsonb, ARRAY['a', 'b'], h, false)

data/lib/sequel/extensions/pg_range_ops.rb

@@ -19,7 +19,7 @@
 # Also, on most Sequel expression objects, you can call the pg_range
 # method:
 #
-#   r = Sequel.expr(:range).pg_range
+#   r = Sequel[:range].pg_range
 #
 # If you have loaded the {core_extensions extension}[rdoc-ref:doc/core_extensions.rdoc],
 # or you have loaded the core_refinements extension

data/lib/sequel/extensions/pg_row_ops.rb

@@ -19,7 +19,7 @@
 # Also, on most Sequel expression objects, you can call the pg_row
 # method:
 #
-#   r = Sequel.expr(:row_column).pg_row
+#   r = Sequel[:row_column].pg_row
 #
 # If you have loaded the {core_extensions extension}[rdoc-ref:doc/core_extensions.rdoc],
 # or you have loaded the core_refinements extension

data/lib/sequel/extensions/select_remove.rb

@@ -35,7 +35,7 @@ module Sequel
     #   In this case, the code will currently use unqualified column names for all columns
     #   the dataset returns, except for the columns given.
     # * This dataset has an existing explicit selection containing an item that returns
-    #   multiple database columns (e.g. Sequel.expr(:table).*, Sequel.lit('column1, column2')).  In this case,
+    #   multiple database columns (e.g. Sequel[:table].*, Sequel.lit('column1, column2')).  In this case,
     #   the behavior is undefined and this method should not be used.
     #
     # There may be other cases where this method does not work correctly, use it with caution.

data/lib/sequel/extensions/sql_expr.rb

@@ -17,6 +17,6 @@
 class Object
   # Return the object wrapper in an appropriate Sequel expression object.
   def sql_expr
-    Sequel.expr(self)
+    Sequel[self]
   end
 end

data/lib/sequel/model/associations.rb

@@ -2792,7 +2792,7 @@ END
         # included by the association's conditions.
         def add_association_filter_conditions(ref, obj, expr)
           if expr != SQL::Constants::FALSE && ref.filter_by_associations_add_conditions?
-            Sequel.expr(ref.filter_by_associations_conditions_expression(obj))
+            Sequel[ref.filter_by_associations_conditions_expression(obj)]
           else
             expr
           end

data/lib/sequel/plugins/active_model.rb

@@ -46,13 +46,6 @@ module Sequel
           @destroyed = true
         end
 
-        # Mark current instance as destroyed if the transaction in which this
-        # instance is created is rolled back.
-        def before_create
-          db.after_rollback{@destroyed = true}
-          super
-        end
-
         # Return ::ActiveModel::Name instance for the class.
         def model_name
           model.model_name
@@ -60,7 +53,16 @@ module Sequel
 
         # False if the object is new? or has been destroyed, true otherwise.
         def persisted?
-          !new? && @destroyed != true
+          return false if new?
+          return false if defined?(@destroyed)
+
+          if defined?(@rollback_checker)
+            if @rollback_checker.call
+              return false
+            end
+          end
+          
+          true
         end
         
         # An array of primary key values, or nil if the object is not persisted.
@@ -93,6 +95,15 @@ module Sequel
         
         private
 
+        # For new objects, add a rollback checker to check if the transaction
+        # in which this instance is created is rolled back.
+        def _save(opts)
+          if new? && db.in_transaction?(opts)
+            @rollback_checker = db.rollback_checker(opts)
+          end
+          super
+        end
+
         # Use ActiveModel compliant errors class.
         def errors_class
           Errors

data/lib/sequel/plugins/dataset_associations.rb

@@ -103,7 +103,7 @@ module Sequel
             edges.each{|e| mds = mds.join(e[:table], Array(e[:right]).zip(Array(e[:left])))}
             ds.filter(r.qualified_right_primary_key=>r.send(:apply_filter_by_associations_limit_strategy, mds))
           when :pg_array_to_many
-            ds.filter(Sequel.expr(r.primary_key=>sds.select{Sequel.pg_array_op(r.qualify(r[:model].table_name, r[:key])).unnest}))
+            ds.filter(Sequel[r.primary_key=>sds.select{Sequel.pg_array_op(r.qualify(r[:model].table_name, r[:key])).unnest}])
           when :many_to_pg_array
             ds.filter(Sequel.function(:coalesce, Sequel.pg_array_op(r[:key]).overlaps(sds.select{array_agg(r.qualify(r[:model].table_name, r.primary_key))}), false))
           else

data/lib/sequel/plugins/hook_class_methods.rb

@@ -119,8 +119,44 @@ module Sequel
       end
 
       module InstanceMethods
-        Model::BEFORE_HOOKS.each{|h| class_eval("def #{h}; model.hook_blocks(:#{h}){|b| return false if instance_eval(&b) == false}; super; end", __FILE__, __LINE__)}
-        Model::AFTER_HOOKS.each{|h| class_eval("def #{h}; super; model.hook_blocks(:#{h}){|b| instance_eval(&b)}; end", __FILE__, __LINE__)}
+        (Model::BEFORE_HOOKS - [:before_save, :before_destroy]).each{|h| class_eval("def #{h}; model.hook_blocks(:#{h}){|b| return false if instance_eval(&b) == false}; super; end", __FILE__, __LINE__)}
+        (Model::AFTER_HOOKS - [:after_save, :after_destroy, :after_commit, :after_rollback, :after_destroy_commit, :after_destroy_rollback]).each{|h| class_eval("def #{h}; super; model.hook_blocks(:#{h}){|b| instance_eval(&b)}; end", __FILE__, __LINE__)}
+
+        def after_destroy
+          super
+          model.hook_blocks(:after_destroy){|b| instance_eval(&b)}
+          if model.has_hooks?(:after_destroy_commit)
+            db.after_rollback{model.hook_blocks(:after_destroy_commit){|b| instance_eval(&b)}}
+          end
+        end
+
+        def after_save
+          super
+          model.hook_blocks(:after_save){|b| instance_eval(&b)}
+          if model.has_hooks?(:after_commit)
+            db.after_rollback{model.hook_blocks(:after_commit){|b| instance_eval(&b)}}
+          end
+        end
+
+        def before_destroy
+          model.hook_blocks(:before_destroy) do |b|
+            return false if instance_eval(&b) == false
+          end
+          super
+          if model.has_hooks?(:after_destroy_rollback)
+            db.after_rollback{model.hook_blocks(:after_destroy_rollback){|b| instance_eval(&b)}}
+          end
+        end
+
+        def before_save
+          model.hook_blocks(:before_save) do |b|
+            return false if instance_eval(&b) == false
+          end
+          super
+          if model.has_hooks?(:after_rollback)
+            db.after_rollback{model.hook_blocks(:after_rollback){|b| instance_eval(&b)}}
+          end
+        end
       end
     end
   end