sequel 4.12.0 → 4.13.0

data/lib/sequel/adapters/jdbc/as400.rb

@@ -1,8 +1,17 @@
+Sequel::JDBC.load_driver('com.ibm.as400.access.AS400JDBCDriver')
 Sequel.require 'adapters/jdbc/transactions'
 Sequel.require 'adapters/utils/emulate_offset_with_row_number'
 
 module Sequel
   module JDBC
+    Sequel.synchronize do
+      DATABASE_SETUP[:as400] = proc do |db|
+        db.extend(Sequel::JDBC::AS400::DatabaseMethods)
+        db.dataset_class = Sequel::JDBC::AS400::Dataset
+        com.ibm.as400.access.AS400JDBCDriver
+      end
+    end
+
     # Database and Dataset support for AS400 databases accessed via JDBC.
     module AS400
       # Instance methods for AS400 Database objects accessed via JDBC.

data/lib/sequel/adapters/jdbc/cubrid.rb

@@ -1,8 +1,17 @@
+Sequel::JDBC.load_driver('Java::cubrid.jdbc.driver.CUBRIDDriver')
 Sequel.require 'adapters/shared/cubrid'
 Sequel.require 'adapters/jdbc/transactions'
 
 module Sequel
   module JDBC
+    Sequel.synchronize do
+      DATABASE_SETUP[:cubrid] = proc do |db|
+        db.extend(Sequel::JDBC::Cubrid::DatabaseMethods)
+        db.extend_datasets Sequel::Cubrid::DatasetMethods
+        Java::cubrid.jdbc.driver.CUBRIDDriver
+      end
+    end
+
     module Cubrid
       module DatabaseMethods
         extend Sequel::Database::ResetIdentifierMangling

data/lib/sequel/adapters/jdbc/db2.rb

@@ -1,8 +1,17 @@
+Sequel::JDBC.load_driver('com.ibm.db2.jcc.DB2Driver')
 Sequel.require 'adapters/shared/db2'
 Sequel.require 'adapters/jdbc/transactions'
 
 module Sequel
   module JDBC
+    Sequel.synchronize do
+      DATABASE_SETUP[:db2] = proc do |db|
+        db.extend(Sequel::JDBC::DB2::DatabaseMethods)
+        db.dataset_class = Sequel::JDBC::DB2::Dataset
+        com.ibm.db2.jcc.DB2Driver
+      end
+    end
+
     class TypeConvertor
       def DB2Clob(r, i)
         if v = r.getClob(i)

data/lib/sequel/adapters/jdbc/derby.rb

@@ -1,7 +1,16 @@
+Sequel::JDBC.load_driver('org.apache.derby.jdbc.EmbeddedDriver', :Derby)
 Sequel.require 'adapters/jdbc/transactions'
 
 module Sequel
   module JDBC
+    Sequel.synchronize do
+      DATABASE_SETUP[:derby] = proc do |db|
+        db.extend(Sequel::JDBC::Derby::DatabaseMethods)
+        db.dataset_class = Sequel::JDBC::Derby::Dataset
+        org.apache.derby.jdbc.EmbeddedDriver
+      end
+    end
+
     # Database and Dataset support for Derby databases accessed via JDBC.
     module Derby
       # Instance methods for Derby Database objects accessed via JDBC.

data/lib/sequel/adapters/jdbc/{firebird.rb → firebirdsql.rb}

@@ -1,8 +1,17 @@
+Sequel::JDBC.load_driver('org.firebirdsql.jdbc.FBDriver')
 Sequel.require 'adapters/shared/firebird'
 Sequel.require 'adapters/jdbc/transactions'
 
 module Sequel
   module JDBC
+    Sequel.synchronize do
+      DATABASE_SETUP[:firebirdsql] = proc do |db|
+        db.extend(Sequel::JDBC::Firebird::DatabaseMethods)
+        db.extend_datasets Sequel::Firebird::DatasetMethods
+        org.firebirdsql.jdbc.FBDriver
+      end
+    end
+
     # Database and Dataset instance methods for Firebird specific
     # support via JDBC.
     module Firebird

data/lib/sequel/adapters/jdbc/h2.rb

@@ -1,5 +1,15 @@
+Sequel::JDBC.load_driver('org.h2.Driver', :H2)
+
 module Sequel
   module JDBC
