sequel 4.46.0 → 4.49.0

data/lib/sequel/adapters/shared/sqlite.rb

@@ -20,12 +20,14 @@ module Sequel
 
       PRIMARY_KEY_INDEX_RE = /\Asqlite_autoindex_/.freeze
       Sequel::Deprecation.deprecate_constant(self, :PRIMARY_KEY_INDEX_RE)
+      TABLES_FILTER = Sequel.~(:name=>'sqlite_sequence'.freeze) & {:type => 'table'.freeze}
+      Sequel::Deprecation.deprecate_constant(self, :TABLES_FILTER)
+      VIEWS_FILTER = {:type => 'view'.freeze}.freeze
+      Sequel::Deprecation.deprecate_constant(self, :VIEWS_FILTER)
 
       AUTO_VACUUM = [:none, :full, :incremental].freeze
       SYNCHRONOUS = [:off, :normal, :full].freeze
-      TABLES_FILTER = Sequel.~(:name=>'sqlite_sequence'.freeze) & {:type => 'table'.freeze}
       TEMP_STORE = [:default, :file, :memory].freeze
-      VIEWS_FILTER = {:type => 'view'.freeze}.freeze
       TRANSACTION_MODE = {
         :deferred => "BEGIN DEFERRED TRANSACTION".freeze,
         :immediate => "BEGIN IMMEDIATE TRANSACTION".freeze,
@@ -37,26 +39,6 @@ module Sequel
       # booleans be stored as integers, but historically Sequel has used 't'/'f'.
       attr_accessor :integer_booleans
 
-      # A symbol signifying the value of the auto_vacuum PRAGMA.
-      def auto_vacuum
-        AUTO_VACUUM[pragma_get(:auto_vacuum).to_i]
-      end
-      
-      # Set the auto_vacuum PRAGMA using the given symbol (:none, :full, or
-      # :incremental).  See pragma_set.  Consider using the :auto_vacuum
-      # Database option instead.
-      def auto_vacuum=(value)
-        value = AUTO_VACUUM.index(value) || (raise Error, "Invalid value for auto_vacuum option. Please specify one of :none, :full, :incremental.")
-        pragma_set(:auto_vacuum, value)
-      end
-
-      # Set the case_sensitive_like PRAGMA using the given boolean value, if using
-      # SQLite 3.2.3+.  If not using 3.2.3+, no error is raised. See pragma_set.
-      # Consider using the :case_sensitive_like Database option instead.
-      def case_sensitive_like=(value)
-        pragma_set(:case_sensitive_like, !!value ? 'on' : 'off') if sqlite_version >= 30203
-      end
-
       # A symbol signifying the value of the default transaction mode
       attr_reader :transaction_mode
 
@@ -74,18 +56,50 @@ module Sequel
         :sqlite
       end
       
-      # Boolean signifying the value of the foreign_keys PRAGMA, or nil
-      # if not using SQLite 3.6.19+.
+      # SEQUEL5: Remove
+      def auto_vacuum
+        AUTO_VACUUM[pragma_get(:auto_vacuum).to_i]
+      end
+      def auto_vacuum=(value)
+        value = AUTO_VACUUM.index(value) || (raise Error, "Invalid value for auto_vacuum option. Please specify one of :none, :full, :incremental.")
+        pragma_set(:auto_vacuum, value)
+      end
+      def case_sensitive_like=(value)
+        pragma_set(:case_sensitive_like, !!value ? 'on' : 'off') if sqlite_version >= 30203
+      end
       def foreign_keys
         pragma_get(:foreign_keys).to_i == 1 if sqlite_version >= 30619
       end
-      
-      # Set the foreign_keys PRAGMA using the given boolean value, if using
-      # SQLite 3.6.19+.  If not using 3.6.19+, no error is raised. See pragma_set.
-      # Consider using the :foreign_keys Database option instead.
       def foreign_keys=(value)
         pragma_set(:foreign_keys, !!value ? 'on' : 'off') if sqlite_version >= 30619
       end
+      def pragma_get(name)
+        Sequel::Deprecation.deprecate('Database#{pragma_get,auto_vacuum,case_sensitive_like,foreign_keys,synchronous,temp_store} on SQLite', "These methods may not be safe when using multiple connections, call fetch(#{"PRAGMA #{name}".inspect}).single_value if you really want to get the pragma value")
+        self["PRAGMA #{name}"].single_value
+      end
+      def pragma_set(name, value)
+        Sequel::Deprecation.deprecate('Database#{pragma_set,auto_vacuum=,case_sensitive_like=,foreign_keys=,synchronous=,temp_store=} on SQLite', "These methods are not thread safe or safe when using multiple connections, pass the appropriate option when connecting to set the pragma correctly for all connections")
+        execute_ddl("PRAGMA #{name} = #{value}")
+      end
+      def synchronous
+        SYNCHRONOUS[pragma_get(:synchronous).to_i]
+      end
+      def synchronous=(value)
+        value = SYNCHRONOUS.index(value) || (raise Error, "Invalid value for synchronous option. Please specify one of :off, :normal, :full.")
+        pragma_set(:synchronous, value)
+      end
+      def temp_store
+        TEMP_STORE[pragma_get(:temp_store).to_i]
+      end
+      def temp_store=(value)
+        value = TEMP_STORE.index(value) || (raise Error, "Invalid value for temp_store option. Please specify one of :default, :file, :memory.")
+        pragma_set(:temp_store, value)
+      end
+
+      # Set the integer_booleans option using the passed in :integer_boolean option.
+      def set_integer_booleans
+        @integer_booleans = @opts.has_key?(:integer_booleans) ? typecast_value_boolean(@opts[:integer_booleans]) : true
+      end
 
       # Return the array of foreign key info hashes using the foreign_key_list PRAGMA,
       # including information for the :on_update and :on_delete entries.
@@ -115,8 +129,18 @@ module Sequel
         im = input_identifier_meth
         indexes = {}
         metadata_dataset.with_sql("PRAGMA index_list(?)", im.call(table)).each do |r|
-          # :only_autocreated internal option can be used to get only autocreated indexes
-          next if (!!(r[:name] =~ /\Asqlite_autoindex_/) ^ !!opts[:only_autocreated])
+          if opts[:only_autocreated]
+            # If specifically asked for only autocreated indexes, then return those an only those
+            next unless r[:name] =~ /\Asqlite_autoindex_/
+          elsif r.has_key?(:origin)
+            # If origin is set, then only exclude primary key indexes and partial indexes
+            next if r[:origin] == 'pk'
+            next if r[:partial].to_i == 1
+          else
+            # When :origin key not present, assume any autoindex could be a primary key one and exclude it
+            next if r[:name] =~ /\Asqlite_autoindex_/
+          end
+
           indexes[m.call(r[:name])] = {:unique=>r[:unique].to_i==1}
         end
         indexes.each do |k, v|
@@ -125,28 +149,6 @@ module Sequel
         indexes
       end
 
-      # Get the value of the given PRAGMA.
-      def pragma_get(name)
-        Sequel::Deprecation.deprecate('Database#{pragma_get,auto_vacuum,case_sensitive_like,foreign_keys,synchronous,temp_store} on SQLite', "These methods may not be safe when using multiple connections, call fetch(#{"PRAGMA #{name}".inspect}).single_value if you really want to get the pragma value")
-        self["PRAGMA #{name}"].single_value
-      end
-      
-      # Set the value of the given PRAGMA to value.
-      #
-      # This method is not thread safe, and will not work correctly if there
-      # are multiple connections in the Database's connection pool. PRAGMA
-      # modifications should be done when the connection is created, using
-      # an option provided when creating the Database object.
-      def pragma_set(name, value)
-        Sequel::Deprecation.deprecate('Database#{pragma_set,auto_vacuum=,case_sensitive_like=,foreign_keys=,synchronous=,temp_store=} on SQLite', "These methods are not thread safe or safe when using multiple connections, pass the appropriate option when connecting to set the pragma correctly for all connections")
-        execute_ddl("PRAGMA #{name} = #{value}")
-      end
-
-      # Set the integer_booleans option using the passed in :integer_boolean option.
-      def set_integer_booleans
-        @integer_booleans = @opts.has_key?(:integer_booleans) ? typecast_value_boolean(@opts[:integer_booleans]) : true
-      end
-      
       # The version of the server as an integer, where 3.6.19 = 30619.
       # If the server version can't be determined, 0 is used.
       def sqlite_version
@@ -190,36 +192,12 @@ module Sequel
         defined?(@use_timestamp_timezones) ? @use_timestamp_timezones : (@use_timestamp_timezones = false)
       end
 
-      # A symbol signifying the value of the synchronous PRAGMA.
-      def synchronous
-        SYNCHRONOUS[pragma_get(:synchronous).to_i]
-      end
-      
-      # Set the synchronous PRAGMA using the given symbol (:off, :normal, or :full). See pragma_set.
-      # Consider using the :synchronous Database option instead.
-      def synchronous=(value)
-        value = SYNCHRONOUS.index(value) || (raise Error, "Invalid value for synchronous option. Please specify one of :off, :normal, :full.")
-        pragma_set(:synchronous, value)
-      end
-      
       # Array of symbols specifying the table names in the current database.
       #
       # Options:
       # :server :: Set the server to use.
       def tables(opts=OPTS)
-        tables_and_views(TABLES_FILTER, opts)
-      end
-      
-      # A symbol signifying the value of the temp_store PRAGMA.
-      def temp_store
-        TEMP_STORE[pragma_get(:temp_store).to_i]
-      end
-      
-      # Set the temp_store PRAGMA using the given symbol (:default, :file, or :memory). See pragma_set.
-      # Consider using the :temp_store Database option instead.
-      def temp_store=(value)
-        value = TEMP_STORE.index(value) || (raise Error, "Invalid value for temp_store option. Please specify one of :default, :file, :memory.")
-        pragma_set(:temp_store, value)
+        tables_and_views(Sequel.~(:name=>'sqlite_sequence') & {:type => 'table'}, opts)
       end
       
       # Creates a dataset that uses the VALUES clause:
@@ -235,7 +213,7 @@ module Sequel
       # Options:
       # :server :: Set the server to use.
       def views(opts=OPTS)
-        tables_and_views(VIEWS_FILTER, opts)
+        tables_and_views({:type => 'view'}, opts)
       end
 
       private
@@ -438,8 +416,12 @@ module Sequel
 
         # Determine unique constraints and make sure the new columns have them
         unique_columns = []
-        indexes(table, :only_autocreated=>true).each_value do |h|
-          unique_columns.concat(h[:columns]) if h[:columns].length == 1 && h[:unique]
+        skip_indexes = []
+        indexes(table, :only_autocreated=>true).each do |name, h|
+          skip_indexes << name
+          if h[:columns].length == 1 && h[:unique]
+            unique_columns.concat(h[:columns])
+          end
         end
         unique_columns -= pks
         unless unique_columns.empty?
@@ -462,6 +444,7 @@ module Sequel
            "DROP TABLE #{bt}"
         ]
         indexes(table).each do |name, h|
+          next if skip_indexes.include?(name)
           if (h[:columns].map(&:to_s) - new_columns).empty?
             a << alter_table_sql(table, h.merge(:op=>:add_index, :name=>name))
           end
@@ -471,7 +454,7 @@ module Sequel
 
       # Does the reverse of on_delete_clause, eg. converts strings like +'SET NULL'+
       # to symbols +:set_null+.
-      def on_delete_sql_to_sym str
+      def on_delete_sql_to_sym(str)
         case str
         when 'RESTRICT'
           :restrict
@@ -549,6 +532,9 @@ module Sequel
       include Dataset::Replace
       include UnmodifiedIdentifiers::DatasetMethods
 
+      # The allowed values for insert_conflict
+      INSERT_CONFLICT_RESOLUTIONS = %w'ROLLBACK ABORT FAIL IGNORE REPLACE'.each(&:freeze).freeze
+
       CONSTANT_MAP = {:CURRENT_DATE=>"date(CURRENT_TIMESTAMP, 'localtime')".freeze, :CURRENT_TIMESTAMP=>"datetime(CURRENT_TIMESTAMP, 'localtime')".freeze, :CURRENT_TIME=>"time(CURRENT_TIMESTAMP, 'localtime')".freeze}#.freeze # SEQUEL5
       EXTRACT_MAP = {:year=>"'%Y'", :month=>"'%m'", :day=>"'%d'", :hour=>"'%H'", :minute=>"'%M'", :second=>"'%f'"}#.freeze # SEQUEL5
       #EXTRACT_MAP.each_value(&:freeze) # SEQUEL5
@@ -676,7 +662,7 @@ module Sequel
       end
       
       # Return an array of strings specifying a query explanation for a SELECT of the
-      # current dataset. Currently, the options are ignore, but it accepts options
+      # current dataset. Currently, the options are ignored, but it accepts options
       # to be compatible with other adapters.
       def explain(opts=nil)
         # Load the PrettyTable class, needed for explain output
@@ -723,6 +709,10 @@ module Sequel
       #   DB[:table].insert_conflict(:replace).insert(:a=>1, :b=>2)
       #   # INSERT OR REPLACE INTO TABLE (a, b) VALUES (1, 2)
       def insert_conflict(resolution = :ignore)
+        unless INSERT_CONFLICT_RESOLUTIONS.include?(resolution.to_s.upcase)
+          Sequel::Deprecation.deprecate("Passing #{resolution.inspect} argument to Dataset#insert_conflict", "The allowed values are: :rollback, :abort, :fail, :ignore, or :replace")
+          # raise Error, "Invalid value passed to Dataset#insert_conflict: #{resolution.inspect}.  The allowed values are: :rollback, :abort, :fail, :ignore, or :replace"
+        end
         clone(:insert_conflict => resolution)
       end
 

data/lib/sequel/adapters/sqlanywhere.rb

@@ -19,7 +19,7 @@ module Sequel
       end
     end
 
-    TYPE_TRANSLATOR = tt = Class.new do
+    tt = Class.new do
       def blob(s) ::Sequel::SQL::Blob.new(s) end
       def boolean(s) s.to_i != 0 end
       def date(s) ::Date.strptime(s) end
@@ -27,6 +27,9 @@ module Sequel
       def time(s) ::Sequel.string_to_time(s) end
     end.new
 
+    TYPE_TRANSLATOR = tt
+    Sequel::Deprecation.deprecate_constant(self, :TYPE_TRANSLATOR)
+
     SQLANYWHERE_TYPES = {}
     {
         [0, 484] => tt.method(:decimal),

data/lib/sequel/adapters/sqlite.rb

@@ -7,9 +7,9 @@ module Sequel
   # Top level module for holding all SQLite-related modules and classes
   # for Sequel.
   module SQLite
-    TYPE_TRANSLATOR = tt = Class.new do
-      FALSE_VALUES = (%w'0 false f no n' + [0]).freeze
+    FALSE_VALUES = (%w'0 false f no n' + [0]).freeze
 
+    tt = Class.new do
       def blob(s)
         Sequel::SQL::Blob.new(s.to_s)
       end
@@ -58,9 +58,11 @@ module Sequel
           raise Sequel::Error, "unhandled type when converting to date: #{s.inspect} (#{s.class.inspect})"
         end
       end
-
     end.new
 
+    TYPE_TRANSLATOR = tt
+    Sequel::Deprecation.deprecate_constant(self, :TYPE_TRANSLATOR)
+
     # Hash with string keys and callable values for converting SQLite types.
     SQLITE_TYPES = {}
     {

data/lib/sequel/adapters/swift/postgres.rb

@@ -4,8 +4,6 @@ require 'swift/db/postgres'
 Sequel.require 'adapters/shared/postgres'
 
 module Sequel
-  Postgres::CONVERTED_EXCEPTIONS << ::Swift::Error
-  
   module Swift
     # Adapter, Database, and Dataset support for accessing a PostgreSQL
     # database via Swift.
@@ -23,6 +21,11 @@ module Sequel
         
         private
         
+        DATABASE_ERROR_CLASSES = [::Swift::Error].freeze
+        def database_error_classes
+          DATABASE_ERROR_CLASSES
+        end
+
         # Remove all other options except for ones specifically handled, as
         # otherwise swift passes them to dbic++ which passes them to PostgreSQL
         # which can raise an error.

data/lib/sequel/adapters/tinytds.rb

@@ -188,14 +188,11 @@ module Sequel
       Database::DatasetClass = self
       Sequel::Deprecation.deprecate_constant(Database, :DatasetClass)
       
-      # SQLite already supports named bind arguments, so use directly.
       module ArgumentMapper
         include Sequel::Dataset::ArgumentMapper
         
         protected
         
-        # Return a hash with the same values as the given hash,
-        # but with the keys converted to strings.
         def map_to_prepared_args(hash)
           args = {}
           hash.each{|k,v| args[k.to_s.gsub('.', '__')] = v}
@@ -204,8 +201,6 @@ module Sequel
         
         private
         
-        # SQLite uses a : before the name of the argument for named
-        # arguments.
         def prepared_arg(k)
           LiteralString.new("@#{k.to_s.gsub('.', '__')}")
         end

data/lib/sequel/adapters/utils/mysql_mysql2.rb

@@ -18,7 +18,7 @@ module Sequel
         closed MySQL connection
         END
         # Error messages for mysql and mysql2 that indicate the current connection should be disconnected
-        MYSQL_DATABASE_DISCONNECT_ERRORS = /\A#{Regexp.union(disconnect_errors)}/o
+        MYSQL_DATABASE_DISCONNECT_ERRORS = /\A#{Regexp.union(disconnect_errors)}/
        
         # Support stored procedures on MySQL
         def call_sproc(name, opts=OPTS, &block)

data/lib/sequel/adapters/utils/pg_types.rb

@@ -1,78 +1,4 @@
 # frozen-string-literal: true
 
-module Sequel
-  module Postgres
-    NAN             = 0.0/0.0
-    PLUS_INFINITY   = 1.0/0.0
-    MINUS_INFINITY  = -1.0/0.0
-
-    NAN_STR             = 'NaN'.freeze
-    Sequel::Deprecation.deprecate_constant(self, :NAN_STR)
-    PLUS_INFINITY_STR   = 'Infinity'.freeze
-    Sequel::Deprecation.deprecate_constant(self, :PLUS_INFINITY_STR)
-    MINUS_INFINITY_STR  = '-Infinity'.freeze
-    Sequel::Deprecation.deprecate_constant(self, :MINUS_INFINITY_STR)
-    TRUE_STR = 't'.freeze
-    Sequel::Deprecation.deprecate_constant(self, :TRUE_STR)
-    DASH_STR = '-'.freeze
-    Sequel::Deprecation.deprecate_constant(self, :DASH_STR)
-    
-    TYPE_TRANSLATOR = tt = Class.new do
-      def boolean(s) s == 't' end
-      def integer(s) s.to_i end
-      def float(s) 
-        case s
-        when 'NaN'
-          NAN
-        when 'Infinity'
-          PLUS_INFINITY
-        when '-Infinity'
-          MINUS_INFINITY
-        else
-          s.to_f 
-        end
-      end
-      def date(s) ::Date.new(*s.split('-').map(&:to_i)) end
-      def bytea(str)
-        str = if str =~ /\A\\x/
-          # PostgreSQL 9.0+ bytea hex format
-          str[2..-1].gsub(/(..)/){|s| s.to_i(16).chr}
-        else
-          # Historical PostgreSQL bytea escape format
-          str.gsub(/\\(\\|'|[0-3][0-7][0-7])/) {|s|
-            if s.size == 2 then s[1,1] else s[1,3].oct.chr end
-          }
-        end
-        ::Sequel::SQL::Blob.new(str)
-      end
-    end.new
-
-    # Type OIDs for string types used by PostgreSQL.  These types don't
-    # have conversion procs associated with them (since the data is
-    # already in the form of a string).
-    STRING_TYPES = [18, 19, 25, 1042, 1043]#.freeze # SEQUEL5
-
-    # Hash with type name strings/symbols and callable values for converting PostgreSQL types.
-    # Non-builtin types that don't have fixed numbers should use this to register
-    # conversion procs.
-    PG_NAMED_TYPES = {} unless defined?(PG_NAMED_TYPES)
-    PG_NAMED__TYPES = PG_NAMED_TYPES
-    Sequel::Deprecation.deprecate_constant(self, :PG_NAMED_TYPES)
-
-    # Hash with integer keys and callable values for converting PostgreSQL types.
-    PG_TYPES = {} unless defined?(PG_TYPES)
-
-    {
-      [16] => tt.method(:boolean),
-      [17] => tt.method(:bytea),
-      [20, 21, 23, 26] => tt.method(:integer),
-      [700, 701] => tt.method(:float),
-      [1700] => ::BigDecimal.method(:new),
-      [1083, 1266] => ::Sequel.method(:string_to_time),
-      [1082] => ::Sequel.method(:string_to_date),
-      [1184, 1114] => ::Sequel.method(:database_to_application_timestamp),
-    }.each do |k,v|
-      k.each{|n| PG_TYPES[n] = v}
-    end
-  end
-end 
+Sequel::Deprecation.deprecate("requiring sequel/adapters/utils/pg_types", "This file should no longer be required, use Database#conversion_procs to modify conversion procs for a Database instance")
+Sequel.require 'adapters/shared/postgres'

data/lib/sequel/ast_transformer.rb

@@ -93,7 +93,7 @@ module Sequel
     def initialize(table, unused=nil)
       if unused
         # :nocov:
-        Sequel::Deprecation.deprecate("Passing two arguments to Sequel::Qualifier.new", 'Pass only the second arguument specifying the table used for qualification')
+        Sequel::Deprecation.deprecate("Passing two arguments to Sequel::Qualifier.new", 'Pass only the second argument specifying the table used for qualification')
         @table = unused
         # :nocov:
       else

data/lib/sequel/connection_pool/sharded_single.rb

@@ -111,5 +111,5 @@ class Sequel::ShardedSingleConnectionPool < Sequel::ConnectionPool
     servers.each{|s| hold(s){}}
   end
   
-  CONNECTION_POOL_MAP[[true, true]] = self
+  CONNECTION_POOL__MAP[[true, true]] = self
 end

data/lib/sequel/connection_pool/sharded_threaded.rb

@@ -353,5 +353,5 @@ class Sequel::ShardedThreadedConnectionPool < Sequel::ThreadedConnectionPool
     disconnect_connection(conn)
   end
   
-  CONNECTION_POOL_MAP[[false, true]] = self
+  CONNECTION_POOL__MAP[[false, true]] = self
 end

data/lib/sequel/connection_pool/single.rb

@@ -26,7 +26,7 @@ class Sequel::SingleConnectionPool < Sequel::ConnectionPool
   def hold(server=nil)
     begin
       unless c = @conn.first
-        @conn.replace([c = make_new(DEFAULT_SERVER)])
+        @conn.replace([c = make_new(:default)])
       end
       yield c
     rescue Sequel::DatabaseDisconnectError, *@error_classes => e
@@ -57,5 +57,5 @@ class Sequel::SingleConnectionPool < Sequel::ConnectionPool
     hold{}
   end
 
-  CONNECTION_POOL_MAP[[true, false]] = self
+  CONNECTION_POOL__MAP[[true, false]] = self
 end

data/lib/sequel/connection_pool/threaded.rb

@@ -198,7 +198,7 @@ class Sequel::ThreadedConnectionPool < Sequel::ConnectionPool
   # available, tries to create a new connection. The calling code should already
   # have the mutex before calling this.
   def available
-    next_available || make_new(DEFAULT_SERVER)
+    next_available || make_new(:default)
   end
 
   # Return a connection to the pool of available connections, returns the connection.
@@ -282,5 +282,5 @@ class Sequel::ThreadedConnectionPool < Sequel::ConnectionPool
     @mutex.synchronize{yield}
   end
   
-  CONNECTION_POOL_MAP[[false, false]] = self
+  CONNECTION_POOL__MAP[[false, false]] = self
 end

data/lib/sequel/connection_pool.rb

@@ -29,12 +29,15 @@ class Sequel::ConnectionPool
 
   # The default server to use
   DEFAULT_SERVER = :default
+  Sequel::Deprecation.deprecate_constant(self, :DEFAULT_SERVER)
   
   # A map of [single threaded, sharded] values to symbols or ConnectionPool subclasses.
   CONNECTION_POOL_MAP = {[true, false] => :single, 
     [true, true] => :sharded_single,
     [false, false] => :threaded,
     [false, true] => :sharded_threaded}
+  CONNECTION_POOL__MAP = CONNECTION_POOL_MAP
+  Sequel::Deprecation.deprecate_constant(self, :CONNECTION_POOL_MAP)
   
   # Class methods used to return an appropriate pool subclass, separated
   # into a module for easier overridding by extensions.
@@ -57,7 +60,10 @@ class Sequel::ConnectionPool
     
     # Return a connection pool class based on the given options.
     def connection_pool_class(opts)
-      CONNECTION_POOL_MAP[opts[:pool_class]] || opts[:pool_class] || CONNECTION_POOL_MAP[[!!opts[:single_threaded], !!opts[:servers]]]
+      if opts[:pool_class] && !opts[:pool_class].is_a?(Class) && ![:threaded, :single, :sharded_threaded, :sharded_single].include?(opts[:pool_class])
+        Sequel::Deprecation.deprecate("Using an unrecognized :pool_class option", "Use a class for the :pool_class option to select a custom pool class, or one of the following symbols for one of the default pool classes: :threaded, :single, :sharded_threaded, :sharded_single")
+      end
+      CONNECTION_POOL__MAP[opts[:pool_class]] || opts[:pool_class] || CONNECTION_POOL__MAP[[!!opts[:single_threaded], !!opts[:servers]]]
     end
   end
   extend ClassMethods
@@ -89,12 +95,13 @@ class Sequel::ConnectionPool
   
   # Alias for +size+, not aliased directly for ease of subclass implementation
   def created_count(*args)
+    Sequel::Deprecation.deprecate("Sequel::ConnectionPool#created_count", "Use #size instead")
     size(*args)
   end
   
   # An array of symbols for all shards/servers, which is a single <tt>:default</tt> by default.
   def servers
-    [DEFAULT_SERVER]
+    [:default]
   end
   
   private

data/lib/sequel/core.rb

@@ -188,8 +188,8 @@ module Sequel
 
   # Convert given object to json and return the result.
   # This can be overridden to use an alternative json implementation.
-  def self.object_to_json(obj, *args)
-    obj.to_json(*args)
+  def self.object_to_json(obj, *args, &block)
+    obj.to_json(*args, &block)
   end
 
   # Parse the string as JSON and return the result.

data/lib/sequel/database/connecting.rb

@@ -8,7 +8,7 @@ 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)
+    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
@@ -49,7 +49,7 @@ module Sequel
       case conn_string
       when String
         # SEQUEL5: Remove do
-        if match = /\A(jdbc|do):/o.match(conn_string)
+        if match = /\A(jdbc|do):/.match(conn_string)
           c = adapter_class(match[1].to_sym)
           opts = opts.merge(:orig_opts=>opts.dup)
           opts = {:uri=>conn_string}.merge!(opts)
@@ -58,7 +58,7 @@ 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.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)}
           opts = uri_options.merge(opts).merge!(:orig_opts=>opts.dup, :uri=>conn_string, :adapter=>scheme)
         end
@@ -197,7 +197,7 @@ module Sequel
     #   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.")
+        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
       end
@@ -220,14 +220,14 @@ module Sequel
     
     # 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
@@ -262,7 +262,7 @@ 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.")
+        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
       end

data/lib/sequel/database/dataset.rb

@@ -58,12 +58,15 @@ module Sequel
     #   DB.from(:items) # SELECT * FROM items
     #   DB.from(:items){id > 2} # SELECT * FROM items WHERE (id > 2)
     def from(*args, &block)
-      ds = @default_dataset.from(*args)
       if block
         Sequel::Deprecation.deprecate("Sequel::Database#from with a block", "Use .from(*args).where(&block) instead")
-        ds.where(&block)
+        @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)}
       else
-        ds
+        @default_dataset.from(*args)
       end
     end
     

data/lib/sequel/database/dataset_defaults.rb

@@ -69,6 +69,9 @@ 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
@@ -82,9 +85,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)