activerecord-sqlserver-adapter 8.0.10 → 8.1.0

data/lib/arel/visitors/sqlserver.rb

@@ -16,7 +16,9 @@ module Arel
       BIND_BLOCK = proc { |i| "@#{i - 1}" }
       private_constant :BIND_BLOCK
 
-      def bind_block; BIND_BLOCK; end
+      def bind_block
+        BIND_BLOCK
+      end
 
       def visit_Arel_Nodes_Bin(o, collector)
         visit o.expr, collector
@@ -29,10 +31,49 @@ module Arel
         visit o.right, collector
       end
 
+      # Same as SQLite and PostgreSQL.
       def visit_Arel_Nodes_UpdateStatement(o, collector)
-        if has_join_and_composite_primary_key?(o)
-          update_statement_using_join(o, collector)
+        collector.retryable = false
+        o = prepare_update_statement(o)
+
+        collector << "UPDATE "
+
+        # UPDATE with JOIN is in the form of:
+        #
+        #   UPDATE t1
+        #   SET ..
+        #   FROM t1 JOIN t2 ON t2.join_id = t1.join_id ..
+        #   WHERE ..
+        if has_join_sources?(o)
+          collector = visit o.relation.left, collector
+          collect_nodes_for o.values, collector, " SET "
+          collector << " FROM "
+          collector = inject_join o.relation.right, collector, " "
+        else
+          collector = visit o.relation, collector
+          collect_nodes_for o.values, collector, " SET "
+        end
+
+        collect_nodes_for o.wheres, collector, " WHERE ", " AND "
+        collect_nodes_for o.orders, collector, " ORDER BY "
+        maybe_visit o.limit, collector
+        maybe_visit o.comment, collector
+      end
+
+      # Similar to PostgreSQL and SQLite.
+      def prepare_update_statement(o)
+        if o.key && has_join_sources?(o) && !has_group_by_and_having?(o) && !has_limit_or_offset_or_orders?(o)
+          # Join clauses cannot reference the target table, so alias the
+          # updated table, place the entire relation in the FROM clause, and
+          # add a self-join (which requires the primary key)
+          stmt = o.clone
+
+          stmt.relation, stmt.wheres = o.relation.clone, o.wheres.clone
+          stmt.relation.right = [stmt.relation.left, *stmt.relation.right]
+          # Don't need to use alias
+          stmt
         else
+          # If using subquery, we need to add limit
           o.limit = Nodes::Limit.new(9_223_372_036_854_775_807) if o.orders.any? && o.limit.nil?
 
           super
@@ -61,19 +102,8 @@ module Arel
         collect_nodes_for o.wheres, collector, " WHERE ", " AND "
       end
 
-      def update_statement_using_join(o, collector)
-        collector.retryable = false
-
-        collector << "UPDATE "
-        visit o.relation.left, collector
-        collect_nodes_for o.values, collector, " SET "
-        collector << " FROM "
-        visit o.relation, collector
-        collect_nodes_for o.wheres, collector, " WHERE ", " AND "
-      end
-
       def visit_Arel_Nodes_Lock(o, collector)
-        o.expr = Arel.sql("WITH(UPDLOCK)") if o.expr.to_s =~ /FOR UPDATE/
+        o.expr = Arel.sql("WITH(UPDLOCK)") if /FOR UPDATE/.match?(o.expr.to_s)
         collector << " "
         visit o.expr, collector
       end
@@ -87,12 +117,11 @@ module Arel
       def visit_Arel_Nodes_Limit(o, collector)
         if node_value(o) == 0
           collector << FETCH0
-          collector << ROWS_ONLY
         else
           collector << FETCH
           visit o.expr, collector
-          collector << ROWS_ONLY
         end
+        collector << ROWS_ONLY
       end
 
       def visit_Arel_Nodes_Grouping(o, collector)
@@ -105,10 +134,10 @@ module Arel
 
         visit o.left, collector
 
-        if o.type == :in
-          collector << " IN ("
+        collector << if o.type == :in
+          " IN ("
         else
-          collector << " NOT IN ("
+          " NOT IN ("
         end
 
         values = o.casted_values
@@ -170,14 +199,14 @@ module Arel
                 quote_table_name(o.name)
               end
             end
-          rescue Exception
+          rescue
             quote_table_name(o.name)
           end
 
-        if o.table_alias
-          collector << "#{table_name} #{quote_table_name o.table_alias}"
+        collector << if o.table_alias
+          "#{table_name} #{quote_table_name o.table_alias}"
         else
