sequel 4.21.0 → 4.22.0

data/lib/sequel/adapters/tinytds.rb

@@ -71,18 +71,24 @@ module Sequel
 
       # Return the number of rows modified by the given +sql+.
       def execute_dui(sql, opts=OPTS)
-        execute(sql, opts.merge(:return=>:do))
+        opts = Hash[opts]
+        opts[:return] = :do
+        execute(sql, opts)
       end
 
       # Return the value of the autogenerated primary key (if any)
       # for the row inserted by the given +sql+.
       def execute_insert(sql, opts=OPTS)
-        execute(sql, opts.merge(:return=>:insert))
+        opts = Hash[opts]
+        opts[:return] = :insert
+        execute(sql, opts)
       end
 
       # Execute the DDL +sql+ on the database and return nil.
       def execute_ddl(sql, opts=OPTS)
-        execute(sql, opts.merge(:return=>:each))
+        opts = Hash[opts]
+        opts[:return] = :each
+        execute(sql, opts)
         nil
       end
 
@@ -202,30 +208,8 @@ module Sequel
         end
       end
       
-      # SQLite prepared statement uses a new prepared statement each time
-      # it is called, but it does use the bind arguments.
-      module PreparedStatementMethods
-        include ArgumentMapper
-        
-        private
-        
-        # Run execute_select on the database with the given SQL and the stored
-        # bind arguments.
-        def execute(sql, opts=OPTS, &block)
-          super(prepared_sql, {:arguments=>bind_arguments}.merge(opts), &block)
-        end
-        
-        # Same as execute, explicit due to intricacies of alias and super.
-        def execute_dui(sql, opts=OPTS, &block)
-          super(prepared_sql, {:arguments=>bind_arguments}.merge(opts), &block)
-        end
-        
-        # Same as execute, explicit due to intricacies of alias and super.
-        def execute_insert(sql, opts=OPTS, &block)
-          super(prepared_sql, {:arguments=>bind_arguments}.merge(opts), &block)
-        end
-      end
-      
+      PreparedStatementMethods = prepared_statements_module("sql = prepared_sql; opts = Hash[opts]; opts[:arguments] = bind_arguments", ArgumentMapper)
+    
       # Yield hashes with symbol keys, attempting to optimize for
       # various cases.
       def fetch_rows(sql)
@@ -238,7 +222,7 @@ module Sequel
             result.each(*args) do |r|
               unless cols
                 cols = result.fields.map{|c| [c, output_identifier(c)]}
-                @columns = columns = cols.map{|c| c.last}
+                @columns = columns = cols.map(&:last)
               end
               h = {}
               cols.each do |s, sym|

data/lib/sequel/adapters/utils/pg_types.rb

@@ -24,7 +24,7 @@ module Sequel
           s.to_f 
         end
       end
-      def date(s) ::Date.new(*s.split(DASH_STR).map{|x| x.to_i}) end
+      def date(s) ::Date.new(*s.split(DASH_STR).map(&:to_i)) end
       def bytea(str)
         str = if str =~ /\A\\x/
           # PostgreSQL 9.0+ bytea hex format

data/lib/sequel/connection_pool/sharded_threaded.rb

@@ -18,6 +18,12 @@ class Sequel::ShardedThreadedConnectionPool < Sequel::ThreadedConnectionPool
     @available_connections = {}
     @connections_to_remove = []
     @servers = opts.fetch(:servers_hash, Hash.new(:default))
+
+    if USE_WAITER
+      @waiter = nil
+      @waiters = {}
+    end
+
     add_servers([:default])
     add_servers(opts[:servers].keys) if opts[:servers]
   end
@@ -32,6 +38,7 @@ class Sequel::ShardedThreadedConnectionPool < Sequel::ThreadedConnectionPool
           @servers[server] = server
           @available_connections[server] = []
           @allocated[server] = {}
+          @waiters[server] = ConditionVariable.new if USE_WAITER
         end
       end
     end
@@ -115,16 +122,7 @@ class Sequel::ShardedThreadedConnectionPool < Sequel::ThreadedConnectionPool
       return yield(conn)
     end
     begin