+    Sequel.synchronize do
+      DATABASE_SETUP[:h2] = proc do |db|
+        db.extend(Sequel::JDBC::H2::DatabaseMethods)
+        db.dataset_class = Sequel::JDBC::H2::Dataset
+        org.h2.Driver
+      end
+    end
+
     # Database and Dataset support for H2 databases accessed via JDBC.
     module H2
       # Instance methods for H2 Database objects accessed via JDBC.

data/lib/sequel/adapters/jdbc/hsqldb.rb

@@ -1,7 +1,16 @@
+Sequel::JDBC.load_driver('org.hsqldb.jdbcDriver', :HSQLDB)
 Sequel.require 'adapters/jdbc/transactions'
 
 module Sequel
   module JDBC
+    Sequel.synchronize do
+      DATABASE_SETUP[:hsqldb] = proc do |db|
+        db.extend(Sequel::JDBC::HSQLDB::DatabaseMethods)
+        db.dataset_class = Sequel::JDBC::HSQLDB::Dataset
+        org.hsqldb.jdbcDriver
+      end
+    end
+
     # Database and Dataset support for HSQLDB databases accessed via JDBC.
     module HSQLDB
       # Instance methods for HSQLDB Database objects accessed via JDBC.

data/lib/sequel/adapters/jdbc/{informix.rb → informix-sqli.rb}

@@ -1,7 +1,16 @@
+Sequel::JDBC.load_driver('com.informix.jdbc.IfxDriver')
 Sequel.require 'adapters/shared/informix'
 
 module Sequel
   module JDBC
+    Sequel.synchronize do
+      DATABASE_SETUP[:"informix-sqli"] = proc do |db|
+        db.extend(Sequel::JDBC::Informix::DatabaseMethods)
+        db.extend_datasets Sequel::Informix::DatasetMethods
+        com.informix.jdbc.IfxDriver
+      end
+    end
+
     # Database and Dataset instance methods for Informix specific
     # support via JDBC.
     module Informix

data/lib/sequel/adapters/jdbc/{progress.rb → jdbcprogress.rb}

@@ -1,8 +1,17 @@
+Sequel::JDBC.load_driver('com.progress.sql.jdbc.JdbcProgressDriver')
 Sequel.require 'adapters/shared/progress'
 Sequel.require 'adapters/jdbc/transactions'
 
 module Sequel
   module JDBC
+    Sequel.synchronize do
+      DATABASE_SETUP[:jdbcprogress] = proc do |db|
+        db.extend(Sequel::JDBC::Progress::DatabaseMethods)
+        db.extend_datasets Sequel::Progress::DatasetMethods
+        com.progress.sql.jdbc.JdbcProgressDriver
+      end
+    end
+
     # Database and Dataset instance methods for Progress v9 specific
     # support via JDBC.
     module Progress

data/lib/sequel/adapters/jdbc/jtds.rb

@@ -1,7 +1,17 @@
+Sequel::JDBC.load_driver('Java::net.sourceforge.jtds.jdbc.Driver', :JTDS)
 Sequel.require 'adapters/jdbc/mssql'
 
 module Sequel
   module JDBC
+    Sequel.synchronize do
+      DATABASE_SETUP[:jtds] = proc do |db|
+        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
+    end
+
     # Database and Dataset instance methods for JTDS specific
     # support via JDBC.
     module JTDS

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

@@ -1,7 +1,16 @@
+Sequel::JDBC.load_driver('com.mysql.jdbc.Driver', :MySQL)
 Sequel.require 'adapters/shared/mysql'
 
 module Sequel
   module JDBC
+    Sequel.synchronize do
+      DATABASE_SETUP[:mysql] = proc do |db|
+        db.extend(Sequel::JDBC::MySQL::DatabaseMethods)
+        db.extend_datasets Sequel::MySQL::DatasetMethods
+        com.mysql.jdbc.Driver
+      end
+    end
+
     # Database and Dataset instance methods for MySQL specific
     # support via JDBC.
     module MySQL
@@ -26,6 +35,11 @@ module Sequel
           false
         end
 
+        # Raise a disconnect error if the SQL state of the cause of the exception indicates so.
+        def disconnect_error?(exception, opts)
+          exception.message =~ /\ACommunications link failure/ || super
+        end
+
         # Get the last inserted id using LAST_INSERT_ID().
         def last_insert_id(conn, opts=OPTS)
           if stmt = opts[:stmt]

data/lib/sequel/adapters/jdbc/oracle.rb

@@ -1,8 +1,17 @@
+Sequel::JDBC.load_driver('Java::oracle.jdbc.driver.OracleDriver')
 Sequel.require 'adapters/shared/oracle'
 Sequel.require 'adapters/jdbc/transactions'
 
 module Sequel
   module JDBC
