activerecord-jdbc-alt-adapter 52.4.0-java → 61.0.0-java

data/lib/arel/visitors/postgresql_jdbc.rb

@@ -2,5 +2,5 @@ require 'arel/visitors/compat'
 
 class Arel::Visitors::PostgreSQL
   # AREL converts bind argument markers "?" to "$n" for PG, but JDBC wants "?".
-  remove_method :visit_Arel_Nodes_BindParam if ArJdbc::AR42
+  remove_method :bind_block
 end

data/lib/arel/visitors/sqlserver.rb

@@ -4,13 +4,8 @@
 module Arel
   module Visitors
     class SQLServer < Arel::Visitors::ToSql
-
-      OFFSET = " OFFSET "
-      ROWS = " ROWS"
-      FETCH = " FETCH NEXT "
-      FETCH0 = " FETCH FIRST (SELECT 0) "
-      ROWS_ONLY = " ROWS ONLY"
-
+      # 'FETCH FIRST' or 'FETCH NEXT' do the same thing
+      # The SQL ANSI Standard says NEXT and FIRST are synonyms
 
       private
 
@@ -35,33 +30,38 @@ module Arel
 
       def visit_Arel_Nodes_Lock o, collector
         o.expr = Arel.sql('WITH(UPDLOCK)') if o.expr.to_s =~ /FOR UPDATE/
-        collector << SPACE
+        collector << ' '
         visit o.expr, collector
       end
 
       def visit_Arel_Nodes_Offset o, collector
-        collector << OFFSET
+        collector << ' OFFSET '
         visit o.expr, collector
-        collector << ROWS
+        collector << ' ROWS'
       end
 
       def visit_Arel_Nodes_Limit o, collector
         if node_value(o) == 0
-          collector << FETCH0
-          collector << ROWS_ONLY
+          collector << ' FETCH FIRST (SELECT 0) '
+          collector << ' ROWS ONLY'
         else
-          collector << FETCH
+          collector << ' FETCH NEXT '
           visit o.expr, collector
-          collector << ROWS_ONLY
+          collector << ' ROWS ONLY'
         end
       end
 
+      def visit_Arel_Nodes_Grouping(o, collector)
+        remove_invalid_ordering_from_select_statement(o.expr)
+        super
+      end
+
       def visit_Arel_Nodes_SelectStatement o, collector
         @select_statement = o
         distinct_One_As_One_Is_So_Not_Fetch o
         if o.with
           collector = visit o.with, collector
-          collector << SPACE
+          collector << ' '
         end
         collector = o.cores.inject(collector) { |c,x|
           visit_Arel_Nodes_SelectCore(x, c)
@@ -99,7 +99,7 @@ module Arel
           collector = visit_Arel_Nodes_SelectStatement_SQLServer_Lock collector
         end
         if o.right.any?
-          collector << SPACE if o.left
+          collector << ' ' if o.left
           collector = inject_join o.right, collector, ' '
         end
         collector
@@ -110,7 +110,7 @@ module Arel
         collector = visit o.left, collector
         collector = visit_Arel_Nodes_SelectStatement_SQLServer_Lock collector, space: true
         if o.right
-          collector << SPACE
+          collector << ' '
           visit(o.right, collector)
         else
           collector
@@ -121,16 +121,31 @@ module Arel
         collector << "LEFT OUTER JOIN "
         collector = visit o.left, collector
         collector = visit_Arel_Nodes_SelectStatement_SQLServer_Lock collector, space: true
-        collector << SPACE
+        collector << ' '
         visit o.right, collector
       end
 
+      # NOTE: this overrides the original method in arel visitors 'to_sql.rb'
+      # fixes The ORDER BY clause is invalid in subqueries
+      # FIXME: we should probably have a 2-pass visitor for this
+      def build_subselect(key, o)
+        stmt             = Nodes::SelectStatement.new
+        core             = stmt.cores.first
+        core.froms       = o.relation
+        core.wheres      = o.wheres
+        core.projections = [key]
+        stmt.limit       = o.limit
+        stmt.offset      = o.offset
+        stmt.orders      = []
+        stmt
+      end
+
       # SQLServer ToSql/Visitor (Additions)
 
       def visit_Arel_Nodes_SelectStatement_SQLServer_Lock collector, options = {}
         if select_statement_lock?
           collector = visit @select_statement.lock, collector
-          collector << SPACE if options[:space]
+          collector << ' ' if options[:space]
         end
         collector
       end
@@ -138,12 +153,12 @@ module Arel
       def visit_Orders_And_Let_Fetch_Happen o, collector
         make_Fetch_Possible_And_Deterministic o
         unless o.orders.empty?
-          collector << SPACE
-          collector << ORDER_BY
+          collector << ' '
+          collector << ' ORDER BY '
           len = o.orders.length - 1
           o.orders.each_with_index { |x, i|
             collector = visit(x, collector)
-            collector << COMMA unless len == i
+            collector << ', ' unless len == i
           }
         end
         collector
@@ -173,9 +188,11 @@ module Arel
 
       def make_Fetch_Possible_And_Deterministic o
         return if o.limit.nil? && o.offset.nil?
+
         t = table_From_Statement o
         pk = primary_Key_From_Table t
         return unless pk
+
         if o.orders.empty?
           # Prefer deterministic vs a simple `(SELECT NULL)` expr.
           o.orders = [pk.asc]
@@ -205,12 +222,13 @@ module Arel
         elsif Arel::Nodes::SqlLiteral === core.from
           Arel::Table.new(core.from)
         elsif Arel::Nodes::JoinSource === core.source
-          Arel::Nodes::SqlLiteral === core.source.left ? Arel::Table.new(core.source.left, @engine) : core.source.left
+          Arel::Nodes::SqlLiteral === core.source.left ? Arel::Table.new(core.source.left, @engine) : core.source.left.left
         end
       end
 
       def primary_Key_From_Table t
         return unless t
+
         # column_name = schema_cache.primary_keys(t.name) || column_cache(t.name).first.try(:second).try(:name)
         # NOTE: for table name aliases columns_hash('table_alias')  requires to return an empty hash.
         column_name = @connection.schema_cache.primary_keys(t.name) ||
@@ -224,6 +242,14 @@ module Arel
         ).quoted
       end
 
