activerecord-sqlserver-adapter_new 4.2.15

data/test/cases/schema_test_sqlserver.rb

@@ -0,0 +1,54 @@
+require 'cases/helper_sqlserver'
+
+class SchemaTestSQLServer < ActiveRecord::TestCase
+
+  describe 'When table is dbo schema' do
+
+    it 'find primary key for tables with odd schema' do
+      connection.primary_key('sst_natural_pk_data').must_equal 'legacy_id'
+    end
+
+  end
+
+  describe 'When table is in non-dbo schema' do
+
+    it 'work with table exists' do
+      assert connection.table_exists?('test.sst_schema_natural_id')
+      assert connection.table_exists?('[test].[sst_schema_natural_id]')
+    end
+
+    it 'find primary key for tables with odd schema' do
+      connection.primary_key('test.sst_schema_natural_id').must_equal 'legacy_id'
+    end
+
+    it "have only one identity column" do
+      columns = connection.columns("test.sst_schema_identity")
+      assert_equal 2, columns.size
+      assert_equal 1, columns.select{ |c| c.is_identity? }.size
+    end
+
+    it "read only column properties for table in specific schema" do
+      test_columns = connection.columns("test.sst_schema_columns")
+      dbo_columns = connection.columns("dbo.sst_schema_columns")
+      columns = connection.columns("sst_schema_columns") # This returns table from dbo schema
+      assert_equal 7, test_columns.size
+      assert_equal 2, dbo_columns.size
+      assert_equal 2, columns.size
+      assert_equal 1, test_columns.select{ |c| c.is_identity? }.size
+      assert_equal 1, dbo_columns.select{ |c| c.is_identity? }.size
+      assert_equal 1, columns.select{ |c| c.is_identity? }.size
+    end
+
+    it "return correct varchar and nvarchar column limit length when table is in non dbo schema" do
+      columns = connection.columns("test.sst_schema_columns")
+      assert_equal 255, columns.find {|c| c.name == 'name'}.limit
+      assert_equal 1000, columns.find {|c| c.name == 'description'}.limit
+      assert_equal 255, columns.find {|c| c.name == 'n_name'}.limit
+      assert_equal 1000, columns.find {|c| c.name == 'n_description'}.limit
+    end
+
+  end
+
+
+end
+

data/test/cases/scratchpad_test_sqlserver.rb

@@ -0,0 +1,9 @@
+require 'cases/helper_sqlserver'
+
+class ScratchpadTestSQLServer < ActiveRecord::TestCase
+
+  it 'helps debug things' do
+    #
+  end
+
+end

data/test/cases/showplan_test_sqlserver.rb

@@ -0,0 +1,65 @@
+require 'cases/helper_sqlserver'
+require 'models/car'
+
+class ShowplanTestSQLServer < ActiveRecord::TestCase
+
+  fixtures :cars
+
+  describe 'Unprepare previously prepared SQL' do
+
+    it 'from simple statement' do
+      plan = Car.where(id: 1).explain
+      plan.must_include "SELECT [cars].* FROM [cars] WHERE [cars].[id] = 1"
+      plan.must_include "Clustered Index Seek", 'make sure we do not showplan the sp_executesql'
+    end
+
+    it 'from multiline statement' do
+      plan = Car.where("\n id = 1 \n").explain
+      plan.must_include "SELECT [cars].* FROM [cars] WHERE (\n id = 1 \n)"
+      plan.must_include "Clustered Index Seek", 'make sure we do not showplan the sp_executesql'
+    end
+
+    it 'from prepared statement ...' do
+      plan = Car.where(name: ',').limit(1).explain
+      plan.must_include " SELECT  [cars].* FROM [cars] WHERE [cars].[name]"
+      plan.must_include "TOP EXPRESSION", 'make sure we do not showplan the sp_executesql'
+      plan.must_include "Clustered Index Scan", 'make sure we do not showplan the sp_executesql'
+    end
+
+  end
+
+  describe 'With SHOWPLAN_TEXT option' do
+
+    it 'use simple table printer' do
+      with_showplan_option('SHOWPLAN_TEXT') do
+        plan = Car.where(id: 1).explain
+        plan.must_include "SELECT [cars].* FROM [cars] WHERE [cars].[id]"
+        plan.must_include "Clustered Index Seek", 'make sure we do not showplan the sp_executesql'
+      end
+    end
+
+  end
+
+  describe 'With SHOWPLAN_XML option' do
+
+    it 'show formatted xml' do
+      with_showplan_option('SHOWPLAN_XML') do
+        plan = Car.where(id: 1).explain
+        plan.must_include 'ShowPlanXML'
+      end
+    end
+
+  end
+
+
+  private
+
+  def with_showplan_option(option)
+    old_option = ActiveRecord::ConnectionAdapters::SQLServerAdapter.showplan_option
+    ActiveRecord::ConnectionAdapters::SQLServerAdapter.showplan_option = option
+    yield
+  ensure
+    ActiveRecord::ConnectionAdapters::SQLServerAdapter.showplan_option = old_option
+  end
+
+end

