sequel 3.21.0 → 3.36.0

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

@@ -0,0 +1,29 @@
+Sequel.require 'adapters/jdbc/mssql'
+
+module Sequel
+  module JDBC
+    # Database and Dataset instance methods for JTDS specific
+    # support via JDBC.
+    module JTDS
+      # Dataset class for JTDS datasets accessed via JDBC.
+      class Dataset < JDBC::Dataset
+        include Sequel::MSSQL::DatasetMethods
+
+        class ::Sequel::JDBC::Dataset::TYPE_TRANSLATOR
+          def jtds_clob(v) Sequel::SQL::Blob.new(v.getSubString(1, v.length)) end
+        end
+
+        JTDS_CLOB_METHOD = TYPE_TRANSLATOR_INSTANCE.method(:jtds_clob)
+      
+        # Handle CLOB types retrieved via JTDS.
+        def convert_type_proc(v)
+          if v.is_a?(Java::NetSourceforgeJtdsJdbc::ClobImpl)
+            JTDS_CLOB_METHOD
+          else
+            super
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -13,20 +13,17 @@ module Sequel
       # Database instance methods for MSSQL databases accessed via JDBC.
       module DatabaseMethods
         PRIMARY_KEY_INDEX_RE = /\Apk__/i.freeze
+        ATAT_IDENTITY = 'SELECT @@IDENTITY'.freeze
+        SCOPE_IDENTITY = 'SELECT SCOPE_IDENTITY()'.freeze
         
         include Sequel::MSSQL::DatabaseMethods
         
-        # Return instance of Sequel::JDBC::MSSQL::Dataset with the given opts.
-        def dataset(opts=nil)
-          Sequel::JDBC::MSSQL::Dataset.new(self, opts)
-        end
-        
         private
         
         # Get the last inserted id using SCOPE_IDENTITY().
         def last_insert_id(conn, opts={})
           statement(conn) do |stmt|
-            sql = opts[:prepared] ? 'SELECT @@IDENTITY' : 'SELECT SCOPE_IDENTITY()'
+            sql = opts[:prepared] ? ATAT_IDENTITY : SCOPE_IDENTITY
             rs = log_yield(sql){stmt.executeQuery(sql)}
             rs.next
             rs.getInt(1)
@@ -43,33 +40,6 @@ module Sequel
         def primary_key_index_re
           PRIMARY_KEY_INDEX_RE
         end
-
-        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 MSSQL datasets accessed via JDBC.
-      class Dataset < JDBC::Dataset
-        include Sequel::MSSQL::DatasetMethods
       end
     end
   end

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

@@ -8,11 +8,7 @@ module Sequel
       # Database instance methods for MySQL databases accessed via JDBC.
       module DatabaseMethods
         include Sequel::MySQL::DatabaseMethods
-        
-        # Return instance of Sequel::JDBC::MySQL::Dataset with the given opts.
-        def dataset(opts=nil)
-          Sequel::JDBC::MySQL::Dataset.new(self, opts)
-        end
+        LAST_INSERT_ID = 'SELECT LAST_INSERT_ID()'.freeze
         
         private
         
@@ -39,7 +35,7 @@ module Sequel
             end
           else
             statement(conn) do |stmt|
-              rs = stmt.executeQuery('SELECT LAST_INSERT_ID()')
+              rs = stmt.executeQuery(LAST_INSERT_ID)
               rs.next
               rs.getInt(1)
             end
@@ -56,25 +52,12 @@ module Sequel
         def schema_column_type(db_type)
           db_type == 'tinyint(1)' ? :boolean : super
         end
-      end
       
-      # Dataset class for MySQL datasets accessed via JDBC.
-      class Dataset < JDBC::Dataset
-        include Sequel::MySQL::DatasetMethods
-        
-        # Use execute_insert to execute the insert_sql.
-        def insert(*values)
-          execute_insert(insert_sql(*values))
-        end
-        
-        # Use execute_insert to execute the replace_sql.
-        def replace(*args)
-          execute_insert(replace_sql(*args))
-        end
-        
-        # MySQL on JDBC does provides an accurate number of rows matched.
-        def provides_accurate_rows_matched?
-          true
+        # Run the default connection setting SQL statements.
+        # Apply the connectiong setting SQLs for every new connection.
+        def setup_connection(conn)
+          mysql_connection_setting_sqls.each{|sql| statement(conn){|s| log_yield(sql){s.execute(sql)}}}
+          super
         end
       end
     end

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
@@ -6,44 +7,106 @@ module Sequel
     module Oracle
       # Instance methods for Oracle Database objects accessed via JDBC.
       module DatabaseMethods
