activerecord-jdbc-adapter 0.9.2 → 1.1.0

data/src/java/arjdbc/sqlite3/Sqlite3RubyJdbcConnection.java

@@ -0,0 +1,64 @@
+/*
+ **** BEGIN LICENSE BLOCK *****
+ * Copyright (c) 2006-2010 Nick Sieger <nick@nicksieger.com>
+ * Copyright (c) 2006-2007 Ola Bini <ola.bini@gmail.com>
+ * Copyright (c) 2008-2009 Thomas E Enebo <enebo@acm.org>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ ***** END LICENSE BLOCK *****/
+
+package arjdbc.sqlite3;
+
+import arjdbc.jdbc.RubyJdbcConnection;
+
+import org.jruby.Ruby;
+import org.jruby.RubyClass;
+import org.jruby.runtime.ObjectAllocator;
+import org.jruby.runtime.ThreadContext;
+import org.jruby.runtime.builtin.IRubyObject;
+
+/**
+ *
+ * @author enebo
+ */
+public class Sqlite3RubyJdbcConnection extends RubyJdbcConnection {
+    protected Sqlite3RubyJdbcConnection(Ruby runtime, RubyClass metaClass) {
+        super(runtime, metaClass);
+    }
+
+    public static RubyClass createSqlite3JdbcConnectionClass(Ruby runtime, RubyClass jdbcConnection) {
+        RubyClass clazz = RubyJdbcConnection.getConnectionAdapters(runtime).defineClassUnder("Sqlite3JdbcConnection",
+                jdbcConnection, SQLITE3_JDBCCONNECTION_ALLOCATOR);
+        clazz.defineAnnotatedMethods(Sqlite3RubyJdbcConnection.class);
+
+        return clazz;
+    }
+
+    private static ObjectAllocator SQLITE3_JDBCCONNECTION_ALLOCATOR = new ObjectAllocator() {
+        public IRubyObject allocate(Ruby runtime, RubyClass klass) {
+            return new Sqlite3RubyJdbcConnection(runtime, klass);
+        }
+    };
+
+    @Override
+    protected IRubyObject tables(ThreadContext context, String catalog, String schemaPattern, String tablePattern, String[] types) {
+        return (IRubyObject) withConnectionAndRetry(context, tableLookupBlock(context.getRuntime(), catalog, schemaPattern, tablePattern, types, true));
+    }
+}

data/test/abstract_db_create.rb

@@ -1,45 +1,124 @@
 require 'jdbc_common'
 require 'rake'
 
+module Rails
+  class Configuration
+  end
+  class Application
+    def self.config
+      @config ||= Object.new
+    end
+  end
+  def self.application
+    Rails::Application
+  end
+end
+
 module AbstractDbCreate
   def setup
     @prevapp = Rake.application
     Rake.application = Rake::Application.new
     verbose(true)
-    @prevenv = Object.const_get("RAILS_ENV") rescue nil
-    @prevroot = Object.const_get("RAILS_ENV") rescue nil
-    Object.const_set("RAILS_ENV", "unittest")
-    Object.const_set("RAILS_ROOT", ".")
+    do_setup
+  end
+
+  def do_setup(env = 'unittest', db = 'test_rake_db_create')
+    @env = env
     @prevconfigs = ActiveRecord::Base.configurations
     ActiveRecord::Base.connection.disconnect!
-    @db_name = 'test_rake_db_create'
-    require 'initializer'
-    the_db_name = @db_name
-    the_db_config = db_config
-    Rails::Configuration.class_eval do
-      define_method(:database_configuration) do
-        { "unittest" => the_db_config.merge({:database => the_db_name}).stringify_keys! }
-      end
+    @db_name = db
+    setup_rails
+    set_rails_constant("env", @env)
+    set_rails_constant("root", ".")
+    load File.dirname(__FILE__) + '/../lib/arjdbc/jdbc/jdbc.rake' if jruby?
+    task :environment do
+      ActiveRecord::Base.configurations = configurations
+      @full_env_loaded = true
+    end
+    task :rails_env do
+      @rails_env_set = true
     end
