activerecord-jdbc-alt-adapter 50.3.0-java

data/lib/arel/visitors/sqlserver.rb

@@ -0,0 +1,214 @@
+# NOTE: this code was take from the **sqlserver** adapter and adapted to work
+# with this adapter.
+#
+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"
+
+
+      private
+
+      # SQLServer ToSql/Visitor (Overides)
+
+      def visit_Arel_Nodes_BindParam o, collector
+        # collector.add_bind(o) { |i| "@#{i-1}" }
+        collector.add_bind(o) { |i| '?' }
+      end
+
+      def visit_Arel_Nodes_Bin o, collector
+        visit o.expr, collector
+        collector << " #{ActiveRecord::ConnectionAdapters::MSSQLAdapter.cs_equality_operator} "
+      end
+
+      def visit_Arel_Nodes_UpdateStatement(o, a)
+        if o.orders.any? && o.limit.nil?
+          o.limit = Nodes::Limit.new(9_223_372_036_854_775_807)
+        end
+        super
+      end
+
+      def visit_Arel_Nodes_Lock o, collector
+        o.expr = Arel.sql('WITH(UPDLOCK)') if o.expr.to_s =~ /FOR UPDATE/
+        collector << SPACE
+        visit o.expr, collector
+      end
+
+      def visit_Arel_Nodes_Offset o, collector
+        collector << OFFSET
+        visit o.expr, collector
+        collector << ROWS
+      end
+
+      def visit_Arel_Nodes_Limit o, collector
+        if node_value(o) == 0
+          collector << FETCH0
+          collector << ROWS_ONLY
+        else
+          collector << FETCH
+          visit o.expr, collector
+          collector << ROWS_ONLY
+        end
+      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
+        end
+        collector = o.cores.inject(collector) { |c,x|
+          visit_Arel_Nodes_SelectCore(x, c)
+        }
+        collector = visit_Orders_And_Let_Fetch_Happen o, collector
+        collector = visit_Make_Fetch_Happen o, collector
+        collector
+      ensure
+        @select_statement = nil
+      end
+
+      def visit_Arel_Table o, collector
+        # Apparently, o.engine.connection can actually be a different adapter
+        # than sqlserver. Can be removed if fixed in ActiveRecord. See:
+        # github.com/rails-sqlserver/activerecord-sqlserver-adapter/issues/450
+        table_name = begin
+          if o.class.engine.connection.respond_to?(:sqlserver?) && o.class.engine.connection.database_prefix_remote_server?
+            remote_server_table_name(o)
+          else
+            quote_table_name(o.name)
+          end
+        rescue Exception => e
+          quote_table_name(o.name)
+        end
+        if o.table_alias
+          collector << "#{table_name} #{quote_table_name o.table_alias}"
+        else
+          collector << table_name
+        end
+      end
+
+      def visit_Arel_Nodes_JoinSource o, collector
+        if o.left
+          collector = visit o.left, collector
+          collector = visit_Arel_Nodes_SelectStatement_SQLServer_Lock collector
+        end
+        if o.right.any?
+          collector << " " if o.left
+          collector = inject_join o.right, collector, ' '
+        end
+        collector
+      end
+
+      def visit_Arel_Nodes_OuterJoin o, collector
+        collector << "LEFT OUTER JOIN "
+        collector = visit o.left, collector
+        collector = visit_Arel_Nodes_SelectStatement_SQLServer_Lock collector, space: true
+        collector << " "
+        visit o.right, collector
+      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]
+        end
+        collector
+      end
+
+      def visit_Orders_And_Let_Fetch_Happen o, collector
+        make_Fetch_Possible_And_Deterministic o
+        unless o.orders.empty?
+          collector << SPACE
+          collector << ORDER_BY
+          len = o.orders.length - 1
+          o.orders.each_with_index { |x, i|
+            collector = visit(x, collector)
+            collector << COMMA unless len == i
+          }
+        end
+        collector
+      end
+
+      def visit_Make_Fetch_Happen o, collector
+        o.offset = Nodes::Offset.new(0) if o.limit && !o.offset
+        collector = visit o.offset, collector if o.offset
+        collector = visit o.limit, collector if o.limit
+        collector
+      end
+
+      # SQLServer Helpers
+
+      def node_value(node)
+        return nil unless node
+        case node.expr
+        when NilClass then nil
+        when Numeric then node.expr
+        when Arel::Nodes::Unary then node.expr.expr
+        end
+      end
+
+      def select_statement_lock?
+        @select_statement && @select_statement.lock
+      end
+
+      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]
+        end
+      end
+
+      def distinct_One_As_One_Is_So_Not_Fetch o
+        core = o.cores.first
+        distinct = Nodes::Distinct === core.set_quantifier
+        oneasone = core.projections.all? { |x| x == ActiveRecord::FinderMethods::ONE_AS_ONE }
+        limitone = [nil, 0, 1].include? node_value(o.limit)
+        if distinct && oneasone && limitone && !o.offset
+          # NOTE: part clears the limit part of the query but the bind parameter
+          # is still hanging around in active record, this issue makes
+          # the prepared statement to fails with "index i is out of range"
+          # As a quick fix is just add the bind marker as parameter of TOP
+          # which always be one.
+          core.projections = [Arel.sql("TOP(?) 1 AS [one]")]
+          o.limit = nil
+        end
+      end
+
+      def table_From_Statement o
+        core = o.cores.first
+        if Arel::Table === core.from
+          core.from
+        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
+        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)
+        column_name ? t[column_name] : nil
+      end
+
+      def remote_server_table_name o
+        ActiveRecord::ConnectionAdapters::SQLServer::Utils.extract_identifiers(
+          "#{o.class.engine.connection.database_prefix}#{o.name}"
+        ).quoted
+      end
+
+    end
+  end
+end

