activerecord-jdbc-adapter 1.2.5 → 1.2.8

data/lib/arjdbc/hsqldb/connection_methods.rb

@@ -2,7 +2,11 @@ module ActiveRecord
   class Base
     class << self
       def hsqldb_connection(config)
-        require 'active_record/connection_adapters/jdbchsqldb_adapter'
+        begin
+          require 'jdbc/hsqldb'
+          ::Jdbc::HSQLDB.load_driver(:require) if defined?(::Jdbc::HSQLDB.load_driver)
+        rescue LoadError # assuming driver.jar is on the class-path
+        end
 
         config[:url] ||= "jdbc:hsqldb:#{config[:database]}"
         config[:driver] ||= defined?(::Jdbc::HSQLDB.driver_name) ? ::Jdbc::HSQLDB.driver_name : 'org.hsqldb.jdbcDriver'

data/lib/arjdbc/hsqldb/explain_support.rb

@@ -0,0 +1,35 @@
+module ArJdbc
+  module HSQLDB
+    module ExplainSupport
+      def supports_explain?; true; end
+      
+      def explain(arel, binds = [])
+        sql = "EXPLAIN PLAN FOR #{to_sql(arel, binds)}"
+        raw_result  = execute(sql, "EXPLAIN", binds)
+        # HSQLDB's SqlTool just prints it as it comes :
+        # 
+        #  sql> EXPLAIN PLAN FOR SELECT * FROM entries JOIN users on ... ;
+        #  
+        # isDistinctSelect=[false]
+        # isGrouped=[false]
+        # isAggregated=[false]
+        # columns=[  COLUMN: PUBLIC.ENTRIES.ID
+        #  not nullable  COLUMN: PUBLIC.ENTRIES.TITLE
+        #  nullable  COLUMN: PUBLIC.ENTRIES.UPDATED_ON
+        #  nullable  COLUMN: PUBLIC.ENTRIES.CONTENT
+        #  nullable  COLUMN: PUBLIC.ENTRIES.RATING
+        #  nullable  COLUMN: PUBLIC.ENTRIES.USER_ID
+        #  nullable  COLUMN: PUBLIC.USERS.ID
+        #  not nullable  COLUMN: PUBLIC.USERS.LOGIN
+        #  nullable
+        # ]
+        # ...
+        # PARAMETERS=[]
+        # SUBQUERIES[]
+        #
+        rows = raw_result.map { |hash| hash.values }
+        rows.join("\n")
+      end
+    end
+  end
+end

data/lib/arjdbc/informix/adapter.rb

@@ -1,43 +1,35 @@
-module ::ActiveRecord
-  class Base
-    after_save :write_lobs
-
-  private
-    def write_lobs
-      if connection.is_a?(ArJdbc::Informix)
-        self.class.columns.each do |c|
-          if [:text, :binary].include? c.type
-            value = self[c.name]
-            if respond_to?(:unserializable_attribute?)
-              value = value.to_yaml if unserializable_attribute?(c.name, c)
-            else
-              value = value.to_yaml if value.is_a?(Hash)
-            end
+require 'arjdbc/jdbc/serialized_attributes_helper'
 
-            unless value.nil? || (value == '')
-              connection.write_large_object(c.type == :binary,
-                                            c.name,
-                                            self.class.table_name,
-                                            self.class.primary_key,
-                                            quote_value(id),
-                                            value)
+module ArJdbc
+  module Informix
+    
+    @@_lob_callback_added = nil
+    
+    def self.extended(base)
+      unless @@_lob_callback_added
+        ActiveRecord::Base.class_eval do
+          def after_save_with_informix_lob
+            lob_columns = self.class.columns.select { |c| [:text, :binary].include?(c.type) }
+            lob_columns.each do |column|
+              value = ::ArJdbc::SerializedAttributesHelper.dump_column_value(self, column)
+              next if value.nil? || (value == '')
+              
+              connection.write_large_object(
+                column.type == :binary, column.name, 
+                self.class.table_name, self.class.primary_key, 
+                quote_value(id), value
+              )
             end
           end
         end
-      end
-    end
-  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
+        ActiveRecord::Base.after_save :after_save_with_informix_lob
+        @@_lob_callback_added = true
+      end
     end
 
     def self.column_selector
-      [ /informix/i,
-        lambda { |cfg, column| column.extend(::ArJdbc::Informix::Column) } ]
+      [ /informix/i, lambda { |cfg, column| column.extend(::ArJdbc::Informix::Column) } ]
     end
 
     def self.jdbc_connection_class
