activerecord-sqlserver-adapter 8.0.10 → 8.1.0

data/lib/active_record/connection_adapters/sqlserver/database_statements.rb

@@ -19,47 +19,57 @@ module ActiveRecord
             sql = sp_executesql_sql(sql, types, params, notification_payload[:name])
           end
 
-          result = if id_insert_table_name = query_requires_identity_insert?(sql)
-                     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
+          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
 
           verified!
+          notification_payload[:affected_rows] = affected_rows
           notification_payload[:row_count] = result.count
           result
         end
 
-        def cast_result(raw_result)
-          if raw_result.columns.empty?
-            ActiveRecord::Result.empty
-          else
-            ActiveRecord::Result.new(raw_result.columns, raw_result.rows)
-          end
+        # Method `perform_query` already returns an `ActiveRecord::Result` so we have nothing to cast here. This is
+        # different to the MySQL/PostgreSQL adapters where the raw result is converted to `ActiveRecord::Result` in
+        # `cast_result`.
+        def cast_result(result)
+          result
         end
 
+        # Returns the affected rows from results.
         def affected_rows(raw_result)
-          column_name = lowercase_schema_reflection ? 'affectedrows' : 'AffectedRows'
-          raw_result.first[column_name]
+          column_name = lowercase_schema_reflection ? "affectedrows" : "AffectedRows"
+          raw_result&.first&.fetch(column_name, nil)
+        end
+
+        # Returns the affected rows from results or handle.
+        def affected_rows_from_results_or_handle(raw_result, handle)
+          affected_rows(raw_result) || handle.affected_rows
         end
 
         def internal_exec_sql_query(sql, conn)
           handle = internal_raw_execute(sql, conn)
-          handle_to_names_and_values(handle, ar_result: true)
+          results = handle_to_names_and_values(handle, ar_result: true)
+
+          [results, affected_rows_from_results_or_handle(results, handle)]
         ensure
           finish_statement_handle(handle)
         end
 
         def exec_delete(sql, name = nil, binds = [])
           sql = sql.dup << "; SELECT @@ROWCOUNT AS AffectedRows"
-          super(sql, name, binds)
+          super
         end
 
         def exec_update(sql, name = nil, binds = [])
           sql = sql.dup << "; SELECT @@ROWCOUNT AS AffectedRows"
-          super(sql, name, binds)
+          super
         end
 
         def begin_db_transaction
@@ -150,7 +160,6 @@ module ActiveRecord
           end
         end
 
-
         def build_sql_for_merge_insert(insert:, insert_all:, columns_with_uniqueness_constraints:) # :nodoc:
           insert_all.inserts.reverse! if insert.update_duplicates?
 
