sequel 4.34.0 → 4.35.0

data/lib/sequel/database/misc.rb

@@ -116,31 +116,35 @@ module Sequel
     # :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.
-    def initialize(opts = OPTS, &block)
+    def initialize(opts = OPTS)
       @opts ||= opts
       @opts = connection_pool_default_options.merge(@opts)
       @loggers = Array(@opts[:logger]) + Array(@opts[:loggers])
-      self.log_warn_duration = @opts[:log_warn_duration]
-      block ||= proc{|server| connect(server)}
       @opts[:servers] = {} if @opts[:servers].is_a?(String)
       @sharded = !!@opts[:servers]
       @opts[:adapter_class] = self.class
-      
       @opts[:single_threaded] = @single_threaded = typecast_value_boolean(@opts.fetch(:single_threaded, Database.single_threaded))
-      @schemas = {}
       @default_string_column_size = @opts[:default_string_column_size] || DEFAULT_STRING_COLUMN_SIZE
+
+      @schemas = {}
       @prepared_statements = {}
       @transactions = {}
+      @symbol_literal_cache = {}
+
       @identifier_input_method = nil
       @identifier_output_method = nil
       @quote_identifiers = nil
       @timezone = nil
+
       @dataset_class = dataset_class_default
       @cache_schema = typecast_value_boolean(@opts.fetch(:cache_schema, true))
       @dataset_modules = []
-      @symbol_literal_cache = {}
       @schema_type_classes = SCHEMA_TYPE_CLASSES.dup
+
       self.sql_log_level = @opts[:sql_log_level] ? @opts[:sql_log_level].to_sym : :info
+      self.log_warn_duration = @opts[:log_warn_duration]
+      self.log_connection_info = typecast_value_boolean(@opts[:log_connection_info])
+
       @pool = ConnectionPool.get_pool(self, @opts)
 
       reset_identifier_mangling
@@ -166,7 +170,7 @@ module Sequel
       synchronize(opts[:server]) do |conn|
         if h = _trans(conn)
           raise Error, "cannot call after_commit in a prepared transaction" if h[:prepare]
-          (h[:after_commit] ||= []) << block
+          add_transaction_hook(conn, :after_commit, block)
         else
           yield
         end
@@ -183,7 +187,7 @@ module Sequel
       synchronize(opts[:server]) do |conn|
         if h = _trans(conn)
           raise Error, "cannot call after_rollback in a prepared transaction" if h[:prepare]
-          (h[:after_rollback] ||= []) << block
+          add_transaction_hook(conn, :after_rollback, block)
         end
       end
     end
@@ -337,6 +341,13 @@ module Sequel
     def adapter_initialize
     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
+
     # Returns true when the object is considered blank.
     # The only objects that are blank are nil, false,
     # strings with all whitespace, and ones that respond

data/lib/sequel/database/schema_generator.rb

@@ -18,8 +18,7 @@ module Sequel
     # the {"Schema Modification" guide}[rdoc-ref:doc/schema_modification.rdoc].
     class CreateTableGenerator
       # Classes specifying generic types that Sequel will convert to database-specific types.
-      GENERIC_TYPES=[String, Integer, Fixnum, Bignum, Float, Numeric, BigDecimal,
-      Date, DateTime, Time, File, TrueClass, FalseClass]
+      GENERIC_TYPES=%w'String Integer Fixnum Float Numeric BigDecimal Date DateTime Time File TrueClass FalseClass'
       
       # Return the column hashes created by this generator
       attr_reader :columns
@@ -41,6 +40,12 @@ module Sequel
         instance_eval(&block) if block
         @columns.unshift(@primary_key) if @primary_key && !has_column?(primary_key_name)
       end
+
+      # Use custom Bignum method to use :Bignum instead of Bignum class, to work
+      # correctly in cases where Bignum is the same as Integer.
+      def Bignum(name, opts=OPTS)
+        column(name, :Bignum, opts)
+      end
       
       # Add a method for each of the given types that creates a column
       # with that type as a constant.  Types given should either already

data/lib/sequel/database/schema_methods.rb

@@ -108,7 +108,7 @@ module Sequel
     # be option hashes, so long as the option hashes have a :table
     # entry giving the table referenced:
     #
-    #   create_join_table(:cat_id=>{:table=>:cats, :type=>Bignum}, :dog_id=>:dogs)
+    #   create_join_table(:cat_id=>{:table=>:cats, :type=>:Bignum}, :dog_id=>:dogs)
     #   
     # You can provide a second argument which is a table options hash:
     #
@@ -884,7 +884,14 @@ module Sequel
 
     # SQL fragment specifying the type of a given column.
     def type_literal(column)
