activerecord-jdbc-adapter 1.3.0.beta2 → 1.3.0.rc1

data/test/db/mssql/reset_column_information_test.rb

@@ -1,6 +0,0 @@
-require 'jdbc_common'
-require 'db/mssql'
-
-class MsSQLResetColumnInformationTest < Test::Unit::TestCase
-  include ResetColumnInformationTestMethods
-end

data/test/db/mssql/row_locking_test.rb

@@ -1,7 +0,0 @@
-require 'jdbc_common'
-require 'db/mssql'
-
-class MSSQLRowLockingTest < Test::Unit::TestCase
-  include MigrationSetup
-  include RowLockingTestMethods
-end

data/test/db/mssql/serialize_test.rb

@@ -1,6 +0,0 @@
-require 'db/mssql'
-require 'serialize'
-
-class MSSQLSerializeTest < Test::Unit::TestCase
-  include SerializeTestMethods
-end

data/test/db/mssql/simple_test.rb

@@ -1,140 +0,0 @@
-require 'jdbc_common'
-require 'db/mssql'
-
-class MSSQLSimpleTest < Test::Unit::TestCase
-  include SimpleTestMethods
-  include ActiveRecord3TestMethods
-  include DirtyAttributeTests
-
-  include ExplainSupportTestMethods if ar_version("3.1")
-  
-  # MS SQL 2005 doesn't have a DATE class, only TIMESTAMP
-
-  # String comparisons are insensitive by default
-  undef_method :test_validates_uniqueness_of_strings_case_sensitive
-
-  def test_does_not_munge_quoted_strings
-    example_quoted_values = [%{'quoted'}, %{D\'oh!}]
-    example_quoted_values.each do |value|
-      entry = Entry.create!(:title => value)
-      entry.reload
-      assert_equal(value, entry.title)
-    end
-  end
-
-  def test_change_column_default
-    Entry.connection.change_column "entries", "title", :string, :default => "new default"
-    Entry.reset_column_information
-    assert_equal("new default", Entry.new.title)
-
-    Entry.connection.change_column "entries", "title", :string, :default => nil
-    Entry.reset_column_information
-    assert_equal(nil, Entry.new.title)
-  end
-
-  def test_change_column_nullability
-    Entry.connection.change_column "entries", "title", :string, :null => true
-    Entry.reset_column_information
-    title_column = Entry.columns.find { |c| c.name == "title" }
-    assert(title_column.null)
-
-    Entry.connection.change_column "entries", "title", :string, :null => false
-    Entry.reset_column_information
-    title_column = Entry.columns.find { |c| c.name == "title" }
-    assert(!title_column.null)
-  end
-
-  [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
-  
-  # ACTIVERECORD_JDBC-124
-  def test_model_does_not_have_row_num_column
-    User.create! :login => 'row_num'
-    model = User.first
-    assert_false model.attributes.keys.include?("_row_num")
-    assert_false model.respond_to?(:_row_num)
-  end
-  
-  def test_returns_charset
-    assert_not_nil ActiveRecord::Base.connection.charset
-  end
-  
-  def test_rename_table
-    user = User.create! :login => 'luser'
-    begin
-      ActiveRecord::Base.connection.rename_table 'users', 'lusers'
-      lusers = Class.new(ActiveRecord::Base)
-      lusers.table_name = 'lusers'
-      assert_kind_of ActiveRecord::Base, lusers.find(user.id)
-    ensure
-      CreateUsers.up rescue nil
-      ActiveRecord::Base.connection.execute("DROP TABLE lusers") rescue nil
-    end
-  end
-  
-  def test_remove_column_with_index
-    ActiveRecord::Schema.define do
-      add_column :entries, 'another_column', :string
-      add_index :entries, 'another_column'
-    end
-
-    columns = ActiveRecord::Base.connection.columns("entries")
-    assert columns.find { |col| col.name == 'another_column' }
-
-    ActiveRecord::Schema.define do
-      remove_column "entries", 'another_column'
-    end
-
-    columns = ActiveRecord::Base.connection.columns("entries")
-    assert ! columns.find { |col| col.name == 'another_column' }
-  end
-  
-  def test_find_by_sql_WITH_statement
-    user = User.create! :login => 'ferko'
-    Entry.create! :title => 'aaa', :user_id => user.id
-    entries = Entry.find_by_sql '' + 
-      'WITH EntryAndUser (title, login, updated_on) AS ' +
-      '(' +
-      ' SELECT e.title, u.login, e.updated_on ' + 
-      ' FROM entries e INNER JOIN users u ON e.user_id = u.id ' +
-      ')' +
-      ' ' +
-      'SELECT * FROM EntryAndUser ORDER BY title ASC'
-    assert entries.first
-    assert entries.first.title
-    assert entries.first.login
-  end
-  
-  def test_exec
-    ActiveRecord::Base.connection.execute "CREATE PROCEDURE usp_allentries AS SELECT * FROM entries"
-    
-    assert ActiveRecord::Base.connection.exec_query(" EXEC usp_allentries ")
-    
-    # exec_sql = "EXEC sp_msforeachdb 'SELECT count(*) FROM sys.objects'"
-    # NOTE: our _execute logic assumes all EXEC statements to do an update :
-    # assert_not_empty ActiveRecord::Base.connection.execute(exec_sql) # [ { '' => 42 }]
-  ensure
-    ActiveRecord::Base.connection.execute "DROP PROCEDURE usp_allentries" rescue nil
-  end
-  
-  def test_current_user
-    # skip if ActiveRecord::Base.connection.send(:sqlserver_2000?)
-    assert_equal 'dbo', ActiveRecord::Base.connection.current_user
-  end
-
-  def test_default_schema
-    # skip if ActiveRecord::Base.connection.send(:sqlserver_2000?)
-    assert_equal 'dbo', ActiveRecord::Base.connection.default_schema
-  end
-  
-end
-
-class MSSQLHasManyThroughTest < Test::Unit::TestCase
-  include HasManyThroughMethods
-end

data/test/db/mssql/transaction_test.rb

@@ -1,6 +0,0 @@
-require 'db/mssql'
-require 'transaction'
-
-class MSSQLTransactionTest < Test::Unit::TestCase
-  include TransactionTestMethods
-end

data/test/db/mssql/types_test.rb

@@ -1,205 +0,0 @@
-require 'test_helper'
-require 'db/mssql'
-
-class MSSQLDateTimeTypesTest < Test::Unit::TestCase
-  
-  TABLE_DEFINITION = <<-SQL
-    CREATE TABLE date_and_times (
-      [id] int NOT NULL IDENTITY(1, 1) PRIMARY KEY, 
-      [datetime] DATETIME
-    )
-  SQL
-  
-  @@default_timezone = ActiveRecord::Base.default_timezone
-  
-  def self.startup
-    ActiveRecord::Base.default_timezone = :local
-    ActiveRecord::Base.connection.execute TABLE_DEFINITION
-    # ActiveRecord::Base.logger.level = Logger::DEBUG
-  end
-
-  def self.shutdown
-    # ActiveRecord::Base.logger.level = Logger::WARN
-    ActiveRecord::Base.connection.execute "DROP TABLE date_and_times"
-    ActiveRecord::Base.default_timezone = @@default_timezone
-  end
-  
-  class DateAndTime < ActiveRecord::Base; end
-  
-  def test_datetime
-    # January 1, 1753, through December 31, 9999 + 00:00:00 through 23:59:59.997
-    datetime = DateTime.parse('2012-12-21T21:11:01')
-    model = DateAndTime.create! :datetime => datetime
-    assert_datetime_equal datetime, model.reload.datetime
-  end if ar_version('3.0')
-  
-  if ActiveRecord::Base.connection.sqlserver_version >= '2008'
-    
-    # 2008 Date and Time: http://msdn.microsoft.com/en-us/library/ff848733.aspx
-    
-    TABLE_DEFINITION.replace <<-SQL
-      CREATE TABLE date_and_times (
-        [id] int NOT NULL IDENTITY(1, 1), 
-        [datetime] DATETIME,
-        [date] DATE,
-        [datetime2] DATETIME2,
-        [datetime25] DATETIME2(5),
-        [smalldatetime] SMALLDATETIME,
-        [time] TIME
-        PRIMARY KEY CLUSTERED ( [id] ASC ) WITH ( 
-          PAD_INDEX = OFF, STATISTICS_NORECOMPUTE = OFF, IGNORE_DUP_KEY = OFF, 
-          ALLOW_ROW_LOCKS  = ON, ALLOW_PAGE_LOCKS  = ON
-        ) ON [PRIMARY]
-      )
-    SQL
-    
-    def test_date
-      # 0001-01-01 through 9999-12-31
-      date = DateTime.parse('2012-12-31')
-      model = DateAndTime.create! :date => date
-      assert_instance_of Date, model.reload.date
-      assert_date_equal date.to_date, model.date
-    end
-    
-    def test_datetime2
-      # date range + 00:00:00 through 23:59:59.9999999
-      datetime = DateTime.parse('2012-12-21T21:11:01')
-      model = DateAndTime.create! :datetime2 => datetime
-      assert_not_nil model.datetime2
-      assert_datetime_equal datetime, model.reload.datetime2
-    end if ar_version('3.0')
-
-    def test_datetime25
-#      id = DateAndTime.connection.insert 'INSERT INTO date_and_times ([datetime25])' + 
-#        " VALUES ('1982-07-13 02:24:56.12345')"
-#      model = DateAndTime.find(id)
-#      assert_not_nil model.datetime25
-#      datetime = Time.local(1982, 7, 13, 02, 24, 56, 123450)
-#      assert_equal datetime, model.datetime25
-      
-      datetime = Time.local(1982, 7, 13, 02, 24, 56, 123000)
-      model = DateAndTime.create! :datetime25 => datetime
-      assert_not_nil model.datetime25
-      assert_datetime_equal datetime, model.reload.datetime25
-      assert_equal datetime.usec, model.datetime25.usec if ar_version('3.2')
-    end
-    
-    def test_smalldatetime
-      # 1900-01-01 through 2079-06-06 + 00:00:00 through 23:59:59
-      # with seconds always zero - rounded to the nearest minute
-      datetime = DateTime.parse('1999-12-31T23:59:21')
-      model = DateAndTime.create! :smalldatetime => datetime
-      datetime = DateTime.parse('1999-12-31T23:59:00')
-      assert_datetime_equal datetime, model.reload.smalldatetime
-      
-      datetime = DateTime.parse('1999-12-31T22:59:31')
-      model = DateAndTime.create! :smalldatetime => datetime
-      datetime = DateTime.parse('1999-12-31T23:00:00')
-      assert_datetime_equal datetime, model.reload.smalldatetime
-    end
-    
-    def test_time
-      # 00:00:00.0000000 through 23:59:59.9999999
-      time = Time.local(0000, 1, 01, 23, 59, 58, 987000)
-      model = DateAndTime.create! :time => time
-      assert_not_nil model.time
-      assert_time_equal time, model.reload.time
-      assert_equal 987000, model.time.usec
-      
-      id = DateAndTime.connection.insert 'INSERT INTO date_and_times ([time])' + 
-        " VALUES ('22:05:59.123456')"
-      model = DateAndTime.find(id)
-      assert_not_nil model.time
-      time = Time.local(2000, 1, 01, 22, 05, 59, 123456)
-      assert_time_equal time, model.time
-      assert_equal time.usec, model.time.usec
-    end
-    
-  end
-  
-end
-
-class MSSQLLegacyTypesTest < Test::Unit::TestCase
-
-  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', 
-          [text] TEXT,
-          [ntext] NTEXT,
-          [image] IMAGE
-        )
-      SQL
-    end
-
-    def self.down
-      drop_table "articles"
-    end
-
-  end
-
-  class Article < ActiveRecord::Base; end
-  
-  def self.startup; CreateArticles.up; end
-
-  def self.shutdown; CreateArticles.down; end
-
-  def teardown
-    ActiveRecord::Base.clear_active_connections!
-  end
-  
-  def test_varchar_column
-    article = Article.create! :title => "Blah blah"
-    assert_equal("Blah blah", article.reload.title)
-  end
-  
-  def test_varchar_default_value
-    assert_equal("anonymous", Article.new.author)
-  end
-  
-  def test_text_column
-    sample_text = "Lorem ipsum dolor sit amet ..."
-    article = Article.create! :text => sample_text.dup
-    assert_equal(sample_text, article.reload.text)
-  end
-
-  def test_ntext_column
-    sample_text = "Lorem ipsum dolor sit amet ..."
-    article = Article.create! :ntext => sample_text.dup
-    assert_equal(sample_text, article.reload.ntext)
-  end
-
-  test "text, ntext and image are treated as special" do
-    assert_not_empty columns = Article.columns
-    assert_true columns.find { |column| column.name == 'text' }.special
-    assert_true columns.find { |column| column.name == 'ntext' }.special
-    assert_true columns.find { |column| column.name == 'image' }.special
-    assert ! Article.columns.find { |column| column.name == 'id' }.special
-    assert ! Article.columns.find { |column| column.name == 'title' }.special
-    assert ! Article.columns.find { |column| column.name == 'author' }.special
-    
-    special_column_names = Article.connection.send(:special_column_names, 'articles')
-    assert_equal ['text', 'ntext', 'image'], special_column_names
-    special_column_names = Article.connection.send(:special_column_names, '[articles]')
-    assert_equal ['text', 'ntext', 'image'], special_column_names
-  end
-  
-  test "repairs select equlity comparison for special columns" do
-    sql = "SELECT * FROM articles WHERE text = '1' ORDER BY text"
-    r_sql = Article.connection.send(:repair_special_columns, sql)
-    assert_equal "SELECT * FROM articles WHERE [text] LIKE '1' ", r_sql
-    
-    sql = "SELECT * FROM [articles] WHERE [text]='1' AND [ntext]= '2' ORDER BY [ntext]"
-    r_sql = Article.connection.send(:repair_special_columns, sql)
-    assert_equal "SELECT * FROM [articles] WHERE [text] LIKE '1' AND [ntext] LIKE '2' ", r_sql
-    
-    sql = "SELECT * FROM [articles] WHERE [text] = 'text' AND [title] = 't' ORDER BY title"
-    r_sql = Article.connection.send(:repair_special_columns, sql)
-    assert_equal "SELECT * FROM [articles] WHERE [text] LIKE 'text' AND [title] = 't' ORDER BY title", r_sql
-  end
-  
-end

data/test/db/mssql/unit_test.rb

@@ -1,249 +0,0 @@
-require 'test_helper'
-require 'arjdbc/mssql'
-
-class MSSQLUnitTest < Test::Unit::TestCase
-  
-  # NOTE: lot of tests kindly borrowed from __activerecord-sqlserver-adapter__
-  
-  test "get table name" do
-    insert_sql = "INSERT INTO [funny_jokes] ([name]) VALUES('Knock knock')"
-    update_sql = "UPDATE [customers] SET [address_street] = NULL WHERE [id] = 2"
-    select_sql = "SELECT * FROM [customers] WHERE ([customers].[id] = 1)"
-    
-    connection = new_adapter_stub
-    assert_equal 'funny_jokes', connection.send(:get_table_name, insert_sql)
-    assert_equal 'customers', connection.send(:get_table_name, update_sql)
-    assert_equal 'customers', connection.send(:get_table_name, select_sql)
-
-    assert_equal '[funny_jokes]', connection.send(:get_table_name, insert_sql, true)
-    assert_equal '[customers]', connection.send(:get_table_name, update_sql, true)
-    assert_equal '[customers]', connection.send(:get_table_name, select_sql, true)
-    
-    select_sql = " SELECT * FROM  customers  WHERE ( customers.id = 1 ) "
-    assert_equal 'customers', connection.send(:get_table_name, select_sql)
-    assert_equal 'customers', connection.send(:get_table_name, select_sql, true)
-    
-    assert_nil connection.send(:get_table_name, 'SELECT 1')
-    # NOTE: this has been failing even before refactoring - not sure if it's needed :
-    #assert_nil connection.send(:get_table_name, 'SELECT * FROM someFunction()')
-    #assert_nil connection.send(:get_table_name, 'SELECT * FROM someFunction() WHERE 1 > 2')
-  end
-  
-  context "Utils" do
-    
-    setup do
-      @expected_table_name = 'baz'
-      @expected_db_name = 'foo'
-      @first_second_table_names = ['[baz]','baz','[bar].[baz]','bar.baz']
-      @third_table_names = ['[foo].[bar].[baz]','foo.bar.baz']
-      @qualifed_table_names = @first_second_table_names + @third_table_names
-    end
-
-    test 'return clean table_name from Utils.unqualify_table_name' do
-      @qualifed_table_names.each do |qtn|
-        assert_equal @expected_table_name,
-          ArJdbc::MSSQL::Utils.send(:unqualify_table_name, qtn),
-          "This qualifed_table_name #{qtn} did not unqualify correctly."
-      end
-    end
-
-    test 'return nil from Utils.unqualify_db_name when table_name is less than 2 qualified' do
-      @first_second_table_names.each do |qtn|
-        assert_equal nil, ArJdbc::MSSQL::Utils.send(:unqualify_db_name, qtn),
-          "This qualifed_table_name #{qtn} did not return nil."
-      end
-    end
-
-    test 'return clean db_name from Utils.unqualify_db_name when table is thrid level qualified' do
-      @third_table_names.each do |qtn|
-        assert_equal @expected_db_name,
-          ArJdbc::MSSQL::Utils.send(:unqualify_db_name, qtn),
-          "This qualifed_table_name #{qtn} did not unqualify the db_name correctly."
-      end
-    end
-    
-  end
-  
-  test "quote column name" do
-    connection = new_adapter_stub
-    assert_equal "[foo]", connection.quote_column_name("foo")
-    assert_equal "[bar]", connection.quote_column_name("[bar]")
-    assert_equal "[foo]]bar]", connection.quote_column_name("foo]bar")
-    
-    assert_equal "[dbo].[foo]", connection.quote_column_name("dbo.foo")
-    assert_equal "[dbo].[bar]", connection.quote_column_name("[dbo].[bar]")
-    assert_equal "[foo].[bar]", connection.quote_column_name("[foo].bar")
-    assert_equal "[foo].[bar]", connection.quote_column_name("foo.[bar]")
-  end
-  
-  private
-  
-  def new_adapter_stub(config = {})
-    config = config.merge({ 
-        :adapter => 'jdbc', 
-        :adapter_spec => ArJdbc::MSSQL, 
-        :sqlserver_version => 2008
-    })
-    connection = stub('connection'); logger = nil
-    connection.stub_everything
-    adapter = ActiveRecord::ConnectionAdapters::JdbcAdapter.new connection, logger, config
-    yield(adapter) if block_given?
-    adapter
-  end
-  
-end
-
-# This tests ArJdbc::MSSQL#add_lock! without actually connecting to the database.
-class MSSQLRowLockingUnitTest < 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
-
-  class Dummy
-    include ::ArJdbc::MSSQL::LockHelpers::SqlServerAddLock
-  end
-
-  private
-
-  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