activerecord-jdbc-adapter 0.9.2 → 1.1.0

data/test/derby_simple_test.rb

@@ -9,4 +9,91 @@ require 'db/derby'
 
 class DerbySimpleTest < Test::Unit::TestCase
   include SimpleTestMethods
+
+  # Check that a table-less VALUES(xxx) query (like SELECT  works.
+  def test_values
+    value = nil
+    assert_nothing_raised do
+      value = ActiveRecord::Base.connection.send(:select_rows, "VALUES('ur', 'doin', 'it', 'right')")
+    end
+    assert_equal [['ur', 'doin', 'it', 'right']], value
+  end
+
+  def test_find_with_include_and_order
+    users = User.find(:all, :include=>[:entries], :order=>"entries.rating DESC", :limit=>2)
+
+    assert users.include?(@user)
+  end
+
+  def test_text_and_string_conversions
+    e = DbType.find(:first)
+
+    # Derby will normally reject any non text value.
+    # The adapter has been patched to convert non text values to strings
+    ['string', 45, 4.3, 18488425889503641645].each do |value|
+      assert_nothing_raised do
+        e.sample_string = value
+        e.sample_text = value
+        e.save!
+        e.reload
+        assert_equal [value.to_s]*2, [e.sample_string, e.sample_text]
+      end
+    end
+    [true, false].each do |value|
+      assert_nothing_raised do
+        e.sample_string = value
+        e.sample_text = value
+        e.save!
+        e.reload
+        assert_equal [value ? "1" : "0"]*2, [e.sample_string, e.sample_text]
+      end
+    end
+    assert_nothing_raised do
+      value = Time.now
+      if ActiveRecord::VERSION::MAJOR >= 3
+        str = value.utc.to_s(:db)
+      else                      # AR 2 #quoted_date did not do TZ conversions
+        str = value.to_s(:db)
+      end
+      e.sample_string = value
+      e.sample_text = value
+      e.save!
+      e.reload
+      assert_equal [str]*2, [e.sample_string, e.sample_text]
+    end
+    assert_nothing_raised do
+      value = Date.today
+      e.sample_string = value
+      e.sample_text = value
+      e.save!
+      e.reload
+      assert_equal [value.to_s(:db)]*2, [e.sample_string, e.sample_text]
+    end
+    value = {'a' => 7}
+    assert_nothing_raised do
+      e.sample_string = value
+      e.sample_text = value
+      e.save!
+      e.reload
+      assert_equal [value.to_yaml]*2, [e.sample_string, e.sample_text]
+    end
+    value = BigDecimal.new("0")
+    assert_nothing_raised do
+      e.sample_string = value
+      e.sample_text = value
+      e.save!
+      e.reload
+      assert_equal ['0.0']*2, [e.sample_string, e.sample_text]
+    end
+    # An empty string is treated as a null value in Oracle: http://www.techonthenet.com/oracle/questions/empty_null.php
+    unless ActiveRecord::Base.connection.adapter_name =~ /oracle/i
+      assert_nothing_raised do
+        e.sample_string = nil
+        e.sample_text = nil
+        e.save!
+        e.reload
+        assert_equal [nil]*2, [e.sample_string, e.sample_text]
+      end
+    end
+  end
 end

data/test/generic_jdbc_connection_test.rb

@@ -6,4 +6,24 @@ class GenericJdbcConnectionTest < Test::Unit::TestCase
     ActiveRecord::Base.connection.execute("show databases");
     assert ActiveRecord::Base.connected?
   end
-end
+
+  def test_configure_connection_url
+    connection = Object.new
+    connection.extend ActiveRecord::ConnectionAdapters::JdbcConnection::ConfigHelper
+    connection.config = { :url => "jdbc://somehost", :options => { :hoge => "true", :fuya => "false"} }
+    assert_equal "jdbc://somehost?hoge=true&fuya=false", connection.configure_url
+
+    connection.config = { :url => "jdbc://somehost?param=0", :options => { :hoge => "true", :fuya => "false"} }
+    assert_equal "jdbc://somehost?param=0&hoge=true&fuya=false", connection.configure_url
+  end
+
+  def test_connection_fails_without_driver_and_url
+    conn = ActiveRecord::Base.remove_connection
+    assert_raises(ActiveRecord::ConnectionNotEstablished) do
+      ActiveRecord::Base.establish_connection :adapter => 'jdbc'
+      ActiveRecord::Base.connection
+    end
+  ensure
+    ActiveRecord::Base.establish_connection conn
+  end
+end

data/test/h2_simple_test.rb

