sequel 4.26.0 → 5.37.0

data/lib/sequel/database/features.rb

@@ -1,3 +1,5 @@
+# frozen-string-literal: true
+
 module Sequel
   class Database
     # ---------------------
@@ -6,7 +8,7 @@ module Sequel
     # database supprots a given feature.
     # ---------------------
     
-    # Whether the database uses a global namespace for the index.  If
+    # Whether the database uses a global namespace for the index, true by default.  If
     # false, the indexes are going to be namespaced per table.
     def global_index_namespace?
       true
@@ -31,7 +33,7 @@ module Sequel
     end
 
     # Whether the database supports DROP TABLE IF EXISTS syntax,
-    # default is the same as #supports_create_table_if_not_exists?.
+    # false by default.
     def supports_drop_table_if_exists?
       supports_create_table_if_not_exists?
     end
@@ -47,7 +49,8 @@ module Sequel
       respond_to?(:indexes)
     end
 
-    # Whether the database supports partial indexes (indexes on a subset of a table).
+    # Whether the database supports partial indexes (indexes on a subset of a table),
+    # false by default.
     def supports_partial_indexes?
       false
     end
@@ -64,7 +67,7 @@ module Sequel
     end
 
     # Whether the database and adapter support savepoints inside prepared transactions
-    # (two-phase commit), default is false.
+    # (two-phase commit), false by default.
     def supports_savepoints_in_prepared_transactions?
       supports_prepared_transactions? && supports_savepoints?
     end
@@ -106,6 +109,19 @@ module Sequel
 
     private
 
+    # Whether the database supports adding primary key constraints on NULLable columns,
+    # automatically making them NOT NULL.  If false, the columns must be set NOT NULL
+    # before the primary key constraint is added.
+    def can_add_primary_key_constraint_on_nullable_columns?
+      true
+    end
+
+    # Whether this dataset considers unquoted identifiers as uppercase. True
+    # by default as that is the SQL standard
+    def folds_unquoted_identifiers_to_uppercase?
+      true
+    end
+    
     # Whether the database supports combining multiple alter table
     # operations into a single query, false by default.
     def supports_combining_alter_table_ops?

data/lib/sequel/database/logging.rb

@@ -1,3 +1,5 @@
+# frozen-string-literal: true
+
 module Sequel
   class Database
     # ---------------------
@@ -12,6 +14,9 @@ module Sequel
     # Array of SQL loggers to use for this database.
     attr_accessor :loggers
     
+    # Whether to include information about the connection in use when logging queries.
+    attr_accessor :log_connection_info
+    
     # Log level at which to log SQL queries.  This is actually the method
     # sent to the logger, so it should be the method name symbol. The default
     # is :info, it can be set to :debug to log at DEBUG level.
@@ -29,17 +34,18 @@ module Sequel
 
     # Yield to the block, logging any errors at error level to all loggers,
     # and all other queries with the duration at warn or info level.
-    def log_yield(sql, args=nil)
-      return yield if @loggers.empty?
-      sql = "#{sql}; #{args.inspect}" if args
-      start = Time.now
+    def log_connection_yield(sql, conn, args=nil)
+      return yield if skip_logging?
+      sql = "#{connection_info(conn) if conn && log_connection_info}#{sql}#{"; #{args.inspect}" if args}"
+      timer = Sequel.start_timer
+
       begin
         yield
       rescue => e
         log_exception(e, sql)
         raise
       ensure
-        log_duration(Time.now - start, sql) unless e
+        log_duration(Sequel.elapsed_seconds_since(timer), sql) unless e
       end
     end
 
@@ -51,11 +57,23 @@ module Sequel
     end
 
     private
+
+    # Determine if logging should be skipped. Defaults to true if no loggers
+    # have been specified.
+    def skip_logging?
+      @loggers.empty?
+    end
+
+    # String including information about the connection, for use when logging
+    # connection info.
+    def connection_info(conn)
+      "(conn: #{conn.__id__}) "
+    end
     
     # Log the given SQL and then execute it on the connection, used by
     # the transaction code.
     def log_connection_execute(conn, sql)
-      log_yield(sql){conn.send(connection_execute_method, sql)}
+      log_connection_yield(sql, conn){conn.public_send(connection_execute_method, sql)}
     end
 
     # Log message with message prefixed by duration at info level, or
@@ -67,7 +85,7 @@ module Sequel
     # Log message at level (which should be :error, :warn, or :info)
     # to all loggers.
     def log_each(level, message)
-      @loggers.each{|logger| logger.send(level, message)}
+      @loggers.each{|logger| logger.public_send(level, message)}
     end
   end
 end

