activerecord-jdbc-adapter 1.2.1 → 1.2.2

data/test/models/validates_uniqueness_of_string.rb

@@ -13,7 +13,7 @@ class CreateValidatesUniquenessOf < ActiveRecord::Migration
 end
 
 class ValidatesUniquenessOfString < ActiveRecord::Base
-  self.set_table_name "validates_uniqueness_of"
+  self.table_name = "validates_uniqueness_of"
   validates_uniqueness_of :cs_string, :case_sensitive => true
   validates_uniqueness_of :ci_string, :case_sensitive => false
 end

data/test/mssql_ignore_system_views_test.rb

@@ -0,0 +1,27 @@
+#! /usr/bin/env jruby
+
+require 'jdbc_common'
+require 'db/mssql'
+
+class IgnoreSystemViewsTest < Test::Unit::TestCase
+
+  include MigrationSetup
+
+  def test_system_views_ignored
+    assert_equal true, table_exists?("sys.views"), %{table_exists?("sys.views")}
+    assert_equal true, table_exists?("information_schema.views"), %{table_exists?("information_schema.views")}
+    assert_equal false, table_exists?("dbo.views"), %{table_exists?("dbo.views")}
+    assert_equal false, table_exists?(:views), %{table_exists?(:views)}
+    ActiveRecord::Schema.define { suppress_messages { create_table :views } }
+    assert_equal true, table_exists?(:views), %{table_exists?(:views)}
+    ActiveRecord::Schema.define { suppress_messages { drop_table :views } }
+    assert_equal false, table_exists?(:views), %{table_exists?(:views)}
+  end
+
+  private
+
+    def table_exists?(*args)
+      !!ActiveRecord::Base.connection.table_exists?(*args)
+    end
+end
+

data/test/mssql_null_test.rb

@@ -0,0 +1,14 @@
+require 'jdbc_common'
+require 'db/mssql'
+
+class MsSQLNullTest < Test::Unit::TestCase
+  include MigrationSetup
+
+  [nil, "NULL", "null", "(null)", "(NULL)"].each_with_index do |v, i|
+    define_method "test_null_#{i}" do
+      entry = Entry.create!(:title => v, :content => v)
+      entry = Entry.find(entry.id)
+      assert_equal [v, v], [entry.title, entry.content], "writing #{v.inspect} should read back as #{v.inspect} for both string and text columns"
+    end
+  end
+end

data/test/mssql_reset_column_information_test.rb

@@ -0,0 +1,8 @@
+#! /usr/bin/env jruby
+
+require 'jdbc_common'
+require 'db/mssql'
+
+class MsSQLResetColumnInformationTest < Test::Unit::TestCase
+  include ResetColumnInformationTestMethods
+end

data/test/mssql_row_locking_sql_test.rb

