refactor code into more smaller methods

Author: andyundso

lib/active_record/connection_adapters/sqlserver/database_statements.rb

@@ -156,47 +156,23 @@ def default_insert_value(column)
         def build_insert_sql(insert) # :nodoc:
           if insert.skip_duplicates? || insert.update_duplicates?
             insert_all = insert.send(:insert_all)
-            conflict_columns = get_conflicted_columns(insert_all:, insert:)
+            columns_with_uniqueness_constraints = get_columns_with_uniqueness_constraints(insert_all:, insert:)
 
             # if we do not have any columns that might have conflicting values, just execute a regular insert
-            return build_sql_for_regular_insert(insert) if conflict_columns.flatten.empty?
-
-            # why is the "PARTITION BY" clause needed?
-            # in every DBMS system, insert_all / upsert_all is usually implemented with INSERT, that allows to define what happens
-            # when duplicates are found (SKIP OR UPDATE)
-            # by default rows are considered to be unique by every unique index on the table
-            # but since we have to use MERGE in MSSQL, which in return is a JOIN, we have to perform the "de-duplication" ourselves
-            # otherwise the "JOIN" clause would complain about non-unique values and being unable to JOIN the two tables
-            # this works easiest by using PARTITION and make sure that any record
-            # we are trying to insert is "the first one seen across all the potential conflicted columns"
-            sql = <<~SQL
+            return build_sql_for_regular_insert(insert) if columns_with_uniqueness_constraints.flatten.empty?
 
+            sql = <<~SQL
               MERGE INTO #{insert.model.quoted_table_name} WITH (UPDLOCK, HOLDLOCK) AS target
               USING (
                 SELECT *
                 FROM (
-                  SELECT #{insert.send(:columns_list)}, #{conflict_columns.map.with_index do |group_of_conflicted_columns, index|
-                                                          <<~PARTITION_BY
-                                                            ROW_NUMBER() OVER (
-                                                              PARTITION BY #{group_of_conflicted_columns.map { |column| quote_column_name(column) }.join(",")}
-                                                              ORDER BY #{group_of_conflicted_columns.map { |column| "#{quote_column_name(column)} DESC" }.join(",")}
-                                                            ) AS rn_#{index}
-                                                          PARTITION_BY
-                                                        end.join(", ")
-                                                        }
+                  SELECT #{insert.send(:columns_list)}, #{partition_by_columns_with_uniqueness_constraints(columns_with_uniqueness_constraints:)}
                   FROM (#{insert.values_list})
                   AS t1 (#{insert.send(:columns_list)})
                 ) AS ranked_source
-                WHERE #{conflict_columns.map.with_index do |group_of_conflicted_columns, index|
-                  "rn_#{index} = 1"
-                end.join(" AND ")
-                      }
+                WHERE #{is_first_record_across_all_uniqueness_constraints(columns_with_uniqueness_constraints:)}
               ) AS source