data/lib/arjdbc.rb

@@ -0,0 +1,19 @@
+if defined?(JRUBY_VERSION)
+  begin
+    require 'active_record/version'
+    require 'active_record'
+  rescue LoadError => e
+    warn "activerecord-jdbc-adapter requires the activerecord gem at runtime"
+    raise e
+  end
+  require 'arjdbc/jdbc'
+  begin
+    require 'arjdbc/railtie'
+  rescue LoadError => e
+    warn "activerecord-jdbc-adapter failed to load railtie: #{e.inspect}"
+  end if defined?(Rails) && ActiveRecord::VERSION::MAJOR >= 3
+else
+  warn "activerecord-jdbc-adapter is for use with JRuby only"
+end
+
+require 'arjdbc/version'

data/lib/arjdbc/abstract/connection_management.rb

@@ -0,0 +1,35 @@
+module ArJdbc
+  module Abstract
+    module ConnectionManagement
+
+      # @override
+      def active?
+        return unless @connection
+        @connection.active?
+      end
+
+      # @override
+      def reconnect!
+        super # clear_cache! && reset_transaction
+        @connection.reconnect! # handles adapter.configure_connection
+      end
+
+      # @override
+      def disconnect!
+        super # clear_cache! && reset_transaction
+        return unless @connection
+        @connection.disconnect!
+      end
+
+      # @override
+      # def verify!(*ignored)
+      #  if @connection && @connection.jndi?
+      #    # checkout call-back does #reconnect!
+      #  else
+      #    reconnect! unless active? # super
+      #  end
+      # end
+
+    end
+  end
+end

data/lib/arjdbc/abstract/core.rb

@@ -0,0 +1,74 @@
+module ArJdbc
+  module Abstract
+
+    # This is minimum amount of code needed from base JDBC Adapter class to make common adapters
+    # work.  This replaces using jdbc/adapter as a base class for all adapters.
+    module Core
+
+      attr_reader :config
+
+      def initialize(connection, logger = nil, config = {})
+        @config = config
+
+        if self.class.equal? ActiveRecord::ConnectionAdapters::JdbcAdapter
+          spec = @config.key?(:adapter_spec) ? @config[:adapter_spec] :
+                     ( @config[:adapter_spec] = adapter_spec(@config) ) # due resolving visitor
+          extend spec if spec
+        end
+
+        connection ||= jdbc_connection_class(config[:adapter_spec]).new(config, self)
+
+        super(connection, logger, config) # AbstractAdapter
+
+        connection.configure_connection # will call us (maybe)
+      end
+      
+      # Retrieve the raw `java.sql.Connection` object.
+      # The unwrap parameter is useful if an attempt to unwrap a pooled (JNDI)
+      # connection should be made - to really return the 'native' JDBC object.
+      # @param unwrap [true, false] whether to unwrap the connection object
+      # @return [Java::JavaSql::Connection] the JDBC connection
+      def jdbc_connection(unwrap = nil)
+        raw_connection.jdbc_connection(unwrap)
+      end
+
+      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
+
+        exception = translate_exception(e, message)
+        exception.set_backtrace e.backtrace unless e.equal?(exception)
+        exception
+      end
+
+      def translate_exception(e, message)
+        # 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)
+
+        case e
+          when SystemExit, SignalException, NoMemoryError then e
+          when ActiveModel::RangeError, TypeError, RuntimeError then e
+          else ActiveRecord::StatementInvalid.new(message)
+        end
+      end
+
+      def extract_raw_bind_values(binds)
+        binds.map(&:value_for_database)
+      end
+
+      # this version of log() automatically fills type_casted_binds from binds if necessary
+      def log(sql, name = "SQL", binds = [], type_casted_binds = [], statement_name = nil)
+        if binds.any? && (type_casted_binds.nil? || type_casted_binds.empty?)
+          type_casted_binds = ->{ extract_raw_bind_values(binds) }
+        end
+        super
+      end
+    end
+  end
+end

