activerecord-sqlserver-adapter_new 4.2.15

data/test/cases/pessimistic_locking_test_sqlserver.rb

@@ -0,0 +1,90 @@
+require 'cases/helper_sqlserver'
+require 'models/person'
+require 'models/reader'
+
+class PessimisticLockingTestSQLServer < ActiveRecord::TestCase
+
+  fixtures :people, :readers
+
+  before do
+    Person.columns
+    Reader.columns
+  end
+
+  it 'uses with updlock by default' do
+    assert_sql %r|SELECT \[people\]\.\* FROM \[people\] WITH\(UPDLOCK\)| do
+      Person.lock(true).to_a.must_equal Person.all.to_a
+    end
+  end
+
+  describe 'For simple finds with default lock option' do
+
+    it 'lock with simple find' do
+      assert_nothing_raised do
+        Person.transaction do
+          Person.lock(true).find(1).must_equal Person.find(1)
+        end
+      end
+    end
+
+    it 'lock with scoped find' do
+      assert_nothing_raised do
+        Person.transaction do
+          Person.lock(true).scoping do
+            Person.find(1).must_equal Person.find(1)
+          end
+        end
+      end
+    end
+
+    it 'lock with eager find' do
+       assert_nothing_raised do
+        Person.transaction do
+          person = Person.lock(true).includes(:readers).find(1)
+          person.must_equal Person.find(1)
+        end
+      end
+    end
+
+    it '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
+
+    it 'can add a custom lock directive' do
+      assert_sql %r|SELECT \[people\]\.\* FROM \[people\] WITH\(HOLDLOCK, ROWLOCK\)| do
+        Person.lock('WITH(HOLDLOCK, ROWLOCK)').load
+      end
+    end
+
+  end
+
+  describe 'For paginated finds' do
+
+    before do
+      Person.delete_all
+      20.times { |n| Person.create!(first_name: "Thing_#{n}") }
+    end
+
+    it 'copes with eager loading un-locked paginated' do
+      eager_ids_sql = /SELECT\s+DISTINCT \[people\].\[id\] FROM \[people\] WITH\(UPDLOCK\) LEFT OUTER JOIN \[readers\] WITH\(UPDLOCK\)\s+ON \[readers\].\[person_id\] = \[people\].\[id\]\s+ORDER BY \[people\].\[id\] ASC OFFSET 10 ROWS FETCH NEXT 5 ROWS ONLY/
+      loader_sql = /SELECT.*FROM \[people\] WITH\(UPDLOCK\).*WHERE \[people\]\.\[id\] IN/
+      assert_sql(eager_ids_sql, loader_sql) do
+        people = Person.lock(true).limit(5).offset(10).includes(:readers).references(:readers).to_a
+        people[0].first_name.must_equal 'Thing_10'
+        people[1].first_name.must_equal 'Thing_11'
+        people[2].first_name.must_equal 'Thing_12'
+        people[3].first_name.must_equal 'Thing_13'
+        people[4].first_name.must_equal 'Thing_14'
+      end
+    end
+
+  end
+
+end

data/test/cases/rake_test_sqlserver.rb