@@ -45,7 +37,8 @@ module ::ArJdbc
     end
 
     module Column
-    private
+      
+      private
       # TODO: Test all Informix column types.
       def simplified_type(field_type)
         if field_type =~ /serial/i
@@ -54,21 +47,23 @@ module ::ArJdbc
           super
         end
       end
+      
     end
 
-    def modify_types(tp)
-      tp[:primary_key] = "SERIAL PRIMARY KEY"
-      tp[:string]      = { :name => "VARCHAR", :limit => 255 }
-      tp[:integer]     = { :name => "INTEGER" }
-      tp[:float]       = { :name => "FLOAT" }
-      tp[:decimal]     = { :name => "DECIMAL" }
-      tp[:datetime]    = { :name => "DATETIME YEAR TO FRACTION(5)" }
-      tp[:timestamp]   = { :name => "DATETIME YEAR TO FRACTION(5)" }
-      tp[:time]        = { :name => "DATETIME HOUR TO FRACTION(5)" }
-      tp[:date]        = { :name => "DATE" }
-      tp[:binary]      = { :name => "BYTE" }
-      tp[:boolean]     = { :name => "BOOLEAN" }
-      tp
+    def modify_types(types)
+      super(types)
+      types[:primary_key] = "SERIAL PRIMARY KEY"
+      types[:string]      = { :name => "VARCHAR", :limit => 255 }
+      types[:integer]     = { :name => "INTEGER" }
+      types[:float]       = { :name => "FLOAT" }
+      types[:decimal]     = { :name => "DECIMAL" }
+      types[:datetime]    = { :name => "DATETIME YEAR TO FRACTION(5)" }
+      types[:timestamp]   = { :name => "DATETIME YEAR TO FRACTION(5)" }
+      types[:time]        = { :name => "DATETIME HOUR TO FRACTION(5)" }
+      types[:date]        = { :name => "DATE" }
+      types[:binary]      = { :name => "BYTE" }
+      types[:boolean]     = { :name => "BOOLEAN" }
+      types
     end
 
     def prefetch_primary_key?(table_name = nil)
@@ -85,11 +80,9 @@ module ::ArJdbc
 
     def add_limit_offset!(sql, options)
       if options[:limit]
-        limit = "FIRST #{options[:limit]}"
-        # SKIP available only in IDS >= 10
-        offset = (@@db_major_version >= 10 && options[:offset]?
-                  "SKIP #{options[:offset]}" : "")
-        sql.sub!(/^select /i, "SELECT #{offset} #{limit} ")
+        limit = "FIRST #{options[:limit]}" # SKIP available only in IDS >= 10 :
+        offset = (db_major_version >= 10 && options[:offset] ? "SKIP #{options[:offset]}" : "")
+        sql.sub!(/^\s*?select /i, "SELECT #{offset} #{limit} ")
       end
       sql
     end
@@ -104,10 +97,11 @@ module ::ArJdbc
     end
 
     def quote(value, column = nil)
-      if column && [:binary, :text].include?(column.type)
+      column_type = column && column.type
+      if column_type == :binary || column_type == :text
         # LOBs are updated separately by an after_save trigger.
         "NULL"
-      elsif column && column.type == :date
+      elsif column_type == :date
         "'#{value.mon}/#{value.day}/#{value.year}'"
       else
         super
@@ -132,11 +126,18 @@ module ::ArJdbc
     def remove_index(table_name, options = {})
       @connection.execute_update("DROP INDEX #{index_name(table_name, options)}")
     end
-
-  private
+    
     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"), *rest)
     end
+    
+    private
+    
+    def db_major_version
+      @@db_major_version ||= 
+        select_one("SELECT dbinfo('version', 'major') version FROM systables WHERE tabid = 1")['version'].to_i
+    end
+    
   end # module Informix
 end # module ::ArJdbc

data/lib/arjdbc/jdbc/adapter.rb

@@ -50,8 +50,20 @@ module ActiveRecord
       end
 
       # Retrieve the raw java.sql.Connection object.
