sequel 4.12.0 → 4.13.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b15d571f0ccc175749541cfee443b953dcd145fd
-  data.tar.gz: 9dec9dd2f6816432f511c0153737646e44da31a1
+  metadata.gz: 22556ea07ee280b6aeb118f6079e84cd50079cd4
+  data.tar.gz: 011dbf4ff522233e9bed8a1b2bab18347237345b
 SHA512:
-  metadata.gz: ec94d8b6fcd34fecdb4d4c3cc4f2b4fb0277c8d7289baebde098b8b84cc99ab0bfd0ab28effa316df0a0fbba1a7bf2cc3bc0fbbfc682e68f6d50326652719306
-  data.tar.gz: 919e8651ded7808d66e95788af7993c4b13136487bed14b6e12db2150bca22ab166eef6e0eeb5350b2e2aebdb6f72c36f47ef7dfaef4e3eea2170c396f15f02c
+  metadata.gz: 9dc9163ebb7f4066cd44da3bdd85b1f5f26cea75b4af812f50ef2c950742b38b992b5c0fbdf61428395b3624788b31cf9f42a9da9b7bfac4ea4976cd29c73b69
+  data.tar.gz: 0ba493e43d63d2fe3d750a621199bb5f43b39e72858424e0089ff977045a3bc6b1c472751ad4c629bbf83680de7bad227cd29c4d7f705389ee212ee638e5c77f

data/CHANGELOG

