activerecord-jdbc-adapter 1.1.3 → 1.2.0

data/bench/bench_new.rb

@@ -0,0 +1,12 @@
+require File.dirname(__FILE__) + '/bench_model'
+
+puts "Widget.new"
+Benchmark.bm do |make|
+  TIMES.times do
+    make.report do
+      100_000.times do
+        Widget.new
+      end
+    end
+  end
+end

data/bench/bench_new_valid.rb

@@ -0,0 +1,12 @@
+require File.dirname(__FILE__) + '/bench_model'
+
+puts "Widget.new.valid?"
+Benchmark.bm do |make|
+  TIMES.times do
+    make.report do
+      100_000.times do
+        Widget.new.valid?
+      end
+    end
+  end
+end

data/bench/bench_valid.rb

@@ -0,0 +1,13 @@
+require File.dirname(__FILE__) + '/bench_model'
+
+puts "Widget.new.valid?"
+Benchmark.bm do |make|
+  TIMES.times do
+    make.report do
+      widget = Widget.new
+      100_000.times do
+        widget.valid?
+      end
+    end
+  end
+end

data/lib/activerecord-jdbc-adapter.rb

@@ -1,5 +1,5 @@
 require 'arjdbc'
-if ActiveRecord::VERSION::MAJOR >= 3
+if defined?(ActiveRecord::VERSION) && ActiveRecord::VERSION::MAJOR >= 3
   begin
     require 'arjdbc/jdbc/railtie'
   rescue LoadError

data/lib/arel/visitors/derby.rb

@@ -7,12 +7,16 @@ module Arel
         [
          o.cores.map { |x| visit_Arel_Nodes_SelectCore x }.join,
          ("ORDER BY #{o.orders.map { |x| visit x }.join(', ')}" unless o.orders.empty?),
-         ("FETCH FIRST #{limit_for(o.limit)} ROWS ONLY" if o.limit),
+         (visit_Arel_Nodes_Limit(o.limit) if o.limit),
          (visit(o.offset) if o.offset),
          (visit(o.lock) if o.lock),
         ].compact.join ' '
       end
 
+      def visit_Arel_Nodes_Limit o
+        "FETCH FIRST #{limit_for(o)} ROWS ONLY"
+      end
+
       def visit_Arel_Nodes_Offset o
         "OFFSET #{visit o.value} ROWS"
       end

data/lib/arjdbc.rb

@@ -1,26 +1,21 @@
 if defined?(JRUBY_VERSION)
   begin
-    tried_gem ||= false
     require 'active_record/version'
-  rescue LoadError
-    raise if tried_gem
-    require 'rubygems'
-    gem 'activerecord'
-    tried_gem = true
-    retry
-  end
-  if ActiveRecord::VERSION::MAJOR < 2
-    if defined?(RAILS_CONNECTION_ADAPTERS)
-      RAILS_CONNECTION_ADAPTERS << %q(jdbc)
+    if ActiveRecord::VERSION::MAJOR < 2
+      if defined?(RAILS_CONNECTION_ADAPTERS)
+        RAILS_CONNECTION_ADAPTERS << %q(jdbc)
+      else
+        RAILS_CONNECTION_ADAPTERS = %w(jdbc)
+      end
+      if ActiveRecord::VERSION::MAJOR == 1 && ActiveRecord::VERSION::MINOR == 14
+        require 'arjdbc/jdbc'
+      end
     else
-      RAILS_CONNECTION_ADAPTERS = %w(jdbc)
-    end
-    if ActiveRecord::VERSION::MAJOR == 1 && ActiveRecord::VERSION::MINOR == 14
+      require 'active_record'
       require 'arjdbc/jdbc'
     end
-  else
-    require 'active_record'
-    require 'arjdbc/jdbc'
+  rescue LoadError
+    warn "activerecord-jdbc-adapter requires ActiveRecord at runtime"
   end
 else
   warn "activerecord-jdbc-adapter is for use with JRuby only"

data/lib/arjdbc/db2/adapter.rb

@@ -1,7 +1,29 @@
 module ArJdbc
   module DB2
+    def self.extended(base)
+      if base.zos?
+        unless @lob_callback_added
+          ActiveRecord::Base.class_eval do
+            def after_save_with_db2zos_blob
+              lobfields = self.class.columns.select { |c| c.sql_type =~ /blob|clob/i }
+              lobfields.each do |c|
+                value = self[c.name]
+                value = value.to_yaml if unserializable_attribute?(c.name, c)
+                next if value.nil?
+                connection.write_large_object(c.type == :binary, c.name, self.class.table_name, self.class.primary_key, quote_value(id), value)
+              end
+            end
+          end
+
+          ActiveRecord::Base.after_save :after_save_with_db2zos_blob
+
+          @lob_callback_added = true
+        end
+      end
+    end
+
     def self.column_selector