@@ -0,0 +1,163 @@
+require 'cases/helper_sqlserver'
+
+class SQLServerRakeTest < ActiveRecord::TestCase
+
+  self.use_transactional_fixtures = false
+
+  cattr_accessor :azure_skip
+  self.azure_skip = connection_sqlserver_azure?
+
+  let(:db_tasks)              { ActiveRecord::Tasks::DatabaseTasks }
+  let(:new_database)          { 'activerecord_unittest_tasks' }
+  let(:default_configuration) { ARTest.connection_config['arunit'] }
+  let(:configuration)         { default_configuration.merge('database' => new_database) }
+
+  before { skip 'on azure' if azure_skip }
+  before { disconnect! unless azure_skip }
+  after  { reconnect unless azure_skip }
+
+  private
+
+  def disconnect!
+    connection.disconnect!
+  end
+
+  def reconnect
+    config = default_configuration
+    if connection_sqlserver_azure?
+      ActiveRecord::Base.establish_connection(config.merge('database' => 'master'))
+      connection.drop_database(new_database) rescue nil
+      disconnect!
+      ActiveRecord::Base.establish_connection(config)
+    else
+      ActiveRecord::Base.establish_connection(config)
+      connection.drop_database(new_database) rescue nil
+    end
+  end
+
+end
+
+class SQLServerRakeCreateTest < SQLServerRakeTest
+
+  self.azure_skip = false
+
+  it 'establishes connection to database after create ' do
+    db_tasks.create configuration
+    connection.current_database.must_equal(new_database)
+  end
+
+  it 'creates database with default collation' do
+    db_tasks.create configuration
+    connection.collation.must_equal 'SQL_Latin1_General_CP1_CI_AS'
+  end
+
+  it 'creates database with given collation' do
+    db_tasks.create configuration.merge('collation' => 'Latin1_General_CI_AS')
+    connection.collation.must_equal 'Latin1_General_CI_AS'
+  end
+
+  it 'prints error message when database exists' do
+    db_tasks.create configuration
+    message = capture(:stderr) { db_tasks.create configuration }
+    message.must_match %r{activerecord_unittest_tasks already exists}
+  end
+
+end
+
+class SQLServerRakeDropTest < SQLServerRakeTest
+
+  self.azure_skip = false
+
+  it 'drops database and uses master' do
+    db_tasks.create configuration
+    db_tasks.drop configuration
+    connection.current_database.must_equal 'master'
+  end
+
+  it 'prints error message when database does not exist' do
+    message = capture(:stderr) { db_tasks.drop configuration.merge('database' => 'doesnotexist') }
+    message.must_match %r{'doesnotexist' does not exist}
+  end
+
+end
+
+class SQLServerRakePurgeTest < SQLServerRakeTest
+
+  before do
+    db_tasks.create(configuration)
+    connection.create_table :users, force: true do |t|
+      t.string :name, :email
+      t.timestamps null: false
+    end
+  end
+
+  it 'clears active connections, drops database, and recreates with established connection' do
+    connection.current_database.must_equal(new_database)
+    connection.tables.must_include 'users'
+    db_tasks.purge(configuration)
+    connection.current_database.must_equal(new_database)
+    connection.tables.wont_include 'users'
+  end
+
+end
+
+class SQLServerRakeCharsetTest < SQLServerRakeTest
+
+  before { db_tasks.create(configuration) }
+
+  it 'retrieves charset' do
+    db_tasks.charset(configuration).must_equal 'iso_1'
+  end
+
+end
+
+class SQLServerRakeCollationTest < SQLServerRakeTest
+
+  before { db_tasks.create(configuration) }
+
+  it 'retrieves collation' do
+    db_tasks.collation(configuration).must_equal 'SQL_Latin1_General_CP1_CI_AS'
+  end
+
+end
+
+class SQLServerRakeStructureDumpLoadTest < SQLServerRakeTest
+
+  let(:filename) { File.join ARTest::SQLServer.migrations_root, 'structure.sql' }
+  let(:filedata) { File.read(filename) }
+
+  before do
+    db_tasks.create(configuration)
+    connection.create_table :users, force: true do |t|
+      t.string :name, :email
+      t.text :background1
+      t.text_basic :background2
+      t.timestamps null: false
+    end
+  end
+
+  after do
+    FileUtils.rm_rf(filename)
+  end
+
+  it 'dumps structure and accounts for defncopy oddities' do
+    skip 'debug defncopy on windows later' if host_windows?
+    quietly { db_tasks.structure_dump configuration, filename }
+    filedata.wont_match %r{\AUSE.*\z}
+    filedata.wont_match %r{\AGO.*\z}
+    filedata.must_match %r{email\s+nvarchar\(4000\)}
+    filedata.must_match %r{background1\s+nvarchar\(max\)}
+    filedata.must_match %r{background2\s+text\s+}
+  end
+
+  it 'can load dumped structure' do
+    skip 'debug defncopy on windows later' if host_windows?
+    quietly { db_tasks.structure_dump configuration, filename }
+    filedata.must_match %r{CREATE TABLE dbo\.users}
+    db_tasks.purge(configuration)
+    connection.tables.wont_include 'users'
+    db_tasks.load_schema_for configuration, :sql, filename
+    connection.tables.must_include 'users'
+  end
+
+end

data/test/cases/schema_dumper_test_sqlserver.rb