-              ON (#{conflict_columns.map do |columns|
-                columns.map do |column|
-                  "target.#{quote_column_name(column)} = source.#{quote_column_name(column)}"
-                end.join(" AND ")
-              end.join(") OR (")})
+              ON (#{joining_on_columns_with_uniqueness_constraints(columns_with_uniqueness_constraints:)})
             SQL
 
             if insert.update_duplicates?
@@ -206,11 +182,7 @@ def build_insert_sql(insert) # :nodoc:
                 sql << insert.raw_update_sql
               else
                 if insert.record_timestamps?
-                  sql << insert.model.timestamp_attributes_for_update_in_model.filter_map do |column_name|
-                    if insert.send(:touch_timestamp_attribute?, column_name)
-                      "target.#{quote_column_name(column_name)}=CASE WHEN (#{insert.updatable_columns.map { |column| "(COALESCE(target.#{quote_column_name(column)}, 'NULL') = COALESCE(source.#{quote_column_name(column)}, 'NULL'))" }.join(" AND ")}) THEN target.#{quote_column_name(column_name)} ELSE #{high_precision_current_timestamp} END,"
-                    end
-                  end.join
+                  sql << build_sql_for_recording_timestamps_when_updating(insert:)
                 end
 
                 sql << insert.updatable_columns.map { |column| "target.#{quote_column_name(column)}=source.#{quote_column_name(column)}" }.join(",")
@@ -228,48 +200,6 @@ def build_insert_sql(insert) # :nodoc:
           build_sql_for_regular_insert(insert)
         end
 
-        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
-
-          " OUTPUT #{returning_values_sql}"
-        end
-        private :build_sql_for_returning
-
-        def get_conflicted_columns(insert_all:, insert:)
-          if (unique_by = insert_all.unique_by)
-            [unique_by.columns]
-          else
-            # Compare against every unique constraint (primary key included).
-            # Discard constraints that are not fully included on insert.keys. Prevents invalid queries.
-            # Example: ignore unique index for columns ["name"] if insert keys is ["description"]
-            (insert_all.send(:unique_indexes).map(&:columns) + [insert_all.primary_keys]).select do |columns|
-              columns.to_set.subset?(insert.keys)
-            end
-          end
-        end
-        private :get_conflicted_columns
-
-        def build_sql_for_regular_insert(insert)
-          sql = "INSERT #{insert.into}"
-
-          sql << build_sql_for_returning(insert:, insert_all: insert.send(:insert_all))
-          sql << " #{insert.values_list}"
-          sql
-        end
-        private :build_sql_for_regular_insert
-
         # === SQLServer Specific ======================================== #
 
         def execute_procedure(proc_name, *variables)
@@ -571,6 +501,98 @@ def internal_raw_execute(sql, raw_connection, perform_do: false)
           result = raw_connection.execute(sql)
           perform_do ? result.do : result
         end
+
+        # === SQLServer Specific (insert_all / upsert_all support) ===================== #
+        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
+
+          " OUTPUT #{returning_values_sql}"
+        end
+        private :build_sql_for_returning
+
+        def get_columns_with_uniqueness_constraints(insert_all:, insert:)
+          if (unique_by = insert_all.unique_by)
+            [unique_by.columns]
+          else
+            # Compare against every unique constraint (primary key included).
+            # Discard constraints that are not fully included on insert.keys. Prevents invalid queries.
+            # Example: ignore unique index for columns ["name"] if insert keys is ["description"]
+            (insert_all.send(:unique_indexes).map(&:columns) + [insert_all.primary_keys]).select do |columns|
+              columns.to_set.subset?(insert.keys)
+            end
+          end
+        end
+        private :get_columns_with_uniqueness_constraints
+
+        def build_sql_for_regular_insert(insert)
+          sql = "INSERT #{insert.into}"
+
+          sql << build_sql_for_returning(insert:, insert_all: insert.send(:insert_all))
+
+          sql << " #{insert.values_list}"
+          sql
+        end
+        private :build_sql_for_regular_insert
+
+        # why is the "PARTITION BY" clause needed?
+        # in every DBMS system, insert_all / upsert_all is usually implemented with INSERT, that allows to define what happens
+        # when duplicates are found (SKIP OR UPDATE)
+        # by default rows are considered to be unique by every unique index on the table
+        # but since we have to use MERGE in MSSQL, which in return is a JOIN, we have to perform the "de-duplication" ourselves
+        # otherwise the "JOIN" clause would complain about non-unique values and being unable to JOIN the two tables
+        # this works easiest by using PARTITION and make sure that any record
+        # we are trying to insert is "the first one seen across all the potential columns with uniquness constraints"
+        def partition_by_columns_with_uniqueness_constraints(columns_with_uniqueness_constraints:)
+          columns_with_uniqueness_constraints.map.with_index do |group_of_columns_with_uniqueness_constraints, index|
+            <<~PARTITION_BY
+              ROW_NUMBER() OVER (
+                PARTITION BY #{group_of_columns_with_uniqueness_constraints.map { |column| quote_column_name(column) }.join(",")}
+                ORDER BY #{group_of_columns_with_uniqueness_constraints.map { |column| "#{quote_column_name(column)} DESC" }.join(",")}
+              ) AS rn_#{index}
+            PARTITION_BY
+          end.join(", ")
+        end
+        private :partition_by_columns_with_uniqueness_constraints
+
+        def is_first_record_across_all_uniqueness_constraints(columns_with_uniqueness_constraints:)
+          columns_with_uniqueness_constraints.map.with_index do |group_of_columns_with_uniqueness_constraints, index|
+            "rn_#{index} = 1"
+          end.join(" AND ")
+        end
+        private :is_first_record_across_all_uniqueness_constraints
+
+        def joining_on_columns_with_uniqueness_constraints(columns_with_uniqueness_constraints:)
+          columns_with_uniqueness_constraints.map do |columns|
+            columns.map do |column|
+              "target.#{quote_column_name(column)} = source.#{quote_column_name(column)}"
+            end.join(" AND ")
+          end.join(") OR (")
+        end
+        private :joining_on_columns_with_uniqueness_constraints
+
+        # normally, generating the CASE SQL is done entirely by Rails
+        # and you would just hook into "touch_model_timestamps_unless" to add your database-specific instructions
+        # however, since we need to have "target." for the assignment, we also generate the CASE switch ourselves
+        def build_sql_for_recording_timestamps_when_updating(insert:)
+          insert.model.timestamp_attributes_for_update_in_model.filter_map do |column_name|
+            if insert.send(:touch_timestamp_attribute?, column_name)
+              "target.#{quote_column_name(column_name)}=CASE WHEN (#{insert.updatable_columns.map { |column| "(COALESCE(target.#{quote_column_name(column)}, 'NULL') = COALESCE(source.#{quote_column_name(column)}, 'NULL'))" }.join(" AND ")}) THEN target.#{quote_column_name(column_name)} ELSE #{high_precision_current_timestamp} END,"
+            end
+          end.join
+        end
+        private :build_sql_for_recording_timestamps_when_updating
       end
     end
   end