-    load rails_databases_rake_file
-    load File.dirname(__FILE__) + '/../lib/jdbc_adapter/jdbc.rake' if jruby?
-    task :environment; task :rails_env           # dummy environment, rails_env tasks
   end
 
   def teardown
     Rake::Task["db:drop"].invoke
     Rake.application = @prevapp
-    Object.const_set("RAILS_ENV", @prevenv) if @prevenv
-    Object.const_set("RAILS_ROOT", @prevroot) if @prevroot
+    restore_rails
     ActiveRecord::Base.configurations = @prevconfigs
     ActiveRecord::Base.establish_connection(db_config)
+    @rails_env_set = nil
+    @full_env_loaded = nil
   end
 
-  def rails_databases_rake_file
+  def setup_rails
+    if ActiveRecord::VERSION::MAJOR == 3
+      setup_rails3
+    else
+      setup_rails2
+    end
+  end
+
+  def configurations
+    the_db_name = @db_name
+    the_db_config = db_config
+    the_db_config = the_db_config.merge({:database => the_db_name}) if the_db_name
+    the_db_config.stringify_keys!
+    @configs = { @env => the_db_config }
+    @configs["test"] = @configs[@env].dup
+    @configs
+  end
+
+  def setup_rails2
+    configs = configurations
+    Rails::Configuration.class_eval do
+      define_method(:database_configuration) { configs }
+    end
     ar_version = $LOADED_FEATURES.grep(%r{active_record/version}).first
     ar_lib_path = $LOAD_PATH.detect {|p| p if File.exist?File.join(p, ar_version)}
     ar_lib_path = ar_lib_path.sub(%r{activerecord/lib}, 'railties/lib') # edge rails
     rails_lib_path = ar_lib_path.sub(/activerecord/, 'rails') # gem rails
-    "#{rails_lib_path}/tasks/databases.rake"
+    load "#{rails_lib_path}/tasks/databases.rake"
+  end
+
+  def setup_rails3
+    configs = configurations
+    (class << Rails::Application.config; self ; end).instance_eval do
+      define_method(:database_configuration) { configs }
+    end
+    ar_version = $LOADED_FEATURES.grep(%r{active_record/version}).first
+    ar_lib_path = $LOAD_PATH.detect {|p| p if File.exist?File.join(p, ar_version)}
+    load "#{ar_lib_path}/active_record/railties/databases.rake"
+  end
+
+  def set_rails_constant(name, value)
+    cname ="RAILS_#{name.upcase}"
+    @constants ||= {}
+    @constants[name] = Object.const_get(cname) rescue nil
+    silence_warnings { Object.const_set(cname, value) }
+    Rails.instance_eval do
+      if instance_methods(false).include?(name)
+        alias_method "orig_#{name}", name
+        define_method(name) { value }
+      end
+    end
+  end
+
+  def restore_rails
+    @constants.each do |key,value|
+      silence_warnings { Object.const_set("RAILS_#{key.upcase}", value) }
+      Rails.instance_eval do
+        if instance_methods(false).include?(name)
+          remove_method name
+          alias_method name, "orig_#{name}"
+        end
+      end
+    end
+  end
+
+  def silence_warnings
+    prev, $VERBOSE = $VERBOSE, nil
+    yield
+  ensure
+    $VERBOSE = prev
   end
 end

data/test/activerecord/connection_adapters/type_conversion_test.rb

@@ -1,6 +1,6 @@
 require 'java'
 require 'models/data_types'
-require 'active_record/connection_adapters/jdbc_adapter'
+require 'arjdbc'
 require 'db/derby'
 require 'test/unit'
 

data/test/db/db2.rb