-      def jdbc_connection
-        raw_connection.connection
+      # The unwrap parameter is useful if an attempt to unwrap a pooled (JNDI) 
+      # connection should be made - to really return the native (SQL) object.
+      def jdbc_connection(unwrap = nil)
+        java_connection = raw_connection.connection
+        return java_connection unless unwrap
+        connection_class = java.sql.Connection.java_class
+        if java_connection.wrapper_for?(connection_class)
+          java_connection.unwrap(connection_class) # java.sql.Wrapper.unwrap
+        elsif java_connection.respond_to?(:connection)
+          # e.g. org.apache.tomcat.jdbc.pool.PooledConnection
+          java_connection.connection # getConnection
+        else
+          java_connection
+        end
       end
 
       # Locate specialized adapter specification if one exists based on config data
@@ -83,8 +95,8 @@ module ActiveRecord
         nil
       end
 
-      def modify_types(tp)
-        tp
+      def modify_types(types)
+        types
       end
 
       def adapter_name #:nodoc:
@@ -122,7 +134,7 @@ module ActiveRecord
         end
       end
 
-      def is_a?(klass)          # :nodoc:
+      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
@@ -143,39 +155,39 @@ module ActiveRecord
         @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
+      def native_sql_to_type(type)
+        if /^(.*?)\(([0-9]+)\)/ =~ type
+          tname, limit = $1, $2.to_i
+          ntypes = native_database_types
+          if ntypes[:primary_key] == type
+            return :primary_key, nil
           else
-            ntype.each do |name,val|
+            ntypes.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
+              if val[:name].downcase == tname.downcase && 
+                  ( val[:limit].nil? || val[:limit].to_i == limit )
+                return name, limit
               end
             end
           end
-        elsif /^(.*?)/ =~ tp
+        elsif /^(.*?)/ =~ type
           tname = $1
-          ntype = native_database_types
-          if ntype[:primary_key] == tp
-            return :primary_key,nil
+          ntypes = native_database_types
+          if ntypes[:primary_key] == type
+            return :primary_key, nil
           else
-            ntype.each do |name,val|
+            ntypes.each do |name, val|
               if val[:name].downcase == tname.downcase && val[:limit].nil?
-                return name,nil
+                return name, nil
               end
             end
           end
         else
-          return :string,255
+          return :string, 255
         end
-        return nil,nil
+        return nil, nil
       end
 
       def active?
@@ -191,44 +203,20 @@ module ActiveRecord
         @connection.disconnect!
       end
 
-      def substitute_binds(manager, binds = [])
-        sql = extract_sql(manager)
-        if binds.empty?
-          sql
-        else
-          copy = binds.dup
-          sql.gsub('?') { quote(*copy.shift.reverse) }
+      if ActiveRecord::VERSION::MAJOR < 3
+        
+        def jdbc_insert(sql, name = nil, pk = nil, id_value = nil, sequence_name = nil, binds = [])  # :nodoc:
+          insert_sql(sql, name, pk, id_value, sequence_name, binds)
         end
-      end
-
-      def execute(sql, name = nil, binds = [])
-        sql = substitute_binds(sql, binds)
-        if name == :skip_logging
-          _execute(sql)
-        else
-          log(sql, name) { _execute(sql) }
+        
+        def jdbc_update(sql, name = nil, binds = []) # :nodoc:
+          execute(sql, name, binds)
         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, binds = [])
-        insert_sql(sql, name, pk, id_value, sequence_name, binds)
-      end
-
-      def jdbc_update(sql, name = nil, binds = []) #:nodoc:
-        execute(sql, name, binds)
-      end
-      def jdbc_select_all(sql, name = nil, binds = [])
-        select(sql, name, binds)
-      end
-
-      if ActiveRecord::VERSION::MAJOR < 3
+        
+        def jdbc_select_all(sql, name = nil, binds = []) # :nodoc:
+          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
@@ -238,25 +226,14 @@ module ActiveRecord
         def select_one(sql, name = nil)
           select(sql, name).first
         end
+        
       end
 
-      def last_inserted_id(result)
-        result
-      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, binds = [])
-        id = execute(sql, name = nil, binds)
-        id_value || id
+      def jdbc_columns(table_name, name = nil)
+        @connection.columns(table_name.to_s)
       end
-
-      ### Rails 3.1 prepared statement support
-
+      alias_chained_method :columns, :query_cache, :jdbc_columns
+      
       # Executes +sql+ statement in the context of this connection using
       # +binds+ as the bind substitutes.  +name+ is logged along with
       # the executed +sql+ statement.
@@ -284,11 +261,69 @@ module ActiveRecord
       def exec_update(sql, name, binds)
         exec_query(sql, name, binds)
       end
