edit/commit Command (#262)

The main goal of this feature is to enable a command that will
1) Generate a parameterized command for each edit that is in the session
2) Execute that command against the server
3) Update the cached results of the table/view that's being edited with the committed changes (including computed/identity columns)

There's some secret sauce in here where I cheated around worrying about gaps in the updated results. This was accomplished by implementing an IComparable for row edit objects that ensures deletes are the *last* actions to occur and that they occur from the bottom of the list up (highest row ID to lowest). Thus, all other actions that are dependent on the row ID are performed first, then the largest row ID is deleted, then next largest, etc. Nevertheless, by the end of a commit the associated ResultSet is still the source of truth. It is expected that the results grid will need updating once changes are committed.

Also worth noting, although this pull request supports a "many edits, one commit" approach, it will work just fine for a "one edit, one commit" approach.

* WIP

* Adding basic commit support. Deletions work!

* Nailing down the commit logic, insert commits work!

* Updates work!

* Fixing bug in DbColumnWrapper IsReadOnly setting

* Comments

* ResultSet unit tests, fixing issue with seeking in mock writers

* Unit tests for RowCreate commands

* Unit tests for RowDelete

* RowUpdate unit tests

* Session and edit base tests

* Fixing broken unit tests

* Moving constants to constants file

* Addressing code review feedback

* Fixes from merge issues, string consts

* Removing ad-hoc code

* fixing as per @abist requests

* Fixing a couple more issues

src/Microsoft.SqlTools.ServiceLayer/EditData/UpdateManagement/CellUpdate.cs

@@ -4,9 +4,9 @@
 //
 
 using System;
-using System.Data.Common;
 using System.Globalization;
 using System.Text.RegularExpressions;
+using Microsoft.SqlTools.ServiceLayer.QueryExecution.Contracts;
 using Microsoft.SqlTools.Utility;
 
 namespace Microsoft.SqlTools.ServiceLayer.EditData.UpdateManagement
@@ -26,7 +26,7 @@ namespace Microsoft.SqlTools.ServiceLayer.EditData.UpdateManagement
         /// </summary>
         /// <param name="column">Column the cell will be under</param>
         /// <param name="valueAsString">The string from the client to convert to an object</param>