@@ -0,0 +1,159 @@
+#! /usr/bin/env jruby
+
+require 'arjdbc/mssql/adapter'
+require 'test/unit'
+
+# This tests ArJdbc::MsSQL#add_lock! without actually connecting to the database.
+class MssqlRowLockingSqlTest < Test::Unit::TestCase
+
+  def test_find_all
+    add_lock_test "Appointment.find(:all)",
+      %q{SELECT * FROM appointments},
+      %q{SELECT * FROM appointments WITH(ROWLOCK,UPDLOCK)}
+  end
+
+  def test_find_first
+    add_lock_test "Appointment.find(:first)",
+      %q{SELECT t.* FROM (SELECT ROW_NUMBER() OVER(ORDER BY appointments.id) AS _row_num, appointments.* FROM appointments) AS t WHERE t._row_num BETWEEN 1 AND 1},
+      %q{SELECT t.* FROM (SELECT ROW_NUMBER() OVER(ORDER BY appointments.id) AS _row_num, appointments.* FROM appointments WITH(ROWLOCK,UPDLOCK) ) AS t WHERE t._row_num BETWEEN 1 AND 1}
+  end
+
+  def test_find_all_where
+    add_lock_test "AppointmentDetail.find(:all, :conditions => {:name => 'foo', :value => 'bar'})",
+      %q{SELECT * FROM appointment_details WHERE (appointment_details.[name] = N'foo' AND appointment_details.[value] = N'bar')},
+      %q{SELECT * FROM appointment_details WITH(ROWLOCK,UPDLOCK)  WHERE (appointment_details.[name] = N'foo' AND appointment_details.[value] = N'bar')}
+  end
+
+  def test_find_first_where
+    add_lock_test "AppointmentDetail.find(:first, :conditions => {:name => 'foo', :value => 'bar'})",
+      %q{SELECT t.* FROM (SELECT ROW_NUMBER() OVER(ORDER BY appointment_details.id) AS _row_num, appointment_details.* FROM appointment_details WHERE (appointment_details.[name] = N'foo' AND appointment_details.[value] = N'bar')) AS t WHERE t._row_num BETWEEN 1 AND 1},
+      %q{SELECT t.* FROM (SELECT ROW_NUMBER() OVER(ORDER BY appointment_details.id) AS _row_num, appointment_details.* FROM appointment_details WITH(ROWLOCK,UPDLOCK)  WHERE (appointment_details.[name] = N'foo' AND appointment_details.[value] = N'bar')) AS t WHERE t._row_num BETWEEN 1 AND 1}
+  end
+
+  def test_find_all_where_array
+    add_lock_test "AppointmentDetail.find(:all, :conditions => ['name = ?', 'foo'])",
+      %q{SELECT * FROM appointment_details WHERE (name = N'foo')},
+      %q{SELECT * FROM appointment_details WITH(ROWLOCK,UPDLOCK)  WHERE (name = N'foo')}
+  end
+
+  def test_find_first_where_array
+    add_lock_test "AppointmentDetail.find(:first, :conditions => ['name = ?', 'foo'])",
+      %q{SELECT t.* FROM (SELECT ROW_NUMBER() OVER(ORDER BY appointment_details.id) AS _row_num, appointment_details.* FROM appointment_details WHERE (name = N'foo')) AS t WHERE t._row_num BETWEEN 1 AND 1},
+      %q{SELECT t.* FROM (SELECT ROW_NUMBER() OVER(ORDER BY appointment_details.id) AS _row_num, appointment_details.* FROM appointment_details WITH(ROWLOCK,UPDLOCK)  WHERE (name = N'foo')) AS t WHERE t._row_num BETWEEN 1 AND 1}
+  end
+
+  def test_find_all_joins
+    add_lock_test "AppointmentDetail.find(:all, :joins => :appointment)",
+      %q{SELECT appointment_details.* FROM appointment_details INNER JOIN appointments ON appointments.id = appointment_details.appointment_id},
+      %q{SELECT appointment_details.* FROM appointment_details  WITH(ROWLOCK,UPDLOCK) INNER JOIN appointments WITH(ROWLOCK,UPDLOCK)  ON appointments.id = appointment_details.appointment_id}
+  end
+
+  def test_find_first_joins
+    add_lock_test "AppointmentDetail.find(:first, :joins => :appointment)",
+      %q{SELECT t.* FROM (SELECT ROW_NUMBER() OVER(ORDER BY appointment_details.id) AS _row_num, appointment_details.* FROM appointment_details INNER JOIN appointments ON appointments.id = appointment_details.appointment_id) AS t WHERE t._row_num BETWEEN 1 AND 1},
+      %q{SELECT t.* FROM (SELECT ROW_NUMBER() OVER(ORDER BY appointment_details.id) AS _row_num, appointment_details.* FROM appointment_details  WITH(ROWLOCK,UPDLOCK) INNER JOIN appointments WITH(ROWLOCK,UPDLOCK)  ON appointments.id = appointment_details.appointment_id) AS t WHERE t._row_num BETWEEN 1 AND 1}
+  end
+
+  def test_find_all_2joins
+    add_lock_test "Appointment.find(:all, :joins => [:appointment_details, :appointment_hl7s])",
+      %q{SELECT appointments.* FROM appointments INNER JOIN appointment_details ON appointment_details.appointment_id = appointments.id INNER JOIN appointment_hl7s ON appointment_hl7s.appointment_id = appointments.id},
+      %q{SELECT appointments.* FROM appointments  WITH(ROWLOCK,UPDLOCK) INNER JOIN appointment_details WITH(ROWLOCK,UPDLOCK)  ON appointment_details.appointment_id = appointments.id INNER JOIN appointment_hl7s WITH(ROWLOCK,UPDLOCK)  ON appointment_hl7s.appointment_id = appointments.id}
+  end
+
+  def test_find_first_2joins
+    add_lock_test "Appointment.find(:first, :joins => [:appointment_details, :appointment_hl7s])",
+      %q{SELECT t.* FROM (SELECT ROW_NUMBER() OVER(ORDER BY appointments.id) AS _row_num, appointments.* FROM appointments INNER JOIN appointment_details ON appointment_details.appointment_id = appointments.id INNER JOIN appointment_hl7s ON appointment_hl7s.appointment_id = appointments.id) AS t WHERE t._row_num BETWEEN 1 AND 1},
+      %q{SELECT t.* FROM (SELECT ROW_NUMBER() OVER(ORDER BY appointments.id) AS _row_num, appointments.* FROM appointments  WITH(ROWLOCK,UPDLOCK) INNER JOIN appointment_details WITH(ROWLOCK,UPDLOCK)  ON appointment_details.appointment_id = appointments.id INNER JOIN appointment_hl7s WITH(ROWLOCK,UPDLOCK)  ON appointment_hl7s.appointment_id = appointments.id) AS t WHERE t._row_num BETWEEN 1 AND 1}
+  end
+
+  def test_find_all_2joins_where
+    add_lock_test "Appointment.find(:all, :joins => [:appointment_details, :appointment_hl7s], :conditions => {'appointment_details.name' => 'foo'})",
+      %q{SELECT appointments.* FROM appointments INNER JOIN appointment_details ON appointment_details.appointment_id = appointments.id INNER JOIN appointment_hl7s ON appointment_hl7s.appointment_id = appointments.id WHERE (appointment_details.[name] = N'foo')},
+      %q{SELECT appointments.* FROM appointments  WITH(ROWLOCK,UPDLOCK) INNER JOIN appointment_details WITH(ROWLOCK,UPDLOCK)  ON appointment_details.appointment_id = appointments.id INNER JOIN appointment_hl7s WITH(ROWLOCK,UPDLOCK)  ON appointment_hl7s.appointment_id = appointments.id WHERE (appointment_details.[name] = N'foo')}
+  end
+
+  def test_find_first_2joins_where
+    add_lock_test "Appointment.find(:first, :joins => [:appointment_details, :appointment_hl7s], :conditions => {'appointment_details.name' => 'foo'})",
+      %q{SELECT t.* FROM (SELECT ROW_NUMBER() OVER(ORDER BY appointments.id) AS _row_num, appointments.* FROM appointments INNER JOIN appointment_details ON appointment_details.appointment_id = appointments.id INNER JOIN appointment_hl7s ON appointment_hl7s.appointment_id = appointments.id WHERE (appointment_details.[name] = N'foo')) AS t WHERE t._row_num BETWEEN 1 AND 1},
+      %q{SELECT t.* FROM (SELECT ROW_NUMBER() OVER(ORDER BY appointments.id) AS _row_num, appointments.* FROM appointments  WITH(ROWLOCK,UPDLOCK) INNER JOIN appointment_details WITH(ROWLOCK,UPDLOCK)  ON appointment_details.appointment_id = appointments.id INNER JOIN appointment_hl7s WITH(ROWLOCK,UPDLOCK)  ON appointment_hl7s.appointment_id = appointments.id WHERE (appointment_details.[name] = N'foo')) AS t WHERE t._row_num BETWEEN 1 AND 1}
+  end
+
+  def test_custom_join_ar097
+    add_lock_test "custom join (arjdbc 0.9.7)",
+      %q{
+        SELECT t.* FROM (
+          SELECT
+            ROW_NUMBER() OVER(ORDER BY appointments.id) AS row_num,
+            appointments.*
+          FROM
+            appointments INNER JOIN
+            appointment_details AS d1 ON appointments.[id] = d1.[appointment_id]
+          WHERE (d1.[name] = N'appointment_identifier' AND d1.[value] = N'279955^MQ')
+        ) AS t WHERE t.row_num BETWEEN 1 AND 1
+      }, %q{
+        SELECT t.* FROM (
+          SELECT
+            ROW_NUMBER() OVER(ORDER BY appointments.id) AS row_num,
+            appointments.*
+          FROM
+            appointments  WITH(ROWLOCK,UPDLOCK) INNER JOIN
+            appointment_details AS d1 WITH(ROWLOCK,UPDLOCK)  ON appointments.[id] = d1.[appointment_id]
+          WHERE (d1.[name] = N'appointment_identifier' AND d1.[value] = N'279955^MQ')
+        ) AS t WHERE t.row_num BETWEEN 1 AND 1
+      }
+  end
+
+  def test_custom_join_ar111
+    add_lock_test "custom join (arjdbc 1.1.1)",
+      %q{
+        SELECT t.*
+        FROM
+          (
+            SELECT
+              ROW_NUMBER() OVER(ORDER BY appointments.id) AS _row_num,
+              appointments.*
+            FROM
+              appointments INNER JOIN
+              appointment_details AS d1 ON appointments.[id] = d1.[appointment_id]
+            WHERE
+              (d1.[name] = N'appointment_identifier' AND d1.[value] = N'389727^MQ')
+          ) AS t
+        WHERE
+          t._row_num BETWEEN 1 AND 1
+      }, %q{
+        SELECT t.*
+        FROM
+          (
+            SELECT
+              ROW_NUMBER() OVER(ORDER BY appointments.id) AS _row_num,
+              appointments.*
+            FROM
+              appointments  WITH(ROWLOCK,UPDLOCK) INNER JOIN
+              appointment_details AS d1 WITH(ROWLOCK,UPDLOCK)  ON appointments.[id] = d1.[appointment_id]
+            WHERE
+              (d1.[name] = N'appointment_identifier' AND d1.[value] = N'389727^MQ')
+          ) AS t
+        WHERE
+          t._row_num BETWEEN 1 AND 1
+      }
+  end
+
+
+  private
+
+    class Dummy
+      include ::ArJdbc::MsSQL::LockHelpers::SqlServerAddLock
+    end
+
+    def add_lock!(sql, options={})
+      result = sql.dup
+      Dummy.new.add_lock!(result, {:lock=>true}.merge(options))
+      result
+    end
+
+    def add_lock_test(message, before, after, options={})
+      before = before.gsub(/\s*\n\s*/m, " ").strip
+      after = after.gsub(/\s*\n\s*/m, " ").strip
+      assert_equal after, add_lock!(before, options).strip, message
+    end
+end