-      column[:type].is_a?(Class) ? type_literal_generic(column) : type_literal_specific(column)
+      case column[:type]
+      when Class
+        type_literal_generic(column)
+      when :Bignum
+        type_literal_generic_bignum(column)
+      else
+        type_literal_specific(column)
+      end
     end
     
     # SQL fragment specifying the full type of a column,

data/lib/sequel/database/transactions.rb

@@ -80,11 +80,14 @@ module Sequel
     #                 appropriately.  Valid values true, :on, false, :off, :local (9.1+),
     #                 and :remote_write (9.2+).
     def transaction(opts=OPTS, &block)
+      opts = Hash[opts]
       if retry_on = opts[:retry_on]
         tot_retries = opts.fetch(:num_retries, 5)
         num_retries = 0 unless tot_retries.nil?
         begin
-          transaction(Hash[opts].merge!(:retry_on=>nil, :retrying=>true), &block)
+          opts[:retry_on] = nil
+          opts[:retrying] = true
+          transaction(opts, &block)
         rescue *retry_on => e
           if num_retries
             num_retries += 1
@@ -99,21 +102,40 @@ module Sequel
         end
       else
         synchronize(opts[:server]) do |conn|
-          if opts[:savepoint] == :only && supports_savepoints? && !_trans(conn)
-            return yield(conn)
+          if opts[:savepoint] == :only
+            if supports_savepoints?
+              if _trans(conn)
+                opts[:savepoint] = true
+              else
+                return yield(conn)
+              end
+            else
+              opts[:savepoint] = false
+            end
           end
+
           if already_in_transaction?(conn, opts)
+            if opts[:rollback] == :always && !opts.has_key?(:savepoint)
+              if supports_savepoints? 
+                opts[:savepoint] = true
+              else
+                raise Sequel::Error, "cannot set :rollback=>:always transaction option if already inside a transaction"
+              end
+            end
+
             if opts[:savepoint] != false && (stack = _trans(conn)[:savepoints]) && stack.last
-              _transaction(conn, Hash[opts].merge!(:savepoint=>true), &block)
-            else
+              opts[:savepoint] = true
+            end
+
+            unless opts[:savepoint]
               if opts[:retrying]
                 raise Sequel::Error, "cannot set :retry_on options if you are already inside a transaction"
               end
               return yield(conn)
             end
-          else
-            _transaction(conn, opts, &block)
           end
+
+          _transaction(conn, opts, &block)
         end
       end
     end
@@ -174,12 +196,12 @@ module Sequel
 
     # Add the current thread to the list of active transactions
     def add_transaction(conn, opts)
-      hash = {}
+      hash = transaction_options(conn, opts)
 
       if supports_savepoints?
-        if _trans(conn)
-          hash = nil
-          _trans(conn)[:savepoints].push(opts[:auto_savepoint])
+        if t = _trans(conn)
+          t[:savepoints].push(opts[:auto_savepoint])
+          return
         else
           hash[:savepoints] = [opts[:auto_savepoint]]
           if (prep = opts[:prepare]) && supports_prepared_transactions?
@@ -190,9 +212,7 @@ module Sequel
         hash[:prepare] = prep
       end
 
-      if hash
-        Sequel.synchronize{@transactions[conn] = hash}
-      end
+      Sequel.synchronize{@transactions[conn] = hash}
     end    
 
     # Whether the current thread/connection is already inside a transaction
@@ -200,6 +220,12 @@ module Sequel
       _trans(conn) && (!supports_savepoints? || !opts[:savepoint])
     end
 
+    # Derive the transaction hash from the options passed to the transaction.
+    # Meant to be overridden.
+    def transaction_options(conn, opts)
+      {}
+    end
+
     # Issue query to begin a new savepoint.
     def begin_savepoint(conn, opts)
       log_connection_execute(conn, begin_savepoint_sql(savepoint_level(conn)-1))
@@ -279,15 +305,23 @@ module Sequel
       :execute
     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
+        _trans(conn)[committed ? :after_commit : :after_rollback]
+      end
+    end
+
     # Remove the current thread from the list of active transactions
     def remove_transaction(conn, committed)
+      callbacks = transaction_hooks(conn, committed)
+
       if transaction_finished?(conn)
-        callbacks = _trans(conn)[committed ? :after_commit : :after_rollback]
         Sequel.synchronize{@transactions.delete(conn)}
-        if callbacks
-          callbacks.each(&:call)
-        end
       end
+
+      callbacks.each(&:call) if callbacks
     end
 
     # SQL to rollback to a savepoint

data/lib/sequel/dataset/actions.rb

@@ -719,31 +719,33 @@ module Sequel
     #   DB[:table].to_hash([:id, :name]) # SELECT * FROM table
     #   # {[1, 'Jim']=>{:id=>1, :name=>'Jim'}, [2, 'Bob'=>{:id=>2, :name=>'Bob'}, ...}
     #