@@ -0,0 +1,198 @@
+require 'cases/helper_sqlserver'
+
+class SchemaDumperTestSQLServer < ActiveRecord::TestCase
+
+  before { all_tables }
+
+  let(:all_tables)   { ActiveRecord::Base.connection.tables }
+  let(:schema)       { @generated_schema }
+
+  it 'sst_datatypes' do
+    generate_schema_for_table 'sst_datatypes'
+    # Exact Numerics
+    assert_line :bigint,            type: 'bigint',       limit: '8',           precision: nil,   scale: nil,  default: '42'
+    assert_line :int,               type: 'integer',      limit: '4',           precision: nil,   scale: nil,  default: '42'
+    assert_line :smallint,          type: 'integer',      limit: '2',           precision: nil,   scale: nil,  default: '42'
+    assert_line :tinyint,           type: 'integer',      limit: '1',           precision: nil,   scale: nil,  default: '42'
+    assert_line :bit,               type: 'boolean',      limit: nil,           precision: nil,   scale: nil,  default: 'true'
+    assert_line :decimal_9_2,       type: 'decimal',      limit: nil,           precision: '9',   scale: '2',  default: '12345.01'
+    assert_line :numeric_18_0,      type: 'decimal',      limit: nil,           precision: '18',  scale: '0',  default: '191.0'
+    assert_line :numeric_36_2,      type: 'decimal',      limit: nil,           precision: '36',  scale: '2',  default: '12345678901234567890.01'
+    assert_line :money,             type: 'money',        limit: nil,           precision: '19',  scale: '4',  default: '4.2'
+    assert_line :smallmoney,        type: 'smallmoney',   limit: nil,           precision: '10',  scale: '4',  default: '4.2'
+    # Approximate Numerics
+    assert_line :float,             type: 'float',        limit: nil,          precision: nil,   scale: nil,  default: '123.00000001'
+    assert_line :real,              type: 'real',         limit: nil,          precision: nil,   scale: nil,  default: %r{123.4[45]}
+    # Date and Time
+    assert_line :date,              type: 'date',         limit: nil,           precision: nil,   scale: nil,  default: "\"01-01-0001\""
+    assert_line :datetime,          type: 'datetime',     limit: nil,           precision: nil,   scale: nil,  default: "\"01-01-1753 00:00:00.123\""
+    if connection_dblib_73?
+    assert_line :datetime2_7,       type: 'datetime2',    limit: nil,           precision: '7',   scale: nil,  default: "\"12-31-9999 23:59:59.9999999\""
+    assert_line :datetime2_3,       type: 'datetime2',    limit: nil,           precision: '3',   scale: nil,  default: nil
+    assert_line :datetime2_1,       type: 'datetime2',    limit: nil,           precision: '1',   scale: nil,  default: nil
+    end
+    assert_line :smalldatetime,     type: 'smalldatetime',limit: nil,           precision: nil,   scale: nil,  default: "\"01-01-1901 15:45:00\""
+    if connection_dblib_73?
+    assert_line :time_7,            type: 'time',         limit: nil,           precision: '7',   scale: nil,  default: "\"04:20:00.2883215\""
+    assert_line :time_2,            type: 'time',         limit: nil,           precision: '2',   scale: nil,  default: nil
+    end
+    # Character Strings
+    assert_line :char_10,           type: 'char',         limit: '10',          precision: nil,   scale: nil,  default: "\"1234567890\""
+    assert_line :varchar_50,        type: 'varchar',      limit: '50',          precision: nil,   scale: nil,  default: "\"test varchar_50\""
+    assert_line :varchar_max,       type: 'varchar_max',  limit: '2147483647',  precision: nil,   scale: nil,  default: "\"test varchar_max\""
+    assert_line :text,              type: 'text_basic',   limit: '2147483647',  precision: nil,   scale: nil,  default: "\"test text\""
+    # Unicode Character Strings
+    assert_line :nchar_10,          type: 'nchar',        limit: '10',          precision: nil,   scale: nil,  default: "\"12345678åå\""
+    assert_line :nvarchar_50,       type: 'string',       limit: '50',          precision: nil,   scale: nil,  default: "\"test nvarchar_50 åå\""
+    assert_line :nvarchar_max,      type: 'text',         limit: '2147483647',  precision: nil,   scale: nil,  default: "\"test nvarchar_max åå\""
+    assert_line :ntext,             type: 'ntext',        limit: '2147483647',  precision: nil,   scale: nil,  default: "\"test ntext åå\""
+    # Binary Strings
+    assert_line :binary_49,         type: 'binary_basic', limit: '49',          precision: nil,   scale: nil,  default: nil
+    assert_line :varbinary_49,      type: 'varbinary',    limit: '49',          precision: nil,   scale: nil,  default: nil
+    assert_line :varbinary_max,     type: 'binary',       limit: '2147483647',  precision: nil,   scale: nil,  default: nil
+    # Other Data Types
+    assert_line :uniqueidentifier,  type: 'uuid',         limit: nil,           precision: nil,   scale: nil,  default: nil
+    assert_line :timestamp,         type: 'ss_timestamp', limit: nil,           precision: nil,   scale: nil,  default: nil
+  end
+
+  it 'sst_datatypes_migration' do
+    columns = SSTestDatatypeMigration.columns_hash
+    generate_schema_for_table 'sst_datatypes_migration'
+    # Simple Rails conventions
+    columns['integer_col'].sql_type.must_equal      'int(4)'
+    columns['bigint_col'].sql_type.must_equal       'bigint(8)'
+    columns['boolean_col'].sql_type.must_equal      'bit'
+    columns['decimal_col'].sql_type.must_equal      'decimal(18,0)'
+    columns['float_col'].sql_type.must_equal        'float'
+    columns['string_col'].sql_type.must_equal       'nvarchar(4000)'
+    columns['text_col'].sql_type.must_equal         'nvarchar(max)'
+    columns['datetime_col'].sql_type.must_equal     'datetime'
+    columns['timestamp_col'].sql_type.must_equal    'datetime'
+    columns['time_col'].sql_type.must_equal         'time(7)'
+    columns['date_col'].sql_type.must_equal         'date'
+    columns['binary_col'].sql_type.must_equal       'varbinary(max)'
+    assert_line :integer_col,     type: 'integer',      limit: '4',          precision: nil,  scale: nil, default: nil
+    assert_line :bigint_col,      type: 'bigint',       limit: '8',          precision: nil,  scale: nil, default: nil
+    assert_line :boolean_col,     type: 'boolean',      limit: nil,          precision: nil,  scale: nil, default: nil
+    assert_line :decimal_col,     type: 'decimal',      limit: nil,          precision: '18', scale: '0', default: nil
+    assert_line :float_col,       type: 'float',        limit: nil,          precision: nil,  scale: nil, default: nil
+    assert_line :string_col,      type: 'string',       limit: '4000',       precision: nil,  scale: nil, default: nil
+    assert_line :text_col,        type: 'text',         limit: '2147483647', precision: nil,  scale: nil, default: nil
+    assert_line :datetime_col,    type: 'datetime',     limit: nil,          precision: nil,  scale: nil, default: nil
+    assert_line :timestamp_col,   type: 'datetime',     limit: nil,          precision: nil,  scale: nil, default: nil
+    assert_line :time_col,        type: 'time',         limit: nil,          precision: '7',  scale: nil, default: nil
+    assert_line :date_col,        type: 'date',         limit: nil,          precision: nil,  scale: nil, default: nil
+    assert_line :binary_col,      type: 'binary',       limit: '2147483647', precision: nil,  scale: nil, default: nil
+    # Our type methods.
+    columns['real_col'].sql_type.must_equal         'real'
+    columns['money_col'].sql_type.must_equal        'money'
+    columns['datetime2_col'].sql_type.must_equal    'datetime2(7)'
+    columns['datetimeoffset'].sql_type.must_equal   'datetimeoffset(7)'
+    columns['smallmoney_col'].sql_type.must_equal   'smallmoney'
+    columns['char_col'].sql_type.must_equal         'char(1)'
+    columns['varchar_col'].sql_type.must_equal      'varchar(8000)'
+    columns['text_basic_col'].sql_type.must_equal   'text'
+    columns['nchar_col'].sql_type.must_equal        'nchar(1)'
+    columns['ntext_col'].sql_type.must_equal        'ntext'
+    columns['binary_basic_col'].sql_type.must_equal 'binary(1)'
+    columns['varbinary_col'].sql_type.must_equal    'varbinary(8000)'
+    columns['uuid_col'].sql_type.must_equal         'uniqueidentifier'
+    columns['sstimestamp_col'].sql_type.must_equal  'timestamp'
+    assert_line :real_col,          type: 'real',         limit: nil,           precision: nil,   scale: nil,  default: nil
+    assert_line :money_col,         type: 'money',        limit: nil,           precision: '19',  scale: '4',  default: nil
+    assert_line :datetime2_col,     type: 'datetime2',    limit: nil,           precision: '7',   scale: nil,  default: nil
+    assert_line :smallmoney_col,    type: 'smallmoney',   limit: nil,           precision: '10',  scale: '4',  default: nil
+    assert_line :char_col,          type: 'char',         limit: '1',           precision: nil,   scale: nil,  default: nil
+    assert_line :varchar_col,       type: 'varchar',      limit: '8000',        precision: nil,   scale: nil,  default: nil
+    assert_line :text_basic_col,    type: 'text_basic',   limit: '2147483647',  precision: nil,   scale: nil,  default: nil
+    assert_line :nchar_col,         type: 'nchar',        limit: '1',           precision: nil,   scale: nil,  default: nil
+    assert_line :ntext_col,         type: 'ntext',        limit: '2147483647',  precision: nil,   scale: nil,  default: nil
+    assert_line :binary_basic_col,  type: 'binary_basic', limit: '1',           precision: nil,   scale: nil,  default: nil
+    assert_line :varbinary_col,     type: 'varbinary',    limit: '8000',        precision: nil,   scale: nil,  default: nil
+    assert_line :uuid_col,          type: 'uuid',         limit: nil,           precision: nil,   scale: nil,  default: nil
+    assert_line :sstimestamp_col,   type: 'ss_timestamp', limit: nil,           precision: nil,   scale: nil,  default: nil
+  end
+
+  # Special Cases
+
+  it 'honor nonstandard primary keys' do
+    generate_schema_for_table('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
+
+  it 'no id with model driven primary key' do
+    output = generate_schema_for_table 'sst_no_pk_data'
+    output.must_match %r{create_table "sst_no_pk_data".*id:\sfalse.*do}
+    assert_line :name, type: 'string', limit: '4000'
+  end
+
+
+  private
+
+  def generate_schema_for_table(*table_names)
+    require 'stringio'
+    stream = StringIO.new
+    ActiveRecord::SchemaDumper.ignore_tables = all_tables - table_names
+    ActiveRecord::SchemaDumper.dump(ActiveRecord::Base.connection, stream)
+    @generated_schema = stream.string
+    yield @generated_schema if block_given?
+    @schema_lines = Hash.new
+    type_matcher = /\A\s+t\.\w+\s+"(.*?)"[,\n]/
+    @generated_schema.each_line do |line|
+      next unless line =~ type_matcher
+      @schema_lines[Regexp.last_match[1]] = SchemaLine.new(line)
+    end
+    @generated_schema
+  end
+
+  def line(column_name)
+    @schema_lines[column_name.to_s]
+  end
+
+  def assert_line(column_name, options={})
+    line = line(column_name)
+    assert line, "Count not find line with column name: #{column_name.inspect} in schema:\n#{schema}"
+    [:type, :limit, :precision, :scale, :default].each do |key|
+      next unless options.key?(key)
+      actual   = key == :type ? line.send(:type_method) : line.send(key)
+      expected = options[key]
+      message  = "#{key.to_s.titleize} of #{expected.inspect} not found in:\n#{line}"
+      if expected.nil?
+        actual.must_be_nil message
+      elsif expected.is_a?(Regexp)
+        actual.must_match expected, message
+      else
+        actual.must_equal expected, message
+      end
+    end
+  end
+
+  class SchemaLine
+
+    attr_reader :line
+
+    def self.match(method_name, pattern)
+      define_method(method_name) { line.match(pattern).try :[], 1 }
+    end
+
+    def initialize(line)
+      @line = line
+    end
+
+    match :type_method,   %r{\A\s+t\.(.*?)\s}
+    match :limit,         %r{\slimit:\s(.*?)[,\s]}
+    match :default,       %r{\sdefault:\s(.*)\n}
+    match :precision,     %r{\sprecision:\s(.*?)[,\s]}
+    match :scale,         %r{\sscale:\s(.*?)[,\s]}
+
+    def to_s
+      line
+    end
+
+  end
+
+end
+