@@ -1,6 +1,8 @@
 config = {
-  :username => "blog",
-  :password => "",
+# DB2 uses $USER if running locally, just add
+# yourself to your db2 groups in /etc/group
+#  :username => "blog",
+#  :password => "",
   :adapter  => "jdbc",
   :driver => "com.ibm.db2.jcc.DB2Driver",
   :url => "jdbc:db2:weblog_development"

data/test/db/derby.rb

@@ -1,14 +1,12 @@
-require 'logger'
-
-config = {
-  :adapter => 'derby',
-  :database => "derby-testdb"
-}
-
-ActiveRecord::Base.establish_connection(config)
-
-at_exit {  
-  # Clean up derby files
-  require 'fileutils'
-  FileUtils.rm_rf('derby-testdb')
-}
+config = {
+  :adapter => 'derby',
+  :database => "derby-testdb"
+}
+
+ActiveRecord::Base.establish_connection(config)
+
+at_exit {
+  # Clean up derby files
+  require 'fileutils'
+  FileUtils.rm_rf('derby-testdb')
+}

data/test/db/hsqldb.rb

@@ -7,6 +7,7 @@ ActiveRecord::Base.establish_connection(config)
 
 at_exit {
   # Clean up hsqldb when done
-  Dir['test.db*'].each {|f| File.delete(f)}
-  File.delete('hsqldb-testdb.log') rescue nil #can't delete on windows
+  require "fileutils"
+  Dir['test.db*'].each {|f| FileUtils.rm_rf(f)}
+  FileUtils.rm_rf('hsqldb-testdb.log') rescue nil #can't delete on windows
 }

data/test/db/jndi_config.rb

@@ -1,12 +1,24 @@
 require 'fileutils'
-require 'active_record/connection_adapters/jdbc_adapter'
+require 'arjdbc'
+
+JNDI_CONFIG = {
+  :adapter => "jdbc",
+  :jndi => 'jdbc/derbydb'
+}
+
+# To test JNDI, grab fscontext-1_2-beta3.zip from
+# http://java.sun.com/products/jndi/downloads/index.html
+# and put fscontext.jar and providerutil.jar in test/
+require 'test/fscontext.jar'
+require 'test/providerutil.jar'
+require 'jdbc/derby'
 
 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__) + '/../..')
@@ -15,16 +27,14 @@ 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)
+ic.rebind(JNDI_CONFIG[:jndi],
+          org.apache.derby.jdbc.EmbeddedDataSource.new.tap {|ds|
+            ds.database_name = "derby-testdb-jndi"
+            ds.create_database = "create"
+            ds.user = "sa"
+            ds.password = ""})
+
 
+ActiveRecord::Base.establish_connection(JNDI_CONFIG)

data/test/db/mssql.rb