-        public CellUpdate(DbColumn column, string valueAsString)
+        public CellUpdate(DbColumnWrapper column, string valueAsString)
         {
             Validate.IsNotNull(nameof(column), column);
             Validate.IsNotNull(nameof(valueAsString), valueAsString);
@@ -89,7 +89,7 @@ namespace Microsoft.SqlTools.ServiceLayer.EditData.UpdateManagement
         /// <summary>
         /// The column that the cell will be placed in
         /// </summary>
-        public DbColumn Column { get; }
+        public DbColumnWrapper Column { get; }
 
         /// <summary>
         /// The object representation of the cell provided by the client

src/Microsoft.SqlTools.ServiceLayer/EditData/UpdateManagement/RowCreate.cs

@@ -5,10 +5,16 @@
 
 using System;
 using System.Collections.Generic;
+using System.Data;
+using System.Data.Common;
+using System.Data.SqlClient;
+using System.Linq;
+using System.Threading.Tasks;
 using Microsoft.SqlTools.ServiceLayer.EditData.Contracts;
 using Microsoft.SqlTools.ServiceLayer.QueryExecution;
 using Microsoft.SqlTools.ServiceLayer.QueryExecution.Contracts;
 using Microsoft.SqlTools.ServiceLayer.Utility;
+using Microsoft.SqlTools.Utility;
 
 namespace Microsoft.SqlTools.ServiceLayer.EditData.UpdateManagement
 {
@@ -17,7 +23,9 @@ namespace Microsoft.SqlTools.ServiceLayer.EditData.UpdateManagement
     /// </summary>
     public sealed class RowCreate : RowEditBase
     {
-        private const string InsertStatement = "INSERT INTO {0}({1}) VALUES ({2})";
+        private const string InsertStart = "INSERT INTO {0}({1})";
+        private const string InsertCompleteScript = "{0} VALUES ({1})";
+        private const string InsertCompleteOutput = "{0} OUTPUT {1} VALUES ({2})";
 
         private readonly CellUpdate[] newCells;
 
@@ -34,42 +42,121 @@ namespace Microsoft.SqlTools.ServiceLayer.EditData.UpdateManagement
         }
 
         /// <summary>
-        /// Generates the INSERT INTO statement that will apply the row creation
+        /// Sort ID for a RowCreate object. Setting to 1 ensures that these are the first changes 
+        /// to be committed
         /// </summary>
-        /// <returns>INSERT INTO statement</returns>
-        public override string GetScript()
-        {
-            List<string> columnNames = new List<string>();
-            List<string> columnValues = new List<string>();
+        protected override int SortId => 1;
 
-            // Build the column list and value list
+        #region Public Methods
+
+        /// <summary>
+        /// Applies the changes to the associated result set after successfully executing the
+        /// change on the database
+        /// </summary>
+        /// <param name="dataReader">
+        /// Reader returned from the execution of the command to insert a new row. Should contain
+        /// a single row that represents the newly added row.
+        /// </param>
+        public override Task ApplyChanges(DbDataReader dataReader)
+        {
+            Validate.IsNotNull(nameof(dataReader), dataReader);
+
+            return AssociatedResultSet.AddRow(dataReader);
+        }
+
+        /// <summary>
+        /// Generates a command that can be executed to insert a new row -- and return the newly
+        /// inserted row.
+        /// </summary>
+        /// <param name="connection">The connection the command should be associated with</param>
+        /// <returns>Command to insert the new row</returns>
+        public override DbCommand GetCommand(DbConnection connection)
+        {
+            Validate.IsNotNull(nameof(connection), connection);
+
+            // Process all the columns. Add the column to the output columns, add updateable
+            // columns to the input parameters
+            List<string> outColumns = new List<string>();
+            List<string> inColumns = new List<string>();
+            DbCommand command = connection.CreateCommand();
             for (int i = 0; i < AssociatedResultSet.Columns.Length; i++)
             {
                 DbColumnWrapper column = AssociatedResultSet.Columns[i];
                 CellUpdate cell = newCells[i];
 
-                // If the column is not updatable, then skip it
+                // Add the column to the output
+                outColumns.Add($"inserted.{SqlScriptFormatter.FormatIdentifier(column.ColumnName)}");
+
+                // Skip columns that cannot be updated
                 if (!column.IsUpdatable)
                 {
                     continue;
                 }
 
-                // If the cell doesn't have a value, but is updatable, don't try to create the script
+                // If we're missing a cell, then we cannot continue
                 if (cell == null)
                 {
                     throw new InvalidOperationException(SR.EditDataCreateScriptMissingValue);
                 }
 
-                // Add the column and the data to their respective lists
-                columnNames.Add(SqlScriptFormatter.FormatIdentifier(column.ColumnName));
-                columnValues.Add(SqlScriptFormatter.FormatValue(cell.Value, column));
+                // Create a parameter for the value and add it to the command
+                // Add the parameterization to the list and add it to the command
+                string paramName = $"@Value{RowId}{i}";
+                inColumns.Add(paramName);
+                SqlParameter param = new SqlParameter(paramName, cell.Column.SqlDbType)
+                {
+                    Value = cell.Value
+                };
+                command.Parameters.Add(param);
             }
+            string joinedInColumns = string.Join(", ", inColumns);
+            string joinedOutColumns = string.Join(", ", outColumns);
+            
+            // Get the start clause
+            string start = GetTableClause();
 
-            // Put together the components of the statement
-            string joinedColumnNames = string.Join(", ", columnNames);
-            string joinedColumnValues = string.Join(", ", columnValues);
-            return string.Format(InsertStatement, AssociatedObjectMetadata.EscapedMultipartName, joinedColumnNames,
-                joinedColumnValues);
+            // Put the whole #! together
+            command.CommandText = string.Format(InsertCompleteOutput, start, joinedOutColumns, joinedInColumns);
+            command.CommandType = CommandType.Text;
+                
+            return command;
+        }
+
+        /// <summary>
+        /// Generates the INSERT INTO statement that will apply the row creation
+        /// </summary>
+        /// <returns>INSERT INTO statement</returns>
+        public override string GetScript()
+        {
+            // Process all the cells, and generate the values
+            List<string> values = new List<string>();
+            for (int i = 0; i < AssociatedResultSet.Columns.Length; i++)
+            {
+                DbColumnWrapper column = AssociatedResultSet.Columns[i];
+                CellUpdate cell = newCells[i];
+
+                // Skip columns that cannot be updated
+                if (!column.IsUpdatable)
+                {
+                    continue;
+                }
+
+                // If we're missing a cell, then we cannot continue
+                if (cell == null)
+                {
+                    throw new InvalidOperationException(SR.EditDataCreateScriptMissingValue);
+                }
+
+                // Format the value and add it to the list
+                values.Add(SqlScriptFormatter.FormatValue(cell.Value, column));
+            }
+            string joinedValues = string.Join(", ", values);
+
+            // Get the start clause
+            string start = GetTableClause();
+
+            // Put the whole #! together
+            return string.Format(InsertCompleteScript, start, joinedValues);
         }
 
         /// <summary>
@@ -99,5 +186,19 @@ namespace Microsoft.SqlTools.ServiceLayer.EditData.UpdateManagement
             }; 
             return eucr;
         }
+
+        #endregion
+
+        private string GetTableClause()
+        {
+            // Get all the columns that will be provided
+            var inColumns = from c in AssociatedResultSet.Columns
+                            where c.IsUpdatable
+                            select SqlScriptFormatter.FormatIdentifier(c.ColumnName);
+
+            // Package it into a single INSERT statement starter
+            string inColumnsJoined = string.Join(", ", inColumns);
+            return string.Format(InsertStart, AssociatedObjectMetadata.EscapedMultipartName, inColumnsJoined);
+        }
     }
 }

