activerecord-sqlserver-adapter 5.2.1 → 7.0.0.0

data/test/cases/lateral_test_sqlserver.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require "cases/helper_sqlserver"
+require "models/post"
+require "models/author"
+
+class LateralTestSQLServer < ActiveRecord::TestCase
+  fixtures :posts, :authors
+
+  it 'uses OUTER APPLY for OUTER JOIN LATERAL' do
+    post = Arel::Table.new(:posts)
+    author = Arel::Table.new(:authors)
+    subselect = post.project(Arel.star).take(1).where(post[:author_id].eq(author[:id])).where(post[:id].eq(42))
+
+    one = Arel::Nodes::Quoted.new(1)
+    eq = Arel::Nodes::Equality.new(one, one)
+
+    sql = author.project(Arel.star).where(author[:name].matches("David")).outer_join(subselect.lateral.as("bar")).on(eq).to_sql
+    results = ActiveRecord::Base.connection.exec_query sql
+    assert_equal sql, "SELECT * FROM [authors] OUTER APPLY (SELECT * FROM [posts] WHERE [posts].[author_id] = [authors].[id] AND [posts].[id] = 42 ORDER BY [posts].[id] ASC OFFSET 0 ROWS FETCH NEXT 1 ROWS ONLY) AS bar WHERE [authors].[name] LIKE N'David'"
+    assert_equal results.length, 1
+  end
+
+  it 'uses CROSS APPLY for INNER JOIN LATERAL' do
+    post = Arel::Table.new(:posts)
+    author = Arel::Table.new(:authors)
+    subselect = post.project(Arel.star).take(1).where(post[:author_id].eq(author[:id])).where(post[:id].eq(42))
+
+    sql = author.project(Arel.star).where(author[:name].matches("David")).join(subselect.lateral.as("bar")).to_sql
+    results = ActiveRecord::Base.connection.exec_query sql
+
+    assert_equal sql, "SELECT * FROM [authors] CROSS APPLY (SELECT * FROM [posts] WHERE [posts].[author_id] = [authors].[id] AND [posts].[id] = 42 ORDER BY [posts].[id] ASC OFFSET 0 ROWS FETCH NEXT 1 ROWS ONLY) AS bar WHERE [authors].[name] LIKE N'David'"
+    assert_equal results.length, 0
+  end
+end

data/test/cases/migration_test_sqlserver.rb

@@ -1,14 +1,14 @@
-require 'cases/helper_sqlserver'
-require 'models/person'
+# frozen_string_literal: true
 
-class MigrationTestSQLServer < ActiveRecord::TestCase
-
-  describe 'For transactions' do
+require "cases/helper_sqlserver"
+require "models/person"
 
+class MigrationTestSQLServer < ActiveRecord::TestCase
+  describe "For transactions" do
     before do
-      @trans_test_table1 = 'sqlserver_trans_table1'
-      @trans_test_table2 = 'sqlserver_trans_table2'
-      @trans_tables = [@trans_test_table1,@trans_test_table2]
+      @trans_test_table1 = "sqlserver_trans_table1"
+      @trans_test_table2 = "sqlserver_trans_table2"
+      @trans_tables = [@trans_test_table1, @trans_test_table2]
     end
 
     after do
@@ -17,55 +17,102 @@ class MigrationTestSQLServer < ActiveRecord::TestCase
       end
     end
 
-    it 'not create a tables if error in migrations' do
+    it "not create a tables if error in migrations" do
       begin
-        migrations_dir = File.join ARTest::SQLServer.migrations_root, 'transaction_table'
-        quietly { ActiveRecord::MigrationContext.new(migrations_dir).up }
+        migrations_dir = File.join ARTest::SQLServer.migrations_root, "transaction_table"
+        quietly { ActiveRecord::MigrationContext.new(migrations_dir, ActiveRecord::SchemaMigration).up }
       rescue Exception => e
         assert_match %r|this and all later migrations canceled|, e.message
       end
       _(connection.tables).wont_include @trans_test_table1
       _(connection.tables).wont_include @trans_test_table2
     end
-
   end
 