-          collector << table_name
+          table_name
         end
       end
 
@@ -297,7 +326,7 @@ module Arel
       end
 
       def select_statement_lock?
-        @select_statement && @select_statement.lock
+        @select_statement&.lock
       end
 
       def make_Fetch_Possible_And_Deterministic(o)
@@ -330,7 +359,7 @@ module Arel
         elsif Arel::Nodes::SqlLiteral === core.from
           Arel::Table.new(core.from)
         elsif Arel::Nodes::JoinSource === core.source
-          Arel::Nodes::SqlLiteral === core.source.left ? Arel::Table.new(core.source.left, @engine) : core.source.left.left
+          (Arel::Nodes::SqlLiteral === core.source.left) ? Arel::Table.new(core.source.left, @engine) : core.source.left.left
         end
       end
 

data/test/cases/active_schema_test_sqlserver.rb

@@ -12,48 +12,50 @@ class ActiveSchemaTestSQLServer < ActiveRecord::TestCase
     end
 
     after do
-      connection.drop_table :schema_test_table rescue nil
+      connection.drop_table :schema_test_table
+    rescue
+      nil
     end
 
-    it 'default index' do
-      assert_queries_match('CREATE INDEX [index_schema_test_table_on_foo] ON [schema_test_table] ([foo])') do
+    it "default index" do
+      assert_queries_match("CREATE INDEX [index_schema_test_table_on_foo] ON [schema_test_table] ([foo])") do
         connection.add_index :schema_test_table, "foo"
       end
     end
 
-    it 'unique index' do
-      assert_queries_match('CREATE UNIQUE INDEX [index_schema_test_table_on_foo] ON [schema_test_table] ([foo])') do
+    it "unique index" do
+      assert_queries_match("CREATE UNIQUE INDEX [index_schema_test_table_on_foo] ON [schema_test_table] ([foo])") do
         connection.add_index :schema_test_table, "foo", unique: true
       end
     end
 
-    it 'where condition on index' do
+    it "where condition on index" do
       assert_queries_match("CREATE INDEX [index_schema_test_table_on_foo] ON [schema_test_table] ([foo]) WHERE state = 'active'") do
         connection.add_index :schema_test_table, "foo", where: "state = 'active'"
       end
     end
 
-    it 'if index does not exist' do
+    it "if index does not exist" do
       assert_queries_match("IF NOT EXISTS (SELECT name FROM sysindexes WHERE name = 'index_schema_test_table_on_foo') " \
                  "CREATE INDEX [index_schema_test_table_on_foo] ON [schema_test_table] ([foo])") do
         connection.add_index :schema_test_table, "foo", if_not_exists: true
       end
     end
 
-    it 'clustered index' do
-      assert_queries_match('CREATE CLUSTERED INDEX [index_schema_test_table_on_foo] ON [schema_test_table] ([foo])') do
+    it "clustered index" do
+      assert_queries_match("CREATE CLUSTERED INDEX [index_schema_test_table_on_foo] ON [schema_test_table] ([foo])") do
         connection.add_index :schema_test_table, "foo", type: :clustered
       end
     end
 
-    it 'nonclustered index' do
-      assert_queries_match('CREATE NONCLUSTERED INDEX [index_schema_test_table_on_foo] ON [schema_test_table] ([foo])') do
+    it "nonclustered index" do
+      assert_queries_match("CREATE NONCLUSTERED INDEX [index_schema_test_table_on_foo] ON [schema_test_table] ([foo])") do
         connection.add_index :schema_test_table, "foo", type: :nonclustered
       end
     end
   end
 
-  describe 'collation' do
+  describe "collation" do
     it "create column with NOT NULL and COLLATE" do
       assert_nothing_raised do
         connection.create_table :not_null_with_collation_table, force: true, id: false do |t|
@@ -61,12 +63,16 @@ class ActiveSchemaTestSQLServer < ActiveRecord::TestCase
         end
       end
     ensure
-      connection.drop_table :not_null_with_collation_table rescue nil
+      begin
+        connection.drop_table :not_null_with_collation_table
+      rescue
+        nil
+      end
     end
   end
 
-  describe 'datetimeoffset precision' do
-    it 'valid precisions are correct' do
+  describe "datetimeoffset precision" do
+    it "valid precisions are correct" do
       assert_nothing_raised do
         connection.create_table :datetimeoffset_precisions do |t|
           t.datetimeoffset :precision_default