src/Microsoft.SqlTools.ServiceLayer/EditData/UpdateManagement/RowDelete.cs

@@ -4,9 +4,12 @@
 //
 
 using System;
+using System.Data.Common;
 using System.Globalization;
+using System.Threading.Tasks;
 using Microsoft.SqlTools.ServiceLayer.EditData.Contracts;
 using Microsoft.SqlTools.ServiceLayer.QueryExecution;
+using Microsoft.SqlTools.Utility;
 
 namespace Microsoft.SqlTools.ServiceLayer.EditData.UpdateManagement
 {
@@ -29,15 +32,53 @@ namespace Microsoft.SqlTools.ServiceLayer.EditData.UpdateManagement
         {
         }
 
+        /// <summary>
+        /// Sort ID for a RowDelete object. Setting to 2 ensures that these are the LAST changes 
+        /// to be committed
+        /// </summary>
+        protected override int SortId => 2;
+
+        /// <summary>
+        /// Applies the changes to the associated result set after successfully executing the
+        /// change on the database
+        /// </summary>
+        /// <param name="dataReader">
+        /// Reader returned from the execution of the command to insert a new row. Should NOT
+        /// contain any rows.
+        /// </param>
+        public override Task ApplyChanges(DbDataReader dataReader)
+        {
+            // Take the result set and remove the row from it
+            AssociatedResultSet.RemoveRow(RowId);
+            return Task.FromResult(0);
+        }
+
+        /// <summary>
+        /// Generates a command for deleting the selected row
+        /// </summary>
+        /// <returns></returns>
+        public override DbCommand GetCommand(DbConnection connection)
+        {
+            Validate.IsNotNull(nameof(connection), connection);
+
+            // Return a SqlCommand with formatted with the parameters from the where clause
+            WhereClause where = GetWhereClause(true);
+            string commandText = GetCommandText(where.CommandText);
+
+            DbCommand command = connection.CreateCommand();
+            command.CommandText = commandText;
+            command.Parameters.AddRange(where.Parameters.ToArray());
+
+            return command;
+        }
+
         /// <summary>
         /// Generates a DELETE statement to delete this row
         /// </summary>
         /// <returns>String of the DELETE statement</returns>
         public override string GetScript()
         {
-            string formatString = AssociatedObjectMetadata.IsMemoryOptimized ? DeleteMemoryOptimizedStatement : DeleteStatement;
-            return string.Format(CultureInfo.InvariantCulture, formatString,
-                AssociatedObjectMetadata.EscapedMultipartName, GetWhereClause(false).CommandText);
+            return GetCommandText(GetWhereClause(false).CommandText);
         }
 
         /// <summary>
@@ -51,5 +92,23 @@ namespace Microsoft.SqlTools.ServiceLayer.EditData.UpdateManagement
         {
             throw new InvalidOperationException(SR.EditDataDeleteSetCell);
         }
+
+        protected override int CompareToSameType(RowEditBase rowEdit)
+        {
+            // We want to sort by row ID *IN REVERSE* to make sure we delete from the bottom first.
+            // If we delete from the top first, it will change IDs, making all subsequent deletes
+            // off by one or more!
+            return RowId.CompareTo(rowEdit.RowId) * -1;
+        }
+
+        private string GetCommandText(string whereText)
+        {
+            string formatString = AssociatedObjectMetadata.IsMemoryOptimized
+                ? DeleteMemoryOptimizedStatement
+                : DeleteStatement;
+
+            return string.Format(CultureInfo.InvariantCulture, formatString,
+                AssociatedObjectMetadata.EscapedMultipartName, whereText);
+        }
     }
 }