-  describe 'For changing column' do
-
-    it 'not raise exception when column contains default constraint' do
-      lock_version_column = Person.columns_hash['lock_version']
+  describe "For changing column" do
+    it "not raise exception when column contains default constraint" do
+      lock_version_column = Person.columns_hash["lock_version"]
       assert_equal :integer, lock_version_column.type
       assert lock_version_column.default.present?
-      assert_nothing_raised { connection.change_column 'people', 'lock_version', :string }
+      assert_nothing_raised { connection.change_column "people", "lock_version", :string }
       Person.reset_column_information
-      lock_version_column = Person.columns_hash['lock_version']
+      lock_version_column = Person.columns_hash["lock_version"]
       assert_equal :string, lock_version_column.type
       assert lock_version_column.default.nil?
-      assert_nothing_raised { connection.change_column 'people', 'lock_version', :integer }
+      assert_nothing_raised { connection.change_column "people", "lock_version", :integer }
       Person.reset_column_information
     end
 
-    it 'not drop the default contraint if just renaming' do
+    it "not drop the default constraint if just renaming" do
       find_default = lambda do
-        connection.execute_procedure(:sp_helpconstraint, 'sst_string_defaults', 'nomsg').select do |row|
-          row['constraint_type'] == "DEFAULT on column string_with_pretend_paren_three"
+        connection.execute_procedure(:sp_helpconstraint, "sst_string_defaults", "nomsg").select do |row|
+          row["constraint_type"] == "DEFAULT on column string_with_pretend_paren_three"
         end.last
       end
       default_before = find_default.call
       connection.change_column :sst_string_defaults, :string_with_pretend_paren_three, :string, limit: 255
       default_after = find_default.call
       assert default_after
-      assert_equal default_before['constraint_keys'], default_after['constraint_keys']
+      assert_equal default_before["constraint_keys"], default_after["constraint_keys"]
     end
-    
-    it 'change limit' do
+
+    it "change limit" do
       assert_nothing_raised { connection.change_column :people, :lock_version, :integer, limit: 8 }
     end
-    
-    it 'change null and default' do
+
+    it "change null and default" do
       assert_nothing_raised { connection.change_column :people, :first_name, :text, null: true, default: nil }
     end
 
+    it "change collation" do
+      assert_nothing_raised { connection.change_column :sst_string_collation, :string_with_collation, :varchar, collation: :SQL_Latin1_General_CP437_BIN }
+
+      SstStringCollation.reset_column_information
+      assert_equal "SQL_Latin1_General_CP437_BIN", SstStringCollation.columns_hash['string_with_collation'].collation
+    end
+  end
+
+  describe "#create_schema" do
+    it "creates a new schema" do
+      connection.create_schema("some schema")
+
+      schemas = connection.exec_query("select name from sys.schemas").to_a
+
+      assert_includes schemas, { "name" => "some schema" }
+    end
+
+    it "creates a new schema with an owner" do
+      connection.create_schema("some schema", :guest)
+
+      schemas = connection.exec_query("select name, principal_id from sys.schemas").to_a
+
+      assert_includes schemas, { "name" => "some schema", "principal_id" => 2 }
+    end
+  end
+
+  describe "#change_table_schema" do
+    before { connection.create_schema("foo") }
+
+    it "transfer the given table to the given schema" do
+      connection.change_table_schema("foo", "orders")
+
+      assert connection.data_source_exists?("foo.orders")
+    end
   end
 
+  describe "#drop_schema" do
+    before { connection.create_schema("some schema") }
+
+    it "drops a schema" do
+      schemas = connection.exec_query("select name from sys.schemas").to_a
+
+      assert_includes schemas, { "name" => "some schema" }
+
+      connection.drop_schema("some schema")
+
+      schemas = connection.exec_query("select name from sys.schemas").to_a
+
+      refute_includes schemas, { "name" => "some schema" }
+    end
+  end
 end