@@ -81,22 +87,30 @@ class ActiveSchemaTestSQLServer < ActiveRecord::TestCase
       assert_equal columns.find { |column| column.name == "precision_5" }.precision, 5
       assert_equal columns.find { |column| column.name == "precision_7" }.precision, 7
     ensure
-      connection.drop_table :datetimeoffset_precisions rescue nil
+      begin
+        connection.drop_table :datetimeoffset_precisions
+      rescue
+        nil
+      end
     end
 
-    it 'invalid precision raises exception' do
+    it "invalid precision raises exception" do
       assert_raise(ActiveRecord::ActiveRecordError) do
         connection.create_table :datetimeoffset_precisions do |t|
           t.datetimeoffset :precision_8, precision: 8
         end
       end
     ensure
-      connection.drop_table :datetimeoffset_precisions rescue nil
+      begin
+        connection.drop_table :datetimeoffset_precisions
+      rescue
+        nil
+      end
     end
   end
 
-  describe 'time precision' do
-    it 'valid precisions are correct' do
+  describe "time precision" do
+    it "valid precisions are correct" do
       assert_nothing_raised do
         connection.create_table :time_precisions do |t|
           t.time :precision_default
@@ -111,17 +125,25 @@ class ActiveSchemaTestSQLServer < ActiveRecord::TestCase
       assert_equal columns.find { |column| column.name == "precision_5" }.precision, 5
       assert_equal columns.find { |column| column.name == "precision_7" }.precision, 7
     ensure
-      connection.drop_table :time_precisions rescue nil
+      begin
+        connection.drop_table :time_precisions
+      rescue
+        nil
+      end
     end
 
-    it 'invalid precision raises exception' do
+    it "invalid precision raises exception" do
       assert_raise(ActiveRecord::ActiveRecordError) do
         connection.create_table :time_precisions do |t|
           t.time :precision_8, precision: 8
         end
       end
     ensure
-      connection.drop_table :time_precisions rescue nil
+      begin
+        connection.drop_table :time_precisions
+      rescue
+        nil
+      end
     end
   end
 end

data/test/cases/adapter_test_sqlserver.rb

@@ -14,10 +14,10 @@ require "models/discount"
 class AdapterTestSQLServer < ActiveRecord::TestCase
   fixtures :tasks
 
-  let(:arunit_connection)  { Topic.lease_connection }
+  let(:arunit_connection) { Topic.lease_connection }
   let(:arunit2_connection) { College.lease_connection }
-  let(:arunit_database)    { arunit_connection.pool.db_config.database }
-  let(:arunit2_database)   { arunit2_connection.pool.db_config.database }
+  let(:arunit_database) { arunit_connection.pool.db_config.database }
+  let(:arunit2_database) { arunit2_connection.pool.db_config.database }
 
   let(:basic_insert_sql) { "INSERT INTO [funny_jokes] ([name]) VALUES('Knock knock')" }
   let(:basic_merge_sql) { "MERGE INTO [ships] WITH (UPDLOCK, HOLDLOCK) AS target USING ( SELECT * FROM ( SELECT [id], [name], ROW_NUMBER() OVER ( PARTITION BY [id] ORDER BY [id] DESC ) AS rn_0 FROM ( VALUES (101, N'RSS Sir David Attenborough') ) AS t1 ([id], [name]) ) AS ranked_source WHERE rn_0 = 1 ) AS source ON (target.[id] = source.[id]) WHEN MATCHED THEN UPDATE SET target.[name] = source.[name]" }
@@ -50,20 +50,18 @@ class AdapterTestSQLServer < ActiveRecord::TestCase
   end
 
   it "table exists works if table name prefixed by schema and owner" do
-    begin
-      assert_equal "topics", Topic.table_name
-      assert Topic.table_exists?
-
-      # Test when owner included in table name.
-      Topic.table_name = "dbo.topics"
-      assert Topic.table_exists?, "Topics table name of 'dbo.topics' should return true for exists."
-
-      # Test when database and owner included in table name.
-      Topic.table_name = "#{arunit_database}.dbo.topics"
-      assert Topic.table_exists?, "Topics table name of '[DATABASE].dbo.topics' should return true for exists."
-    ensure
-      Topic.table_name = "topics"
-    end
+    assert_equal "topics", Topic.table_name
+    assert Topic.table_exists?
+
+    # Test when owner included in table name.
+    Topic.table_name = "dbo.topics"
+    assert Topic.table_exists?, "Topics table name of 'dbo.topics' should return true for exists."
+
+    # Test when database and owner included in table name.
+    Topic.table_name = "#{arunit_database}.dbo.topics"
+    assert Topic.table_exists?, "Topics table name of '[DATABASE].dbo.topics' should return true for exists."
+  ensure
+    Topic.table_name = "topics"
   end
 
   it "test table existence across database schemas" do