-      unless conn = acquire(t, server)
-        time = Time.now
-        timeout = time + @timeout
-        sleep_time = @sleep_time
-        sleep sleep_time
-        until conn = acquire(t, server)
-          raise(::Sequel::PoolTimeout) if Time.now > timeout
-          sleep sleep_time
-        end
-      end
+      conn = acquire(t, server)
       yield conn
     rescue Sequel::DatabaseDisconnectError
       sync{@connections_to_remove << conn} if conn
@@ -144,6 +142,7 @@ class Sequel::ShardedThreadedConnectionPool < Sequel::ThreadedConnectionPool
       servers.each do |server|
         if @servers.include?(server)
           disconnect_server(server)
+          @waiters.delete(server) if USE_WAITER
           @available_connections.delete(server)
           @allocated.delete(server)
           @servers.delete(server)
@@ -164,16 +163,60 @@ class Sequel::ShardedThreadedConnectionPool < Sequel::ThreadedConnectionPool
   private
 
   # Assigns a connection to the supplied thread for the given server, if one
-  # is available. The calling code should NOT already have the mutex when
+  # is available. The calling code should already have the mutex when
   # calling this.
-  def acquire(thread, server)
-    sync do
-      if conn = available(server)
-        allocated(server)[thread] = conn
-      end
+  def _acquire(thread, server)
+    if conn = available(server)
+      allocated(server)[thread] = conn
     end
   end
   
+  if USE_WAITER
+    # Assigns a connection to the supplied thread, if one
+    # is available. The calling code should NOT already have the mutex when
+    # calling this.
+    #
+    # This should return a connection is one is available within the timeout,
+    # or nil if a connection could not be acquired within the timeout.
+    def acquire(thread, server)
+      sync do
+        if conn = _acquire(thread, server)
+          return conn
+        end
+
+        time = Time.now
+        @waiters[server].wait(@mutex, @timeout)
+        Thread.pass
+
+        until conn = _acquire(thread, server)
+          deadline ||= time + @timeout
+          current_time = Time.now
+          raise(::Sequel::PoolTimeout, "timeout: #{@timeout}, elapsed: #{current_time - time}") if current_time > deadline
+          @waiters[server].wait(@mutex, deadline - current_time)
+          Thread.pass
+        end
+
+        conn
+      end
+    end
+  else
+    # :nocov:
+    def acquire(thread, server)
+      unless conn = sync{_acquire(thread, server)}
+        time = Time.now
+        timeout = time + @timeout
+        sleep_time = @sleep_time
+        sleep sleep_time
+        until conn = sync{_acquire(thread, server)}
+          raise(::Sequel::PoolTimeout, "timeout: #{@timeout}, elapsed: #{Time.now - time}") if Time.now > timeout
+          sleep sleep_time
+        end
+      end
+      conn
+    end
+    # :nocov:
+  end
+
   # Returns an available connection to the given server. If no connection is
   # available, tries to create a new connection. The calling code should already
   # have the mutex before calling this.
@@ -186,6 +229,10 @@ class Sequel::ShardedThreadedConnectionPool < Sequel::ThreadedConnectionPool
   # before calling this.
   def checkin_connection(server, conn)
     available_connections(server) << conn
+    if USE_WAITER
+      @waiters[server].signal
+      Thread.pass
+    end
     conn
   end
 

data/lib/sequel/connection_pool/threaded.rb

@@ -1,6 +1,11 @@
 # A connection pool allowing multi-threaded access to a pool of connections.
 # This is the default connection pool used by Sequel.
 class Sequel::ThreadedConnectionPool < Sequel::ConnectionPool
+  # Whether or not a ConditionVariable should be used to wait for connections.
+  # True except on ruby 1.8, where ConditionVariable#wait does not support a
+  # timeout.
+  USE_WAITER = RUBY_VERSION >= '1.9'
+
   # The maximum number of connections this pool will create (per shard/server
   # if sharding).
   attr_reader :max_size
