activerecord-sqlserver-adapter 2.3.24 → 3.0.0

data/test/cases/pessimistic_locking_test_sqlserver.rb

@@ -1,125 +0,0 @@
-require 'cases/sqlserver_helper'
-require 'models/person'
-require 'models/reader'
-
-class PessimisticLockingTestSqlserver < ActiveRecord::TestCase
-  
-  self.use_transactional_fixtures = false
-  fixtures :people, :readers
-  
-  def setup
-    Person.columns; Reader.columns # Avoid introspection queries during tests.
-  end
-  
-  context 'For simple finds with default lock option' do
-
-    should 'lock with simple find' do
-      assert_nothing_raised do
-        Person.transaction do
-          Person.find 1, :lock => true
-        end
-      end
-    end
-
-    should 'lock with scoped find' do
-      assert_nothing_raised do
-        Person.transaction do
-          Person.with_scope(:find => { :lock => true }) do
-            Person.find 1
-          end
-        end
-      end
-    end
-
-    should 'lock with eager find' do
-      assert_nothing_raised do
-        Person.transaction do
-          Person.find 1, :include => :readers, :lock => true
-        end
-      end
-    end
-
-    should 'reload with lock when #lock! called' do
-      assert_nothing_raised do
-        Person.transaction do
-          person = Person.find 1
-          old, person.first_name = person.first_name, 'fooman'
-          person.lock!
-          assert_equal old, person.first_name
-        end
-      end
-    end
-    
-    should 'simply add lock to find all' do
-      assert_sql %r|SELECT \* FROM \[people\] WITH \(NOLOCK\)| do
-        Person.all(:lock => 'WITH (NOLOCK)')
-      end
-    end
-
-  end
-  
-  context 'For paginated finds' do
-    
-    setup do
-      20.times { |n| Person.create!(:first_name => "Thing_#{n}") }
-    end
-    
-    should 'cope with un-locked paginated results' do
-      tally_not_locked = %r|SELECT count\(\*\) as TotalRows from \(SELECT TOP 1000000000 \* FROM \[people\]\s+WITH \(NOLOCK\) \) tally|
-      inner_tmp_not_locked = %r|SELECT TOP 15 \* FROM \[people\] WITH \(NOLOCK\)|
-      # Currently association limiting is not locked like the parent.
-      association_limiting_not_locked = %r|SELECT \[readers\]\.\* FROM \[readers\] WITH \(NOLOCK\) WHERE \(\[readers\]\.person_id IN \(1,2,3,4,5\)\)|
-      assert_sql(tally_not_locked,inner_tmp_not_locked) do
-        Person.all(:include => :readers, :lock => 'WITH (NOLOCK)', :limit => 5, :offset => 10)
-      end
-    end
-
-  end
-  
-  
-  context 'For dueling concurrent connections' do
-    
-    use_concurrent_connections
-
-    should 'no locks does not wait' do
-      first, second = duel { Person.find 1 }
-      assert first.end > second.end
-    end
-    
-    should 'that second lock waits' do
-      assert [0.2, 1, 5].any? { |zzz|
-        first, second = duel(zzz) { Person.find 1, :lock => true }
-        second.end > first.end
-      }
-    end
-    
-  end
-  
-    
-  protected
-  
-  def duel(zzz = 5)
-    t0, t1, t2, t3 = nil, nil, nil, nil
-    a = Thread.new do
-      t0 = Time.now
-      Person.transaction do
-        yield
-        sleep zzz       # block thread 2 for zzz seconds
-      end
-      t1 = Time.now
-    end
-    b = Thread.new do
-      sleep zzz / 2.0   # ensure thread 1 tx starts first
-      t2 = Time.now
-      Person.transaction { yield }
-      t3 = Time.now
-    end
-    a.join
-    b.join
-    assert t1 > t0 + zzz
-    assert t2 > t0
-    assert t3 > t2
-    [t0.to_f..t1.to_f, t2.to_f..t3.to_f]
-  end
-  
-end

data/test/cases/query_cache_test_sqlserver.rb