+    Sequel.synchronize do
+      DATABASE_SETUP[:oracle] = proc do |db|
+        db.extend(Sequel::JDBC::Oracle::DatabaseMethods)
+        db.dataset_class = Sequel::JDBC::Oracle::Dataset
+        Java::oracle.jdbc.driver.OracleDriver
+      end
+    end
+
     class TypeConvertor
       JAVA_BIG_DECIMAL_CONSTRUCTOR = java.math.BigDecimal.java_class.constructor(Java::long).method(:new_instance)
 

data/lib/sequel/adapters/jdbc/postgresql.rb

@@ -1,9 +1,18 @@
+Sequel::JDBC.load_driver('org.postgresql.Driver', :Postgres)
 Sequel.require 'adapters/shared/postgres'
 
 module Sequel
   Postgres::CONVERTED_EXCEPTIONS << NativeException
   
   module JDBC
+    Sequel.synchronize do
+      DATABASE_SETUP[:postgresql] = proc do |db|
+        db.extend(Sequel::JDBC::Postgres::DatabaseMethods)
+        db.dataset_class = Sequel::JDBC::Postgres::Dataset
+        org.postgresql.Driver
+      end
+    end
+
     class TypeConvertor
       # Return PostgreSQL array types as ruby Arrays instead of
       # JDBC PostgreSQL driver-specific array type. Only used if the

data/lib/sequel/adapters/jdbc/sqlanywhere.rb

@@ -3,6 +3,29 @@ Sequel.require 'adapters/jdbc/transactions'
 
 module Sequel
   module JDBC
+    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
+    raise(Sequel::AdapterNotFound, "no suitable SQLAnywhere JDBC driver found") unless drv
+
+    Sequel.synchronize do
+      DATABASE_SETUP[:sqlanywhere] = proc do |db|
+        db.extend(Sequel::JDBC::SqlAnywhere::DatabaseMethods)
+        db.dataset_class = Sequel::JDBC::SqlAnywhere::Dataset
+        drv
+      end
+    end
+
     class TypeConvertor
       def SqlAnywhereBoolean(r, i)
         if v = Short(r, i)

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

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

data/lib/sequel/adapters/jdbc/sqlserver.rb

@@ -1,7 +1,17 @@
+Sequel::JDBC.load_driver('com.microsoft.sqlserver.jdbc.SQLServerDriver')
 Sequel.require 'adapters/jdbc/mssql'
 
 module Sequel
   module JDBC
+    Sequel.synchronize do
+      DATABASE_SETUP[:sqlserver] = proc do |db|
+        db.extend(Sequel::JDBC::SQLServer::DatabaseMethods)
+        db.extend_datasets Sequel::MSSQL::DatasetMethods
+        db.send(:set_mssql_unicode_strings)
+        com.microsoft.sqlserver.jdbc.SQLServerDriver
+      end
+    end
+
     # Database and Dataset instance methods for SQLServer specific
     # support via JDBC.
     module SQLServer

data/lib/sequel/adapters/odbc.rb

@@ -2,6 +2,10 @@ require 'odbc'
 
 module Sequel
   module ODBC
+    # Contains procs keyed on subadapter type that extend the
+    # given database object so it supports the correct database type.
+    DATABASE_SETUP = {}
+      
     class Database < Sequel::Database
       set_adapter_scheme :odbc
 
@@ -61,20 +65,8 @@ module Sequel
       private
       
       def adapter_initialize
-        case @opts[:db_type]
-        when 'mssql'
-          Sequel.require 'adapters/odbc/mssql'
-          extend Sequel::ODBC::MSSQL::DatabaseMethods
-          self.dataset_class = Sequel::ODBC::MSSQL::Dataset
-          set_mssql_unicode_strings
-        when 'progress'
-          Sequel.require 'adapters/shared/progress'
-          extend Sequel::Progress::DatabaseMethods
-          extend_datasets(Sequel::Progress::DatasetMethods)
-        when 'db2'
-          Sequel.require 'adapters/shared/db2'
-          extend ::Sequel::DB2::DatabaseMethods
-          extend_datasets ::Sequel::DB2::DatasetMethods
+        if (db_type = @opts[:db_type]) && (prok = Sequel::Database.load_adapter(db_type.to_sym, :map=>DATABASE_SETUP, :subdir=>'odbc'))
+          prok.call(self)
         end
       end
 