@@ -1,9 +1,9 @@
-config = { 
+MSSQL_CONFIG = {
   :username => 'blog',
   :password => '',
-  :adapter  => 'jdbc',
-  :url => "jdbc:jtds:sqlserver://localhost:1433/weblog_development",
-  :driver => 'net.sourceforge.jtds.jdbc.Driver'
+  :adapter  => 'mssql',
+  :database => 'weblog_development'
 }
+MSSQL_CONFIG[:host] = ENV['SQLHOST'] if ENV['SQLHOST']
 
-ActiveRecord::Base.establish_connection( config )
+ActiveRecord::Base.establish_connection(MSSQL_CONFIG)

data/test/db/sqlite3.rb

@@ -1,10 +1,6 @@
-require 'jdbc/sqlite3' if jruby?
-
 config = {
-  :adapter => jruby? ? 'jdbcsqlite3' : 'sqlite3', 
-  :dbfile  => 'test.sqlite3.db'
-#  :url => 'jdbc:sqlite:test.sqlite3.db',
-#  :driver => 'org.sqlite.JDBC'
+  :adapter => 'sqlite3',
+  :database  => 'test.sqlite3.db'
 }
 
 ActiveRecord::Base.establish_connection(config)

data/test/db2_simple_test.rb

@@ -3,8 +3,64 @@ require 'db/db2'
 
 class DB2SimpleTest < Test::Unit::TestCase
   include SimpleTestMethods
+
+  # For backwards compatibility with how the DB2 code in
+  # jdbc_adapter 0.9.x handled booleans.
+  #
+  # The old DB2 jdbc_db2.rb driver was broken enough that
+  # applications were exposed to the underlying type (was DECIMAL)
+  # and used 0 and 1 as false and true, respectively.
+  #
+  # This driver now uses SMALLINT as a boolean, and properly
+  # type cast's it to a Ruby boolean. Need to make sure we don't
+  # break existing apps!
+  def test_boolean_as_integer
+    e = DbType.find(:first)
+
+    # true
+    e.sample_boolean = 1
+    assert_equal true, e.sample_boolean
+    assert_equal true, e.sample_boolean?
+    e.save!
+
+    e = DbType.find(:first)
+    assert_equal true, e.sample_boolean
+    assert_equal true, e.sample_boolean?
+
+    # false
+    e.sample_boolean = 0
+    assert_equal false, e.sample_boolean
+    assert_equal false, e.sample_boolean?
+    e.save!
+
+    e = DbType.find(:first)
+    assert_equal false, e.sample_boolean
+    assert_equal false, e.sample_boolean?
+  end
 end
 
 class DB2HasManyThroughTest < Test::Unit::TestCase
   include HasManyThroughMethods
 end
+
+class DB2Test < Test::Unit::TestCase
+  def setup
+    @inst = Object.new
+    @inst.extend ArJdbc::DB2
+    @column = Object.new
+    class << @column
+      attr_accessor :type
+    end
+  end
+
+  def test_quote_decimal
+    assert_equal %q{'123.45'}, @inst.quote("123.45")
+    @column.type = :decimal
+    assert_equal %q{123.45}, @inst.quote("123.45", @column), "decimal columns should not have quotes"
+  end
+
+  def test_primary_key_generation
+    @column.type = :primary_key
+    assert_equal 'int not null generated by default as identity (start with 1) primary key', @inst.modify_types({:string => {}, :integer => {}, :boolean => {}})[:primary_key]
+  end
+end

data/test/derby_migration_test.rb

@@ -8,14 +8,61 @@ class CreateDummies < ActiveRecord::Migration
     end
     add_index :dummies, :year, :unique => true
   end
-  
+
+end
+
+class ChangeColumn < ActiveRecord::Migration
+  def self.up
+    create_table :people, :id => false, :force => true do |t|
+      t.string :id, :limit => 22, :null => false
+      t.string :name, :null => false
+    end
+    change_column(:people, :name, :string, {:limit=>22})
+    execute("SELECT id FROM people WHERE id = 'some string'")
+  end
+
+  def self.down
+  end
+
+end
+
+class CreateIndex < ActiveRecord::Migration
+  def self.up
+    create_table :people, :id => false, :force => true do |t|
+      t.string :id, :limit => 22, :null => false
+      t.string :first_name, :null => false
+      t.string :last_name, :null => false
+      t.string :nickname, :null => false
+      t.string :long_name, :null => false
+      t.string :very_long_name, :null => false
+      t.string :extremely_long_name, :null => false
+    end
+
+    add_index(:people, [:first_name, :last_name, :nickname, :long_name, :very_long_name, :extremely_long_name], :unique => true)
+
+    remove_index(:people, [:first_name, :last_name, :nickname, :long_name, :very_long_name, :extremely_long_name])
+  end
+
+  def self.down
+  end
+
 end
 
-class DerbyQuotingTest < Test::Unit::TestCase
+class DerbyMigrationTest < Test::Unit::TestCase
   include FixtureSetup
 
   def test_create_table_column_quoting_vs_keywords
     CreateDummies.up
   end
-  
+
+  def test_migrate_change_column_for_non_standard_id
+    ChangeColumn.up
+    ChangeColumn.down
+  end
+
+  def test_migrate_create_index
+    CreateIndex.up
+    CreateIndex.down
+  end
+
 end