ActiveRecord-JDBC 0.0.1 → 0.2.0

data/LICENSE

@@ -1,4 +1,5 @@
 Copyright (c) 2006 Nick Sieger <nick@nicksieger.com>
+Copyright (c) 2006 Ola Bini <ola@ologix.com>
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/install.rb

@@ -1,25 +1,25 @@
-
-require 'fileutils'
-
-from_d=File.expand_path(File.join(File.dirname(__FILE__),'lib','active_record'))
-to_d=File.expand_path(File.join(RAILS_ROOT,'lib','active_record'))
-
-FileUtils.cp_r from_d, to_d
-
-env_file = File.expand_path(File.join(RAILS_ROOT,"config","environment.rb"))
-bck_file = File.expand_path(File.join(RAILS_ROOT,"config","~.environment.rb.before_jdbc"))
-
-FileUtils.mv env_file,bck_file
-
-File.open(bck_file,"r") {|inf|
-  File.open(env_file,"w") {|out|
-    inf.each_line do |ln|
-      if ln =~ /^Rails::Initializer\.run/
-        out.puts "# Added by ActiveRecord JDBC plugin"
-        out.puts "RAILS_CONNECTION_ADAPTERS = %w( jdbc mysql postgresql sqlite firebird sqlserver db2 oracle sybase openbase )"
-        out.puts
-      end
-      out.puts ln
-    end
-  }
-}
+
+require 'fileutils'
+
+from_d=File.expand_path(File.join(File.dirname(__FILE__),'lib','active_record'))
+to_d=File.expand_path(File.join(RAILS_ROOT,'lib','active_record'))
+
+FileUtils.cp_r from_d, to_d
+
+env_file = File.expand_path(File.join(RAILS_ROOT,"config","environment.rb"))
+bck_file = File.expand_path(File.join(RAILS_ROOT,"config","~.environment.rb.before_jdbc"))
+
+FileUtils.mv env_file,bck_file
+
+File.open(bck_file,"r") {|inf|
+  File.open(env_file,"w") {|out|
+    inf.each_line do |ln|
+      if ln =~ /^Rails::Initializer\.run/
+        out.puts "# Added by ActiveRecord JDBC plugin"
+        out.puts "require 'jdbc_adapter'"
+        out.puts
+      end
+      out.puts ln
+    end
+  }
+}

data/lib/active_record/connection_adapters/jdbc_adapter.rb

@@ -1,10 +1,20 @@
 require 'active_record/connection_adapters/abstract_adapter'
+require 'active_record/connection_adapters/jdbc_adapter_spec'
 
 module ActiveRecord
   class Base
     def self.jdbc_connection(config)
       ConnectionAdapters::JdbcAdapter.new(ConnectionAdapters::JdbcConnection.new(config), logger, config)
     end
+
+    alias :attributes_with_quotes_pre_oracle :attributes_with_quotes
+    def attributes_with_quotes(include_primary_key = true) #:nodoc:
+      aq = attributes_with_quotes_pre_oracle(include_primary_key)
+      if connection.class == ConnectionAdapters::JdbcAdapter && connection.is_a?(JdbcSpec::Oracle)
+        aq[self.class.primary_key] = "?" if include_primary_key && aq[self.class.primary_key].nil?
+      end
+      aq
+    end
   end
 
   module ConnectionAdapters
@@ -29,25 +39,37 @@ module ActiveRecord
       # 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      => [ proc {|r| Jdbc::Types::VARCHAR == r['data_type']},
