sequel 5.8.0 → 5.38.0

data/lib/sequel/database/connecting.rb

@@ -36,7 +36,7 @@ module Sequel
           c = adapter_class(scheme)
           uri_options = c.send(:uri_to_options, uri)
           uri.query.split('&').map{|s| s.split('=')}.each{|k,v| uri_options[k.to_sym] = v if k && !k.empty?} unless uri.query.to_s.strip.empty?
-          uri_options.to_a.each{|k,v| uri_options[k] = (defined?(URI::DEFAULT_PARSER) ? URI::DEFAULT_PARSER : URI).unescape(v) if v.is_a?(String)}
+          uri_options.to_a.each{|k,v| uri_options[k] = URI::DEFAULT_PARSER.unescape(v) if v.is_a?(String)}
           opts = uri_options.merge(opts).merge!(:orig_opts=>opts.dup, :uri=>conn_string, :adapter=>scheme)
         end
       when Hash
@@ -55,7 +55,6 @@ module Sequel
 
       begin
         db = c.new(opts)
-        db.test_connection if db.send(:typecast_value_boolean, opts.fetch(:test, true))
         if block_given?
           return yield(db)
         end
@@ -248,6 +247,12 @@ module Sequel
     end
     
     if RUBY_ENGINE == 'ruby' && RUBY_VERSION < '2.5'
+    # :nocov:
+      def synchronize(server=nil)
+        @pool.hold(server || :default){|conn| yield conn}
+      end
+    # :nocov:
+    else
       # Acquires a database connection, yielding it to the passed block. This is
       # useful if you want to make sure the same connection is used for all
       # database queries in the block.  It is also useful if you want to gain
@@ -260,15 +265,9 @@ module Sequel
       #   DB.synchronize do |conn|
       #     # ...
       #   end
-      def synchronize(server=nil)
-        @pool.hold(server || :default){|conn| yield conn}
-      end
-    else
-    # :nocov:
       def synchronize(server=nil, &block)
         @pool.hold(server || :default, &block)
       end
-    # :nocov:
     end
     
     # Attempts to acquire a database connection.  Returns true if successful.

data/lib/sequel/database/logging.rb

@@ -35,7 +35,7 @@ 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_connection_yield(sql, conn, args=nil)
-      return yield if @loggers.empty?
+      return yield if skip_logging?
       sql = "#{connection_info(conn) if conn && log_connection_info}#{sql}#{"; #{args.inspect}" if args}"
       timer = Sequel.start_timer
 
@@ -58,6 +58,12 @@ module Sequel
 
     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)

data/lib/sequel/database/misc.rb

@@ -27,7 +27,7 @@ module Sequel
       :blob=>Sequel::SQL::Blob}.freeze
 
     # 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.
@@ -35,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
@@ -97,20 +97,30 @@ module Sequel
     # 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.
+    # :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.
     # :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.
-    # :preconnect :: Whether to automatically connect to the maximum number of servers.  Can use a valid
-    #                of 'concurrently' to preconnect in separate threads.
+    # :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.
+    # 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)
@@ -143,26 +153,23 @@ module Sequel
       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)
-      if typecast_value_boolean(@opts[:preconnect]) && @pool.respond_to?(:preconnect, true)
-        concurrent = typecast_value_string(@opts[:preconnect]) == "concurrently"
-        @pool.send(:preconnect, concurrent)
-      end
+      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)
 
-      case exts = @opts[:extensions]
-      when String
-        extension(*exts.split(',').map(&:to_sym))
-      when Array
-        extension(*exts)
-      when Symbol
-        extension(exts)
-      when nil
-        # nothing
-      else
-        raise Error, "unsupported Database :extensions option: #{@opts[:extensions].inspect}"
+        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)
+        test_connection if typecast_value_boolean(@opts.fetch(:test, true)) && respond_to?(:connect, true)
+      rescue
+        Sequel.synchronize{::Sequel::DATABASES.delete(self)} if keep_reference
+        raise
       end
     end
 