data/test/cases/optimizer_hints_test_sqlserver.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require "cases/helper_sqlserver"
+require "models/company"
+
+class OptimizerHitsTestSQLServer < ActiveRecord::TestCase
+  fixtures :companies
+
+  it "apply optimizations" do
+    assert_sql(%r{\ASELECT .+ FROM .+ OPTION \(HASH GROUP\)\z}) do
+      companies = Company.optimizer_hints("HASH GROUP")
+      companies = companies.distinct.select("firm_id")
+      assert_includes companies.explain, "| Hash Match | Aggregate  |"
+    end
+
+    assert_sql(%r{\ASELECT .+ FROM .+ OPTION \(ORDER GROUP\)\z}) do
+      companies = Company.optimizer_hints("ORDER GROUP")
+      companies = companies.distinct.select("firm_id")
+      assert_includes companies.explain, "| Stream Aggregate | Aggregate  |"
+    end
+  end
+
+  it "apply multiple optimizations" do
+    assert_sql(%r{\ASELECT .+ FROM .+ OPTION \(HASH GROUP, FAST 1\)\z}) do
+      companies = Company.optimizer_hints("HASH GROUP", "FAST 1")
+      companies = companies.distinct.select("firm_id")
+      assert_includes companies.explain, "| Hash Match | Flow Distinct |"
+    end
+  end
+
+  it "support subqueries" do
+    assert_sql(%r{.*'SELECT COUNT\(count_column\) FROM \(SELECT .*\) subquery_for_count OPTION \(MAXDOP 2\)'.*}) do
+      companies = Company.optimizer_hints("MAXDOP 2")
+      companies = companies.select(:id).where(firm_id: [0, 1]).limit(3)
+      assert_equal 3, companies.count
+    end
+  end
+
+  it "sanitize values" do
+    assert_sql(%r{\ASELECT .+ FROM .+ OPTION \(HASH GROUP\)\z}) do
+      companies = Company.optimizer_hints("OPTION (HASH GROUP)")
+      companies = companies.distinct.select("firm_id")
+      companies.to_a
+    end
+
+    assert_sql(%r{\ASELECT .+ FROM .+ OPTION \(HASH GROUP\)\z}) do
+      companies = Company.optimizer_hints("OPTION(HASH GROUP)")
+      companies = companies.distinct.select("firm_id")
+      companies.to_a
+    end
+
+    assert_sql(%r{\ASELECT .+ FROM .+ OPTION \(TABLE HINT \(\[companies\], INDEX\(1\)\)\)\z}) do
+      companies = Company.optimizer_hints("OPTION(TABLE HINT ([companies], INDEX(1)))")
+      companies = companies.distinct.select("firm_id")
+      companies.to_a
+    end
+
+    assert_sql(%r{\ASELECT .+ FROM .+ OPTION \(HASH GROUP\)\z}) do
+      companies = Company.optimizer_hints("Option(HASH GROUP)")
+      companies = companies.distinct.select("firm_id")
+      companies.to_a
+    end
+  end
+
+  it "skip optimization after unscope" do
+    assert_sql("SELECT DISTINCT [companies].[firm_id] FROM [companies]") do
+      companies = Company.optimizer_hints("HASH GROUP")
+      companies = companies.distinct.select("firm_id")
+      companies.unscope(:optimizer_hints).load
+    end
+  end
+end

data/test/cases/order_test_sqlserver.rb

@@ -1,147 +1,153 @@
-require 'cases/helper_sqlserver'
-require 'models/post'
+# frozen_string_literal: true
 
-class OrderTestSQLServer < ActiveRecord::TestCase
+require "cases/helper_sqlserver"
+require "models/post"
 
+class OrderTestSQLServer < ActiveRecord::TestCase
   fixtures :posts
 
-  it 'not mangel complex order clauses' do
+  it "not mangel complex order clauses" do
     xyz_order = "CASE WHEN [title] LIKE N'XYZ%' THEN 0 ELSE 1 END"
-    xyz_post = Post.create title: 'XYZ Post', body: 'Test cased orders.'
+    xyz_post = Post.create title: "XYZ Post", body: "Test cased orders."
     assert_equal xyz_post, Post.order(Arel.sql(xyz_order)).first
   end
 
-  it 'support column' do
+  it "support column" do
     order = "title"
-    post1 = Post.create title: 'AAA Post', body: 'Test cased orders.'
+    post1 = Post.create title: "AAA Post", body: "Test cased orders."
     assert_equal post1, Post.order(order).first
   end
 
-  it 'support column ASC' do
+  it "support column ASC" do
     order = "title ASC"
-    post1 = Post.create title: 'AAA Post', body: 'Test cased orders.'
+    post1 = Post.create title: "AAA Post", body: "Test cased orders."
     assert_equal post1, Post.order(order).first
   end
 
