ActiveRecord-JDBC 0.2.3 → 0.2.4

data/lib/jdbc_adapter.rb

@@ -4,6 +4,9 @@ if RUBY_PLATFORM =~ /java/
   else
     RAILS_CONNECTION_ADAPTERS = %w(jdbc)
   end
+  if defined?(RAILS_GEM_VERSION) && RAILS_GEM_VERSION =~ /1\.1\.\d+/
+    require 'active_record/connection_adapters/jdbc_adapter'
+  end
 else
-  raise "ActiveRecord-JDBC is for use with JRuby only"
-end
+  $stderr.print "warning: ActiveRecord-JDBC is for use with JRuby only\n"
+end

data/lib/jdbc_adapter/jdbc_derby.rb

@@ -1,3 +1,5 @@
+require 'jdbc_adapter/missing_functionality_helper'
+
 module JdbcSpec
   module Derby
     module Column
@@ -34,6 +36,8 @@ module JdbcSpec
       end
     end
 
+    include JdbcSpec::MissingFunctionalityHelper
+    
     def modify_types(tp)
       tp[:primary_key] = "int generated by default as identity NOT NULL PRIMARY KEY"
       tp[:integer][:limit] = nil
@@ -46,20 +50,35 @@ module JdbcSpec
     end
     
     def select_all(sql, name = nil)
-      @limit ||= -1
-      @offset ||= 0
-      select(sql, name)[@offset..(@offset+@limit)]
-    ensure
-      @limit = @offset = nil
+      execute(sql, name)
     end
     
     def select_one(sql, name = nil)
-      @offset ||= 0
-      select(sql, name)[@offset]
+      @limit ||= 1
+      execute(sql, name).first
     ensure
-      @limit = @offset = nil
+      @limit = nil
+    end
+    
+    def classes_for_table_name(table)
+      ActiveRecord::Base.send(:subclasses).select {|klass| klass.table_name == table}
     end
 
+    # Set the sequence to the max value of the table's column.
+    def reset_sequence!(table, column, sequence = nil)
+      mpk = select_value("SELECT MAX(#{column}) FROM #{table}")
+      execute("ALTER TABLE #{table} ALTER COLUMN #{column} RESTART WITH #{mpk.to_i + 1}")      
+    end
+      
+    def reset_pk_sequence!(table, pk = nil, sequence = nil)
+      klasses = classes_for_table_name(table)
+      klass   = klasses.nil? ? nil : klasses.first
+      pk      = klass.primary_key unless klass.nil?
+      if pk && klass.columns_hash[pk].type == :integer
+        reset_sequence!(klass.table_name, pk)
+      end
+    end
+    
     def execute(sql, name = nil)
       log_no_bench(sql, name) do
         if sql =~ /^select/i
@@ -74,6 +93,10 @@ module JdbcSpec
       @limit = @offset = nil
     end
 
+    def primary_key(table_name) #:nodoc:
+      primary_keys(table_name).first
+    end
+
     def remove_index(table_name, options) #:nodoc:
       execute "DROP INDEX #{index_name(table_name, options)}"
     end
@@ -87,10 +110,16 @@ module JdbcSpec
     #
     # This feature has not made it into a formal release and is not in Java 6.  We will
     # need to conditionally support this somehow (supposed to arrive for 10.3.0.0)
-    #
-    # def remove_column(table_name, column_name)
-    #  execute "ALTER TABLE #{table_name} DROP COLUMN #{column_name} RESTRICT"
-    # end
+    def remove_column(table_name, column_name)
+      begin
+        execute "ALTER TABLE #{table_name} DROP COLUMN #{column_name} RESTRICT"
+      rescue
+        alter_table(table_name) do |definition|
+          definition.columns.delete(definition[column_name])
+        end
+#        raise NotImplementedError, "remove_column is not support on this Derby version"
+      end
+    end
     
     # Notes about changing in Derby:
     #    http://db.apache.org/derby/docs/10.2/ref/rrefsqlj81859.html#rrefsqlj81859__rrefsqlj37860)
@@ -98,7 +127,16 @@ module JdbcSpec
     #   can increase the types precision only if it is a VARCHAR.
     #
     def change_column(table_name, column_name, type, options = {}) #:nodoc:
