activerecord-jdbc-adapter-onsite 1.2.2

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_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_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

data/test/mssql_multibyte_test.rb

@@ -0,0 +1,18 @@
+#! /usr/bin/env jruby
+# encoding: utf-8
+require 'jdbc_common'
+require 'db/mssql'
+
+class MsSQLMultibyteTest < Test::Unit::TestCase
+  
+  include MultibyteTestMethods
+
+  def test_select_multibyte_string
+    Entry.create!(:title => 'テスト', :content => '本文')
+    entry = Entry.find(:last)
+    assert_equal "テスト", entry.title
+    assert_equal "本文", entry.content
+    assert_equal entry, Entry.find_by_title("テスト")
+  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