@@ -4,3 +4,38 @@ require 'db/h2'
 class H2SimpleTest < Test::Unit::TestCase
   include SimpleTestMethods
 end
+
+class H2SchemaTest < Test::Unit::TestCase
+  def setup
+    @connection = ActiveRecord::Base.connection
+    @connection.execute("create schema s1");
+    @connection.execute("set schema s1");
+    CreateEntries.up
+    @connection.execute("create schema s2");
+    @connection.execute("set schema s2");
+    CreateUsers.up
+    @connection.execute("set schema public");
+    Entry.set_table_name 's1.entries'
+    User.set_table_name 's2.users'
+    user = User.create! :login => "something"
+    Entry.create! :title => "title", :content => "content", :rating => 123.45, :user => user
+  end
+
+  def teardown
+    @connection.execute("set schema s1");
+    CreateEntries.down
+    @connection.execute("set schema s2");
+    CreateUsers.down
+    @connection.execute("drop schema s1");
+    @connection.execute("drop schema s2");
+    @connection.execute("set schema public");
+    Entry.reset_table_name
+    Entry.reset_column_information
+    User.reset_table_name
+    User.reset_column_information
+  end
+
+  def test_find_in_other_schema
+    assert !Entry.all(:include => :user).empty?
+  end
+end

data/test/jdbc_common.rb

@@ -4,10 +4,8 @@ def jruby?
 end
 
 require 'rubygems'
-# Specify version of activerecord with ENV['AR_VERSION'] if desired
-gem 'activerecord', ENV['AR_VERSION'] if ENV['AR_VERSION']
-require 'active_record/version'
-require 'jdbc_adapter' if jruby?
+require 'pick_rails_version'
+require 'arjdbc' if jruby?
 puts "Using activerecord version #{ActiveRecord::VERSION::STRING}"
 puts "Specify version with AR_VERSION=={version} or RUBYLIB={path}"
 require 'models/auto_id'
@@ -15,12 +13,13 @@ require 'models/entry'
 require 'models/data_types'
 require 'models/add_not_null_column_to_table'
 require 'models/validates_uniqueness_of_string'
+require 'models/string_id'
 require 'simple'
 require 'has_many_through'
 require 'helper'
 require 'test/unit'
 
 # Comment/uncomment to enable logging to be loaded for any of the database adapters
-# require 'db/logger'
+require 'db/logger' if $DEBUG || ENV['DEBUG']
 
 

data/test/jndi_callbacks_test.rb

@@ -1,4 +1,5 @@
 require 'jdbc_common'
+require 'db/jndi_config'
 
 begin
   require 'mocha'
@@ -9,7 +10,7 @@ class JndiConnectionPoolCallbacksTest < Test::Unit::TestCase
     @connection.stubs(:jndi_connection?).returns(true)
     @connection.stubs(:adapter=)
     @logger = mock "logger"
-    @config = { :jndi => "jdbc/some_pool", :adapter => "mysql" }
+    @config = JNDI_CONFIG
     Entry.connection_pool.disconnect!
     assert !Entry.connection_pool.connected?
     class << Entry.connection_pool; public :instance_variable_set; end
@@ -21,6 +22,7 @@ class JndiConnectionPoolCallbacksTest < Test::Unit::TestCase
   end
 
   def test_should_call_hooks_on_checkout_and_checkin
+    @connection.stubs(:active?).returns(true)
     @connection.expects(:disconnect!)
     @adapter = ActiveRecord::ConnectionAdapters::JdbcAdapter.new @connection, @logger, @config
     Entry.connection_pool.instance_variable_set "@connections", [@adapter]

data/test/jndi_test.rb