@@ -1,24 +0,0 @@
-require 'cases/sqlserver_helper'
-require 'models/task'
-
-class QueryCacheTestSqlserver < ActiveRecord::TestCase
-end
-
-class QueryCacheTest < ActiveRecord::TestCase
-  
-  COERCED_TESTS = [:test_cache_does_not_wrap_string_results_in_arrays]
-  
-  include SqlserverCoercedTest
-  
-  fixtures :tasks
-  
-
-  def test_coerced_test_cache_does_not_wrap_string_results_in_arrays
-    Task.cache do
-      assert_instance_of Fixnum, Task.connection.select_value("SELECT count(*) AS count_all FROM tasks")
-    end
-  end
-  
-end
-
-

data/test/cases/schema_dumper_test_sqlserver.rb

@@ -1,72 +0,0 @@
-require 'cases/sqlserver_helper'
-
-class SchemaDumperTestSqlserver < ActiveRecord::TestCase
-  
-  setup :find_all_tables
-  
-  context 'For primary keys' do
-
-    should 'honor nonstandards' do
-      table_dump('movies') do |output|
-        match = output.match(%r{create_table "movies"(.*)do})
-        assert_not_nil(match, "nonstandardpk table not found")
-        assert_match %r(:primary_key => "movieid"), match[1], "non-standard primary key not preserved"
-      end
-    end
-    
-  end
-  
-  context 'For integers' do
-    
-    should 'include limit constraint that match logic for smallint and bigint in #extract_limit' do
-      table_dump('integer_limits') do |output|
-        assert_match %r{c_int_1.*:limit => 2}, output
-        assert_match %r{c_int_2.*:limit => 2}, output
-        assert_match %r{c_int_3.*}, output
-        assert_match %r{c_int_4.*}, output
-        assert_no_match %r{c_int_3.*:limit}, output
-        assert_no_match %r{c_int_4.*:limit}, output
-        assert_match %r{c_int_5.*:limit => 8}, output
-        assert_match %r{c_int_6.*:limit => 8}, output
-        assert_match %r{c_int_7.*:limit => 8}, output
-        assert_match %r{c_int_8.*:limit => 8}, output
-      end
-    end
-    
-  end
-  
-  context 'For strings' do
-
-    should 'have varchar(max) dumped as text' do
-      table_dump('sql_server_strings') do |output|
-        assert_match %r{t.text.*varchar_max}, output
-      end
-    end if sqlserver_2005? || sqlserver_2008?
-
-  end
-  
-  
-  
-  
-  private
-  
-  def find_all_tables
-    @all_tables ||= ActiveRecord::Base.connection.tables
-  end
-  
-  def standard_dump(ignore_tables = [])
-    stream = StringIO.new
-    ActiveRecord::SchemaDumper.ignore_tables = [*ignore_tables]
-    ActiveRecord::SchemaDumper.dump(ActiveRecord::Base.connection, stream)
-    stream.string
-  end
-  
-  def table_dump(*table_names)
-    stream = StringIO.new
-    ActiveRecord::SchemaDumper.ignore_tables = @all_tables-table_names
-    ActiveRecord::SchemaDumper.dump(ActiveRecord::Base.connection, stream)
-    yield stream.string
-    stream.string
-  end
-  
-end

data/test/cases/specific_schema_test_sqlserver.rb

