sequel 3.21.0 → 3.29.0

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

@@ -1,4 +1,5 @@
 Sequel.require 'adapters/shared/oracle'
+Sequel.require 'adapters/jdbc/transactions'
 
 module Sequel
   module JDBC
@@ -7,43 +8,84 @@ module Sequel
       # Instance methods for Oracle Database objects accessed via JDBC.
       module DatabaseMethods
         include Sequel::Oracle::DatabaseMethods
-        TRANSACTION_BEGIN = 'Transaction.begin'.freeze
-        TRANSACTION_COMMIT = 'Transaction.commit'.freeze
-        TRANSACTION_ROLLBACK = 'Transaction.rollback'.freeze
-        
-        # Return Sequel::JDBC::Oracle::Dataset object with the given opts.
-        def dataset(opts=nil)
-          Sequel::JDBC::Oracle::Dataset.new(self, opts)
+        include Sequel::JDBC::Transactions
+
+        def self.extended(db)
+          db.instance_eval do
+            @autosequence = opts[:autosequence]
+            @primary_key_sequences = {}
+          end
         end
         
         private
-        
-        # Use JDBC connection's setAutoCommit to false to start transactions
-        def begin_transaction(conn, opts={})
-          log_yield(TRANSACTION_BEGIN){conn.setAutoCommit(false)}
-          conn
+
+        def last_insert_id(conn, opts)
+          unless sequence = opts[:sequence]
+            if t = opts[:table]
+              sequence = sequence_for_table(t)
+            end
+          end
+          if sequence
+            sql = "SELECT #{literal(sequence)}.currval FROM dual"
+            statement(conn) do |stmt|
+              begin
+                rs = log_yield(sql){stmt.executeQuery(sql)}
+                rs.next
+                rs.getInt(1)
+              rescue java.sql.SQLException
+                nil
+              end
+            end
+          end
         end
-        
-        # Use JDBC connection's commit method to commit transactions
-        def commit_transaction(conn, opts={})
-          log_yield(TRANSACTION_COMMIT){conn.commit}
+
+        def schema_parse_table(*)
+          sch = super
+          sch.each do |c, s|
+            if s[:type] == :decimal && s[:scale] == -127
+              s[:type] = :integer
+            elsif s[:db_type] == 'DATE'
+              s[:type] = :datetime
+            end
+          end
+          sch
         end
-        
-        # Use JDBC connection's setAutoCommit to true to enable non-transactional behavior
-        def remove_transaction(conn)
-          conn.setAutoCommit(true) if conn
-          @transactions.delete(Thread.current)
+
+        def schema_parse_table_skip?(h, schema)
+          super || (h[:table_schem] != current_user unless schema)
         end
-        
-        # Use JDBC connection's rollback method to rollback transactions
-        def rollback_transaction(conn, opts={})
-          log_yield(TRANSACTION_ROLLBACK){conn.rollback}
+
+        # As of Oracle 9.2, releasing savepoints is no longer supported.
+        def supports_releasing_savepoints?
+          false
         end
       end
       
       # Dataset class for Oracle datasets accessed via JDBC.
       class Dataset < JDBC::Dataset
         include Sequel::Oracle::DatasetMethods
+
+        private
+
+        def convert_type(v)
+          case v
+          when Java::JavaMath::BigDecimal
+            if v.scale == 0
+              i = v.long_value
+              if v.equals(Java::JavaMath::BigDecimal.new(i))
+                i
+              else
+                super
+              end
+            else
+              super
+            end
+          when Java::OracleSql::TIMESTAMP
+            db.to_application_timestamp(v.to_string)
+          else
+            super
+          end
+        end
       end
     end
   end

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

@@ -47,19 +47,14 @@ module Sequel
           end
         end
         
-        # Return instance of Sequel::JDBC::Postgres::Dataset with the given opts.
-        def dataset(opts=nil)
-          Sequel::JDBC::Postgres::Dataset.new(self, opts)
-        end
-        
-        # Run the INSERT sql on the database and return the primary key
-        # for the record.
-        def execute_insert(sql, opts={})
-          super(sql, {:type=>:insert}.merge(opts))
-        end
-        
         private
         
+        # Use setNull for nil arguments as the default behavior of setString
+        # with nil doesn't appear to work correctly on PostgreSQL.
+        def set_ps_arg(cps, arg, i)
+          arg.nil? ? cps.setNull(i, JavaSQL::Types::NULL) : super
+        end
+
         # Extend the adapter with the JDBC PostgreSQL AdapterMethods
         def setup_connection(conn)
           conn = super(conn)

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

