sequel 4.49.0 → 5.3.0

data/lib/sequel/core.rb

@@ -9,13 +9,16 @@
 #
 #   DB = Sequel.sqlite # Memory database
 #   DB = Sequel.sqlite('blog.db')
-#   DB = Sequel.postgres('database_name', :user=>'user', 
-#          :password=>'password', :host=>'host', :port=>5432, 
-#          :max_connections=>10)
+#   DB = Sequel.postgres('database_name',
+#          user:'user', 
+#          password: 'password',
+#          host: 'host'
+#          port: 5432, 
+#          max_connections: 10)
 #
 # If a block is given to these methods, it is passed the opened Database
 # object, which is closed (disconnected) when the block exits, just
-# like a block passed to connect.  For example:
+# like a block passed to Sequel.connect.  For example:
 #
 #   Sequel.sqlite('blog.db'){|db| puts db[:users].count} 
 #
@@ -24,7 +27,7 @@
 module Sequel
   @convert_two_digit_years = true
   @datetime_class = Time
-  @split_symbols = :deprecated
+  @split_symbols = false
   @single_threaded = false
 
   class << self
@@ -41,16 +44,13 @@ module Sequel
     #
     #   Sequel.datetime_class = DateTime
     #
-    # For ruby versions less than 1.9.2, +Time+ has a limited range (1901 to
-    # 2038), so if you use datetimes out of that range, you need to switch
-    # to +DateTime+.  Also, before 1.9.2, +Time+ can only handle local and UTC
-    # times, not other timezones.  Note that +Time+ and +DateTime+ objects
+    # Note that +Time+ and +DateTime+ objects
     # have a different API, and in cases where they implement the same methods,
     # they often implement them differently (e.g. + using seconds on +Time+ and
     # days on +DateTime+).
     attr_accessor :datetime_class
 
-    # Set whether sequel is being used in single threaded mode. by default,
+    # Set whether Sequel is being used in single threaded mode. by default,
     # Sequel uses a thread-safe connection pool, which isn't as fast as the
     # single threaded connection pool, and also has some additional thread
     # safety checks.  If your program will only have one thread,
@@ -92,11 +92,11 @@ module Sequel
   #   DB = Sequel.connect('sqlite://blog.db') # ./blog.db
   #   DB = Sequel.connect('sqlite:///blog.db') # /blog.db
   #   DB = Sequel.connect('postgres://user:password@host:port/database_name')
-  #   DB = Sequel.connect('sqlite:///blog.db', :max_connections=>10)
+  #   DB = Sequel.connect('sqlite:///blog.db', max_connections: 10)
   #
   # You can also pass a single options hash:
   #
-  #   DB = Sequel.connect(:adapter=>'sqlite', :database=>'./blog.db')
+  #   DB = Sequel.connect(adapter: 'sqlite', database: './blog.db')
   #
   # If a block is given, it is passed the opened +Database+ object, which is
   # closed when the block exits.  For example:
@@ -108,7 +108,7 @@ module Sequel
   # design, and used by <tt>Sequel::Model</tt> to pick the default
   # database.  It is recommended to pass a block if you do not want the
   # resulting Database object to remain in memory until the process
-  # terminates.
+  # terminates, or use the <tt>keep_reference: false</tt> Database option.
   #
   # For details, see the {"Connecting to a Database" guide}[rdoc-ref:doc/opening_databases.rdoc].
   # To set up a master/slave or sharded database connection, see the {"Master/Slave Databases and Sharding" guide}[rdoc-ref:doc/sharding.rdoc].
@@ -134,9 +134,7 @@ module Sequel
   end
 
   # Load all Sequel extensions given.  Extensions are just files that exist under