+      
+      if ActiveRecord::VERSION::MAJOR < 3 # 2.3.x
+        
+      # NOTE: 2.3 log(sql, name) while does not like `name == nil`
+      
+      # Executes the SQL statement in the context of this connection.
+      def execute(sql, name = nil, binds = [])
+        sql = to_sql(sql, binds)
+        if name == :skip_logging
+          _execute(sql, name)
+        else
+          log(sql, name) { _execute(sql, name ||= "SQL") }
+        end
+      end
 
-      def jdbc_columns(table_name, name = nil)
-        @connection.columns(table_name.to_s)
+      else
+      #elsif ActiveRecord::VERSION::MAJOR == 3 && ActiveRecord::VERSION::MINOR == 0
+      
+      # NOTE: 3.0 log(sql, name) allow `name == nil` (handles `name ||= "SQL"`)
+      
+      # Executes the SQL statement in the context of this connection.
+      def execute(sql, name = nil, binds = [])
+        sql = to_sql(sql, binds)
+        if name == :skip_logging
+          _execute(sql, name)
+        else
+          log(sql, name) { _execute(sql, name) }
+        end
+      end
+
+      # NOTE: 3.1 log(sql, name = "SQL", binds = []) `name == nil` is fine
+      # TODO skip logging the binds (twice) until prepared-statement support
+      
+      #else
+      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
+      private :_execute
+      
+      # Returns an array of record hashes with the column names as keys and
+      # column values as values.
+      # @note on AR-3.2 expects "only" 2 arguments `select(sql, name = nil)`
+      #  we accept 3 arguments as well `select(sql, name = nil, binds = [])`
+      def select(*args)
+        execute(*args)
+      end
+      
+      def select_rows(sql, name = nil)
+        rows = []
+        select(sql, name).each {|row| rows << row.values }
+        rows
+      end
+
+      # NOTE: we have an extra binds argument at the end due 2.3 support (due {#jdbc_insert}).
+      def insert_sql(sql, name = nil, pk = nil, id_value = nil, sequence_name = nil, binds = []) # :nodoc:
+        id = execute(sql, name = nil, binds)
+        id_value || id
       end
-      alias_chained_method :columns, :query_cache, :jdbc_columns
 
       def tables(name = nil)
         @connection.tables
@@ -331,24 +366,76 @@ module ActiveRecord
         @connection.primary_keys(table)
       end
 
-      def select(*args)
-        execute(*args)
+      if ActiveRecord::VERSION::MAJOR >= 3
+        
+      # Converts an arel AST to SQL
+      def to_sql(arel, binds = [])
+        if arel.respond_to?(:ast)
+          visitor.accept(arel.ast) do
+            quote(*binds.shift.reverse)
+          end
+        else # for backwards compatibility :
+          sql = arel.respond_to?(:to_sql) ? arel.send(:to_sql) : arel
+          return sql if binds.blank?
+          sql.gsub('?') { quote(*binds.shift.reverse) }
+        end
       end
-
+      
+      else # AR-2.3 no #to_sql method
+        
+      # Substitutes SQL bind (?) parameters
+      def to_sql(sql, binds = [])
+        sql = sql.send(:to_sql) if sql.respond_to?(:to_sql)
+        return sql if binds.blank?
+        copy = binds.dup
+        sql.gsub('?') { quote(*copy.shift.reverse) }
+      end
+        
+      end
+      
+      protected
+ 
       def translate_exception(e, message)
         puts e.backtrace if $DEBUG || ENV['DEBUG']
         super
       end
 
-      def extract_sql(obj)
-        if obj.respond_to? :to_sql
-          obj.send :to_sql
+      def last_inserted_id(result)
+        result
+      end
+      
+      private
+      
+      # #deprecated no longer used
+      def substitute_binds(sql, binds = [])
+        sql = extract_sql(sql)
+        if binds.empty?
+          sql
         else
-          obj
+          copy = binds.dup
+          sql.gsub('?') { quote(*copy.shift.reverse) }
         end
       end
 
-      protected :translate_exception, :extract_sql
+      # #deprecated no longer used
+      def extract_sql(obj)
+        obj.respond_to?(:to_sql) ? obj.send(:to_sql) : obj
+      end
+      
+      protected
+      
+      def self.select?(sql)
+        JdbcConnection::select?(sql)
+      end
+
+      def self.insert?(sql)
+        JdbcConnection::insert?(sql)
+      end
+
+      def self.update?(sql)
+        ! select?(sql) && ! insert?(sql)
+      end
+
     end
   end
 end