sequel 4.36.0 → 5.61.0

data/lib/sequel/database/connecting.rb

@@ -8,24 +8,13 @@ module Sequel
     # ---------------------
 
     # Array of supported database adapters
-    ADAPTERS = %w'ado amalgalite cubrid do ibmdb jdbc mock mysql mysql2 odbc oracle postgres sqlanywhere sqlite swift tinytds'.collect(&:to_sym)
-
-    @single_threaded = false
-
-    class << self
-      # Whether to use the single threaded connection pool by default
-      attr_accessor :single_threaded
-    end
+    ADAPTERS = %w'ado amalgalite ibmdb jdbc mock mysql mysql2 odbc oracle postgres sqlanywhere sqlite tinytds'.map(&:to_sym)
 
     # The Database subclass for the given adapter scheme.
     # Raises Sequel::AdapterNotFound if the adapter
     # could not be loaded.
     def self.adapter_class(scheme)
-      return scheme if scheme.is_a?(Class)
-
-      scheme = scheme.to_s.gsub('-', '_').to_sym
-
-      load_adapter(scheme)
+      scheme.is_a?(Class) ? scheme : load_adapter(scheme.to_sym)
     end
 
     # Returns the scheme symbol for the Database class.
@@ -37,8 +26,8 @@ module Sequel
     def self.connect(conn_string, opts = OPTS)
       case conn_string
       when String
-        if match = /\A(jdbc|do):/o.match(conn_string)
-          c = adapter_class(match[1].to_sym)
+        if conn_string.start_with?('jdbc:')
+          c = adapter_class(:jdbc)
           opts = opts.merge(:orig_opts=>opts.dup)
           opts = {:uri=>conn_string}.merge!(opts)
         else
@@ -46,8 +35,8 @@ module Sequel
           scheme = uri.scheme
           c = adapter_class(scheme)
           uri_options = c.send(:uri_to_options, uri)
-          uri.query.split('&').collect{|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.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] = 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
@@ -57,20 +46,20 @@ module Sequel
       else
         raise Error, "Sequel::Database.connect takes either a Hash or a String, given: #{conn_string.inspect}"
       end
-      # process opts a bit
+
       opts = opts.inject({}) do |m, (k,v)|
         k = :user if k.to_s == 'username'
         m[k.to_sym] = v
         m
       end
+
       begin
         db = c.new(opts)
-        db.test_connection if opts[:test] && db.send(:typecast_value_boolean, opts[:test])
-        if block_given?
+        if defined?(yield)
           return yield(db)
         end
       ensure
-        if block_given?
+        if defined?(yield)
           db.disconnect if db
           Sequel.synchronize{::Sequel::DATABASES.delete(db)}
         end
@@ -129,6 +118,34 @@ module Sequel
       Sequel.synchronize{ADAPTER_MAP[scheme] = self}
     end
     private_class_method :set_adapter_scheme
+
+    # Sets the given module as the shared adapter module for the given scheme.
+    # Used to register shared adapters for use by the mock adapter. Example:
+    #
+    #   # in file sequel/adapters/shared/mydb.rb
+    #   module Sequel::MyDB
+    #     Sequel::Database.set_shared_adapter_scheme :mydb, self
+    #
+    #     def self.mock_adapter_setup(db)
+    #       # ...
+    #     end
+    #
+    #     module DatabaseMethods
+    #       # ...
+    #     end
+    #
+    #     module DatasetMethods
+    #       # ...
+    #     end
+    #   end
+    #
+    # would allow the mock adapter to return a Database instance that supports
+    # the MyDB syntax via:
+    #
+    #   Sequel.connect('mock://mydb')
+    def self.set_shared_adapter_scheme(scheme, mod)
+      Sequel.synchronize{SHARED_ADAPTER_MAP[scheme] = mod}
+    end
     
     # The connection pool for this Database instance.  All Database instances have
     # their own connection pools.
@@ -139,25 +156,28 @@ module Sequel
     # +database_type+ (for native adapters), in others (i.e. adapters with
     # subadapters), it will be different.
     #
-    #   Sequel.connect('jdbc:postgres://...').adapter_scheme # => :jdbc
+    #   Sequel.connect('jdbc:postgres://...').adapter_scheme
+    #   # => :jdbc
     def adapter_scheme
       self.class.adapter_scheme
     end
 
     # Dynamically add new servers or modify server options at runtime. Also adds new