data/test/cases/specific_schema_test_sqlserver.rb

@@ -0,0 +1,167 @@
+require 'cases/helper_sqlserver'
+
+class SpecificSchemaTestSQLServer < ActiveRecord::TestCase
+
+  after { SSTestEdgeSchema.delete_all }
+
+  it 'handle dollar symbols' do
+    SSTestDollarTableName.create!
+    SSTestDollarTableName.limit(20).offset(1)
+  end
+
+  it 'handle dot table names' do
+    SSTestDotTableName.create! name: 'test'
+    SSTestDotTableName.limit(20).offset(1)
+    SSTestDotTableName.where(name: 'test').first.must_be :present?
+  end
+
+  it 'models can use tinyint pk tables' do
+    obj = SSTestTinyintPk.create! name: '1'
+    obj.id.is_a? Fixnum
+    SSTestTinyintPk.find(obj.id).must_equal obj
+  end
+
+  it 'be able to complex count tables with no primary key' do
+    SSTestNoPkData.delete_all
+    10.times { |n| SSTestNoPkData.create! name: "Test#{n}" }
+    assert_equal 1, SSTestNoPkData.where(name: 'Test5').count
+  end
+
+  it 'quote table names properly even when they are views' do
+    obj = SSTestQuotedTable.create!
+    assert_nothing_raised { assert SSTestQuotedTable.first }
+    obj = SSTestQuotedTableUser.create!
+    assert_nothing_raised { assert SSTestQuotedTableUser.first }
+    obj = SSTestQuotedView1.create!
+    assert_nothing_raised { assert SSTestQuotedView1.first }
+    obj = SSTestQuotedView2.create!
+    assert_nothing_raised { assert SSTestQuotedView2.first }
+  end
+
+  it 'cope with multi line defaults' do
+    default = SSTestStringDefault.new
+    assert_equal "Some long default with a\nnew line.", default.string_with_multiline_default
+  end
+
+  it 'default strings before save' do
+    default = SSTestStringDefault.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
+
+  it 'default strings after save' do
+    default = SSTestStringDefault.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
+
+  it 'default objects work' do
+    obj = SSTestObjectDefault.create! name: 'MetaSkills'
+    obj.date.must_be_nil 'since this is set on insert'
+    obj.reload.date.must_be_instance_of Date
+  end
+
+  it 'allows datetime2 as timestamps' do
+    SSTestBooking.columns_hash['created_at'].sql_type.must_equal 'datetime2(7)'
+    SSTestBooking.columns_hash['updated_at'].sql_type.must_equal 'datetime2(7)'
+    obj1 = SSTestBooking.new name: 'test1'
+    obj1.save!
+    obj1.created_at.must_be_instance_of Time
+    obj1.updated_at.must_be_instance_of Time
+  end
+
+  # Natural primary keys.
+
+  it 'work with identity inserts' do
+    record = SSTestNaturalPkData.new name: 'Test', description: 'Natural identity inserts.'
+    record.id = '12345ABCDE'
+    assert record.save
+    assert_equal '12345ABCDE', record.reload.id
+  end
+
+  it 'work with identity inserts when the key is an int' do
+    record = SSTestNaturalPkIntData.new name: 'Test', description: 'Natural identity inserts.'
+    record.id = 12
+    assert record.save
+    assert_equal 12, record.reload.id
+  end
+
+  it 'use primary key for row table order in pagination sql' do
+    sql = /ORDER BY \[sst_natural_pk_data\]\.\[legacy_id\] ASC OFFSET 5 ROWS FETCH NEXT 5 ROWS ONLY/
+    assert_sql(sql) { SSTestNaturalPkData.limit(5).offset(5).load }
+  end
+
+  # Special quoted column
+
+  it 'work as normal' do
+    SSTestEdgeSchema.delete_all
+    r = SSTestEdgeSchema.create! 'crazy]]quote' => 'crazyqoute'
+    assert SSTestEdgeSchema.columns_hash['crazy]]quote']
+    assert_equal r, SSTestEdgeSchema.where('crazy]]quote' => 'crazyqoute').first
+  end
+
+  it 'various methods to bypass national quoted columns for any column, but primarily useful for char/varchar' do
+    value = Class.new do
+      def quoted_id
+        "'T'"
+      end
+    end
+    # Using ActiveRecord's quoted_id feature for objects.
+    assert_sql(/@0 = 'T'/) { SSTestDatatypeMigration.where(char_col: value.new).first }
+    assert_sql(/@0 = 'T'/) { SSTestDatatypeMigration.where(varchar_col: value.new).first }
+    # Using our custom char type data.
+    data = ActiveRecord::Type::SQLServer::Char::Data
+    assert_sql(/@0 = 'T'/) { SSTestDatatypeMigration.where(char_col: data.new('T')).first }
+    assert_sql(/@0 = 'T'/) { SSTestDatatypeMigration.where(varchar_col: data.new('T')).first }
+    # Taking care of everything.
+    assert_sql(/@0 = 'T'/) { SSTestDatatypeMigration.where(char_col: 'T').first }
+    assert_sql(/@0 = 'T'/) { SSTestDatatypeMigration.where(varchar_col: 'T').first }
+  end
+
+  it 'can update and hence properly quoted non-national char/varchar columns' do
+    o = SSTestDatatypeMigration.create!
+    o.varchar_col = "O'Reilly"
+    o.save!
+    o.reload.varchar_col.must_equal "O'Reilly"
+    o.varchar_col = nil
+    o.save!
+    o.reload.varchar_col.must_be_nil
+  end
+
+  # With column names that have spaces
+
+  it 'create record using a custom attribute reader and be able to load it back in' do
+    value = 'Saved value into a column that has a space in the name.'
+    record = SSTestEdgeSchema.create! with_spaces: value
+    assert_equal value, SSTestEdgeSchema.find(record.id).with_spaces
+  end
+
+  # With description column
+
+  it 'allow all sorts of ordering without adapter munging it up with special description column' do
+    SSTestEdgeSchema.create! description: 'A'
+    SSTestEdgeSchema.create! description: 'B'
+    SSTestEdgeSchema.create! description: 'C'
+    assert_equal ['A','B','C'], SSTestEdgeSchema.order('description').map(&:description)
+    assert_equal ['A','B','C'], SSTestEdgeSchema.order('description asc').map(&:description)
+    assert_equal ['A','B','C'], SSTestEdgeSchema.order('description ASC').map(&:description)
+    assert_equal ['C','B','A'], SSTestEdgeSchema.order('description desc').map(&:description)
+    assert_equal ['C','B','A'], SSTestEdgeSchema.order('description DESC').map(&:description)
+  end
+
+  # For uniqueidentifier model helpers
+
+  it 'returns a new id via connection newid_function' do
+    acceptable_uuid = ActiveRecord::ConnectionAdapters::SQLServer::Type::Uuid::ACCEPTABLE_UUID
+    db_uuid = ActiveRecord::Base.connection.newid_function
+    db_uuid.must_match(acceptable_uuid)
+  end
+
+end