-      [ /(db2|as400)/i,
+      [ /(db2|as400|zos)/i,
         lambda { |cfg, column| column.extend(::ArJdbc::DB2::Column) } ]
     end
 
@@ -147,15 +169,53 @@ module ArJdbc
       'DB2'
     end
 
-    def arel2_visitors
+    def self.arel2_visitors(config)
       require 'arel/visitors/db2'
-      {'db2' => ::Arel::Visitors::DB2, 'as400' => ::Arel::Visitors::DB2}
+      {}.tap {|v| %w(db2 as400).each {|a| v[a] = ::Arel::Visitors::DB2 } }
     end
 
     def add_limit_offset!(sql, options)
       replace_limit_offset!(sql, options[:limit], options[:offset])
     end
 
+
+    def create_table(name, options = {}) #:nodoc:
+      if zos?
+        table_definition = ActiveRecord::ConnectionAdapters::TableDefinition.new(self)
+
+        table_definition.primary_key(options[:primary_key] || ActiveRecord::Base.get_primary_key(name)) unless options[:id] == false
+
+        yield table_definition
+
+        # Clobs in DB2 Host have to be created after the Table with an auxiliary Table.
+        # First: Save them for later in Array "clobs"
+        clobs =table_definition.columns.select { |x| x.type == "text" }
+
+        # Second: and delete them from the original Colums-Array
+        table_definition.columns.delete_if { |x| x.type=="text" }
+
+        if options[:force] && table_exists?(name)
+          super.drop_table(name, options)
+        end
+
+        create_sql = "CREATE#{' TEMPORARY' if options[:temporary]} TABLE "
+        create_sql << "#{quote_table_name(name)} ("
+        create_sql << table_definition.to_sql
+        create_sql << ") #{options[:options]}"
+        create_sql << " IN #{@config[:database]}.#{@config[:tablespace]}"
+
+        execute create_sql
+
+        clobs.each do |clob_column|
+          execute "ALTER TABLE #{name+" ADD COLUMN "+clob_column.name.to_s+" clob"}"
+          execute "CREATE AUXILIARY TABLE #{name+"_"+clob_column.name.to_s+"_CD_"} IN #{@config[:database]}.#{@config[:lob_tablespaces][name.split(".")[1]]} STORES #{name} COLUMN "+clob_column.name.to_s
+          execute "CREATE UNIQUE INDEX #{name+"_"+clob_column.name.to_s+"_CD_"} ON #{name+"_"+clob_column.name.to_s+"_CD_"};"
+        end
+      else
+        super(name, options)
+      end
+    end
+
     def replace_limit_offset!(sql, limit, offset)
       if limit
         limit = limit.to_i
@@ -200,7 +260,11 @@ module ArJdbc
         if column && column.type == :binary
           "BLOB('#{quote_string(value)}')"
         else
-          "'#{quote_string(value)}'"
+          if zos? && column.type == :text
+            "'if_you_see_this_value_the_after_save_hook_in_db2_zos_adapter_went_wrong'"
+          else
+            "'#{quote_string(value)}'"
+          end
         end
       else super
       end
@@ -228,6 +292,21 @@ module ArJdbc
       tables.each {|table| drop_table("#{db2_schema}.#{table}")}
     end
 
+    def add_index(table_name, column_name, options = {})
+      if (!zos? || (table_name.to_s ==  ActiveRecord::Migrator.schema_migrations_table_name.to_s))
+        super
+      else
+        statement ="CREATE"
+        statement << " UNIQUE " if options[:unique]
+        statement << " INDEX "+"#{ActiveRecord::Base.table_name_prefix}#{options[:name]} "
+
+        statement << " ON #{table_name}(#{column_name})"
+
+        execute statement
+      end
+    end
+
+
     def remove_index(table_name, options = { })
       execute "DROP INDEX #{quote_column_name(index_name(table_name, options))}"
     end
@@ -311,6 +390,10 @@ module ArJdbc
     def columns(table_name, name = nil)
       cols = @connection.columns(table_name, name, db2_schema)
 
+      if zos?
+        # Remove the mighty db2_generated_rowid_for_lobs from the list of columns
+        cols = cols.reject { |col| "db2_generated_rowid_for_lobs" == col.name }
+      end
       # scrub out sizing info when CREATE TABLE doesn't support it
       # but JDBC reports it (doh!)
       for col in cols
@@ -398,6 +481,10 @@ module ArJdbc
       definition
     end
 
+    def zos?
+      @config[:driver] == "com.ibm.db2.jcc.DB2Driver"
+    end
+
     private
     def as400?
         @config[:url] =~ /^jdbc:as400:/

data/lib/arjdbc/derby/adapter.rb

@@ -7,7 +7,7 @@ module ::ArJdbc
     end
 
     def self.monkey_rails
-      unless @already_monkeyd
+      unless defined?(@already_monkeyd)
         # Needed because Rails is broken wrt to quoting of
         # some values. Most databases are nice about it,
         # but not Derby. The real issue is that you can't
@@ -50,7 +50,7 @@ module ::ArJdbc
       def default_value(value)
         # jdbc returns column default strings with actual single quotes around the value.
         return $1 if value =~ /^'(.*)'$/
-
+        return nil if value == "GENERATED_BY_DEFAULT"
         value
       end
     end
@@ -59,9 +59,9 @@ module ::ArJdbc
       'Derby'
     end
 
-    def arel2_visitors
+    def self.arel2_visitors(config)
       require 'arel/visitors/derby'
-      {'derby' => ::Arel::Visitors::Derby, 'jdbcderby' => ::Arel::Visitors::Derby}
+      {}.tap {|v| %w(derby jdbcderby).each {|a| v[a] = ::Arel::Visitors::Derby } }
     end
 
     include ArJdbc::MissingFunctionalityHelper
@@ -171,7 +171,8 @@ module ::ArJdbc
       execute(add_column_sql)
     end
 
-    def execute(sql, name = nil)
+    def execute(sql, name = nil, binds = [])
+      sql = extract_sql(sql)
       if sql =~ /\A\s*(UPDATE|INSERT)/i
         i = sql =~ /\swhere\s/im
         if i
@@ -196,8 +197,7 @@ module ::ArJdbc
 
       # construct a clean list of column names from the ORDER BY clause, removing
       # any asc/desc modifiers
-      order_columns = order_by.split(',').collect { |s| s.split.first }
-      order_columns.delete_if(&:blank?)
+      order_columns = [order_by].flatten.map{|o| o.split(',').collect { |s| s.split.first } }.flatten.reject(&:blank?)
       order_columns = order_columns.zip((0...order_columns.size).to_a).map { |s,i| "#{s} AS alias_#{i}" }
 
       # return a DISTINCT clause that's distinct on the columns we want but includes
@@ -316,7 +316,7 @@ module ::ArJdbc
     end
 
     def quote_column_name(name) #:nodoc:
-      %Q{"#{name.to_s.upcase.gsub(/"/, '""')}"}
+      %Q{"#{name.to_s.upcase.gsub(/\"/, '""')}"}
     end
 
     def quoted_true