-  it 'support column DESC' do
+  it "support column DESC" do
     order = "title DESC"
-    post1 = Post.create title: 'ZZZ Post', body: 'Test cased orders.'
+    post1 = Post.create title: "ZZZ Post", body: "Test cased orders."
     assert_equal post1, Post.order(order).first
   end
 
-  it 'support column as symbol' do
+  it "support column as symbol" do
     order = :title
-    post1 = Post.create title: 'AAA Post', body: 'Test cased orders.'
+    post1 = Post.create title: "AAA Post", body: "Test cased orders."
     assert_equal post1, Post.order(order).first
   end
 
-  it 'support table and column' do
+  it "support table and column" do
     order = "posts.title"
-    post1 = Post.create title: 'AAA Post', body: 'Test cased orders.'
+    post1 = Post.create title: "AAA Post", body: "Test cased orders."
     assert_equal post1, Post.order(order).first
   end
 
-  it 'support quoted column' do
+  it "support quoted column" do
     order = "[title]"
-    post1 = Post.create title: 'AAA Post', body: 'Test cased orders.'
+    post1 = Post.create title: "AAA Post", body: "Test cased orders."
     assert_equal post1, Post.order(Arel.sql(order)).first
   end
 
-  it 'support quoted table and column' do
+  it "support quoted table and column" do
     order = "[posts].[title]"
-    post1 = Post.create title: 'AAA Post', body: 'Test cased orders.'
+    post1 = Post.create title: "AAA Post", body: "Test cased orders."
     assert_equal post1, Post.order(Arel.sql(order)).first
   end
 
-  it 'support primary: column, secondary: column' do
+  it "support primary: column, secondary: column" do
     order = "title DESC, body"
-    post1 = Post.create title: 'ZZZ Post', body: 'Test cased orders.'
-    post2 = Post.create title: 'ZZZ Post', body: 'ZZZ Test cased orders.'
+    post1 = Post.create title: "ZZZ Post", body: "Test cased orders."
+    post2 = Post.create title: "ZZZ Post", body: "ZZZ Test cased orders."
     assert_equal post1, Post.order(order).first
     assert_equal post2, Post.order(order).second
   end
 
-  it 'support primary: table and column, secondary: column' do
+  it "support primary: table and column, secondary: column" do
     order = "posts.title DESC, body"
-    post1 = Post.create title: 'ZZZ Post', body: 'Test cased orders.'
-    post2 = Post.create title: 'ZZZ Post', body: 'ZZZ Test cased orders.'
+    post1 = Post.create title: "ZZZ Post", body: "Test cased orders."
+    post2 = Post.create title: "ZZZ Post", body: "ZZZ Test cased orders."
     assert_equal post1, Post.order(order).first
     assert_equal post2, Post.order(order).second
   end
 
-  it 'support primary: case expression, secondary: column' do
+  it "support primary: case expression, secondary: column" do
     order = "(CASE WHEN [title] LIKE N'ZZZ%' THEN title ELSE '' END) DESC, body"
-    post1 = Post.create title: 'ZZZ Post', body: 'Test cased orders.'
-    post2 = Post.create title: 'ZZZ Post', body: 'ZZZ Test cased orders.'
+    post1 = Post.create title: "ZZZ Post", body: "Test cased orders."
+    post2 = Post.create title: "ZZZ Post", body: "ZZZ Test cased orders."
     assert_equal post1, Post.order(Arel.sql(order)).first
     assert_equal post2, Post.order(Arel.sql(order)).second
   end
 
-  it 'support primary: quoted table and column, secondary: case expresion' do
+  it "support primary: quoted table and column, secondary: case expresion" do
     order = "[posts].[body] DESC, (CASE WHEN [title] LIKE N'ZZZ%' THEN title ELSE '' END) DESC"
-    post1 = Post.create title: 'ZZZ Post', body: 'ZZZ Test cased orders.'
-    post2 = Post.create title: 'ZZY Post', body: 'ZZZ Test cased orders.'
+    post1 = Post.create title: "ZZZ Post", body: "ZZZ Test cased orders."
+    post2 = Post.create title: "ZZY Post", body: "ZZZ Test cased orders."
     assert_equal post1, Post.order(Arel.sql(order)).first
     assert_equal post2, Post.order(Arel.sql(order)).second
   end
 
