activerecord-jdbc-adapter 0.9.7-java → 1.0.0.beta1-java

data/lib/arjdbc/h2.rb

@@ -0,0 +1,4 @@
+require 'arjdbc/jdbc'
+jdbc_require_driver 'jdbc/h2'
+require 'arjdbc/h2/connection_methods'
+require 'arjdbc/h2/adapter'

data/lib/arjdbc/h2/adapter.rb

@@ -0,0 +1,15 @@
+require 'arjdbc/hsqldb/adapter'
+
+module ArJdbc
+  module H2
+    include HSQLDB
+
+    def adapter_name #:nodoc:
+      'H2'
+    end
+
+    def h2_adapter
+      true
+    end
+  end
+end

data/lib/arjdbc/h2/connection_methods.rb

@@ -0,0 +1,12 @@
+module ActiveRecord
+  class Base
+    class << self
+      def h2_connection(config)
+        config[:url] ||= "jdbc:h2:#{config[:database]}"
+        config[:driver] ||= "org.h2.Driver"
+        embedded_driver(config)
+      end
+      alias_method :jdbch2_connection, :h2_connection
+    end
+  end
+end

data/lib/arjdbc/hsqldb.rb

@@ -0,0 +1,4 @@
+require 'arjdbc/jdbc'
+jdbc_require_driver 'jdbc/hsqldb'
+require 'arjdbc/hsqldb/connection_methods'
+require 'arjdbc/hsqldb/adapter'

data/lib/{jdbc_adapter/jdbc_hsqldb.rb → arjdbc/hsqldb/adapter.rb}

@@ -1,33 +1,7 @@
-module ::JdbcSpec
-  module ActiveRecordExtensions
-    def hsqldb_connection(config)
-      require File.dirname(__FILE__) + "/../active_record/connection_adapters/hsqldb_adapter"
-      config[:url] ||= "jdbc:hsqldb:#{config[:database]}"
-      config[:driver] ||= "org.hsqldb.jdbcDriver"
-      embedded_driver(config)
-    end
-
-    def h2_connection(config)
-      require File.dirname(__FILE__) + "/../active_record/connection_adapters/h2_adapter"
-      config[:url] ||= "jdbc:h2:#{config[:database]}"
-      config[:driver] ||= "org.h2.Driver"
-      embedded_driver(config)
-    end
-  end
-
+module ::ArJdbc
   module HSQLDB
-    def self.extended(mod)
-      mod.class.class_eval do
-        alias_chained_method :insert, :query_dirty, :insert
-      end
-    end
-
-    def self.adapter_matcher(name, *)
-      name =~ /hsqldb/i ? self : false
-    end
-
     def self.column_selector
-      [/hsqldb|\.h2\./i, lambda {|cfg,col| col.extend(::JdbcSpec::HSQLDB::Column)}]
+      [/hsqldb|\.h2\./i, lambda {|cfg,col| col.extend(::ArJdbc::HSQLDB::Column)}]
     end
 
     module Column
@@ -63,7 +37,7 @@ module ::JdbcSpec
     end
 
     def adapter_name #:nodoc:
-      defined?(::Jdbc::H2) ? 'H2' : 'Hsqldb'
+      'Hsqldb'
     end
 
     def modify_types(tp)
@@ -159,27 +133,13 @@ module ::JdbcSpec
       execute "ALTER TABLE #{name} RENAME TO #{new_name}"
     end
 
-    def insert(sql, name = nil, pk = nil, id_value = nil, sequence_name = nil) #:nodoc:
-      log(sql,name) do
-        @connection.execute_update(sql)
-      end
-      table = sql.split(" ", 4)[2]
-      id_value || last_insert_id(table, nil)
-    end
-
-    def last_insert_id(table, sequence_name)
+    def last_insert_id
       Integer(select_value("CALL IDENTITY()"))
     end
 
-    # Override normal #_execute: See Rubyforge #11567
     def _execute(sql, name = nil)
-      if ::ActiveRecord::ConnectionAdapters::JdbcConnection::select?(sql)
-        @connection.execute_query(sql)
-      elsif ::ActiveRecord::ConnectionAdapters::JdbcConnection::insert?(sql)
-        insert(sql, name)
-      else
-        @connection.execute_update(sql)
-      end
+      result = super
+      ActiveRecord::ConnectionAdapters::JdbcConnection::insert?(sql) ? last_insert_id : result
     end
 
     def add_limit_offset!(sql, options) #:nodoc:
@@ -206,16 +166,4 @@ module ::JdbcSpec
       execute "DROP INDEX #{quote_column_name(index_name(table_name, options))}"
     end
   end
-
-  module H2
-    include HSQLDB
-
-    def self.adapter_matcher(name, *)
-      name =~ /\.h2\./i ? self : false
-    end
-
-    def h2_adapter
-      true
-    end
-  end
 end

data/lib/arjdbc/hsqldb/connection_methods.rb