-                          proc {|r| r['type_name'] =~ /^varchar/i} ],
-        :text        => [ proc {|r| [Jdbc::Types::LONGVARCHAR, Jdbc::Types::CLOB].include?(r['data_type'])},
-                          proc {|r| r['type_name'] =~ /^(text|clob)/i} ],
-        :integer     => [ proc {|r| Jdbc::Types::INTEGER == r['data_type']},
-                          proc {|r| r['type_name'] =~ /^integer/i} ],
-        :float       => [ proc {|r| [Jdbc::Types::FLOAT,Jdbc::Types::DOUBLE].include?(r['data_type'])},
-                          proc {|r| r['type_name'] =~ /^float/i},
-                          proc {|r| r['type_name'] =~ /^double$/i} ],
-        :datetime    => [ proc {|r| Jdbc::Types::TIMESTAMP == r['data_type']},
-                          proc {|r| r['type_name'] =~ /^datetime/i} ],
-        :timestamp   => [ proc {|r| Jdbc::Types::TIMESTAMP == r['data_type']},
-                          proc {|r| r['type_name'] =~ /^timestamp/i},
-                          proc {|r| r['type_name'] =~ /^datetime/i} ],
-        :time        => [ proc {|r| Jdbc::Types::TIME == r['data_type']} ],
-        :date        => [ proc {|r| Jdbc::Types::DATE == r['data_type']} ],
-        :binary      => [ proc {|r| Jdbc::Types::LONGVARBINARY == r['data_type']},
-                          proc {|r| r['type_name'] =~ /^blob/i} ],
-        :boolean     => [ proc {|r| Jdbc::Types::TINYINT == r['data_type']} ]
+        :string      => [ lambda {|r| Jdbc::Types::VARCHAR == r['data_type']},
+                          lambda {|r| r['type_name'] =~ /^varchar/i},
+                          lambda {|r| r['type_name'] =~ /^varchar$/i}],
+        :text        => [ lambda {|r| [Jdbc::Types::LONGVARCHAR, Jdbc::Types::CLOB].include?(r['data_type'])},
+                          lambda {|r| r['type_name'] =~ /^(text|clob)/i} ],
+        :integer     => [ lambda {|r| Jdbc::Types::INTEGER == r['data_type']},
+                          lambda {|r| r['type_name'] =~ /^integer$/i},
+                          lambda {|r| r['type_name'] =~ /^int4$/i},
+                          lambda {|r| r['type_name'] =~ /^int$/i}],
+        :float       => [ lambda {|r| [Jdbc::Types::FLOAT,Jdbc::Types::DOUBLE].include?(r['data_type'])},
+                          lambda {|r| r['type_name'] =~ /^float/i},
+                          lambda {|r| r['type_name'] =~ /^double$/i} ],
+        :datetime    => [ lambda {|r| Jdbc::Types::TIMESTAMP == r['data_type']},
+                          lambda {|r| r['type_name'] =~ /^datetime/i},
+                          lambda {|r| r['type_name'] =~ /^timestamp$/i}],
+        :timestamp   => [ lambda {|r| Jdbc::Types::TIMESTAMP == r['data_type']},
+                          lambda {|r| r['type_name'] =~ /^timestamp$/i},
+                          lambda {|r| r['type_name'] =~ /^datetime/i} ],
+        :time        => [ lambda {|r| Jdbc::Types::TIME == r['data_type']},
+                          lambda {|r| r['type_name'] =~ /^time$/i},
+                          lambda {|r| r['type_name'] =~ /^datetime$/i}],
+        :date        => [ lambda {|r| Jdbc::Types::DATE == r['data_type']},
+                          lambda {|r| r['type_name'] =~ /^datetime$/i}],
+        :binary      => [ lambda {|r| [Jdbc::Types::LONGVARBINARY,Jdbc::Types::BINARY,Jdbc::Types::BLOB].include?(r['data_type'])},
+                          lambda {|r| r['type_name'] =~ /^blob/i},
+                          lambda {|r| r['type_name'] =~ /sub_type 0$/i}, # For FireBird
+                          lambda {|r| r['type_name'] =~ /^binary$/i}, ],
+        :boolean     => [ lambda {|r| [Jdbc::Types::TINYINT].include?(r['data_type'])},
+                          lambda {|r| r['type_name'] =~ /^bool/i},
+                          lambda {|r| r['type_name'] =~ /^tinyint$/i},
+                          lambda {|r| r['type_name'] =~ /^decimal$/i}]
       }
 
       def initialize(types)
@@ -59,7 +81,7 @@ module ActiveRecord
         AR_TO_JDBC_TYPES.each_key do |k|
           typerow = choose_type(k)
           type_map[k] = { :name => typerow['type_name']  }
-          type_map[k][:limit] = typerow['precision'] if [:integer,:string].include?(k)
+          type_map[k][:limit] = typerow['precision'] if [:integer, :string].include?(k)
           type_map[k][:limit] = 1 if k == :boolean
         end
         type_map
