ActiveRecord-JDBC 0.4 → 0.5

data/lib/jdbc_adapter/jdbc_firebird.rb

@@ -1,5 +1,9 @@
-module JdbcSpec
+module ::JdbcSpec
   module FireBird
+    def self.adapter_selector
+      [/firebird/i, lambda{|cfg,adapt| adapt.extend(::JdbcSpec::FireBird)}]
+    end
+
     def modify_types(tp)
       tp[:primary_key] = 'INTEGER NOT NULL PRIMARY KEY'
       tp[:string][:limit] = 252

data/lib/jdbc_adapter/jdbc_hsqldb.rb

@@ -1,5 +1,27 @@
-module JdbcSpec
+module ::JdbcSpec
+  module ActiveRecordExtensions
+    def hsqldb_connection(config)
+      config[:url] ||= "jdbc:hsqldb:#{config[:database]}"
+      config[:driver] ||= "org.hsqldb.jdbcDriver"
+      embedded_driver(config)
+    end
+      
+    def h2_connection(config)
+      config[:url] ||= "jdbc:h2:#{config[:database]}"
+      config[:driver] ||= "org.h2.Driver"
+      embedded_driver(config)
+    end
+  end
+  
   module HSQLDB
+    def self.column_selector
+      [/hsqldb|\.h2\./i, lambda {|cfg,col| col.extend(::JdbcSpec::HSQLDB::Column)}]
+    end
+
+    def self.adapter_selector
+      [/hsqldb|\.h2\./i, lambda {|cfg,adapt| adapt.extend(::JdbcSpec::HSQLDB)}]
+    end
+    
     module Column
       def type_cast(value)
         return nil if value.nil? || value =~ /^\s*null\s*$/i

data/lib/jdbc_adapter/jdbc_mimer.rb

@@ -1,5 +1,9 @@
 module JdbcSpec
   module Mimer
+    def self.adapter_selector
+      [/mimer/i, lambda {|cfg,adapt| adapt.extend(::JdbcSpec::Mimer)}]
+    end
+
     def modify_types(tp)
       tp[:primary_key] = "INTEGER NOT NULL PRIMARY KEY"
       tp[:boolean][:limit] = nil
@@ -110,7 +114,6 @@ module JdbcSpec
     end
 
     def _execute(sql, name = nil)
-      log_no_bench(sql, name) do
         if sql =~ /^select/i
           @offset ||= 0
           if !@limit || @limit == -1
@@ -122,7 +125,6 @@ module JdbcSpec
         else
           @connection.execute_update(sql)
         end
-      end
     ensure
       @limit = @offset = nil
     end

data/lib/jdbc_adapter/jdbc_mssql.rb

@@ -1,10 +1,20 @@
 module JdbcSpec
   module MsSQL
+    def self.column_selector
+      [/sqlserver|tds/i, lambda {|cfg,col| col.extend(::JdbcSpec::MsSQL::Column)}]
+    end
+
+    def self.adapter_selector
+      [/sqlserver|tds/i, lambda {|cfg,adapt| adapt.extend(::JdbcSpec::MsSQL)}]
+    end
+    
     module Column
+      attr_accessor :identity, :is_special
+      
       def simplified_type(field_type)
         case field_type
           when /int|bigint|smallint|tinyint/i                        then :integer
-          when /float|double|decimal|money|numeric|real|smallmoney/i then @scale == 0 ? :integer : :float
+          when /float|double|decimal|money|numeric|real|smallmoney/i then @scale == 0 ? :integer : :decimal
           when /datetime|smalldatetime/i                             then :datetime
           when /timestamp/i                                          then :timestamp
           when /time/i                                               then :time
@@ -17,21 +27,26 @@ module JdbcSpec
       end
 
       def type_cast(value)
-        return nil if value.nil? || value =~ /^\s*null\s*$/i
+        return nil if value.nil? || value == "(NULL)"
         case type
-        when :string    then value
-        when :integer   then value == true || value == false ? value == true ? 1 : 0 : value.to_i
+        when :string then unquote value
+        when :integer then unquote(value).to_i rescue value ? 1 : 0
         when :primary_key then value == true || value == false ? value == true ? 1 : 0 : value.to_i 
-        when :float     then value.to_f
+        when :decimal   then self.class.value_to_decimal(value)
         when :datetime  then cast_to_datetime(value)
         when :timestamp then cast_to_time(value)
         when :time      then cast_to_time(value)
         when :date      then cast_to_datetime(value)