data/lib/arjdbc/derby/connection_methods.rb

@@ -4,6 +4,7 @@ module ActiveRecord
       def derby_connection(config)
         config[:url] ||= "jdbc:derby:#{config[:database]};create=true"
         config[:driver] ||= "org.apache.derby.jdbc.EmbeddedDriver"
+        config[:adapter_spec] = ::ArJdbc::Derby
         conn = embedded_driver(config)
         md = conn.jdbc_connection.meta_data
         if md.database_major_version < 10 || (md.database_major_version == 10 && md.database_minor_version < 5)

data/lib/arjdbc/firebird/adapter.rb

@@ -23,9 +23,9 @@ module ::ArJdbc
       'Firebird'
     end
 
-    def arel2_visitors
+    def self.arel2_visitors(config)
       require 'arel/visitors/firebird'
-      {'firebird' => ::Arel::Visitors::Firebird, 'firebirdsql' => ::Arel::Visitors::Firebird}
+      {}.tap {|v| %w(firebird firebirdsql).each {|a| v[a] = ::Arel::Visitors::Firebird } }
     end
 
     def modify_types(tp)
@@ -35,8 +35,8 @@ module ::ArJdbc
       tp
     end
 
-    def insert(sql, name = nil, pk = nil, id_value = nil, sequence_name = nil) # :nodoc:
-      execute(sql, name)
+    def insert(sql, name = nil, pk = nil, id_value = nil, sequence_name = nil, binds = []) # :nodoc:
+      execute(sql, name, binds)
       id_value
     end
 

