activerecord-sqlserver-adapter 2.3.7 → 3.2.18

data/README.rdoc

@@ -1,190 +0,0 @@
-
-== Rails SQL Server 2000, 2005 and 2008 Adapter
-
-The SQL Server adapter for rails is back for ActiveRecord 2.2 and up! We are currently passing all tests and hope to continue to do so moving forward. 
-
-
-== What's New
-
-* Integration with rails :db namespaced rake tasks.
-* IronRuby support using ADONET connection mode.
-* Direct ODBC mode. No DBI anymore, means around 20% faster!
-* Now supports SQL Server 2008 too!
-* Fully tested under 1.9!!! Correctly encodes/decodes UTF-8 types in ruby 1.9 too.
-* Now supports both rails 2.2 & 2.3!!!
-* An ActiveRecord::Base.execute_procedure method that can be used by classes.
-* Enabled support for DDL transactions.
-* Micro second support. Time#usec is automatically converted to SQL Server's 3.33 millisecond limitation.
-* Datetime data types before type casting are represented correctly. For example: 1998-01-01 23:59:59.997
-* Implementation for #disable_referential_integrity used by ActiveRecord's Fixtures class.
-* Pessimistic locking suppot. See the #add_lock! method for details.
-* Enabled #case_sensitive_equality_operator used by unique validations.
-* Unicode character support for nchar, nvarchar and ntext data types. Configuration option for defaulting all string data types to the unicode safe types.
-* View support for table names, identity inserts, and column defaults.
-* A block method to run queries within a specific isolation level.
-* Automatically reconnects to lost database connections.
-
-
-==== Testing Rake Tasks Support
-
-This is a long story, but if you are not working with a legacy database and you can trust your schema.rb to setup you local development or test database, then we have adapter level support for rails :db rake tasks. Please read this wiki page for full details.
-
-http://wiki.github.com/rails-sqlserver/2000-2005-adapter/rails-db-rake-tasks
-
-
-==== SQL Server 2008 Support
-
-Because this adapter is primarily coded to SQL Server 2000/2005, it does not take advantage of many of the things in 2008 that would speed up the code. At some point in the future there will be a branch of this code that is specifically targeted for 2008. That adapter version will remove much of the dirty innards of this version that are meant to code around many previous SQL Server 2000/2005 short comings, the biggest being no limit/offset.
-
-
-
-==== Date/Time Data Type Hinting
-
-Both SQL Server 2000 and 2005 do not include native data types for just 'date' or 'time', it only has 'datetime'. To pass the ActiveRecord tests we implemented two simple class methods that can teach your models to coerce column information to be cast correctly. Simply past a list of symbols to either the <tt>coerce_sqlserver_date</tt> or <tt>coerce_sqlserver_time</tt> methods that correspond to 'datetime' columns that need to be cast correctly.
-
-  class Topic < ActiveRecord::Base
-    coerce_sqlserver_date :last_read
-    coerce_sqlserver_time :bonus_time
-  end
-
-This implementation has some limitations. To date we can only coerce date/time types for models that conform to the expected ActiveRecord class to table naming convention. So a table of 'foo_bar_widgets' will look for coerced types in the FooBarWidget class if it exists.
-
-==== Executing Stored Procedures
-
-Every class that sub classes ActiveRecord::Base will now have an execute_procedure class method to use. This method takes the name of the stored procedure which can be a string or symbol and any number of variables to pass to the procedure. Arguments will automatically be quoted per the connection's standards as normal. For example.
-
-  Account.execute_procedure :update_totals, 'admin', nil, true
-
-==== Native Data Type Support
-
-Currently the following custom data types have been tested for schema definitions.
-
-* char
-* nchar
-* nvarchar
-* ntext
-* varchar(max) for SQL Server 2005 only.
-* nvarchar(max) for SQL Server 2005 only.
-
-For example:
-
-  create_table :sql_server_custom_types, :force => true do |t|
-    t.column :ten_code,       :char,      :limit => 10
-    t.column :ten_code_utf8,  :nchar,     :limit => 10
-    t.column :title_utf8,     :nvarchar
-    t.column :body,           :varchar_max    # Creates varchar(max)
-    t.column :body_utf8,      :ntext
-    t.column :body2_utf8,     :nvarchar_max   # Creates nvarchar(max)
-  end
-
-Manually creating a varchar(max) on SQL Server 2005 is not necessary since this is the default type created when specifying a :text field. As time goes on we will be testing other SQL Server specific data types are handled correctly when created in a migration.
-
-
-==== Native Text/String/Binary Data Type Accessor
-
-To pass the ActiveRecord tests we had to implement an class accessor for the native type created for :text columns. By default any :text column created by migrations will create these native types.
-
-* SQL Server 2000 is 'text'
-* SQL Server 2005 is 'varchar(max)'
-
-During testing this type is set to 'varchar(8000)' for SQL Server 2000. The reason is that rails expects to be able to use SQL = operators on text data types and this is not possible with a native 'text' data type in SQL Server. The default 'varchar(max)' for SQL Server 2005 can be queried using the SQL = operator and has plenty of storage space which is why we made it the default for 2005. If for some reason you want to change the data type created during migrations for any SQL Server version, you can configure this line to your liking in a config/initializers file.
-
-  ActiveRecord::ConnectionAdapters::SQLServerAdapter.native_text_database_type = 'varchar(8000)'
-  
-Also, there is a class attribute setter for the native string database type. This is the same for both SQL Server 2000 and 2005, 'varchar'. However in can be used instead of the #enable_default_unicode_types below for finer grain control over which types you want unicode safe when adding or changing the schema.
-
-  ActiveRecord::ConnectionAdapters::SQLServerAdapter.native_string_database_type = 'nvarchar'
-
-By default any :binary column created by migrations will create these native types
-
-* SQL Server 2000 is 'image'
-* SQL Server 2005 is 'varbinary(max)'
-
-
-====  Setting Unicode Types As Default
-
-By default the adapter will use non-unicode safe data types for :string and :text types when DEFINING or CHANGING the schema. If you choose, you can set the following class attribute in a config/initializers file that will change this behavior. When set to true it has the equivalent meaning as the two lower items. These examples show detail level alternatives to achieve similar effects.
-  
-  ActiveRecord::ConnectionAdapters::SQLServerAdapter.enable_default_unicode_types = true
-  
-  # SQL Server 2000
-  ActiveRecord::ConnectionAdapters::SQLServerAdapter.native_text_database_type = 'ntext'
-  ActiveRecord::ConnectionAdapters::SQLServerAdapter.native_string_database_type = 'nvarchar'
-  
-  # SQL Server 2005
-  ActiveRecord::ConnectionAdapters::SQLServerAdapter.native_text_database_type = 'nvarchar(max)'
-  ActiveRecord::ConnectionAdapters::SQLServerAdapter.native_string_database_type = 'nvarchar'
-
-It is important to remember that unicode types in SQL Server have approximately half the storage capacity as their counter parts. So where a normal string would max out at (8000) a unicode string will top off at (4000).
-
-
-====  Schema Information Logging
-
-By default all queries to the INFORMATION_SCHEMA table is silenced. If you think logging these queries are useful, you can enable it by adding this like to a config/initializers file.
-
-  ActiveRecord::ConnectionAdapters::SQLServerAdapter.log_info_schema_queries = true
-
-==== Auto Connecting
-
-By default the adapter will auto connect to lost DB connections. For every query it will retry at intervals of 2, 4, 8, 16 and 32 seconds. During each retry it will callback out to ActiveRecord::Base.did_retry_sqlserver_connection(connection,count). When all retries fail, it will callback to ActiveRecord::Base.did_lose_sqlserver_connection(connection). Both implementations of these methods are to write to the rails logger, however, they make great override points for notifications like Hoptoad. If you want to disable automatic reconnections use the following in an initializer.
-
-  ActiveRecord::ConnectionAdapters::SQLServerAdapter.auto_connect = false
-
-
-== Versions
-
-It is our goal to match the adapter version with each version of rails. However we will track our own tiny version independent of ActiveRecord. For example, an adapter version of 2.2.x will work on any 2.2.x version of ActiveRecord. This convention will be used in both the Git tags as well as the Rubygems versioning.
-
-
-== Installation
-
-You will need Ruby ODBC. If you are using the adapter under 1.9, then you need at least ruby-odbc version 0.9996. ODBC is the preferred mode, however if you are using IronRuby you can use the ADONET connection mode which uses native System.Data connection. Other connection modes may be supported, possibly a straight FreeTDS layer. The sky is the limit now and we have a code that can be accept these optional transports. If you are interested in helping, open a ticket and submit a patch. Or start a conversation on the Google Group.
-
-  $ gem install activerecord-sqlserver-adapter
-
-Optionally configure your gem dependencies in your rails environment.rb file.
-
-  config.gem 'activerecord-sqlserver-adapter', :version => 'x.x.xx'
-
-Here are some external links for libraries and/or tutorials on how to install any other additional components to use this adapter. If you know of a good one that we can include here, just let us know.
-
-* http://www.ch-werner.de/rubyodbc/
-
-
-== IronRuby ADONET Mode
-
-A few details on this implementation. All that is needed in your database.yml configuration file is "mode: adonet" vs "odbc" and if you are running IronRuby, the connection will be native. You can also specify an "integrated_security: true" option in your configuration, remember to remove the username/password options too. To use this adapter, you will not need need ANY DBI middle layer or special extension gems to the adapter. 
-
-This adapter is opinionated in regards to IronRuby on types going in and out of the DB. For example strings will be String, not System::String and DateTime vs System::Datetime. There are many more examples but the rule of thumb is that the types will be simple types that correlate to a standard Ruby implementation. We enforce this basic rule because it is necessary to pass the tests and let the framework do its job. We recommend sticking to native Ruby types in your application code too.
-
-The adapter establishes a System::Data::SqlClient connection that has both MultipleActiveResultSets (MARS) and Pooling turned off. There are good reasons for this one because the connection would not work otherwise for all the code issued by ActiveRecord. Remember too that ActiveRecord has it's own connection pooling and these underlying features like MARS/Pooling work against the adapter code.
-
-Currently IronRuby is passing most of the ActiveRecord and Adapter tests. Here is a list of the ones remaining. Some are in the adapter's realm and some are in Marshaling area of IronRuby's core to fix. Feel like helping knock these out? Submit a patch to github issues.
-
-http://gist.github.com/381101
-
-
-== Contributing
-
-If you’d like to contribute a feature or bugfix, thanks! To make sure your fix/feature has a high chance of being added, please read the following guidelines. First, ask on the Google list, IRC, or post a ticket on github issues. Second, make sure there are tests! We will not accept any patch that is not tested. Please read the RUNNING_UNIT_TESTS file for the details of how to run the unit tests.
-
-* Github: http://github.com/rails-sqlserver
-* Google Group: http://groups.google.com/group/rails-sqlserver-adapter
-* IRC Room: #rails-sqlserver on irc.freenode.net
-
-
-== Credits
-
-Many many people have contributed. If you do not see your name here and it should be let us know.
-
-* Ken Collins
-* Murray Steele
-* Shawn Balestracci
-* Joe Rafaniello
-* Tom Ward
-
-
-== License
-
-Copyright © 2008. It is free software, and may be redistributed under the terms specified in the MIT-LICENSE file.
-