-        when :boolean   then value == true or (value =~ /^t(rue)?$/i) == 0 or value.to_s == '1'
+        when :boolean   then value == true or (value =~ /^t(rue)?$/i) == 0 or unquote(value)=="1"
+        when :binary    then unquote value
         else value
         end
       end
-
+      
+      def unquote(value)
+        value.to_s.sub(/^\([\(\']?/, "").sub(/[\'\)]?\)$/, "")
+      end
+      
       def cast_to_time(value)
         return value if value.is_a?(Time)
         time_array = ParseDate.parsedate(value)
@@ -85,77 +100,70 @@ module JdbcSpec
       tp[:binary] = { :name => "image"}
       tp
     end
-
+    
     def quote(value, column = nil)
-      if column && column.type == :primary_key
-        return value.to_s
-      end
-        case value
-          when String                
-            if column && column.type == :binary && column.class.respond_to?(:string_to_binary)
-              val = quote_string(column.class.string_to_binary(value))
-              "'#{val}'"
-            else
-              "'#{quote_string(value)}'"
-            end
-          when NilClass              then "NULL"
-          when TrueClass             then '1'
-          when FalseClass            then '0'
-          when Float, Fixnum, Bignum then value.to_s
-          when Date                  then "'#{value.to_s}'" 
-          when Time, DateTime        then "'#{value.strftime("%Y-%m-%d %H:%M:%S")}'"
-          else                            "'#{quote_string(value.to_yaml)}'"
-        end
+      return value.quoted_id if value.respond_to?(:quoted_id)
+
+      case value
+        when TrueClass             then '1'
+        when FalseClass            then '0'
+        when Time, DateTime        then "'#{value.strftime("%Y%m%d %H:%M:%S")}'"
+        when Date                  then "'#{value.strftime("%Y%m%d")}'"
+        else                       super
       end
+    end
 
       def quote_string(string)
         string.gsub(/\'/, "''")
       end
 
-      def quoted_true
-        "1"
-      end
-      
-      def quoted_false
-        "0"
-      end
-
       def quote_column_name(name)
         "[#{name}]"
       end
+      
+        def add_limit_offset!(sql, options)
+          if options[:limit] and options[:offset]
+            total_rows = select_all("SELECT count(*) as TotalRows from (#{sql.gsub(/\bSELECT(\s+DISTINCT)?\b/i, "SELECT#{$1} TOP 1000000000")}) tally")[0][:TotalRows].to_i
 
-    def add_limit_offset!(sql, options)
-      if options[:limit] and options[:offset]
-        total_rows = @connection.select_all("SELECT count(*) as TotalRows from (#{sql.gsub(/\bSELECT\b/i, "SELECT TOP 1000000000")}) tally")[0][:TotalRows].to_i
-        if (options[:limit] + options[:offset]) >= total_rows
-          options[:limit] = (total_rows - options[:offset] >= 0) ? (total_rows - options[:offset]) : 0
-        end
-        sql.sub!(/^\s*SELECT/i, "SELECT * FROM (SELECT TOP #{options[:limit]} * FROM (SELECT TOP #{options[:limit] + options[:offset]} ")
-        sql << ") AS tmp1"
-        if options[:order]
-          options[:order] = options[:order].split(',').map do |field|
-            parts = field.split(" ")
-            tc = parts[0]
-            if sql =~ /\.\[/ and tc =~ /\./ # if column quoting used in query
-              tc.gsub!(/\./, '\\.\\[')
-              tc << '\\]'
-            end
-            if sql =~ /#{tc} AS (t\d_r\d\d?)/
-              parts[0] = $1
+            sql.sub!(/^\s*SELECT(\s+DISTINCT)?/i, "SELECT * FROM (SELECT TOP #{options[:limit]} * FROM (SELECT#{$1} TOP #{options[:limit] + options[:offset]} ")
+            sql << ") AS tmp1"
+            if options[:order]
+              options[:order] = options[:order].split(',').map do |field|
+                parts = field.split(" ")
+                tc = parts[0]
+                if sql =~ /\.\[/ and tc =~ /\./ # if column quoting used in query
+                  tc.gsub!(/\./, '\\.\\[')
+                  tc << '\\]'
+                end
+                if sql =~ /#{tc} AS (t\d_r\d\d?)/
+                  parts[0] = $1
+                elsif parts[0] =~ /\w+\.(\w+)/
+                  parts[0] = $1
+                end
+                parts.join(' ')
+              end.join(', ')
+              sql << " ORDER BY #{change_order_direction(options[:order])}) AS tmp2 ORDER BY #{options[:order]}"
+            else
+              sql << " ) AS tmp2"
             end
-            parts.join(' ')
-          end.join(', ')
-          sql << " ORDER BY #{change_order_direction(options[:order])}) AS tmp2 ORDER BY #{options[:order]}"
-        else
-          sql << " ) AS tmp2"
+          elsif sql !~ /^\s*SELECT (@@|COUNT\()/i
+            sql.sub!(/^\s*SELECT(\s+DISTINCT)?/i) do
+              "SELECT#{$1} TOP #{options[:limit]}"
+            end unless options[:limit].nil?
+          end
         end
-      elsif sql !~ /^\s*SELECT (@@|COUNT\()/i
-        sql.sub!(/^\s*SELECT([\s]*distinct)?/i) do
-          "SELECT#{$1} TOP #{options[:limit]}"
-        end unless options[:limit].nil?
-      end
-    end
     
+      
+          def change_order_direction(order)
+            order.split(",").collect {|fragment|
+              case fragment
+                when  /\bDESC\b/i     then fragment.gsub(/\bDESC\b/i, "ASC")
+                when  /\bASC\b/i      then fragment.gsub(/\bASC\b/i, "DESC")
+                else                  String.new(fragment).split(',').join(' DESC,') + ' DESC'
+              end
+            }.join(",")
+          end
+      
     def recreate_database(name)
       drop_database(name)
       create_database(name)
@@ -179,15 +187,17 @@ module JdbcSpec
       
       def change_column(table_name, column_name, type, options = {}) #:nodoc:
         sql_commands = ["ALTER TABLE #{table_name} ALTER COLUMN #{column_name} #{type_to_sql(type, options[:limit])}"]
-        if options[:default]
+        if options_include_default?(options)
           remove_default_constraint(table_name, column_name)
-          sql_commands << "ALTER TABLE #{table_name} ADD CONSTRAINT DF_#{table_name}_#{column_name} DEFAULT #{options[:default]} FOR #{column_name}"
+          sql_commands << "ALTER TABLE #{table_name} ADD CONSTRAINT DF_#{table_name}_#{column_name} DEFAULT #{quote(options[:default], options[:column])} FOR #{column_name}"
         end
         sql_commands.each {|c|
           execute(c)
         }
       end
-      
+      def change_column_default(table_name, column_name, default) #:nodoc:
+        execute "ALTER TABLE #{table_name} ADD CONSTRAINT DF_#{table_name}_#{column_name} DEFAULT #{quote(default, column_name)} FOR #{column_name}"
+      end
       def remove_column(table_name, column_name)
         remove_default_constraint(table_name, column_name)
         execute "ALTER TABLE #{table_name} DROP COLUMN #{column_name}"
@@ -203,6 +213,78 @@ module JdbcSpec
       def remove_index(table_name, options = {})
         execute "DROP INDEX #{table_name}.#{index_name(table_name, options)}"
       end
+      
+
+      def columns(table_name, name = nil)
+        cc = super
+        cc.each do |col|
+          col.identity = true if col.sql_type =~ /identity/i
+          col.is_special = true if col.sql_type =~ /text|ntext|image/i
+        end
+        cc
+      end
+      
+      def _execute(sql, name = nil)
+        if sql.lstrip =~ /^insert/i
+         if query_requires_identity_insert?(sql)
+            table_name = get_table_name(sql)
+            with_identity_insert_enabled(table_name) do 
+            id = @connection.execute_insert(sql)
+        end
+         else
+            @connection.execute_insert(sql)
+         end
+      elsif sql.lstrip =~ /^\(?\s*(select|show)/i
+      @connection.execute_query(sql)
+      else
+      @connection.execute_update(sql)
+      end
+    end
+      
+      
+      private
+      # Turns IDENTITY_INSERT ON for table during execution of the block
+      # N.B. This sets the state of IDENTITY_INSERT to OFF after the
+      # block has been executed without regard to its previous state
+
+      def with_identity_insert_enabled(table_name, &block)
+        set_identity_insert(table_name, true)
+        yield
+      ensure
+        set_identity_insert(table_name, false)  
+      end
+      
+      def set_identity_insert(table_name, enable = true)
+        execute "SET IDENTITY_INSERT #{table_name} #{enable ? 'ON' : 'OFF'}"
+      rescue Exception => e
+        raise ActiveRecordError, "IDENTITY_INSERT could not be turned #{enable ? 'ON' : 'OFF'} for table #{table_name}"  
+      end
+
+      def get_table_name(sql)
+        if sql =~ /^\s*insert\s+into\s+([^\(\s]+)\s*|^\s*update\s+([^\(\s]+)\s*/i
+          $1
+        elsif sql =~ /from\s+([^\(\s]+)\s*/i
+          $1
+        else
+          nil
+        end
+      end
+
+      def identity_column(table_name)
+        @table_columns = {} unless @table_columns
+        @table_columns[table_name] = columns(table_name) if @table_columns[table_name] == nil
+        @table_columns[table_name].each do |col|
+          return col.name if col.identity
+        end
+
+        return nil
+      end
+
+      def query_requires_identity_insert?(sql)
+        table_name = get_table_name(sql)
+        id_column = identity_column(table_name)
+        sql =~ /\[#{id_column}\]/ ? table_name : nil
+      end
   end
 end
 

data/lib/jdbc_adapter/jdbc_mysql.rb

@@ -1,7 +1,27 @@
 require 'active_record/connection_adapters/abstract/schema_definitions'
 
-module JdbcSpec
+module ::JdbcSpec
+  module ActiveRecordExtensions
+    def mysql_connection(config)
+      if config[:socket]
+        warn "AR-JDBC MySQL on JRuby does not support sockets"
+      end
+      config[:port] ||= 3306
+      config[:url] ||= "jdbc:mysql://#{config[:host]}:#{config[:port]}/#{config[:database]}"
+      config[:driver] = "com.mysql.jdbc.Driver"
+      jdbc_connection(config)
+    end
+  end
+
   module MySQL
+    def self.column_selector
+      [/mysql/i, lambda {|cfg,col| col.extend(::JdbcSpec::MySQL::Column)}]
+    end
+
+    def self.adapter_selector
+      [/mysql/i, lambda {|cfg,adapt| adapt.extend(::JdbcSpec::MySQL)}]
+    end
+    
     def self.extended(adapter)
       adapter.execute("SET SQL_AUTO_IS_NULL=0")
     end
@@ -10,7 +30,7 @@ module JdbcSpec
       TYPES_ALLOWING_EMPTY_STRING_DEFAULT = Set.new([:binary, :string, :text])
 
       def simplified_type(field_type)
-        return :boolean if field_type =~ /tinyint\(1\)|bit\(1\)/i 
+        return :boolean if field_type =~ /tinyint\(1\)|bit/i 
         return :string  if field_type =~ /enum/i
         super
       end

data/lib/jdbc_adapter/jdbc_oracle.rb

@@ -1,5 +1,42 @@
-module JdbcSpec
+module ::ActiveRecord
+  class Base
+    # After setting large objects to empty, write data back with a helper method
+    after_save :write_lobs
+    def write_lobs() #:nodoc:
+      if connection.is_a?(JdbcSpec::Oracle)
+        self.class.columns.select { |c| c.sql_type =~ /LOB\(|LOB$/i }.each { |c|
+          value = self[c.name]
+          value = value.to_yaml if unserializable_attribute?(c.name, c)
+          next if value.nil?  || (value == '')
+
+          connection.write_large_object(c.type == :binary, c.name, self.class.table_name, self.class.primary_key, quote_value(id), value)
+        }
+      end
+    end
+
+    private :write_lobs
+  end
+end
+
+module ::JdbcSpec
+  module ActiveRecordExtensions
+    def oracle_connection(config)
+      config[:port] ||= 1521
+      config[:url] ||= "jdbc:oracle:thin:@#{config[:host]}:#{config[:port]}:#{config[:database]}"
+      config[:driver] ||= "oracle.jdbc.driver.OracleDriver"
+      jdbc_connection(config)
+    end
+  end
+  
   module Oracle
+    def self.column_selector
+      [/oracle/i, lambda {|cfg,col| col.extend(::JdbcSpec::Oracle::Column)}]
+    end
+
+    def self.adapter_selector
+      [/oracle/i, lambda {|cfg,adapt| adapt.extend(::JdbcSpec::Oracle)}]
+    end
+    
     module Column
       def type_cast(value)
         return nil if value.nil? || value =~ /^\s*null\s*$/i
@@ -8,39 +45,46 @@ module JdbcSpec
         when :integer  then defined?(value.to_i) ? value.to_i : (value ? 1 : 0)
         when :primary_key then defined?(value.to_i) ? value.to_i : (value ? 1 : 0) 
         when :float    then value.to_f
-        when :datetime then cast_to_date_or_time(value)
-        when :time     then cast_to_time(value)
+        when :datetime then JdbcSpec::Oracle::Column.cast_to_date_or_time(value)
+        when :time     then JdbcSpec::Oracle::Column.cast_to_time(value)
         when :decimal   then self.class.value_to_decimal(value)
         when :boolean   then self.class.value_to_boolean(value)
         else value
         end
       end
       
+      def type_cast_code(var_name)
+        return "JdbcSpec::Oracle::Column.cast_to_date_or_time(#{var_name})" if type == :datetime
+        super
+      end
+      
       private
-      def simplified_type(field_type)
+      def simplified_type(field_type)      
         case field_type
-        when /char/i                          : :string
-        when /num|float|double|dec|real|int/i : @scale == 0 ? :integer : :float
-        when /date|time/i                     : @name =~ /_at$/ ? :time : :datetime
+        when /char/i                           : :string
+        when /float|double/i                   : :float
+        when /int/i                            : :integer
+        when /num|dec|real/i                   : @scale == 0 ? :integer : :decimal
+        when /date|time/i                      : :datetime
         when /clob/i                           : :text
         when /blob/i                           : :binary
         end
       end
 
-      def cast_to_date_or_time(value)
+      def self.cast_to_date_or_time(value)
         return value if value.is_a? Date
         return nil if value.blank?
-        guess_date_or_time (value.is_a? Time) ? value : cast_to_time(value)
+        guess_date_or_time((value.is_a? Time) ? value : cast_to_time(value))
       end
 
-      def cast_to_time(value)
+      def self.cast_to_time(value)
         return value if value.is_a? Time
         time_array = ParseDate.parsedate value
         time_array[0] ||= 2000; time_array[1] ||= 1; time_array[2] ||= 1;
         Time.send(ActiveRecord::Base.default_timezone, *time_array) rescue nil
       end
 
-      def guess_date_or_time(value)
+      def self.guess_date_or_time(value)
         (value.hour == 0 and value.min == 0 and value.sec == 0) ?
         Date.new(value.year, value.month, value.day) : value
       end
@@ -65,6 +109,10 @@ module JdbcSpec
       execute "DROP SEQUENCE #{name}_seq" rescue nil
     end
 
+    def recreate_database(name)
+      tables.each{ |table| drop_table(table) }
+    end
+    
     def insert(sql, name = nil, pk = nil, id_value = nil, sequence_name = nil) #:nodoc:
       if pk.nil? # Who called us? What does the sql look like? No idea!
         execute sql, name
@@ -79,15 +127,17 @@ module JdbcSpec
       id_value
     end
 
+    def indexes(table, name = nil)
+      @connection.indexes(table, name, @connection.connection.meta_data.user_name)
+    end
+    
     def _execute(sql, name = nil)
-      log_no_bench(sql, name) do
         case sql.strip
         when /^(select|show)/i:
           @connection.execute_query(sql)
         else
           @connection.execute_update(sql)
         end
-      end
     end
     
     def modify_types(tp)
@@ -147,7 +197,11 @@ module JdbcSpec
               from user_tab_columns
               where table_name = '#{table.to_a.first.last}'
               order by column_id
-            }).map do |row|              
+            }).map do |row|
+          row = row.inject({}) do |h,args| 
+            h[args[0].downcase] = args[1]
+            h 
+          end
           col = "#{row['column_name'].downcase} #{row['data_type'].downcase}"      
           if row['data_type'] =='NUMBER' and !row['data_precision'].nil?
             col << "(#{row['data_precision'].to_i}"
@@ -202,7 +256,7 @@ module JdbcSpec
           return value.to_s
         end
         case value
-        when String     : %Q{'#{quote_string(value)}'}
+        when String, ActiveSupport::Multibyte::Chars     : %Q{'#{quote_string(value)}'}
         when NilClass   : 'null'
         when TrueClass  : '1'
         when FalseClass : '0'
@@ -212,5 +266,16 @@ module JdbcSpec
         end
       end
     end
+    
+    private
+    
+    def select(sql, name = nil)
+      records = execute(sql, name)
+      records.map do |col|
+          col.delete('raw_rnum_')
+          col       
+      end
+      records
+    end
   end
 end