+        PRIMARY_KEY_INDEX_RE = /\Asys_/i.freeze
+
         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}
+
+        # Primary key indexes appear to start with sys_ on Oracle
+        def primary_key_index_re
+          PRIMARY_KEY_INDEX_RE
         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(*)
+          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 rollback method to rollback transactions
-        def rollback_transaction(conn, opts={})
-          log_yield(TRANSACTION_ROLLBACK){conn.rollback}
+
+        def schema_parse_table_skip?(h, schema)
+          super || (h[:table_schem] != current_user unless schema)
+        end
+
+        # 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
+
+        JAVA_BIG_DECIMAL = ::Sequel::JDBC::Dataset::JAVA_BIG_DECIMAL
+
+        class ::Sequel::JDBC::Dataset::TYPE_TRANSLATOR
+          def oracle_decimal(v)
+            if v.scale == 0
+              i = v.long_value
+              if v.equals(JAVA_BIG_DECIMAL.new(i))
+                i
+              else
+                decimal(v)
+              end
+            else
+              decimal(v)
+            end
+          end
+        end
+
+        ORACLE_DECIMAL_METHOD = TYPE_TRANSLATOR_INSTANCE.method(:oracle_decimal)
+
+        def convert_type_oracle_timestamp(v)
+          db.to_application_timestamp(v.to_string)
+        end
+      
+        def convert_type_proc(v)
+          case v
+          when JAVA_BIG_DECIMAL
+            ORACLE_DECIMAL_METHOD
+          when Java::OracleSql::TIMESTAMP
+            method(:convert_type_oracle_timestamp)
+          else
+            super
+          end
+        end
       end
     end
   end

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

@@ -7,32 +7,6 @@ module Sequel
     # Adapter, Database, and Dataset support for accessing a PostgreSQL
     # database via JDBC.
     module Postgres
-      # Methods to add to the JDBC adapter/connection to allow it to work
-      # with the shared PostgreSQL code.
-      module AdapterMethods
-        include Sequel::Postgres::AdapterMethods
-        
-        # Give the JDBC adapter a direct execute method, which creates
-        # a statement with the given sql and executes it.
-        def execute(sql, args=nil)
-          method = block_given? ? :executeQuery : :execute
-          @db.send(:statement, self) do |stmt|
-            rows = @db.log_yield(sql){stmt.send(method, sql)}
-            yield(rows) if block_given?
-          end
-        end
-        
-        private
-        
-        # JDBC specific method of getting specific values from a result set.
-        def single_value(r)
-          unless r.nil?
-            r.next
-            r.getString(1) unless r.getRow == 0
-          end
-        end
-      end
-    
       # Methods to add to Database instances that access PostgreSQL via
       # JDBC.
       module DatabaseMethods
@@ -47,48 +21,84 @@ 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
         
-        # Extend the adapter with the JDBC PostgreSQL AdapterMethods
+        # 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
+
+        # Execute the connection configuration SQL queries on the connection.
         def setup_connection(conn)
           conn = super(conn)
-          conn.extend(Sequel::JDBC::Postgres::AdapterMethods)
-          conn.db = self
-          conn.apply_connection_settings
+          statement(conn) do |stmt|
+            connection_configuration_sqls.each{|sql| log_yield(sql){stmt.execute(sql)}}
+          end
           conn
         end
-        
-        # Call insert_result with the table and values specified in the opts.
-        def last_insert_id(conn, opts)
-          insert_result(conn, opts[:table], opts[:values])
-        end
       end
       
       # Dataset subclass used for datasets that connect to PostgreSQL via JDBC.
       class Dataset < JDBC::Dataset
         include Sequel::Postgres::DatasetMethods
+        APOS = Dataset::APOS
+        
+        class ::Sequel::JDBC::Dataset::TYPE_TRANSLATOR
+          # Convert Java::OrgPostgresqlJdbc4::Jdbc4Array to ruby arrays
+          def pg_array(v)
+            _pg_array(v.array)
+          end
+
+          # Convert Java::OrgPostgresqlUtil::PGobject to ruby strings
+          def pg_object(v)
+            v.to_string
+          end
+
+          private
+
+          # Handle multi-dimensional Java arrays by recursively mapping them
+          # to ruby arrays.
+          def _pg_array(v)
+            v.to_ary.map do |i|
+              if i.respond_to?(:to_ary)
+                _pg_array(i)
+              else
+                i
+              end
+            end
+          end
+        end
 
+        PG_ARRAY_METHOD = TYPE_TRANSLATOR_INSTANCE.method(:pg_array)
+        PG_OBJECT_METHOD = TYPE_TRANSLATOR_INSTANCE.method(:pg_object)
+      
         # Add the shared PostgreSQL prepared statement methods
         def prepare(*args)
           ps = super
           ps.extend(::Sequel::Postgres::DatasetMethods::PreparedStatementMethods)
           ps
         end