data/RUNNING_UNIT_TESTS

@@ -1,65 +0,0 @@
-== Creating the test database
-
-The default names for the test databases are "activerecord_unittest" and 
-"activerecord_unittest2". If you want to use another database name then be sure 
-to update the connection adapter setups you want to test with in 
-test/connections/<your database>/connection.rb. 
-
-The connection files make certain assumptions. For instance, the ODBC connection 
-assumes you have a DSN setup that matches the name of the default database names.
-
-
-== Requirements
-
-The following gems need to be installed. Make sure you have gems.github.com as a
-source. Info here. http://gems.github.com/
-
-We use echoe for packagemanagement to rubyforge. Not needed really for the tests 
-but since we need it... you need to install it.
-
-  * gem install echoe
-  * gem install thoughtbot-shoulda -s http://gems.github.com
-  * gem install mocha
-
-The tests of this adapter depend on the existence of rails checkout. All the tests
-defined by rails are re-used. For this to work the following directory structure 
-is assumed to exist:
-
-#{RAILS_ROOT}/vendor/plugins/adapters/sqlserver
-#{RAILS_ROOT}/vendor/rails/activerecord/test
-
-Define a user named 'rails' in SQL Server with all privileges granted for the 
-test databases. Use an empty password for said user.
-
-
-== Running with Rake
-
-The easiest way to run the unit tests is through Rake. Either run "rake test" which 
-defaults to ODBC mode or being mode specific using either "rake sqlserver:test:adonet" 
-or "rake sqlserver:test:odbc". For more information, checkout the full array of rake tasks 
-with "rake -T"
-
-Rake can be found at http://rake.rubyforge.org
-
-
-== Running with Autotest
-
-Using autotest is easy, just run "autotest" and the tests will run continually in the 
-same order as the rake test command. By default autotest will use ODBC connection. If 
-you want to change this you can edit the autotest/sqlserver.rb file and set odbc_mode 
-to false.
-
-Lastly, you can run autotest on just the adapter specific tests with "autotest sqlserver". 
-This will continuously run ONLY the SQL Sever specific behavior tests which are much 
-quicker to run than the entire active record test suite.
-
-
-== Running by hand
-
-Unit tests are located in test directory. If you only want to run a single test suite, 
-you can do so with:
-
-   rake test_sqlserver TEST=base_test.rb
-   
-That'll run the base suite using the SQLServer-Ruby adapter.
-