data/lib/sequel/adapters/odbc/db2.rb

@@ -0,0 +1,9 @@
+Sequel.require 'adapters/shared/db2'
+
+Sequel.synchronize do
+  Sequel::ODBC::DATABASE_SETUP[:db2] = proc do |db|
+    db.extend ::Sequel::DB2::DatabaseMethods
+    db.extend_datasets ::Sequel::DB2::DatasetMethods
+  end
+end
+

data/lib/sequel/adapters/odbc/mssql.rb

@@ -2,6 +2,14 @@ Sequel.require 'adapters/shared/mssql'
 
 module Sequel
   module ODBC
+    Sequel.synchronize do
+      DATABASE_SETUP[:mssql] = proc do |db|
+        db.extend Sequel::ODBC::MSSQL::DatabaseMethods
+        db.dataset_class = Sequel::ODBC::MSSQL::Dataset
+        db.send(:set_mssql_unicode_strings)
+      end
+    end
+
     # Database and Dataset instance methods for MSSQL specific
     # support via ODBC.
     module MSSQL

data/lib/sequel/adapters/odbc/progress.rb

@@ -0,0 +1,8 @@
+Sequel.require 'adapters/shared/progress'
+
+Sequel.synchronize do
+  Sequel::ODBC::DATABASE_SETUP[:progress] = proc do |db|
+    db.extend Sequel::Progress::DatabaseMethods
+    db.extend_datasets(Sequel::Progress::DatasetMethods)
+  end
+end

data/lib/sequel/adapters/oracle.rb

@@ -273,7 +273,7 @@ module Sequel
 
         # Default values
         defaults = begin
-          metadata_dataset.from(:user_tab_cols).
+          metadata_dataset.from(:all_tab_cols).
             where(:table_name=>im.call(table)).
             to_hash(:column_name, :data_default)
         rescue DatabaseError

data/lib/sequel/adapters/postgres.rb

@@ -108,7 +108,7 @@ module Sequel
     # PGconn subclass for connection specific methods used with the
     # pg, postgres, or postgres-pr driver.
     class Adapter < ::PGconn
-      DISCONNECT_ERROR_RE = /\A(?:could not receive data from server|no connection to the server|connection not open)/
+      DISCONNECT_ERROR_RE = /\A(?:could not receive data from server|no connection to the server|connection not open|terminating connection due to administrator command)/
       
       self.translate_results = false if respond_to?(:translate_results=)
       

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

@@ -175,7 +175,14 @@ module Sequel
 
       # Insert a record returning the record inserted
       def insert_select(*values)
-        returning.insert(*values){|r| return r}
+        with_sql_first(insert_select_sql(*values))
+      end
+
+      # The SQL to use for an insert_select, adds a RETURNING clause to the insert
+      # unless the RETURNING clause is already present.
+      def insert_select_sql(*values)
+        ds = opts[:returning] ? self : returning
+        ds.insert_sql(*values)
       end
 
       def requires_sql_standard_datetimes?

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

@@ -525,7 +525,6 @@ module Sequel
       DATEPART_SECOND_MIDDLE = ') + datepart(ns, '.freeze
       DATEPART_SECOND_CLOSE = ")/1000000000.0) AS double precision)".freeze
       DATEPART_OPEN = "datepart(".freeze
-      TIMESTAMP_USEC_FORMAT = ".%03d".freeze
       OUTPUT_INSERTED = " OUTPUT INSERTED.*".freeze
       HEX_START = '0x'.freeze
       UNICODE_STRING_START = "N'".freeze
@@ -624,7 +623,14 @@ module Sequel
       # Use the OUTPUT clause to get the value of all columns for the newly inserted record.
       def insert_select(*values)
         return unless supports_insert_select?
-        naked.clone(default_server_opts(:sql=>output(nil, [SQL::ColumnAll.new(:inserted)]).insert_sql(*values))).single_record
+        with_sql_first(insert_select_sql(*values))
+      end
+
+      # Add OUTPUT clause unless there is already an existing output clause, then return
+      # the SQL to insert.
+      def insert_select_sql(*values)
+        ds = (opts[:output] || opts[:returning]) ? self : output(nil, [SQL::ColumnAll.new(:inserted)])
+        ds.insert_sql(*values)
       end
 
       # Specify a table for a SELECT ... INTO query.
@@ -658,20 +664,31 @@ module Sequel
         raise(Error, "SQL Server versions 2000 and earlier do not support the OUTPUT clause") unless supports_output_clause?
         output = {}
         case values