@@ -8,11 +8,6 @@ module Sequel
       module DatabaseMethods
         include Sequel::SQLite::DatabaseMethods
         
-        # Return Sequel::JDBC::SQLite::Dataset object with the given opts.
-        def dataset(opts=nil)
-          Sequel::JDBC::SQLite::Dataset.new(self, opts)
-        end
-        
         private
         
         # Use last_insert_rowid() to get the last inserted id.

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

@@ -0,0 +1,41 @@
+Sequel.require 'adapters/jdbc/mssql'
+
+module Sequel
+  module JDBC
+    # Database and Dataset instance methods for SQLServer specific
+    # support via JDBC.
+    module SQLServer
+      # Database instance methods for SQLServer databases accessed via JDBC.
+      module DatabaseMethods
+        include Sequel::JDBC::MSSQL::DatabaseMethods
+        
+        def metadata_dataset
+          ds = super
+          # Work around a bug in SQL Server JDBC Driver 3.0, where the metadata
+          # for the getColumns result set specifies an incorrect type for the
+          # IS_AUTOINCREMENT column. The column is a string, but the type is
+          # specified as a short. This causes getObject() to throw a
+          # com.microsoft.sqlserver.jdbc.SQLServerException: "The conversion
+          # from char to SMALLINT is unsupported." Using getString() rather
+          # than getObject() for this column avoids the problem.
+          # Reference: http://social.msdn.microsoft.com/Forums/en/sqldataaccess/thread/20df12f3-d1bf-4526-9daa-239a83a8e435
+          def ds.result_set_object_getter
+            lambda do |result, n, i|
+              if n == :is_autoincrement
+                @convert_types ? convert_type(result.getString(i)) : result.getString(i)
+              else
+                @convert_types ? convert_type(result.getObject(i)) : result.getObject(i)
+              end
+            end
+          end
+          ds
+        end
+      end
+      
+      # Dataset class for SQLServer datasets accessed via JDBC.
+      class Dataset < JDBC::Dataset
+        include Sequel::MSSQL::DatasetMethods
+      end
+    end
+  end
+end

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

@@ -0,0 +1,83 @@
+module Sequel
+  module JDBC
+    module Transactions
+      TRANSACTION_BEGIN = 'Transaction.begin'.freeze
+      TRANSACTION_COMMIT = 'Transaction.commit'.freeze
+      TRANSACTION_RELEASE_SP = 'Transaction.release_savepoint'.freeze
+      TRANSACTION_ROLLBACK = 'Transaction.rollback'.freeze
+      TRANSACTION_ROLLBACK_SP = 'Transaction.rollback_savepoint'.freeze
+      TRANSACTION_SAVEPOINT= 'Transaction.savepoint'.freeze
+
+      # Check the JDBC DatabaseMetaData for savepoint support
+      def supports_savepoints?
+        return @supports_savepoints if defined?(@supports_savepoints)
+        @supports_savepoints = synchronize{|c| c.get_meta_data.supports_savepoints}
+      end
+
+      private
+
+      # Most JDBC drivers that support savepoints support releasing them.
+      def supports_releasing_savepoints?
+        true
+      end
+
+      # Use JDBC connection's setAutoCommit to false to start transactions
+      def begin_transaction(conn, opts={})
+        if supports_savepoints?
+          th = @transactions[conn]
+          if sps = th[:savepoints]
+            sps << log_yield(TRANSACTION_SAVEPOINT){conn.set_savepoint}
+          else
+            log_yield(TRANSACTION_BEGIN){conn.setAutoCommit(false)}
+            th[:savepoints] = []
+          end
+          th[:savepoint_level] += 1
+        else
+          log_yield(TRANSACTION_BEGIN){conn.setAutoCommit(false)}
+        end
+      end
+      
+      # Use JDBC connection's commit method to commit transactions
+      def commit_transaction(conn, opts={})
+        if supports_savepoints?
+          sps = @transactions[conn][:savepoints]
+          if sps.empty?
+            log_yield(TRANSACTION_COMMIT){conn.commit}
+          elsif supports_releasing_savepoints?
+            log_yield(TRANSACTION_RELEASE_SP){supports_releasing_savepoints? ? conn.release_savepoint(sps.last) : sps.last}
+          end
+        else
+          log_yield(TRANSACTION_COMMIT){conn.commit}
+        end
+      end
+      
+      # Use JDBC connection's setAutoCommit to true to enable non-transactional behavior
+      def remove_transaction(conn, committed)
+        if supports_savepoints?
+          sps = @transactions[conn][:savepoints]
+          conn.setAutoCommit(true) if sps.empty?
+          sps.pop
+        else
+          conn.setAutoCommit(true)
+        end
+      ensure
+        super
+      end
+      
+      # Use JDBC connection's rollback method to rollback transactions
+      def rollback_transaction(conn, opts={})
+        if supports_savepoints?
+          sps = @transactions[conn][:savepoints]
+          if sps.empty?
+            log_yield(TRANSACTION_ROLLBACK){conn.rollback}
+          else
+            log_yield(TRANSACTION_ROLLBACK_SP){conn.rollback(sps.last)}
+          end
+        else
+          log_yield(TRANSACTION_ROLLBACK){conn.rollback}
+        end
+      end
+    end
+  end
+end
+