@@ -1,154 +0,0 @@
-require 'cases/sqlserver_helper'
-
-class StringDefault < ActiveRecord::Base; end;
-class SqlServerEdgeSchema < ActiveRecord::Base
-  attr_accessor :new_id_setting
-  before_create :set_new_id
-  protected
-  def set_new_id
-    self[:guid_newid] ||= connection.newid_function if new_id_setting
-    true
-  end
-end
-
-class SpecificSchemaTestSqlserver < ActiveRecord::TestCase
-  
-  should 'quote table names properly even when they are views' do
-    obj = SqlServerQuotedTable.create!
-    assert_nothing_raised { SqlServerQuotedTable.first }
-    obj = SqlServerQuotedView1.create!
-    assert_nothing_raised { SqlServerQuotedView1.first }
-    obj = SqlServerQuotedView2.create!
-    assert_nothing_raised { SqlServerQuotedView2.first }
-  end
-  
-  should 'cope with multi line defaults' do
-    default = StringDefault.new
-    assert_equal "Some long default with a\nnew line.", default.string_with_multiline_default
-  end
-  
-  should 'default strings before save' do
-    default = StringDefault.new
-    assert_equal nil, default.string_with_null_default
-    assert_equal 'null', default.string_with_pretend_null_one
-    assert_equal '(null)', default.string_with_pretend_null_two
-    assert_equal 'NULL', default.string_with_pretend_null_three
-    assert_equal '(NULL)', default.string_with_pretend_null_four
-    assert_equal '(3)', default.string_with_pretend_paren_three
-  end
-
-  should 'default strings after save' do
-    default = StringDefault.create
-    assert_equal nil, default.string_with_null_default
-    assert_equal 'null', default.string_with_pretend_null_one
-    assert_equal '(null)', default.string_with_pretend_null_two
-    assert_equal 'NULL', default.string_with_pretend_null_three
-    assert_equal '(NULL)', default.string_with_pretend_null_four
-  end
-  
-  context 'Testing edge case schemas' do
-    
-    setup do
-      @edge_class = SqlServerEdgeSchema
-    end
-    
-    context 'with description column' do
-
-      setup do
-        @da = @edge_class.create! :description => 'A'
-        @db = @edge_class.create! :description => 'B'
-        @dc = @edge_class.create! :description => 'C'
-      end
-      
-      teardown { @edge_class.delete_all }
-
-      should 'allow all sorts of ordering without adapter munging it up' do
-        assert_equal ['A','B','C'], @edge_class.all(:order => 'description').map(&:description)
-        assert_equal ['A','B','C'], @edge_class.all(:order => 'description asc').map(&:description)
-        assert_equal ['A','B','C'], @edge_class.all(:order => 'description ASC').map(&:description)
-        assert_equal ['C','B','A'], @edge_class.all(:order => 'description desc').map(&:description)
-        assert_equal ['C','B','A'], @edge_class.all(:order => 'description DESC').map(&:description)
-      end
-
-    end
-    
-    context 'with bigint column' do
-
-      setup do
-        @b5k   = 5000
-        @bi5k  = @edge_class.create! :bigint => @b5k, :description => 'Five Thousand'
-        @bnum  = 9_000_000_000_000_000_000
-        @bimjr = @edge_class.create! :bigint => @bnum, :description => 'Close to max bignum'
-      end
-
-      should 'can find by biginit' do
-        assert_equal @bi5k,  @edge_class.find_by_bigint(@b5k)
-        assert_equal @b5k,   @edge_class.find(:first, :select => 'bigint', :conditions => {:bigint => @b5k}).bigint
-        assert_equal @bimjr, @edge_class.find_by_bigint(@bnum)
-        assert_equal @bnum,  @edge_class.find(:first, :select => 'bigint', :conditions => {:bigint => @bnum}).bigint
-      end
-
-    end
-    
-    context 'with tinyint column' do
-
-      setup do
-        @tiny1 = @edge_class.create! :tinyint => 1
-        @tiny255 = @edge_class.create! :tinyint => 255
-      end
-
-      should 'not treat tinyint like boolean as mysql does' do
-        assert_equal 1, @edge_class.find_by_tinyint(1).tinyint
-        assert_equal 255, @edge_class.find_by_tinyint(255).tinyint
-      end
-      
-      should 'throw an error when going out of our tiny int bounds' do
-        assert_raise(ActiveRecord::StatementInvalid) { @edge_class.create! :tinyint => 256 }
-      end
-      
-    end
-    
-    context 'with uniqueidentifier column' do
-
-      setup do
-        @newid = ActiveRecord::Base.connection.newid_function
-        assert_guid @newid
-      end
-
-      should 'allow a simple insert and read of a column without a default function' do
-        obj = @edge_class.create! :guid => @newid
-        assert_equal @newid, @edge_class.find(obj.id).guid
-      end
-      
-      should 'record the default function name in the column definition but still show a nil real default, will use one day for insert/update' do
-        newid_column = @edge_class.columns_hash['guid_newid']
-        assert newid_column.default_function.present?
-        assert_nil newid_column.default
-        assert_equal 'newid()', newid_column.default_function
-        unless ActiveRecord::Base.connection.sqlserver_2000?
-          newseqid_column = @edge_class.columns_hash['guid_newseqid']
-          assert newseqid_column.default_function.present?
-          assert_nil newseqid_column.default
-          assert_equal 'newsequentialid()', newseqid_column.default_function
-        end
-      end
-      
-      should 'use model callback to set get a new guid' do
-        obj = @edge_class.new
-        obj.new_id_setting = true
-        obj.save!
-        assert_guid obj.guid_newid
-      end
-
-    end
-    
-  end
-  
-  
-  protected
-  
-  def assert_guid(guid)
-    assert_match %r|\w{8}-\w{4}-\w{4}-\w{4}-\w{12}|, guid
-  end
-  
-end