data/test/cases/transaction_test_sqlserver.rb

@@ -0,0 +1,66 @@
+# encoding: UTF-8
+require 'cases/helper_sqlserver'
+require 'models/ship'
+require 'models/developer'
+
+class TransactionTestSQLServer < ActiveRecord::TestCase
+
+  self.use_transactional_fixtures = false
+
+  before { delete_ships }
+
+  it 'allow ActiveRecord::Rollback to work in 1 transaction block' do
+    Ship.transaction do
+      Ship.create! name: 'Black Pearl'
+      raise ActiveRecord::Rollback
+    end
+    assert_no_ships
+  end
+
+  it 'allow nested transactions to totally rollback' do
+    begin
+      Ship.transaction do
+        Ship.create! name: 'Black Pearl'
+        Ship.transaction do
+          Ship.create! name: 'Flying Dutchman'
+          raise 'HELL'
+        end
+      end
+    rescue Exception => e
+      assert_no_ships
+    end
+  end
+
+  it 'can use an isolation level and reverts back to starting isolation level' do
+    in_level = nil
+    begin_level = connection.user_options_isolation_level
+    begin_level.must_match %r{read committed}i
+    Ship.transaction(isolation: :serializable) do
+      Ship.create! name: 'Black Pearl'
+      in_level = connection.user_options_isolation_level
+    end
+    after_level = connection.user_options_isolation_level
+    in_level.must_match %r{serializable}i
+    after_level.must_match %r{read committed}i
+  end
+
+  it 'can use an isolation level and reverts back to starting isolation level under exceptions' do
+    connection.user_options_isolation_level.must_match %r{read committed}i
+    lambda {
+      Ship.transaction(isolation: :serializable) { Ship.create! }
+    }.must_raise(ActiveRecord::RecordInvalid)
+    connection.user_options_isolation_level.must_match %r{read committed}i
+  end
+
+
+  protected
+
+  def delete_ships
+    Ship.delete_all
+  end
+
+  def assert_no_ships
+    assert Ship.count.zero?, "Expected Ship to have no models but it did have:\n#{Ship.all.inspect}"
+  end
+
+end