@@ -183,7 +190,9 @@ module Sequel
 
     # 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
 
@@ -281,7 +290,7 @@ module Sequel
     end
 
     # Whether this database instance uses multiple servers, either for sharding
-    # or for master/slave.
+    # or for primary/replica configurations.
     def sharded?
       @sharded
     end
@@ -412,6 +421,22 @@ 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 backtrace.
     def raise_error(exception, opts=OPTS)
@@ -422,6 +447,19 @@ module Sequel
       end
     end
 
+    # Swallow database errors, unless they are connect/disconnect errors.
+    def swallow_database_error
+      yield
+    rescue Sequel::DatabaseDisconnectError, DatabaseConnectionError
+      # Always raise disconnect errors
+      raise
+    rescue Sequel::DatabaseError
+      # Don't raise other database errors.
+      nil
+    # else
+    #   Don't rescue other exceptions, they will be raised normally.
+    end
+
     # Typecast the value to an SQL::Blob
     def typecast_value_blob(value)
       value.is_a?(Sequel::SQL::Blob) ? value : Sequel::SQL::Blob.new(value)
@@ -460,13 +498,11 @@ module Sequel
     
     if RUBY_VERSION >= '2.4'
       # Typecast a string to a BigDecimal
-      def _typecast_value_string_to_decimal(value)
-        BigDecimal.new(value)
-      end
+      alias _typecast_value_string_to_decimal BigDecimal
     else
       # :nocov:
       def _typecast_value_string_to_decimal(value)