data/lib/arjdbc/abstract/database_statements.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module ArJdbc
+  module Abstract
+
+    # This provides the basic interface for interacting with the
+    # database for JDBC based adapters
+    module DatabaseStatements
+
+      NO_BINDS = [].freeze
+
+      def exec_insert(sql, name = nil, binds = NO_BINDS, pk = nil, sequence_name = nil)
+        if without_prepared_statement?(binds)
+          log(sql, name) { @connection.execute_insert(sql) }
+        else
+          log(sql, name, binds) do
+            @connection.execute_insert(sql, binds)
+          end
+        end
+      end
+
+      # 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 without_prepared_statement?(binds)
+          log(sql, name) { @connection.execute_query(sql) }
+        else
+          log(sql, name, binds) do
+            # this is different from normal AR that always caches
+            cached_statement = fetch_cached_statement(sql) if prepare && @jdbc_statement_cache_enabled
+            @connection.execute_prepared_query(sql, binds, cached_statement)
+          end
+        end
+      end
+
+      def exec_update(sql, name = nil, binds = NO_BINDS)
+        if without_prepared_statement?(binds)
+          log(sql, name) { @connection.execute_update(sql) }
+        else
+          log(sql, name, binds) { @connection.execute_prepared_update(sql, binds) }
+        end
+      end
+      alias :exec_delete :exec_update
+
+      def execute(sql, name = nil)
+        log(sql, name) { @connection.execute(sql) }
+      end
+
+      def select_all(arel, name = nil, binds = NO_BINDS, preparable: nil)
+        binds = convert_legacy_binds_to_attributes(binds) if binds.first.is_a?(Array)
+        super
+      end
+
+      private
+
+      def convert_legacy_binds_to_attributes(binds)
+        binds.map do |column, value|
+          ActiveRecord::Relation::QueryAttribute.new(nil, type_cast(value, column), ActiveModel::Type::Value.new)
+        end
+      end
+
+    end
+  end
+end

data/lib/arjdbc/abstract/statement_cache.rb

@@ -0,0 +1,58 @@
+require 'active_record/connection_adapters/statement_pool'
+
+module ArJdbc
+  module Abstract
+    module StatementCache
+
+      # This works a little differently than the AR implementation in that
+      # we are storing an actual PreparedStatement object instead of just
+      # the name of the prepared statement
+      class StatementPool < ActiveRecord::ConnectionAdapters::StatementPool
+
+        private
+
+        def dealloc(statement)
+          statement.close
+        end
+
+      end
+
+      def initialize(*args) # (connection, logger, config)
+        super
+
+        # Only say we support the statement cache if we are using prepared statements
+        # and have a max number of statements defined
+        statement_limit = self.class.type_cast_config_to_integer(config[:statement_limit])
+        @jdbc_statement_cache_enabled = prepared_statements && (statement_limit.nil? || statement_limit > 0)
+
+        @statements = StatementPool.new(statement_limit) # AR (5.0) expects this to be stored as @statements
+      end
+
+      # Clears the prepared statements cache.
+      def clear_cache!
+        @statements.clear
+      end
+
+      def delete_cached_statement(sql)
+        @statements.delete(sql_key(sql))
+      end
+
+      def fetch_cached_statement(sql)
+        @statements[sql_key(sql)] ||= @connection.prepare_statement(sql)
+      end
+
+      def supports_statement_cache?
+        @jdbc_statement_cache_enabled
+      end
+
+      private
+
+      # This should be overridden by the adapter if the sql itself
+      # is not enough to make the key unique
+      def sql_key(sql)
+        sql
+      end
+
+    end
+  end
+end