-    # This method accepts an optional :hash parameter (which can be a hash with
-    # a default value, a hash with a default proc, or any object that supports
-    # #[] and #[]=) into which entries will be merged. The default behavior is
-    # to start with a new, empty hash.
+    # Options:
+    # :all :: Use all instead of each to retrieve the objects
+    # :hash :: The object into which the values will be placed.  If this is not
+    #          given, an empty hash is used.  This can be used to use a hash with
+    #          a default value or default proc.
     def to_hash(key_column, value_column = nil, opts = OPTS)
       h = opts[:hash] || {}
+      meth = opts[:all] ? :all : :each
       if value_column
         return naked.to_hash(key_column, value_column, opts) if row_proc
         if value_column.is_a?(Array)
           if key_column.is_a?(Array)
-            each{|r| h[r.values_at(*key_column)] = r.values_at(*value_column)}
+            send(meth){|r| h[r.values_at(*key_column)] = r.values_at(*value_column)}
           else
-            each{|r| h[r[key_column]] = r.values_at(*value_column)}
+            send(meth){|r| h[r[key_column]] = r.values_at(*value_column)}
           end
         else
           if key_column.is_a?(Array)
-            each{|r| h[r.values_at(*key_column)] = r[value_column]}
+            send(meth){|r| h[r.values_at(*key_column)] = r[value_column]}
           else
-            each{|r| h[r[key_column]] = r[value_column]}
+            send(meth){|r| h[r[key_column]] = r[value_column]}
           end
         end
       elsif key_column.is_a?(Array)
-        each{|r| h[key_column.map{|k| r[k]}] = r}
+        send(meth){|r| h[key_column.map{|k| r[k]}] = r}
       else
-        each{|r| h[r[key_column]] = r}
+        send(meth){|r| h[r[key_column]] = r}
       end
       h
     end
@@ -767,31 +769,34 @@ module Sequel
     #   DB[:table].to_hash_groups([:first, :middle]) # SELECT * FROM table
     #   # {['Jim', 'Bob']=>[{:id=>1, :first=>'Jim', :middle=>'Bob', :last=>'Smith'}, ...], ...}
     #
-    # This method accepts an optional :hash parameter (which can be a hash with
-    # a default value, a hash with a default proc, or any object that supports
-    # #[] and #[]=) into which entries will be merged. The default behavior is
+    # Options:
+    # :all :: Use all instead of each to retrieve the objects
+    # :hash :: The object into which the values will be placed.  If this is not
+    #          given, an empty hash is used.  This can be used to use a hash with
+    #          a default value or default proc.
     # to start with a new, empty hash.
     def to_hash_groups(key_column, value_column = nil, opts = OPTS)
       h = opts[:hash] || {}
+      meth = opts[:all] ? :all : :each
       if value_column
         return naked.to_hash_groups(key_column, value_column, opts) if row_proc
         if value_column.is_a?(Array)
           if key_column.is_a?(Array)
-            each{|r| (h[r.values_at(*key_column)] ||= []) << r.values_at(*value_column)}
+            send(meth){|r| (h[r.values_at(*key_column)] ||= []) << r.values_at(*value_column)}
           else
-            each{|r| (h[r[key_column]] ||= []) << r.values_at(*value_column)}
+            send(meth){|r| (h[r[key_column]] ||= []) << r.values_at(*value_column)}
           end
         else
           if key_column.is_a?(Array)
-            each{|r| (h[r.values_at(*key_column)] ||= []) << r[value_column]}
+            send(meth){|r| (h[r.values_at(*key_column)] ||= []) << r[value_column]}
           else
-            each{|r| (h[r[key_column]] ||= []) << r[value_column]}
+            send(meth){|r| (h[r[key_column]] ||= []) << r[value_column]}
           end
         end
       elsif key_column.is_a?(Array)
-        each{|r| (h[key_column.map{|k| r[k]}] ||= []) << r}
+        send(meth){|r| (h[key_column.map{|k| r[k]}] ||= []) << r}
       else
-        each{|r| (h[r[key_column]] ||= []) << r}
+        send(meth){|r| (h[r[key_column]] ||= []) << r}
       end
       h
     end

data/lib/sequel/dataset/features.rb

@@ -157,6 +157,11 @@ module Sequel
       false
     end
 
+    # Whether the dataset supports skipping locked rows when returning data.
+    def supports_skip_locked?
+      false
+    end
+
     # Whether the database supports SELECT *, column FROM table
     def supports_select_all_and_column?
       true

data/lib/sequel/dataset/query.rb

@@ -827,6 +827,12 @@ module Sequel
       end
     end
 