+
+        private
+        
+        # Handle PostgreSQL array and object types. Object types are just
+        # turned into strings, similarly to how the native adapter treats
+        # the types.
+        def convert_type_proc(v)
+          case v
+          when Java::OrgPostgresqlJdbc4::Jdbc4Array
+            PG_ARRAY_METHOD
+          when Java::OrgPostgresqlUtil::PGobject
+            PG_OBJECT_METHOD
+          else
+            super
+          end
+        end
         
         # Literalize strings similar to the native postgres adapter
-        def literal_string(v)
-          db.synchronize{|c| "'#{c.escape_string(v)}'"}
+        def literal_string_append(sql, v)
+          sql << APOS << db.synchronize{|c| c.escape_string(v)} << APOS
         end
       end
     end

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

@@ -0,0 +1,21 @@
+Sequel.require 'adapters/shared/progress'
+Sequel.require 'adapters/jdbc/transactions'
+
+module Sequel
+  module JDBC
+    # Database and Dataset instance methods for Progress v9 specific
+    # support via JDBC.
+    module Progress
+      # Database instance methods for Progress databases accessed via JDBC.
+      module DatabaseMethods
+        include Sequel::Progress::DatabaseMethods
+        include Sequel::JDBC::Transactions
+
+        # Progress DatabaseMetaData doesn't even implement supportsSavepoints()
+        def supports_savepoints?
+          false
+        end
+      end
+    end
+  end
+end

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

@@ -7,18 +7,33 @@ module Sequel
       # Instance methods for SQLite Database objects accessed via JDBC.
       module DatabaseMethods
         include Sequel::SQLite::DatabaseMethods
+        LAST_INSERT_ROWID = 'SELECT last_insert_rowid()'.freeze
+        FOREIGN_KEY_ERROR_RE = /query does not return ResultSet/.freeze
         
-        # Return Sequel::JDBC::SQLite::Dataset object with the given opts.
-        def dataset(opts=nil)
-          Sequel::JDBC::SQLite::Dataset.new(self, opts)
+        # Swallow pointless exceptions when the foreign key list pragma
+        # doesn't return any rows.
+        def foreign_key_list(table, opts={})
+          super
+        rescue Sequel::DatabaseError => e
+          raise unless e.message =~ FOREIGN_KEY_ERROR_RE
+          []
         end
-        
+
+        # Swallow pointless exceptions when the index list pragma
+        # doesn't return any rows.
+        def indexes(table, opts={})
+          super
+        rescue Sequel::DatabaseError => e
+          raise unless e.message =~ FOREIGN_KEY_ERROR_RE
+          {}
+        end
+
         private
         
         # Use last_insert_rowid() to get the last inserted id.
         def last_insert_id(conn, opts={})
           statement(conn) do |stmt|
-            rs = stmt.executeQuery('SELECT last_insert_rowid()')
+            rs = stmt.executeQuery(LAST_INSERT_ROWID)
             rs.next
             rs.getInt(1)
           end
@@ -39,11 +54,6 @@ module Sequel
           conn
         end
       end
-      
-      # Dataset class for SQLite datasets accessed via JDBC.
-      class Dataset < JDBC::Dataset
-        include Sequel::SQLite::DatasetMethods
-      end
     end
   end
 end

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

@@ -0,0 +1,66 @@
+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
+
+        # 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
+        module MetadataDatasetMethods
+          def process_result_set_convert(cols, result, rn)
+            while result.next
+              row = {}
+              cols.each do |n, i, p|
+                v = (n == :is_autoincrement ? result.getString(i) : result.getObject(i))
+                row[n] = if v
+                  if p
+                    p.call(v)
+                  elsif p.nil?
+                    cols[i-1][2] = p = convert_type_proc(v)
+                    if p
+                      p.call(v)
+                    else
+                      v
+                    end
+                  else
+                    v
+                  end
+                else
+                  v
+                end
+              end
+              row.delete(rn) if rn
+              yield row
+            end
+          end
+
+          def process_result_set_no_convert(cols, result, rn)
+            while result.next
+              row = {}
+              cols.each do |n, i|
+                row[n] = (n == :is_autoincrement ? result.getString(i) : result.getObject(i))
+              end
+              row.delete(rn) if rn
+              yield row
+            end
+          end
+        end
+        
+        def metadata_dataset
+          super.extend(MetadataDatasetMethods)
+        end
+      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 = _trans(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 = _trans(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 = _trans(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 = _trans(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
+