-      execute "ALTER TABLE #{table_name} ALTER COLUMN #{column_name} SET DATA TYPE #{type_to_sql(type, options[:limit])}"
+      # Derby can't change the datatype or size unless the type is varchar
+      execute "ALTER TABLE #{table_name} ALTER COLUMN #{column_name} SET DATA TYPE #{type_to_sql(type, options[:limit])}" if type == :string
+      if options.include? :null
+        # This seems to only work with 10.2 of Derby
+        if options[:null] == false
+          execute "ALTER TABLE #{table_name} ALTER COLUMN #{column_name} NOT NULL"
+        else
+          execute "ALTER TABLE #{table_name} ALTER COLUMN #{column_name} NULL"
+        end
+      end
     end
 
     def change_column_default(table_name, column_name, default) #:nodoc:

data/lib/jdbc_adapter/jdbc_mysql.rb

@@ -2,9 +2,41 @@ require 'active_record/connection_adapters/abstract/schema_definitions'
 
 module JdbcSpec
   module MySQL
+    def self.extended(adapter)
+      adapter.execute("SET SQL_AUTO_IS_NULL=0")
+    end
+    
+    module Column
+      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 :string  if field_type =~ /enum/i
+        super
+      end
+
+      def init_column(name, default, *args)
+        @original_default = default
+        @default = nil if missing_default_forged_as_empty_string?
+      end
+      
+      # MySQL misreports NOT NULL column default when none is given.
+      # We can't detect this for columns which may have a legitimate ''
+      # default (string, text, binary) but we can for others (integer,
+      # datetime, boolean, and the rest).
+      #
+      # Test whether the column has default '', is not null, and is not
+      # a type allowing default ''.
+      def missing_default_forged_as_empty_string?
+        !null && @original_default == '' && !TYPES_ALLOWING_EMPTY_STRING_DEFAULT.include?(type)
+      end
+    end
+    
     def modify_types(tp)
       tp[:primary_key] = "int(11) DEFAULT NULL auto_increment PRIMARY KEY"
       tp[:decimal] = { :name => "decimal" }
+      tp[:timestamp] = { :name => "datetime" }
+      tp[:datetime][:limit] = nil
       tp
     end
     
@@ -12,9 +44,15 @@ module JdbcSpec
     
     def quote(value, column = nil)
       if column && column.type == :primary_key
-        return value.to_s
+        value.to_s
+      elsif column && String === value && column.type == :binary && column.class.respond_to?(:string_to_binary)
+        s = column.class.string_to_binary(value).unpack("H*")[0]
+        "x'#{s}'"
+      elsif BigDecimal === value
+        "'#{value.to_s("F")}'"
+      else
+        super
       end
-      super
     end
     
     def quote_column_name(name) #:nodoc:
@@ -23,15 +61,7 @@ module JdbcSpec
 
     # from active_record/vendor/mysql.rb
     def quote_string(str) #:nodoc:
-      str.gsub(/([\0\n\r\032\'\"\\])/) do
-        case $1
-        when "\0" then "\\0"
-        when "\n" then "\\n"
-        when "\r" then "\\r"
-        when "\032" then "\\Z"
-        else "\\"+$1
-        end
-      end
+      @connection.mysql_quote_string(str)
     end
     
     def quoted_true
@@ -87,24 +117,39 @@ module JdbcSpec
     end  
     
     def change_column_default(table_name, column_name, default) #:nodoc:
-      current_type = select_one("SHOW COLUMNS FROM #{table_name} LIKE '#{column_name}'")["type"]
+      current_type = select_one("SHOW COLUMNS FROM #{table_name} LIKE '#{column_name}'")["Type"]
 
-      type, limit = native_sql_to_type(current_type)
-      
-      change_column(table_name, column_name, type, { :default => default, :limit => limit })
+      execute("ALTER TABLE #{table_name} CHANGE #{column_name} #{column_name} #{current_type} DEFAULT #{quote(default)}")
     end
     
     def change_column(table_name, column_name, type, options = {}) #:nodoc:
-      options[:default] ||= select_one("SHOW COLUMNS FROM #{table_name} LIKE '#{column_name}'")["default"]
+      unless options.include?(:default) && !(options[:null] == false && options[:default].nil?)
+        options[:default] = select_one("SHOW COLUMNS FROM #{table_name} LIKE '#{column_name}'")["Default"]
+      end
       
-      change_column_sql = "ALTER TABLE #{table_name} CHANGE #{column_name} #{column_name} #{type_to_sql(type, options[:limit])}"
+      change_column_sql = "ALTER TABLE #{table_name} CHANGE #{column_name} #{column_name} #{type_to_sql(type, options[:limit], options[:precision], options[:scale])}"
       add_column_options!(change_column_sql, options)
       execute(change_column_sql)
     end
     
     def rename_column(table_name, column_name, new_column_name) #:nodoc:
-      current_type = select_one("SHOW COLUMNS FROM #{table_name} LIKE '#{column_name}'")["type"]
+      current_type = select_one("SHOW COLUMNS FROM #{table_name} LIKE '#{column_name}'")["Type"]
       execute "ALTER TABLE #{table_name} CHANGE #{column_name} #{new_column_name} #{current_type}"
     end
+    
+    def add_limit_offset!(sql, options) #:nodoc:
+      if limit = options[:limit]
+        unless offset = options[:offset]
+          sql << " LIMIT #{limit}"
+        else
+          sql << " LIMIT #{offset}, #{limit}"
+        end
+      end
+    end
+
+    private
+    def supports_views?
+      false
+    end
   end
 end

data/lib/jdbc_adapter/missing_functionality_helper.rb

@@ -0,0 +1,72 @@
+module JdbcSpec
+  module MissingFunctionalityHelper
+    #Taken from SQLite adapter
+
+    def alter_table(table_name, options = {}) #:nodoc:
+      table_name = table_name.downcase
+      altered_table_name = "altered_#{table_name}"
+      caller = lambda {|definition| yield definition if block_given?}
+
+      transaction do
+        move_table(table_name, altered_table_name)
+        move_table(altered_table_name, table_name, &caller)
+      end
+    end
+    
+    def move_table(from, to, options = {}, &block) #:nodoc:
+      copy_table(from, to, options, &block)
+      drop_table(from)
+    end
+
+    def copy_table(from, to, options = {}) #:nodoc:
+      create_table(to, options) do |@definition|
+        columns(from).each do |column|
+          column_name = options[:rename] ?
+          (options[:rename][column.name] ||
+           options[:rename][column.name.to_sym] ||
+           column.name) : column.name
+
+          @definition.column(column_name, column.type, 
+                             :limit => column.limit, :default => column.default,
+                             :null => column.null)
+        end
+        @definition.primary_key(primary_key(from))
+        yield @definition if block_given?
+      end
+      
+      copy_table_indexes(from, to)
+      copy_table_contents(from, to, 
+                          @definition.columns.map {|column| column.name}, 
+                          options[:rename] || {})
+    end
+    
+    def copy_table_indexes(from, to) #:nodoc:
+      indexes(from).each do |index|
+        name = index.name.downcase
+        if to == "altered_#{from}"
+          name = "temp_#{name}"
+        elsif from == "altered_#{to}"
+          name = name[5..-1]
+        end
+        
+        # index name can't be the same
+        opts = { :name => name.gsub(/_(#{from})_/, "_#{to}_") }
+        opts[:unique] = true if index.unique
+        add_index(to, index.columns, opts)
+      end
+    end
+    
+    def copy_table_contents(from, to, columns, rename = {}) #:nodoc:
+      column_mappings = Hash[*columns.map {|name| [name, name]}.flatten]
+      rename.inject(column_mappings) {|map, a| map[a.last] = a.first; map}
+      from_columns = columns(from).collect {|col| col.name}
+      columns = columns.find_all{|col| from_columns.include?(column_mappings[col])}
+      execute("SELECT * FROM #{from}").each do |row|
+        sql = "INSERT INTO #{to} ("+columns*','+") VALUES ("            
+        sql << columns.map {|col| quote row[column_mappings[col]]} * ', '
+        sql << ')'
+        execute sql
+      end
+    end
+  end
+end

data/test/db/derby.rb

@@ -17,5 +17,5 @@ at_exit {
   # Clean up derby files
   require 'fileutils'
   Dir.glob('derby-testdb/**/*') {|f| File.delete(f)}
-  FileUtils.rm_r('derby-testdb')
-}
+  FileUtils.rm_rf('derby-testdb')
+}

data/test/db/jndi_config.rb

@@ -0,0 +1,30 @@
+require 'fileutils'
+require 'active_record/connection_adapters/jdbc_adapter'
+
+System = java.lang.System
+Context = javax.naming.Context
+InitialContext = javax.naming.InitialContext
+Reference = javax.naming.Reference
+StringRefAddr = javax.naming.StringRefAddr
+  
+System.set_property(Context::INITIAL_CONTEXT_FACTORY,
+                    'com.sun.jndi.fscontext.RefFSContextFactory')
+project_path = File.expand_path(File.dirname(__FILE__) + '/../..')
+jndi_dir = project_path + '/jndi_test'
+jdbc_dir = jndi_dir + '/jdbc'
+FileUtils.mkdir_p jdbc_dir unless File.exist?(jdbc_dir)
+
+System.set_property(Context::PROVIDER_URL, "file://#{jndi_dir}")
+derby_ref = Reference.new('javax.sql.DataSource',
+                          'org.apache.commons.dbcp.BasicDataSourceFactory',
+                          nil)
+derby_ref.add StringRefAddr.new('driverClassName', 
+                                'org.apache.derby.jdbc.EmbeddedDriver')
+derby_ref.add StringRefAddr.new('url', 
+                                'jdbc:derby:derby-testdb;create=true')
+derby_ref.add StringRefAddr.new('username', 'sa')
+derby_ref.add StringRefAddr.new('password', '')
+
+ic = InitialContext.new
+ic.rebind("jdbc/derbydb", derby_ref)
+

data/test/db/postgres.rb

@@ -0,0 +1,10 @@
+config = { 
+  :adapter => 'jdbc',
+  :database => 'weblog_development',
+  :url => 'jdbc:postgresql://localhost/weblog_development',
+  :driver => 'org.postgresql.Driver',
+  :username => 'blog',
+  :password => ''
+}
+
+ActiveRecord::Base.establish_connection(config)

data/test/derby_simple_test.rb

@@ -4,12 +4,8 @@
 #   create database weblog_development;
 #   grant all on weblog_development.* to blog@localhost;
 
-
-require 'models/auto_id'
-require 'models/entry'
+require 'jdbc_common'
 require 'db/derby'
-require 'simple'
-require 'test/unit'
 
 class DerbySimpleTest < Test::Unit::TestCase
   include SimpleTestMethods

data/test/h2_simple_test.rb

@@ -1,7 +1,5 @@
-require 'models/entry'
+require 'jdbc_common'
 require 'db/h2'
-require 'simple'
-require 'test/unit'
 require 'db/logger'
 
 class H2SimpleTest < Test::Unit::TestCase

data/test/hsqldb_simple_test.rb

@@ -1,8 +1,5 @@
-require 'models/auto_id'
-require 'models/entry'
+require 'jdbc_common'
 require 'db/hsqldb'
-require 'simple'
-require 'test/unit'
 
 class HsqldbSimpleTest < Test::Unit::TestCase
   include SimpleTestMethods

data/test/jdbc_common.rb

@@ -0,0 +1,6 @@
+require 'jdbc_adapter'
+require 'rubygems'
+require 'models/auto_id'
+require 'models/entry'
+require 'simple'
+require 'test/unit'

data/test/jndi_test.rb

@@ -0,0 +1,37 @@
+# In order to run these tests, you need to have a few things on your
+# classpath. First, you're going to need the Sun File system
+# context. You can get that here: 
+#
+# http://java.sun.com/products/jndi/serviceproviders.html.  
+#
+# Make sure that you put both the fscontext.jar and the
+# providerutil.jar on your classpath.  
+#
+# To support the connection pooling in the test, you'll need
+# commons-dbcp, commons-pool, and commons-collections.
+#
+# Finally, you'll need the jdbc driver, which is derby, for this test.
+
+require 'models/auto_id'
+require 'models/entry'
+require 'db/jndi_config'
+require 'simple'
+require 'test/unit'
+require 'logger'
+
+class DerbyJndiTest < Test::Unit::TestCase
+  include SimpleTestMethods
+  alias_method :setup_simple, :setup
+  def setup
+    ActiveRecord::Base.establish_connection({ :jndi => 'jdbc/derbydb', :adapter => 'jdbc'})
+    logger = Logger.new('jndi_test.log')
+    logger.level = Logger::DEBUG
+    ActiveRecord::Base.logger = logger
+    setup_simple
+  end
+end
+
+at_exit { 
+  require 'fileutils'
+  FileUtils.rm_rf 'derby-testdb'
+}