-          when Hash
-            output[:column_list], output[:select_list] = values.keys, values.values
-          when Array
-            output[:select_list] = values
+        when Hash
+          output[:column_list], output[:select_list] = values.keys, values.values
+        when Array
+          output[:select_list] = values
         end
         output[:into] = into
-        clone({:output => output})
+        clone(:output => output)
       end
 
       # MSSQL uses [] to quote identifiers.
       def quoted_identifier_append(sql, name)
         sql << BRACKET_OPEN << name.to_s.gsub(/\]/, DOUBLE_BRACKET_CLOSE) << BRACKET_CLOSE
       end
-      
+
+      # Emulate RETURNING using the output clause.  This only handles values that are simple column references.
+      def returning(*values)
+        values = values.map do |v|
+          unless r = unqualified_column_for(v)
+            raise(Error, "cannot emulate RETURNING via OUTPUT for value: #{v.inspect}")
+          end
+          r
+        end
+        clone(:returning=>values)
+      end
+
       # On MSSQL 2012+ add a default order to the current dataset if an offset is used.
       # The default offset emulation using a subquery would be used in the unordered
       # case by default, and that also adds a default order, so it's better to just
@@ -738,11 +755,16 @@ module Sequel
         is_2012_or_later?
       end
 
-      # MSSQL 2005+ supports the output clause.
+      # MSSQL 2005+ supports the OUTPUT clause.
       def supports_output_clause?
         is_2005_or_later?
       end
 
+      # MSSQL 2005+ can emulate RETURNING via the OUTPUT clause.
+      def supports_returning?(type)
+        supports_insert_select?
+      end
+
       # MSSQL 2005+ supports window functions
       def supports_window_functions?
         true
@@ -816,6 +838,10 @@ module Sequel
       end
       alias update_from_sql delete_from2_sql
 
+      def delete_output_sql(sql)
+        output_sql(sql, :DELETED)
+      end
+
       # There is no function on Microsoft SQL Server that does character length
       # and respects trailing spaces (datalength respects trailing spaces, but
       # counts bytes instead of characters).  Use a hack to work around the
@@ -844,22 +870,10 @@ module Sequel
         @db.schema(self).map{|k, v| k if v[:primary_key] == true}.compact.first
       end
 
-      # MSSQL raises an error if you try to provide more than 3 decimal places
-      # for a fractional timestamp.  This probably doesn't work for smalldatetime
-      # fields.
-      def format_timestamp_usec(usec)
-        sprintf(TIMESTAMP_USEC_FORMAT, usec/1000)
-      end
-
-      # Use OUTPUT INSERTED.* to return all columns of the inserted row,
-      # for use with the prepared statement code.
       def insert_output_sql(sql)
-        if @opts.has_key?(:returning)
-          sql << OUTPUT_INSERTED
-        else
-          output_sql(sql)
-        end
+        output_sql(sql, :INSERTED)
       end
+      alias update_output_sql insert_output_sql
 
       # Handle CROSS APPLY and OUTER APPLY JOIN types
       def join_type_sql(join_type)
@@ -964,9 +978,16 @@ module Sequel
       end
 
       # SQL fragment for MSSQL's OUTPUT clause.
-      def output_sql(sql)
+      def output_sql(sql, type)
         return unless supports_output_clause?
-        return unless output = @opts[:output]
+        if output = @opts[:output]
+          output_list_sql(sql, output)
+        elsif values = @opts[:returning]
+          output_returning_sql(sql, type, values)
+        end
+      end
+
+      def output_list_sql(sql, output)
         sql << OUTPUT
         column_list_append(sql, output[:select_list])
         if into = output[:into]
@@ -979,8 +1000,28 @@ module Sequel
           end
         end
       end
-      alias delete_output_sql output_sql
-      alias update_output_sql output_sql
+
+      def output_returning_sql(sql, type, values)
+        sql << OUTPUT
+        if values.empty?
+          literal_append(sql, SQL::ColumnAll.new(type))
+        else
+          values = values.map do |v|
+            case v
+            when SQL::AliasedExpression
+              Sequel.qualify(type, v.expression).as(v.alias)
+            else
+              Sequel.qualify(type, v)
+            end
+          end
+          column_list_append(sql, values)
+        end
+      end
+
+      # MSSQL supports millisecond timestamp precision.
+      def timestamp_precision
+        3
+      end
 
       # Only include the primary table in the main update clause
       def update_table_sql(sql)