@@ -77,18 +75,18 @@ class AdapterTestSQLServer < ActiveRecord::TestCase
     assert_not_equal arunit_database, arunit2_database
 
     # Assert that the Topics table exists when using the Topics connection.
-    assert arunit_connection.table_exists?('topics'), 'Topics table exists using table name'
-    assert arunit_connection.table_exists?('dbo.topics'), 'Topics table exists using owner and table name'
-    assert arunit_connection.table_exists?("#{arunit_database}.dbo.topics"), 'Topics table exists using database, owner and table name'
+    assert arunit_connection.table_exists?("topics"), "Topics table exists using table name"
+    assert arunit_connection.table_exists?("dbo.topics"), "Topics table exists using owner and table name"
+    assert arunit_connection.table_exists?("#{arunit_database}.dbo.topics"), "Topics table exists using database, owner and table name"
 
     # Assert that the Colleges table exists when using the Colleges connection.
-    assert arunit2_connection.table_exists?('colleges'), 'College table exists using table name'
-    assert arunit2_connection.table_exists?('dbo.colleges'), 'College table exists using owner and table name'
-    assert arunit2_connection.table_exists?("#{arunit2_database}.dbo.colleges"), 'College table exists using database, owner and table name'
+    assert arunit2_connection.table_exists?("colleges"), "College table exists using table name"
+    assert arunit2_connection.table_exists?("dbo.colleges"), "College table exists using owner and table name"
+    assert arunit2_connection.table_exists?("#{arunit2_database}.dbo.colleges"), "College table exists using database, owner and table name"
 
     # Assert that the tables exist when using each others connection.
-    assert arunit_connection.table_exists?("#{arunit2_database}.dbo.colleges"), 'Colleges table exists using Topics connection'
-    assert arunit2_connection.table_exists?("#{arunit_database}.dbo.topics"), 'Topics table exists using Colleges connection'
+    assert arunit_connection.table_exists?("#{arunit2_database}.dbo.colleges"), "Colleges table exists using Topics connection"
+    assert arunit2_connection.table_exists?("#{arunit_database}.dbo.topics"), "Topics table exists using Colleges connection"
   end
 
   it "return true to insert sql query for inserts only" do
@@ -118,20 +116,20 @@ class AdapterTestSQLServer < ActiveRecord::TestCase
     db_config = ActiveRecord::Base.configurations.configs_for(env_name: "arunit", name: "primary")
     configuration = db_config.configuration_hash.merge(database: "nonexistent_activerecord_unittest")
     assert_not ActiveRecord::ConnectionAdapters::SQLServerAdapter.database_exists?(configuration),
-               "expected database #{configuration[:database]} to not exist"
+      "expected database #{configuration[:database]} to not exist"
   end
 
   it "test database exists returns true when the database exists" do
     db_config = ActiveRecord::Base.configurations.configs_for(env_name: "arunit", name: "primary")
     assert ActiveRecord::ConnectionAdapters::SQLServerAdapter.database_exists?(db_config.configuration_hash),
-           "expected database #{db_config.database} to exist"
+      "expected database #{db_config.database} to exist"
   end
 
   it "test primary key violation" do
-    Post.create!(id: 0, title: 'Setup', body: 'Create post with primary key of zero')
+    Post.create!(id: 0, title: "Setup", body: "Create post with primary key of zero")
 
     assert_raise ActiveRecord::RecordNotUnique do
-      Post.create!(id: 0, title: 'Test', body: 'Try to create another post with primary key of zero')
+      Post.create!(id: 0, title: "Test", body: "Try to create another post with primary key of zero")
     end
   end
 
@@ -141,12 +139,20 @@ class AdapterTestSQLServer < ActiveRecord::TestCase
     end
 
     after do
-      connection.execute("SET LANGUAGE #{@default_language}") rescue nil
+      begin
+        connection.execute("SET LANGUAGE #{@default_language}")
+      rescue
+        nil
+      end
       connection.send :initialize_dateformatter
     end
 
     it "memos users dateformat" do
