kb-activerecord-jdbc-adapter 0.9.7.1-java → 1.0.0.beta1-java

data/lib/arjdbc/jdbc/quoted_primary_key.rb

@@ -0,0 +1,28 @@
+module ArJdbc
+  module QuotedPrimaryKeyExtension
+    def self.extended(base)
+      #       Rails 3 method           Rails 2 method
+      meth = [:arel_attributes_values, :attributes_with_quotes].detect do |m|
+        base.private_instance_methods.include?(m.to_s)
+      end
+      pk_hash_key = "self.class.primary_key"
+      pk_hash_value = '"?"'
+      if meth == :arel_attributes_values
+        pk_hash_key = "self.class.arel_table[#{pk_hash_key}]"
+        pk_hash_value = "Arel::SqlLiteral.new(#{pk_hash_value})"
+      end
+      if meth
+        base.module_eval <<-PK, __FILE__, __LINE__
+          alias :#{meth}_pre_pk :#{meth}
+          def #{meth}(include_primary_key = true, *args) #:nodoc:
+            aq = #{meth}_pre_pk(include_primary_key, *args)
+            if connection.is_a?(ArJdbc::Oracle) || connection.is_a?(ArJdbc::Mimer)
+              aq[#{pk_hash_key}] = #{pk_hash_value} if include_primary_key && aq[#{pk_hash_key}].nil?
+            end
+            aq
+          end
+        PK
+      end
+    end
+  end
+end

data/lib/{jdbc_adapter → arjdbc/jdbc}/railtie.rb

@@ -1,6 +1,6 @@
 require 'rails/railtie'
 
-module ::JdbcSpec
+module ::ArJdbc
   class Railtie < ::Rails::Railtie
     rake_tasks do
       load File.expand_path('../rake_tasks.rb', __FILE__)

data/lib/arjdbc/jdbc/require_driver.rb

@@ -0,0 +1,16 @@
+module Kernel
+  # load a JDBC driver library/gem, failing silently. If failed, trust
+  # that the driver jar is already present through some other means
+  def jdbc_require_driver(path, gem_name = nil)
+    gem_name ||= path.sub('/', '-')
+    2.times do
+      begin
+        require path
+        break
+      rescue LoadError
+        require 'rubygems'
+        begin; gem gem_name; rescue LoadError; end
+      end
+    end
+  end
+end

data/lib/arjdbc/jdbc/type_converter.rb

@@ -0,0 +1,119 @@
+module ActiveRecord
+  module ConnectionAdapters
+    # I want to use JDBC's DatabaseMetaData#getTypeInfo to choose the best native types to
+    # use for ActiveRecord's Adapter#native_database_types in a database-independent way,
+    # but apparently a database driver can return multiple types for a given
+    # java.sql.Types constant.  So this type converter uses some heuristics to try to pick
+    # the best (most common) type to use.  It's not great, it would be better to just
+    # delegate to each database's existin AR adapter's native_database_types method, but I
+    # wanted to try to do this in a way that didn't pull in all the other adapters as
+    # dependencies.  Suggestions appreciated.
+    class JdbcTypeConverter
+      # The basic ActiveRecord types, mapped to an array of procs that are used to #select
+      # the best type.  The procs are used as selectors in order until there is only one
+      # type left.  If all the selectors are applied and there is still more than one
+      # type, an exception will be raised.
+      AR_TO_JDBC_TYPES = {
+        :string      => [ lambda {|r| Jdbc::Types::VARCHAR == r['data_type'].to_i},
+                          lambda {|r| r['type_name'] =~ /^varchar/i},
+                          lambda {|r| r['type_name'] =~ /^varchar$/i},
+                          lambda {|r| r['type_name'] =~ /varying/i}],
+        :text        => [ lambda {|r| [Jdbc::Types::LONGVARCHAR, Jdbc::Types::CLOB].include?(r['data_type'].to_i)},
+                          lambda {|r| r['type_name'] =~ /^text$/i},     # For Informix
+                          lambda {|r| r['type_name'] =~ /^(text|clob)$/i},
+                          lambda {|r| r['type_name'] =~ /^character large object$/i},
+                          lambda {|r| r['sql_data_type'] == 2005}],
+        :integer     => [ lambda {|r| Jdbc::Types::INTEGER == r['data_type'].to_i},
+                          lambda {|r| r['type_name'] =~ /^integer$/i},
+                          lambda {|r| r['type_name'] =~ /^int4$/i},
+                          lambda {|r| r['type_name'] =~ /^int$/i}],
+        :decimal     => [ lambda {|r| Jdbc::Types::DECIMAL == r['data_type'].to_i},
+                          lambda {|r| r['type_name'] =~ /^decimal$/i},
+                          lambda {|r| r['type_name'] =~ /^numeric$/i},
+                          lambda {|r| r['type_name'] =~ /^number$/i},
+                          lambda {|r| r['type_name'] =~ /^real$/i},
+                          lambda {|r| r['precision'] == '38'},
+                          lambda {|r| r['data_type'] == '2'}],
+        :float       => [ lambda {|r| [Jdbc::Types::FLOAT,Jdbc::Types::DOUBLE, Jdbc::Types::REAL].include?(r['data_type'].to_i)},
+                          lambda {|r| r['data_type'].to_i == Jdbc::Types::REAL}, #Prefer REAL to DOUBLE for Postgresql
+                          lambda {|r| r['type_name'] =~ /^float/i},
+                          lambda {|r| r['type_name'] =~ /^double$/i},
+                          lambda {|r| r['type_name'] =~ /^real$/i},
+                          lambda {|r| r['precision'] == '15'}],
+        :datetime    => [ lambda {|r| Jdbc::Types::TIMESTAMP == r['data_type'].to_i},
+                          lambda {|r| r['type_name'] =~ /^datetime$/i},
+                          lambda {|r| r['type_name'] =~ /^timestamp$/i},
+                          lambda {|r| r['type_name'] =~ /^date/i},
+                          lambda {|r| r['type_name'] =~ /^integer/i}],  #Num of milliseconds for SQLite3 JDBC Driver
+        :timestamp   => [ lambda {|r| Jdbc::Types::TIMESTAMP == r['data_type'].to_i},
+                          lambda {|r| r['type_name'] =~ /^timestamp$/i},
+                          lambda {|r| r['type_name'] =~ /^datetime/i},
+                          lambda {|r| r['type_name'] =~ /^date/i},
+                          lambda {|r| r['type_name'] =~ /^integer/i}],  #Num of milliseconds for SQLite3 JDBC Driver
+        :time        => [ lambda {|r| Jdbc::Types::TIME == r['data_type'].to_i},
+                          lambda {|r| r['type_name'] =~ /^time$/i},
+                          lambda {|r| r['type_name'] =~ /^datetime/i},  # For Informix
+                          lambda {|r| r['type_name'] =~ /^date/i},
+                          lambda {|r| r['type_name'] =~ /^integer/i}],  #Num of milliseconds for SQLite3 JDBC Driver
+        :date        => [ lambda {|r| Jdbc::Types::DATE == r['data_type'].to_i},
+                          lambda {|r| r['type_name'] =~ /^date$/i},
+                          lambda {|r| r['type_name'] =~ /^date/i},
+                          lambda {|r| r['type_name'] =~ /^integer/i}],  #Num of milliseconds for SQLite3 JDBC Driver3
+        :binary      => [ lambda {|r| [Jdbc::Types::LONGVARBINARY,Jdbc::Types::BINARY,Jdbc::Types::BLOB].include?(r['data_type'].to_i)},
+                          lambda {|r| r['type_name'] =~ /^blob/i},
+                          lambda {|r| r['type_name'] =~ /sub_type 0$/i}, # For FireBird
+                          lambda {|r| r['type_name'] =~ /^varbinary$/i}, # We want this sucker for Mimer
+                          lambda {|r| r['type_name'] =~ /^binary$/i}, ],
+        :boolean     => [ lambda {|r| [Jdbc::Types::TINYINT].include?(r['data_type'].to_i)},
+                          lambda {|r| r['type_name'] =~ /^bool/i},
+                          lambda {|r| r['data_type'] == '-7'},
+                          lambda {|r| r['type_name'] =~ /^tinyint$/i},
+                          lambda {|r| r['type_name'] =~ /^decimal$/i},
+                          lambda {|r| r['type_name'] =~ /^integer$/i}]
+      }
+
+      def initialize(types)
+        @types = types
+        @types.each {|t| t['type_name'] ||= t['local_type_name']} # Sybase driver seems to want 'local_type_name'
+      end
+
+      def choose_best_types
+        type_map = {}
+        @types.each do |row|
+          name = row['type_name'].downcase
+          k = name.to_sym
+          type_map[k] = { :name => name }
+          type_map[k][:limit] = row['precision'].to_i if row['precision']
+        end
+
+        AR_TO_JDBC_TYPES.keys.each do |k|
+          typerow = choose_type(k)
+          type_map[k] = { :name => typerow['type_name'].downcase }
+          case k
+          when :integer, :string, :decimal
+            type_map[k][:limit] = typerow['precision'] && typerow['precision'].to_i
+          when :boolean
+            type_map[k][:limit] = 1
+          end
+        end
+        type_map
+      end
+
+      def choose_type(ar_type)
+        procs = AR_TO_JDBC_TYPES[ar_type]
+        types = @types
+        procs.each do |p|
+          new_types = types.reject {|r| r["data_type"].to_i == Jdbc::Types::OTHER}
+          new_types = new_types.select(&p)
+          new_types = new_types.inject([]) do |typs,t|
+            typs << t unless typs.detect {|el| el['type_name'] == t['type_name']}
+            typs
+          end
+          return new_types.first if new_types.length == 1
+          types = new_types if new_types.length > 0
+        end
+        raise "unable to choose type for #{ar_type} from:\n#{types.collect{|t| t['type_name']}.inspect}"
+      end
+    end
+  end
+end

data/lib/arjdbc/jdbc.rb

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

data/lib/{jdbc_adapter/jdbc_mimer.rb → arjdbc/mimer/adapter.rb}

@@ -1,11 +1,8 @@
-module JdbcSpec
+module ArJdbc
   module Mimer
     def self.extended(mod)
-      ActiveRecord::Base.extend JdbcSpec::QuotedPrimaryKeyExtension
-    end
-
-    def self.adapter_matcher(name, *)
-      name =~ /mimer/i ? self : false
+      require 'arjdbc/jdbc/quoted_primary_key'
+      ActiveRecord::Base.extend ArJdbc::QuotedPrimaryKeyExtension
     end
 
     def modify_types(tp)
@@ -20,7 +17,7 @@ module JdbcSpec
       tp[:date] = { :name => "TIMESTAMP" }
       tp
     end
-    
+
     def default_sequence_name(table, column) #:nodoc:
       "#{table}_seq"
     end
@@ -54,13 +51,13 @@ module JdbcSpec
         log(sql, name) { @connection.execute_insert sql,pk }
       else # Assume the sql contains a bind-variable for the id
         id_value = select_one("SELECT NEXT_VALUE OF #{sequence_name} AS val FROM MIMER.ONEROW")['val']
-        log(sql, name) { 
+        log(sql, name) {
           execute_prepared_insert(sql,id_value)
         }
       end
       id_value
     end
-    
+
     def execute_prepared_insert(sql, id)
       @stmts ||= {}
       @stmts[sql] ||= @connection.ps(sql)
@@ -72,24 +69,24 @@ module JdbcSpec
 
     def quote(value, column = nil) #:nodoc:
       return value.quoted_id if value.respond_to?(:quoted_id)
-      
+
       if String === value && column && column.type == :binary
         return "X'#{quote_string(value.unpack("C*").collect {|v| v.to_s(16)}.join)}'"
       end
       case value
-      when String     
+      when String
         %Q{'#{quote_string(value)}'}
-      when NilClass   
+      when NilClass
         'NULL'
-      when TrueClass  
+      when TrueClass
         '1'
-      when FalseClass 
+      when FalseClass
         '0'
-      when Numeric    
+      when Numeric
         value.to_s
-      when Date, Time 
+      when Date, Time
         %Q{TIMESTAMP '#{value.strftime("%Y-%m-%d %H:%M:%S")}'}
-      else              
+      else
         %Q{'#{quote_string(value.to_yaml)}'}
       end
     end
@@ -106,7 +103,7 @@ module JdbcSpec
       @limit = options[:limit]
       @offset = options[:offset]
     end
-    
+
     def select_all(sql, name = nil)
       @offset ||= 0
       if !@limit || @limit == -1
@@ -118,7 +115,7 @@ module JdbcSpec
     ensure
       @limit = @offset = nil
     end
-    
+
     def select_one(sql, name = nil)
       @offset ||= 0
       select(sql, name)[@offset]

data/lib/arjdbc/mimer.rb

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

data/lib/{jdbc_adapter/jdbc_mssql.rb → arjdbc/mssql/adapter.rb}

@@ -1,22 +1,7 @@
-require 'jdbc_adapter/tsql_helper'
-
-module ::JdbcSpec
-
-  module ActiveRecordExtensions
-
-    def mssql_connection(config)
-      require "active_record/connection_adapters/mssql_adapter"
-      config[:host] ||= "localhost"
-      config[:port] ||= 1433
-      config[:url] ||= "jdbc:jtds:sqlserver://#{config[:host]}:#{config[:port]}/#{config[:database]}"
-      config[:driver] ||= "net.sourceforge.jtds.jdbc.Driver"
-      embedded_driver(config)
-    end
-
-  end
+require 'arjdbc/mssql/tsql_helper'
 
+module ::ArJdbc
   module MsSQL
-
     include TSqlMethods
 
     def self.extended(mod)
@@ -39,12 +24,8 @@ module ::JdbcSpec
       mod.add_version_specific_add_limit_offset
     end
 
-    def self.adapter_matcher(name, *)
-      name =~ /sqlserver|tds/i ? self : false
-    end
-
     def self.column_selector
-      [/sqlserver|tds/i, lambda {|cfg,col| col.extend(::JdbcSpec::MsSQL::Column)}]
+      [/sqlserver|tds/i, lambda {|cfg,col| col.extend(::ArJdbc::MsSQL::Column)}]
     end
 
     def self.jdbc_connection_class
@@ -102,7 +83,7 @@ module ::JdbcSpec
       def type_cast(value)
         return nil if value.nil? || value == "(null)" || value == "(NULL)"
         case type
-        when :integer then unquote(value).to_i rescue value ? 1 : 0
+        when :integer then value.to_i rescue unquote(value).to_i rescue value ? 1 : 0
         when :primary_key then value == true || value == false ? value == true ? 1 : 0 : value.to_i
         when :decimal   then self.class.value_to_decimal(unquote(value))
         when :datetime  then cast_to_datetime(value)
@@ -165,7 +146,7 @@ module ::JdbcSpec
       when String, ActiveSupport::Multibyte::Chars
         value = value.to_s
         if column && column.type == :binary
-          "'#{quote_string(JdbcSpec::MsSQL::Column.string_to_binary(value))}'" # ' (for ruby-mode)
+          "'#{quote_string(ArJdbc::MsSQL::Column.string_to_binary(value))}'" # ' (for ruby-mode)
         elsif column && [:integer, :float].include?(column.type)
           value = column.type == :integer ? value.to_i : value.to_f
           value.to_s
@@ -209,7 +190,7 @@ module ::JdbcSpec
           end_row = offset + limit.to_i
           order = (options[:order] || determine_order_clause(sql))
           sql.sub!(/ ORDER BY.*$/i, '')
-          find_select = /\b(SELECT(?:\s+DISTINCT)?)\b(.*)/i
+          find_select = /\b(SELECT(?:\s+DISTINCT)?)\b(.*)/im
           whole, select, rest_of_query = find_select.match(sql).to_a
           if (start_row == 1) && (end_row ==1)
             new_sql = "#{select} TOP 1 #{rest_of_query}"
@@ -240,7 +221,7 @@ module ::JdbcSpec
           end_row = offset + limit.to_i
           order = (options[:order] || determine_order_clause(sql))
           sql.sub!(/ ORDER BY.*$/i, '')
-          find_select = /\b(SELECT(?:\s+DISTINCT)?)\b(.*)/i
+          find_select = /\b(SELECT(?:\s+DISTINCT)?)\b(.*)/im
           whole, select, rest_of_query = find_select.match(sql).to_a
           new_sql = "#{select} t.* FROM (SELECT ROW_NUMBER() OVER(ORDER BY #{order}) AS row_num, #{rest_of_query}"
           new_sql << ") AS t WHERE t.row_num BETWEEN #{start_row.to_s} AND #{end_row.to_s}"
@@ -371,6 +352,12 @@ module ::JdbcSpec
       end
     end
 
+    def select(sql, name = nil)
+      log(sql, name) do
+        @connection.execute_query(sql)
+      end
+    end
+
     #SELECT .. FOR UPDATE is not supported on Microsoft SQL Server
     def add_lock!(sql, options)
       sql
@@ -452,17 +439,18 @@ module ::JdbcSpec
 
     def determine_order_clause(sql)
       return $1 if sql =~ /ORDER BY (.*)$/
-      sql =~ /FROM +(\w+?)\b/ || raise("can't determine table name")
-      table_name = $1
+      table_name = get_table_name(sql)
       "#{table_name}.#{determine_primary_key(table_name)}"
     end
 
     def determine_primary_key(table_name)
       primary_key = columns(table_name).detect { |column| column.primary || column.identity }
-      primary_key ? primary_key.name : "id"
+      return primary_key.name if primary_key
+      # Look for an id column.  Return it, without changing case, to cover dbs with a case-sensitive collation.
+      columns(table_name).each { |column| return column.name if column.name =~ /^id$/i }
+      # Give up and provide something which is going to crash almost certainly
+      "id"
     end
-
   end
-
 end
 

data/lib/arjdbc/mssql/connection_methods.rb

@@ -0,0 +1,13 @@
+class ActiveRecord::Base
+  class << self
+    def mssql_connection(config)
+      require "arjdbc/mssql"
+      config[:host] ||= "localhost"
+      config[:port] ||= 1433
+      config[:url] ||= "jdbc:jtds:sqlserver://#{config[:host]}:#{config[:port]}/#{config[:database]}"
+      config[:driver] ||= "net.sourceforge.jtds.jdbc.Driver"
+      embedded_driver(config)
+    end
+    alias_method :jdbcmssql_connection, :mssql_connection
+  end
+end

data/lib/arjdbc/mssql.rb

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