-  it 'support inline function' do
+  it "support inline function" do
     order = "LEN(title)"
-    post1 = Post.create title: 'A', body: 'AAA Test cased orders.'
+    post1 = Post.create title: "A", body: "AAA Test cased orders."
     assert_equal post1, Post.order(Arel.sql(order)).first
   end
 
-  it 'support inline function with parameters' do
+  it "support inline function with parameters" do
     order = "SUBSTRING(title, 1, 3)"
-    post1 = Post.create title: 'AAA Post', body: 'Test cased orders.'
+    post1 = Post.create title: "AAA Post", body: "Test cased orders."
     assert_equal post1, Post.order(Arel.sql(order)).first
   end
 
-  it 'support inline function with parameters DESC' do
+  it "support inline function with parameters DESC" do
     order = "SUBSTRING(title, 1, 3) DESC"
-    post1 = Post.create title: 'ZZZ Post', body: 'Test cased orders.'
+    post1 = Post.create title: "ZZZ Post", body: "Test cased orders."
     assert_equal post1, Post.order(Arel.sql(order)).first
   end
 
-  it 'support primary: inline function, secondary: column' do
+  it "support primary: inline function, secondary: column" do
     order = "LEN(title), body"
-    post1 = Post.create title: 'A', body: 'AAA Test cased orders.'
-    post2 = Post.create title: 'A', body: 'Test cased orders.'
+    post1 = Post.create title: "A", body: "AAA Test cased orders."
+    post2 = Post.create title: "A", body: "Test cased orders."
     assert_equal post1, Post.order(Arel.sql(order)).first
     assert_equal post2, Post.order(Arel.sql(order)).second
   end
 
-  it 'support primary: inline function, secondary: column with direction' do
+  it "support primary: inline function, secondary: column with direction" do
     order = "LEN(title) ASC, body DESC"
-    post1 = Post.create title: 'A', body: 'ZZZ Test cased orders.'
-    post2 = Post.create title: 'A', body: 'Test cased orders.'
+    post1 = Post.create title: "A", body: "ZZZ Test cased orders."
+    post2 = Post.create title: "A", body: "Test cased orders."
     assert_equal post1, Post.order(Arel.sql(order)).first
     assert_equal post2, Post.order(Arel.sql(order)).second
   end
 
-  it 'support primary: column, secondary: inline function' do
+  it "support primary: column, secondary: inline function" do
     order = "body DESC, LEN(title)"
-    post1 = Post.create title: 'Post', body: 'ZZZ Test cased orders.'
-    post2 = Post.create title: 'Longer Post', body: 'ZZZ Test cased orders.'
+    post1 = Post.create title: "Post", body: "ZZZ Test cased orders."
+    post2 = Post.create title: "Longer Post", body: "ZZZ Test cased orders."
     assert_equal post1, Post.order(Arel.sql(order)).first
     assert_equal post2, Post.order(Arel.sql(order)).second
   end
 
-  it 'support primary: case expression, secondary: inline function' do
+  it "support primary: case expression, secondary: inline function" do
     order = "CASE WHEN [title] LIKE N'ZZZ%' THEN title ELSE '' END DESC, LEN(body) ASC"
-    post1 = Post.create title: 'ZZZ Post', body: 'Z'
-    post2 = Post.create title: 'ZZZ Post', body: 'Test cased orders.'
+    post1 = Post.create title: "ZZZ Post", body: "Z"
+    post2 = Post.create title: "ZZZ Post", body: "Test cased orders."
     assert_equal post1, Post.order(Arel.sql(order)).first
     assert_equal post2, Post.order(Arel.sql(order)).second
   end
 
-  it 'support primary: inline function, secondary: case expression' do
+  it "support primary: inline function, secondary: case expression" do
     order = "LEN(body), CASE WHEN [title] LIKE N'ZZZ%' THEN title ELSE '' END DESC"
-    post1 = Post.create title: 'ZZZ Post', body: 'Z'
-    post2 = Post.create title: 'Post', body: 'Z'
+    post1 = Post.create title: "ZZZ Post", body: "Z"
+    post2 = Post.create title: "Post", body: "Z"
     assert_equal post1, Post.order(Arel.sql(order)).first
     assert_equal post2, Post.order(Arel.sql(order)).second
   end
 