-      connection.execute("SET LANGUAGE us_english") rescue nil
+      begin
+        connection.execute("SET LANGUAGE us_english")
+      rescue
+        nil
+      end
       dateformat = connection.instance_variable_get(:@database_dateformat)
       assert_equal "mdy", dateformat
     end
@@ -206,7 +212,7 @@ class AdapterTestSQLServer < ActiveRecord::TestCase
       connection.lowercase_schema_reflection = true
 
       assert_nothing_raised do
-        post = Post.create!(title: 'Setup', body: 'Record to be deleted')
+        post = Post.create!(title: "Setup", body: "Record to be deleted")
         post.destroy!
       end
     end
@@ -237,12 +243,12 @@ class AdapterTestSQLServer < ActiveRecord::TestCase
     end
 
     it "return quoted table_name to #query_requires_identity_insert? when INSERT sql contains id column" do
-      assert_equal "[funny_jokes]",   connection.send(:query_requires_identity_insert?, @identity_insert_sql)
-      assert_equal "[funny_jokes]",   connection.send(:query_requires_identity_insert?, @identity_insert_sql_unquoted)
-      assert_equal "[funny_jokes]",   connection.send(:query_requires_identity_insert?, @identity_insert_sql_unordered)
-      assert_equal "[funny_jokes]",   connection.send(:query_requires_identity_insert?, @identity_insert_sql_sp)
-      assert_equal "[funny_jokes]",   connection.send(:query_requires_identity_insert?, @identity_insert_sql_unquoted_sp)
-      assert_equal "[funny_jokes]",   connection.send(:query_requires_identity_insert?, @identity_insert_sql_unordered_sp)
+      assert_equal "[funny_jokes]", connection.send(:query_requires_identity_insert?, @identity_insert_sql)
+      assert_equal "[funny_jokes]", connection.send(:query_requires_identity_insert?, @identity_insert_sql_unquoted)
+      assert_equal "[funny_jokes]", connection.send(:query_requires_identity_insert?, @identity_insert_sql_unordered)
+      assert_equal "[funny_jokes]", connection.send(:query_requires_identity_insert?, @identity_insert_sql_sp)
+      assert_equal "[funny_jokes]", connection.send(:query_requires_identity_insert?, @identity_insert_sql_unquoted_sp)
+      assert_equal "[funny_jokes]", connection.send(:query_requires_identity_insert?, @identity_insert_sql_unordered_sp)
 
       assert_equal "[ships]", connection.send(:query_requires_identity_insert?, @identity_merge_sql)
       assert_equal "[ships]", connection.send(:query_requires_identity_insert?, @identity_merge_sql_unquoted)
@@ -326,7 +332,10 @@ class AdapterTestSQLServer < ActiveRecord::TestCase
 
   describe "disabling referential integrity" do
     before do
-      connection.disable_referential_integrity { SSTestHasPk.delete_all; SSTestHasFk.delete_all }
+      connection.disable_referential_integrity {
+        SSTestHasPk.delete_all
+        SSTestHasFk.delete_all
+      }
       @parent = SSTestHasPk.create!
       @member = SSTestHasFk.create!(fk_id: @parent.id)
     end
@@ -467,8 +476,8 @@ class AdapterTestSQLServer < ActiveRecord::TestCase
       assert_equal columns.size, SSTestCustomersView.columns.size
       columns.each do |colname|
         assert_instance_of ActiveRecord::ConnectionAdapters::SQLServer::Column,
-                           SSTestCustomersView.columns_hash[colname],
-                           "Column name #{colname.inspect} was not found in these columns #{SSTestCustomersView.columns.map(&:name).inspect}"
+          SSTestCustomersView.columns_hash[colname],
+          "Column name #{colname.inspect} was not found in these columns #{SSTestCustomersView.columns.map(&:name).inspect}"
       end
     end
 
@@ -494,8 +503,8 @@ class AdapterTestSQLServer < ActiveRecord::TestCase
       assert_equal columns.size, SSTestStringDefaultsView.columns.size
       columns.each do |colname|
         assert_instance_of ActiveRecord::ConnectionAdapters::SQLServer::Column,
-                           SSTestStringDefaultsView.columns_hash[colname],
-                           "Column name #{colname.inspect} was not found in these columns #{SSTestStringDefaultsView.columns.map(&:name).inspect}"
+          SSTestStringDefaultsView.columns_hash[colname],
+          "Column name #{colname.inspect} was not found in these columns #{SSTestStringDefaultsView.columns.map(&:name).inspect}"
       end
     end
 