data/Rakefile

@@ -1,41 +0,0 @@
-require 'rake'
-require 'rake/testtask'
-require 'rake/rdoctask'
-
-
-namespace :sqlserver do
-  
-  namespace :test do
-    
-    ['odbc','adonet'].each do |mode|
-
-      Rake::TestTask.new(mode) do |t|
-        t.libs << "test"
-        t.libs << "test/connections/native_sqlserver#{mode == 'adonet' ? '' : "_#{mode}"}"
-        t.libs << "../../../rails/activerecord/test/"
-        t.test_files = (
-          Dir.glob("test/cases/**/*_test_sqlserver.rb").sort + 
-          Dir.glob("../../../rails/activerecord/test/**/*_test.rb").sort )
-        t.verbose = true
-      end
-      
-    end
-
-    desc 'Test with unicode types enabled, uses ODBC mode.'
-    task :unicode_types do
-      ENV['ENABLE_DEFAULT_UNICODE_TYPES'] = 'true'
-      test = Rake::Task['sqlserver:test:odbc']
-      test.invoke
-    end
-    
-  end
-  
-end
-
-
-desc 'Default runs tests for the adapters ODBC mode.'
-task :test do
-  test = Rake::Task['sqlserver:test:odbc']
-  test.invoke
-end
-

