sequel 4.26.0 → 5.37.0

data/lib/sequel/database.rb

@@ -1,11 +1,19 @@
+# frozen-string-literal: true
+
 module Sequel
   # Hash of adapters that have been used. The key is the adapter scheme
   # symbol, and the value is the Database subclass.
   ADAPTER_MAP = {}
     
+  # Hash of shared adapters that have been registered.  The key is the
+  # adapter scheme symbol, and the value is the Sequel module containing
+  # the shared adapter.
+  SHARED_ADAPTER_MAP = {}
+
   # Array of all databases to which Sequel has connected.  If you are
   # developing an application that can connect to an arbitrary number of 
-  # databases, delete the database objects from this or they will not get
+  # databases, delete the database objects from this (or use the :keep_reference
+  # Database option or a block when connecting) or they will not get
   # garbage collected.
   DATABASES = []
 
@@ -16,5 +24,14 @@ module Sequel
     OPTS = Sequel::OPTS
   end
 
-  require(%w"connecting dataset dataset_defaults logging features misc query transactions schema_generator schema_methods", 'database')
+  require_relative "database/connecting"
+  require_relative "database/dataset"
+  require_relative "database/dataset_defaults"
+  require_relative "database/logging"
+  require_relative "database/features"
+  require_relative "database/misc"
+  require_relative "database/query"
+  require_relative "database/transactions"
+  require_relative "database/schema_generator"
+  require_relative "database/schema_methods"
 end

data/lib/sequel/database/connecting.rb

@@ -1,3 +1,5 @@
+# frozen-string-literal: true
+
 module Sequel
   class Database
     # ---------------------
@@ -6,24 +8,13 @@ module Sequel
     # ---------------------
 
     # Array of supported database adapters
-    ADAPTERS = %w'ado amalgalite cubrid do firebird ibmdb informix 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.
@@ -35,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
@@ -44,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
@@ -55,15 +46,16 @@ 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])
+        db.test_connection if db.send(:typecast_value_boolean, opts.fetch(:test, true))
         if block_given?
           return yield(db)
         end
@@ -127,6 +119,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.
@@ -137,25 +157,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
@@ -163,24 +186,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
@@ -192,19 +215,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
@@ -213,10 +225,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.
@@ -232,7 +247,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
@@ -245,15 +266,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

@@ -1,3 +1,5 @@
+# frozen-string-literal: true
+
 module Sequel
   class Database
     # ---------------------
@@ -41,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
@@ -48,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

@@ -1,3 +1,5 @@
+# frozen-string-literal: true
+
 module Sequel
   class Database
     # ---------------------
@@ -5,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.
@@ -65,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
@@ -78,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)
@@ -91,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