data/test/mssql_row_locking_test.rb

@@ -0,0 +1,9 @@
+#! /usr/bin/env jruby
+
+require 'jdbc_common'
+require 'db/mssql'
+
+class MssqlRowLockingTest < Test::Unit::TestCase
+  include MigrationSetup
+  include RowLockingTestMethods
+end

data/test/mysql_reset_column_information_test.rb

@@ -0,0 +1,8 @@
+#! /usr/bin/env jruby
+
+require 'jdbc_common'
+require 'db/mysql'
+
+class MySQLResetColumnInformationTest < Test::Unit::TestCase
+  include ResetColumnInformationTestMethods
+end

data/test/mysql_simple_test.rb

@@ -18,7 +18,7 @@ class MysqlSimpleTest < Test::Unit::TestCase
   def test_column_class_instantiation
     text_column = nil
     assert_nothing_raised do
-      text_column = ActiveRecord::ConnectionAdapters::MysqlAdapter::Column.
+      text_column = ActiveRecord::ConnectionAdapters::MysqlColumn.
         new("title", nil, "text")
     end
     assert_not_nil text_column
@@ -42,17 +42,81 @@ class MysqlSimpleTest < Test::Unit::TestCase
     assert_nothing_raised { Entry.update_all({:title => "test"}, {}, {:limit => 1}) }
   end
 