data/test/cases/sqlserver_helper.rb

@@ -1,140 +0,0 @@
-
-SQLSERVER_TEST_ROOT       = File.expand_path(File.join(File.dirname(__FILE__),'..'))
-SQLSERVER_ASSETS_ROOT     = File.expand_path(File.join(SQLSERVER_TEST_ROOT,'assets'))
-SQLSERVER_FIXTURES_ROOT   = File.expand_path(File.join(SQLSERVER_TEST_ROOT,'fixtures'))
-SQLSERVER_MIGRATIONS_ROOT = File.expand_path(File.join(SQLSERVER_TEST_ROOT,'migrations'))
-SQLSERVER_SCHEMA_ROOT     = File.expand_path(File.join(SQLSERVER_TEST_ROOT,'schema'))
-ACTIVERECORD_TEST_ROOT    = File.expand_path(File.join(ENV['RAILS_SOURCE'],'activerecord','test'))
-
-require 'rubygems'
-require 'bundler'
-Bundler.setup
-require 'shoulda'
-require 'mocha'
-begin ; require 'ruby-debug' ; rescue LoadError ; end
-[ File.expand_path(File.join(File.dirname(__FILE__),'..','..','test')),
-  File.expand_path(File.join(File.dirname(__FILE__),'..','..','test','connections','native_sqlserver_odbc')),
-  File.expand_path(File.join(ENV['RAILS_SOURCE'],'activerecord','test'))
-].each{ |lib| $:.unshift(lib) unless $:.include?(lib) } if ENV['TM_DIRECTORY']
-require 'cases/helper'
-require 'models/topic'
-require 'active_record/version'
-
-GC.copy_on_write_friendly = true if GC.respond_to?(:copy_on_write_friendly?)
-
-ActiveRecord::Migration.verbose = false
-ActiveRecord::ConnectionAdapters::SQLServerAdapter.log_info_schema_queries = true
-
-# Defining our classes in one place as well as soem core tests that need coercing date/time types.
-
-class TableWithRealColumn < ActiveRecord::Base; end
-class FkTestHasFk < ActiveRecord::Base ; end
-class FkTestHasPk < ActiveRecord::Base ; end
-class NumericData < ActiveRecord::Base ; self.table_name = 'numeric_data' ; end
-class FloatData < ActiveRecord::Base ; self.table_name = 'float_data' ; end
-class CustomersView < ActiveRecord::Base ; self.table_name = 'customers_view' ; end
-class StringDefaultsView < ActiveRecord::Base ; self.table_name = 'string_defaults_view' ; end
-class StringDefaultsBigView < ActiveRecord::Base ; self.table_name = 'string_defaults_big_view' ; end
-class SqlServerQuotedTable < ActiveRecord::Base ; self.table_name = 'quoted-table' ; end
-class SqlServerQuotedView1 < ActiveRecord::Base ; self.table_name = 'quoted-view1' ; end
-class SqlServerQuotedView2 < ActiveRecord::Base ; self.table_name = 'quoted-view2' ; end
-class SqlServerUnicode < ActiveRecord::Base ; end
-class SqlServerString < ActiveRecord::Base ; end
-class SqlServerChronic < ActiveRecord::Base
-  coerce_sqlserver_date :date
-  coerce_sqlserver_time :time
-  default_timezone = :utc
-end
-class Topic < ActiveRecord::Base
-  coerce_sqlserver_date :last_read
-  coerce_sqlserver_time :bonus_time
-end
-class Person < ActiveRecord::Base
-  coerce_sqlserver_date :favorite_day
-end
-
-# A module that we can include in classes where we want to override an active record test.
-
-module SqlserverCoercedTest
-  def self.included(base)
-    base.extend ClassMethods
-  end
-  module ClassMethods
-    def coerced_tests
-      self.const_get(:COERCED_TESTS) rescue nil
-    end
-    def method_added(method)
-      if coerced_tests && coerced_tests.include?(method)
-        undef_method(method)
-        STDOUT.puts("Undefined coerced test: #{self.name}##{method}")
-      end
-    end
-  end
-end
-
-# Set weather to test unicode string defaults or not. Used from rake task.
-
-if ENV['ENABLE_DEFAULT_UNICODE_TYPES'] != 'false'
-  puts "With enabled unicode string types"
-  ActiveRecord::ConnectionAdapters::SQLServerAdapter.enable_default_unicode_types = true
-end
-
-# Change the text database type to support ActiveRecord's tests for = on text columns which 
-# is not supported in SQL Server text columns, so use varchar(8000) instead.
-
-if ActiveRecord::Base.connection.sqlserver_2000?
-  if ActiveRecord::ConnectionAdapters::SQLServerAdapter.enable_default_unicode_types
-    ActiveRecord::ConnectionAdapters::SQLServerAdapter.native_text_database_type = 'nvarchar(4000)'
-  else
-    ActiveRecord::ConnectionAdapters::SQLServerAdapter.native_text_database_type = 'varchar(8000)'
-  end
-end
-
-# Our changes/additions to ActiveRecord test helpers specific for SQL Server.
-
-ActiveRecord::Base.connection.class.class_eval do
-  IGNORED_SQL << %r|SELECT SCOPE_IDENTITY| << %r{INFORMATION_SCHEMA\.(TABLES|VIEWS|COLUMNS)}
-  IGNORED_SQL << %r|SELECT @@IDENTITY| << %r|SELECT @@ROWCOUNT| << %r|SELECT @@version| << %r|SELECT @@TRANCOUNT|
-end
-
-ActiveRecord::ConnectionAdapters::SQLServerAdapter.class_eval do
-  def raw_select_with_query_record(sql, name=nil, options={})
-    $queries_executed ||= []
-    $queries_executed << sql unless IGNORED_SQL.any? { |r| sql =~ r }
-    raw_select_without_query_record(sql,name,options)
-  end
-  alias_method_chain :raw_select, :query_record
-end
-
-module ActiveRecord 
-  class TestCase < ActiveSupport::TestCase
-    class << self
-      def connection_mode_dblib? ; ActiveRecord::Base.connection.instance_variable_get(:@connection_options)[:mode] == :dblib ; end
-      def connection_mode_odbc? ; ActiveRecord::Base.connection.instance_variable_get(:@connection_options)[:mode] == :odbc ; end
-      def connection_mode_adonet? ; ActiveRecord::Base.connection.instance_variable_get(:@connection_options)[:mode] == :adonet ; end
-      def sqlserver_2000? ; ActiveRecord::Base.connection.sqlserver_2000? ; end
-      def sqlserver_2005? ; ActiveRecord::Base.connection.sqlserver_2005? ; end
-      def sqlserver_2008? ; ActiveRecord::Base.connection.sqlserver_2008? ; end
-      def ruby_19? ; RUBY_VERSION >= '1.9' ; end
-    end
-    def assert_sql(*patterns_to_match)
-      $queries_executed = []
-      yield
-    ensure
-      failed_patterns = []
-      patterns_to_match.each do |pattern|
-        failed_patterns << pattern unless $queries_executed.any?{ |sql| pattern === sql }
-      end
-      assert failed_patterns.empty?, "Query pattern(s) #{failed_patterns.map(&:inspect).join(', ')} not found in:\n#{$queries_executed.inspect}"
-    end
-    def connection_mode_dblib? ; self.class.connection_mode_dblib? ; end
-    def connection_mode_odbc? ; self.class.connection_mode_odbc? ; end
-    def connection_mode_adonet? ; self.class.connection_mode_adonet? ; end
-    def sqlserver_2000? ; self.class.sqlserver_2000? ; end
-    def sqlserver_2005? ; self.class.sqlserver_2005? ; end
-    def sqlserver_2008? ; self.class.sqlserver_2008? ; end
-    def ruby_19? ; self.class.ruby_19? ; end
-  end
-end
-
-