data/test/cases/utils_test_sqlserver.rb

@@ -0,0 +1,129 @@
+require 'cases/helper_sqlserver'
+
+class UtilsTestSQLServer < ActiveRecord::TestCase
+
+  it '.quote_string' do
+    SQLServer::Utils.quote_string("I'll store this in C:\\Users").must_equal "I''ll store this in C:\\Users"
+  end
+
+  it '.unquote_string' do
+    SQLServer::Utils.unquote_string("I''ll store this in C:\\Users").must_equal "I'll store this in C:\\Users"
+  end
+
+  it '.quoted_raw' do
+    SQLServer::Utils.quoted_raw("some.Name").must_equal "[some.Name]"
+  end
+
+  describe '.extract_identifiers constructor and thus SQLServer::Utils::Name value object' do
+
+    let(:valid_names) { valid_names_unquoted + valid_names_quoted }
+
+    let(:valid_names_unquoted) {[
+      'server.database.schema.object',
+      'server.database..object',
+      'server..schema.object',
+      'server...object',
+      'database.schema.object',
+      'database..object',
+      'schema.object',
+      'object'
+    ]}
+
+    let(:valid_names_quoted) {[
+      '[server].[database].[schema].[object]',
+      '[server].[database]..[object]',
+      '[server]..[schema].[object]',
+      '[server]...[object]',
+      '[database].[schema].[object]',
+      '[database]..[object]',
+      '[schema].[object]',
+      '[object]'
+    ]}
+
+    let(:server_names)   { valid_names.partition { |name| name =~ /server/ } }
+    let(:database_names) { valid_names.partition { |name| name =~ /database/ } }
+    let(:schema_names)   { valid_names.partition { |name| name =~ /schema/ } }
+
+    it 'extracts and returns #object identifier unquoted by default or quoted as needed' do
+      valid_names.each do |n|
+        name = extract_identifiers(n)
+        name.object.must_equal 'object', "With #{n.inspect} for #object"
+        name.object_quoted.must_equal '[object]', "With #{n.inspect} for #object_quoted"
+      end
+    end
+
+    [:schema, :database, :server].each do |part|
+
+      it "extracts and returns #{part} identifier unquoted by default or quoted as needed" do
+        present, blank = send(:"#{part}_names")
+        present.each do |n|
+          name = extract_identifiers(n)
+          name.send(:"#{part}").must_equal "#{part}", "With #{n.inspect} for ##{part} method"
+          name.send(:"#{part}_quoted").must_equal "[#{part}]", "With #{n.inspect} for ##{part}_quoted method"
+        end
+        blank.each do |n|
+          name = extract_identifiers(n)
+          name.send(:"#{part}").must_be_nil "With #{n.inspect} for ##{part} method"
+          name.send(:"#{part}_quoted").must_be_nil "With #{n.inspect} for ##{part}_quoted method"
+        end
+      end
+
+    end
+
+    it 'does not blow up on nil or blank string name' do
+      extract_identifiers(nil).object.must_be_nil
+      extract_identifiers(' ').object.must_be_nil
+    end
+
+    it 'has a #quoted that returns a fully quoted name with all identifiers as orginially passed in' do
+      extract_identifiers('object').quoted.must_equal '[object]'
+      extract_identifiers('server.database..object').quoted.must_equal '[server].[database]..[object]'
+      extract_identifiers('[server]...[object]').quoted.must_equal '[server]...[object]'
+    end
+
+    it 'can take a symbol argument' do
+      extract_identifiers(:object).object.must_equal 'object'
+    end
+
+    it 'allows identifiers with periods to work' do
+      extract_identifiers('[obj.name]').quoted.must_equal '[obj.name]'
+      extract_identifiers('[obj.name].[foo]').quoted.must_equal '[obj.name].[foo]'
+    end
+
+    it 'should indicate if a name is fully qualitified' do
+      extract_identifiers('object').fully_qualified?.must_equal false
+      extract_identifiers('schema.object').fully_qualified?.must_equal false
+      extract_identifiers('database.schema.object').fully_qualified?.must_equal false
+      extract_identifiers('database.object').fully_qualified?.must_equal false
+      extract_identifiers('server...object').fully_qualified?.must_equal false
+      extract_identifiers('server.database..object').fully_qualified?.must_equal false
+      extract_identifiers('server.database.schema.object').fully_qualified?.must_equal true
+      extract_identifiers('server.database.schema.').fully_qualified?.must_equal true
+      extract_identifiers('[obj.name]').fully_qualified?.must_equal false
+      extract_identifiers('[schema].[obj.name]').fully_qualified?.must_equal false
+      extract_identifiers('[database].[schema].[obj.name]').fully_qualified?.must_equal false
+      extract_identifiers('[database].[obj.name]').fully_qualified?.must_equal false
+      extract_identifiers('[server.name]...[obj.name]').fully_qualified?.must_equal false
+      extract_identifiers('[server.name].[database]..[obj.name]').fully_qualified?.must_equal false
+      extract_identifiers('[server.name].[database].[schema].[obj.name]').fully_qualified?.must_equal true
+      extract_identifiers('[server.name].[database].[schema].').fully_qualified?.must_equal true
+    end
+
+    it 'can return fully qualified quoted table name' do
+      name = extract_identifiers('[my.server].db.schema.')
+      name.fully_qualified_database_quoted.must_equal '[my.server].[db]'
+      name = extract_identifiers('[server.name].[database].[schema].[object]')
+      name.fully_qualified_database_quoted.must_equal '[server.name].[database]'
+      name = extract_identifiers('server.database.schema.object')
+      name.fully_qualified_database_quoted.must_equal '[server].[database]'
+    end
+
+  end
+
+  private
+
+  def extract_identifiers(name)
+    SQLServer::Utils.extract_identifiers(name)
+  end
+
+end