src/Microsoft.SqlTools.ServiceLayer/EditData/UpdateManagement/RowEdit.cs

@@ -8,6 +8,7 @@ using System.Collections.Generic;
 using System.Data.Common;
 using System.Data.SqlClient;
 using System.Linq;
+using System.Threading.Tasks;
 using Microsoft.SqlTools.ServiceLayer.EditData.Contracts;
 using Microsoft.SqlTools.ServiceLayer.QueryExecution;
 using Microsoft.SqlTools.ServiceLayer.QueryExecution.Contracts;
@@ -18,9 +19,10 @@ namespace Microsoft.SqlTools.ServiceLayer.EditData.UpdateManagement
     /// <summary>
     /// Base class for row edit operations. Provides basic information and helper functionality
     /// that all RowEdit implementations can use. Defines functionality that must be implemented
-    /// in all child classes.
+    /// in all child classes. Implements a custom IComparable to enable sorting by type of the edit
+    /// and then by an overrideable 
     /// </summary>
-    public abstract class RowEditBase
+    public abstract class RowEditBase : IComparable<RowEditBase>
     {
         /// <summary>
         /// Internal parameterless constructor, required for mocking
@@ -58,8 +60,31 @@ namespace Microsoft.SqlTools.ServiceLayer.EditData.UpdateManagement
         /// </summary>
         public IEditTableMetadata AssociatedObjectMetadata { get; }
 
+        /// <summary>
+        /// Sort ID for a row edit. Ensures that when a collection of RowEditBase objects are
+        /// sorted, the appropriate types are sorted to the top.
+        /// </summary>
+        protected abstract int SortId { get; }
+
         #endregion
 
+        #region Abstract Methods
+
+        /// <summary>
+        /// Applies the changes to the associated result set
+        /// </summary>
+        /// <param name="dataReader">
+        /// Data reader from execution of the command to commit the change to the db
+        /// </param>
+        public abstract Task ApplyChanges(DbDataReader dataReader);
+
+        /// <summary>
+        /// Gets a command that will commit the change to the db
+        /// </summary>
+        /// <param name="connection">The connection to associate the command to</param>
+        /// <returns>Command to commit the change to the db</returns>
+        public abstract DbCommand GetCommand(DbConnection connection);
+
         /// <summary>
         /// Converts the row edit into a SQL statement
         /// </summary>
@@ -74,6 +99,10 @@ namespace Microsoft.SqlTools.ServiceLayer.EditData.UpdateManagement
         /// <returns>The value of the cell after applying validation logic</returns>
         public abstract EditUpdateCellResult SetCell(int columnId, string newValue);
 
+        #endregion
+
+        #region Protected Helper Methods
+
         /// <summary>
         /// Performs validation of column ID and if column can be updated.
         /// </summary>
@@ -146,7 +175,11 @@ namespace Microsoft.SqlTools.ServiceLayer.EditData.UpdateManagement
                             //       we execute multiple row edits at once.
                             string paramName = $"@Param{RowId}{col.Ordinal}";
                             cellDataClause = $"= {paramName}";
-                            output.Parameters.Add(new SqlParameter(paramName, col.DbColumn.SqlDbType));
+                            SqlParameter parameter = new SqlParameter(paramName, col.DbColumn.SqlDbType)
+                            {
+                                Value = cellData.RawObject
+                            };
+                            output.Parameters.Add(parameter);
                         }
                         else
                         {
@@ -163,6 +196,66 @@ namespace Microsoft.SqlTools.ServiceLayer.EditData.UpdateManagement
             return output;
         }
 