@@ -0,0 +1,14 @@
+module ActiveRecord
+  class Base
+    class << self
+      def hsqldb_connection(config)
+        require "arjdbc/hsqldb"
+        config[:url] ||= "jdbc:hsqldb:#{config[:database]}"
+        config[:driver] ||= "org.hsqldb.jdbcDriver"
+        embedded_driver(config)
+      end
+
+      alias_method :jdbchsqldb_connection, :hsqldb_connection
+    end
+  end
+end

data/lib/arjdbc/informix.rb

@@ -0,0 +1,3 @@
+require 'arjdbc/jdbc'
+require 'arjdbc/informix/connection_methods'
+require 'arjdbc/informix/adapter'

data/lib/{jdbc_adapter/jdbc_informix.rb → arjdbc/informix/adapter.rb}

@@ -4,7 +4,7 @@ module ::ActiveRecord
 
   private
     def write_lobs
-      if connection.is_a?(JdbcSpec::Informix)
+      if connection.is_a?(ArJdbc::Informix)
         self.class.columns.each do |c|
           if [:text, :binary].include? c.type
             value = self[c.name]
@@ -25,28 +25,15 @@ module ::ActiveRecord
   end
 end
 
-module ::JdbcSpec
-  module ActiveRecordExtensions
-    def informix_connection(config)
-      config[:port] ||= 9088
-      config[:url] ||= "jdbc:informix-sqli://#{config[:host]}:#{config[:port]}/#{config[:database]}:INFORMIXSERVER=#{config[:servername]}"
-      config[:driver] = 'com.informix.jdbc.IfxDriver'
-      jdbc_connection(config)
-    end
-  end
-
+module ::ArJdbc
   module Informix
     def self.extended(base)
       @@db_major_version = base.select_one("SELECT dbinfo('version', 'major') version FROM systables WHERE tabid = 1")['version'].to_i
     end
 
-    def self.adapter_matcher(name, *)
-      name =~ /informix/i ? self : false
-    end
-
     def self.column_selector
       [ /informix/i,
-        lambda { |cfg, column| column.extend(::JdbcSpec::Informix::Column) } ]
+        lambda { |cfg, column| column.extend(::ArJdbc::Informix::Column) } ]
     end
 
     module Column
@@ -123,12 +110,12 @@ module ::JdbcSpec
       super(name, options)
       execute("CREATE SEQUENCE #{name}_seq")
     end
- 
+
     def rename_table(name, new_name)
       execute("RENAME TABLE #{name} TO #{new_name}")
       execute("RENAME SEQUENCE #{name}_seq TO #{new_name}_seq")
     end
- 
+
     def drop_table(name)
       super(name)
       execute("DROP SEQUENCE #{name}_seq")
@@ -144,4 +131,4 @@ module ::JdbcSpec
       execute(sql.gsub(/(!=|<>)\s*null/i, "IS NOT NULL").gsub(/=\s*null/i, "IS NULL"), name)
     end
   end # module Informix
-end # module ::JdbcSpec
+end # module ::ArJdbc

data/lib/arjdbc/informix/connection_methods.rb

@@ -0,0 +1,10 @@
+class ActiveRecord::Base
+  class << self
+    def informix_connection(config)
+      config[:port] ||= 9088
+      config[:url] ||= "jdbc:informix-sqli://#{config[:host]}:#{config[:port]}/#{config[:database]}:INFORMIXSERVER=#{config[:servername]}"
+      config[:driver] = 'com.informix.jdbc.IfxDriver'
+      jdbc_connection(config)
+    end
+  end
+end

data/lib/arjdbc/jdbc.rb

@@ -0,0 +1,2 @@
+require 'arjdbc/jdbc/adapter'
+require 'arjdbc/jdbc/discover'

data/lib/arjdbc/jdbc/adapter.rb