+      # Need to remove ordering from subqueries unless TOP/OFFSET also used. Otherwise, SQLServer
+      # returns error "The ORDER BY clause is invalid in views, inline functions, derived tables,
+      # subqueries, and common table expressions, unless TOP, OFFSET or FOR XML is also specified."
+      def remove_invalid_ordering_from_select_statement(node)
+        return unless Arel::Nodes::SelectStatement === node
+
+        node.orders = [] unless node.offset || node.limit
+      end
     end
   end
 end

data/lib/arjdbc/abstract/connection_management.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ArJdbc
   module Abstract
     module ConnectionManagement
@@ -8,6 +10,11 @@ module ArJdbc
         @connection.active?
       end
 
+      def really_valid?
+        return unless @connection
+        @connection.really_valid?
+      end
+
       # @override
       def reconnect!
         super # clear_cache! && reset_transaction

data/lib/arjdbc/abstract/core.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ArJdbc
   module Abstract
 
@@ -34,28 +36,27 @@ module ArJdbc
 
       protected
 
-      def translate_exception_class(e, sql)
-        begin
-          message = "#{e.class.name}: #{e.message}: #{sql}"
-        rescue Encoding::CompatibilityError
-          message = "#{e.class.name}: #{e.message.force_encoding sql.encoding}: #{sql}"
-        end
+      def translate_exception_class(e, sql, binds)
+        message = "#{e.class.name}: #{e.message}"
 
-        exception = translate_exception(e, message)
-        exception.set_backtrace e.backtrace unless e.equal?(exception)
+        exception = translate_exception(
+          e, message: message, sql: sql, binds: binds
+        )
+        exception.set_backtrace e.backtrace
         exception
       end
 
-      def translate_exception(e, message)
+      def translate_exception(exception, message:, sql:, binds:)
         # override in derived class
 
         # we shall not translate native "Java" exceptions as they might
         # swallow an ArJdbc / driver bug into an AR::StatementInvalid !
-        return e if e.is_a?(Java::JavaLang::Throwable)
+        return exception if exception.is_a?(Java::JavaLang::Throwable)
 
-        case e
-          when SystemExit, SignalException, NoMemoryError then e
-          when ActiveModel::RangeError, TypeError, RuntimeError then e
+        case exception
+          when SystemExit, SignalException, NoMemoryError then exception
+          when ActiveModel::RangeError, TypeError, RuntimeError then exception
+          when ActiveRecord::ConnectionNotEstablished then exception
           else super
         end
       end
@@ -74,13 +75,6 @@ module ArJdbc
     end
   end
 