data/lib/sequel/database/misc.rb

@@ -1,3 +1,5 @@
+# frozen-string-literal: true
+
 module Sequel
   class Database
     # ---------------------
@@ -24,16 +26,8 @@ module Sequel
       :time=>Sequel::SQLTime, :boolean=>[TrueClass, FalseClass].freeze, :float=>Float, :decimal=>BigDecimal,
       :blob=>Sequel::SQL::Blob}.freeze
 
-    # Module to be included in shared adapters so that when the DatabaseMethods are
-    # included in the database, the identifier mangling defaults are reset correctly.
-    module ResetIdentifierMangling
-      def extended(obj)
-        obj.send(:reset_identifier_mangling)
-      end
-    end
-
     # Nested hook Proc; each new hook Proc just wraps the previous one.
-    @initialize_hook = Proc.new {|db| }
+    @initialize_hook = proc{|db| }
 
     # Register a hook that will be run when a new Database is instantiated. It is
     # called with the new database handle.
@@ -41,7 +35,7 @@ module Sequel
       raise Error, "must provide block to after_initialize" unless block
       Sequel.synchronize do
         previous = @initialize_hook
-        @initialize_hook = Proc.new do |db|
+        @initialize_hook = proc do |db|
           previous.call(db)
           block.call(db)
         end
@@ -78,11 +72,13 @@ module Sequel
     # Converts a uri to an options hash. These options are then passed
     # to a newly created database object. 
     def self.uri_to_options(uri)
-      { :user => uri.user,
+      {
+        :user => uri.user,
         :password => uri.password,
-        :host => uri.host,
         :port => uri.port,
-        :database => (m = /\/(.*)/.match(uri.path)) && (m[1]) }
+        :host => uri.hostname,
+        :database => (m = /\/(.*)/.match(uri.path)) && (m[1])
+      }
     end
     private_class_method :uri_to_options
 
@@ -99,91 +95,110 @@ module Sequel
     # options hash.
     #
     # Accepts the following options:
+    # :cache_schema :: Whether schema should be cached for this Database instance
     # :default_string_column_size :: The default size of string columns, 255 by default.
-    # :identifier_input_method :: A string method symbol to call on identifiers going into the database.
-    # :identifier_output_method :: A string method symbol to call on identifiers coming from the database.
+    # :extensions :: Extensions to load into this Database instance.  Can be a symbol, array of symbols,
+    #                or string with extensions separated by columns.  These extensions are loaded after
+    #                connections are made by the :preconnect option.
+    # :keep_reference :: Whether to keep a reference to this instance in Sequel::DATABASES, true by default.
     # :logger :: A specific logger to use.
     # :loggers :: An array of loggers to use.
-    # :preconnect :: Whether to automatically connect to the maximum number of servers.
+    # :log_connection_info :: Whether connection information should be logged when logging queries.
+    # :log_warn_duration :: The number of elapsed seconds after which queries should be logged at warn level.
+    # :name :: A name to use for the Database object, displayed in PoolTimeout .
+    # :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.
+    #                Set to :concurrently to create the connections in separate threads. Otherwise
+    #                they'll be created sequentially.
+    # :preconnect_extensions :: Similar to the :extensions option, but loads the extensions before the
+    #                           connections are made by the :preconnect option.
     # :quote_identifiers :: Whether to quote identifiers.
     # :servers :: A hash specifying a server/shard specific options, keyed by shard symbol .
     # :single_threaded :: Whether to use a single-threaded connection pool.
     # :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)
+    # All options given are also passed to the connection pool.  Additional options respected by
+    # the connection pool are :after_connect, :connect_sqls, :max_connections, :pool_timeout,
+    # :servers, and :servers_hash.  See the connection pool documentation for details.
+    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 = {}
+      @opts[:single_threaded] = @single_threaded = typecast_value_boolean(@opts.fetch(:single_threaded, Sequel.single_threaded))
       @default_string_column_size = @opts[:default_string_column_size] || DEFAULT_STRING_COLUMN_SIZE
+
+      @schemas = {}
       @prepared_statements = {}
       @transactions = {}
-      @identifier_input_method = nil
-      @identifier_output_method = nil
-      @quote_identifiers = nil
+      @symbol_literal_cache = {}
+
       @timezone = nil
+
       @dataset_class = dataset_class_default
       @cache_schema = typecast_value_boolean(@opts.fetch(:cache_schema, true))
       @dataset_modules = []
-      @symbol_literal_cache = {}
+      @loaded_extensions = []
       @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