+  # from rails active record tests
+  def test_update_all_with_joins_and_offset_and_order
+    user_1 = User.create :login => 'user_1'
+    user_2 = User.create :login => 'user_2'
+
+    entry_1 = Entry.create :title => 'title_1', :content => 'content_1', :rating => 0,
+    :user_id => user_1.id
+    entry_2 = Entry.create :title => 'title_2', :content => 'content_2', :rating => 1,
+    :user_id => user_2.id
+
+    all_entries = Entry.joins(:user).where('users.id' => user_1.id).
+      order('users.id', 'entries.id')
+    count   = all_entries.count
+    entries = all_entries.offset(1)
+
+    assert_equal count - 1, entries.update_all(:user_id => user_2.id)
+    assert_equal user_2, Entry.find_by_title('title_2').user
+  end
+
+  # from rails active record tests
+  def test_caching_of_columns
+    user = User.create :login => 'test'
+
+    # clear cache possibly created by other tests
+    user.entries.reset_column_information
+
+    assert_queries(1, /SHOW FIELDS/) { user.entries.columns; user.entries.columns }
+
+    ## and again to verify that reset_column_information clears the cache correctly
+    user.entries.reset_column_information
+    assert_queries(1, /SHOW FIELDS/) { user.entries.columns; user.entries.columns }
+  end
+
+  # from rails active record tests
+  def test_drop_index_from_table_named_values
+    connection = Entry.connection
+    connection.create_table :values, :force => true do |t|
+      t.integer :value
+    end
+
+    assert_nothing_raised do
+      connection.add_index :values, :value
+      connection.remove_index :values, :column => :value
+    end
+
+    connection.drop_table :values rescue nil
+  end
+
   def test_find_in_other_schema_with_include
     old_entries_table_name = Entry.table_name
     old_users_table_name   = User.table_name
     begin