-  module LogSubscriber
-    JDBC_GEM_ROOT = File.expand_path("../../../..", __FILE__) + "/"
-
-    # Remove this gem from log trace so that query shows where it was called in application
-    def ignored_callstack(path)
-      super || path.start_with?(JDBC_GEM_ROOT)
-    end
-  end
-  ActiveRecord::LogSubscriber.prepend(ArJdbc::LogSubscriber)
-end
+  JDBC_GEM_ROOT = File.expand_path("../../../..", __FILE__) + "/"
+  ActiveRecord::LogSubscriber.backtrace_cleaner.add_silencer { |line| line.start_with?(JDBC_GEM_ROOT) }
+end

data/lib/arjdbc/abstract/database_statements.rb

@@ -10,13 +10,20 @@ module ArJdbc
       NO_BINDS = [].freeze
 
       def exec_insert(sql, name = nil, binds = NO_BINDS, pk = nil, sequence_name = nil)
+        if preventing_writes?
+          raise ActiveRecord::ReadOnlyError, "Write query attempted while in readonly mode: #{sql}"
+        end
+
+        materialize_transactions
+        mark_transaction_written_if_write(sql)
+
         binds = convert_legacy_binds_to_attributes(binds) if binds.first.is_a?(Array)
 
         if without_prepared_statement?(binds)
-          log(sql, name) { @connection.execute_insert(sql) }
+          log(sql, name) { @connection.execute_insert_pk(sql, pk) }
         else
           log(sql, name, binds) do
-            @connection.execute_insert(sql, binds)
+            @connection.execute_insert_pk(sql, binds, pk)
           end
         end
       end
@@ -24,6 +31,13 @@ module ArJdbc
       # It appears that at this point (AR 5.0) "prepare" should only ever be true
       # if prepared statements are enabled
       def exec_query(sql, name = nil, binds = NO_BINDS, prepare: false)
+        if preventing_writes? && write_query?(sql)
+          raise ActiveRecord::ReadOnlyError, "Write query attempted while in readonly mode: #{sql}"
+        end
+
+        materialize_transactions
+        mark_transaction_written_if_write(sql)
+
         binds = convert_legacy_binds_to_attributes(binds) if binds.first.is_a?(Array)
 
         if without_prepared_statement?(binds)
@@ -38,6 +52,13 @@ module ArJdbc
       end
 
       def exec_update(sql, name = nil, binds = NO_BINDS)
+        if preventing_writes?
+          raise ActiveRecord::ReadOnlyError, "Write query attempted while in readonly mode: #{sql}"
+        end
+
+        materialize_transactions
+        mark_transaction_written_if_write(sql)
+
         binds = convert_legacy_binds_to_attributes(binds) if binds.first.is_a?(Array)
 
         if without_prepared_statement?(binds)
@@ -49,6 +70,13 @@ module ArJdbc
       alias :exec_delete :exec_update
 
       def execute(sql, name = nil)
+        if preventing_writes? && write_query?(sql)
+          raise ActiveRecord::ReadOnlyError, "Write query attempted while in readonly mode: #{sql}"
+        end
+
+        materialize_transactions
+        mark_transaction_written_if_write(sql)
+
         log(sql, name) { @connection.execute(sql) }
       end
 

data/lib/arjdbc/abstract/statement_cache.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'active_record/connection_adapters/statement_pool'
 
 module ArJdbc
@@ -41,11 +43,6 @@ module ArJdbc
         @statements[sql_key(sql)] ||= @connection.prepare_statement(sql)
       end
 
-      def supports_statement_cache?
-        ActiveSupport::Deprecation.deprecation_warning(__method__)
-        @jdbc_statement_cache_enabled
-      end
-
       private
 
       # This should be overridden by the adapter if the sql itself

data/lib/arjdbc/abstract/transaction_support.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ArJdbc
   module Abstract
 
@@ -22,26 +24,26 @@ module ArJdbc
       # Starts a database transaction.
       # @override
       def begin_db_transaction
-        log('BEGIN TRANSACTION'.freeze, nil) { @connection.begin }
+        log('BEGIN', 'TRANSACTION') { @connection.begin }
       end
 
       # Starts a database transaction.
       # @param isolation the transaction isolation to use
       def begin_isolated_db_transaction(isolation)
-        log("BEGIN ISOLATED TRANSACTION - #{isolation}", nil) { @connection.begin(isolation) }
+        log("BEGIN ISOLATED - #{isolation}", 'TRANSACTION') { @connection.begin(isolation) }
       end
 
       # Commits the current database transaction.
       # @override
       def commit_db_transaction