@@ -0,0 +1,235 @@
+require 'active_record/version'
+require 'active_record/connection_adapters/abstract_adapter'
+require 'arjdbc/version'
+require 'arjdbc/jdbc/require_driver'
+require 'arjdbc/jdbc/connection_methods'
+require 'arjdbc/jdbc/compatibility'
+require 'arjdbc/jdbc/core_ext'
+require 'arjdbc/jdbc/java'
+require 'arjdbc/jdbc/type_converter'
+require 'arjdbc/jdbc/driver'
+require 'arjdbc/jdbc/column'
+require 'arjdbc/jdbc/connection'
+require 'arjdbc/jdbc/callbacks'
+require 'arjdbc/jdbc/extension'
+require 'bigdecimal'
+
+module ActiveRecord
+  module ConnectionAdapters
+    class JdbcAdapter < AbstractAdapter
+      extend ShadowCoreMethods
+      include CompatibilityMethods if CompatibilityMethods.needed?(self)
+      include JdbcConnectionPoolCallbacks if JdbcConnectionPoolCallbacks.needed?
+
+      attr_reader :config
+
+      def initialize(connection, logger, config)
+        @config = config
+        spec = adapter_spec config
+        unless connection
+          connection_class = jdbc_connection_class spec
+          connection = connection_class.new config
+        end
+        super(connection, logger)
+        extend spec if spec
+        connection.adapter = self
+        JndiConnectionPoolCallbacks.prepare(self, connection)
+      end
+
+      def jdbc_connection_class(spec)
+        connection_class = spec.jdbc_connection_class if spec && spec.respond_to?(:jdbc_connection_class)
+        connection_class = ::ActiveRecord::ConnectionAdapters::JdbcConnection unless connection_class
+        connection_class
+      end
+
+      def jdbc_column_class
+        ActiveRecord::ConnectionAdapters::JdbcColumn
+      end
+
+      # Locate specialized adapter specification if one exists based on config data
+      def adapter_spec(config)
+        dialect = (config[:dialect] || config[:driver]).to_s
+        ::ArJdbc.constants.map { |name| ::ArJdbc.const_get name }.each do |constant|
+          if constant.respond_to? :adapter_matcher
+            spec = constant.adapter_matcher(dialect, config)
+            return spec if spec
+          end
+        end
+        nil
+      end
+
+      def modify_types(tp)
+        tp
+      end
+
+      def adapter_name #:nodoc:
+        'JDBC'
+      end
+
+      def is_a?(klass)          # :nodoc:
+        # This is to fake out current_adapter? conditional logic in AR tests
+        if Class === klass && klass.name =~ /#{adapter_name}Adapter$/i
+          true
+        else
+          super
+        end
+      end
+
+      def supports_migrations?
+        true
+      end
+
+      def native_database_types #:nodoc:
+        @connection.native_database_types
+      end
+
+      def database_name #:nodoc:
+        @connection.database_name
+      end
+
+      def native_sql_to_type(tp)
+        if /^(.*?)\(([0-9]+)\)/ =~ tp
+          tname = $1
+          limit = $2.to_i
+          ntype = native_database_types
+          if ntype[:primary_key] == tp
+            return :primary_key,nil
+          else
+            ntype.each do |name,val|
+              if name == :primary_key
+                next
+              end
+              if val[:name].downcase == tname.downcase && (val[:limit].nil? || val[:limit].to_i == limit)
+                return name,limit
+              end
+            end
+          end
+        elsif /^(.*?)/ =~ tp
+          tname = $1
+          ntype = native_database_types
+          if ntype[:primary_key] == tp
+            return :primary_key,nil
+          else
+            ntype.each do |name,val|
+              if val[:name].downcase == tname.downcase && val[:limit].nil?
+                return name,nil
+              end
+            end
+          end
+        else
+          return :string,255
+        end
+        return nil,nil
+      end
+
+      def active?
+        @connection.active?
+      end
+
+      def reconnect!
+        @connection.reconnect!
+        @connection
+      end
+
+      def disconnect!
+        @connection.disconnect!
+      end
+
+      def execute(sql, name = nil)
+        if name == :skip_logging
+          _execute(sql)
+        else
+          log(sql, name) { _execute(sql) }
+        end
+      end
+
+      # we need to do it this way, to allow Rails stupid tests to always work
+      # even if we define a new execute method. Instead of mixing in a new
+      # execute, an _execute should be mixed in.
+      def _execute(sql, name = nil)
+        @connection.execute(sql)
+      end
+
+      def jdbc_insert(sql, name = nil, pk = nil, id_value = nil, sequence_name = nil)
+        insert_sql(sql, name, pk, id_value, sequence_name)
+      end
+
+      def jdbc_update(sql, name = nil) #:nodoc:
+        execute(sql, name)
+      end
+      def jdbc_select_all(sql, name = nil)
+        select(sql, name)
+      end
+
+      if ActiveRecord::VERSION::MAJOR < 3
+        # Allow query caching to work even when we override alias_method_chain'd methods
+        alias_chained_method :select_all, :query_cache, :jdbc_select_all
+        alias_chained_method :update, :query_dirty, :jdbc_update
+        alias_chained_method :insert, :query_dirty, :jdbc_insert
+
+        # Do we need this? Not in AR 3.
+        def select_one(sql, name = nil)
+          select(sql, name).first
+        end
+      end
+
+      def select_rows(sql, name = nil)
+        rows = []
+        select(sql, name).each {|row| rows << row.values }
+        rows
+      end
+
+      def insert_sql(sql, name = nil, pk = nil, id_value = nil, sequence_name = nil)
+        id = execute(sql, name = nil)
+        id_value || id
+      end
+
+
+      def jdbc_columns(table_name, name = nil)
+        @connection.columns(table_name.to_s)
+      end
+      alias_chained_method :columns, :query_cache, :jdbc_columns
+
+      def tables(name = nil)
+        @connection.tables
+      end
+
+      def indexes(table_name, name = nil, schema_name = nil)
+        @connection.indexes(table_name, name, schema_name)
+      end
+
+      def begin_db_transaction
+        @connection.begin
+      end
+
+      def commit_db_transaction
+        @connection.commit
+      end
+
+      def rollback_db_transaction
+        @connection.rollback
+      end
+
+      def write_large_object(*args)
+        @connection.write_large_object(*args)
+      end
+
+      def pk_and_sequence_for(table)
+        key = primary_key(table)
+        [key, nil] if key
+      end
+
+      def primary_key(table)
+        primary_keys(table).first
+      end
+
+      def primary_keys(table)
+        @connection.primary_keys(table)
+      end
+
+      def select(*args)
+        execute(*args)
+      end
+    end
+  end
+end