-  # <tt>sequel/extensions</tt> in the load path, and are just required.  Generally,
-  # extensions modify the behavior of +Database+ and/or +Dataset+, but Sequel ships
-  # with some extensions that modify other classes that exist for backwards compatibility.
+  # <tt>sequel/extensions</tt> in the load path, and are just required.  
   # In some cases, requiring an extension modifies classes directly, and in others,
   # it just loads a module that you can extend other classes with.  Consult the documentation
   # for each extension you plan on using for usage.
@@ -147,39 +145,6 @@ module Sequel
     extensions.each{|e| Kernel.require "sequel/extensions/#{e}"}
   end
   
-  # Set the method to call on identifiers going into the database.  This affects
-  # the literalization of identifiers by calling this method on them before they are input.
-  # Sequel upcases identifiers in all SQL strings for most databases, so to turn that off:
-  #
-  #   Sequel.identifier_input_method = nil
-  # 
-  # to downcase instead:
-  #
-  #   Sequel.identifier_input_method = :downcase
-  #
-  # Other String instance methods work as well.
-  def self.identifier_input_method=(value)
-    # SEQUEL5: Remove
-    Database.identifier_input_method = value
-  end
-
-  # Set the method to call on identifiers coming out of the database.  This affects
-  # the literalization of identifiers by calling this method on them when they are
-  # retrieved from the database.  Sequel downcases identifiers retrieved for most
-  # databases, so to turn that off:
-  #
-  #   Sequel.identifier_output_method = nil
-  # 
-  # to upcase instead:
-  #
-  #   Sequel.identifier_output_method = :upcase
-  #
-  # Other String instance methods work as well.
-  def self.identifier_output_method=(value)
-    # SEQUEL5: Remove
-    Database.identifier_output_method = value
-  end
-
   # The exception classed raised if there is an error parsing JSON.
   # This can be overridden to use an alternative json implementation.
   def self.json_parser_error_class
@@ -198,15 +163,6 @@ module Sequel
     JSON.parse(json, :create_additions=>false)
   end
 
-  # Set whether to quote identifiers for all databases by default. By default,
-  # Sequel quotes identifiers in all SQL strings, so to turn that off:
-  #
-  #   Sequel.quote_identifiers = false
-  def self.quote_identifiers=(value)
-    # SEQUEL5: Remove
-    Database.quote_identifiers = value
-  end
-
   # Convert each item in the array to the correct type, handling multi-dimensional
   # arrays.  For each element in the array or subarrays, call the converter,
   # unless the value is nil.
@@ -220,17 +176,15 @@ module Sequel
     end
   end
 
-  # Require all given +files+ which should be in the same or a subdirectory of
-  # this file.  If a +subdir+ is given, assume all +files+ are in that subdir.
-  # This is used to ensure that the files loaded are from the same version of
-  # Sequel as this file.
+  # For backwards compatibility only.  require_relative should be used instead.
   def self.require(files, subdir=nil)