@@ -19,7 +24,7 @@ class Sequel::ThreadedConnectionPool < Sequel::ConnectionPool
   # * :max_connections - The maximum number of connections the connection pool
   #   will open (default 4)
   # * :pool_sleep_time - The amount of time to sleep before attempting to acquire
-  #   a connection again (default 0.001)
+  #   a connection again, only used on ruby 1.8. (default 0.001)
   # * :pool_timeout - The amount of seconds to wait to acquire a connection
   #   before raising a PoolTimeoutError (default 5)
   def initialize(db, opts = OPTS)
@@ -31,7 +36,12 @@ class Sequel::ThreadedConnectionPool < Sequel::ConnectionPool
     @available_connections = []
     @allocated = {}
     @timeout = Float(opts[:pool_timeout] || 5)
-    @sleep_time = Float(opts[:pool_sleep_time] || 0.001)
+
+    if USE_WAITER
+      @waiter = ConditionVariable.new
+    else
+      @sleep_time = Float(opts[:pool_sleep_time] || 0.001)
+    end
   end
   
   # Yield all of the available connections, and the one currently allocated to
@@ -85,16 +95,7 @@ class Sequel::ThreadedConnectionPool < Sequel::ConnectionPool
       return yield(conn)
     end
     begin
-      unless conn = acquire(t)
-        time = Time.now
-        timeout = time + @timeout
-        sleep_time = @sleep_time
-        sleep sleep_time
-        until conn = acquire(t)
-          raise(::Sequel::PoolTimeout) if Time.now > timeout
-          sleep sleep_time
-        end
-      end
+      conn = acquire(t)
       yield conn
     rescue Sequel::DatabaseDisconnectError
       oconn = conn
@@ -120,16 +121,65 @@ class Sequel::ThreadedConnectionPool < Sequel::ConnectionPool
   private
 
   # Assigns a connection to the supplied thread, if one
-  # is available. The calling code should NOT already have the mutex when
+  # is available. The calling code should already have the mutex when
   # calling this.
-  def acquire(thread)
-    sync do
-      if conn = available
-        @allocated[thread] = conn
-      end
+  def _acquire(thread)
+    if conn = available
+      @allocated[thread] = conn
     end
   end
   
+  if USE_WAITER
+    # Assigns a connection to the supplied thread, if one
+    # is available. The calling code should NOT already have the mutex when
+    # calling this.
+    #
+    # This should return a connection is one is available within the timeout,
+    # or nil if a connection could not be acquired within the timeout.
+    def acquire(thread)
+      sync do
+        if conn = _acquire(thread)
+          return conn
+        end
+
+        time = Time.now
+        @waiter.wait(@mutex, @timeout)
+
+        # Not sure why this is helpful, but calling Thread.pass after conditional
+        # variable access dramatically increases reliability when under heavy
+        # resource contention (almost eliminating timeouts), at a small cost to
+        # runtime performance.
+        Thread.pass
+
+        until conn = _acquire(thread)
+          deadline ||= time + @timeout
+          current_time = Time.now
+          raise(::Sequel::PoolTimeout, "timeout: #{@timeout}, elapsed: #{current_time - time}") if current_time > deadline
+          @waiter.wait(@mutex, deadline - current_time)
+          Thread.pass
+        end
+
+        conn
+      end
+    end
+  else
+    # :nocov:
+    def acquire(thread)
+      unless conn = sync{_acquire(thread)}
+        time = Time.now
+        timeout = time + @timeout
+        sleep_time = @sleep_time
+        sleep sleep_time
+        until conn = sync{_acquire(thread)}
+          raise(::Sequel::PoolTimeout, "timeout: #{@timeout}, elapsed: #{Time.now - time}") if Time.now > timeout
+          sleep sleep_time
+        end
+      end
+      conn
+    end
+    # :nocov:
+  end
+
   # Returns an available connection. If no connection is
   # available, tries to create a new connection. The calling code should already
   # have the mutex before calling this.
@@ -141,6 +191,10 @@ class Sequel::ThreadedConnectionPool < Sequel::ConnectionPool
   # The calling code should already have the mutex before calling this.
   def checkin_connection(conn)
     @available_connections << conn
