sequel 4.49.0 → 5.3.0

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

@@ -3,11 +3,6 @@
 module Sequel
   class Dataset
     module Replace
-      INSERT = 'INSERT'.freeze
-      Sequel::Deprecation.deprecate_constant(self, :INSERT)
-      REPLACE = 'REPLACE'.freeze
-      Sequel::Deprecation.deprecate_constant(self, :REPLACE)
-
       # Execute a REPLACE statement on the database (deletes any duplicate
       # rows before inserting).
       def replace(*values)

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

@@ -3,8 +3,6 @@
 module Sequel 
   class Dataset
     module StoredProcedureMethods
-      Dataset.def_deprecated_opts_setter(self, :sproc_type, :sproc_name, :sproc_args)
-
       # The name of the stored procedure to call
       def sproc_name
         @opts[:sproc_name]

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

@@ -1,3 +1,5 @@
+# frozen-string-literal: true
+
 module Sequel
   module UnmodifiedIdentifiers
     module DatabaseMethods

data/lib/sequel/ast_transformer.rb

@@ -55,7 +55,7 @@ module Sequel
         end
         SQL::Function.new!(o.name, v(o.args), h)
       when SQL::Subscript
-        SQL::Subscript.new(v(o.f), v(o.sub))
+        SQL::Subscript.new(v(o.expression), v(o.sub))
       when SQL::Window
         opts = o.opts.dup
         opts[:partition] = v(opts[:partition]) if opts[:partition]
@@ -90,15 +90,8 @@ module Sequel
   # in the dataset are qualified with a given table name.
   class Qualifier < ASTTransformer
     # Set the table used to qualify unqualified columns
-    def initialize(table, unused=nil)
-      if unused
-        # :nocov:
-        Sequel::Deprecation.deprecate("Passing two arguments to Sequel::Qualifier.new", 'Pass only the second argument specifying the table used for qualification')
-        @table = unused
-        # :nocov:
-      else
-        @table = table
-      end
+    def initialize(table)
+      @table = table
     end
 
     private
@@ -128,88 +121,4 @@ module Sequel
       end
     end
   end
-
-  # +Unbinder+ is used to take a dataset filter and return a modified version
-  # that unbinds already bound values and returns a dataset with bound value
-  # placeholders and a hash of bind values.  You can then prepare the dataset
-  # and use the bound variables to execute it with the same values.
-  #
-  # This class only does a limited form of unbinding where the variable names
-  # and values can be associated unambiguously.  The only cases it handles
-  # are <tt>SQL::ComplexExpression<tt> with an operator in +UNBIND_OPS+, a
-  # first argument that's an instance of a member of +UNBIND_KEY_CLASSES+, and
-  # a second argument that's an instance of a member of +UNBIND_VALUE_CLASSES+.
-  #
-  # So it can handle cases like:
-  #
-  #   DB.where(:a=>1).exclude(:b=>2).where{c > 3}
-  #
-  # But it cannot handle cases like:
-  #
-  #   DB.where(:a + 1 < 0)
-  class Unbinder < ASTTransformer
-    # The <tt>SQL::ComplexExpression<tt> operates that will be considered
-    # for transformation.
-    UNBIND_OPS = [:'=', :'!=', :<, :>, :<=, :>=]
-
-    # The key classes (first argument of the ComplexExpression) that will
-    # considered for transformation.
-    UNBIND_KEY_CLASSES = [Symbol, SQL::Identifier, SQL::QualifiedIdentifier]
-
-    # The value classes (second argument of the ComplexExpression) that
-    # will be considered for transformation.
-    UNBIND_VALUE_CLASSES = [Numeric, String, Date, Time]
-
-    # The hash of bind variables that were extracted from the dataset filter.
-    attr_reader :binds
-
-    # Intialize an empty +binds+ hash.
-    def initialize
-      Sequel::Deprecation.deprecate("Sequel::Unbinder", 'There is no replacement')
-      @binds = {}
-    end
-
-    private
-
-    # Create a suitable bound variable key for the object, which should be
-    # an instance of one of the +UNBIND_KEY_CLASSES+.
-    def bind_key(obj)
-      case obj
-      when Symbol
-        obj
-      when String
-        obj.to_sym
-      when SQL::Identifier
-        bind_key(obj.value)
-      when SQL::QualifiedIdentifier
-        :"#{bind_key(obj.table)}.#{bind_key(obj.column)}"
-      else
-        raise Error, "unhandled object in Sequel::Unbinder#bind_key: #{obj}"
-      end
-    end
-
-    # Handle <tt>SQL::ComplexExpression</tt> instances with suitable ops
-    # and arguments, substituting the value with a bound variable placeholder
-    # and assigning it an entry in the +binds+ hash with a matching key.
-    def v(o)
-      if o.is_a?(SQL::ComplexExpression) && UNBIND_OPS.include?(o.op)
-        l, r = o.args
-        l = l.value if l.is_a?(Sequel::SQL::Wrapper)
-        r = r.value if r.is_a?(Sequel::SQL::Wrapper)
-        if UNBIND_KEY_CLASSES.any?{|c| l.is_a?(c)} && UNBIND_VALUE_CLASSES.any?{|c| r.is_a?(c)} && !r.is_a?(LiteralString)
-          key = bind_key(l)
-          if (old = binds[key]) && old != r
-            raise UnbindDuplicate, "two different values for #{key.inspect}: #{[r, old].inspect}" 
-          end
-          binds[key] = r
-          SQL::ComplexExpression.new(o.op, l, :"$#{key}")
-        else
-          super
-        end
-      else
-        super
-      end
-    end
-  end
-  Sequel::Deprecation.deprecate_constant(self, :Unbinder)
 end

