activerecord-jdbcsqlserver-adapter 50.0.0

data/test/cases/pessimistic_locking_test_sqlserver.rb

@@ -0,0 +1,94 @@
+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
+      if defined? JRUBY_VERSION
+        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 \? ROWS FETCH NEXT \? ROWS ONLY/
+      else
+        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 @0 ROWS FETCH NEXT @1 ROWS ONLY/
+      end
+      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,169 @@
+require 'cases/helper_sqlserver'
+
+class SQLServerRakeTest < ActiveRecord::TestCase
+
+  self.use_transactional_tests = 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
+    quietly { db_tasks.create configuration }
+    connection.current_database.must_equal(new_database)
+  end
+
+  it 'creates database with default collation' do
+    quietly { db_tasks.create configuration }
+    connection.collation.must_equal 'SQL_Latin1_General_CP1_CI_AS'
+  end
+
+  it 'creates database with given collation' do
+    quietly { 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
+    quietly { 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
+    quietly do
+      db_tasks.create configuration
+      db_tasks.drop configuration
+    end
+    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
+    quietly { 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'
+    quietly { db_tasks.purge(configuration) }
+    connection.current_database.must_equal(new_database)
+    connection.tables.wont_include 'users'
+  end
+
+end
+
+class SQLServerRakeCharsetTest < SQLServerRakeTest
+
+  before do
+    quietly { db_tasks.create(configuration) }
+  end
+
+  it 'retrieves charset' do
+    db_tasks.charset(configuration).must_equal 'iso_1'
+  end
+
+end
+
+class SQLServerRakeCollationTest < SQLServerRakeTest
+
+  before do
+    quietly { db_tasks.create(configuration) }
+  end
+
+  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
+    quietly { 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 configuration, :sql, filename
+    connection.tables.must_include 'users'
+  end
+
+end

data/test/cases/schema_dumper_test_sqlserver.rb

@@ -0,0 +1,234 @@
+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'
+    assert_line :bigint,            type: 'bigint',       limit: nil,           precision: nil,   scale: nil,  default: 42
+    assert_line :int,               type: 'integer',      limit: nil,           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: 123.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: 'datetime',     limit: nil,           precision: 7,     scale: nil,  default: "12-31-9999 23:59:59.9999999"
+    assert_line :datetime2_3,       type: 'datetime',     limit: nil,           precision: 3,     scale: nil,  default: nil
+    assert_line :datetime2_1,       type: 'datetime',     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.0"
+    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",           collation: nil
+    assert_line :varchar_50,        type: 'varchar',      limit: 50,            precision: nil,   scale: nil,  default: "test varchar_50",      collation: nil
+    assert_line :varchar_max,       type: 'varchar_max',  limit: 2147483647,    precision: nil,   scale: nil,  default: "test varchar_max",     collation: nil
+    assert_line :text,              type: 'text_basic',   limit: 2147483647,    precision: nil,   scale: nil,  default: "test text",            collation: nil
+    # Unicode Character Strings
+    assert_line :nchar_10,          type: 'nchar',        limit: 10,            precision: nil,   scale: nil,  default: "12345678åå",           collation: nil
+    assert_line :nvarchar_50,       type: 'string',       limit: 50,            precision: nil,   scale: nil,  default: "test nvarchar_50 åå",  collation: nil
+    assert_line :nvarchar_max,      type: 'text',         limit: 2147483647,    precision: nil,   scale: nil,  default: "test nvarchar_max åå", collation: nil
+    assert_line :ntext,             type: 'ntext',        limit: 2147483647,    precision: nil,   scale: nil,  default: "test ntext åå",        collation: nil
+    # 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: -> { "newid()" }
+    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: nil,          precision: nil,  scale: nil, default: nil
+    assert_line :bigint_col,      type: 'bigint',       limit: nil,          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: nil,          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['smalldatetime_col'].sql_type.must_equal 'smalldatetime'
+    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'
+    columns['json_col'].sql_type.must_equal         'nvarchar(max)'
+    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 :smalldatetime_col, type: 'smalldatetime',  limit: nil,           precision: nil,   scale: nil,  default: nil
+    assert_line :datetime2_col,     type: 'datetime',       limit: nil,           precision: 7,     scale: nil,  default: nil
+    assert_line :datetimeoffset,    type: 'datetimeoffset', 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: nil,           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: nil,           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
+    assert_line :json_col,          type: 'text',           limit: 2147483647,    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: nil, default: nil, collation: nil
+  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, :collation, :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?(Array)
+        actual.must_include expected, message
+      elsif expected.is_a?(Float)
+        actual.must_be_close_to expected, 0.001
+      elsif expected.is_a?(Proc)
+        actual.call.must_equal(expected.call)
+      else
+        actual.must_equal expected, message
+      end
+    end
+  end
+
+  class SchemaLine
+
+    LINE_PARSER = %r{t\.(\w+)\s+"(.*?)"[,\s+](.*)}
+
+    attr_reader :line,
+                :type_method,
+                :col_name,
+                :options
+
+    def self.option(method_name)
+      define_method(method_name) { options.present? ? options[method_name.to_sym] : nil }
+    end
+
+    def initialize(line)
+      @line = line
+      @type_method, @col_name, @options = parse_line
+    end
+
+    option :limit
+    option :precision
+    option :scale
+    option :default
+    option :collation
+
+    def to_s
+      line.squish
+    end
+
+    def inspect
+      "#<SchemaLine col_name=#{col_name.inspect}, options=#{options.inspect}>"
+    end
+
+    private
+
+    def parse_line
+      _all, type_method, col_name, options = @line.match(LINE_PARSER).to_a
+      options = parse_options(options)
+      [type_method, col_name, options]
+    end
+
+    def parse_options(opts)
+      if opts.present?
+        eval "{#{opts}}"
+      else
+        {}
+      end
+    rescue SyntaxError
+      {}
+    end
+
+  end
+
+end
+