Standardrb

Author: aidanharan

lib/active_record/connection_adapters/sqlserver/database_statements.rb

@@ -22,12 +22,12 @@ def perform_query(raw_connection, sql, binds, type_casted_binds, prepare:, notif
           id_insert_table_name = query_requires_identity_insert?(sql)
 
           result, affected_rows = if id_insert_table_name
-                                    with_identity_insert_enabled(id_insert_table_name, raw_connection) do
-                                      internal_exec_sql_query(sql, raw_connection)
-                                    end
-                                  else
-                                    internal_exec_sql_query(sql, raw_connection)
-                                  end
+            with_identity_insert_enabled(id_insert_table_name, raw_connection) do
+              internal_exec_sql_query(sql, raw_connection)
+            end
+          else
+            internal_exec_sql_query(sql, raw_connection)
+          end
 
           verified!
           notification_payload[:affected_rows] = affected_rows
@@ -231,10 +231,10 @@ def merge_insert_values_list(insert:, insert_all:)
 
         def execute_procedure(proc_name, *variables)
           vars = if variables.any? && variables.first.is_a?(Hash)
-                   variables.first.map { |k, v| "@#{k} = #{quote(v)}" }
-                 else
-                   variables.map { |v| quote(v) }
-                 end.join(", ")
+            variables.first.map { |k, v| "@#{k} = #{quote(v)}" }
+          else
+            variables.map { |v| quote(v) }
+          end.join(", ")
           sql = "EXEC #{proc_name} #{vars}".strip
 
           log(sql, "Execute Procedure") do |notification_payload|
@@ -340,35 +340,35 @@ def sql_for_insert(sql, pk, binds, returning)
           end
 
           sql = if pk && use_output_inserted? && !database_prefix_remote_server?
-                  table_name ||= get_table_name(sql)
-                  exclude_output_inserted = exclude_output_inserted_table_name?(table_name, sql)
-
-                  if exclude_output_inserted
-                    pk_and_types = Array(pk).map do |subkey|
-                      {
-                        quoted: SQLServer::Utils.extract_identifiers(subkey).quoted,
-                        id_sql_type: exclude_output_inserted_id_sql_type(subkey, exclude_output_inserted)
-                      }
-                    end
-
-                    <<~SQL.squish
+            table_name ||= get_table_name(sql)
+            exclude_output_inserted = exclude_output_inserted_table_name?(table_name, sql)
+
+            if exclude_output_inserted
+              pk_and_types = Array(pk).map do |subkey|
+                {
+                  quoted: SQLServer::Utils.extract_identifiers(subkey).quoted,
+                  id_sql_type: exclude_output_inserted_id_sql_type(subkey, exclude_output_inserted)
+                }
+              end
+
+              <<~SQL.squish
                 DECLARE @ssaIdInsertTable table (#{pk_and_types.map { |pk_and_type| "#{pk_and_type[:quoted]} #{pk_and_type[:id_sql_type]}" }.join(", ")});
                 #{sql.dup.insert sql.index(/ (DEFAULT )?VALUES/i), " OUTPUT #{pk_and_types.map { |pk_and_type| "INSERTED.#{pk_and_type[:quoted]}" }.join(", ")} INTO @ssaIdInsertTable"}
                 SELECT #{pk_and_types.map { |pk_and_type| "CAST(#{pk_and_type[:quoted]} AS #{pk_and_type[:id_sql_type]}) #{pk_and_type[:quoted]}" }.join(", ")} FROM @ssaIdInsertTable
               SQL
-                  else
-                    returning_columns = returning || Array(pk)
-
-                    if returning_columns.any?
-                      returning_columns_statements = returning_columns.map { |c| " INSERTED.#{SQLServer::Utils.extract_identifiers(c).quoted}" }
-                      sql.dup.insert sql.index(/ (DEFAULT )?VALUES/i), " OUTPUT" + returning_columns_statements.join(",")
-                    else
-                      sql
-                    end
-                  end
-                else
-                  "#{sql}; SELECT CAST(SCOPE_IDENTITY() AS bigint) AS Ident"
-                end
+            else
+              returning_columns = returning || Array(pk)
+
+              if returning_columns.any?
+                returning_columns_statements = returning_columns.map { |c| " INSERTED.#{SQLServer::Utils.extract_identifiers(c).quoted}" }
+                sql.dup.insert sql.index(/ (DEFAULT )?VALUES/i), " OUTPUT" + returning_columns_statements.join(",")
+              else
+                sql
+              end
+            end
+          else
+            "#{sql}; SELECT CAST(SCOPE_IDENTITY() AS bigint) AS Ident"
+          end
 
           [sql, binds]
         end
@@ -537,16 +537,16 @@ def build_sql_for_returning(insert:, insert_all:)
           return "" unless insert_all.returning
 
           returning_values_sql = if insert_all.returning.is_a?(String)
-                                   insert_all.returning
-                                 else
-                                   Array(insert_all.returning).map do |attribute|
-                                     if insert.model.attribute_alias?(attribute)
-                                       "INSERTED.#{quote_column_name(insert.model.attribute_alias(attribute))} AS #{quote_column_name(attribute)}"
-                                     else
-                                       "INSERTED.#{quote_column_name(attribute)}"
-                                     end
-                                   end.join(",")
-                                 end
+            insert_all.returning
+          else
+            Array(insert_all.returning).map do |attribute|
+              if insert.model.attribute_alias?(attribute)
+                "INSERTED.#{quote_column_name(insert.model.attribute_alias(attribute))} AS #{quote_column_name(attribute)}"
+              else
+                "INSERTED.#{quote_column_name(attribute)}"
+              end
+            end.join(",")
+          end
 
           " OUTPUT #{returning_values_sql}"
         end

test/cases/coerced_tests.rb

@@ -261,7 +261,7 @@ def test_belongs_to_with_primary_key_joins_on_correct_column_coerced
   def test_belongs_to_coerced
     client = Client.find(3)
     first_firm = companies(:first_firm)
-    assert_queries_and_values_match(/FETCH NEXT @3 ROWS ONLY/, ['Firm', 'Agency', 1, 1]) do
+    assert_queries_and_values_match(/FETCH NEXT @3 ROWS ONLY/, ["Firm", "Agency", 1, 1]) do
       assert_equal first_firm, client.firm
       assert_equal first_firm.name, client.firm.name
     end
@@ -397,11 +397,11 @@ def test_select_avg_with_group_by_as_virtual_attribute_with_ar_coerced
     rails_core = companies(:rails_core)
 
     account = Account
-                .select(:firm_id, "AVG(CAST(credit_limit AS DECIMAL)) AS avg_credit_limit")
-                .where(firm: rails_core)
-                .group(:firm_id)
-                .order(:firm_id)
-                .take!
+      .select(:firm_id, "AVG(CAST(credit_limit AS DECIMAL)) AS avg_credit_limit")
+      .where(firm: rails_core)
+      .group(:firm_id)
+      .order(:firm_id)
+      .take!
 
     # id was not selected, so it should be nil
     # (cannot select id because it wasn't used in the GROUP BY clause)
@@ -448,11 +448,11 @@ def test_select_avg_with_joins_and_group_by_as_virtual_attribute_with_ar_coerced
     rails_core = companies(:rails_core)
 
     firm = DependentFirm
-             .select("companies.*", "AVG(CAST(accounts.credit_limit AS DECIMAL)) AS avg_credit_limit")
-             .where(id: rails_core)
-             .joins(:account)
-             .group(:id, :type, :firm_id, :firm_name, :name, :client_of, :rating, :account_id, :description, :status)
-             .take!
+      .select("companies.*", "AVG(CAST(accounts.credit_limit AS DECIMAL)) AS avg_credit_limit")
+      .where(id: rails_core)
+      .joins(:account)
+      .group(:id, :type, :firm_id, :firm_name, :name, :client_of, :rating, :account_id, :description, :status)
+      .take!
 
     # all the DependentFirm attributes should be present
     assert_equal rails_core, firm
@@ -997,7 +997,7 @@ class FinderTest < ActiveRecord::TestCase
 
   # We have implicit ordering, via FETCH.
   coerce_tests! %r{doesn't have implicit ordering},
-                :test_find_doesnt_have_implicit_ordering
+    :test_find_doesnt_have_implicit_ordering
 
   # Assert SQL Server limit implementation
   coerce_tests! :test_take_and_first_and_last_with_integer_should_use_sql_limit
@@ -1154,7 +1154,8 @@ def test_implicit_order_column_prepends_query_constraints_coerced
     quoted_color = Regexp.escape(c.quote_table_name("clothing_items.color"))
     quoted_descrption = Regexp.escape(c.quote_table_name("clothing_items.description"))
 
-    assert_queries_match(/ORDER BY #{quoted_descrption} ASC, #{quoted_type} ASC, #{quoted_color} ASC OFFSET 0 ROWS FETCH NEXT @(\d) ROWS ONLY/i) do      assert_kind_of ClothingItem, ClothingItem.first
+    assert_queries_match(/ORDER BY #{quoted_descrption} ASC, #{quoted_type} ASC, #{quoted_color} ASC OFFSET 0 ROWS FETCH NEXT @(\d) ROWS ONLY/i) do
+      assert_kind_of ClothingItem, ClothingItem.first
     end
   ensure
     ClothingItem.implicit_order_column = nil
@@ -1481,7 +1482,7 @@ def test_reorder_with_first_coerced
   def test_multiple_where_and_having_clauses_coerced
     post = Post.first
     having_then_where = Post.having(id: post.id).where(title: post.title)
-                            .having(id: post.id).where(title: post.title).group(:id).select(:id)
+      .having(id: post.id).where(title: post.title).group(:id).select(:id)
 
     assert_equal [post], having_then_where
   end
@@ -2486,7 +2487,7 @@ def test_upsert_all_updates_using_provided_sql_coerced
           ELSE 1
         END
       SQL
-      )
+                            )
     )
 
     assert_equal "published", Book.find(1).status

test/support/query_assertions.rb

@@ -22,7 +22,7 @@ def assert_queries_count(count = nil, include_schema: false, &block)
         end
       end
 
-      def assert_queries_and_values_match(match, bound_values=[], count: nil, &block)
+      def assert_queries_and_values_match(match, bound_values = [], count: nil, &block)
         ActiveRecord::Base.lease_connection.materialize_transactions
 
         counter = ActiveRecord::Assertions::QueryAssertions::SQLCounter.new
@@ -35,9 +35,9 @@ def assert_queries_and_values_match(match, bound_values=[], count: nil, &block)
           end
 
           if count
-            assert_equal count, matched_queries.size, "#{matched_queries.size} instead of #{count} queries were executed.#{count.log.empty? ? '' : "\nQueries:\n#{counter.log.join("\n")}"}"
+            assert_equal count, matched_queries.size, "#{matched_queries.size} instead of #{count} queries were executed.#{"\nQueries:\n#{counter.log.join("\n")}" unless count.log.empty?}"
           else
-            assert_operator matched_queries.size, :>=, 1, "1 or more queries expected, but none were executed.#{counter.log.empty? ? '' : "\nQueries:\n#{counter.log.join("\n")}"}"
+            assert_operator matched_queries.size, :>=, 1, "1 or more queries expected, but none were executed.#{"\nQueries:\n#{counter.log.join("\n")}" unless counter.log.empty?}"
           end
 
           result