data/lib/sequel/connection_pool/sharded_single.rb

@@ -66,8 +66,7 @@ class Sequel::ShardedSingleConnectionPool < Sequel::ConnectionPool
     1
   end
   
-  # Remove servers from the connection pool. Primarily used in conjunction with master/slave
-  # or shard configurations.  Similar to disconnecting from all given servers,
+  # Remove servers from the connection pool. Similar to disconnecting from all given servers,
   # except that after it is used, future requests for the server will use the
   # :default server instead.
   def remove_servers(servers)
@@ -110,6 +109,4 @@ class Sequel::ShardedSingleConnectionPool < Sequel::ConnectionPool
   def preconnect(concurrent = nil)
     servers.each{|s| hold(s){}}
   end
-  
-  CONNECTION_POOL__MAP[[true, true]] = self
 end

data/lib/sequel/connection_pool/sharded_threaded.rb

@@ -1,6 +1,6 @@
 # frozen-string-literal: true
 
-require 'sequel/connection_pool/threaded'
+require_relative 'threaded'
 
 # The slowest and most advanced connection, dealing with both multi-threaded
 # access and configurations with multiple shards/servers.
@@ -20,18 +20,14 @@ 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
+    remove_instance_variable(:@waiter)
+    @waiters = {}
 
     add_servers([:default])
     add_servers(opts[:servers].keys) if opts[:servers]
   end
   
-  # Adds new servers to the connection pool. Primarily used in conjunction with master/slave
-  # or shard configurations. Allows for dynamic expansion of the potential slaves/shards
+  # Adds new servers to the connection pool.  Allows for dynamic expansion of the potential slaves/shards
   # at runtime. servers argument should be an array of symbols. 
   def add_servers(servers)
     sync do
@@ -40,7 +36,7 @@ class Sequel::ShardedThreadedConnectionPool < Sequel::ThreadedConnectionPool
           @servers[server] = server
           @available_connections[server] = []
           @allocated[server] = {}
-          @waiters[server] = ConditionVariable.new if USE_WAITER
+          @waiters[server] = ConditionVariable.new
         end
       end
     end
@@ -77,12 +73,11 @@ class Sequel::ShardedThreadedConnectionPool < Sequel::ThreadedConnectionPool
     @available_connections[server]
   end
   
-  # The total number of connections opened for the given server, should
-  # be equal to available_connections.length + allocated.length.  Nonexistent
-  # servers will return the created count of the default server.
+  # The total number of connections opened for the given server.
+  # Nonexistent servers will return the created count of the default server.
+  # The calling code should not have the mutex before calling this.
   def size(server=:default)