-    # servers to the connection pool. Intended for use with master/slave or shard
-    # configurations where it is useful to add new server hosts at runtime.
+    # servers to the connection pool. Only usable when using a sharded connection pool.
     #
     # servers argument should be a hash with server name symbol keys and hash or
     # proc values.  If a servers key is already in use, it's value is overridden
     # with the value provided.
     #
-    #   DB.add_servers(:f=>{:host=>"hash_host_f"})
+    #   DB.add_servers(f: {host: "hash_host_f"})
     def add_servers(servers)
-      if h = @opts[:servers]
-        Sequel.synchronize{h.merge!(servers)}
-        @pool.add_servers(servers.keys)
+      unless sharded?
+        raise Error, "cannot call Database#add_servers on a Database instance that does not use a sharded connection pool"
       end
+
+      h = @opts[:servers]
+      Sequel.synchronize{h.merge!(servers)}
+      @pool.add_servers(servers.keys)
     end
 
     # The database type for this database object, the same as the adapter scheme
@@ -165,24 +185,24 @@ module Sequel
     # to be the correct type, so that even if two separate Database objects are
     # using different adapters you can tell that they are using the same database
     # type.  Even better, you can tell that two Database objects that are using
-    # the same adapter are connecting to different database types (think JDBC or
-    # DataObjects).
+    # the same adapter are connecting to different database types.
     #
-    #   Sequel.connect('jdbc:postgres://...').database_type # => :postgres
+    #   Sequel.connect('jdbc:postgres://...').database_type
+    #   # => :postgres
     def database_type
       adapter_scheme
     end
     
     # Disconnects all available connections from the connection pool.  Any
     # connections currently in use will not be disconnected. Options:
-    # :servers :: Should be a symbol specifing the server to disconnect from,
+    # :server :: Should be a symbol specifing the server to disconnect from,
     #             or an array of symbols to specify multiple servers.
     #
     # Example:
     #
     #   DB.disconnect # All servers
-    #   DB.disconnect(:servers=>:server1) # Single server
-    #   DB.disconnect(:servers=>[:server1, :server2]) # Multiple servers
+    #   DB.disconnect(server: :server1) # Single server
+    #   DB.disconnect(server: [:server1, :server2]) # Multiple servers
     def disconnect(opts = OPTS)
       pool.disconnect(opts)
     end
@@ -194,19 +214,8 @@ module Sequel
       conn.close
     end
 
-    # Yield a new Database instance for every server in the connection pool.
-    # Intended for use in sharded environments where there is a need to make schema
-    # modifications (DDL queries) on each shard.
-    #
-    #   DB.each_server{|db| db.create_table(:users){primary_key :id; String :name}}
-    def each_server(&block)
-      raise(Error, "Database#each_server must be passed a block") unless block
-      servers.each{|s| self.class.connect(server_opts(s), &block)}
-    end
-
-    # Dynamically remove existing servers from the connection pool. Intended for
-    # use with master/slave or shard configurations where it is useful to remove
-    # existing server hosts at runtime.
+    # Dynamically remove existing servers from the connection pool. Only usable
+    # when using a sharded connection pool
     #
     # servers should be symbols or arrays of symbols.  If a nonexistent server
     # is specified, it is ignored.  If no servers have been specified for
@@ -215,10 +224,13 @@ module Sequel
     #
     #   DB.remove_servers(:f1, :f2)
     def remove_servers(*servers)
-      if h = @opts[:servers]
-        servers.flatten.each{|s| Sequel.synchronize{h.delete(s)}}
-        @pool.remove_servers(servers)
+      unless sharded?
+        raise Error, "cannot call Database#remove_servers on a Database instance that does not use a sharded connection pool"
       end
+
+      h = @opts[:servers]
+      servers.flatten.each{|s| Sequel.synchronize{h.delete(s)}}
+      @pool.remove_servers(servers)
     end
     
     # An array of servers/shards for this Database object.
@@ -234,7 +246,13 @@ module Sequel
       @single_threaded
     end
     
-    if !defined?(RUBY_ENGINE) || RUBY_ENGINE == 'ruby'
+    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
@@ -247,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/dataset.rb