@@ -160,7 +169,7 @@ module ActiveRecord
               SELECT *
               FROM (
                 SELECT #{insert.send(:columns_list)}, #{partition_by_columns_with_uniqueness_constraints(columns_with_uniqueness_constraints:)}
-                FROM (#{insert.values_list})
+                FROM (#{merge_insert_values_list(insert:, insert_all:)})
                 AS t1 (#{insert.send(:columns_list)})
               ) AS ranked_source
               WHERE #{is_first_record_across_all_uniqueness_constraints(columns_with_uniqueness_constraints:)}
@@ -189,21 +198,50 @@ module ActiveRecord
           sql
         end
 
+        # For `nil` identity columns we need to ensure that the values do not match so that they are all inserted.
+        # Method is a combination of `ActiveRecord::InsertAll#values_list` and `ActiveRecord::ConnectionAdapters::SQLServer::DatabaseStatements#default_insert_value`.
+        def merge_insert_values_list(insert:, insert_all:)
+          connection = insert.send(:connection)
+          identity_index = 0
+
+          types = insert.send(:extract_types_for, insert.keys_including_timestamps)
+
+          values_list = insert_all.map_key_with_value do |key, value|
+            if Arel::Nodes::SqlLiteral === value
+              value
+            elsif insert.primary_keys.include?(key) && value.nil?
+              column = insert.model.columns_hash[key]
+
+              if column.is_identity?
+                identity_index += 1
+                table_name = quote(quote_table_name(column.table_name))
+                Arel.sql("IDENT_CURRENT(#{table_name}) + (IDENT_INCR(#{table_name}) * #{identity_index})")
+              else
+                connection.default_insert_value(column)
+              end
+            else
+              ActiveModel::Type::SerializeCastValue.serialize(type = types[key], type.cast(value))
+            end
+          end
+
+          connection.visitor.compile(Arel::Nodes::ValuesList.new(values_list))
+        end
+
         # === SQLServer Specific ======================================== #
 
         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|
             with_raw_connection do |conn|
               result = internal_raw_execute(sql, conn)
               verified!
-              options = { as: :hash, cache_rows: true, timezone: ActiveRecord.default_timezone || :utc }
+              options = {as: :hash, cache_rows: true, timezone: ActiveRecord.default_timezone || :utc}
 
               result.each(options) do |row|
                 r = row.with_indifferent_access
@@ -240,7 +278,7 @@ module ActiveRecord
 
           rows = select_rows("DBCC USEROPTIONS WITH NO_INFOMSGS", "SCHEMA")
           rows = rows.first if rows.size == 2 && rows.last.empty?
-          rows.reduce(HashWithIndifferentAccess.new) do |values, row|
+          rows.each_with_object(HashWithIndifferentAccess.new) do |row, values|
             if row.instance_of? Hash
               set_option = row.values[0].gsub(/\s+/, "_")
               user_value = row.values[1]
@@ -249,7 +287,6 @@ module ActiveRecord
               user_value = row[1]
             end
             values[set_option] = user_value
-            values
           end
         end
 
@@ -303,35 +340,35 @@ module ActiveRecord
           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
-                      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
+            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
 
           [sql, binds]
         end
@@ -339,9 +376,9 @@ module ActiveRecord
         # === SQLServer Specific ======================================== #
 
         def set_identity_insert(table_name, conn, enable)
-          internal_raw_execute("SET IDENTITY_INSERT #{table_name} #{enable ? 'ON' : 'OFF'}", conn , perform_do: true)
-        rescue Exception
-          raise ActiveRecordError, "IDENTITY_INSERT could not be turned #{enable ? 'ON' : 'OFF'} for table #{table_name}"
+          internal_raw_execute("SET IDENTITY_INSERT #{table_name} #{enable ? "ON" : "OFF"}", conn, perform_do: true)
+        rescue
+          raise ActiveRecordError, "IDENTITY_INSERT could not be turned #{enable ? "ON" : "OFF"} for table #{table_name}"
         end
 
         # === SQLServer Specific (Executing) ============================ #
@@ -359,7 +396,7 @@ module ActiveRecord
 
         def sp_executesql_sql_type(attr)
           if attr.respond_to?(:type)
-            type = attr.type.is_a?(ActiveRecord::Normalization::NormalizedValueType) ? attr.type.cast_type : attr.type
+            type = attr.type.is_a?(ActiveModel::Attributes::Normalization::NormalizedValueType) ? attr.type.cast_type : attr.type
             type = type.subtype if type.serialized?
 
             return type.sqlserver_type if type.respond_to?(:sqlserver_type)
@@ -372,9 +409,9 @@ module ActiveRecord
           value = active_model_attribute?(attr) ? attr.value_for_database : attr
 
           if value.is_a?(Numeric)
-            value > 2_147_483_647 ? "bigint".freeze : "int".freeze
+            (value > 2_147_483_647) ? "bigint" : "int"
           else
-            "nvarchar(max)".freeze
+            "nvarchar(max)"
           end
         end
 
@@ -474,26 +511,24 @@ module ActiveRecord
           end
           results = handle.each(query_options)
 
-          columns = handle.fields
-          # If query returns multiple result sets, only return the columns of the last one.
-          columns = columns.last if columns.any? && columns.all? { |e| e.is_a?(Array) }
-          columns = columns.map(&:downcase) if lowercase_schema_reflection
+          if options[:ar_result]
+            columns = handle.fields
+            columns = columns.last if columns.any? && columns.all? { |e| e.is_a?(Array) } # If query returns multiple result sets, only return the columns of the last one.
+            columns = columns.map(&:downcase) if lowercase_schema_reflection
 
-          options[:ar_result] ? ActiveRecord::Result.new(columns, results) : results
+            ActiveRecord::Result.new(columns, results, affected_rows: handle.affected_rows)
+          else
+            results
+          end
         end
 
         def finish_statement_handle(handle)
-          handle.cancel if handle
+          handle&.cancel
           handle
         end
 
-        # TinyTDS returns false instead of raising an exception if connection fails.
-        # Getting around this by raising an exception ourselves while PR
-        # https://github.com/rails-sqlserver/tiny_tds/pull/469 is not released.
         def internal_raw_execute(sql, raw_connection, perform_do: false)
           result = raw_connection.execute(sql)
-          raise TinyTds::Error, "failed to execute statement" if result.is_a?(FalseClass)
-
           perform_do ? result.do : result
         end
 
@@ -502,16 +537,16 @@ module ActiveRecord
           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

data/lib/active_record/connection_adapters/sqlserver/database_tasks.rb

@@ -32,20 +32,19 @@ module ActiveRecord
         private
 
         def create_database_options(options = {})
-          keys  = [:collate]
+          keys = [:collate]
           copts = @connection_parameters
-          options = {
+          {
             collate: copts[:collation]
           }.merge(options.symbolize_keys).select { |_, v|
             v.present?
           }.slice(*keys).map { |k, v|
             "#{k.to_s.upcase} #{v}"
           }.join(" ")
-          options
         end
 
         def create_database_edition_options(options = {})
-          keys  = [:maxsize, :edition, :service_objective]
+          keys = [:maxsize, :edition, :service_objective]
           copts = @connection_parameters
           edition_options = {
             maxsize: copts[:azure_maxsize],

data/lib/active_record/connection_adapters/sqlserver/quoting.rb

@@ -55,11 +55,11 @@ module ActiveRecord
           cast_type = lookup_cast_type(sql_type)
 
           simple_type = SqlTypeMetadata.new(
-            sql_type:  sql_type,
-            type:      cast_type.type,
-            limit:     cast_type.limit,
+            sql_type: sql_type,
+            type: cast_type.type,
+            limit: cast_type.limit,
             precision: cast_type.precision,
-            scale:     cast_type.scale
+            scale: cast_type.scale
           )
 
           SQLServer::TypeMetadata.new(simple_type, **sqlserver_options)
@@ -79,7 +79,7 @@ module ActiveRecord
 
         def quote_default_expression(value, column)
           cast_type = lookup_cast_type(column.sql_type)
-          if cast_type.type == :uuid && value.is_a?(String) && value.include?('()')
+          if cast_type.type == :uuid && value.is_a?(String) && value.include?("()")
             value
           else
             super
@@ -87,7 +87,7 @@ module ActiveRecord
         end
 
         def quoted_true
-          '1'
+          "1"
         end
 
         def unquoted_true
@@ -95,7 +95,7 @@ module ActiveRecord
         end
 
         def quoted_false
-          '0'
+          "0"
         end
 
         def unquoted_false

data/lib/active_record/connection_adapters/sqlserver/schema_creation.rb

@@ -6,10 +6,18 @@ module ActiveRecord
       class SchemaCreation < SchemaCreation
         private
 
+        delegate :quoted_include_columns_for_index, to: :@conn
+
         def supports_index_using?
           false
         end
 
+        def visit_ColumnDefinition(o)
+          column_sql = super
+          column_sql = column_sql.sub(" #{o.sql_type}", "") if o.options[:as].present?
+          column_sql
+        end
+
         def visit_TableDefinition(o)
           if_not_exists = o.if_not_exists
 
@@ -44,25 +52,29 @@ module ActiveRecord
           sql << "INDEX"
           sql << "#{quote_column_name(index.name)} ON #{quote_table_name(index.table)}"
           sql << "(#{quoted_columns(index)})"
+          sql << "INCLUDE (#{quoted_include_columns(index.include)})" if supports_index_include? && index.include
           sql << "WHERE #{index.where}" if index.where
 
           sql.join(" ")
         end
 
+        def quoted_include_columns(o)
+          (String === o) ? o : quoted_include_columns_for_index(o)
+        end
+
         def add_column_options!(sql, options)
-          sql << " DEFAULT #{quote_default_expression(options[:default], options[:column])}" if options_include_default?(options)
-          if options[:collation].present?
-            sql << " COLLATE #{options[:collation]}"
-          end
-          if options[:null] == false
-            sql << " NOT NULL"
-          end
-          if options[:is_identity] == true
-            sql << " IDENTITY(1,1)"
-          end
-          if options[:primary_key] == true
-            sql << " PRIMARY KEY"
+          sql << " DEFAULT #{quote_default_expression_for_column_definition(options[:default], options[:column])}" if options_include_default?(options)
+
+          sql << " COLLATE #{options[:collation]}" if options[:collation].present?
+          sql << " NOT NULL" if options[:null] == false
+          sql << " IDENTITY(1,1)" if options[:is_identity] == true
+          sql << " PRIMARY KEY" if options[:primary_key] == true
+
+          if (as = options[:as])
+            sql << " AS #{as}"
+            sql << " PERSISTED" if options[:stored]
           end
+
           sql
         end
 

data/lib/active_record/connection_adapters/sqlserver/schema_dumper.rb

@@ -4,22 +4,31 @@ module ActiveRecord
   module ConnectionAdapters
     module SQLServer
       class SchemaDumper < ConnectionAdapters::SchemaDumper
-        SQLSEVER_NO_LIMIT_TYPES = [
-          "text",
-          "ntext",
-          "varchar(max)",
-          "nvarchar(max)",
-          "varbinary(max)"
-        ].freeze
+        SQLSERVER_NO_LIMIT_TYPES = %w[text ntext varchar(max) nvarchar(max) varbinary(max)].freeze
 
         private
 
+        def prepare_column_options(column)
+          spec = super
+
+          if @connection.supports_virtual_columns? && column.virtual?
+            spec[:as] = extract_expression_for_virtual_column(column)
+            spec[:stored] = column.virtual_stored?
+          end
+
+          spec
+        end
+
+        def extract_expression_for_virtual_column(column)
+          column.default_function.inspect
+        end
+
         def explicit_primary_key_default?(column)
           column.type == :integer && !column.is_identity?
         end
 
         def schema_limit(column)
-          return if SQLSEVER_NO_LIMIT_TYPES.include?(column.sql_type)
+          return if SQLSERVER_NO_LIMIT_TYPES.include?(column.sql_type)
 
           super
         end