+    # Skip locked rows when returning results from this dataset.
+    def skip_locked
+      raise(Error, 'This dataset does not support skipping locked rows') unless supports_skip_locked?
+      clone(:skip_locked=>true)
+    end
+
     # Unbind bound variables from this dataset's filter and return an array of two
     # objects.  The first object is a modified dataset where the filter has been
     # replaced with one that uses bound variable placeholders.  The second object

data/lib/sequel/extensions/_pretty_table.rb

@@ -63,7 +63,7 @@ module Sequel
     # Format the value so it takes up exactly size characters
     def self.format_cell(size, v) # :nodoc:
       case v
-      when Bignum, Fixnum
+      when Integer
         "%#{size}d" % v
       when Float, BigDecimal
         "%#{size}g" % v

data/lib/sequel/extensions/error_sql.rb

@@ -20,7 +20,7 @@
 #
 # This extension may not work correctly in the following cases:
 #
-# * log_yield is not used when executing the query.
+# * log_connection_yield is not used when executing the query.
 # * The underlying exception is frozen or reused.
 # * The underlying exception doesn't correctly record instance
 #   variables set on it (seems to happen on JRuby when underlying
@@ -57,12 +57,12 @@ module Sequel
     # If there are no loggers for this database and an exception is raised
     # store the SQL related to the exception with the exception, so it
     # is available for DatabaseError#sql later.
-    def log_yield(sql, args=nil)
+    def log_connection_yield(sql, conn, args=nil)
       if @loggers.empty?
         begin
           yield
         rescue => e
-          sql = "#{sql}; #{args.inspect}" if args
+          sql = "#{connection_info(conn) if conn && log_connection_info}#{sql}#{"; #{args.inspect}" if args}"
           e.instance_variable_set(:@sequel_error_sql, sql)
           raise
         end

data/lib/sequel/extensions/pg_range.rb

@@ -405,11 +405,20 @@ module Sequel
 
       # Delegate to the ruby range object so that the object mostly acts like a range.
       range_methods = %w'each last first step'
-      range_methods << 'cover?' if RUBY_VERSION >= '1.9'
       range_methods.each do |m|
         class_eval("def #{m}(*a, &block) to_range.#{m}(*a, &block) end", __FILE__, __LINE__)
       end
 
+      # Return whether the value is inside the range.
+      def cover?(value)
+        return false if empty?
+        b = self.begin
+        return false if b && b.send(exclude_begin? ? :>= : :>, value)
+        e = self.end
+        return false if e && e.send(exclude_end? ? :<= : :<, value)
+        true
+      end
+
       # Consider the receiver equal to other PGRange instances with the
       # same beginning, ending, exclusions, and database type.  Also consider
       # it equal to Range instances if this PGRange can be converted to a

data/lib/sequel/extensions/schema_dumper.rb

@@ -25,17 +25,17 @@ module Sequel
         if !$1 && $2 && $2.to_i >= 10 && $3
           # Unsigned integer type with 10 digits can potentially contain values which
           # don't fit signed integer type, so use bigint type in target database.
-          {:type=>Bignum}
+          {:type=>:Bignum}
         else
           {:type=>Integer}
         end
       when /\Atinyint(?:\((\d+)\))?(?: unsigned)?\z/o
         {:type =>schema[:type] == :boolean ? TrueClass : Integer}
       when /\Abigint(?:\((?:\d+)\))?(?: unsigned)?\z/o
-        {:type=>Bignum}
+        {:type=>:Bignum}
       when /\A(?:real|float|double(?: precision)?|double\(\d+,\d+\)(?: unsigned)?)\z/o
         {:type=>Float}
-      when 'boolean', 'bit'
+      when 'boolean', 'bit', 'bool'
         {:type=>TrueClass}
       when /\A(?:(?:tiny|medium|long|n)?text|clob)\z/o
         {:type=>String, :text=>true}
@@ -206,7 +206,7 @@ END_MIG
           gen.foreign_key(name, table, col_opts)
         else
           gen.column(name, type, col_opts)
-          if [Integer, Bignum, Float].include?(type) && schema[:db_type] =~ / unsigned\z/io
+          if [Integer, :Bignum, Float].include?(type) && schema[:db_type] =~ / unsigned\z/io
             gen.check(Sequel::SQL::Identifier.new(name) >= 0)
           end
         end
@@ -407,8 +407,11 @@ END_MIG
           else
             type = c.delete(:type)
             opts = opts_inspect(c)
-            if type.is_a?(Class)
+            case type
+            when Class
               "#{type.name} #{name.inspect}#{opts}"
+            when :Bignum
+              "Bignum #{name.inspect}#{opts}"
             else
               "column #{name.inspect}, #{type.inspect}#{opts}"
             end