-    Array(files).each{|f| super("#{File.dirname(__FILE__).untaint}/#{"#{subdir}/" if subdir}#{f}")}
+    # Use Kernel.require_relative to work around JRuby 9.0 bug
+    Array(files).each{|f| Kernel.require_relative "#{"#{subdir}/" if subdir}#{f}"}
   end
 
   SPLIT_SYMBOL_CACHE = {}
 
-  # Splits the symbol into three parts, if symbol splitting is enabled.
+  # Splits the symbol into three parts, if symbol splitting is enabled (not the default).
   # Each part will either be a string or nil. If symbol splitting
   # is disabled, returns an array with the first and third parts
   # being nil, and the second part beind a string version of the symbol.
@@ -239,22 +193,13 @@ module Sequel
   # For tables, these parts are the schema, table, and alias.
   def self.split_symbol(sym)
     unless v = Sequel.synchronize{SPLIT_SYMBOL_CACHE[sym]}
-      if split = split_symbols?
+      if split_symbols?
         v = case s = sym.to_s
         when /\A((?:(?!__).)+)__((?:(?!___).)+)___(.+)\z/
-          if split == :deprecated
-            Sequel::Deprecation.deprecate("Symbol splitting", "Either set Sequel.split_symbols = true, or change #{sym.inspect} to Sequel.qualify(#{$1.inspect}, #{$2.inspect}).as(#{$3.inspect})")
-          end
           [$1.freeze, $2.freeze, $3.freeze].freeze
         when /\A((?:(?!___).)+)___(.+)\z/
-          if split == :deprecated
-            Sequel::Deprecation.deprecate("Symbol splitting", "Either set Sequel.split_symbols = true, or change #{sym.inspect} to Sequel.identifier(#{$1.inspect}).as(#{$2.inspect})")
-          end
           [nil, $1.freeze, $2.freeze].freeze
         when /\A((?:(?!__).)+)__(.+)\z/
-          if split == :deprecated
-            Sequel::Deprecation.deprecate("Symbol splitting", "Either set Sequel.split_symbols = true, or change #{sym.inspect} to Sequel.qualify(#{$1.inspect}, #{$2.inspect})")
-          end
           [$1.freeze, $2.freeze, nil].freeze
         else
           [nil, s.freeze, nil].freeze
@@ -267,32 +212,28 @@ module Sequel
     v
   end
 
-  # Sequel by default will split symbols, treating:
+  # Setting this to true enables Sequel's historical behavior of splitting
+  # symbols on double or triple underscores:
   #
   #   :table__column         # table.column
   #   :column___alias        # column AS alias
   #   :table__column___alias # table.column AS alias
   #
-  # This can cause problems if any identifiers in the database use a double
-  # or triple underscore.  When Sequel was first created, using symbols with
-  # double or triple underscores was the only way to represent qualified or
-  # aliased identifiers.  Sequel now offers many ways to create qualified and
-  # aliased identifiers, so there is less of a need for this now.  This allows
-  # you to turn off symbol splitting, potentially avoiding problems if you
-  # have identifiers that use double underscores:
+  # It is only recommended to turn this on for backwards compatibility until
+  # such symbols have been converted to use newer Sequel APIs such as:
   #
-  #   Sequel.split_symbols = false
+  #   Sequel[:table][:column]            # table.column
+  #   Sequel[:column].as(:alias)         # column AS alias
+  #   Sequel[:table][:column].as(:alias) # table.column AS alias
   #
-  # Note that Sequel::Database instances do their own caching of literalized
+  # Sequel::Database instances do their own caching of literalized
   # symbols, and changing this setting does not affect those caches.  It is
   # recommended that if you want to change this setting, you do so directly
   # after requiring Sequel, before creating any Sequel::Database instances.
   #
-  # Also note that disabling symbol splitting will also disable the handling
+  # Disabling symbol splitting will also disable the handling
   # of double underscores in virtual row methods, causing such methods to
-  # yield regular identifers instead of qualified identifiers. To make sure
-  # the code works when splitting symbols is both disabled and enabled, you
-  # can use Sequel::SQL::Identifier#[].
+  # yield regular identifers instead of qualified identifiers:
   #
   #   # Sequel.split_symbols = true
   #   Sequel.expr{table__column}  # table.column
@@ -356,6 +297,8 @@ module Sequel
   # Unless in single threaded mode, protects access to any mutable
   # global data structure in Sequel.
   # Uses a non-reentrant mutex, so calling code should be careful.
+  # In general, this should only be used around the minimal possible code
+  # such as Hash#[], Hash#[]=, Hash#delete, Array#<<, and Array#delete.
   def self.synchronize(&block)
     @single_threaded ? yield : @data_mutex.synchronize(&block)
   end
@@ -433,18 +376,23 @@ module Sequel
 
   # Method that adds a database adapter class method to Sequel that calls
   # Sequel.adapter_method.
-  #
-  # Do not call this method with untrusted input, as that can result in
-  # arbitrary code execution.
   def self.def_adapter_method(*adapters) # :nodoc:
     adapters.each do |adapter|
-      instance_eval("def #{adapter}(*args, &block); adapter_method('#{adapter}', *args, &block) end", __FILE__, __LINE__)
+      define_singleton_method(adapter){|*args, &block| adapter_method(adapter, *args, &block)}
     end
   end
 
   private_class_method :adapter_method, :def_adapter_method
 
-  require(%w"deprecated sql connection_pool exceptions dataset database timezones ast_transformer version")
+  require_relative "deprecated"
+  require_relative "sql"
+  require_relative "connection_pool"
+  require_relative "exceptions"
+  require_relative "dataset"
+  require_relative "database"
+  require_relative "timezones"
+  require_relative "ast_transformer"
+  require_relative "version"
 
   class << self
     # Allow nicer syntax for creating Sequel expressions:
@@ -452,17 +400,10 @@ module Sequel
     #   Sequel[1]     # => Sequel::SQL::NumericExpression: 1
     #   Sequel["a"]   # => Sequel::SQL::StringExpression: 'a'
     #   Sequel[:a]    # => Sequel::SQL::Identifier: "a"
-    #   Sequel[:a=>1] # => Sequel::SQL::BooleanExpression: ("a" = 1)
+    #   Sequel[a: 1]  # => Sequel::SQL::BooleanExpression: ("a" = 1)
     alias_method :[], :expr
   end
 
   # Add the database adapter class methods to Sequel via metaprogramming
   def_adapter_method(*Database::ADAPTERS)
-
-  COLUMN_REF_RE1 = /\A((?:(?!__).)+)__((?:(?!___).)+)___(.+)\z/.freeze
-  Sequel::Deprecation.deprecate_constant(self, :COLUMN_REF_RE1)
-  COLUMN_REF_RE2 = /\A((?:(?!___).)+)___(.+)\z/.freeze
-  Sequel::Deprecation.deprecate_constant(self, :COLUMN_REF_RE2)
-  COLUMN_REF_RE3 = /\A((?:(?!__).)+)__(.+)\z/.freeze
-  Sequel::Deprecation.deprecate_constant(self, :COLUMN_REF_RE3)
 end

data/lib/sequel/database/connecting.rb

@@ -8,35 +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'.map(&:to_sym)
-    # SEQUEL5: Remove cubrid do swift
-
-    def self.single_threaded
-      Sequel::Deprecation.deprecate("Sequel::Database.single_threaded", "Use Sequel.single_threaded instead")
-      Sequel.single_threaded
-    end
-
-    def self.single_threaded=(v)
-      Sequel::Deprecation.deprecate("Sequel::Database.single_threaded=", "Use Sequel.single_threaded= instead")
-      Sequel.single_threaded = v
-    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)
-
-      if scheme.to_s.include?('-')
-        # :nocov:
-        Sequel::Deprecation.deprecate("Automatically converting '-' to '_' in adapter schemes", "Use '_' instead of '-' in the adapter scheme")
-        # :nocov:
-      end
-
-      scheme = scheme.to_s.gsub('-', '_').to_sym # SEQUEL5: Remove
-      # scheme = scheme.to_sym # SEQUEL5
-
-      load_adapter(scheme)
+      scheme.is_a?(Class) ? scheme : load_adapter(scheme.to_sym)
     end
 
     # Returns the scheme symbol for the Database class.
@@ -48,9 +26,8 @@ module Sequel
     def self.connect(conn_string, opts = OPTS)
       case conn_string
       when String
-        # SEQUEL5: Remove do
-        if match = /\A(jdbc|do):/.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
@@ -69,16 +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)
-        # SEQUEL5: Default opts[:test] to true
-        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
@@ -155,7 +132,6 @@ module Sequel
     #     end
     #
     #     module DatabaseMethods
-    #       extend Sequel::Database::ResetIdentifierMangling
     #       # ...
     #     end
     #
@@ -181,27 +157,26 @@ 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)
-      unless h = @opts[:servers]
-        Sequel::Deprecation.deprecate("Calling Database#add_servers on a database that does not use sharding", "This method should only be called if the database supports sharding")
-        # raise Error, "cannot call Database#add_servers on a Database instance that does not use a sharded connection pool" # SEQUEL5
-        return
+      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
@@ -213,7 +188,8 @@ module Sequel
     # type.  Even better, you can tell that two Database objects that are using
     # 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