+        #endregion
+
+        #region IComparable Implementation
+
+        /// <summary>
+        /// Compares a row edit against another row edit. If they are the same type, then we
+        /// compare using an overrideable "same type" comparer. If they are different types, they
+        /// are sorted by their sort indexes.
+        /// 
+        /// In general, RowCreate and RowUpdates are sorted to the top. RowDeletes are sorted last.
+        /// If there are ties, default behavior is to sort by row ID ascending.
+        /// </summary>
+        /// <param name="other">The other row edit to compare against</param>
+        /// <returns>
+        /// A positive value if this edit should go first, a negative value if the other edit
+        /// should go first. 0 is returned if there is a tie.
+        /// </returns>
+        public int CompareTo(RowEditBase other)
+        {
+            // If the other is null, this one will come out on top
+            if (other == null)
+            {
+                return 1;
+            }
+
+            // If types are the same, use the type's tiebreaking sorter
+            if (GetType() == other.GetType())
+            {
+                return CompareToSameType(other);
+            }
+
+            // If the type's sort index is the same, use our tiebreaking sorter
+            // If they are different, use that as the comparison
+            int sortIdComparison = SortId.CompareTo(other.SortId);
+            return sortIdComparison == 0
+                ? CompareByRowId(other)
+                : sortIdComparison;
+        }
+
+        /// <summary>
+        /// Default behavior for sorting if the two compared row edits are the same type. Sorts
+        /// by row ID ascending.
+        /// </summary>
+        /// <param name="rowEdit">The other row edit to compare against</param>
+        protected virtual int CompareToSameType(RowEditBase rowEdit)
+        {
+            return CompareByRowId(rowEdit);
+        }
+
+        /// <summary>
+        /// Compares two row edits by their row ID ascending.
+        /// </summary>
+        /// <param name="rowEdit">The other row edit to compare against</param>
+        private int CompareByRowId(RowEditBase rowEdit)
+        {
+            return RowId.CompareTo(rowEdit.RowId);
+        }
+
+        #endregion
+
         /// <summary>
         /// Represents a WHERE clause that can be used for identifying a row in a table.
         /// </summary>

src/Microsoft.SqlTools.ServiceLayer/EditData/UpdateManagement/RowUpdate.cs

@@ -5,12 +5,16 @@
 
 using System;
 using System.Collections.Generic;
-using System.Globalization;
+using System.Data;
+using System.Data.Common;
+using System.Data.SqlClient;
 using System.Linq;
+using System.Threading.Tasks;
 using Microsoft.SqlTools.ServiceLayer.EditData.Contracts;
 using Microsoft.SqlTools.ServiceLayer.QueryExecution;
 using Microsoft.SqlTools.ServiceLayer.QueryExecution.Contracts;
 using Microsoft.SqlTools.ServiceLayer.Utility;