@@ -17,19 +17,9 @@ require 'db/jndi_config'
 
 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 { 
+at_exit {
   require 'fileutils'
   FileUtils.rm_rf 'derby-testdb'
 }

data/test/models/entry.rb

@@ -8,6 +8,7 @@ class CreateEntries < ActiveRecord::Migration
       t.column :updated_on, :datetime
       t.column :content, :text
       t.column :rating, :decimal, :precision => 10, :scale => 2
+      t.column :user_id, :integer
     end
   end
 
@@ -17,7 +18,26 @@ class CreateEntries < ActiveRecord::Migration
 end
 
 class Entry < ActiveRecord::Base
+  belongs_to :user
+
   def to_param
     "#{id}-#{title.gsub(/[^a-zA-Z0-9]/, '-')}"
   end
 end
+
+class CreateUsers < ActiveRecord::Migration
+  def self.up
+    create_table "users", :force => true do |t|
+      t.column :login, :string, :limit => 100
+    end
+  end
+
+  def self.down
+    drop_table "users"
+  end
+end
+
+class User < ActiveRecord::Base
+  has_many :entries
+end
+

data/test/models/mixed_case.rb

@@ -3,15 +3,20 @@ require 'active_record'
 
 module Migration
   class MixedCase < ActiveRecord::Migration
-    
+
     def self.up
       create_table "mixed_cases" do |t|
         t.column :SOME_value, :string
       end
+      create_table "tblUsers" do |t|
+        t.column :firstName, :string
+        t.column :lastName, :string
+      end
     end
-    
+
     def self.down
       drop_table "mixed_cases"
+      drop_table "tblUsers"
     end
   end
 end

data/test/models/string_id.rb

@@ -0,0 +1,18 @@
+require 'rubygems'
+require 'active_record'
+
+class CreateStringIds < ActiveRecord::Migration
+  def self.up
+    create_table "string_ids", :force => true, :id => false do |t|
+      t.string :id
+    end
+  end
+
+  def self.down
+    drop_table "string_ids"
+  end
+end
+
+class StringId < ActiveRecord::Base
+  def self.table_name () "string_ids" end
+end

data/test/mssql_db_create_test.rb

@@ -0,0 +1,26 @@
+require 'abstract_db_create'
+require 'db/mssql'
+
+class MysqlDbCreateTest < Test::Unit::TestCase
+  include AbstractDbCreate
+
+  def db_config
+    MSSQL_CONFIG
+  end
+  
+  def test_rake_db_create
+    begin
+      Rake::Task["db:create"].invoke
+    rescue => e
+      if e.message =~ /CREATE DATABASE permission denied/
+        puts "\nwarning: db:create test skipped; add 'dbcreator' role to user '#{db_config[:username]}' to run"
+        return
+      end
+    end
+    ActiveRecord::Base.establish_connection(db_config.merge(:database => "master"))
+    select = "SELECT NAME FROM sys.sysdatabases"
+    select = "SELECT name FROM master..sysdatabases ORDER BY name" if ActiveRecord::Base.connection.sqlserver_version == "2000"
+    databases = ActiveRecord::Base.connection.select_rows(select).flatten
+    assert databases.include?(@db_name)
+  end
+end

data/test/mssql_identity_insert_test.rb

@@ -0,0 +1,19 @@
+require 'jdbc_common'
+require 'db/mssql'
+
+class MsSQLIdentityInsertTest < Test::Unit::TestCase
+
+  include MigrationSetup
+  
+  def test_enable_identity_insert_when_necessary
+    Entry.connection.execute("INSERT INTO entries([id], [title]) VALUES (333, 'Title')")
+    Entry.connection.execute("INSERT INTO entries([title], [id]) VALUES ('Title', 344)")
+    Entry.connection.execute("INSERT INTO entries(id, title) VALUES (666, 'Title')")
+    Entry.connection.execute("INSERT INTO entries(id, title) (SELECT id+123, title FROM entries)")
+  end
+
+  def test_dont_enable_identity_insert_when_unnecessary
+    Entry.connection.execute("INSERT INTO entries([title]) VALUES ('[id]')")
+  end
+
+end

data/test/mssql_legacy_types_test.rb

@@ -0,0 +1,58 @@
+require 'jdbc_common'
+require 'db/mssql'
+
+ActiveRecord::Schema.verbose = false
+
+class CreateArticles < ActiveRecord::Migration
+
+  def self.up
+    execute <<-SQL
+      CREATE TABLE articles (
+        [id] int NOT NULL IDENTITY(1, 1) PRIMARY KEY, 
+        [title] VARCHAR(100), 
+        [author] VARCHAR(60) DEFAULT 'anonymous', 
+        [body] TEXT
+      )
+    SQL
+  end
+
+  def self.down
+    drop_table "articles"
+  end
+
+end
+
+class Article < ActiveRecord::Base
+end
+
+class MsSQLLegacyTypesTest < Test::Unit::TestCase
+
+  def setup
+    CreateArticles.up
+    @connection = ActiveRecord::Base.connection
+  end
+
+  def teardown
+    CreateArticles.down
+    ActiveRecord::Base.clear_active_connections!
+  end
+
+  def test_varchar_column
+    Article.create!(:title => "Blah blah")
+    article = Article.first
+    assert_equal("Blah blah", article.title)
+  end
+  
+  SAMPLE_TEXT = "Lorem ipsum dolor sit amet ..."
+  
+  def test_text_column
+    Article.create!(:body => SAMPLE_TEXT)
+    article = Article.first
+    assert_equal(SAMPLE_TEXT, article.body)
+  end
+  
+  def test_varchar_default_value
+    assert_equal("anonymous", Article.new.author)
+  end
+  
+end

data/test/mssql_limit_offset_test.rb

@@ -0,0 +1,136 @@
+require 'jdbc_common'
+require 'db/mssql'
+
+ActiveRecord::Schema.verbose = false
+
+class CreateLongShips < ActiveRecord::Migration
+
+  def self.up
+    create_table "long_ships", :force => true do |t|
+      t.string "name", :limit => 50, :null => false
+      t.integer "width", :default => 123
+      t.integer "length", :default => 456
+    end
+  end
+
+  def self.down
+    drop_table "long_ships"
+  end
+
+end
+
+class LongShip < ActiveRecord::Base
+  has_many :vikings
+end
+
+class CreateVikings < ActiveRecord::Migration
+
+  def self.up
+    create_table "vikings", :force => true do |t|
+      t.integer "long_ship_id", :null => false
+      t.string "name", :limit => 50, :default => "Sven"
+    end
+  end
+
+  def self.down
+    drop_table "vikings"
+  end
+
+end
+
+class Viking < ActiveRecord::Base
+  belongs_to :long_ship
+end
+
+
+class CreateNoIdVikings < ActiveRecord::Migration
+  def self.up
+    create_table "no_id_vikings", :force => true do |t|
+      t.string "name", :limit => 50, :default => "Sven"
+    end
+    remove_column "no_id_vikings", "id"
+  end
+
+  def self.down
+    drop_table "no_id_vikings"
+  end
+end
+
+class NoIdViking < ActiveRecord::Base
+end
+
+
+
+class MsSQLLimitOffsetTest < Test::Unit::TestCase
+
+  def setup
+    CreateLongShips.up
+    CreateVikings.up
+    CreateNoIdVikings.up
+    @connection = ActiveRecord::Base.connection
+  end
+
+  def teardown
+    CreateVikings.down
+    CreateLongShips.down
+    CreateNoIdVikings.down
+    ActiveRecord::Base.clear_active_connections!
+  end
+
+  def test_limit_with_no_id_column_available
+    NoIdViking.create!(:name => 'Erik')
+    assert_nothing_raised(ActiveRecord::StatementInvalid) do 
+      NoIdViking.find(:first)
+    end
+  end
+
+  def test_limit_and_offset
+    %w(one two three four five six seven eight).each do |name|
+      LongShip.create!(:name => name)
+    end
+    ship_names = LongShip.find(:all, :offset => 2, :limit => 3).map(&:name)
+    assert_equal(%w(three four five), ship_names)
+  end
+
+  def test_limit_and_offset_with_order
+    %w(one two three four five six seven eight).each do |name|
+      LongShip.create!(:name => name)
+    end
+    ship_names = LongShip.find(:all, :order => "name", :offset => 4, :limit => 2).map(&:name)
+    assert_equal(%w(seven six), ship_names)
+  end
+
+  # TODO: work out how to fix DISTINCT support without breaking :include
+  # def test_limit_and_offset_with_distinct
+  #   %w(c a b a b a c d c d).each do |name|
+  #     LongShip.create!(:name => name)
+  #   end
+  #   ship_names = LongShip.find(:all, :select => "DISTINCT name", :order => "name", :offset => 1, :limit => 2).map(&:name)
+  #   assert_equal(%w(b c), ship_names)
+  # end
+
+  def test_limit_and_offset_with_include
+    skei = LongShip.create!(:name => "Skei")
+    skei.vikings.create!(:name => "Bob")
+    skei.vikings.create!(:name => "Ben")
+    skei.vikings.create!(:name => "Basil")
+    ships = Viking.find(:all, :include => :long_ship, :offset => 1, :limit => 2)
+    assert_equal(2, ships.size)
+  end
+
+  def test_limit_and_offset_with_include_and_order
+
+    boat1 = LongShip.create!(:name => "1-Skei")
+    boat2 = LongShip.create!(:name => "2-Skei")
+
+    boat1.vikings.create!(:name => "Adam")
+    boat2.vikings.create!(:name => "Ben")
+    boat1.vikings.create!(:name => "Carl")
+    boat2.vikings.create!(:name => "Donald")
+  
+    vikings = Viking.find(:all, :include => :long_ship, :order => "long_ships.name, vikings.name", :offset => 0, :limit => 3)
+    assert_equal(["Adam", "Carl", "Ben"], vikings.map(&:name))
+
+  end
+  
+end