@@ -73,7 +95,7 @@ module ActiveRecord
           return new_types.first if new_types.length == 1
           types = new_types if new_types.length > 0
         end
-        raise "unable to choose type from: #{types.collect{|t| t['type_name']}.inspect}"
+        raise "unable to choose type from: #{types.collect{|t| t['type_name']}.inspect} for #{ar_type}"
       end
     end
 
@@ -90,13 +112,36 @@ module ActiveRecord
       end
     end
 
+    class JdbcColumn < Column
+      def initialize(config, name, default, *args)
+        case config[:driver].to_s
+          when /oracle/i: self.extend(JdbcSpec::Oracle::Column)
+          when /postgre/i: self.extend(JdbcSpec::PostgreSQL::Column)
+          when /sqlserver|tds/i: self.extend(JdbcSpec::MsSQL::Column)
+          when /hsqldb/i: self.extend(JdbcSpec::HSQLDB::Column)
+          when /derby/i: self.extend(JdbcSpec::Derby::Column)
+          when /db2/i: 
+            if config[:url] =~ /^jdbc:derby:net:/
+              self.extend(JdbcSpec::Derby::Column)
+            else
+              self.extend(JdbcSpec::DB2::Column)
+            end
+        end
+        super(name,default_value(default),*args)
+      end    
+
+      def default_value(val)
+        val
+      end
+    end
+    
     class JdbcConnection
       def initialize(config)
-        config = config.symbolize_keys
-        driver = config[:driver].to_s
-        user   = config[:username].to_s
-        pass   = config[:password].to_s
-        url    = config[:url].to_s
+        @config = config.symbolize_keys
+        driver = @config[:driver].to_s
+        user   = @config[:username].to_s
+        pass   = @config[:password].to_s
+        url    = @config[:url].to_s
 
         unless driver && url
           raise ArgumentError, "jdbc adapter requires driver class and url"
@@ -105,29 +150,35 @@ module ActiveRecord
         JdbcDriver.load(driver)
         @connection = Jdbc::DriverManager.getConnection(url, user, pass)
         set_native_database_types
+
+        @stmts = {}
+      rescue Exception => e
+        raise "The driver encounter an error: #{e}"
       end
 
+      def ps(sql)
+        @connection.prepareStatement(sql)
+      end
+      
       def set_native_database_types
         types = unmarshal_result(@connection.getMetaData.getTypeInfo)
         @native_types = JdbcTypeConverter.new(types).choose_best_types
       end
 
-      def native_database_types
-        types = {
-          # TODO: this is copied from MySQL -- figure out how to
-          # generalize the primary key type
-          :primary_key => "int(11) DEFAULT NULL auto_increment PRIMARY KEY",
-        }
+      def native_database_types(adapt)
+        types = {}
         @native_types.each_pair {|k,v| types[k] = v.inject({}) {|memo,kv| memo.merge({kv.first => kv.last.dup})}}
-        types
+        adapt.modify_types(types)
       end
-
+      
       def columns(table_name, name = nil)
         metadata = @connection.getMetaData
+        table_name.upcase! if metadata.storesUpperCaseIdentifiers
+        table_name.downcase! if metadata.storesLowerCaseIdentifiers
         results = metadata.getColumns(nil, nil, table_name, nil)
         columns = []
         unmarshal_result(results).each do |col|