@@ -226,8 +202,8 @@ module Sequel
     # Example:
     #
     #   DB.disconnect # All servers
-    #   DB.disconnect(:server=>:server1) # Single server
-    #   DB.disconnect(:server=>[: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
@@ -239,20 +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)
-      Sequel::Deprecation.deprecate("Database#each_server", "Switching to using Dataset#servers and Database#with_server from the server_block extension: \"DB.servers.each{|s| DB.with_server(s){}}\"")
-      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
@@ -261,12 +225,11 @@ module Sequel
     #
     #   DB.remove_servers(:f1, :f2)
     def remove_servers(*servers)
-      unless h = @opts[:servers]
-        Sequel::Deprecation.deprecate("Calling Database#add_servers on a database that does not use sharding", "This method should only be called if the database supports sharding")
-        # raise Error, "cannot call Database#remove_servers on a Database instance that does not use a sharded connection pool" # SEQUEL5
-        return
+      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

data/lib/sequel/database/dataset.rb

@@ -53,18 +53,15 @@ 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)
       if block
-        Sequel::Deprecation.deprecate("Sequel::Database#from with a block", "Use .from(*args).where(&block) instead")
-        @default_dataset.from(*args).where(&block)
-      #SEQUEL5
-      #  @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)}
+        @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
@@ -73,7 +70,7 @@ module Sequel
     # 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,42 +7,6 @@ module Sequel
     # This methods change the default behavior of this database's datasets.
     # ---------------------
 