+    if USE_WAITER
+      @waiter.signal
+      Thread.pass
+    end
     conn
   end
 

data/lib/sequel/core.rb

@@ -328,7 +328,7 @@ module Sequel
   def self.transaction(dbs, opts=OPTS, &block)
     unless opts[:rollback]
       rescue_rollback = true
-      opts = opts.merge(:rollback=>:reraise)
+      opts = Hash[opts].merge!(:rollback=>:reraise)
     end
     pr = dbs.reverse.inject(block){|bl, db| proc{db.transaction(opts, &bl)}}
     if rescue_rollback

data/lib/sequel/database/connecting.rb

@@ -6,7 +6,7 @@ module Sequel
     # ---------------------
 
     # Array of supported database adapters
-    ADAPTERS = %w'ado amalgalite cubrid db2 dbi do fdbsql firebird ibmdb informix jdbc mock mysql mysql2 odbc openbase oracle postgres sqlanywhere sqlite swift tinytds'.collect{|x| x.to_sym}
+    ADAPTERS = %w'ado amalgalite cubrid db2 dbi do fdbsql firebird ibmdb informix jdbc mock mysql mysql2 odbc openbase oracle postgres sqlanywhere sqlite swift tinytds'.collect(&:to_sym)
 
     @single_threaded = false
 
@@ -38,7 +38,7 @@ module Sequel
         if match = /\A(jdbc|do):/o.match(conn_string)
           c = adapter_class(match[1].to_sym)
           opts = opts.merge(:orig_opts=>opts.dup)
-          opts = {:uri=>conn_string}.merge(opts)
+          opts = {:uri=>conn_string}.merge!(opts)
         else
           uri = URI.parse(conn_string)
           scheme = uri.scheme

data/lib/sequel/database/misc.rb

@@ -390,11 +390,11 @@ module Sequel
       nil
     end
     
-    NOT_NULL_CONSTRAINT_SQLSTATES = %w'23502'.freeze.each{|s| s.freeze}
-    FOREIGN_KEY_CONSTRAINT_SQLSTATES = %w'23503 23506 23504'.freeze.each{|s| s.freeze}
-    UNIQUE_CONSTRAINT_SQLSTATES = %w'23505'.freeze.each{|s| s.freeze}
-    CHECK_CONSTRAINT_SQLSTATES = %w'23513 23514'.freeze.each{|s| s.freeze}
-    SERIALIZATION_CONSTRAINT_SQLSTATES = %w'40001'.freeze.each{|s| s.freeze}
+    NOT_NULL_CONSTRAINT_SQLSTATES = %w'23502'.freeze.each(&:freeze)
+    FOREIGN_KEY_CONSTRAINT_SQLSTATES = %w'23503 23506 23504'.freeze.each(&:freeze)
+    UNIQUE_CONSTRAINT_SQLSTATES = %w'23505'.freeze.each(&:freeze)
+    CHECK_CONSTRAINT_SQLSTATES = %w'23513 23514'.freeze.each(&:freeze)
+    SERIALIZATION_CONSTRAINT_SQLSTATES = %w'40001'.freeze.each(&:freeze)
     # Given the SQLState, return the appropriate DatabaseError subclass.
     def database_specific_error_class_from_sqlstate(sqlstate)
       case sqlstate

data/lib/sequel/database/query.rb

@@ -91,7 +91,8 @@ module Sequel
     #
     # :allow_null :: Whether NULL is an allowed value for the column.
     # :db_type :: The database type for the column, as a database specific string.
-    # :default :: The database default for the column, as a database specific string.
+    # :default :: The database default for the column, as a database specific string, or nil if there is
+    #             no default value.
     # :primary_key :: Whether the columns is a primary key column.  If this column is not present,
     #                 it means that primary key information is unavailable, not that the column
     #                 is not a primary key.
@@ -166,7 +167,7 @@ module Sequel
       end
 
       cols.each do |_,c|