data/lib/sequel/adapters/jdbc.rb

@@ -32,47 +32,89 @@ module Sequel
     DATABASE_SETUP = {:postgresql=>proc do |db|
         Sequel.ts_require 'adapters/jdbc/postgresql'
         db.extend(Sequel::JDBC::Postgres::DatabaseMethods)
+        db.dataset_class = Sequel::JDBC::Postgres::Dataset
         JDBC.load_gem('postgres')
         org.postgresql.Driver
       end,
       :mysql=>proc do |db|
         Sequel.ts_require 'adapters/jdbc/mysql'
         db.extend(Sequel::JDBC::MySQL::DatabaseMethods)
+        db.dataset_class = Sequel::JDBC::MySQL::Dataset
         JDBC.load_gem('mysql')
         com.mysql.jdbc.Driver
       end,
       :sqlite=>proc do |db|
         Sequel.ts_require 'adapters/jdbc/sqlite'
         db.extend(Sequel::JDBC::SQLite::DatabaseMethods)
+        db.dataset_class = Sequel::JDBC::SQLite::Dataset
         JDBC.load_gem('sqlite3')
         org.sqlite.JDBC
       end,
       :oracle=>proc do |db|
         Sequel.ts_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|
-        Sequel.ts_require 'adapters/jdbc/mssql'
-        db.extend(Sequel::JDBC::MSSQL::DatabaseMethods)
+        Sequel.ts_require 'adapters/jdbc/sqlserver'
+        db.extend(Sequel::JDBC::SQLServer::DatabaseMethods)
+        db.dataset_class = Sequel::JDBC::SQLServer::Dataset
+        db.send(:set_mssql_unicode_strings)
         com.microsoft.sqlserver.jdbc.SQLServerDriver
       end,
       :jtds=>proc do |db|
-        Sequel.ts_require 'adapters/jdbc/mssql'
-        db.extend(Sequel::JDBC::MSSQL::DatabaseMethods)
+        Sequel.ts_require 'adapters/jdbc/jtds'
+        db.extend(Sequel::JDBC::JTDS::DatabaseMethods)
+        db.dataset_class = Sequel::JDBC::JTDS::Dataset
+        db.send(:set_mssql_unicode_strings)
         JDBC.load_gem('jtds')
         Java::net.sourceforge.jtds.jdbc.Driver
       end,
       :h2=>proc do |db|
         Sequel.ts_require 'adapters/jdbc/h2'
         db.extend(Sequel::JDBC::H2::DatabaseMethods)
+        db.dataset_class = Sequel::JDBC::H2::Dataset
         JDBC.load_gem('h2')
         org.h2.Driver
       end,
+      :hsqldb=>proc do |db|
+        Sequel.ts_require 'adapters/jdbc/hsqldb'
+        db.extend(Sequel::JDBC::HSQLDB::DatabaseMethods)
+        db.dataset_class = Sequel::JDBC::HSQLDB::Dataset
+        # Current gem is 1.8.1.3, but Sequel supports 2.2.5
+        org.hsqldb.jdbcDriver
+      end,
+      :derby=>proc do |db|
+        Sequel.ts_require 'adapters/jdbc/derby'
+        db.extend(Sequel::JDBC::Derby::DatabaseMethods)
+        db.dataset_class = Sequel::JDBC::Derby::Dataset
+        JDBC.load_gem('derby')
+        org.apache.derby.jdbc.EmbeddedDriver
+      end,
       :as400=>proc do |db|
         Sequel.ts_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|
+        Sequel.ts_require 'adapters/jdbc/informix'
+        db.extend(Sequel::JDBC::Informix::DatabaseMethods)
+        db.dataset_class = Sequel::JDBC::Informix::Dataset
+        com.informix.jdbc.IfxDriver
+      end,
+      :db2=>proc do |db|
+        Sequel.ts_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|
+        Sequel.ts_require 'adapters/jdbc/firebird'
+        db.extend(Sequel::JDBC::Firebird::DatabaseMethods)
+        db.dataset_class = Sequel::JDBC::Firebird::Dataset
+        org.firebirdsql.jdbc.FBDriver
       end
     }
     
