sequel 4.26.0 → 5.37.0

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

@@ -1,3 +1,5 @@
+# frozen-string-literal: true
+
 module Sequel::Database::SplitAlterTable
   private
 

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

@@ -1,17 +1,16 @@
+# frozen-string-literal: true
+
 module Sequel 
   class Dataset
     module StoredProcedureMethods
       # The name of the stored procedure to call
-      attr_accessor :sproc_name
-      
-      # The name of the stored procedure to call
-      attr_writer :sproc_args
+      def sproc_name
+        @opts[:sproc_name]
+      end
       
       # Call the stored procedure with the given args
       def call(*args, &block)
-        sp = clone
-        sp.sproc_args = args
-        sp.run(&block)
+        clone(:sproc_args=>args).run(&block)
       end
 
       # Programmer friendly string showing this is a stored procedure,
@@ -22,7 +21,7 @@ module Sequel
       
       # Run the stored procedure with the current args on the database
       def run(&block)
-        case @sproc_type
+        case @opts[:sproc_type]
         when :select, :all
           all(&block)
         when :first
@@ -35,14 +34,6 @@ module Sequel
           delete
         end
       end
-      
-      # Set the type of the stored procedure and override the corresponding _sql
-      # method to return the empty string (since the result will be
-      # ignored anyway).
-      def sproc_type=(type)
-        @sproc_type = type
-        @opts[:sql] = ''
-      end
     end
   
     module StoredProcedures
@@ -56,18 +47,14 @@ module Sequel
       # Transform this dataset into a stored procedure that you can call
       # multiple times with new arguments.
       def prepare_sproc(type, name)
-        sp = clone
-        prepare_extend_sproc(sp)
-        sp.sproc_type = type
-        sp.sproc_name = name
-        sp
+        prepare_extend_sproc(self).clone(:sproc_type=>type, :sproc_name=>name, :sql=>'')
       end
       
       private
       
       # Extend the dataset with the stored procedure methods.
       def prepare_extend_sproc(ds)
-        ds.extend(StoredProcedureMethods)
+        ds.with_extend(StoredProcedureMethods)
       end
     end
   end

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

@@ -0,0 +1,28 @@
+# frozen-string-literal: true
+
+module Sequel
+  module UnmodifiedIdentifiers
+    module DatabaseMethods
+      private
+
+      # Databases that use this module for unquoted identifiers to lowercase.
+      def folds_unquoted_identifiers_to_uppercase?
+        false
+      end
+    end
+
+    module DatasetMethods
+      private
+
+      # Turn the given symbol/string into a symbol, keeping the current case.
+      def output_identifier(v)
+        v == '' ? :untitled : v.to_sym
+      end
+
+      # Turn the given symbol/string into a string, keeping the current case.
+      def input_identifier(v)
+        v.to_s
+      end
+    end
+  end
+end

data/lib/sequel/ast_transformer.rb

@@ -1,3 +1,5 @@
+# frozen-string-literal: true
+
 module Sequel
   # The +ASTTransformer+ class is designed to handle the abstract syntax trees
   # that Sequel uses internally and produce modified copies of them.  By itself
@@ -24,8 +26,14 @@ module Sequel
         h = {}
         o.each{|k, val| h[v(k)] = v(val)}
         h
+      when SQL::NumericExpression
+        if o.op == :extract
+          o.class.new(o.op, o.args[0], v(o.args[1]))
+        else
+          o.class.new(o.op, *v(o.args))
+        end
       when SQL::ComplexExpression
-        SQL::ComplexExpression.new(o.op, *v(o.args))
+        o.class.new(o.op, *v(o.args))
       when SQL::Identifier
         SQL::Identifier.new(v(o.value))
       when SQL::QualifiedIdentifier
@@ -47,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]
@@ -81,10 +89,8 @@ module Sequel
   # Handles qualifying existing datasets, so that unqualified columns
   # in the dataset are qualified with a given table name.
   class Qualifier < ASTTransformer
-    # Store the dataset to use as the basis for qualification, 
-    # and the table used to qualify unqualified columns. 
-    def initialize(ds, table)
-      @ds = ds
+    # Set the table used to qualify unqualified columns
+    def initialize(table)
       @table = table
     end
 