data/lib/arjdbc/h2/adapter.rb

@@ -12,8 +12,9 @@ module ArJdbc
       'H2'
     end
 
-    def arel2_visitors
-      super.merge 'h2' => ::Arel::Visitors::HSQLDB, 'jdbch2' => ::Arel::Visitors::HSQLDB
+    def self.arel2_visitors(config)
+      v = HSQLDB.arel2_visitors(config)
+      v.merge({}.tap {|v| %w(h2 jdbch2).each {|a| v[a] = ::Arel::Visitors::HSQLDB } })
     end
 
     def h2_adapter

data/lib/arjdbc/h2/connection_methods.rb

@@ -4,6 +4,7 @@ module ActiveRecord
       def h2_connection(config)
         config[:url] ||= "jdbc:h2:#{config[:database]}"
         config[:driver] ||= "org.h2.Driver"
+        config[:adapter_spec] = ::ArJdbc::H2
         embedded_driver(config)
       end
       alias_method :jdbch2_connection, :h2_connection

data/lib/arjdbc/hsqldb/adapter.rb

@@ -27,6 +27,9 @@ module ::ArJdbc
 
       # Post process default value from JDBC into a Rails-friendly format (columns{-internal})
       def default_value(value)
+        # H2 auto-generated key default value
+        return nil if value =~ /^\(NEXT VALUE FOR/i
+
         # jdbc returns column default strings with actual single quotes around the value.
         return $1 if value =~ /^'(.*)'$/
 
@@ -38,9 +41,9 @@ module ::ArJdbc
       'Hsqldb'
     end
 
-    def arel2_visitors
+    def self.arel2_visitors(config)
       require 'arel/visitors/hsqldb'
-      {'hsqldb' => ::Arel::Visitors::HSQLDB, 'jdbchsqldb' => ::Arel::Visitors::HSQLDB}
+      {}.tap {|v| %w(hsqldb jdbchsqldb).each {|a| v[a] = ::Arel::Visitors::HSQLDB } }
     end
 
     def modify_types(tp)

data/lib/arjdbc/hsqldb/connection_methods.rb

@@ -5,6 +5,7 @@ module ActiveRecord
         require "arjdbc/hsqldb"
         config[:url] ||= "jdbc:hsqldb:#{config[:database]}"
         config[:driver] ||= "org.hsqldb.jdbcDriver"
+        config[:adapter_spec] = ::ArJdbc::HSQLDB
         embedded_driver(config)
       end
 

data/lib/arjdbc/informix/adapter.rb

@@ -130,9 +130,9 @@ module ::ArJdbc
     end
 
   private
-    def select(sql, name = nil)
+    def select(sql, *rest)
       # Informix does not like "= NULL", "!= NULL", or "<> NULL".
-      execute(sql.gsub(/(!=|<>)\s*null/i, "IS NOT NULL").gsub(/=\s*null/i, "IS NULL"), name)
+      execute(sql.gsub(/(!=|<>)\s*null/i, "IS NOT NULL").gsub(/=\s*null/i, "IS NULL"), *rest)
     end
   end # module Informix
 end # module ::ArJdbc

data/lib/arjdbc/informix/connection_methods.rb

@@ -4,6 +4,7 @@ class ActiveRecord::Base
       config[:port] ||= 9088
       config[:url] ||= "jdbc:informix-sqli://#{config[:host]}:#{config[:port]}/#{config[:database]}:INFORMIXSERVER=#{config[:servername]}"
       config[:driver] = 'com.informix.jdbc.IfxDriver'
+      config[:adapter_spec] = ::ArJdbc::Informix
       jdbc_connection(config)
     end
   end

data/lib/arjdbc/jdbc/adapter.rb

@@ -25,13 +25,16 @@ module ActiveRecord
 
       def initialize(connection, logger, config)
         @config = config
-        spec = adapter_spec config
+        spec = config[:adapter_spec] || adapter_spec(config)
+        config[:adapter_spec] ||= spec
         unless connection
           connection_class = jdbc_connection_class spec
           connection = connection_class.new config
         end
         super(connection, logger)
-        extend spec if spec
+        if spec && (config[:adapter_class].nil? || config[:adapter_class] == JdbcAdapter)
+          extend spec
+        end
         configure_arel2_visitors(config)
         connection.adapter = self
         JndiConnectionPoolCallbacks.prepare(self, connection)
@@ -89,15 +92,27 @@ module ActiveRecord
         'JDBC'
       end
 
-      def arel2_visitors
-        {}
+      def self.visitor_for(pool)
+        config = pool.spec.config
+        adapter = config[:adapter]
+        adapter_spec = config[:adapter_spec] || self
+        if adapter =~ /^(jdbc|jndi)$/
+          adapter_spec.arel2_visitors(config).values.first.new(pool)
+        else
+          adapter_spec.arel2_visitors(config)[adapter].new(pool)
+        end
+      end
+
+      def self.arel2_visitors(config)
+        { 'jdbc' => ::Arel::Visitors::ToSql }
       end
 
       def configure_arel2_visitors(config)
         if defined?(::Arel::Visitors::VISITORS)
           visitors = ::Arel::Visitors::VISITORS
           visitor = nil
-          arel2_visitors.each do |k,v|
+          adapter_spec = config[:adapter_spec] || self
+          adapter_spec.arel2_visitors(config).each do |k,v|
             visitor = v
             visitors[k] = v
           end
@@ -176,7 +191,17 @@ module ActiveRecord
         @connection.disconnect!
       end
 
-      def execute(sql, name = nil)
+      def substitute_binds(manager, binds = [])
+        sql = extract_sql(manager)
+        if binds.empty?
+          sql
+        else
+          sql.gsub('?') { quote(*binds.shift.reverse) }
+        end
+      end
+
+      def execute(sql, name = nil, binds = [])
+        sql = substitute_binds(sql, binds)
         if name == :skip_logging
           _execute(sql)
         else
@@ -191,25 +216,31 @@ module ActiveRecord
         @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)