@@ -101,7 +143,7 @@ module Sequel
       # True by default, can be set to false to roughly double performance when
       # fetching rows.
       attr_accessor :convert_types
-      
+
       # Call the DATABASE_SETUP proc directly after initialization,
       # so the object always uses sub adapter specific code.  Also,
       # raise an error immediately if the connection doesn't have a
@@ -180,11 +222,6 @@ module Sequel
         setup_connection(conn)
       end
       
-      # Return instances of JDBC::Dataset with the given opts.
-      def dataset(opts = nil)
-        JDBC::Dataset.new(self, opts)
-      end
-      
       # Execute the given SQL.  If a block is given, if should be a SELECT
       # statement or something else that returns rows.
       def execute(sql, opts={}, &block)
@@ -246,12 +283,14 @@ module Sequel
         indexes
       end 
 
+      # Whether or not JNDI is being used for this connection.
+      def jndi?
+        !!(uri =~ JNDI_URI_REGEXP)
+      end
+      
       # All tables in this database
       def tables(opts={})
-        ts = []
-        m = output_identifier_meth
-        metadata(:getTables, nil, nil, nil, ['TABLE'].to_java(:string)){|h| ts << m.call(h[:table_name])}
-        ts
+        get_tables('TABLE', opts)
       end
       
       # The uri for this connection.  You can specify the uri
@@ -264,11 +303,11 @@ module Sequel
         ur =~ /^\Ajdbc:/ ? ur : "jdbc:#{ur}"
       end
 
-      # Whether or not JNDI is being used for this connection.
-      def jndi?
-        !!(uri =~ JNDI_URI_REGEXP)
+      # All views in this database
+      def views(opts={})
+        get_tables('VIEW', opts)
       end
-      
+
       private
          
       # Close given adapter connections
@@ -276,6 +315,12 @@ module Sequel
         c.close
       end
       
+      # Raise a disconnect error if the SQL state of the cause of the exception indicates so.
+      def disconnect_error?(exception, opts)
+        cause = exception.respond_to?(:cause) ? exception.cause : exception
+        super || (cause.respond_to?(:getSQLState) && cause.getSQLState =~ /^08/)
+      end
+
       # Execute the prepared statement.  If the provided name is a
       # dataset, use that as the prepared statement, otherwise use
       # it as a key to look it up in the prepared_statements hash.
@@ -325,6 +370,12 @@ module Sequel
         end
       end
 
+      # Gets the connection from JNDI.
+      def get_connection_from_jndi
+        jndi_name = JNDI_URI_REGEXP.match(uri)[1]
+        JavaxNaming::InitialContext.new.lookup(jndi_name).connection
+      end
+            
       # Gets the JDBC connection uri from the JNDI resource.
       def get_uri_from_jndi
         conn = get_connection_from_jndi
@@ -333,12 +384,14 @@ module Sequel
         conn.close if conn
       end
       
-      # Gets the connection from JNDI.
-      def get_connection_from_jndi
-        jndi_name = JNDI_URI_REGEXP.match(uri)[1]
-        JavaxNaming::InitialContext.new.lookup(jndi_name).connection
+      # Backbone of the tables and views support.
+      def get_tables(type, opts)
+        ts = []
+        m = output_identifier_meth
+        metadata(:getTables, nil, nil, nil, [type].to_java(:string)){|h| ts << m.call(h[:table_name])}
+        ts
       end
-            
+
       # Support Date objects used in bound variables
       def java_sql_date(date)
         java.sql.Date.new(Time.local(date.year, date.month, date.day).to_i * 1000)
@@ -383,12 +436,6 @@ module Sequel
         end
       end
 
-      # Treat SQLExceptions with a "Connection Error" SQLState as disconnects
-      def raise_error(exception, opts={})
-        cause = exception.respond_to?(:cause) ? exception.cause : exception
-        super(exception, {:disconnect => cause.respond_to?(:getSQLState) && cause.getSQLState =~ /^08/}.merge(opts))
-      end
-
       # Java being java, you need to specify the type of each argument
       # for the prepared statement, and bind it individually.  This
       # guesses which JDBC method to use, and hopefully JRuby will convert