-        d = BigDecimal.new(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
@@ -488,7 +524,7 @@ module Sequel
       when BigDecimal
         value
       when Numeric
-        BigDecimal.new(value.to_s)
+        BigDecimal(value.to_s)
       when String
         _typecast_value_string_to_decimal(value)
       else
@@ -497,9 +533,7 @@ module Sequel
     end
 
     # Typecast the value to a Float
-    def typecast_value_float(value)
-      Float(value)
-    end
+    alias typecast_value_float Float
 
     # Typecast the value to an Integer
     def typecast_value_integer(value)

data/lib/sequel/database/query.rb

@@ -32,7 +32,7 @@ module Sequel
     #
     #   DB[:items].where(id: 1).prepare(:first, :sa)
     #   DB.call(:sa) # SELECT * FROM items WHERE id = 1
-    def call(ps_name, hash={}, &block)
+    def call(ps_name, hash=OPTS, &block)
       prepared_statement(ps_name).call(hash, &block)
     end
     
@@ -240,7 +240,7 @@ module Sequel
       when :time
         Sequel.string_to_time(default)
       when :decimal
-        BigDecimal.new(default)
+        BigDecimal(default)
       end
     end
    
@@ -325,13 +325,13 @@ module Sequel
         :integer
       when /\Adate\z/io
         :date
-      when /\A((small)?datetime|timestamp( with(out)? time zone)?)(\(\d+\))?\z/io
+      when /\A((small)?datetime|timestamp(\(\d\))?( with(out)? time zone)?)\z/io
         :datetime
       when /\Atime( with(out)? time zone)?\z/io
         :time
       when /\A(bool(ean)?)\z/io
         :boolean
-      when /\A(real|float|double( precision)?|double\(\d+,\d+\)( unsigned)?)\z/io
+      when /\A(real|float( unsigned)?|double( precision)?|double\(\d+,\d+\)( unsigned)?)\z/io
         :float
       when /\A(?:(?:(?:num(?:ber|eric)?|decimal)(?:\(\d+,\s*(\d+|false|true)\))?))\z/io
         $1 && ['0', 'false'].include?($1) ? :integer : :decimal
@@ -344,7 +344,9 @@ module Sequel
 
     # Post process the schema values.  
     def schema_post_process(cols)
+      # :nocov:
       if RUBY_VERSION >= '2.5'
+      # :nocov:
         cols.each do |_, h|
           db_type = h[:db_type]
           if db_type.is_a?(String)

data/lib/sequel/database/schema_generator.rb

@@ -38,7 +38,6 @@ module Sequel
         @constraints = []
         @primary_key = nil
         instance_exec(&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
@@ -67,7 +66,7 @@ module Sequel
             method = type.to_s
           end
 
-          define_method(method){|name, opts={}| column(name, type, opts)}
+          define_method(method){|name, opts=OPTS| column(name, type, opts)}
         end
         nil
       end
@@ -81,7 +80,8 @@ module Sequel
         constraint(nil, *args, &block)
       end
 
-      # Add a column with the given name, type, and opts      #
+      # Add a column with the given name, type, and opts:
+      #
       #   column :num, :integer
       #   # num INTEGER
       #
@@ -109,6 +109,9 @@ module Sequel
       #                yet exist on referenced table (but will exist before the transaction commits).
       #                Basically it adds DEFERRABLE INITIALLY DEFERRED on key creation.
       #                If you use :immediate as the value, uses DEFERRABLE INITIALLY IMMEDIATE.
+      # :generated_always_as :: Specify a GENERATED ALWAYS AS column expression,
+      #                         if generated columns are supported (PostgreSQL 12+, MariaDB 5.2.0+,
+      #                         and MySQL 5.7.6+).
       # :index :: Create an index on this column.  If given a hash, use the hash as the
       #           options for the index.
       # :key :: For foreign key columns, the column in the associated table
@@ -122,18 +125,30 @@ module Sequel
       # :on_update :: Specify the behavior of this column when being updated
       #               (:restrict, :cascade, :set_null, :set_default, :no_action).
       # :primary_key :: Make the column as a single primary key column.  This should not
-      #                 be used if you have a single, nonautoincrementing primary key column
+      #                 be used if you want a single autoincrementing primary key column
       #                 (use the primary_key method in that case).
       # :primary_key_constraint_name :: The name to give the primary key constraint
+      # :primary_key_deferrable :: Similar to :deferrable, but for the primary key constraint
+      #                            if :primary_key is used.
       # :type :: Overrides the type given as the argument.  Generally not used by column
       #          itself, but can be passed as an option to other methods that call column.
       # :unique :: Mark the column as unique, generally has the same effect as
       #            creating a unique index on the column.
       # :unique_constraint_name :: The name to give the unique key constraint
+      # :unique_deferrable :: Similar to :deferrable, but for the unique constraint if :unique
+      #                       is used.
+      #
+      # PostgreSQL specific options:
+      #
+      # :identity :: Create an identity column.
+      #
+      # MySQL specific options:
+      # :generated_type :: Set the type of column when using :generated_always_as,
+      #                    should be :virtual or :stored to force a type.
       def column(name, type, opts = OPTS)
         columns << {:name => name, :type => type}.merge!(opts)
         if index_opts = opts[:index]
-          index(name, index_opts.is_a?(Hash) ? index_opts : {})
+          index(name, index_opts.is_a?(Hash) ? index_opts : OPTS)
         end
         nil
       end
@@ -152,7 +167,7 @@ module Sequel
         nil
       end
       
-      # Add a foreign key in the table that references another table. See column
+      # Add a foreign key in the table that references another table. See #column
       # for available options.
       #
       #   foreign_key(:artist_id) # artist_id INTEGER
@@ -216,6 +231,9 @@ module Sequel
       #                  operations on the table while the index is being
       #                  built.
       # :opclass :: Use a specific operator class in the index.
+      # :include :: Include additional column values in the index, without
+      #             actually indexing on those values (PostgreSQL 11+).
+      # :tablespace :: Specify tablespace for index.
       #
       # Microsoft SQL Server specific options:
       #
@@ -232,7 +250,7 @@ module Sequel
         nil
       end
       
-      # Add a column with the given type, name, and opts.  See +column+ for available
+      # Add a column with the given type, name, and opts.  See #column for available
       # options.
       def method_missing(type, name = nil, opts = OPTS)
         name ? column(name, type, opts) : super
@@ -311,7 +329,7 @@ module Sequel
 
       # Add a composite primary key constraint
       def composite_primary_key(columns, *args)
-        opts = args.pop || {}
+        opts = args.pop || OPTS
         constraints << {:type => :primary_key, :columns => columns}.merge!(opts)
         nil
       end
@@ -347,7 +365,8 @@ module Sequel
       end
       
       # Add a column with the given name, type, and opts.
-      # See CreateTableGenerator#column for the available options.
+      # See CreateTableGenerator#column for the available options (except for +:index+, use a
+      # separate +add_index+ call to add an index for the column).
       #
       #   add_column(:name, String) # ADD COLUMN name varchar(255)
       #
@@ -389,7 +408,8 @@ module Sequel
       end
 
       # Add a foreign key with the given name and referencing the given table.
-      # See CreateTableGenerator#column for the available options.
+      # See CreateTableGenerator#column for the available options (except for +:index+, use a
+      # separate +add_index+ call to add an index for the column).
       #
       # You can also pass an array of column names for creating composite foreign
       # keys. In this case, it will assume the columns exist and will only add
@@ -622,7 +642,7 @@ module Sequel
 
       # 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 << opts.merge(:op => :drop_constraint, :type => :foreign_key, :columns => columns)
         nil
       end
     end

data/lib/sequel/database/schema_methods.rb

@@ -80,7 +80,7 @@ module Sequel
     # Create a join table using a hash of foreign keys to referenced
     # table names.  Example:
     #
-    #   create_join_table:cat_id: :cats, dog_id: :dogs)
+    #   create_join_table(cat_id: :cats, dog_id: :dogs)
     #   # CREATE TABLE cats_dogs (
     #   #  cat_id integer NOT NULL REFERENCES cats,
     #   #  dog_id integer NOT NULL REFERENCES dogs,
@@ -93,6 +93,13 @@ module Sequel
     # key ensures that entries in the table are unique, which is the typical
     # desire for a join table.
     #
+    # The default table name this will create is the sorted version of the two
+    # hash values, joined by an underscore.  So the following two method calls
+    # create the same table:
+    #
+    #   create_join_table(cat_id: :cats, dog_id: :dogs) # cats_dogs
+    #   create_join_table(dog_id: :dogs, cat_id: :cats) # cats_dogs
+    #
     # You can provide column options by making the values in the hash
     # be option hashes, so long as the option hashes have a :table
     # entry giving the table referenced:
@@ -121,7 +128,7 @@ module Sequel
           foreign_key(key, v)
         end
         primary_key(keys) unless options[:no_primary_key]
-        index(keys.reverse, options[:index_options] || {}) unless options[:no_index]
+        index(keys.reverse, options[:index_options] || OPTS) unless options[:no_index]
       end
       nil
     end
@@ -174,6 +181,7 @@ module Sequel
     #             where keys are option names and values are option values.  Note
     #             that option names are unquoted, so you should not use untrusted
     #             keys.
+    # :tablespace :: The tablespace to use for the table.
     #
     # See <tt>Schema::CreateTableGenerator</tt> and the {"Schema Modification" guide}[rdoc-ref:doc/schema_modification.rdoc].
     def create_table(name, options=OPTS, &block)
@@ -232,7 +240,7 @@ module Sequel
       if supports_create_or_replace_view?
         options = options.merge(:replace=>true)
       else
-        drop_view(name) rescue nil
+        swallow_database_error{drop_view(name)}
       end
 
       create_view(name, source, options)
@@ -274,6 +282,7 @@ module Sequel
     #               in a subquery, if you are providing a Dataset as the source
     #               argument, if should probably call the union method with the
     #               all: true and from_self: false options.
+    # :tablespace :: The tablespace to use for materialized views.
     def create_view(name, source, options = OPTS)
       execute_ddl(create_view_sql(name, source, options))
       remove_cached_schema(name)
@@ -314,7 +323,7 @@ module Sequel
     #   DB.drop_table(:posts, :comments)
     #   DB.drop_table(:posts, :comments, cascade: true)
     def drop_table(*names)
-      options = names.last.is_a?(Hash) ? names.pop : {}
+      options = names.last.is_a?(Hash) ? names.pop : OPTS 
       names.each do |n|
         execute_ddl(drop_table_sql(n, options))
         remove_cached_schema(n)
@@ -329,7 +338,7 @@ module Sequel
     #   # SELECT NULL FROM a LIMIT 1 -- check existence
     #   # DROP TABLE a -- if it already exists
     def drop_table?(*names)
-      options = names.last.is_a?(Hash) ? names.pop : {}
+      options = names.last.is_a?(Hash) ? names.pop : OPTS
       if supports_drop_table_if_exists?
         options = options.merge(:if_exists=>true)
         names.each do |name|
@@ -357,7 +366,7 @@ module Sequel
     # PostgreSQL specific options:
     # :materialized :: Drop a materialized view.
     def drop_view(*names)
-      options = names.last.is_a?(Hash) ? names.pop : {}
+      options = names.last.is_a?(Hash) ? names.pop : OPTS
       names.each do |n|
         execute_ddl(drop_view_sql(n, options))
         remove_cached_schema(n)
@@ -485,7 +494,9 @@ module Sequel
       when :drop_index
         drop_index_sql(table, op)
       else
-        "ALTER TABLE #{quote_schema_table(table)} #{alter_table_op_sql(table, op)}"
+        if sql = alter_table_op_sql(table, op)
+          "ALTER TABLE #{quote_schema_table(table)} #{sql}"
+        end
       end
     end
 
@@ -577,6 +588,7 @@ module Sequel
           sql << " CONSTRAINT #{quote_identifier(name)}"
         end
         sql << ' PRIMARY KEY'
+        constraint_deferrable_sql_append(sql, column[:primary_key_deferrable])
       end
     end
     
@@ -597,6 +609,7 @@ module Sequel
           sql << " CONSTRAINT #{quote_identifier(name)}"
         end
         sql << ' UNIQUE'
+        constraint_deferrable_sql_append(sql, column[:unique_deferrable])
       end
     end
     
@@ -800,23 +813,20 @@ module Sequel
     # Proxy the filter_expr call to the dataset, used for creating constraints.
     # Support passing Proc arguments as blocks, as well as treating plain strings
     # as literal strings, so that previous migrations that used this API do not break.
-    def filter_expr(*args, &block)
-      if args.length == 1
-        arg = args.first
-        if arg.is_a?(Proc) && !block
-          block = args.first
-          args = nil
-        elsif arg.is_a?(String)
-          args = [Sequel.lit(*args)]
-        elsif arg.is_a?(Array)
-          if arg.first.is_a?(String)
-            args = [Sequel.lit(*arg)]
-          elsif arg.length > 1
-            args = [Sequel.&(*arg)]
-          end
+    def filter_expr(arg=nil, &block)
+      if arg.is_a?(Proc) && !block
+        block = arg
+        arg = nil
+      elsif arg.is_a?(String)
+        arg = Sequel.lit(arg)
+      elsif arg.is_a?(Array)
+        if arg.first.is_a?(String)
+          arg = Sequel.lit(*arg)
+        elsif arg.length > 1
+          arg = Sequel.&(*arg)
         end
       end
-      schema_utility_dataset.literal(schema_utility_dataset.send(:filter_expr, *args, &block))
+      schema_utility_dataset.literal(schema_utility_dataset.send(:filter_expr, arg, &block))
     end
 
     # SQL statement for creating an index for the table with the given name