-
+  # Executing this kind of queries will raise "A column has been specified more than once in the order by list"
+  # This test shows that we don't do anything to prevent this
+  it "doesn't deduplicate semantically equal orders" do
+    sql = Post.order(:id).order("posts.id ASC").to_sql
+    assert_equal "SELECT [posts].* FROM [posts] ORDER BY [posts].[id] ASC, posts.id ASC", sql
+  end
 end

data/test/cases/pessimistic_locking_test_sqlserver.rb

@@ -1,9 +1,10 @@
-require 'cases/helper_sqlserver'
-require 'models/person'
-require 'models/reader'
+# frozen_string_literal: true
 
-class PessimisticLockingTestSQLServer < ActiveRecord::TestCase
+require "cases/helper_sqlserver"
+require "models/person"
+require "models/reader"
 
+class PessimisticLockingTestSQLServer < ActiveRecord::TestCase
   fixtures :people, :readers
 
   before do
@@ -11,15 +12,14 @@ class PessimisticLockingTestSQLServer < ActiveRecord::TestCase
     Reader.columns
   end
 
-  it 'uses with updlock by default' do
+  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
+  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)
@@ -27,7 +27,7 @@ class PessimisticLockingTestSQLServer < ActiveRecord::TestCase
       end
     end
 
-    it 'lock with scoped find' do
+    it "lock with scoped find" do
       assert_nothing_raised do
         Person.transaction do
           Person.lock(true).scoping do
@@ -37,8 +37,8 @@ class PessimisticLockingTestSQLServer < ActiveRecord::TestCase
       end
     end
 
-    it 'lock with eager find' do
-       assert_nothing_raised do
+    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)
@@ -46,62 +46,56 @@ class PessimisticLockingTestSQLServer < ActiveRecord::TestCase
       end
     end
 
-    it 'can add a custom lock directive' do
+    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
+        Person.lock("WITH(HOLDLOCK, ROWLOCK)").load
       end
     end
 
-    describe 'joining tables' do
-
-      it 'joined tables use updlock by default' do
+    describe "joining tables" do
+      it "joined tables use updlock by default" do
         assert_sql %r|SELECT \[people\]\.\* FROM \[people\] WITH\(UPDLOCK\) INNER JOIN \[readers\] WITH\(UPDLOCK\)\s+ON \[readers\]\.\[person_id\] = \[people\]\.\[id\]| do
           Person.lock(true).joins(:readers).load
         end
       end
 
-      it 'joined tables can use custom lock directive' do
+      it "joined tables can use custom lock directive" do
         assert_sql %r|SELECT \[people\]\.\* FROM \[people\] WITH\(NOLOCK\) INNER JOIN \[readers\] WITH\(NOLOCK\)\s+ON \[readers\]\.\[person_id\] = \[people\]\.\[id\]| do
-          Person.lock('WITH(NOLOCK)').joins(:readers).load
+          Person.lock("WITH(NOLOCK)").joins(:readers).load
         end
       end
 
-      it 'left joined tables use updlock by default' do
+      it "left joined tables use updlock by default" do
         assert_sql %r|SELECT \[people\]\.\* FROM \[people\] WITH\(UPDLOCK\) LEFT OUTER JOIN \[readers\] WITH\(UPDLOCK\)\s+ON \[readers\]\.\[person_id\] = \[people\]\.\[id\]| do
           Person.lock(true).left_joins(:readers).load
         end
       end
 
-      it 'left joined tables can use custom lock directive' do
+      it "left joined tables can use custom lock directive" do
         assert_sql %r|SELECT \[people\]\.\* FROM \[people\] WITH\(NOLOCK\) LEFT OUTER JOIN \[readers\] WITH\(NOLOCK\)\s+ON \[readers\]\.\[person_id\] = \[people\]\.\[id\]| do
-          Person.lock('WITH(NOLOCK)').left_joins(:readers).load
+          Person.lock("WITH(NOLOCK)").left_joins(:readers).load
         end
       end
-
     end
-
   end
 
-  describe 'For paginated finds' do
-
+  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
+    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 @0 ROWS FETCH NEXT @1 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'
+        _(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