sequel 3.21.0 → 3.32.0

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,17 +52,21 @@ module Sequel
         def schema_column_type(db_type)
           db_type == 'tinyint(1)' ? :boolean : super
         end
+      
+        # By default, MySQL 'where id is null' selects the last inserted id.
+        # Turn that off unless explicitly enabled.
+        def setup_connection(conn)
+          super
+          sql = "SET SQL_AUTO_IS_NULL=0"
+          statement(conn){|s| log_yield(sql){s.execute(sql)}} unless opts[:auto_is_null]
+          conn
+        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))

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

@@ -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)
@@ -78,6 +73,7 @@ module Sequel
       # Dataset subclass used for datasets that connect to PostgreSQL via JDBC.
       class Dataset < JDBC::Dataset
         include Sequel::Postgres::DatasetMethods
+        APOS = Dataset::APOS
 
         # Add the shared PostgreSQL prepared statement methods
         def prepare(*args)
@@ -87,8 +83,8 @@ module Sequel
         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/sqlite.rb

@@ -7,18 +7,14 @@ module Sequel
       # Instance methods for SQLite Database objects accessed via JDBC.
       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
+        LAST_INSERT_ROWID = 'SELECT last_insert_rowid()'.freeze
         
         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

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

@@ -0,0 +1,71 @@
+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
+      
+      # 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
+