data/autotest/discover.rb

@@ -1,4 +0,0 @@
-
-Autotest.add_discovery do
-  ARGV.first || 'railssqlserver'
-end

data/autotest/railssqlserver.rb

@@ -1,16 +0,0 @@
-require 'autotest/sqlserver'
-
-class Autotest::Railssqlserver < Autotest::Sqlserver
-
-  def initialize
-    super
-    self.libs << "#{File::PATH_SEPARATOR}../../../rails/activerecord/test/"
-    self.extra_files = ['../../../rails/activerecord/test/']
-    self.add_mapping %r%../../../rails/activerecord/test/.*/.*_test.rb$% do |filename, _|
-      filename
-    end
-  end
-  
-
-end
-

data/autotest/sqlserver.rb

@@ -1,54 +0,0 @@
-require 'autotest'
-require 'active_support'
-
-class Autotest::Sqlserver < Autotest
-
-  def initialize
-    super
-    
-    odbc_mode = true
-    
-    clear_mappings
-    
-    self.libs = [
-      "lib",
-      "test",
-      "test/connections/native_sqlserver#{odbc_mode ? '_odbc' : ''}",
-      "../../../rails/activerecord/test/"
-    ].join(File::PATH_SEPARATOR)
-    
-    @test_sqlserver_file_match = %r%^test/cases/.*_test_sqlserver\.rb$%
-    
-    add_exception %r%^\./(?:autotest)%
-    add_exception %r%^\./(.*LICENSE|debug.log|README.*|CHANGELOG.*)$%i
-    
-    # Any *_test_sqlserver file saved runs that file
-    self.add_mapping @test_sqlserver_file_match do |filename, matchs|
-      filename
-    end
-    
-    # If any the adapter changes
-    # the test directory, ofcourse having _test.rb at the end, will run that test. 
-    self.add_mapping(%r%^lib/(.*)\.rb$%) do |filename, matchs|
-      files_matching @test_sqlserver_file_match
-    end
-    
-    # If any core file like the test helper, connections, fixtures, migratinos,
-    # and other support files, then run all matching *_test_sqlserver files.
-    add_mapping %r%^test/(cases/(sqlserver_helper)\.rb|connections|fixtures|migrations|schema/.*)% do
-      files_matching @test_sqlserver_file_match
-    end
-    
-  end
-  
-  # Have to use a custom reorder method since the normal :alpha for Autotest would put the 
-  # files with ../ in the path before others.
-  def reorder(files_to_test)
-    ar_tests, sqlsvr_tests = files_to_test.partition { |k,v| k.starts_with?('../../../') }
-    ar_tests.sort! { |a,b| a[0] <=> b[0] }
-    sqlsvr_tests.sort! { |a,b| a[0] <=> b[0] }
-    sqlsvr_tests + ar_tests
-  end
-  
-end
-