@@ -1,3 +1,67 @@
+=== 4.13.0 (2014-08-01)
+
+* Use copy constructors instead of overriding Model#dup and #clone (ged, jeremyevans) (#852)
+
+* Fix handling of MySQL create_table foreign_key calls using :key option (mimperatore, jeremyevans) (#850)
+
+* Handle another disconnection error in the postgres adapter (lbosque) (#848)
+
+* Make list plugin update remaining positions after destroying an instance (ehq, jeremyevans) (#847)
+
+* Unalias aliased tables in Dataset#insert (jeremyevans)
+
+* Add insert_returning_select plugin, for setting up RETURNING for inserts for models selecting explicit columns (jeremyevans)
+
+* Make Model#save use insert_select if the dataset used for inserting already uses returning (jeremyevans)
+
+* Add Dataset#unqualified_column_for helper method, returning unqualified version of possibly qualified column (jeremyevans)
+
+* Calling Dataset#returning when the Database does not support or emulate RETURNING now raises an Error (jeremyevans)
+
+* Emulate RETURNING on Microsoft SQL Server using OUTPUT, as long as only simple column references are used (jeremyevans)
+
+* Switch class_table_inheritance plugin to use JOIN ON instead of JOIN USING (jeremyevans)
+
+* Qualify primary keys for models with joined datasets when looking up model instances by primary key (jeremyevans)
+
+* Fix qualification of columns when Dataset#graph automatically wraps the initially graphed dataset in a subselect (jeremyevans)
+
+* Make Dataset#joined_dataset? a public method (jeremyevans)
+
+* Allow external jdbc, odbc, and do subadapters to be loaded automatically (jeremyevans)
+
+* Recognize another disconnect error in the jdbc/mysql adapter (jeremyevans)
+
+* Set primary keys correctly for models even if datasets select specific columns (jeremyevans)
+
+* Add dataset_source_alias extension, for automatically aliasing datasets to their first source (jeremyevans)
+
+* Use qualified columns in the lazy_attributes plugin (jeremyevans)
+
+* Add column_select plugin, for using explicit column selections in model datasets (jeremyevans)
+
+* Use associated model's existing selection for join associations if it consists solely of explicitly quailfied columns (jeremyevans)
+
+* Add round_timestamps extension for automatically rounding timestamp values to database precision before literalizing (jeremyevans)
+
+* Make rake default task run plugin specs as well as core/model specs (jeremyevans)
+
+* Use all_tables and all_views for Database#tables and #views on Oracle (jeremyevans)
+
+* Use all_tab_cols instead of user_tab cols for defaults parsing in the oracle adapter (jeremyevans)
+
+* Fix recursive mutex locking issue on JRuby when using Sequel::Model(dataset) (jeremyevans) (#841)
+
+* Make composition and serialization plugins support validations on underlying columns (jeremyevans)
+
+* Fix regression in timestamps and table inheritance plugin where column values would not be saved if validation is skipped (jeremyevans) (#839)
+
+* Add pg_enum extension, for dealing with PostgreSQL enums (jeremyevans)
+
+* Add modification_detection plugin, for automatic detection of in-place column value modifications (jeremyevans)
+
+* Speed up using plain strings, numbers, true, false, and nil in json columns if underlying json library supports them (jeremyevans) (#834)
+
 === 4.12.0 (2014-07-01)
 
 * Support :readonly Database option in sqlite adapter (ippeiukai, jeremyevans) (#832)

data/Rakefile

@@ -132,7 +132,9 @@ begin
     t
   end
 
-  task :default => [:spec]
+  desc "Run the core, model, and extension/plugin specs"
+  task :default => [:spec, :spec_plugin]
+
   spec_with_cov.call("spec", Dir["spec/{core,model}/*_spec.rb"], "Run core and model specs"){|t| t.rcov_opts.concat(%w'--exclude "lib/sequel/(adapters/([a-ln-z]|m[a-np-z])|extensions/core_extensions)"')}
   spec.call("spec_bin", ["spec/bin_spec.rb"], "Run bin/sequel specs")
   spec.call("spec_core", Dir["spec/core/*_spec.rb"], "Run core specs")

data/bin/sequel

@@ -2,8 +2,6 @@
 
 require 'rubygems'
 require 'optparse'
-$: << File.join(File.dirname(__FILE__), '..', 'lib')
-require 'sequel'
 
 code = nil
 copy_databases = nil
@@ -13,6 +11,7 @@ env = nil
 migrate_dir = nil
 migrate_ver = nil
 backtrace = nil
+show_version = false
 test = true
 load_dirs = []
 exclusive_options = []
@@ -43,6 +42,7 @@ options = OptionParser.new do |opts|
   
   opts.on("-C", "--copy-databases", "copy one database to another") do 
     copy_databases = true
+    exclusive_options << :C
   end
   
   opts.on("-d", "--dump-migration", "print database migration to STDOUT") do 
@@ -104,8 +104,7 @@ options = OptionParser.new do |opts|
   end
   
   opts.on_tail("-v", "--version", "Show version") do
-    puts "sequel #{Sequel.version}"
-    exit
+    show_version = true
   end
 end
 opts = options
@@ -140,6 +139,15 @@ connect_proc = lambda do |database|
 end
 
 begin
+  $:.unshift(File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib')))
+  require 'sequel'
+  if show_version
+    puts "sequel #{Sequel.version}"
+    unless db || code
+      exit
+    end
+  end
+
   DB = connect_proc[db]
   load_dirs.each{|d| d.is_a?(Array) ? require(d.first) : Dir["#{d}/**/*.rb"].each{|f| load(f)}}
   if migrate_dir
@@ -222,7 +230,7 @@ begin
   end
 rescue => e
   raise e if backtrace
-  error_proc["Error: #{e.class}: #{e.message}#{e.backtrace.first}"]
+  error_proc["Error: #{e.class}: #{e.message}\n#{e.backtrace.first}"]
 end
 
 if !ARGV.empty? 

data/doc/release_notes/4.13.0.txt

@@ -0,0 +1,169 @@
+= New Features
+
+* A modification_detection plugin has been added, for automatic
+  detection of in-place column value modifications.  This makes
+  it so you don't have to call Model#modified! manually when
+  changing a value in place.
+
+* A column_select plugin has been added, for automatically
+  selecting explicitly qualified columns in model datasets.
+  Example:
+
+    Sequel::Model.plugin :column_select
+    class Album < Sequel::Model
+    end
+    Album.dataset.sql
+    # SELECT albums.id, albums.name, albums.artist_id
+    # FROM albums
+
+* An insert_returning_select plugin has been added, for automatically
+  setting up RETURNING clauses for models that select explicit
+  columns.  This is useful when using the column_select or
+  lazy_attributes plugins.
+
+* A pg_enum extension has been added, for easier dealing with
+  PostgreSQL enum types.  The possible values for the type
+  are then returned in the schema hashes under the :enum_values
+  key.  It also adds create_enum, drop_enum, and add_enum_value
+  Database methods for migration support.
+
+* A round_timestamps extension has been added, for automatically
+  rounding timestamps to database supported precision when
+  literalizing.
+
+* A dataset_source_alias extension has been added, for automatically
+  aliasing datasets to their first source, instead of using t1, t2.
+  Example:
+
+    DB.from(:a, DB[:b]).sql
+    # SELECT * FROM a, (SELECT * FROM b) AS t1
+
+    DB.extension(:dataset_source_alias)
+    DB.from(:a, DB[:b]).sql
+    # SELECT * FROM a, (SELECT * FROM b) AS b
+
+* On Microsoft SQL Server, Sequel now emulates RETURNING support
+  using the OUTPUT clause, as long as only simple column references
+  are used.
+
+= Other Improvements
+
+* A regression has been fixed in the timestamps and table
+  inheritance plugins, where column values would not be
+  saved when skipping validations.  This was first broken in
+  4.11.0.
+
+* A regression has been fixed on JRuby and Rubinius when using
+  Sequel::Model(dataset) if the dataset needs to literalize a
+  symbol (and most do).  This was first broken in 4.10.0.
+
+* Primary keys are now automatically setup for models even if
+  the models select specific columns.
+
+* The lazy_attributes plugin now uses qualified columns in its
+  selection, instead of unqualified columns.
+
+* When looking up model instances by primary key, Sequel now uses a
+  qualified primary key if the model uses a joined dataset.
+
+* For associations that require joins, Sequel will now use the
+  associated model's selection directly (instead of
+  associated_table.*) if the associated model's selection consists
+  solely of qualified columns.
+
+  Among other things, this means that a many_to_many association to 
+  a model that uses lazy attributes will not eagerly load the lazy
+  attributes by default.
+
+* Model#save now uses insert_select if there is an existing
+  RETURNING clause used by the underlying dataset, even if the model
+  selects specific columns.
+
+* In Dataset#insert, aliased tables are now automatically unaliased.
+  This allows you to use a dataset with an aliased table and have
+  full SELECT/INSERT/UPDATE/DELETE support, assuming the database
+  supports aliased tables in UPDATE and DELETE.
+
+* Dataset#graph now qualifies columns correctly if the current
+  dataset is a joined dataset and it moves the current dataset to
+  a subselect.
+
+* Dataset#joined_dataset? is now a public method, and can be used to
+  determine whether the dataset uses a join, either explicitly via
+  JOIN or implicitly via multiple FROM tables.
+
+* The Dataset#unqualified_column_for helper method has been added,
+  returning the unqualified version of a possibly qualified column.
+
+* The composition and serialization plugins now support validations
+  on the underlying columns.  Previously, the didn't update the
+  underlying columns until after validations were performed.  This
+  works better when using the auto_validations plugin.
+
+* The class_table_inheritance plugin now uses JOIN ON instead of
+  JOIN USING, which makes it work on all databases that Sequel
+  supports.  Additionally, the plugin now explicitly selects
+  qualified columns from all of the tables.
+
+* The list plugin now adds an after_destroy hook that will renumber
+  rows after the current row, similar to how moving existing values
+  in the list works.
+
+* The pg_json extension is now faster when json column value is a
+  plain string, number, true, false, or nil, if the underlying json
+  library handles such values natively.
+
+* External jdbc, odbc, and do subadapters can now be loaded
+  automatically without requiring them first, assuming proper
+  support in the external subadapter.
+
+* When using create_table on MySQL, correctly handle the :key
+  option to when calling foreign_key with a column reference.
+
+* On Oracle, use all_tab_cols instead of user_tab_cols for getting
+  default values when parsing the schema.  This makes it work if the
+  user does not own the table.
+
+* On Oracle, use all_tables and all_views for Database#tables and
+  Database#views.  This works better for users with limited rights.
+
+* Additional disconnect errors are now recognized in the postgres and
+  jdbc/mysql adapters.
+
+* Sequel::Model now uses copy constructors (e.g. initialize_copy)
+  instead of overriding #dup and #clone.
+
+* The rake default task now runs plugin specs in addition to
+  core and model specs.
+
+= bin/sequel Improvements
+
+* Add the sequel lib directory to the front of the load path
+  instead of the end, fixing cases where you end up requiring an
+  old version of the sequel gem (e.g. by using sequel_pg).
+
+* Add the sequel lib directory as an absolute path, fixing cases
+  where you later change the current directory.
+
+* Require sequel later in the code, so that bin/sequel -h doesn't
+  need to require sequel, and full backtrace is not printed if
+  requiring sequel raises an error (unless -t is used).
+
+* If an exception is raised, put a newline between the exception
+  message and backtrace.
+
+* Don't allow usage of -C with any of -cdDmS.
+
+* If sequel -v is given along with a database or code string to
+  execute, print the Sequel version but also continue, similar
+  to how ruby -v works.
+
+= Backwards Compatibility
+
+* The switch from JOIN ON to JOIN USING in the
+  class_table_inheritance can break certain usage, such as querying
+  using unqualified primary key.  Users should switch to using a
+  qualified primary key instead.
+
+* Calling Dataset#returning when the underlying database does not
+  support it now raises an Error.

data/doc/sql.rdoc

@@ -287,9 +287,9 @@ Sequel also supports the SQL EXISTS operator using <tt>Dataset#exists</tt>:
 
 Hashes in Sequel use IS if the value is true, false, or nil:
 
-  {:column=>nil) # ("column" IS NULL)
-  {:column=>true) # ("column" IS TRUE)
-  {:column=>false) # ("column" IS FALSE)
+  {:column=>nil} # ("column" IS NULL)
+  {:column=>true} # ("column" IS TRUE)
+  {:column=>false} # ("column" IS FALSE)
 
 Negation works the same way as it does for equality and inclusion:
 

data/lib/sequel/adapters/do.rb

@@ -11,29 +11,17 @@ module Sequel
   # *  Sequel.connect('do:postgres://user:password@host/database')
   # *  Sequel.connect('do:mysql://user:password@host/database')
   module DataObjects
-    # Contains procs keyed on sub adapter type that extend the
+    # Contains procs keyed on subadapter type that extend the
     # given database object so it supports the correct database type.
-    DATABASE_SETUP = {:postgres=>proc do |db|
-        require 'do_postgres'
-        Sequel.require 'adapters/do/postgres'
-        db.extend(Sequel::DataObjects::Postgres::DatabaseMethods)
-        db.extend_datasets Sequel::Postgres::DatasetMethods
-      end,
-      :mysql=>proc do |db|
-        require 'do_mysql'
-        Sequel.require 'adapters/do/mysql'
-        db.extend(Sequel::DataObjects::MySQL::DatabaseMethods)
-        db.dataset_class = Sequel::DataObjects::MySQL::Dataset
-      end,
-      :sqlite3=>proc do |db|
-        require 'do_sqlite3'
-        Sequel.require 'adapters/do/sqlite'
-        db.extend(Sequel::DataObjects::SQLite::DatabaseMethods)
-        db.extend_datasets Sequel::SQLite::DatasetMethods
-        db.set_integer_booleans
-      end
-    }
+    DATABASE_SETUP = {}
       
+    # Wrapper for require that raises AdapterNotFound if driver could not be loaded
+    def self.load_driver(path)
+      require path
+    rescue LoadError => e
+      raise AdapterNotFound, e.message
+    end
+        
     # DataObjects uses it's own internal connection pooling in addition to the
     # pooling that Sequel uses.  You should make sure that you don't set
     # the connection pool size to more than 8 for a
@@ -108,12 +96,12 @@ module Sequel
       private
       
       # Call the DATABASE_SETUP proc directly after initialization,
-      # so the object always uses sub adapter specific code.  Also,
+      # so the object always uses subadapter specific code.  Also,
       # raise an error immediately if the connection doesn't have a
       # uri, since DataObjects requires one.
       def adapter_initialize
         raise(Error, "No connection string specified") unless uri
-        if prok = DATABASE_SETUP[subadapter.to_sym]
+        if prok = Sequel::Database.load_adapter(subadapter.to_sym, :map=>DATABASE_SETUP, :subdir=>'do')
           prok.call(self)
         end
       end

data/lib/sequel/adapters/do/mysql.rb

@@ -1,7 +1,15 @@
+Sequel::DataObjects.load_driver 'do_mysql'
 Sequel.require 'adapters/shared/mysql'
 
 module Sequel
   module DataObjects
+    Sequel.synchronize do
+      DATABASE_SETUP[:mysql] = proc do |db|
+        db.extend(Sequel::DataObjects::MySQL::DatabaseMethods)
+        db.dataset_class = Sequel::DataObjects::MySQL::Dataset
+      end
+    end
+
     # Database and Dataset instance methods for MySQL specific
     # support via DataObjects.
     module MySQL

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

@@ -1,9 +1,17 @@
+Sequel::DataObjects.load_driver 'do_postgres'
 Sequel.require 'adapters/shared/postgres'
 
 module Sequel
   Postgres::CONVERTED_EXCEPTIONS << ::DataObjects::Error
   
   module DataObjects
+    Sequel.synchronize do
+      DATABASE_SETUP[:postgres] = proc do |db|
+        db.extend(Sequel::DataObjects::Postgres::DatabaseMethods)
+        db.extend_datasets Sequel::Postgres::DatasetMethods
+      end
+    end
+
     # Adapter, Database, and Dataset support for accessing a PostgreSQL
     # database via DataObjects.
     module Postgres

data/lib/sequel/adapters/do/{sqlite.rb → sqlite3.rb}

@@ -1,7 +1,16 @@
+Sequel::DataObjects.load_driver 'do_sqlite3'
 Sequel.require 'adapters/shared/sqlite'
 
 module Sequel
   module DataObjects
+    Sequel.synchronize do
+      DATABASE_SETUP[:sqlite3] = proc do |db|
+        db.extend(Sequel::DataObjects::SQLite::DatabaseMethods)
+        db.extend_datasets Sequel::SQLite::DatasetMethods
+        db.set_integer_booleans
+      end
+    end
+
     # Database and Dataset support for SQLite databases accessed via DataObjects.
     module SQLite
       # Instance methods for SQLite Database objects accessed via DataObjects.

data/lib/sequel/adapters/jdbc.rb

@@ -27,146 +27,11 @@ module Sequel
     # to :integer.
     DECIMAL_TYPE_RE = /number|numeric|decimal/io
     
-    # Contains procs keyed on sub adapter type that extend the
+    # Contains procs keyed on subadapter type that extend the
     # given database object so it supports the correct database type.
-    DATABASE_SETUP = {:postgresql=>proc do |db|
-        JDBC.load_gem(:Postgres)
-        org.postgresql.Driver
-        Sequel.require 'adapters/jdbc/postgresql'
-        db.extend(Sequel::JDBC::Postgres::DatabaseMethods)
-        db.dataset_class = Sequel::JDBC::Postgres::Dataset
-        org.postgresql.Driver
-      end,
-      :mysql=>proc do |db|
-        JDBC.load_gem(:MySQL)
-        com.mysql.jdbc.Driver
-        Sequel.require 'adapters/jdbc/mysql'
-        db.extend(Sequel::JDBC::MySQL::DatabaseMethods)
-        db.extend_datasets Sequel::MySQL::DatasetMethods
-        com.mysql.jdbc.Driver
-      end,
-      :sqlite=>proc do |db|
-        JDBC.load_gem(:SQLite3)
-        org.sqlite.JDBC
-        Sequel.require 'adapters/jdbc/sqlite'
-        db.extend(Sequel::JDBC::SQLite::DatabaseMethods)
-        db.extend_datasets Sequel::SQLite::DatasetMethods
-        db.set_integer_booleans
-        org.sqlite.JDBC
-      end,
-      :oracle=>proc do |db|
-        Java::oracle.jdbc.driver.OracleDriver
-        Sequel.require 'adapters/jdbc/oracle'
-        db.extend(Sequel::JDBC::Oracle::DatabaseMethods)
-        db.dataset_class = Sequel::JDBC::Oracle::Dataset
-        Java::oracle.jdbc.driver.OracleDriver
-      end,
-      :sqlserver=>proc do |db|
-        com.microsoft.sqlserver.jdbc.SQLServerDriver
-        Sequel.require 'adapters/jdbc/sqlserver'
-        db.extend(Sequel::JDBC::SQLServer::DatabaseMethods)
-        db.extend_datasets Sequel::MSSQL::DatasetMethods
-        db.send(:set_mssql_unicode_strings)
-        com.microsoft.sqlserver.jdbc.SQLServerDriver
-      end,
-      :jtds=>proc do |db|
-        JDBC.load_gem(:JTDS)
-        Java::net.sourceforge.jtds.jdbc.Driver
-        Sequel.require 'adapters/jdbc/jtds'
-        db.extend(Sequel::JDBC::JTDS::DatabaseMethods)
-        db.dataset_class = Sequel::JDBC::JTDS::Dataset
-        db.send(:set_mssql_unicode_strings)
-        Java::net.sourceforge.jtds.jdbc.Driver
-      end,
-      :h2=>proc do |db|
-        JDBC.load_gem(:H2)
-        org.h2.Driver
-        Sequel.require 'adapters/jdbc/h2'
-        db.extend(Sequel::JDBC::H2::DatabaseMethods)
-        db.dataset_class = Sequel::JDBC::H2::Dataset
-        org.h2.Driver
-      end,
-      :hsqldb=>proc do |db|
-        JDBC.load_gem(:HSQLDB)
-        org.hsqldb.jdbcDriver
-        Sequel.require 'adapters/jdbc/hsqldb'
-        db.extend(Sequel::JDBC::HSQLDB::DatabaseMethods)
-        db.dataset_class = Sequel::JDBC::HSQLDB::Dataset
-        org.hsqldb.jdbcDriver
-      end,
-      :derby=>proc do |db|
-        JDBC.load_gem(:Derby)
-        org.apache.derby.jdbc.EmbeddedDriver
-        Sequel.require 'adapters/jdbc/derby'
-        db.extend(Sequel::JDBC::Derby::DatabaseMethods)
-        db.dataset_class = Sequel::JDBC::Derby::Dataset
-        org.apache.derby.jdbc.EmbeddedDriver
-      end,
-      :as400=>proc do |db|
-        com.ibm.as400.access.AS400JDBCDriver
-        Sequel.require 'adapters/jdbc/as400'
-        db.extend(Sequel::JDBC::AS400::DatabaseMethods)
-        db.dataset_class = Sequel::JDBC::AS400::Dataset
-        com.ibm.as400.access.AS400JDBCDriver
-      end,
-      :"informix-sqli"=>proc do |db|
-        com.informix.jdbc.IfxDriver
-        Sequel.require 'adapters/jdbc/informix'
-        db.extend(Sequel::JDBC::Informix::DatabaseMethods)
-        db.extend_datasets Sequel::Informix::DatasetMethods
-        com.informix.jdbc.IfxDriver
-      end,
-      :db2=>proc do |db|
-        com.ibm.db2.jcc.DB2Driver
-        Sequel.require 'adapters/jdbc/db2'
-        db.extend(Sequel::JDBC::DB2::DatabaseMethods)
-        db.dataset_class = Sequel::JDBC::DB2::Dataset
-        com.ibm.db2.jcc.DB2Driver
-      end,
-      :firebirdsql=>proc do |db|
-        org.firebirdsql.jdbc.FBDriver
-        Sequel.require 'adapters/jdbc/firebird'
-        db.extend(Sequel::JDBC::Firebird::DatabaseMethods)
-        db.extend_datasets Sequel::Firebird::DatasetMethods
-        org.firebirdsql.jdbc.FBDriver
-      end,
-      :jdbcprogress=>proc do |db|
-        com.progress.sql.jdbc.JdbcProgressDriver
-        Sequel.require 'adapters/jdbc/progress'
-        db.extend(Sequel::JDBC::Progress::DatabaseMethods)
-        db.extend_datasets Sequel::Progress::DatasetMethods
-        com.progress.sql.jdbc.JdbcProgressDriver
-      end,
-      :cubrid=>proc do |db|
-        Java::cubrid.jdbc.driver.CUBRIDDriver
-        Sequel.require 'adapters/jdbc/cubrid'
-        db.extend(Sequel::JDBC::Cubrid::DatabaseMethods)
-        db.extend_datasets Sequel::Cubrid::DatasetMethods
-        Java::cubrid.jdbc.driver.CUBRIDDriver
-      end,
-      :sqlanywhere=>proc do |db|
-        drv = [
-          lambda{Java::sybase.jdbc4.sqlanywhere.IDriver},
-          lambda{Java::ianywhere.ml.jdbcodbc.jdbc4.IDriver},
-          lambda{Java::sybase.jdbc.sqlanywhere.IDriver},
-          lambda{Java::ianywhere.ml.jdbcodbc.jdbc.IDriver},
-          lambda{Java::com.sybase.jdbc4.jdbc.Sybdriver},
-          lambda{Java::com.sybase.jdbc3.jdbc.Sybdriver}
-        ].each do |class_proc|
-          begin
-            break class_proc.call
-          rescue NameError
-          end
-        end
-        Sequel.require 'adapters/jdbc/sqlanywhere'
-        db.extend(Sequel::JDBC::SqlAnywhere::DatabaseMethods)
-        db.dataset_class = Sequel::JDBC::SqlAnywhere::Dataset
-        drv
-      end
-    }
+    DATABASE_SETUP = {}
     
-    # Allowing loading the necessary JDBC support via a gem, which
-    # works for PostgreSQL, MySQL, and SQLite.
+    # Allow loading the necessary JDBC support via a gem.
     def self.load_gem(name)
       begin
         require "jdbc/#{name.to_s.downcase}"
@@ -180,6 +45,18 @@ module Sequel
       end
     end
 
+    # Attempt to load the JDBC driver class, which should be specified as a string
+    # containing the driver class name (which JRuby should autoload).
+    # Note that the string is evaled, so this method is not safe to call with
+    # untrusted input.
+    # Raise a Sequel::AdapterNotFound if evaluating the class name raises a NameError.
+    def self.load_driver(drv, gem=nil)
+      load_gem(gem) if gem
+      eval drv
+    rescue NameError
+      raise Sequel::AdapterNotFound, "#{drv} not loaded#{", try installing jdbc-#{gem.to_s.downcase} gem" if gem}"
+    end
+
     class TypeConvertor
       %w'Boolean Float Double Int Long Short'.each do |meth|
         class_eval("def #{meth}(r, i) v = r.get#{meth}(i); v unless r.wasNull end", __FILE__, __LINE__)
@@ -473,7 +350,7 @@ module Sequel
         
         resolved_uri = jndi? ? get_uri_from_jndi : uri
 
-        @driver = if (match = /\Ajdbc:([^:]+)/.match(resolved_uri)) && (prok = DATABASE_SETUP[match[1].to_sym])
+        @driver = if (match = /\Ajdbc:([^:]+)/.match(resolved_uri)) && (prok = Sequel::Database.load_adapter(match[1].to_sym, :map=>DATABASE_SETUP, :subdir=>'jdbc'))
           prok.call(self)
         else
           @opts[:driver]