+      reset_default_dataset
       adapter_initialize
 
-      unless typecast_value_boolean(@opts[:keep_reference]) == false
-        Sequel.synchronize{::Sequel::DATABASES.push(self)}
-      end
-      Sequel::Database.run_after_initialize(self)
-      @pool.send(:preconnect) if typecast_value_boolean(@opts[:preconnect]) && @pool.respond_to?(:preconnect, true)
-    end
-
-    # 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]
-          (h[:after_commit] ||= []) << block
-        else
-          yield
+      keep_reference = typecast_value_boolean(@opts[:keep_reference]) != false
+      begin
+        Sequel.synchronize{::Sequel::DATABASES.push(self)} if keep_reference
+        Sequel::Database.run_after_initialize(self)
+
+        initialize_load_extensions(:preconnect_extensions)
+
+        if typecast_value_boolean(@opts[:preconnect]) && @pool.respond_to?(:preconnect, true)
+          concurrent = typecast_value_string(@opts[:preconnect]) == "concurrently"
+          @pool.send(:preconnect, concurrent)
         end
+
+        initialize_load_extensions(:extensions)
+      rescue
+        Sequel.synchronize{::Sequel::DATABASES.delete(self)} if keep_reference
+        raise
       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]
-          (h[:after_rollback] ||= []) << block
-        end
-      end
+
+    # Freeze internal data structures for the Database instance.
+    def freeze
+      valid_connection_sql
+      metadata_dataset
+      @opts.freeze
+      @loggers.freeze
+      @pool.freeze
+      @dataset_class.freeze
+      @dataset_modules.freeze
+      @schema_type_classes.freeze
+      @loaded_extensions.freeze
+      metadata_dataset
+      super
     end
-    
+
+    # Disallow dup/clone for Database instances
+    undef_method :dup, :clone, :initialize_copy
+    # :nocov:
+    if RUBY_VERSION >= '1.9.3'
+    # :nocov:
+      undef_method :initialize_clone, :initialize_dup
+    end
+
     # Cast the given type to a literal type
     #
     #   DB.cast_type_literal(Float) # double precision
-    #   DB.cast_type_literal(:foo) # foo
+    #   DB.cast_type_literal(:foo)  # foo
     def cast_type_literal(type)
       type_literal(:type=>type)
     end
@@ -197,7 +212,10 @@ module Sequel
       Sequel.extension(*exts)
       exts.each do |ext|
         if pr = Sequel.synchronize{EXTENSIONS[ext]}
-          pr.call(self)
+          unless Sequel.synchronize{@loaded_extensions.include?(ext)}
+            Sequel.synchronize{@loaded_extensions << ext}
+            pr.call(self)
+          end
         else
           raise(Error, "Extension #{ext} does not have specific support handling individual databases (try: Sequel.extension #{ext.inspect})")
         end
@@ -212,13 +230,6 @@ module Sequel
       Sequel.convert_output_timestamp(v, timezone)
     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 string representation of the database object including the
     # class name and connection URI and options used when connecting (if any).
     def inspect
@@ -232,8 +243,8 @@ module Sequel
 
     # Proxy the literal call to the dataset.
     #
-    #   DB.literal(1) # 1
-    #   DB.literal(:a) # a
+    #   DB.literal(1)   # 1
+    #   DB.literal(:a)  # a
     #   DB.literal('a') # 'a'
     def literal(v)
       schema_utility_dataset.literal(v)
@@ -267,20 +278,18 @@ module Sequel
       @schema_type_classes[type]
     end
     
-    # Default serial primary key options, used by the table creation
-    # code.
+    # Default serial primary key options, used by the table creation code.
     def serial_primary_key_options
       {:primary_key => true, :type => Integer, :auto_increment => true}
     end
 
     # Cache the prepared statement object at the given name.
     def set_prepared_statement(name, ps)
-      ps.prepared_sql
       Sequel.synchronize{prepared_statements[name] = ps}
     end
 
     # Whether this database instance uses multiple servers, either for sharding
-    # or for master/slave.
+    # or for primary/replica configurations.
     def sharded?
       @sharded
     end
@@ -306,6 +315,7 @@ module Sequel
       return nil if value.nil?
       meth = "typecast_value_#{column_type}"
       begin
+        # Allow calling private methods as per-type typecasting methods are private
         respond_to?(meth, true) ? send(meth, value) : value
       rescue ArgumentError, TypeError => e
         raise Sequel.convert_exception_class(e, InvalidValue)
@@ -347,11 +357,6 @@ module Sequel
       end
     end
 