data/lib/active_record/connection_adapters/sqlserver_adapter/core_ext/active_record.rb

@@ -1,151 +0,0 @@
-require 'active_record/version'
-
-module ActiveRecord
-  module ConnectionAdapters
-    module SQLServerCoreExtensions
-      
-      
-      module ActiveRecord
-
-        def self.included(klass)
-          klass.extend ClassMethods
-          class << klass
-            alias_method_chain :reset_column_information, :sqlserver_cache_support
-            alias_method_chain :add_order!, :sqlserver_unique_checking
-            alias_method_chain :add_limit!, :sqlserver_order_checking
-          end
-        end
-
-        module ClassMethods
-
-          def execute_procedure(proc_name, *variables)
-            if connection.respond_to?(:execute_procedure)
-              connection.execute_procedure(proc_name,*variables)
-            else
-              []
-            end
-          end
-
-          def coerce_sqlserver_date(*attributes)
-            write_inheritable_attribute :coerced_sqlserver_date_columns, Set.new(attributes.map(&:to_s))
-          end
-
-          def coerce_sqlserver_time(*attributes)
-            write_inheritable_attribute :coerced_sqlserver_time_columns, Set.new(attributes.map(&:to_s))
-          end
-
-          def coerced_sqlserver_date_columns
-            read_inheritable_attribute(:coerced_sqlserver_date_columns) || []
-          end
-
-          def coerced_sqlserver_time_columns
-            read_inheritable_attribute(:coerced_sqlserver_time_columns) || []
-          end
-
-          def reset_column_information_with_sqlserver_cache_support
-            connection.send(:initialize_sqlserver_caches) if connection.respond_to?(:sqlserver?)
-            reset_column_information_without_sqlserver_cache_support
-          end
-
-          private
-
-          def add_limit_with_sqlserver_order_checking!(sql, options, scope = :auto)
-            if connection.respond_to?(:sqlserver?)
-              scope = scope(:find) if :auto == scope
-              if scope
-                options = options.dup
-                scoped_order = scope[:order]
-                order = options[:order]
-                if order && scoped_order
-                  options[:order] = add_order_with_sqlserver_unique_checking!('', order, scope).gsub(/^ ORDER BY /,'')
-                elsif scoped_order
-                  options[:order] = scoped_order
-                end
-              end
-            end
-            add_limit_without_sqlserver_order_checking!(sql, options, scope)
-          end
-
-          def add_order_with_sqlserver_unique_checking!(sql, order, scope = :auto)
-            if connection.respond_to?(:sqlserver?)
-              order_sql = ''
-              add_order_without_sqlserver_unique_checking!(order_sql, order, scope)
-              unless order_sql.blank?
-                unique_order_hash = {}
-                select_table_name = connection.send(:get_table_name,sql)
-                select_table_name.tr!('[]','') if select_table_name
-                orders_and_dirs_set = connection.send(:orders_and_dirs_set,order_sql)
-                unique_order_sql = orders_and_dirs_set.inject([]) do |array,order_dir|
-                  ord, dir = order_dir
-                  ord_tn_and_cn = ord.to_s.split('.').map{|o|o.tr('[]','')}
-                  ord_table_name, ord_column_name = if ord_tn_and_cn.size > 1
-                                                      ord_tn_and_cn
-                                                    else
-                                                      [nil, ord_tn_and_cn.first]
-                                                    end
-                  unique_key = [(ord_table_name || select_table_name), ord_column_name]
-                  if unique_order_hash[unique_key]
-                    array
-                  else
-                    unique_order_hash[unique_key] = true
-                    array << "#{ord} #{dir}".strip
-                  end
-                end.join(', ')
-                sql << " ORDER BY #{unique_order_sql}"
-              end
-            else
-              add_order_without_sqlserver_unique_checking!(sql, order, scope)
-            end
-          end
-
-        end
-        
-        module JoinAssociationChanges
-          
-          def self.included(klass)
-            klass.class_eval do
-              include InstanceMethods
-              alias_method_chain :aliased_table_name_for, :sqlserver_support
-            end
-          end
-
-          module InstanceMethods
-
-            protected
-
-            # An exact copy, except this method has a Regexp escape on the quoted table name.
-            def aliased_table_name_for_with_sqlserver_support(name,suffix=nil)
-              if !parent.table_joins.blank? && parent.table_joins.to_s.downcase =~ %r{join(\s+\w+)?\s+#{Regexp.escape(active_record.connection.quote_table_name(name.downcase))}\son}i
-                @join_dependency.table_aliases[name] += 1
-              end
-              unless @join_dependency.table_aliases[name].zero?
-                # if the table name has been used, then use an alias
-                name = active_record.connection.table_alias_for "#{pluralize(reflection.name)}_#{parent_table_name}#{suffix}"
-                table_index = @join_dependency.table_aliases[name]
-                @join_dependency.table_aliases[name] += 1
-                name = name[0..active_record.connection.table_alias_length-3] + "_#{table_index+1}" if table_index > 0
-              else
-                @join_dependency.table_aliases[name] += 1
-              end
-              name
-            end
-
-          end
-          
-        end
-        
-      end
-      
-      
-    end
-  end
-end
-
-
-ActiveRecord::Base.send :include, ActiveRecord::ConnectionAdapters::SQLServerCoreExtensions::ActiveRecord
-
-if ActiveRecord::VERSION::MAJOR == 2 && ActiveRecord::VERSION::MINOR >= 3
-  require 'active_record/associations'
-  ActiveRecord::Associations::ClassMethods::JoinDependency::JoinAssociation.send :include, ActiveRecord::ConnectionAdapters::SQLServerCoreExtensions::ActiveRecord::JoinAssociationChanges
-end
-

data/lib/active_record/connection_adapters/sqlserver_adapter/core_ext/odbc.rb

@@ -1,40 +0,0 @@
-
-module ActiveRecord
-  module ConnectionAdapters
-    module SQLServerCoreExtensions
-      module ODBC
-        
-        module TimeStamp
-          def to_sqlserver_string
-            date, time, nanoseconds = to_s.split(' ')
-            "#{date} #{time}.#{sprintf("%03d",nanoseconds.to_i/1000000)}"
-          end
-        end
-        
-        module Statement
-          def finished?
-            begin
-              connected?
-              false
-            rescue ::ODBC::Error => e
-              true
-            end
-          end
-        end
-
-        module Database
-          def run_block(*args)
-            yield sth = run(*args)
-            sth.drop
-          end
-        end
-        
-      end
-    end
-  end
-end
-
-ODBC::TimeStamp.send :include, ActiveRecord::ConnectionAdapters::SQLServerCoreExtensions::ODBC::TimeStamp if defined?(ODBC::TimeStamp)
-ODBC::Statement.send :include, ActiveRecord::ConnectionAdapters::SQLServerCoreExtensions::ODBC::Statement if defined?(ODBC::Statement)
-ODBC::Database.send :include, ActiveRecord::ConnectionAdapters::SQLServerCoreExtensions::ODBC::Database if defined?(ODBC::Database)
-

data/test/cases/aaaa_create_tables_test_sqlserver.rb

@@ -1,19 +0,0 @@
-# The filename begins with "aaaa" to ensure this is the first test.
-require 'cases/sqlserver_helper'
-
-class AAAACreateTablesTestSqlserver < ActiveRecord::TestCase
-  self.use_transactional_fixtures = false
-  
-  should 'load activerecord schema' do
-    schema_file = "#{ACTIVERECORD_TEST_ROOT}/schema/schema.rb"
-    eval(File.read(schema_file))
-    assert true
-  end
-  
-  should 'load sqlserver specific schema' do
-    sqlserver_specific_schema_file = "#{SQLSERVER_SCHEMA_ROOT}/sqlserver_specific_schema.rb"
-    eval(File.read(sqlserver_specific_schema_file))
-    assert true
-  end
-  
-end