-        c[:ruby_default] = column_schema_to_ruby_default(c[:default], c[:type])
+        c[:ruby_default] = column_schema_to_ruby_default(c[:default], c[:type]) unless c.has_key?(:ruby_default)
         if c[:primary_key] && !auto_increment_set
           # If adapter didn't set it, assume that integer primary keys are auto incrementing
           c[:auto_increment] = primary_keys == 1 && !!(c[:db_type] =~ /int/io)

data/lib/sequel/database/schema_generator.rb

@@ -109,7 +109,7 @@ module Sequel
       #            creating a unique index on the column.
       # :unique_constraint_name :: The name to give the unique key constraint
       def column(name, type, opts = OPTS)
-        columns << {:name => name, :type => type}.merge(opts)
+        columns << {:name => name, :type => type}.merge!(opts)
         if index_opts = opts[:index]
           index(name, index_opts.is_a?(Hash) ? index_opts : {})
         end
@@ -206,7 +206,7 @@ module Sequel
       #   index [:artist_id, :name]
       #   # CREATE INDEX table_artist_id_name_index ON table (artist_id, name)
       def index(columns, opts = OPTS)
-        indexes << {:columns => Array(columns)}.merge(opts)
+        indexes << {:columns => Array(columns)}.merge!(opts)
       end
       
       # Add a column with the given type, name, and opts to the DDL.  See +column+ for available
@@ -267,7 +267,7 @@ module Sequel
       # Supports the same :deferrable option as #column. The :name option can be used
       # to name the constraint.
       def unique(columns, opts = OPTS)
-        constraints << {:type => :unique, :columns => Array(columns)}.merge(opts)
+        constraints << {:type => :unique, :columns => Array(columns)}.merge!(opts)
       end
 
       private
@@ -275,12 +275,12 @@ module Sequel
       # Add a composite primary key constraint
       def composite_primary_key(columns, *args)
         opts = args.pop || {}
-        constraints << {:type => :primary_key, :columns => columns}.merge(opts)
+        constraints << {:type => :primary_key, :columns => columns}.merge!(opts)
       end
 
       # Add a composite foreign key constraint
       def composite_foreign_key(columns, opts)
-        constraints << {:type => :foreign_key, :columns => columns}.merge(opts)
+        constraints << {:type => :foreign_key, :columns => columns}.merge!(opts)
       end
       
       add_type_method(*GENERIC_TYPES)
@@ -315,7 +315,7 @@ module Sequel
       #
       #   add_column(:name, String) # ADD COLUMN name varchar(255)
       def add_column(name, type, opts = OPTS)
-        @operations << {:op => :add_column, :name => name, :type => type}.merge(opts)
+        @operations << {:op => :add_column, :name => name, :type => type}.merge!(opts)
       end
       
       # Add a constraint with the given name and args to the DDL for the table.
@@ -337,7 +337,7 @@ module Sequel
       #
       # Supports the same :deferrable option as CreateTableGenerator#column.
       def add_unique_constraint(columns, opts = OPTS)
-        @operations << {:op => :add_constraint, :type => :unique, :columns => Array(columns)}.merge(opts)
+        @operations << {:op => :add_constraint, :type => :unique, :columns => Array(columns)}.merge!(opts)
       end
 
       # Add a foreign key with the given name and referencing the given table
@@ -364,13 +364,13 @@ module Sequel
       #               sense when using an array of columns.
       def add_foreign_key(name, table, opts = OPTS)
         return add_composite_foreign_key(name, table, opts) if name.is_a?(Array)
-        add_column(name, Integer, {:table=>table}.merge(opts))
+        add_column(name, Integer, {:table=>table}.merge!(opts))
       end
       
       # Add a full text index on the given columns to the DDL for the table.
       # See CreateTableGenerator#index for available options.
       def add_full_text_index(columns, opts = OPTS)
-        add_index(columns, {:type=>:full_text}.merge(opts))
+        add_index(columns, {:type=>:full_text}.merge!(opts))
       end
       
       # Add an index on the given columns to the DDL for the table.  See
@@ -378,7 +378,7 @@ module Sequel
       #
       #   add_index(:artist_id) # CREATE INDEX table_artist_id_index ON table (artist_id)
       def add_index(columns, opts = OPTS)