-      User.set_table_name "#{MYSQL_CONFIG[:database]}.users"
-      Entry.set_table_name "#{MYSQL_CONFIG[:database]}.entries"
+      User.table_name  = "#{MYSQL_CONFIG[:database]}.users"
+      Entry.table_name = "#{MYSQL_CONFIG[:database]}.entries"
       assert !Entry.all(:include => :user).empty?
     ensure
-      Entry.set_table_name old_entries_table_name
-      User.set_table_name old_users_table_name
+      Entry.table_name = old_entries_table_name
+      User.table_name  = old_users_table_name
+    end
+  end
+
+  def test_create_xml_column
+    assert_nothing_raised do
+      @connection.create_table :xml_testings do |t|
+        t.xml :xml_test
+      end
     end
+
+    xml_test = @connection.columns(:xml_testings).detect do |c|
+      c.name == "xml_test"
+    end
+
+    assert_equal "text", xml_test.sql_type
+  ensure
+    @connection.drop_table :xml_testings rescue nil
   end
 end
 

data/test/oracle_reset_column_information_test.rb

@@ -0,0 +1,8 @@
+#! /usr/bin/env jruby
+
+require 'jdbc_common'
+require 'db/oracle'
+
+class OracleResetColumnInformationTest < Test::Unit::TestCase
+  include ResetColumnInformationTestMethods
+end

data/test/oracle_specific_test.rb

