activerecord-jdbc-adapter-ficoh 1.3.21-java

data/lib/arjdbc/jdbc/adapter_require.rb

@@ -0,0 +1,46 @@
+module ActiveRecord
+
+  if defined? ConnectionAdapters::ConnectionSpecification::Resolver # 4.0
+    ConnectionAdapters::ConnectionSpecification::Resolver
+  elsif defined? Base::ConnectionSpecification::Resolver # 3.2
+    Base::ConnectionSpecification::Resolver
+  else class << Base; self; end # 2.3, 3.0, 3.1 :
+    # def self.establish_connection ... on ActiveRecord::Base
+  end.class_eval do
+
+    # @private
+    def require(path)
+      # NOTE: we're inspecting resolver.spec connection resolution which does :
+      # `require "active_record/connection_adapters/#{spec[:adapter]}_adapter"`
+      # ...
+      # this {#require} method is only re-defined on a Resolver object and thus
+      # will not hurt performance - it will only be called for a few times (most
+      # likely once), this should still be fine for AR < 3.2 where this patch
+      # ends up on `class << ActiveRecord::Base` since models usually rely on
+      # Rails's auto-loading of (missing) constants and rarely use `require`.
+      #
+      # other alternative (to make sure we do not need to eager load AR built-in
+      #  adapters) would be to mingle with the $LOAD_PATH which seems worse ...
+      case path
+      when 'active_record/connection_adapters/mysql_adapter'
+        $LOADED_FEATURES << 'active_record/connection_adapters/mysql_adapter.rb'
+        super('arjdbc/mysql')
+      when 'active_record/connection_adapters/mysql2_adapter'
+        $LOADED_FEATURES << 'active_record/connection_adapters/mysql2_adapter.rb'
+        super('arjdbc/mysql')
+      when 'active_record/connection_adapters/postgresql_adapter'
+        $LOADED_FEATURES << 'active_record/connection_adapters/postgresql_adapter.rb'
+        super('arjdbc/postgresql')
+      when 'active_record/connection_adapters/sqlite_adapter'
+        $LOADED_FEATURES << 'active_record/connection_adapters/sqlite_adapter.rb'
+        super('arjdbc/sqlite3')
+      when 'active_record/connection_adapters/sqlite3_adapter'
+        $LOADED_FEATURES << 'active_record/connection_adapters/sqlite3_adapter.rb'
+        super('arjdbc/sqlite3')
+      else super
+      end
+    end
+
+  end
+
+end

data/lib/arjdbc/jdbc/arel_support.rb