@@ -97,7 +103,7 @@ module Sequel
     def v(o)
       case o
       when Symbol
-        t, column, aliaz = @ds.send(:split_symbol, o)
+        t, column, aliaz = Sequel.split_symbol(o)
         if t
           o
         elsif aliaz
@@ -115,86 +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.filter(:a=>1).exclude(:b=>2).where{c > 3}
-  #
-  # But it cannot handle cases like:
-  #
-  #   DB.filter(: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
-      @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
 end

data/lib/sequel/connection_pool.rb

@@ -1,3 +1,5 @@
+# frozen-string-literal: true
+
 # The base connection pool class, which all other connection pools are based
 # on.  This class is not instantiated directly, but subclasses should at
 # the very least implement the following API:
@@ -24,16 +26,13 @@
 #                                     specified by the array of symbols.
 class Sequel::ConnectionPool
   OPTS = Sequel::OPTS
+  POOL_CLASS_MAP = {
+    :threaded => :ThreadedConnectionPool,
+    :single => :SingleConnectionPool,
+    :sharded_threaded => :ShardedThreadedConnectionPool,
+    :sharded_single => :ShardedSingleConnectionPool
+  }.freeze
 
-  # The default server to use
-  DEFAULT_SERVER = :default
-  
-  # A map of [single threaded, sharded] values to symbols or ConnectionPool subclasses.
-  CONNECTION_POOL_MAP = {[true, false] => :single, 
-    [true, true] => :sharded_single,
-    [false, false] => :threaded,
-    [false, true] => :sharded_threaded}
-  
   # Class methods used to return an appropriate pool subclass, separated
   # into a module for easier overridding by extensions.
   module ClassMethods
@@ -42,20 +41,33 @@ class Sequel::ConnectionPool
     # use a new instance of an appropriate pool subclass based on the
     # <tt>:single_threaded</tt> and <tt>:servers</tt> options.
     def get_pool(db, opts = OPTS)
-      case v = connection_pool_class(opts)
-      when Class
-        v.new(db, opts)
-      when Symbol
-        require("sequel/connection_pool/#{v}")
-        connection_pool_class(opts).new(db, opts) || raise(Sequel::Error, "No connection pool class found")
-      end
+      connection_pool_class(opts).new(db, opts)
     end
     
     private
     
     # Return a connection pool class based on the given options.
     def connection_pool_class(opts)
-      CONNECTION_POOL_MAP[opts[:pool_class]] || opts[:pool_class] || CONNECTION_POOL_MAP[[!!opts[:single_threaded], !!opts[:servers]]]
+      if pc = opts[:pool_class]
+        unless pc.is_a?(Class)
+          unless name = POOL_CLASS_MAP[pc]
+            raise Sequel::Error, "unsupported connection pool type, please pass appropriate class as the :pool_class option"
+          end
+
+          require_relative "connection_pool/#{pc}"
+          pc = Sequel.const_get(name)
+        end
+
+        pc
+      else
+        pc = if opts[:single_threaded]
+          opts[:servers] ? :sharded_single : :single
+        else
+          opts[:servers] ? :sharded_threaded : :threaded
+        end
+
+        connection_pool_class(:pool_class=>pc)
+      end
     end
   end
   extend ClassMethods
@@ -64,6 +76,9 @@ class Sequel::ConnectionPool
   # connection made, and is usually used to set custom per-connection settings.
   attr_accessor :after_connect
 
+  # An array of sql strings to execute on each new connection.
+  attr_accessor :connect_sqls
+
   # The Sequel::Database object tied to this connection pool.
   attr_accessor :db
 
@@ -74,31 +89,38 @@ class Sequel::ConnectionPool
   # :after_connect :: A callable object called after each new connection is made, with the
   #                   connection object (and server argument if the callable accepts 2 arguments),
   #                   useful for customizations that you want to apply to all connections.
-  # :preconnect :: Automatically create the maximum number of connections, so that they don't
-  #                need to be created as needed.  This is useful when connecting takes a long time
-  #                and you want to avoid possible latency during runtime.
+  # :connect_sqls :: An array of sql strings to execute on each new connection, after :after_connect runs.
   def initialize(db, opts=OPTS)
     @db = db
     @after_connect = opts[:after_connect]