+using Microsoft.SqlTools.Utility;
 
 namespace Microsoft.SqlTools.ServiceLayer.EditData.UpdateManagement
 {
@@ -19,8 +23,11 @@ namespace Microsoft.SqlTools.ServiceLayer.EditData.UpdateManagement
     /// </summary>
     public sealed class RowUpdate : RowEditBase
     {
-        private const string UpdateStatement = "UPDATE {0} SET {1} {2}";
-        private const string UpdateStatementMemoryOptimized = "UPDATE {0} WITH (SNAPSHOT) SET {1} {2}";
+        private const string UpdateScriptStart = @"UPDATE {0}";
+        private const string UpdateScriptStartMemOptimized = @"UPDATE {0} WITH (SNAPSHOT)";
+
+        private const string UpdateScript = @"{0} SET {1} {2}";
+        private const string UpdateScriptOutput = @"{0} SET {1} OUTPUT {2} {3}";
 
         private readonly Dictionary<int, CellUpdate> cellUpdates;
         private readonly IList<DbCellValue> associatedRow;
@@ -38,6 +45,73 @@ namespace Microsoft.SqlTools.ServiceLayer.EditData.UpdateManagement
             associatedRow = associatedResultSet.GetRow(rowId);
         }
 
+        /// <summary>
+        /// Sort order property. Sorts to same position as RowCreate
+        /// </summary>
+        protected override int SortId => 1;
+
+        #region Public Methods
+
+        /// <summary>
+        /// Applies the changes to the associated result set after successfully executing the
+        /// change on the database
+        /// </summary>
+        /// <param name="dataReader">
+        /// Reader returned from the execution of the command to update a row. Should contain
+        /// a single row that represents all the values of the row.
+        /// </param>
+        public override Task ApplyChanges(DbDataReader dataReader)
+        {
+            Validate.IsNotNull(nameof(dataReader), dataReader);
+            return AssociatedResultSet.UpdateRow(RowId, dataReader);
+        }
+
+        /// <summary>
+        /// Generates a command that can be executed to update a row -- and return the contents of
+        /// the updated row.
+        /// </summary>
+        /// <param name="connection">The connection the command should be associated with</param>
+        /// <returns>Command to update the row</returns>
+        public override DbCommand GetCommand(DbConnection connection)
+        {
+            Validate.IsNotNull(nameof(connection), connection);
+            DbCommand command = connection.CreateCommand();
+
+            // Build the "SET" portion of the statement
+            List<string> setComponents = new List<string>();
+            foreach (var updateElement in cellUpdates)
+            {
+                string formattedColumnName = SqlScriptFormatter.FormatIdentifier(updateElement.Value.Column.ColumnName);
+                string paramName = $"@Value{RowId}{updateElement.Key}";
+                setComponents.Add($"{formattedColumnName} = {paramName}");
+                SqlParameter parameter = new SqlParameter(paramName, updateElement.Value.Column.SqlDbType)
+                {
+                    Value = updateElement.Value.Value
+                };
+                command.Parameters.Add(parameter);
+            }
+            string setComponentsJoined = string.Join(", ", setComponents);
+
+            // Build the "OUTPUT" portion of the statement
+            var outColumns = from c in AssociatedResultSet.Columns
+                             let formatted = SqlScriptFormatter.FormatIdentifier(c.ColumnName)
+                             select $"inserted.{formatted}";
+            string outColumnsJoined = string.Join(", ", outColumns);
+
+            // Get the where clause
+            WhereClause where = GetWhereClause(true);
+            command.Parameters.AddRange(where.Parameters.ToArray());
+
+            // Get the start of the statement
+            string statementStart = GetStatementStart();
+
+            // Put the whole #! together
+            command.CommandText = string.Format(UpdateScriptOutput, statementStart, setComponentsJoined,
+                outColumnsJoined, where.CommandText);
+            command.CommandType = CommandType.Text;
+            return command;
+        }
+
         /// <summary>
         /// Constructs an update statement to change the associated row.
         /// </summary>
@@ -45,7 +119,7 @@ namespace Microsoft.SqlTools.ServiceLayer.EditData.UpdateManagement
         public override string GetScript()
         {
             // Build the "SET" portion of the statement
-            IEnumerable<string> setComponents = cellUpdates.Values.Select(cellUpdate =>
+            var setComponents = cellUpdates.Values.Select(cellUpdate =>
             {
                 string formattedColumnName = SqlScriptFormatter.FormatIdentifier(cellUpdate.Column.ColumnName);
                 string formattedValue = SqlScriptFormatter.FormatValue(cellUpdate.Value, cellUpdate.Column);
@@ -56,10 +130,11 @@ namespace Microsoft.SqlTools.ServiceLayer.EditData.UpdateManagement
             // Get the where clause
             string whereClause = GetWhereClause(false).CommandText;
 
-            // Put it all together
-            string formatString = AssociatedObjectMetadata.IsMemoryOptimized ? UpdateStatementMemoryOptimized : UpdateStatement;
-            return string.Format(CultureInfo.InvariantCulture, formatString,
-                AssociatedObjectMetadata.EscapedMultipartName, setClause, whereClause);
+            // Get the start of the statement
+            string statementStart = GetStatementStart();
+
+            // Put the whole #! together
+            return string.Format(UpdateScript, statementStart, setClause, whereClause);
         }
 
         /// <summary>
@@ -106,5 +181,16 @@ namespace Microsoft.SqlTools.ServiceLayer.EditData.UpdateManagement
                 IsRevert = false            // If we're in this branch, it is not a revert
             };
         }
+
+        #endregion
+
+        private string GetStatementStart()
+        {
+            string formatString = AssociatedObjectMetadata.IsMemoryOptimized
+                ? UpdateScriptStartMemOptimized
+                : UpdateScriptStart;
+
+            return string.Format(formatString, AssociatedObjectMetadata.EscapedMultipartName);
+        }
     }
 }