@@ -0,0 +1,149 @@
+module ActiveRecord::ConnectionAdapters
+  module Jdbc
+    # AREL support for the JDBC adapter.
+    # @see ActiveRecord::ConnectionAdapters::JdbcAdapter
+    module ArelSupport
+
+      def self.included(base)
+        base.extend ClassMethods
+      end
+
+      module ClassMethods
+
+        def arel_visitor_name(spec)
+          if spec
+            if spec.respond_to?(:arel_visitor_name)
+              spec.arel_visitor_name # for AREL built-in visitors
+            else
+              spec.name.split('::').last.downcase # ArJdbc::PostgreSQL -> postgresql
+            end
+          else # AR::ConnnectionAdapters::MySQLAdapter => mysql
+            name.split('::').last.sub('Adapter', '').downcase
+          end
+        end
+
+        # NOTE: it's important to track our own since we might want to override
+        # what AREL setup for us e.g. we do not want `::Arel::Visitors::MSSQL`
+
+        # @private
+        RESOLVED_VISITORS = {} # lazy filled mirror of ::Arel::Visitors::VISITORS
+
+        # @todo document
+        def resolve_visitor_type(config)
+          raise "missing :adapter in #{config.inspect}" unless adapter = config[:adapter]
+
+          visitor_type = RESOLVED_VISITORS[ adapter ]
+
+          if visitor_type.nil? || adapter == 'jdbc'
+            if adapter_spec = config[:adapter_spec]
+              if adapter_spec.respond_to?(:arel_visitor_type)
+                visitor_type = adapter_spec.arel_visitor_type(config)
+              elsif adapter_spec.respond_to?(:arel2_visitors) # backwards compat
+                visitor_type = adapter_spec.arel2_visitors(config).values.first
+              else # auto-convention ArJdbc::MySQL -> Arel::Visitors::MySQL
+                const_name = adapter_spec.name.split('::').last
+                visitor_type = ::Arel::Visitors.const_get(const_name) rescue nil
+              end
+            elsif respond_to?(:arel_visitor_type)
+              visitor_type = arel_visitor_type(config) # adapter_class' override
+            end
+
+            if visitor_type && RESOLVED_VISITORS[ adapter ] # adapter == 'jdbc'
+              if visitor_type != RESOLVED_VISITORS[ adapter ]
+                ArJdbc.warn("overriding visitor for 'adapter: jdbc' (from #{RESOLVED_VISITORS[ adapter ]} to #{visitor_type})")
+              end
+            end
+
+            visitor_type ||= ::Arel::Visitors::VISITORS[ arel_visitor_name(adapter_spec) ]
+            visitor_type ||= ::Arel::Visitors::ToSql # default (if nothing resolved)
+
+            RESOLVED_VISITORS.to_java.synchronized do
+              RESOLVED_VISITORS[ adapter ] = ::Arel::Visitors::VISITORS[ adapter ] = visitor_type
+            end
+          end
+
+          visitor_type
+        end
+
+        # @private
+        def clean_visitor_type(adapter)
+          RESOLVED_VISITORS.to_java.synchronized do
+            RESOLVED_VISITORS.delete(adapter); ::Arel::Visitors::VISITORS.delete(adapter)
+          end
+        end
+        private :clean_visitor_type
+
+        # @note called from `ActiveRecord::ConnectionAdapters::ConnectionPool.checkout` (up till AR-3.2)
+        # @override
+        def visitor_for(pool)
+          visitor = resolve_visitor_type(config = pool.spec.config)
+          ( prepared_statements?(config) ? visitor : bind_substitution(visitor) ).new(pool)
+        end
+
+        # @private
+        @@bind_substitutions = nil
+
+        # Generates a class for the given visitor type, this new {Class} instance
+        # is a sub-class of `Arel::Visitors::BindVisitor`.
+        # @return [Class] class for given visitor type
+        def bind_substitution(visitor)
+          # NOTE: similar convention as in AR (but no base substitution type) :
+          # class BindSubstitution < ::Arel::Visitors::ToSql
+          #   include ::Arel::Visitors::BindVisitor
+          # end
+          return const_get(:BindSubstitution) if const_defined?(:BindSubstitution)
+
+          @@bind_substitutions ||= Java::JavaUtil::HashMap.new
+          unless bind_visitor = @@bind_substitutions.get(visitor)
+            @@bind_substitutions.synchronized do
+              unless @@bind_substitutions.get(visitor)
+                bind_visitor = Class.new(visitor) do
+                  include ::Arel::Visitors::BindVisitor
+                end
+                @@bind_substitutions.put(visitor, bind_visitor)
+              end
+            end
+            bind_visitor = @@bind_substitutions.get(visitor)
+          end
+          bind_visitor
+        end
+
+        begin
+          require 'arel/visitors/bind_visitor'
+        rescue LoadError # AR-3.0
+          def bind_substitution(visitor); visitor; end
+        end
+
+      end
+
+      if defined? ::Arel::Visitors::VISITORS
+
+        # Instantiates a new AREL visitor for this adapter.
+        # @note On `ActiveRecord` **2.3** this method won't be used.
+        def new_visitor
+          visitor = self.class.resolve_visitor_type(config)
+          ( prepared_statements? ? visitor : bind_substitution(visitor) ).new(self)
+        end
+        protected :new_visitor
+
+        def bind_substitution(visitor); self.class.bind_substitution(visitor); end
+        private :bind_substitution
+
+        # @override ActiveRecord's convention
+        def unprepared_visitor
+          # super does self.class::BindSubstitution.new self
+          # we do not require the BindSubstitution constant - auto-generated :
+          visitor = self.class.resolve_visitor_type(config)
+          bind_substitution(visitor).new(self)
+        end
+
+      else # NO-OP when no AREL (AR-2.3)
+
+        # @private documented above
+        def new_visitor; end
+
+      end
+
+    end
+  end
+end

data/lib/arjdbc/jdbc/base_ext.rb

@@ -0,0 +1,34 @@
+module ActiveRecord
+  # ActiveRecord::Base extensions.
+  Base.class_eval do
+    class << self
+      # Allow adapters to provide their own {#reset_column_information} method.
+      # @note This only affects the current thread's connection.
+      def reset_column_information_with_arjdbc # :nodoc:
+        # invoke the adapter-specific reset_column_information method
+        connection.reset_column_information if connection.respond_to?(:reset_column_information)
+        reset_column_information_without_arjdbc
+      end
+      unless method_defined?("reset_column_information_without_arjdbc")
+        alias_method_chain :reset_column_information, :arjdbc
+      end
+    end
+  end
+
+  module ConnectionAdapters
+    # Allows properly re-defining methods that may already be alias-chain-ed.
+    # Query caching works even with overriden alias_method_chain'd methods.
+    # @private
+    module ShadowCoreMethods
+      def alias_chained_method(name, feature, target)
+        # NOTE: aliasing for things such as columns (with feature query_cache)
+        # seems to only be used for 2.3 since 3.0 methods are not aliased ...
+        if method_defined?(method = "#{name}_without_#{feature}")
+          alias_method method, target
+        else
+          alias_method name, target if name.to_s != target.to_s
+        end
+      end
+    end
+  end
+end

