activerecord-sqlserver-adapter 6.0.0.rc1 → 6.1.0.0.rc1

data/test/cases/index_test_sqlserver.rb

@@ -1,9 +1,8 @@
 # frozen_string_literal: true
 
-require 'cases/helper_sqlserver'
+require "cases/helper_sqlserver"
 
 class IndexTestSQLServer < ActiveRecord::TestCase
-
   before do
     connection.create_table(:testings) do |t|
       t.column :foo, :string, limit: 100
@@ -19,31 +18,30 @@ class IndexTestSQLServer < ActiveRecord::TestCase
     connection.drop_table :testings rescue nil
   end
 
-  it 'add index with order' do
+  it "add index with order" do
     assert_sql(/CREATE.*INDEX.*\(\[last_name\] DESC\)/i) do
-      connection.add_index 'testings', ['last_name'], order: { last_name: :desc }
-      connection.remove_index 'testings', ['last_name']
+      connection.add_index "testings", ["last_name"], order: { last_name: :desc }
+      connection.remove_index "testings", ["last_name"]
     end
     assert_sql(/CREATE.*INDEX.*\(\[last_name\] DESC, \[first_name\]\)/i) do
-      connection.add_index 'testings', ['last_name', 'first_name'], order: { last_name: :desc }
-      connection.remove_index 'testings', ['last_name', 'first_name']
+      connection.add_index "testings", ["last_name", "first_name"], order: { last_name: :desc }
+      connection.remove_index "testings", ["last_name", "first_name"]
     end
     assert_sql(/CREATE.*INDEX.*\(\[last_name\] DESC, \[first_name\] ASC\)/i) do
-      connection.add_index 'testings', ['last_name', 'first_name'], order: { last_name: :desc, first_name: :asc }
-      connection.remove_index 'testings', ['last_name', 'first_name']
+      connection.add_index "testings", ["last_name", "first_name"], order: { last_name: :desc, first_name: :asc }
+      connection.remove_index "testings", ["last_name", "first_name"]
     end
   end
 
-  it 'add index with where' do
+  it "add index with where" do
     assert_sql(/CREATE.*INDEX.*\(\[last_name\]\) WHERE \[first_name\] = N'john doe'/i) do
-      connection.add_index 'testings', 'last_name', where: "[first_name] = N'john doe'"
-      connection.remove_index 'testings', 'last_name'
+      connection.add_index "testings", "last_name", where: "[first_name] = N'john doe'"
+      connection.remove_index "testings", "last_name"
     end
   end
 
-  it 'add index with expression' do
+  it "add index with expression" do
     connection.execute "ALTER TABLE [testings] ADD [first_name_upper] AS UPPER([first_name])"
-    connection.add_index 'testings', 'first_name_upper'
+    connection.add_index "testings", "first_name_upper"
   end
-
 end

data/test/cases/json_test_sqlserver.rb

@@ -1,34 +1,32 @@
 # frozen_string_literal: true
 
-require 'cases/helper_sqlserver'
+require "cases/helper_sqlserver"
 
 if ActiveRecord::Base.connection.supports_json?
-class JsonTestSQLServer < ActiveRecord::TestCase
+  class JsonTestSQLServer < ActiveRecord::TestCase
+    before do
+      @o1 = SSTestDatatypeMigrationJson.create! json_col: { "a" => "a", "b" => "b", "c" => "c" }
+      @o2 = SSTestDatatypeMigrationJson.create! json_col: { "a" => nil, "b" => "b", "c" => "c" }
+      @o3 = SSTestDatatypeMigrationJson.create! json_col: { "x" => 1, "y" => 2, "z" => 3 }
+      @o4 = SSTestDatatypeMigrationJson.create! json_col: { "array" => [1, 2, 3] }
+      @o5 = SSTestDatatypeMigrationJson.create! json_col: nil
+    end
 
-  before do
-    @o1 = SSTestDatatypeMigrationJson.create! json_col: { 'a' => 'a', 'b' => 'b', 'c' => 'c' }
-    @o2 = SSTestDatatypeMigrationJson.create! json_col: { 'a' => nil, 'b' => 'b', 'c' => 'c' }
-    @o3 = SSTestDatatypeMigrationJson.create! json_col: { 'x' => 1, 'y' => 2, 'z' => 3 }
-    @o4 = SSTestDatatypeMigrationJson.create! json_col: { 'array' => [1, 2, 3] }
-    @o5 = SSTestDatatypeMigrationJson.create! json_col: nil
-  end
-
-  it 'can return and save JSON data' do
-    _(SSTestDatatypeMigrationJson.find(@o1.id).json_col).must_equal({ 'a' => 'a', 'b' => 'b', 'c' => 'c' })
-    @o1.json_col = { 'a' => 'a' }
-    _(@o1.json_col).must_equal({ 'a' => 'a' })
-    @o1.save!
-    _(@o1.reload.json_col).must_equal({ 'a' => 'a' })
-  end
+    it "can return and save JSON data" do
+      _(SSTestDatatypeMigrationJson.find(@o1.id).json_col).must_equal({ "a" => "a", "b" => "b", "c" => "c" })
+      @o1.json_col = { "a" => "a" }
+      _(@o1.json_col).must_equal({ "a" => "a" })
+      @o1.save!
+      _(@o1.reload.json_col).must_equal({ "a" => "a" })
+    end
 
-  it 'can use ISJSON function' do
-    _(SSTestDatatypeMigrationJson.where('ISJSON(json_col) > 0').count).must_equal 4
-    _(SSTestDatatypeMigrationJson.where('ISJSON(json_col) IS NULL').count).must_equal 1
-  end
+    it "can use ISJSON function" do
+      _(SSTestDatatypeMigrationJson.where("ISJSON(json_col) > 0").count).must_equal 4
+      _(SSTestDatatypeMigrationJson.where("ISJSON(json_col) IS NULL").count).must_equal 1
+    end
 
-  it 'can use JSON_VALUE function' do
-    _(SSTestDatatypeMigrationJson.where("JSON_VALUE(json_col, '$.b') = 'b'").count).must_equal 2
+    it "can use JSON_VALUE function" do
+      _(SSTestDatatypeMigrationJson.where("JSON_VALUE(json_col, '$.b') = 'b'").count).must_equal 2
+    end
   end
-
-end
 end

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,16 +1,14 @@
 # frozen_string_literal: true
 
-require 'cases/helper_sqlserver'
-require 'models/person'
+require "cases/helper_sqlserver"
+require "models/person"
 
 class MigrationTestSQLServer < ActiveRecord::TestCase
-
-  describe 'For transactions' do
-
+  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
@@ -19,9 +17,9 @@ 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'
+        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
@@ -29,45 +27,92 @@ class MigrationTestSQLServer < ActiveRecord::TestCase
       _(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 constraint 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,149 +1,153 @@
 # frozen_string_literal: true
 
-require 'cases/helper_sqlserver'
-require 'models/post'
+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