@@ -43,6 +43,9 @@ module Sequel
     # injection:
     #
     #   DB.fetch('SELECT * FROM items WHERE name = ?', my_name).all
+    #
+    # See caveats listed in Dataset#with_sql regarding datasets using custom
+    # SQL and the methods that can be called on them.
     def fetch(sql, *args, &block)
       ds = @default_dataset.with_sql(sql, *args)
       ds.each(&block) if block
@@ -50,19 +53,24 @@ module Sequel
     end
     
     # Returns a new dataset with the +from+ method invoked. If a block is given,
-    # it is used as a filter on the dataset.
+    # it acts as a virtual row block
     #
     #   DB.from(:items) # SELECT * FROM items
-    #   DB.from(:items){id > 2} # SELECT * FROM items WHERE (id > 2)
+    #   DB.from{schema[:table]} # SELECT * FROM schema.table
     def from(*args, &block)
-      ds = @default_dataset.from(*args)
-      block ? ds.filter(&block) : ds
+      if block
+        @default_dataset.from(*args, &block)
+      elsif args.length == 1 && (table = args[0]).is_a?(Symbol)
+        @default_dataset.send(:cached_dataset, :"_from_#{table}_ds"){@default_dataset.from(table)}
+      else
+        @default_dataset.from(*args)
+      end
     end
     
     # Returns a new dataset with the select method invoked.
     #
     #   DB.select(1) # SELECT 1
-    #   DB.select{server_version{}} # SELECT server_version()
+    #   DB.select{server_version.function} # SELECT server_version()
     #   DB.select(:id).from(:items) # SELECT id FROM items
     def select(*args, &block)
       @default_dataset.select(*args, &block)

data/lib/sequel/database/dataset_defaults.rb

@@ -7,45 +7,11 @@ module Sequel
     # This methods change the default behavior of this database's datasets.
     # ---------------------
 
-    # The default class to use for datasets
-    DatasetClass = Sequel::Dataset
-
-    @identifier_input_method = nil
-    @identifier_output_method = nil
-    @quote_identifiers = nil
-
-    class << self
-      # The identifier input method to use by default for all databases (default: adapter default)
-      attr_reader :identifier_input_method
-
-      # The identifier output method to use by default for all databases (default: adapter default)
-      attr_reader :identifier_output_method
-
-      # Whether to quote identifiers (columns and tables) by default for all databases (default: adapter default)
-      attr_accessor :quote_identifiers
-    end
-
-    # Change the default identifier input method to use for all databases,
-    def self.identifier_input_method=(v)
-      @identifier_input_method = v.nil? ? false : v
-    end
-
-    # Change the default identifier output method to use for all databases,
-    def self.identifier_output_method=(v)
-      @identifier_output_method = v.nil? ? false : v
-    end
-
     # The class to use for creating datasets.  Should respond to
     # new with the Database argument as the first argument, and
     # an optional options hash.
     attr_reader :dataset_class
 
-    # The identifier input method to use by default for this database (default: adapter default)
-    attr_reader :identifier_input_method
-
-    # The identifier output method to use by default for this database (default: adapter default)
-    attr_reader :identifier_output_method
-
     # If the database has any dataset modules associated with it,
     # use a subclass of the given class that includes the modules
     # as the dataset class.
@@ -67,9 +33,12 @@ module Sequel
     # This allows you to override any of the dataset methods even if they are
     # defined directly on the dataset class that this Database object uses.
     #
+    # If a block is given, a Dataset::DatasetModule instance is created, allowing
+    # for the easy creation of named dataset methods that will do caching.
+    #
     # Examples:
     #
-    #   # Introspec columns for all of DB's datasets
+    #   # Introspect columns for all of DB's datasets
     #   DB.extend_datasets(Sequel::ColumnsIntrospection)
     #   
     #   # Trace all SELECT queries by printing the SQL and the full backtrace
@@ -80,9 +49,19 @@ module Sequel
     #       super
     #     end
     #   end
+    #
+    #   # Add some named dataset methods
+    #   DB.extend_datasets do
+    #     order :by_id, :id
+    #     select :with_id_and_name, :id, :name
+    #     where :active, :active
+    #   end
+    #
+    #   DB[:table].active.with_id_and_name.by_id
+    #   # SELECT id, name FROM table WHERE active ORDER BY id
     def extend_datasets(mod=nil, &block)
       raise(Error, "must provide either mod or block, not both") if mod && block