data/lib/arjdbc/jdbc/callbacks.rb

@@ -0,0 +1,52 @@
+module ActiveRecord::ConnectionAdapters
+  module Jdbc
+    # ActiveRecord connection pool callbacks for JDBC.
+    # @see ActiveRecord::ConnectionAdapters::Jdbc::JndiConnectionPoolCallbacks
+    module ConnectionPoolCallbacks
+
+      def self.included(base)
+        if base.respond_to?(:set_callback) # Rails 3 callbacks
+          base.set_callback :checkin, :after, :on_checkin
+          base.set_callback :checkout, :before, :on_checkout
+        else
+          base.checkin :on_checkin
+          base.checkout :on_checkout
+        end
+      end
+
+      def on_checkin
+        # default implementation does nothing
+      end
+
+      def on_checkout
+        # default implementation does nothing
+      end
+
+    end
+    # JNDI specific connection pool callbacks that make sure the JNDI connection
+    # is disconnected on check-in and looked up (re-connected) on-checkout.
+    module JndiConnectionPoolCallbacks
+
+      def self.prepare(adapter, connection)
+        if adapter.is_a?(ConnectionPoolCallbacks) && connection.jndi?
+          adapter.extend self # extend JndiConnectionPoolCallbacks
+          #connection.disconnect! #if connection.open? # close initial (JNDI) connection
+          connection.disconnect! if connection.open? # close initial (JNDI) connection
+        end
+      end
+
+      def on_checkin
+        disconnect!
+      end
+
+      def on_checkout
+        reconnect!
+      end
+    end
+
+  end
+  # @deprecated use {ActiveRecord::ConnectionAdapters::Jdbc::ConnectionPoolCallbacks}
+  JdbcConnectionPoolCallbacks = Jdbc::ConnectionPoolCallbacks
+  # @deprecated use {ActiveRecord::ConnectionAdapters::Jdbc::JndiConnectionPoolCallbacks}
+  JndiConnectionPoolCallbacks = Jdbc::JndiConnectionPoolCallbacks
+end

data/lib/arjdbc/jdbc/column.rb

@@ -0,0 +1,83 @@
+module ActiveRecord
+  module ConnectionAdapters
+    module Jdbc
+      autoload :TypeCast, 'arjdbc/jdbc/type_cast'
+    end
+    # The base class for all of {JdbcAdapter}'s returned columns.
+    # Instances of {JdbcColumn} will get extended with "column-spec" modules
+    # (similar to how {JdbcAdapter} gets spec modules in) if the adapter spec
+    # module provided a `column_selector` (matcher) method for it's database
+    # specific type.
+    # @see JdbcAdapter#jdbc_column_class
+    class JdbcColumn < Column
+      # @deprecated attribute writers will be removed in 1.4
+      attr_writer :limit, :precision # unless ArJdbc::AR42
+
+      def initialize(config, name, *args)
+        if self.class == JdbcColumn
+          # NOTE: extending classes do not want this if they do they shall call
+          call_discovered_column_callbacks(config) if config
+          default = args.shift
+        else # for extending classes allow ignoring first argument :
+          if ! config.nil? && ! config.is_a?(Hash)
+            default = name; name = config # initialize(name, default, *args)
+          else
+            default = args.shift
+          end
+        end
+        default = default_value(default)
+
+        # super <= 4.1: (name, default, sql_type = nil, null = true)
+        # super >= 4.2: (name, default, cast_type, sql_type = nil, null = true)
+        super(name, default, *args)
+        init_column(name, default, *args)
+      end
+
+      # Additional column initialization for sub-classes.
+      def init_column(*args); end
+
+      # Similar to `ActiveRecord`'s `extract_value_from_default(default)`.
+      # @return default value for a column (possibly extracted from driver value)
+      def default_value(value); value; end
+
+      protected
+
+      # @private
+      def call_discovered_column_callbacks(config)
+        dialect = (config[:dialect] || config[:driver]).to_s
+        for matcher, block in self.class.column_types
+          block.call(config, self) if matcher === dialect
+        end
+      end
+
+      public
+
+      # Returns the available column types
+      # @return [Hash] of (matcher, block) pairs
+      def self.column_types
+        types = {}
+        for mod in ::ArJdbc.modules
+          if mod.respond_to?(:column_selector)
+            sel = mod.column_selector # [ matcher, block ]
+            types[ sel[0] ] = sel[1]
+          end
+        end
+        types
+      end
+
+      class << self
+
+        include Jdbc::TypeCast if ::ActiveRecord::VERSION::STRING >= '4.2'
+
+        if ActiveRecord::VERSION::MAJOR > 3 && ActiveRecord::VERSION::STRING < '4.2'
+
+          # @private provides compatibility between AR 3.x/4.0 API
+          def string_to_date(value); value_to_date(value) end
+
+        end
+
+      end
+
+    end
+  end
+end