+      def jdbc_insert(sql, name = nil, pk = nil, id_value = nil, sequence_name = nil, binds = [])
+        insert_sql(sql, name, pk, id_value, sequence_name, binds)
       end
 
-      def jdbc_update(sql, name = nil) #:nodoc:
-        execute(sql, name)
+      def jdbc_update(sql, name = nil, binds = []) #:nodoc:
+        execute(sql, name, binds)
       end
-      def jdbc_select_all(sql, name = nil)
-        select(sql, name)
+      def jdbc_select_all(sql, name = nil, binds = [])
+        select(sql, name, binds)
       end
 
-      # 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
+      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
 
-      # Do we need this? Not in AR 3.
-      def select_one(sql, name = nil)
-        select(sql, name).first
+      def last_inserted_id(result)
+        result
       end
 
       def select_rows(sql, name = nil)
@@ -218,11 +249,41 @@ module ActiveRecord
         rows
       end
 
-      def insert_sql(sql, name = nil, pk = nil, id_value = nil, sequence_name = nil)
-        id = execute(sql, name = nil)
+      def insert_sql(sql, name = nil, pk = nil, id_value = nil, sequence_name = nil, binds = [])
+        id = execute(sql, name = nil, binds)
         id_value || id
       end
 
+      ### Rails 3.1 prepared statement support
+
+      # Executes +sql+ statement in the context of this connection using
+      # +binds+ as the bind substitutes.  +name+ is logged along with
+      # the executed +sql+ statement.
+      def exec_query(sql, name = 'SQL', binds = [])
+        execute(sql, name, binds)
+      end
+
+      # Executes insert +sql+ statement in the context of this connection using
+      # +binds+ as the bind substitutes. +name+ is the logged along with
+      # the executed +sql+ statement.
+      def exec_insert(sql, name, binds)
+        exec_query(sql, name, binds)
+      end
+
+      # Executes delete +sql+ statement in the context of this connection using
+      # +binds+ as the bind substitutes. +name+ is the logged along with
+      # the executed +sql+ statement.
+      def exec_delete(sql, name, binds)
+        exec_query(sql, name, binds)
+      end
+
+      # Executes update +sql+ statement in the context of this connection using
+      # +binds+ as the bind substitutes. +name+ is the logged along with
+      # the executed +sql+ statement.
+      def exec_update(sql, name, binds)
+        exec_query(sql, name, binds)
+      end
+
       def jdbc_columns(table_name, name = nil)
         @connection.columns(table_name.to_s)
       end
@@ -277,7 +338,16 @@ module ActiveRecord
         puts e.backtrace if $DEBUG || ENV['DEBUG']
         super
       end
-      protected :translate_exception
+
+      def extract_sql(obj)
+        if obj.respond_to? :to_sql
+          obj.send :to_sql
+        else
+          obj
+        end
+      end
+
+      protected :translate_exception, :extract_sql
     end
   end
 end