@@ -70,7 +70,7 @@ class OracleSpecificTest < Test::Unit::TestCase
 
   def test_model_access_by_synonym
     @klass = Class.new(ActiveRecord::Base)
-    @klass.set_table_name "POSTS"
+    @klass.table_name = "POSTS"
     entry_columns = Entry.columns_hash
     @klass.columns.each do |c|
       ec = entry_columns[c.name]

data/test/postgres_nonseq_pkey_test.rb

@@ -15,7 +15,7 @@ class CreateUrls < ActiveRecord::Migration
 end
 
 class Url < ActiveRecord::Base
-  set_primary_key :uhash
+  self.primary_key = :uhash
   #Shouldn't be needed: set_sequence_name nil
 end
 

data/test/postgres_reset_column_information_test.rb

@@ -0,0 +1,8 @@
+#! /usr/bin/env jruby
+
+require 'jdbc_common'
+require 'db/postgres'
+
+class PostgresResetColumnInformationTest < Test::Unit::TestCase
+  include ResetColumnInformationTestMethods
+end

data/test/postgres_simple_test.rb

@@ -16,13 +16,84 @@ class PostgresSimpleTest < Test::Unit::TestCase
     classname = @connection.class.name[/[^:]*$/]
     assert_equal 'PostgreSQLAdapter', classname
   end
-  
+
+  def test_encoding
+    assert_not_nil @connection.encoding
+  end
+
   def test_multi_statement_support
     results = @connection.execute "SELECT title from entries; SELECT login from users"
     assert_equal 2, results.length
     assert_equal ["title"], results[0].first.keys
     assert_equal ["login"], results[1].first.keys
   end
+
+  def test_create_xml_column
+    assert_nothing_raised do
+      @connection.create_table :xml_testings do |t|
+        t.column :xml_test, :xml
+      end
+    end
+
+    xml_test = @connection.columns(:xml_testings).detect do
+      |c| c.name == "xml_test"
+    end
+
+    assert_equal "xml", xml_test.sql_type
+  ensure
+    @connection.drop_table :xml_testings rescue nil
+  end
+
+  def test_create_table_with_limits
+    assert_nothing_raised do
+      @connection.create_table :testings do |t|
+        t.column :eleven_int, :integer, :limit => 11
+      end
+    end
+
+    columns = @connection.columns(:testings)
+    eleven = columns.detect { |c| c.name == "eleven_int" }
+    assert_equal "integer", eleven.sql_type
+  ensure
+    @connection.drop_table :testings rescue nil
+  end
+end
+
+class PostgresTimestampTest < Test::Unit::TestCase
+  def setup
+    DbTypeMigration.up
+  end
+
+  def teardown
+    DbTypeMigration.down
+  end
+
+  def test_string_is_character_varying
+    sample_string = DbType.connection.columns(:db_types).detect do |c|
+      c.name == "sample_string"
+    end
+
+    assert_match(/^character varying/, sample_string.sql_type)
+  end
+
+  # infinite timestamp tests based on rails tests for postgresql_adapter.rb
+  def test_load_infinity_and_beyond
+    d = DbType.find_by_sql("select 'infinity'::timestamp as sample_timestamp")
+    assert d.first.sample_timestamp.infinite?, 'timestamp should be infinite'
+
+    d = DbType.find_by_sql "select '-infinity'::timestamp as sample_timestamp"
+    time = d.first.sample_timestamp
+    assert time.infinite?, "timestamp should be infinte"
+    assert_operator time, :<, 0
+  end
+
+  def test_save_infinity_and_beyond
+    d = DbType.create!(:sample_timestamp => 1.0 / 0.0)
+    assert_equal(1.0 / 0.0, d.sample_timestamp)
+
+    e = DbType.create!(:sample_timestamp => -1.0 / 0.0)
+    assert_equal(-1.0 / 0.0, e.sample_timestamp)
+  end
 end
 
 class PostgresDeserializationTest < Test::Unit::TestCase