-    server = @servers[server]
-    @allocated[server].length + @available_connections[server].length
+    @mutex.synchronize{_size(server)}
   end
   
   # Removes all connections currently available on all servers, optionally
@@ -120,8 +115,7 @@ class Sequel::ShardedThreadedConnectionPool < Sequel::ThreadedConnectionPool
   # If no connection is immediately available and the pool is already using the maximum
   # number of connections, Pool#hold will block until a connection
   # is available or the timeout expires.  If the timeout expires before a
-  # connection can be acquired, a Sequel::PoolTimeout is 
-  # raised.
+  # connection can be acquired, a Sequel::PoolTimeout is raised.
   def hold(server=:default)
     server = pick_server(server)
     t = Thread.current
@@ -139,8 +133,7 @@ class Sequel::ShardedThreadedConnectionPool < Sequel::ThreadedConnectionPool
     end
   end
 
-  # Remove servers from the connection pool. Primarily used in conjunction with master/slave
-  # or shard configurations.  Similar to disconnecting from all given servers,
+  # Remove servers from the connection pool. Similar to disconnecting from all given servers,
   # except that after it is used, future requests for the server will use the
   # :default server instead.
   def remove_servers(servers)
@@ -150,7 +143,7 @@ class Sequel::ShardedThreadedConnectionPool < Sequel::ThreadedConnectionPool
       servers.each do |server|
         if @servers.include?(server)
           conns = disconnect_server_connections(server)
-          @waiters.delete(server) if USE_WAITER
+          @waiters.delete(server)
           @available_connections.delete(server)
           @allocated.delete(server)
           @servers.delete(server)
@@ -174,71 +167,89 @@ 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 already have the mutex when
-  # calling this.
-  def _acquire(thread, server)
-    if conn = available(server)
-      allocated(server)[thread] = conn
-    end
+  # The total number of connections opened for the given server.
+  # The calling code should already have the mutex before calling this.
+  def _size(server)
+    server = @servers[server]
+    @allocated[server].length + @available_connections[server].length
   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)
+  # 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)
+    if conn = assign_connection(thread, server)
+      return conn
+    end
+
+    time = Time.now
+
+    sync do
+      @waiters[server].wait(@mutex, @timeout)
+      if conn = next_available(server)
+        return(allocated(server)[thread] = conn)
+      end
+    end
+
+    until conn = assign_connection(thread, server)
+      deadline ||= time + @timeout
+      current_time = Time.now
+      raise_pool_timeout(current_time - time, server) if current_time > deadline
+      # :nocov:
+      # It's difficult to get to this point, it can only happen if there is a race condition
+      # where a connection cannot be acquired even after the thread is signalled by the condition
       sync do
-        if conn = _acquire(thread, server)
-          return conn
+        @waiters[server].wait(@mutex, deadline - current_time)
+        if conn = next_available(server)
+          return(allocated(server)[thread] = conn)
         end
+      end
+      # :nocov:
+    end
+
+    conn
+  end
 
-        time = Time.now
-        @waiters[server].wait(@mutex, @timeout)
-        Thread.pass
+  # Assign a connection to the thread, or return nil if one cannot be assigned.
+  # The caller should NOT have the mutex before calling this.
+  def assign_connection(thread, server)
+    alloc = allocated(server)
 
-        until conn = _acquire(thread, server)
-          deadline ||= time + @timeout
-          current_time = Time.now
-          raise_pool_timeout(current_time - time, server) if current_time > deadline
-          # :nocov:
-          # It's difficult to get to this point, it can only happen if there is a race condition
-          # where a connection cannot be acquired even after the thread is signalled by the condition
-          # variable that a connection is ready.
-          @waiters[server].wait(@mutex, deadline - current_time)
-          Thread.pass
-          # :nocov:
-        end
+    do_make_new = false
+    sync do
+      if conn = next_available(server)
+        alloc[thread] = conn
+        return conn
+      end
+
+      if (n = _size(server)) >= (max = @max_size)
+        alloc.to_a.each{|t,c| release(t, c, server) unless t.alive?}
+        n = nil
+      end
 
-        conn
+      if (n || _size(server)) < max
+        do_make_new = alloc[thread] = true
       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_pool_timeout(Time.now - time, server) if Time.now > timeout