-  end
-  
-  # Alias for +size+, not aliased directly for ease of subclass implementation
-  def created_count(*args)
-    size(*args)
+    @connect_sqls = opts[:connect_sqls]
+    @error_classes = db.send(:database_error_classes).dup.freeze
   end
   
   # An array of symbols for all shards/servers, which is a single <tt>:default</tt> by default.
   def servers
-    [DEFAULT_SERVER]
+    [:default]
   end
   
   private
+
+  # Remove the connection from the pool.  For threaded connections, this should be
+  # called without the mutex, because the disconnection may block.
+  def disconnect_connection(conn)
+    db.disconnect_connection(conn)
+  end
+
+  # Whether the given exception is a disconnect exception.
+  def disconnect_error?(exception)
+    exception.is_a?(Sequel::DatabaseDisconnectError) || db.send(:disconnect_error?, exception, OPTS)
+  end
   
   # Return a new connection by calling the connection proc with the given server name,
   # and checking for connection errors.
   def make_new(server)
     begin
       conn = @db.connect(server)
+
       if ac = @after_connect
         if ac.arity == 2
           ac.call(conn, server)
@@ -106,6 +128,12 @@ class Sequel::ConnectionPool
           ac.call(conn)
         end
       end
+
+      if cs = @connect_sqls
+        cs.each do |sql|
+          db.send(:log_connection_execute, conn, sql)
+        end
+      end
     rescue Exception=>exception
       raise Sequel.convert_exception_class(exception, Sequel::DatabaseConnectionError)
     end

data/lib/sequel/connection_pool/sharded_single.rb

@@ -1,3 +1,5 @@
+# frozen-string-literal: true
+
 # A ShardedSingleConnectionPool is a single threaded connection pool that
 # works with multiple shards/servers.
 class Sequel::ShardedSingleConnectionPool < Sequel::ConnectionPool
@@ -17,9 +19,9 @@ class Sequel::ShardedSingleConnectionPool < Sequel::ConnectionPool
     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
-  # at runtime. servers argument should be an array of symbols. 
+  # Adds new servers to the connection pool. Primarily used in conjunction with primary/replica
+  # or sharded configurations. Allows for dynamic expansion of the potential replicas/shards
+  # at runtime. +servers+ argument should be an array of symbols. 
   def add_servers(servers)
     servers.each{|s| @servers[s] = s}
   end
@@ -39,7 +41,15 @@ class Sequel::ShardedSingleConnectionPool < Sequel::ConnectionPool
   # :server :: Should be a symbol specifing the server to disconnect from,
   #            or an array of symbols to specify multiple servers.
   def disconnect(opts=OPTS)
-    (opts[:server] ? Array(opts[:server]) : servers).each{|s| disconnect_server(s)}
+    (opts[:server] ? Array(opts[:server]) : servers).each do |s|
+      raise Sequel::Error, "invalid server: #{s}" unless @servers.has_key?(s)
+      disconnect_server(s)
+    end
+  end
+
+  def freeze
+    @servers.freeze
+    super
   end
   
   # Yields the connection to the supplied block for the given server.
@@ -48,8 +58,8 @@ class Sequel::ShardedSingleConnectionPool < Sequel::ConnectionPool
     begin
       server = pick_server(server)
       yield(@conns[server] ||= make_new(server))
-    rescue Sequel::DatabaseDisconnectError
-      disconnect_server(server)
+    rescue Sequel::DatabaseDisconnectError, *@error_classes => e
+      disconnect_server(server) if disconnect_error?(e)
       raise
     end
   end
@@ -59,8 +69,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)
@@ -90,7 +99,7 @@ class Sequel::ShardedSingleConnectionPool < Sequel::ConnectionPool
   # Disconnect from the given server, if connected.
   def disconnect_server(server)
     if conn = @conns.delete(server)
-      db.disconnect_connection(conn)
+      disconnect_connection(conn)
     end
   end
 
@@ -100,9 +109,7 @@ class Sequel::ShardedSingleConnectionPool < Sequel::ConnectionPool
   end
   
   # Make sure there is a valid connection for each server.
-  def preconnect
+  def preconnect(concurrent = nil)
     servers.each{|s| hold(s){}}
   end
-  
-  CONNECTION_POOL_MAP[[true, true]] = self
 end