@@ -507,7 +516,7 @@ class AdapterTestSQLServer < ActiveRecord::TestCase
 
     it "find default values" do
       assert_equal "null", SSTestStringDefaultsView.new.pretend_null,
-                   SSTestStringDefaultsView.columns_hash["pretend_null"].inspect
+        SSTestStringDefaultsView.columns_hash["pretend_null"].inspect
     end
 
     it "respond true to data_source_exists?" do
@@ -517,12 +526,12 @@ class AdapterTestSQLServer < ActiveRecord::TestCase
     # That have more than 4000 chars for their definition
 
     it "cope with null returned for the definition" do
-      assert_nothing_raised() { SSTestStringDefaultsBigView.columns }
+      assert_nothing_raised { SSTestStringDefaultsBigView.columns }
     end
 
     it "using alternate view definition still be able to find real default" do
       assert_equal "null", SSTestStringDefaultsBigView.new.pretend_null,
-                   SSTestStringDefaultsBigView.columns_hash["pretend_null"].inspect
+        SSTestStringDefaultsBigView.columns_hash["pretend_null"].inspect
     end
   end
 
@@ -597,30 +606,30 @@ class AdapterTestSQLServer < ActiveRecord::TestCase
     end
   end
 
-  describe 'table is in non-dbo schema' do
+  describe "table is in non-dbo schema" do
     it "records can be created successfully" do
       assert_difference("Alien.count", 1) do
-        Alien.create!(name: 'Trisolarans')
+        Alien.create!(name: "Trisolarans")
       end
     end
 
-    it 'records can be inserted using SQL' do
+    it "records can be inserted using SQL" do
       assert_difference("Alien.count", 2) do
         Alien.lease_connection.exec_insert("insert into [test].[aliens] (id, name) VALUES(1, 'Trisolarans'), (2, 'Xenomorph')")
       end
     end
   end
 
-  describe 'table names contains spaces' do
-    it 'records can be created successfully' do
+  describe "table names contains spaces" do
+    it "records can be created successfully" do
       assert_difference("TableWithSpaces.count", 1) do
-        TableWithSpaces.create!(name: 'Bob')
+        TableWithSpaces.create!(name: "Bob")
       end
     end
   end
 
   describe "exec_insert" do
-    it 'values clause should be case-insensitive' do
+    it "values clause should be case-insensitive" do
       assert_difference("Post.count", 4) do
         first_insert = connection.exec_insert("INSERT INTO [posts] ([id],[title],[body]) VALUES(100, 'Title', 'Body'), (102, 'Title', 'Body')")
         second_insert = connection.exec_insert("INSERT INTO [posts] ([id],[title],[body]) values(113, 'Body', 'Body'), (114, 'Body', 'Body')")
@@ -636,33 +645,37 @@ class AdapterTestSQLServer < ActiveRecord::TestCase
       @conn = ActiveRecord::Base.lease_connection
     end
 
-    it 'raises an error when the foreign key is mismatched' do
+    it "raises an error when the foreign key is mismatched" do
       error = assert_raises(ActiveRecord::MismatchedForeignKey) do
         @conn.add_reference :engines, :old_car
         @conn.add_foreign_key :engines, :old_cars
       end
 
       assert_match(
-        %r/Column 'old_cars\.id' is not the same data type as referencing column 'engines\.old_car_id' in foreign key '.*'/,
+        %r{Column 'old_cars\.id' is not the same data type as referencing column 'engines\.old_car_id' in foreign key '.*'},
         error.message
       )
       assert_not_nil error.cause
       assert_equal @conn.pool, error.connection_pool
     ensure
-      @conn.execute("ALTER TABLE engines DROP COLUMN old_car_id") rescue nil
+      begin
+        @conn.execute("ALTER TABLE engines DROP COLUMN old_car_id")
+      rescue
+        nil
+      end
     end
   end
 
   describe "placeholder conditions" do
-    it 'using time placeholder' do
+    it "using time placeholder" do
       assert_equal Task.where("starting < ?", Time.now).count, 1
     end
 
-    it 'using date placeholder' do
+    it "using date placeholder" do
       assert_equal Task.where("starting < ?", Date.today).count, 1
     end
 
-    it 'using date-time placeholder' do
+    it "using date-time placeholder" do
       assert_equal Task.where("starting < ?", DateTime.current).count, 1
     end
   end