-    # The default class to use for datasets
-    DatasetClass = Sequel::Dataset
-    Sequel::Deprecation.deprecate_constant(self, :DatasetClass)
-
-    # SEQUEL5: Remove
-    @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_reader :quote_identifiers
-    end
-
-    # Change the default identifier input method to use for all databases,
-    def self.identifier_input_method=(v)
-      Sequel::Deprecation.deprecate("Sequel.identifier_input_method= and Sequel::Database.identifier_input_method=", "Call Sequel::Database#identifier_input_method= instead")
-      @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)
-      Sequel::Deprecation.deprecate("Sequel.identifier_output_method= and Sequel::Database.identifier_output_method=", "Call Sequel::Database#identifier_output_method= instead")
-      @identifier_output_method = v.nil? ? false : v
-    end
-
-    def self.quote_identifiers=(v)
-      Sequel::Deprecation.deprecate("Sequel.quote_identifiers= and Sequel::Database.quote_identifiers=", "Call Sequel::Database#quote_identifiers= instead")
-      @quote_identifiers = 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.
@@ -74,7 +38,7 @@ module Sequel
     #
     # 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
@@ -112,24 +76,16 @@ module Sequel
     
     # The default dataset class to use for the database
     def dataset_class_default
-      if self.class == Sequel::Database
-        Sequel::Dataset
-      else
-        Sequel::Deprecation.deprecate("Using self.class.const_get(:DatasetClass) to get the default dataset class", "Modify the database adapter to implement Database#dataset_class_default")
-        self.class.const_get(:DatasetClass)
-      end
+      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
 
-    # 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

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

data/lib/sequel/database/logging.rb

@@ -32,13 +32,6 @@ 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)
-      Sequel::Deprecation.deprecate("Sequel::Database#log_yield", "Update the adapter to use Sequel::Database#log_connection_yield")
-      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)
@@ -73,7 +66,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
@@ -85,7 +78,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