-          columns << ActiveRecord::ConnectionAdapters::Column.new(col['column_name'], col['column_def'],
+          columns << ActiveRecord::ConnectionAdapters::JdbcColumn.new(@config,col['column_name'].downcase, col['column_def'],
               "#{col['type_name']}(#{col['column_size']})", col['is_nullable'] != 'NO')
         end
         columns
@@ -141,7 +192,7 @@ module ActiveRecord
 
       def execute_insert(sql, pk)
         stmt = @connection.createStatement
-        stmt.executeUpdate(sql, Jdbc::Statement::RETURN_GENERATED_KEYS)
+        stmt.executeUpdate(sql,Jdbc::Statement::RETURN_GENERATED_KEYS)
         row = unmarshal_result(stmt.getGeneratedKeys)
         row.first && row.first.values.first
       ensure
@@ -218,18 +269,22 @@ module ActiveRecord
           decimal.to_f
         else
           case type
-          when Jdbc::Types::CHAR, Jdbc::Types::VARCHAR, Jdbc::Types::LONGVARCHAR
+          when Jdbc::Types::CHAR, Jdbc::Types::VARCHAR, Jdbc::Types::LONGVARCHAR, Jdbc::Types::CLOB
             resultset.getString(row)
           when Jdbc::Types::SMALLINT, Jdbc::Types::INTEGER, Jdbc::Types::NUMERIC, Jdbc::Types::BIGINT
             resultset.getInt(row)
-          when Jdbc::Types::BIT, Jdbc::Types::BOOLEAN, Jdbc::Types::TINYINT
+          when Jdbc::Types::BIT, Jdbc::Types::BOOLEAN, Jdbc::Types::TINYINT, Jdbc::Types::DECIMAL
             resultset.getBoolean(row)
+          when Jdbc::Types::FLOAT, Jdbc::Types::DOUBLE
+            resultset.getDouble(row)
           when Jdbc::Types::TIMESTAMP
             to_ruby_time(resultset.getTimestamp(row))
           when Jdbc::Types::TIME
             to_ruby_time(resultset.getTime(row))
           when Jdbc::Types::DATE
             to_ruby_time(resultset.getDate(row))
+          when Jdbc::Types::LONGVARBINARY, Jdbc::Types::BLOB, Jdbc::Types::BINARY
+            resultset.getString(row)
           else
             types = Jdbc::Types.constants
             name = types.find {|t| Jdbc::Types.const_get(t.to_sym) == type}
@@ -243,8 +298,27 @@ module ActiveRecord
       def initialize(connection, logger, config)
         super(connection, logger)
         @config = config
+        case config[:driver].to_s
+          when /oracle/i: self.extend(JdbcSpec::Oracle)
+          when /postgre/i: self.extend(JdbcSpec::PostgreSQL)
+          when /mysql/i: self.extend(JdbcSpec::MySQL)
+          when /sqlserver|tds/i: self.extend(JdbcSpec::MsSQL)
+          when /hsqldb/i: self.extend(JdbcSpec::HSQLDB)
+          when /derby/i: self.extend(JdbcSpec::Derby)
+          when /db2/i: 
+            if config[:url] =~ /^jdbc:derby:net:/
+              self.extend(JdbcSpec::Derby)
+            else
+              self.extend(JdbcSpec::DB2)
+            end
+          when /firebird/i: self.extend(JdbcSpec::FireBird)
+        end
       end
 
+      def modify_types(tp)
+        tp
+      end
+      
       def adapter_name #:nodoc:
         'JDBC'
       end
@@ -254,16 +328,51 @@ module ActiveRecord
       end
 
       def native_database_types #:nodoc
-        @connection.native_database_types
+        @connection.native_database_types(self)
       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?
         true
       end
 
       def reconnect!
         @connection.close rescue nil
-        @connection = JdbcConnection.new(@config)
+        @connection = JdbcConnection.new(@config,self)
       end
 
       def select_all(sql, name = nil)
@@ -276,7 +385,7 @@ module ActiveRecord
 
       def execute(sql, name = nil)
         log_no_bench(sql, name) do
-          if sql =~ /^select/i
+          if sql =~ /^(select|show)/i
             @connection.execute_query(sql)
           else
             @connection.execute_update(sql)
@@ -284,21 +393,6 @@ module ActiveRecord
         end
       end
 
-      # Oracle doesn't support limit and offset. Fake it instead.
-      def add_limit_offset!(sql, options) #:nodoc:
-        if /oracle/ =~ @config[:driver]
-          offset = options[:offset] || 0
-        
-          if limit = options[:limit]
-            sql.replace "select * from (select raw_sql_.*, rownum raw_rnum_ from (#{sql}) raw_sql_ where rownum <= #{offset+limit}) where raw_rnum_ > #{offset}"
-          elsif offset > 0
-            sql.replace "select * from (select raw_sql_.*, rownum raw_rnum_ from (#{sql}) raw_sql_) where raw_rnum_ > #{offset}"
-          end
-        else
-          super
-        end
-      end
-      
       alias :update :execute
       alias :delete :execute
 
@@ -330,7 +424,7 @@ module ActiveRecord
       end
 
       private
-      def select(sql, name)
+      def select(sql, name=nil)
         log_no_bench(sql, name) { @connection.execute_query(sql) }
       end