-      mod = Module.new(&block) if block
+      mod = Dataset::DatasetModule.new(&block) if block
       if @dataset_modules.empty?
        @dataset_modules = [mod]
        @dataset_class = Class.new(@dataset_class)
@@ -93,85 +72,22 @@ module Sequel
       reset_default_dataset
     end
 
-    # Set the method to call on identifiers going into the database:
-    #
-    #   DB[:items] # SELECT * FROM items
-    #   DB.identifier_input_method = :upcase
-    #   DB[:items] # SELECT * FROM ITEMS
-    def identifier_input_method=(v)
-      reset_default_dataset
-      @identifier_input_method = v
-    end
-    
-    # Set the method to call on identifiers coming from the database:
-    #
-    #   DB[:items].first # {:id=>1, :name=>'foo'}
-    #   DB.identifier_output_method = :upcase
-    #   DB[:items].first # {:ID=>1, :NAME=>'foo'}
-    def identifier_output_method=(v)
-      reset_default_dataset
-      @identifier_output_method = v
-    end
-
-    # Set whether to quote identifiers (columns and tables) for this database:
-    #
-    #   DB[:items] # SELECT * FROM items
-    #   DB.quote_identifiers = true
-    #   DB[:items] # SELECT * FROM "items"
-    def quote_identifiers=(v)
-      reset_default_dataset
-      @quote_identifiers = v
-    end
-    
-    # Returns true if the database quotes identifiers.
-    def quote_identifiers?
-      @quote_identifiers
-    end
-    
     private
     
     # The default dataset class to use for the database
     def dataset_class_default
-      self.class.const_get(:DatasetClass)
+      Sequel::Dataset
     end
 
-    # Reset the default dataset used by most Database methods that
-    # create datasets.  Usually done after changes to the identifier
-    # mangling methods.
+    # Reset the default dataset used by most Database methods that create datasets.
     def reset_default_dataset
       Sequel.synchronize{@symbol_literal_cache.clear}
       @default_dataset = dataset
     end
 
-    # The method to apply to identifiers going into the database by default.
-    # Should be overridden in subclasses for databases that fold unquoted
-    # identifiers to lower case instead of uppercase, such as
-    # MySQL, PostgreSQL, and SQLite.
-    def identifier_input_method_default
-      :upcase
-    end
-    
-    # The method to apply to identifiers coming the database by default.
-    # Should be overridden in subclasses for databases that fold unquoted
-    # identifiers to lower case instead of uppercase, such as
-    # MySQL, PostgreSQL, and SQLite.
-    def identifier_output_method_default
-      :downcase
-    end
-    
-    # Whether to quote identifiers by default for this database, true
-    # by default.
+    # Whether to quote identifiers by default for this database, true by default.
     def quote_identifiers_default
       true
     end
-
-    # Reset the identifier mangling options.  Overrides any already set on
-    # the instance.  Only for internal use by shared adapters.
-    def reset_identifier_mangling
-      @quote_identifiers = @opts.fetch(:quote_identifiers){(qi = Database.quote_identifiers).nil? ? quote_identifiers_default : qi}
-      @identifier_input_method = @opts.fetch(:identifier_input_method){(iim = Database.identifier_input_method).nil? ? identifier_input_method_default : (iim if iim)}
-      @identifier_output_method = @opts.fetch(:identifier_output_method){(iom = Database.identifier_output_method).nil? ? identifier_output_method_default : (iom if iom)}
-      reset_default_dataset
-    end
   end
 end

data/lib/sequel/database/features.rb

@@ -8,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
@@ -33,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
@@ -49,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
@@ -66,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
@@ -108,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

@@ -32,25 +32,20 @@ module Sequel
       log_each(:info, args ? "#{message}; #{args.inspect}" : message)
     end
 
-    # 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, &block)
-      log_connection_yield(sql, nil, args, &block)
-    end
-
     # 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}"
-      start = Time.now
+      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
 
@@ -63,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)
@@ -72,7 +73,7 @@ module Sequel
     # Log the given SQL and then execute it on the connection, used by
     # the transaction code.
     def log_connection_execute(conn, sql)
-      log_connection_yield(sql, conn){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
@@ -84,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