activerecord-jdbc-adapter 0.9.2 → 1.1.0

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,36 @@
+require 'arjdbc/hsqldb/adapter'
+
+module ArJdbc
+  module H2
+    include HSQLDB
+
+    def self.jdbc_connection_class
+      ::ActiveRecord::ConnectionAdapters::H2JdbcConnection
+    end
+
+    def adapter_name #:nodoc:
+      'H2'
+    end
+
+    def arel2_visitors
+      super.merge 'h2' => ::Arel::Visitors::HSQLDB, 'jdbch2' => ::Arel::Visitors::HSQLDB
+    end
+
+    def h2_adapter
+      true
+    end
+
+    def tables
+      @connection.tables(nil, h2_schema)
+    end
+
+    def columns(table_name, name=nil)
+      @connection.columns_internal(table_name.to_s, name, h2_schema)
+    end
+
+    private
+    def h2_schema
+      @config[:schema] || ''
+    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,27 +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.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
@@ -32,6 +12,8 @@ module ::JdbcSpec
           :text
         when /tinyint/i
           :boolean
+        when /real/i
+          :float
         else
           super(field_type)
         end
@@ -55,7 +37,12 @@ module ::JdbcSpec
     end
 
     def adapter_name #:nodoc:
-      defined?(::Jdbc::H2) ? 'h2' : 'hsqldb'
+      'Hsqldb'
+    end
+
+    def arel2_visitors
+      require 'arel/visitors/hsqldb'
+      {'hsqldb' => ::Arel::Visitors::HSQLDB, 'jdbchsqldb' => ::Arel::Visitors::HSQLDB}
     end
 
     def modify_types(tp)
@@ -84,7 +71,8 @@ module ::JdbcSpec
           "''"
         elsif column && column.type == :binary
           "'#{value.unpack("H*")}'"
-        elsif column.respond_to?(:primary) && column.primary
+        elsif column && (column.type == :integer ||
+                         column.respond_to?(:primary) && column.primary && column.klass != String)
           value.to_i.to_s
         else
           "'#{quote_string(value)}'"
@@ -116,15 +104,9 @@ module ::JdbcSpec
     end
 
     def add_column(table_name, column_name, type, options = {})
-      if option_not_null = options[:null] == false
-        option_not_null = options.delete(:null)
-      end
       add_column_sql = "ALTER TABLE #{quote_table_name(table_name)} ADD #{quote_column_name(column_name)} #{type_to_sql(type, options[:limit], options[:precision], options[:scale])}"
       add_column_options!(add_column_sql, options)
       execute(add_column_sql)
-      if option_not_null
-        alter_column_sql = "ALTER TABLE #{quote_table_name(table_name)} ALTER #{quote_column_name(column_name)} NOT NULL"
-      end
     end
 
     def change_column(table_name, column_name, type, options = {}) #:nodoc:
@@ -150,36 +132,24 @@ 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:
-      offset = options[:offset] || 0
-      bef = sql[7..-1]
-      if limit = options[:limit]
-        sql.replace "select limit #{offset} #{limit} #{bef}"
-      elsif offset > 0
-        sql.replace "select limit #{offset} 0 #{bef}"
+      if sql =~ /^select/i
+        offset = options[:offset] || 0
+        bef = sql[7..-1]
+        if limit = options[:limit]
+          sql.replace "SELECT LIMIT #{offset} #{limit} #{bef}"
+        elsif offset > 0
+          sql.replace "SELECT LIMIT #{offset} 0 #{bef}"
+        end
       end
     end
 
@@ -196,17 +166,19 @@ module ::JdbcSpec
     def remove_index(table_name, options = {})
       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
+    def recreate_database(name)
+      drop_database(name)
     end
-
-    def h2_adapter
-      true
+    
+    # do nothing since database gets created upon connection. However
+    # this method gets called by rails db rake tasks so now we're
+    # avoiding method_missing error
+    def create_database(name)
     end
+
+    def drop_database(name)
+      execute("DROP ALL OBJECTS")
+    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,19 @@ 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
+
+    def self.jdbc_connection_class
+      ::ActiveRecord::ConnectionAdapters::InformixJdbcConnection
     end
 
     module Column
@@ -123,12 +114,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 +135,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,285 @@
+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
+        configure_arel2_visitors(config)
+        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
+
+      # Retrieve the raw java.sql.Connection object.
+      def jdbc_connection
+        raw_connection.connection
+      end
+
+      # Locate specialized adapter specification if one exists based on config data
+      def adapter_spec(config)
+        2.times do
+          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
+
+          # If nothing matches and we're using jndi, try to automatically detect the database.
+          break unless config[:jndi] and !config[:dialect]
+          begin
+            conn = Java::javax.naming.InitialContext.new.lookup(config[:jndi]).getConnection
+            config[:dialect] = conn.getMetaData.getDatabaseProductName
+
+            # Derby-specific hack
+            if ::ArJdbc::Derby.adapter_matcher(config[:dialect], config)
+              # Needed to set the correct database schema name
+              config[:username] ||= conn.getMetaData.getUserName
+            end
+          rescue
+            conn.close
+          end
+        end
+        nil
+      end
+
+      def modify_types(tp)
+        tp
+      end
+
+      def adapter_name #:nodoc:
+        'JDBC'
+      end
+
+      def arel2_visitors
+        {}
+      end
+
+      def configure_arel2_visitors(config)
+        if defined?(::Arel::Visitors::VISITORS)
+          visitors = ::Arel::Visitors::VISITORS
+          visitor = nil
+          arel2_visitors.each do |k,v|
+            visitor = v
+            visitors[k] = v unless visitors.has_key?(k)
+          end
+          if visitor && config[:adapter] =~ /^(jdbc|jndi)$/
+            visitors[config[:adapter]] = visitor
+          end
+        end
+      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 table_exists?(name)
+        jdbc_columns(name) rescue nil
+      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
+
+      def translate_exception(e, message)
+        puts e.backtrace if $DEBUG || ENV['DEBUG']
+        super
+      end
+      protected :translate_exception
+    end
+  end
+end