-          sleep sleep_time
+
+    # Connect to the database outside of the connection pool mutex,
+    # as that can take a long time and the connection pool mutex
+    # shouldn't be locked while the connection takes place.
+    if do_make_new
+      begin
+        conn = make_new(server)
+        sync{alloc[thread] = conn}
+      ensure
+        unless conn
+          sync{alloc.delete(thread)}
         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.
-  def available(server)
-    next_available(server) || make_new(server)
+    conn
   end
 
   # Return a connection to the pool of available connections for the server,
@@ -246,10 +257,7 @@ 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
+    @waiters[server].signal
     conn
   end
 
@@ -263,29 +271,18 @@ class Sequel::ShardedThreadedConnectionPool < Sequel::ThreadedConnectionPool
     if dis_conns = available_connections(server)
       conns = dis_conns.dup
       dis_conns.clear
+      @waiters[server].signal
     end
     conns
   end
 
-  # Disconnect all given connections.  
-  # immediately, and schedules currently allocated connections for disconnection
+  # Disconnect all available connections immediately, and schedule currently allocated connections for disconnection
   # as soon as they are returned to the pool. The calling code should not
   # have the mutex before calling this.
   def disconnect_connections(conns)
     conns.each{|conn| disconnect_connection(conn)}
   end
 
-  # Creates a new connection to the given server if the size of the pool for
-  # the server is less than the maximum size of the pool. The calling code
-  # should already have the mutex before calling this.
-  def make_new(server)
-    if (n = size(server)) >= @max_size
-      allocated(server).to_a.each{|t, c| release(t, c, server) unless t.alive?}
-      n = nil
-    end
-    default_make_new(server) if (n || size(server)) < @max_size
-  end
-
   # Return the next available connection in the pool for the given server, or nil
   # if there is not currently an available connection for the server.
   # The calling code should already have the mutex before calling this.
@@ -309,17 +306,20 @@ class Sequel::ShardedThreadedConnectionPool < Sequel::ThreadedConnectionPool
     sync{@servers[server]}
   end
   
-  # Create the maximum number of connections to each server immediately.
+  # Create the maximum number of connections immediately.  The calling code should
+  # NOT have the mutex before calling this.
   def preconnect(concurrent = false)
-    conn_servers = @servers.keys.map{|s| Array.new(max_size - size(s), s)}.flatten
+    conn_servers = @servers.keys.map!{|s| Array.new(max_size - _size(s), s)}.flatten!
 
     if concurrent
-      conn_servers.map{|s| Thread.new{[s, make_new(s)]}}.map(&:join).each{|t| checkin_connection(*t.value)}
+      conn_servers.map!{|s| Thread.new{[s, make_new(s)]}}.map!(&:value)
     else
-      conn_servers.each{|s| checkin_connection(s, make_new(s))}
+      conn_servers.map!{|s| [s, make_new(s)]}
     end
+
+    sync{conn_servers.each{|s, conn| checkin_connection(s, conn)}}
   end
-  
+
   # Raise a PoolTimeout error showing the current timeout, the elapsed time, the server
   # the connection attempt was made to, and the database's name (if any).
   def raise_pool_timeout(elapsed, server)
@@ -343,6 +343,10 @@ class Sequel::ShardedThreadedConnectionPool < Sequel::ThreadedConnectionPool
         checkin_connection(server, conn)
       end
     end
+
+    if waiter = @waiters[server]
+      waiter.signal
+    end
   end
 
   # Removes the currently allocated connection from the connection pool. The
@@ -352,6 +356,4 @@ class Sequel::ShardedThreadedConnectionPool < Sequel::ThreadedConnectionPool
     allocated(server).delete(thread) if @servers.include?(server)
     disconnect_connection(conn)
   end
-  
-  CONNECTION_POOL__MAP[[false, true]] = self
 end

data/lib/sequel/connection_pool/single.rb

@@ -56,6 +56,4 @@ class Sequel::SingleConnectionPool < Sequel::ConnectionPool
   def preconnect(concurrent = nil)
     hold{}
   end
-
-  CONNECTION_POOL__MAP[[true, false]] = self
 end