-        @operations << {:op => :add_index, :columns => Array(columns)}.merge(opts)
+        @operations << {:op => :add_index, :columns => Array(columns)}.merge!(opts)
       end
       
       # Add a primary key to the DDL for the table.  See CreateTableGenerator#column
@@ -396,7 +396,7 @@ module Sequel
       # Add a spatial index on the given columns to the DDL for the table.
       # See CreateTableGenerator#index for available options.
       def add_spatial_index(columns, opts = OPTS)
-        add_index(columns, {:type=>:spatial}.merge(opts))
+        add_index(columns, {:type=>:spatial}.merge!(opts))
       end
       
       # Remove a column from the DDL for the table.
@@ -404,7 +404,7 @@ module Sequel
       #   drop_column(:artist_id) # DROP COLUMN artist_id
       #   drop_column(:artist_id, :cascade=>true) # DROP COLUMN artist_id CASCADE
       def drop_column(name, opts=OPTS)
-        @operations << {:op => :drop_column, :name => name}.merge(opts)
+        @operations << {:op => :drop_column, :name => name}.merge!(opts)
       end
       
       # Remove a constraint from the DDL for the table. MySQL/SQLite specific options:
@@ -415,7 +415,7 @@ module Sequel
       #   drop_constraint(:unique_name) # DROP CONSTRAINT unique_name
       #   drop_constraint(:unique_name, :cascade=>true) # DROP CONSTRAINT unique_name CASCADE
       def drop_constraint(name, opts=OPTS)
-        @operations << {:op => :drop_constraint, :name => name}.merge(opts)
+        @operations << {:op => :drop_constraint, :name => name}.merge!(opts)
       end
       
       # Remove a foreign key and the associated column from the DDL for the table. General options:
@@ -449,14 +449,14 @@ module Sequel
       #   drop_index([:a, :b]) # DROP INDEX table_a_b_index
       #   drop_index([:a, :b], :name=>:foo) # DROP INDEX foo
       def drop_index(columns, options=OPTS)
-        @operations << {:op => :drop_index, :columns => Array(columns)}.merge(options)
+        @operations << {:op => :drop_index, :columns => Array(columns)}.merge!(options)
       end
 
       # Modify a column's name in the DDL for the table.
       #
       #   rename_column(:name, :artist_name) # RENAME COLUMN name TO artist_name
       def rename_column(name, new_name, opts = OPTS)
-        @operations << {:op => :rename_column, :name => name, :new_name => new_name}.merge(opts)
+        @operations << {:op => :rename_column, :name => name, :new_name => new_name}.merge!(opts)
       end
       
       # Modify a column's default value in the DDL for the table.
@@ -480,7 +480,7 @@ module Sequel
       # On MySQL, make sure to use a symbol for the name of the column, as otherwise you
       # can lose the default and NULL/NOT NULL setting for the column.
       def set_column_type(name, type, opts=OPTS)
-        @operations << {:op => :set_column_type, :name => name, :type => type}.merge(opts)
+        @operations << {:op => :set_column_type, :name => name, :type => type}.merge!(opts)
       end
       
       # Set a given column as allowing NULL values.
@@ -507,17 +507,17 @@ module Sequel
 
       # Add a composite primary key constraint
       def add_composite_primary_key(columns, opts)
-        @operations << {:op => :add_constraint, :type => :primary_key, :columns => columns}.merge(opts)
+        @operations << {:op => :add_constraint, :type => :primary_key, :columns => columns}.merge!(opts)
       end
 
       # Add a composite foreign key constraint
       def add_composite_foreign_key(columns, table, opts)
-        @operations << {:op => :add_constraint, :type => :foreign_key, :columns => columns, :table => table}.merge(opts)
+        @operations << {:op => :add_constraint, :type => :foreign_key, :columns => columns, :table => table}.merge!(opts)
       end
 
       # 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 << {:op => :drop_constraint, :type => :foreign_key, :columns => columns}.merge!(opts)
       end
     end
   end