@@ -405,8 +452,8 @@ module Sequel
           cps.setDouble(i, arg)
         when TrueClass, FalseClass
           cps.setBoolean(i, arg)
-        when nil
-          cps.setNull(i, JavaSQL::Types::NULL)
+        when NilClass
+          cps.setString(i, nil)
         when DateTime
           cps.setTimestamp(i, java_sql_datetime(arg))
         when Date
@@ -435,8 +482,8 @@ module Sequel
       
       # Parse the table schema for the given table.
       def schema_parse_table(table, opts={})
-        m = output_identifier_meth
-        im = input_identifier_meth
+        m = output_identifier_meth(opts[:dataset])
+        im = input_identifier_meth(opts[:dataset])
         ds = dataset
         schema, table = schema_and_table(table)
         schema ||= opts[:schema]
@@ -444,9 +491,11 @@ module Sequel
         table = im.call(table)
         pks, ts = [], []
         metadata(:getPrimaryKeys, nil, schema, table) do |h|
+          next if schema_parse_table_skip?(h, schema)
           pks << h[:column_name]
         end
         metadata(:getColumns, nil, schema, table, nil) do |h|
+          next if schema_parse_table_skip?(h, schema)
           s = {:type=>schema_column_type(h[:type_name]), :db_type=>h[:type_name], :default=>(h[:column_def] == '' ? nil : h[:column_def]), :allow_null=>(h[:nullable] != 0), :primary_key=>pks.include?(h[:column_name]), :column_size=>h[:column_size], :scale=>h[:decimal_digits]}
           if s[:db_type] =~ DECIMAL_TYPE_RE && s[:scale] == 0
             s[:type] = :integer
@@ -456,6 +505,12 @@ module Sequel
         ts
       end
       
+      # Whether schema_parse_table should skip the given row when
+      # parsing the schema.
+      def schema_parse_table_skip?(h, schema)
+        h[:table_schem] == 'INFORMATION_SCHEMA'
+      end
+
       # Yield a new statement object, and ensure that it is closed before returning.
       def statement(conn)
         stmt = conn.createStatement
@@ -476,6 +531,8 @@ module Sequel
     
     class Dataset < Sequel::Dataset
       include StoredProcedures
+
+      Database::DatasetClass = self
       
       # Use JDBC PreparedStatements instead of emulated ones.  Statements
       # created using #prepare are cached at the connection level to allow
@@ -530,8 +587,8 @@ module Sequel
       # Uses the database's setting by default, can be set to false to roughly
       # double performance when fetching rows.
       attr_accessor :convert_types
-      
-      # Use the convert_types default setting from the database
+
+      # Use the convert_types default setting from the database.
       def initialize(db, opts={})
         @convert_types = db.convert_types
         super
@@ -560,8 +617,10 @@ module Sequel
       # Convert the type.  Used for converting Java types to ruby types.
       def convert_type(v)
         case v
-        when Java::JavaSQL::Timestamp, Java::JavaSQL::Time
-          Sequel.database_to_application_timestamp(v.to_string)
+        when Java::JavaSQL::Timestamp
+          db.to_application_timestamp(v.to_string)
+        when Java::JavaSQL::Time
+          Sequel.string_to_time(v.to_string)
         when Java::JavaSQL::Date
           Sequel.string_to_date(v.to_string)
         when Java::JavaIo::BufferedReader
@@ -574,6 +633,8 @@ module Sequel
           Sequel::SQL::Blob.new(String.from_java_bytes(v))
         when Java::JavaSQL::Blob
           convert_type(v.getBytes(1, v.length))
+        when Java::JavaSQL::Clob
+          Sequel::SQL::Blob.new(v.getSubString(1, v.length))
         else
           v
         end
@@ -592,7 +653,12 @@ module Sequel
         cols = []
         i = 0
         meta.getColumnCount.times{cols << [output_identifier(meta.getColumnLabel(i+=1)), i]}
-        @columns = cols.map{|c| c.at(0)}
+        columns = cols.map{|c| c.at(0)}
+        if opts[:offset] && offset_returns_row_number_column?
+          rn = row_number_column
+          columns.delete(rn)
+        end
+        @columns = columns
         blk = result_set_object_getter
         # get rows
         while result.next
@@ -600,8 +666,11 @@ module Sequel
           cols.each do |n, i|
             row[n] = blk.call(result, n, i)
           end
+          row.delete(rn) if rn
           yield row
         end
+      ensure
+        result.close
       end
 
       # Proc that takes the ResultSet and an integer field number and returns