-        log('COMMIT TRANSACTION'.freeze, nil) { @connection.commit }
+        log('COMMIT', 'TRANSACTION') { @connection.commit }
       end
 
       # Rolls back the current database transaction.
       # Called from 'rollback_db_transaction' in the AbstractAdapter
       # @override
       def exec_rollback_db_transaction
-        log('ROLLBACK TRANSACTION'.freeze, nil) { @connection.rollback }
+        log('ROLLBACK', 'TRANSACTION') { @connection.rollback }
       end
 
       ########################## Savepoint Interface ############################
@@ -53,7 +55,7 @@ module ArJdbc
       # @since 1.3.0
       # @extension added optional name parameter
       def create_savepoint(name = current_savepoint_name)
-        log("SAVEPOINT #{name}", 'Savepoint') { @connection.create_savepoint(name) }
+        log("SAVEPOINT #{name}", 'TRANSACTION') { @connection.create_savepoint(name) }
       end
 
       # Transaction rollback to a given (previously created) save-point.
@@ -62,7 +64,7 @@ module ArJdbc
       # @param name the save-point name
       # @extension added optional name parameter
       def exec_rollback_to_savepoint(name = current_savepoint_name)
-        log("ROLLBACK TO SAVEPOINT #{name}", 'Savepoint') { @connection.rollback_savepoint(name) }
+        log("ROLLBACK TO SAVEPOINT #{name}", 'TRANSACTION') { @connection.rollback_savepoint(name) }
       end
 
       # Release a previously created save-point.
@@ -71,9 +73,22 @@ module ArJdbc
       # @param name the save-point name
       # @extension added optional name parameter
       def release_savepoint(name = current_savepoint_name)
-        log("RELEASE SAVEPOINT #{name}", 'Savepoint') { @connection.release_savepoint(name) }
+        log("RELEASE SAVEPOINT #{name}", 'TRANSACTION') { @connection.release_savepoint(name) }
       end
 
     end
   end
 end
+
+# patch to avoid the usage of WeakMap
+require 'active_record/connection_adapters/abstract/transaction'
+module ActiveRecord
+  module ConnectionAdapters
+    class Transaction
+      def add_record(record, ensure_finalize = true)
+        @records ||= []
+        @records << record
+      end
+    end
+  end
+end

data/lib/arjdbc/db2/column.rb

@@ -80,45 +80,6 @@ module ArJdbc
 
       private
 
-      def simplified_type(field_type)
-        case field_type
-        when /^decimal\(1\)$/i   then DB2.emulate_booleans? ? :boolean : :integer
-        when /smallint/i         then DB2.emulate_booleans? ? :boolean : :integer
-        when /boolean/i          then :boolean
-        when /^real|double/i     then :float
-        when /int|serial/i       then :integer
-        # if a numeric column has no scale, lets treat it as an integer.
-        # The AS400 rpg guys do this ALOT since they have no integer datatype ...
-        when /decimal|numeric|decfloat/i
-          extract_scale(field_type) == 0 ? :integer : :decimal
-        when /timestamp/i        then :timestamp
-        when /datetime/i         then :datetime
-        when /time/i             then :time
-        when /date/i             then :date
-        # DB2 provides three data types to store these data objects as strings of up to 2 GB in size:
-        #  Character large objects (CLOBs)
-        #    Use the CLOB data type to store SBCS or mixed data, such as documents that contain
-        #    single character set. Use this data type if your data is larger (or might grow larger)
-        #    than the VARCHAR data type permits.
-        #  Double-byte character large objects (DBCLOBs)
-        #    Use the DBCLOB data type to store large amounts of DBCS data, such as documents that
-        #    use a DBCS character set.
-        #  Binary large objects (BLOBs)
-        #    Use the BLOB data type to store large amounts of noncharacter data, such as pictures,
-        #    voice, and mixed media.
-        when /clob|text/i        then :text # handles DBCLOB
-        when /^long varchar/i    then :text # :limit => 32700
-        when /blob|binary/i      then :binary
-        # varchar () for bit data, char () for bit data, long varchar for bit data
-        when /for bit data/i     then :binary
-        when /xml/i              then :xml
-        when /graphic/i          then :graphic # vargraphic, long vargraphic
-        when /rowid/i            then :rowid # rowid is a supported datatype on z/OS and i/5
-        else
-          super
-        end
-      end
-
       # Post process default value from JDBC into a Rails-friendly format (columns{-internal})
       def default_value(value)
         # IBM i (AS400) will return an empty string instead of null for no default