-    # Which transaction errors to translate, blank by default.
-    def database_error_classes
-      []
-    end
-
     # An enumerable yielding pairs of regexps and exception classes, used
     # to match against underlying driver exception messages in
     # order to raise a more specific Sequel::DatabaseError subclass.
@@ -365,8 +370,7 @@ module Sequel
       database_specific_error_class(exception, opts) || DatabaseError
     end
     
-    # Return the SQLState for the given exception, if one can be
-    # determined
+    # Return the SQLState for the given exception, if one can be determined
     def database_exception_sqlstate(exception, opts)
       nil
     end
@@ -416,8 +420,24 @@ module Sequel
       opts[:disconnect]
     end
     
+    # Load extensions during initialization from the given key in opts.
+    def initialize_load_extensions(key)
+      case exts = @opts[key]
+      when String
+        extension(*exts.split(',').map(&:to_sym))
+      when Array
+        extension(*exts)
+      when Symbol
+        extension(exts)
+      when nil
+        # nothing
+      else
+        raise Error, "unsupported Database #{key.inspect} option: #{@opts[key].inspect}"
+      end
+    end
+
     # Convert the given exception to an appropriate Sequel::DatabaseError
-    # subclass, keeping message and traceback.
+    # subclass, keeping message and backtrace.
     def raise_error(exception, opts=OPTS)
       if !opts[:classes] || Array(opts[:classes]).any?{|c| exception.is_a?(c)}
         raise Sequel.convert_exception_class(exception, database_error_class(exception, opts))
@@ -461,16 +481,14 @@ module Sequel
     def typecast_value_datetime(value)
       Sequel.typecast_to_application_timestamp(value)
     end
-
-    # Typecast the value to a BigDecimal
-    def typecast_value_decimal(value)
-      case value
-      when BigDecimal
-        value
-      when Numeric
-        BigDecimal.new(value.to_s)
-      when String
-        d = BigDecimal.new(value)
+    
+    if RUBY_VERSION >= '2.4'
+      # Typecast a string to a BigDecimal
+      alias _typecast_value_string_to_decimal BigDecimal
+    else
+      # :nocov:
+      def _typecast_value_string_to_decimal(value)
+        d = BigDecimal(value)
         if d.zero?
           # BigDecimal parsing is loose by default, returning a 0 value for
           # invalid input.  If a zero value is received, use Float to check
@@ -482,33 +500,30 @@ module Sequel
           end
         end
         d
+      end
+      # :nocov:
+    end
+
+    # Typecast the value to a BigDecimal
+    def typecast_value_decimal(value)
+      case value
+      when BigDecimal
+        value
+      when Numeric
+        BigDecimal(value.to_s)
+      when String
+        _typecast_value_string_to_decimal(value)
       else
         raise InvalidValue, "invalid value for BigDecimal: #{value.inspect}"
       end
     end
 
     # Typecast the value to a Float
-    def typecast_value_float(value)
-      Float(value)
-    end
+    alias typecast_value_float Float
 
-    # Used for checking/removing leading zeroes from strings so they don't get
-    # interpreted as octal.
-    LEADING_ZERO_RE = /\A0+(\d)/.freeze
-    if RUBY_VERSION >= '1.9'
-      # Typecast the value to an Integer
-      def typecast_value_integer(value)
-        (value.is_a?(String) && value =~ LEADING_ZERO_RE) ? Integer(value, 10) : Integer(value)
-      end
-    else
-    # :nocov:
-      # Replacement string when replacing leading zeroes.
-      LEADING_ZERO_REP = "\\1".freeze 
-      # Typecast the value to an Integer
-      def typecast_value_integer(value)
-        Integer(value.is_a?(String) ? value.sub(LEADING_ZERO_RE, LEADING_ZERO_REP) : value)
-      end
-    # :nocov:
+    # Typecast the value to an Integer
+    def typecast_value_integer(value)
+      (value.is_a?(String) && value =~ /\A0+(\d)/) ? Integer(value, 10) : Integer(value)
     end
 
     # Typecast the value to a String
@@ -528,8 +543,7 @@ module Sequel
         if value.is_a?(SQLTime)
           value
         else
-          # specifically check for nsec == 0 value to work around JRuby 1.6 ruby 1.9 mode bug
-          SQLTime.create(value.hour, value.min, value.sec, (value.respond_to?(:nsec) && value.nsec != 0) ? value.nsec/1000.0 : value.usec)
+          SQLTime.create(value.hour, value.min, value.sec, value.nsec/1000.0)
         end
       when String
         Sequel.string_to_time(value)