sequel 3.21.0 → 3.41.0

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,72 @@
+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
+
+        private
+
+        def disconnect_error?(exception, opts)
+          super || (exception.message =~ /connection is closed/)
+        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
+