data/lib/arjdbc/jdbc/connection.rb

@@ -0,0 +1,26 @@
+module ActiveRecord
+  module ConnectionAdapters
+    # JDBC (connection) base class, custom adapters we support likely extend
+    # this class. For maximum performance most of this class and the sub-classes
+    # we ship are implemented in "native" Java, check: *RubyJdbcConnection.java*
+    class JdbcConnection
+
+      # @deprecated no longer used (pass adapter into #initialize)
+      # @see ActiveRecord::ConnectionAdapters::JdbcAdapter#initialize
+      def adapter=(adapter)
+        ArJdbc.deprecate "adapter= will be removed, please pass adapter on JdbcConnection#initialize(config, adapter)"
+        set_adapter adapter
+      end
+
+      def native_database_types
+        JdbcTypeConverter.new(supported_data_types).choose_best_types
+      end
+
+      # @deprecated no longer used - only kept for compatibility
+      def set_native_database_types
+        ArJdbc.deprecate "set_native_database_types is no longer used and does nothing override native_database_types instead"
+      end
+
+    end
+  end
+end

data/lib/arjdbc/jdbc/connection_methods.rb

@@ -0,0 +1,59 @@
+module ArJdbc
+  if ActiveRecord.const_defined? :ConnectionHandling # 4.0
+    ConnectionMethods = ActiveRecord::ConnectionHandling
+  else # 3.x
+    ConnectionMethods = (class << ActiveRecord::Base; self; end)
+  end
+  ConnectionMethods.module_eval do
+
+    def jdbc_connection(config)
+      adapter_class = config[:adapter_class] || begin
+        if config[:adapter] == 'jdbc' && adapter = supported_adapter(config)
+          ArJdbc.deprecate("please update your **adapter: jdbc** configuration to adapter: #{adapter}", true)
+        end
+        ::ActiveRecord::ConnectionAdapters::JdbcAdapter
+      end
+      adapter_class.new(nil, logger, config)
+    end
+
+    def jndi_connection(config)
+      if config[:adapter] == 'jndi'
+        ArJdbc.deprecate("please change your **adapter: jndi** configuration to " <<
+            "the concrete adapter you're wish to use with jndi: '#{config[:jndi]}'", true)
+      end
+      jdbc_connection(config)
+    end
+
+    def embedded_driver(config)
+      config[:username] ||= 'sa'
+      config[:password] ||= ''
+      jdbc_connection(config)
+    end
+
+    private
+
+    def jndi_config?(config)
+      ::ActiveRecord::ConnectionAdapters::JdbcConnection.jndi_config?(config)
+    end
+
+    def supported_adapter(config)
+      return unless driver = config[:driver]
+      case driver
+      when 'com.ibm.db2.jcc.DB2Driver' then 'db2'
+      when /derby/ then 'derby' # 'org.apache.derby.jdbc.EmbeddedDriver'
+      when 'org.firebirdsql.jdbc.FBDriver' then 'firebird'
+      when 'org.h2.Driver' then 'h2'
+      when 'org.hsqldb.jdbcDriver' then 'hsqldb'
+      when 'net.sourceforge.jtds.jdbc.Driver' then 'mssql'
+      when 'com.microsoft.sqlserver.jdbc.SQLServerDriver' then 'sqlserver'
+      when /mysql/ then 'mysql' # 'com.mysql.jdbc.Driver/NonRegisteringDriver'
+      when /mariadb/ then 'mariadb' # 'org.mariadb.jdbc.Driver'
+      when /oracle/ then 'oracle' # 'oracle.jdbc.driver.OracleDriver'
+      when /postgre/i then 'postgresql' # 'org.postgresql.Driver'
+      when /sqlite/i then 'sqlite3' # 'org.sqlite.JDBC'
+      else false
+      end
+    end
+
+  end
+end