Edit Data Service (#241)

This is a very large change. I'll try to outline what's going on.

1. This adds the **EditDataService** which manages editing **Sessions**.
    1. Each session has a **ResultSet** (from the QueryExecutionService) which has the rows of the table and basic metadata about the columns 
    2. Each session also has an **IEditTableMetadata** implementation which is derived from SMO metadata which provides more in-depth and trustworthy data about the table than SqlClient alone can.
    3. Each session holds a list of **RowEditBase** abstract class implementations
        1. **RowUpdate** - Update cells in a row (generates `UPDATE` statement)
        2. **RowDelete** - Delete an entire row (generates `DELETE` statement)
        3. **RowCreate** - Add a new row (generates `INSERT INTO` statement)
    4. Row edits have a collection of **CellUpdates** that hold updates for individual cells (except for RowDelete)
        1. Cell updates are generated from text
     5. RowEditBase offers some baseline functionality
        1. Generation of `WHERE` clauses (which can be parameterized)
        2. Validation of whether a column can be updated
2. New API Actions
    1. edit/initialize - Queries for the contents of a table/view, builds SMO metadata, sets up a session
    2. edit/createRow - Adds a new RowCreate to the Session
    3. edit/deleteRow - Adds a new RowDelete to the Session
    4. edit/updateCell - Adds a CellUpdate to a RowCreate or RowUpdate in the Session
    5. edit/revertRow - Removes a RowCreate, RowDelete, or RowUpdate from the Session
    6. edit/script - Generates a script for the changes in the Session and stores to disk
    7. edit/dispose - Removes a Session and releases the query
3. Smaller updates (unit test mock improvements, tweaks to query execution service)

**There are more updates planned -- this is just to get eyeballs on the main body of code**

* Initial stubs for edit data service

* Stubbing out update management code

* Adding rudimentary dispose request

* More stubbing out of update row code

* Adding complete edit command contracts, stubbing out request handlers

* Adding basic implementation of get script

* More in progress work to implement base of row edits

* More in progress work to implement base of row edits

* Adding string => object conversion logic and various cleanup

* Adding a formatter for using values in scripts

* Splitting IMessageSender into IEventSender and IRequestSender

* Adding inter-service method for executing queries

* Adding inter-service method for disposing of a query

* Changing edit contract to include the object to edit

* Fully fleshing out edit session initialization

* Generation of delete scripts is working

* Adding scripter for update statements

* Adding scripting functionality for INSERT statements

* Insert, Update, and Delete all working with SMO metadata

* Polishing for SqlScriptFormatter

* Unit tests and reworked byte[] conversion

* Replacing the awful and inflexible Dictionary<string, string>[][] with a much better test data set class

* Fixing syntax error in generated UPDATE statements

* Adding unit tests for RowCreate

* Adding tests for the row edit base class

* Adding row delete tests

* Adding RowUpdate tests, validation for number of key columns

* Adding tests for the unit class

* Adding get script tests for the session

* Service integration tests, except initialization tests

* Service integration tests, except initialization tests

* Adding messages to sr.strings

* Adding messages to sr.strings

* Fixing broken unit tests

* Adding factory pattern for SMO metadata provider

* Copyright and other comments

* Addressing first round of comments

* Refactoring EditDataService to have a single method for handling
session-dependent operations
* Refactoring Edit Data contracts to inherit from a Session and Row
operation params base class
* Copyright additions
* Small tweak to strings
* Updated unit tests to test the refactors

* More revisions as per pull request comments

src/Microsoft.SqlTools.ServiceLayer/EditData/Contracts/EditCreateRowRequest.cs

@@ -0,0 +1,35 @@
+//
+// Copyright (c) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+//
+
+using Microsoft.SqlTools.ServiceLayer.Hosting.Protocol.Contracts;
+
+namespace Microsoft.SqlTools.ServiceLayer.EditData.Contracts
+{
+    /// <summary>
+    /// Parameters for the update cell request
+    /// </summary>
+    public class EditCreateRowParams : SessionOperationParams
+    {
+    }
+
+    /// <summary>
+    /// Parameters to return upon successful addition of a row to the edit session
+    /// </summary>
+    public class EditCreateRowResult
+    {
+        /// <summary>
+        /// The internal ID of the newly created row
+        /// </summary>
+        public long NewRowId { get; set; }
+    }
+
+    public class EditCreateRowRequest
+    {
+        public static readonly
+            RequestType<EditCreateRowParams, EditCreateRowResult> Type =
+            RequestType<EditCreateRowParams, EditCreateRowResult>.Create("edit/createRow");
+
+    }
+}

src/Microsoft.SqlTools.ServiceLayer/EditData/Contracts/EditDeleteRowRequest.cs

@@ -0,0 +1,30 @@
+//
+// Copyright (c) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+//
+
+using Microsoft.SqlTools.ServiceLayer.Hosting.Protocol.Contracts;
+
+namespace Microsoft.SqlTools.ServiceLayer.EditData.Contracts
+{
+    /// <summary>
+    /// Parameters for identifying a row to mark for deletion
+    /// </summary>
+    public class EditDeleteRowParams : RowOperationParams
+    {
+    }
+
+    /// <summary>
+    /// Parameters to return upon successfully adding row delete to update cache
+    /// </summary>
+    public class EditDeleteRowResult
+    {
+    }
+
+    public class EditDeleteRowRequest
+    {
+        public static readonly
+            RequestType<EditDeleteRowParams, EditDeleteRowResult> Type =
+            RequestType<EditDeleteRowParams, EditDeleteRowResult>.Create("edit/deleteRow");
+    }
+}

src/Microsoft.SqlTools.ServiceLayer/EditData/Contracts/EditDisposeRequest.cs

@@ -0,0 +1,28 @@
+//
+// Copyright (c) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+//
+
+using Microsoft.SqlTools.ServiceLayer.Hosting.Protocol.Contracts;
+
+namespace Microsoft.SqlTools.ServiceLayer.EditData.Contracts
+{
+    /// <summary>
+    /// Parameters of the edit session dispose request
+    /// </summary>
+    public class EditDisposeParams : SessionOperationParams
+    {
+    }
+
+    /// <summary>
+    /// Object to return upon successful disposal of an edit session
+    /// </summary>
+    public class EditDisposeResult { }
+
+    public class EditDisposeRequest
+    {
+        public static readonly
+            RequestType<EditDisposeParams, EditDisposeResult> Type =
+            RequestType<EditDisposeParams, EditDisposeResult>.Create("edit/dispose");
+    }
+}

src/Microsoft.SqlTools.ServiceLayer/EditData/Contracts/EditInitializeRequest.cs

@@ -0,0 +1,42 @@
+//
+// Copyright (c) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+//
+
+using Microsoft.SqlTools.ServiceLayer.Hosting.Protocol.Contracts;
+
+namespace Microsoft.SqlTools.ServiceLayer.EditData.Contracts
+{
+    /// <summary>
+    /// Parameters of the edit session initialize request
+    /// </summary>
+    public class EditInitializeParams : SessionOperationParams
+    {
+        /// <summary>
+        /// The object to use for generating an edit script
+        /// </summary>
+        public string ObjectName { get; set; }
+
+        /// <summary>
+        /// The type of the object to use for generating an edit script
+        /// </summary>
+        public string ObjectType { get; set; }
+    }
+
+    /// <summary>
+    /// Object to return upon successful completion of an edit session initialize request
+    /// </summary>
+    /// <remarks>
+    /// Empty for now, since there isn't anything special to return on success
+    /// </remarks>
+    public class EditInitializeResult
+    {
+    }
+
+    public class EditInitializeRequest
+    {
+        public static readonly 
+            RequestType<EditInitializeParams, EditInitializeResult> Type =
+            RequestType<EditInitializeParams, EditInitializeResult>.Create("edit/initialize");
+    }
+}

src/Microsoft.SqlTools.ServiceLayer/EditData/Contracts/EditRevertRowRequest.cs

@@ -0,0 +1,30 @@
+//
+// Copyright (c) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+//
+
+using Microsoft.SqlTools.ServiceLayer.Hosting.Protocol.Contracts;
+
+namespace Microsoft.SqlTools.ServiceLayer.EditData.Contracts
+{
+    /// <summary>
+    /// Parameters for the revert row request
+    /// </summary>
+    public class EditRevertRowParams : RowOperationParams
+    {
+    }
+
+    /// <summary>
+    /// Parameters to return upon successful revert of a row
+    /// </summary>
+    public class EditRevertRowResult
+    {
+    }
+
+    public class EditRevertRowRequest
+    {
+        public static readonly
+            RequestType<EditRevertRowParams, EditRevertRowResult> Type =
+            RequestType<EditRevertRowParams, EditRevertRowResult>.Create("edit/revertRow");
+    }
+}

src/Microsoft.SqlTools.ServiceLayer/EditData/Contracts/EditSessionReadyEvent.cs

@@ -0,0 +1,29 @@
+//
+// Copyright (c) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+//
+
+using Microsoft.SqlTools.ServiceLayer.Hosting.Protocol.Contracts;
+
+namespace Microsoft.SqlTools.ServiceLayer.EditData.Contracts
+{
+    public class EditSessionReadyParams
+    {
+        /// <summary>
+        /// URI for the editor
+        /// </summary>
+        public string OwnerUri { get; set; }
+
+        /// <summary>
+        /// Whether or not the session is ready
+        /// </summary>
+        public bool Success { get; set; }
+    }
+
+    public class EditSessionReadyEvent
+    {
+        public static readonly
+            EventType<EditSessionReadyParams> Type =
+            EventType<EditSessionReadyParams>.Create("edit/sessionReady");
+    }
+}

src/Microsoft.SqlTools.ServiceLayer/EditData/Contracts/EditUpdateCellRequest.cs

@@ -0,0 +1,62 @@
+//
+// Copyright (c) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+//
+
+using Microsoft.SqlTools.ServiceLayer.Hosting.Protocol.Contracts;
+
+namespace Microsoft.SqlTools.ServiceLayer.EditData.Contracts
+{
+    /// <summary>
+    /// Parameters for the update cell request
+    /// </summary>
+    public class EditUpdateCellParams : RowOperationParams
+    {
+        /// <summary>
+        /// Internal ID of the column to update
+        /// </summary>
+        public int ColumnId { get; set; }
+
+        /// <summary>
+        /// String representation of the value to assign to the cell
+        /// </summary>
+        public string NewValue { get; set; }
+    }
+
+    /// <summary>
+    /// Parameters to return upon successful update of the cell
+    /// </summary>
+    public class EditUpdateCellResult
+    {
+        /// <summary>
+        /// Whether or not the cell value was modified from the provided string.
+        /// If <c>true</c>, the client should replace the display value of the cell with the value
+        /// in <see cref="NewValue"/>
+        /// </summary>
+        public bool HasCorrections { get; set; }
+
+        /// <summary>
+        /// Whether or not the cell was reverted with the change.
+        /// If <c>true</c>, the client should unmark the cell as having an update and replace the
+        /// display value of the cell with the value in <see cref="NewValue"/>
+        /// </summary>
+        public bool IsRevert { get; set; }
+
+        /// <summary>
+        /// Whether or not the new value of the cell is null
+        /// </summary>
+        public bool IsNull { get; set; }
+
+        /// <summary>
+        /// The new string value of the cell
+        /// </summary>
+        public string NewValue { get; set; }
+    }
+
+    public class EditUpdateCellRequest
+    {
+        public static readonly
+            RequestType<EditUpdateCellParams, EditUpdateCellResult> Type =
+            RequestType<EditUpdateCellParams, EditUpdateCellResult>.Create("edit/updateCell");
+    }
+}

src/Microsoft.SqlTools.ServiceLayer/EditData/Contracts/RowOperationParams.cs

@@ -0,0 +1,18 @@
+//
+// Copyright (c) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+//
+
+namespace Microsoft.SqlTools.ServiceLayer.EditData.Contracts
+{
+    /// <summary>
+    /// Abstract class for parameters that require an OwnerUri and a RowId
+    /// </summary>
+    public abstract class RowOperationParams : SessionOperationParams
+    {
+        /// <summary>
+        /// Internal ID of the row to revert
+        /// </summary>
+        public long RowId { get; set; }
+    }
+}

src/Microsoft.SqlTools.ServiceLayer/EditData/Contracts/SessionOperationParams.cs

@@ -0,0 +1,18 @@
+//
+// Copyright (c) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+//
+
+namespace Microsoft.SqlTools.ServiceLayer.EditData.Contracts
+{
+    /// <summary>
+    /// Abstract class for parameters that require an OwnerUri
+    /// </summary>
+    public abstract class SessionOperationParams
+    {
+        /// <summary>
+        /// Owner URI for the session to add new row to
+        /// </summary>
+        public string OwnerUri { get; set; }
+    }
+}

src/Microsoft.SqlTools.ServiceLayer/EditData/EditColumnWrapper.cs

@@ -0,0 +1,41 @@
+//
+// Copyright (c) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+//
+
+using Microsoft.SqlTools.ServiceLayer.QueryExecution.Contracts;
+
+namespace Microsoft.SqlTools.ServiceLayer.EditData
+{
+    /// <summary>
+    /// Small class that stores information needed by the edit data service to properly process
+    /// edits into scripts.
+    /// </summary>
+    public class EditColumnWrapper
+    {
+        /// <summary>
+        /// The DB column
+        /// </summary>
+        public DbColumnWrapper DbColumn { get; set; }
+
+        /// <summary>
+        /// Escaped identifier for the name of the column
+        /// </summary>
+        public string EscapedName { get; set; }
+
+        /// <summary>
+        /// Whether or not the column is used in a key to uniquely identify a row
+        /// </summary>
+        public bool IsKey { get; set; }
+
+        /// <summary>
+        /// Whether or not the column can be trusted for uniqueness
+        /// </summary>
+        public bool IsTrustworthyForUniqueness { get; set; }
+
+        /// <summary>
+        /// The ordinal ID of the column
+        /// </summary>
+        public int Ordinal { get; set; }
+    }
+}

src/Microsoft.SqlTools.ServiceLayer/EditData/EditDataService.cs

@@ -0,0 +1,286 @@
+//
+// Copyright (c) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+//
+
+using System;
+using System.Collections.Concurrent;
+using System.Data.Common;
+using System.Threading.Tasks;
+using Microsoft.SqlTools.ServiceLayer.Connection;
+using Microsoft.SqlTools.ServiceLayer.EditData.Contracts;
+using Microsoft.SqlTools.ServiceLayer.Hosting;
+using Microsoft.SqlTools.ServiceLayer.Hosting.Protocol;
+using Microsoft.SqlTools.ServiceLayer.QueryExecution;
+using Microsoft.SqlTools.ServiceLayer.QueryExecution.Contracts.ExecuteRequests;
+using Microsoft.SqlTools.ServiceLayer.Utility;
+using ConnectionType = Microsoft.SqlTools.ServiceLayer.Connection.ConnectionType;
+
+namespace Microsoft.SqlTools.ServiceLayer.EditData
+{
+    /// <summary>
+    /// Service that handles edit data scenarios
+    /// </summary>
+    public class EditDataService
+    {
+        #region Singleton Instance Implementation
+
+        private static readonly Lazy<EditDataService> LazyInstance = new Lazy<EditDataService>(() => new EditDataService());
+
+        public static EditDataService Instance => LazyInstance.Value;
+
+        private EditDataService()
+        {
+            queryExecutionService = QueryExecutionService.Instance;
+            connectionService = ConnectionService.Instance;
+            metadataFactory = new SmoEditMetadataFactory();
+        }
+
+        internal EditDataService(QueryExecutionService qes, ConnectionService cs, IEditMetadataFactory factory)
+        {
+            queryExecutionService = qes;
+            connectionService = cs;
+            metadataFactory = factory;
+        }
+
+        #endregion
+
+        #region Member Variables 
+
+        private readonly ConnectionService connectionService;
+
+        private readonly IEditMetadataFactory metadataFactory;
+
+        private readonly QueryExecutionService queryExecutionService;
+
+        private readonly Lazy<ConcurrentDictionary<string, Session>> editSessions = new Lazy<ConcurrentDictionary<string, Session>>(
+            () => new ConcurrentDictionary<string, Session>());
+
+        #endregion
+
+        #region Properties
+
+        /// <summary>
+        /// Dictionary mapping OwnerURIs to active sessions
+        /// </summary>
+        internal ConcurrentDictionary<string, Session> ActiveSessions => editSessions.Value;
+
+        #endregion
+
+        /// <summary>
+        /// Initializes the edit data service with the service host
+        /// </summary>
+        /// <param name="serviceHost">The service host to register commands/events with</param>
+        public void InitializeService(ServiceHost serviceHost)
+        {
+            // Register handlers for requests
+            serviceHost.SetRequestHandler(EditCreateRowRequest.Type, HandleCreateRowRequest);
+            serviceHost.SetRequestHandler(EditDeleteRowRequest.Type, HandleDeleteRowRequest);
+            serviceHost.SetRequestHandler(EditDisposeRequest.Type, HandleDisposeRequest);
+            serviceHost.SetRequestHandler(EditInitializeRequest.Type, HandleInitializeRequest);
+            serviceHost.SetRequestHandler(EditRevertRowRequest.Type, HandleRevertRowRequest);
+            serviceHost.SetRequestHandler(EditUpdateCellRequest.Type, HandleUpdateCellRequest);
+        }
+
+        #region Request Handlers
+
+        internal async Task HandleSessionRequest<TResult>(SessionOperationParams sessionParams,
+            RequestContext<TResult> requestContext, Func<Session, TResult> sessionOperation)
+        {
+            try
+            {
+                Session session = GetActiveSessionOrThrow(sessionParams.OwnerUri);
+
+                // Get the result from execution of the session operation
+                TResult result = sessionOperation(session);
+                await requestContext.SendResult(result);
+            }
+            catch (Exception e)
+            {
+                await requestContext.SendError(e.Message);
+            }
+        }
+
+        internal Task HandleCreateRowRequest(EditCreateRowParams createParams,
+            RequestContext<EditCreateRowResult> requestContext)
+        {
+            return HandleSessionRequest(createParams, requestContext, session =>
+            {
+                // Create the row and get the ID of the new row
+                long newRowId = session.CreateRow();
+                return new EditCreateRowResult
+                {
+                    NewRowId = newRowId
+                };
+            });
+        }
+
+        internal Task HandleDeleteRowRequest(EditDeleteRowParams deleteParams,
+            RequestContext<EditDeleteRowResult> requestContext)
+        {
+            return HandleSessionRequest(deleteParams, requestContext, session =>
+            {
+                // Add the delete row to the edit cache
+                session.DeleteRow(deleteParams.RowId);
+                return new EditDeleteRowResult();
+            });
+        }
+
+        internal async Task HandleDisposeRequest(EditDisposeParams disposeParams,
+            RequestContext<EditDisposeResult> requestContext)
+        {
+            try
+            {
+                // Sanity check the owner URI
+                Validate.IsNotNullOrWhitespaceString(nameof(disposeParams.OwnerUri), disposeParams.OwnerUri);
+
+                // Attempt to remove the session
+                Session session;
+                if (!ActiveSessions.TryRemove(disposeParams.OwnerUri, out session))
+                {
+                    await requestContext.SendError(SR.EditDataSessionNotFound);
+                    return;
+                }
+
+                // Everything was successful, return success
+                await requestContext.SendResult(new EditDisposeResult());
+            }
+            catch (Exception e)
+            {
+                await requestContext.SendError(e.Message);
+            }
+        }
+
+        internal async Task HandleInitializeRequest(EditInitializeParams initParams,
+            RequestContext<EditInitializeResult> requestContext)
+        {
+            try
+            {          
+                // Make sure we have info to process this request
+                Validate.IsNotNullOrWhitespaceString(nameof(initParams.OwnerUri), initParams.OwnerUri);
+                Validate.IsNotNullOrWhitespaceString(nameof(initParams.ObjectName), initParams.ObjectName);
+
+                // Setup a callback for when the query has successfully created
+                Func<Query, Task<bool>> queryCreateSuccessCallback = async query =>
+                {
+                    await requestContext.SendResult(new EditInitializeResult());
+                    return true;
+                };
+
+                // Setup a callback for when the query failed to be created
+                Func<string, Task> queryCreateFailureCallback = requestContext.SendError;
+
+                // Setup a callback for when the query completes execution successfully
+                Query.QueryAsyncEventHandler queryCompleteSuccessCallback =
+                    q => QueryCompleteCallback(q, initParams, requestContext);
+
+                // Setup a callback for when the query completes execution with failure
+                Query.QueryAsyncEventHandler queryCompleteFailureCallback = query =>
+                {
+                    EditSessionReadyParams readyParams = new EditSessionReadyParams
+                    {
+                        OwnerUri = initParams.OwnerUri,
+                        Success = false
+                    };
+                    return requestContext.SendEvent(EditSessionReadyEvent.Type, readyParams);
+                };
+
+                // Put together a query for the results and execute it
+                ExecuteStringParams executeParams = new ExecuteStringParams
+                {
+                    Query = $"SELECT * FROM {SqlScriptFormatter.FormatMultipartIdentifier(initParams.ObjectName)}",
+                    OwnerUri = initParams.OwnerUri
+                };
+                await queryExecutionService.InterServiceExecuteQuery(executeParams, requestContext,
+                    queryCreateSuccessCallback, queryCreateFailureCallback,
+                    queryCompleteSuccessCallback, queryCompleteFailureCallback);
+            }
+            catch (Exception e)
+            {
+                await requestContext.SendError(e.Message);
+            }
+        }
+
+        internal Task HandleRevertRowRequest(EditRevertRowParams revertParams,
+            RequestContext<EditRevertRowResult> requestContext)
+        {
+            return HandleSessionRequest(revertParams, requestContext, session =>
+            {
+                session.RevertRow(revertParams.RowId);
+                return new EditRevertRowResult();
+            });
+        }
+
+        internal Task HandleUpdateCellRequest(EditUpdateCellParams updateParams,
+            RequestContext<EditUpdateCellResult> requestContext)
+        {
+            return HandleSessionRequest(updateParams, requestContext,
+                session => session.UpdateCell(updateParams.RowId, updateParams.ColumnId, updateParams.NewValue));
+        }
+
+        #endregion
+
+        #region Private Helpers
+
+        /// <summary>
+        /// Returns the session with the given owner URI or throws if it can't be found
+        /// </summary>
+        /// <exception cref="Exception">If the edit session doesn't exist</exception>
+        /// <param name="ownerUri">Owner URI for the edit session</param>
+        /// <returns>The edit session that corresponds to the owner URI</returns>
+        private Session GetActiveSessionOrThrow(string ownerUri)
+        {
+            // Sanity check the owner URI is provided
+            Validate.IsNotNullOrWhitespaceString(nameof(ownerUri), ownerUri);
+
+            // Attempt to get the session, throw if unable
+            Session session;
+            if (!ActiveSessions.TryGetValue(ownerUri, out session))
+            {
+                throw new Exception(SR.EditDataSessionNotFound);
+            }
+
+            return session;
+        }
+
+        private async Task QueryCompleteCallback(Query query, EditInitializeParams initParams,
+            IEventSender requestContext)
+        {
+            EditSessionReadyParams readyParams = new EditSessionReadyParams
+            {
+                OwnerUri = initParams.OwnerUri
+            };
+
+            try
+            {
+                // Validate the query for a session
+                ResultSet resultSet = Session.ValidateQueryForSession(query);
+
+                // Get a connection we'll use for SMO metadata lookup (and committing, later on)
+                DbConnection conn = await connectionService.GetOrOpenConnection(initParams.OwnerUri, ConnectionType.Edit);
+                var metadata = metadataFactory.GetObjectMetadata(conn, resultSet.Columns,
+                    initParams.ObjectName, initParams.ObjectType);
+
+                // Create the session and add it to the sessions list
+                Session session = new Session(resultSet, metadata);
+                if (!ActiveSessions.TryAdd(initParams.OwnerUri, session))
+                {
+                    throw new InvalidOperationException("Failed to create edit session, session already exists.");
+                }
+                readyParams.Success = true;
+            }
+            catch (Exception)
+            {
+                // Request that the query be disposed
+                await queryExecutionService.InterServiceDisposeQuery(initParams.OwnerUri, null, null);
+                readyParams.Success = false;
+            }
+
+            // Send the edit session ready notification
+            await requestContext.SendEvent(EditSessionReadyEvent.Type, readyParams);
+        }
+
+        #endregion
+
+    }
+}

src/Microsoft.SqlTools.ServiceLayer/EditData/EditTableMetadata.cs

@@ -0,0 +1,99 @@
+//
+// Copyright (c) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+//
+
+using System.Collections.Generic;
+using System.Linq;
+using System.Diagnostics;
+using Microsoft.SqlServer.Management.Smo;
+using Microsoft.SqlTools.ServiceLayer.QueryExecution.Contracts;
+using Microsoft.SqlTools.ServiceLayer.Utility;
+
+namespace Microsoft.SqlTools.ServiceLayer.EditData
+{
+    /// <summary>
+    /// Provides metadata about the table or view being edited
+    /// </summary>
+    public class EditTableMetadata : IEditTableMetadata
+    {
+        private readonly List<EditColumnWrapper> columns;
+        private readonly List<EditColumnWrapper> keyColumns;
+
+        /// <summary>
+        /// Constructor that extracts useful metadata from the provided metadata objects
+        /// </summary>
+        /// <param name="dbColumns">DB columns from the ResultSet</param>
+        /// <param name="smoObject">SMO metadata object for the table/view being edited</param>
+        public EditTableMetadata(IList<DbColumnWrapper> dbColumns, TableViewTableTypeBase smoObject)
+        {
+            Validate.IsNotNull(nameof(dbColumns), dbColumns);
+            Validate.IsNotNull(nameof(smoObject), smoObject);
+
+            // Make sure that we have equal columns on both metadata providers
+            Debug.Assert(dbColumns.Count == smoObject.Columns.Count);
+
+            // Create the columns for edit usage
+            columns = new List<EditColumnWrapper>();
+            for (int i = 0; i < dbColumns.Count; i++)
+            {
+                Column smoColumn = smoObject.Columns[i];
+                DbColumnWrapper dbColumn = dbColumns[i];
+
+                // A column is trustworthy for uniqueness if it can be updated or it has an identity
+                // property. If both of these are false (eg, timestamp) we can't trust it to uniquely
+                // identify a row in the table
+                bool isTrustworthyForUniqueness = dbColumn.IsUpdatable || smoColumn.Identity;
+
+                EditColumnWrapper column = new EditColumnWrapper
+                {
+                    DbColumn = dbColumn,
+                    Ordinal = i,
+                    EscapedName = SqlScriptFormatter.FormatIdentifier(dbColumn.ColumnName),
+                    IsTrustworthyForUniqueness = isTrustworthyForUniqueness,
+
+                    // A key column is determined by whether it is in the primary key and trustworthy
+                    IsKey = smoColumn.InPrimaryKey && isTrustworthyForUniqueness
+                };
+                columns.Add(column);
+            }
+
+            // Determine what the key columns are
+            keyColumns = columns.Where(c => c.IsKey).ToList();
+            if (keyColumns.Count == 0)
+            {
+                // We didn't find any explicit key columns. Instead, we'll use all columns that are
+                // trustworthy for uniqueness (usually all the columns)
+                keyColumns = columns.Where(c => c.IsTrustworthyForUniqueness).ToList();
+            }
+
+            // If a table is memory optimized it is Hekaton. If it's a view, then it can't be Hekaton
+            Table smoTable = smoObject as Table;
+            IsMemoryOptimized = smoTable != null && smoTable.IsMemoryOptimized;
+
+            // Escape the parts of the name
+            string[] objectNameParts = {smoObject.Schema, smoObject.Name};
+            EscapedMultipartName = SqlScriptFormatter.FormatMultipartIdentifier(objectNameParts);
+        }
+
+        /// <summary>
+        /// Read-only list of columns in the object being edited
+        /// </summary>
+        public IEnumerable<EditColumnWrapper> Columns => columns.AsReadOnly();
+
+        /// <summary>
+        /// Full escaped multipart identifier for the object being edited
+        /// </summary>
+        public string EscapedMultipartName { get; }
+
+        /// <summary>
+        /// Whether or not the object being edited is memory optimized
+        /// </summary>
+        public bool IsMemoryOptimized { get; }
+
+        /// <summary>
+        /// Read-only list of columns that are used to uniquely identify a row
+        /// </summary>
+        public IEnumerable<EditColumnWrapper> KeyColumns => keyColumns.AsReadOnly();
+    }
+}

src/Microsoft.SqlTools.ServiceLayer/EditData/IEditMetadataFactory.cs

@@ -0,0 +1,26 @@
+//
+// Copyright (c) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+//
+
+using System.Data.Common;
+using Microsoft.SqlTools.ServiceLayer.QueryExecution.Contracts;
+
+namespace Microsoft.SqlTools.ServiceLayer.EditData
+{
+    /// <summary>
+    /// Interface for a factory that generates metadata for an object to edit
+    /// </summary>
+    public interface IEditMetadataFactory
+    {
+        /// <summary>
+        /// Generates a edit-ready metadata object
+        /// </summary>
+        /// <param name="connection">Connection to use for getting metadata</param>
+        /// <param name="columns">List of columns from a query against the object</param>
+        /// <param name="objectName">Name of the object to return metadata for</param>
+        /// <param name="objectType">Type of the object to return metadata for</param>
+        /// <returns>Metadata about the object requested</returns>
+        IEditTableMetadata GetObjectMetadata(DbConnection connection, DbColumnWrapper[] columns, string objectName, string objectType);
+    }
+}

src/Microsoft.SqlTools.ServiceLayer/EditData/IEditTableMetadata.cs

@@ -0,0 +1,36 @@
+//
+// Copyright (c) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+//
+
+using System.Collections.Generic;
+
+namespace Microsoft.SqlTools.ServiceLayer.EditData
+{
+    /// <summary>
+    /// An interface used in edit scenarios that defines properties for what columns are primary
+    /// keys, and other metadata of the table.
+    /// </summary>
+    public interface IEditTableMetadata
+    {
+        /// <summary>
+        /// All columns in the table that's being edited
+        /// </summary>
+        IEnumerable<EditColumnWrapper> Columns { get; }
+
+        /// <summary>
+        /// The escaped name of the table that's being edited
+        /// </summary>
+        string EscapedMultipartName { get; }
+
+        /// <summary>
+        /// Whether or not this table is a memory optimized table
+        /// </summary>
+        bool IsMemoryOptimized { get; }
+
+        /// <summary>
+        /// Columns that can be used to uniquely identify the a row
+        /// </summary>
+        IEnumerable<EditColumnWrapper> KeyColumns { get; }
+    }
+}

src/Microsoft.SqlTools.ServiceLayer/EditData/Session.cs

@@ -0,0 +1,215 @@
+//
+// Copyright (c) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+//
+
+using System;
+using System.Collections.Concurrent;
+using System.IO;
+using System.Linq;
+using Microsoft.SqlTools.ServiceLayer.EditData.Contracts;
+using Microsoft.SqlTools.ServiceLayer.EditData.UpdateManagement;
+using Microsoft.SqlTools.ServiceLayer.QueryExecution;
+using Microsoft.SqlTools.ServiceLayer.Utility;
+
+namespace Microsoft.SqlTools.ServiceLayer.EditData
+{
+    /// <summary>
+    /// Represents an edit "session" bound to the results of a query, containing a cache of edits
+    /// that are pending. Provides logic for performing edit operations.
+    /// </summary>
+    public class Session
+    {
+
+        #region Member Variables
+
+        private readonly ResultSet associatedResultSet;
+        private readonly IEditTableMetadata objectMetadata;
+
+        #endregion
+
+        /// <summary>
+        /// Constructs a new edit session bound to the result set and metadat object provided
+        /// </summary>
+        /// <param name="resultSet">The result set of the table to be edited</param>
+        /// <param name="objMetadata">Metadata provider for the table to be edited</param>
+        public Session(ResultSet resultSet, IEditTableMetadata objMetadata)
+        {
+            Validate.IsNotNull(nameof(resultSet), resultSet);
+            Validate.IsNotNull(nameof(objMetadata), objMetadata);
+
+            // Setup the internal state
+            associatedResultSet = resultSet;
+            objectMetadata = objMetadata;
+            NextRowId = associatedResultSet.RowCount;
+            EditCache = new ConcurrentDictionary<long, RowEditBase>();
+        }
+
+        #region Properties
+
+        /// <summary>
+        /// The internal ID for the next row in the table. Internal for unit testing purposes only.
+        /// </summary>
+        internal long NextRowId { get; private set; }
+
+        /// <summary>
+        /// The cache of pending updates. Internal for unit test purposes only
+        /// </summary>
+        internal ConcurrentDictionary<long, RowEditBase> EditCache { get;}
+
+        #endregion
+
+        #region Public Methods
+
+        /// <summary>
+        /// Validates that a query can be used for an edit session. The target result set is returned
+        /// </summary>
+        /// <param name="query">The query to validate</param>
+        /// <returns>The result set to use</returns>
+        public static ResultSet ValidateQueryForSession(Query query)
+        {
+            Validate.IsNotNull(nameof(query), query);
+
+            // Determine if the query is valid for editing
+            // Criterion 1) Query has finished executing
+            if (!query.HasExecuted)
+            {
+                throw new InvalidOperationException(SR.EditDataQueryNotCompleted);
+            }
+
+            // Criterion 2) Query only has a single result set
+            ResultSet[] queryResultSets = query.Batches.SelectMany(b => b.ResultSets).ToArray();
+            if (queryResultSets.Length != 1)
+            {
+                throw new InvalidOperationException(SR.EditDataQueryImproperResultSets);
+            }
+
+            return query.Batches[0].ResultSets[0];
+        }
+
+        /// <summary>
+        /// Creates a new row update and adds it to the update cache
+        /// </summary>
+        /// <exception cref="InvalidOperationException">If inserting into cache fails</exception>
+        /// <returns>The internal ID of the newly created row</returns>
+        public long CreateRow()
+        {
+            // Create a new row ID (atomically, since this could be accesses concurrently)
+            long newRowId = NextRowId++;
+
+            // Create a new row create update and add to the update cache
+            RowCreate newRow = new RowCreate(newRowId, associatedResultSet, objectMetadata);
+            if (!EditCache.TryAdd(newRowId, newRow))
+            {
+                // Revert the next row ID
+                NextRowId--;
+                throw new InvalidOperationException(SR.EditDataFailedAddRow);
+            }
+
+            return newRowId;
+        }
+
+        /// <summary>
+        /// Creates a delete row update and adds it to the update cache
+        /// </summary>
+        /// <exception cref="InvalidOperationException">
+        /// If row requested to delete already has a pending change in the cache
+        /// </exception>
+        /// <param name="rowId">The internal ID of the row to delete</param>
+        public void DeleteRow(long rowId)
+        {
+            // Sanity check the row ID
+            if (rowId >= NextRowId || rowId < 0)
+            {
+                throw new ArgumentOutOfRangeException(nameof(rowId), SR.EditDataRowOutOfRange);
+            }
+
+            // Create a new row delete update and add to cache
+            RowDelete deleteRow = new RowDelete(rowId, associatedResultSet, objectMetadata);
+            if (!EditCache.TryAdd(rowId, deleteRow))
+            {
+                throw new InvalidOperationException(SR.EditDataUpdatePending);
+            }
+        }
+
+        /// <summary>
+        /// Removes a pending row update from the update cache.
+        /// </summary>
+        /// <exception cref="ArgumentOutOfRangeException">
+        /// If a pending row update with the given row ID does not exist.
+        /// </exception>
+        /// <param name="rowId">The internal ID of the row to reset</param>
+        public void RevertRow(long rowId)
+        {
+            // Attempt to remove the row with the given ID
+            RowEditBase removedEdit;
+            if (!EditCache.TryRemove(rowId, out removedEdit))
+            {
+                throw new ArgumentOutOfRangeException(nameof(rowId), SR.EditDataUpdateNotPending);
+            }
+        }
+
+        public string ScriptEdits(string outputPath)
+        {
+            // Validate the output path
+            // @TODO: Reinstate this code once we have an interface around file generation
+            //if (outputPath == null)
+            //{
+            //    // If output path isn't provided, we'll use a temporary location
+            //    outputPath = Path.GetTempFileName();
+            //}
+            //else 
+            if (outputPath == null || outputPath.Trim() == string.Empty)
+            {
+                // If output path is empty, that's an error
+                throw new ArgumentNullException(nameof(outputPath), SR.EditDataScriptFilePathNull);
+            }
+
+            // Open a handle to the output file
+            using (FileStream outputStream = File.OpenWrite(outputPath))
+            using (TextWriter outputWriter = new StreamWriter(outputStream))
+            {
+
+                // Convert each update in the cache into an insert/update/delete statement
+                foreach (RowEditBase rowEdit in EditCache.Values)
+                {
+                    outputWriter.WriteLine(rowEdit.GetScript());
+                }
+            }
+
+            // Return the location of the generated script
+            return outputPath;
+        }
+
+        /// <summary>
+        /// Performs an update to a specific cell in a row. If the row has not already been
+        /// initialized with a record in the update cache, one is created.
+        /// </summary>
+        /// <exception cref="InvalidOperationException">If adding a new update row fails</exception>
+        /// <exception cref="ArgumentOutOfRangeException">
+        /// If the row that is requested to be edited is beyond the rows in the results and the
+        /// rows that are being added.
+        /// </exception>
+        /// <param name="rowId">The internal ID of the row to edit</param>
+        /// <param name="columnId">The ordinal of the column to edit in the row</param>
+        /// <param name="newValue">The new string value of the cell to update</param>
+        public EditUpdateCellResult UpdateCell(long rowId, int columnId, string newValue)
+        {
+            // Sanity check to make sure that the row ID is in the range of possible values
+            if (rowId >= NextRowId || rowId < 0)
+            {
+                throw new ArgumentOutOfRangeException(nameof(rowId), SR.EditDataRowOutOfRange);
+            }
+
+            // Attempt to get the row that is being edited, create a new update object if one
+            // doesn't exist
+            RowEditBase editRow = EditCache.GetOrAdd(rowId, new RowUpdate(rowId, associatedResultSet, objectMetadata));
+
+            // Pass the call to the row update
+            return editRow.SetCell(columnId, newValue);
+        }
+
+        #endregion
+
+    }
+}

src/Microsoft.SqlTools.ServiceLayer/EditData/SmoEditMetadataFactory.cs

@@ -0,0 +1,68 @@
+//
+// Copyright (c) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+//
+
+using System;
+using System.Data.Common;
+using System.Data.SqlClient;
+using Microsoft.SqlServer.Management.Common;
+using Microsoft.SqlServer.Management.Smo;
+using Microsoft.SqlTools.ServiceLayer.Connection.ReliableConnection;
+using Microsoft.SqlTools.ServiceLayer.QueryExecution.Contracts;
+
+namespace Microsoft.SqlTools.ServiceLayer.EditData
+{
+    /// <summary>
+    /// Factory that generates metadata using a combination of SMO and SqlClient metadata
+    /// </summary>
+    public class SmoEditMetadataFactory : IEditMetadataFactory
+    {
+        /// <summary>
+        /// Generates a edit-ready metadata object using SMO
+        /// </summary>
+        /// <param name="connection">Connection to use for getting metadata</param>
+        /// <param name="columns">List of columns from a query against the object</param>
+        /// <param name="objectName">Name of the object to return metadata for</param>
+        /// <param name="objectType">Type of the object to return metadata for</param>
+        /// <returns>Metadata about the object requested</returns>
+        public IEditTableMetadata GetObjectMetadata(DbConnection connection, DbColumnWrapper[] columns, string objectName, string objectType)
+        {
+            // Get a connection to the database for SMO purposes
+            SqlConnection sqlConn = connection as SqlConnection;
+            if (sqlConn == null)
+            {
+                // It's not actually a SqlConnection, so let's try a reliable SQL connection
+                ReliableSqlConnection reliableConn = connection as ReliableSqlConnection;
+                if (reliableConn == null)
+                {
+                    // If we don't have connection we can use with SMO, just give up on using SMO
+                    return null;
+                }
+
+                // We have a reliable connection, use the underlying connection
+                sqlConn = reliableConn.GetUnderlyingConnection();
+            }
+
+            Server server = new Server(new ServerConnection(sqlConn));
+            TableViewTableTypeBase result;
+            switch (objectType.ToLowerInvariant())
+            {
+                case "table":
+                    result = server.Databases[sqlConn.Database].Tables[objectName];
+                    break;
+                case "view":
+                    result = server.Databases[sqlConn.Database].Views[objectName];
+                    break;
+                default:
+                    throw new ArgumentOutOfRangeException(nameof(objectType), SR.EditDataUnsupportedObjectType(objectType));
+            }
+            if (result == null)
+            {
+                throw new ArgumentOutOfRangeException(nameof(objectName), SR.EditDataObjectMetadataNotFound);
+            }
+
+            return new EditTableMetadata(columns, result);
+        }
+    }
+}

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

@@ -0,0 +1,202 @@
+//
+// Copyright (c) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+//
+
+using System;
+using System.Data.Common;
+using System.Globalization;
+using System.Text.RegularExpressions;
+using Microsoft.SqlTools.ServiceLayer.Utility;
+
+namespace Microsoft.SqlTools.ServiceLayer.EditData.UpdateManagement
+{
+    /// <summary>
+    /// Representation of a cell that should have a value inserted or updated
+    /// </summary>
+    public sealed class CellUpdate
+    {
+        private const string NullString = @"NULL";
+        private const string TextNullString = @"'NULL'";
+        private static readonly Regex HexRegex = new Regex("0x[0-9A-F]+", RegexOptions.Compiled | RegexOptions.IgnoreCase);
+
+        /// <summary>
+        /// Constructs a new cell update based on the the string value provided and the column
+        /// for the cell.
+        /// </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)
+        {
+            Validate.IsNotNull(nameof(column), column);
+            Validate.IsNotNull(nameof(valueAsString), valueAsString);
+
+            // Store the state that won't be changed
+            Column = column;
+            Type columnType = column.DataType;
+
+            // Check for null
+            if (valueAsString == NullString)
+            {
+                Value = DBNull.Value;
+                ValueAsString = valueAsString;
+            }
+            else if (columnType == typeof(byte[]))
+            {
+                // Binary columns need special attention
+                ProcessBinaryCell(valueAsString);
+            }
+            else if (columnType == typeof(string))
+            {
+                // Special case for strings because the string value should stay the same as provided
+                // If user typed 'NULL' they mean NULL as text
+                Value = valueAsString == TextNullString ? NullString : valueAsString;
+                ValueAsString = valueAsString;
+            }
+            else if (columnType == typeof(Guid))
+            {
+                Value = Guid.Parse(valueAsString);
+                ValueAsString = Value.ToString();
+            }
+            else if (columnType == typeof(TimeSpan))
+            {
+                Value = TimeSpan.Parse(valueAsString, CultureInfo.CurrentCulture);
+                ValueAsString = Value.ToString();
+            }
+            else if (columnType == typeof(DateTimeOffset))
+            {
+                Value = DateTimeOffset.Parse(valueAsString, CultureInfo.CurrentCulture);
+                ValueAsString = Value.ToString();
+            }
+            else if (columnType == typeof(bool))
+            {
+                ProcessBooleanCell(valueAsString);
+            }
+            // @TODO: Microsoft.SqlServer.Types.SqlHierarchyId
+            else
+            {
+                // Attempt to go straight to the destination type, if we know what it is, otherwise
+                // leave it as a string
+                Value = columnType != null 
+                    ? Convert.ChangeType(valueAsString, columnType, CultureInfo.CurrentCulture) 
+                    : valueAsString;
+                ValueAsString = Value.ToString();
+            }
+        }
+
+        #region Properties
+
+        /// <summary>
+        /// The column that the cell will be placed in
+        /// </summary>
+        public DbColumn Column { get; }
+
+        /// <summary>
+        /// The object representation of the cell provided by the client
+        /// </summary>
+        public object Value { get; private set; }
+
+        /// <summary>
+        /// <see cref="Value"/> converted to a string
+        /// </summary>
+        public string ValueAsString { get; private set; }
+
+        #endregion
+
+        #region Private Helpers
+
+        private void ProcessBinaryCell(string valueAsString)
+        {
+            string trimmedString = valueAsString.Trim();
+
+            byte[] byteArray;
+            uint uintVal;
+            if (uint.TryParse(trimmedString, NumberStyles.None, CultureInfo.InvariantCulture, out uintVal))
+            {
+                // Get the bytes
+                byteArray = BitConverter.GetBytes(uintVal);
+                if (BitConverter.IsLittleEndian)
+                {
+                    Array.Reverse(byteArray);
+                }
+                Value = byteArray;
+
+                // User typed something numeric (may be hex or dec)
+                if ((uintVal & 0xFFFFFF00) == 0)
+                {
+                    // Value can fit in a single byte
+                    Value = new[] { byteArray[3] };
+                }
+                else if ((uintVal & 0xFFFF0000) == 0)
+                {
+                    // Value can fit in two bytes
+                    Value = new[] { byteArray[2], byteArray[3] };
+                }
+                else if ((uintVal & 0xFF000000) == 0)
+                {
+                    // Value can fit in three bytes
+                    Value = new[] { byteArray[1], byteArray[2], byteArray[3] };
+                }
+            }
+            else if (HexRegex.IsMatch(valueAsString))
+            {
+                // User typed something that starts with a hex identifier (0x)
+                // Strip off the 0x, pad with zero if necessary
+                trimmedString = trimmedString.Substring(2);
+                if (trimmedString.Length % 2 == 1)
+                {
+                    trimmedString = "0" + trimmedString;
+                }
+
+                // Convert to a byte array
+                byteArray = new byte[trimmedString.Length / 2];
+                for (int i = 0; i < trimmedString.Length; i += 2)
+                {
+                    string bString = $"{trimmedString[i]}{trimmedString[i + 1]}";
+                    byte bVal = byte.Parse(bString, NumberStyles.AllowHexSpecifier, CultureInfo.InvariantCulture);
+                    byteArray[i / 2] = bVal;
+                }
+                Value = byteArray;
+            }
+            else
+            {
+                // Invalid format
+                throw new FormatException(SR.EditDataInvalidFormatBinary);
+            }
+
+            // Generate the hex string as the return value
+            ValueAsString = "0x" + BitConverter.ToString((byte[])Value).Replace("-", string.Empty);
+        }
+
+        private void ProcessBooleanCell(string valueAsString)
+        {
+            // Allow user to enter 1 or 0
+            string trimmedString = valueAsString.Trim();
+            int intVal;
+            if (int.TryParse(trimmedString, out intVal))
+            {
+                switch (intVal)
+                {
+                    case 1:
+                        Value = true;
+                        break;
+                    case 0:
+                        Value = false;
+                        break;
+                    default:
+                        throw new ArgumentOutOfRangeException(nameof(valueAsString),
+                            SR.EditDataInvalidFormatBoolean);
+                }
+            }
+            else
+            {
+                // Allow user to enter true or false
+                Value = bool.Parse(valueAsString);
+            }
+
+            ValueAsString = Value.ToString();
+        }
+
+        #endregion
+    }
+}

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

@@ -0,0 +1,103 @@
+//
+// Copyright (c) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+//
+
+using System;
+using System.Collections.Generic;
+using Microsoft.SqlTools.ServiceLayer.EditData.Contracts;
+using Microsoft.SqlTools.ServiceLayer.QueryExecution;
+using Microsoft.SqlTools.ServiceLayer.QueryExecution.Contracts;
+using Microsoft.SqlTools.ServiceLayer.Utility;
+
+namespace Microsoft.SqlTools.ServiceLayer.EditData.UpdateManagement
+{
+    /// <summary>
+    /// Represents a row that should be added to the result set. Generates an INSERT statement.
+    /// </summary>
+    public sealed class RowCreate : RowEditBase
+    {
+        private const string InsertStatement = "INSERT INTO {0}({1}) VALUES ({2})";
+
+        private readonly CellUpdate[] newCells;
+
+        /// <summary>
+        /// Creates a new Row Creation edit to the result set
+        /// </summary>
+        /// <param name="rowId">Internal ID of the row that is being created</param>
+        /// <param name="associatedResultSet">The result set for the rows in the table we're editing</param>
+        /// <param name="associatedMetadata">The metadata for table we're editing</param>
+        public RowCreate(long rowId, ResultSet associatedResultSet, IEditTableMetadata associatedMetadata)
+            : base(rowId, associatedResultSet, associatedMetadata)
+        {
+            newCells = new CellUpdate[associatedResultSet.Columns.Length];
+        }
+
+        /// <summary>
+        /// Generates the INSERT INTO statement that will apply the row creation
+        /// </summary>
+        /// <returns>INSERT INTO statement</returns>
+        public override string GetScript()
+        {
+            List<string> columnNames = new List<string>();
+            List<string> columnValues = new List<string>();
+
+            // Build the column list and value list
+            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
+                if (!column.IsUpdatable)
+                {
+                    continue;
+                }
+
+                // If the cell doesn't have a value, but is updatable, don't try to create the script
+                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));
+            }
+
+            // 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);
+        }
+
+        /// <summary>
+        /// Sets the value of a cell in the row to be added
+        /// </summary>
+        /// <param name="columnId">Ordinal of the column to set in the row</param>
+        /// <param name="newValue">String representation from the client of the value to add</param>
+        /// <returns>
+        /// The updated value as a string of the object generated from <paramref name="newValue"/>
+        /// </returns>
+        public override EditUpdateCellResult SetCell(int columnId, string newValue)
+        {
+            // Validate the column and the value and convert to object
+            ValidateColumnIsUpdatable(columnId);
+            CellUpdate update = new CellUpdate(AssociatedResultSet.Columns[columnId], newValue);
+
+            // Add the cell update to the 
+            newCells[columnId] = update;
+
+            // Put together a result of the change
+            EditUpdateCellResult eucr = new EditUpdateCellResult
+            {
+                HasCorrections = update.ValueAsString != newValue,
+                NewValue = update.ValueAsString != newValue ? update.ValueAsString : null,
+                IsNull = update.Value == DBNull.Value,
+                IsRevert = false            // Editing cells of new rows cannot be reverts
+            }; 
+            return eucr;
+        }
+    }
+}

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

@@ -0,0 +1,55 @@
+//
+// Copyright (c) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+//
+
+using System;
+using System.Globalization;
+using Microsoft.SqlTools.ServiceLayer.EditData.Contracts;
+using Microsoft.SqlTools.ServiceLayer.QueryExecution;
+
+namespace Microsoft.SqlTools.ServiceLayer.EditData.UpdateManagement
+{
+    /// <summary>
+    /// Represents a row that should be deleted. This will generate a DELETE statement
+    /// </summary>
+    public sealed class RowDelete : RowEditBase
+    {
+        private const string DeleteStatement = "DELETE FROM {0} {1}";
+        private const string DeleteMemoryOptimizedStatement = "DELETE FROM {0} WITH(SNAPSHOT) {1}";
+
+        /// <summary>
+        /// Constructs a new RowDelete object
+        /// </summary>
+        /// <param name="rowId">Internal ID of the row to be deleted</param>
+        /// <param name="associatedResultSet">Result set that is being edited</param>
+        /// <param name="associatedMetadata">Improved metadata of the object being edited</param>
+        public RowDelete(long rowId, ResultSet associatedResultSet, IEditTableMetadata associatedMetadata)
+            : base(rowId, associatedResultSet, associatedMetadata)
+        {
+        }
+
+        /// <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);
+        }
+
+        /// <summary>
+        /// This method should not be called. A cell cannot be updated on a row that is pending
+        /// deletion.
+        /// </summary>
+        /// <exception cref="InvalidOperationException">Always thrown</exception>
+        /// <param name="columnId">Ordinal of the column to update</param>
+        /// <param name="newValue">New value for the cell</param>
+        public override EditUpdateCellResult SetCell(int columnId, string newValue)
+        {
+            throw new InvalidOperationException(SR.EditDataDeleteSetCell);
+        }
+    }
+}

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

@@ -0,0 +1,197 @@
+//
+// Copyright (c) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+//
+
+using System;
+using System.Collections.Generic;
+using System.Data.Common;
+using System.Data.SqlClient;
+using System.Linq;
+using Microsoft.SqlTools.ServiceLayer.EditData.Contracts;
+using Microsoft.SqlTools.ServiceLayer.QueryExecution;
+using Microsoft.SqlTools.ServiceLayer.QueryExecution.Contracts;
+using Microsoft.SqlTools.ServiceLayer.Utility;
+
+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.
+    /// </summary>
+    public abstract class RowEditBase
+    {
+        /// <summary>
+        /// Internal parameterless constructor, required for mocking
+        /// </summary>
+        protected internal RowEditBase() { }
+
+        /// <summary>
+        /// Base constructor for a row edit. Stores the state that should be available to all row
+        /// edit implementations.
+        /// </summary>
+        /// <param name="rowId">The internal ID of the row that is being edited</param>
+        /// <param name="associatedResultSet">The result set that will be updated</param>
+        /// <param name="associatedMetadata">Metadata provider for the object to edit</param>
+        protected RowEditBase(long rowId, ResultSet associatedResultSet, IEditTableMetadata associatedMetadata)
+        {
+            RowId = rowId;
+            AssociatedResultSet = associatedResultSet;
+            AssociatedObjectMetadata = associatedMetadata;
+        }
+
+        #region Properties
+
+        /// <summary>
+        /// The internal ID of the row to which this edit applies, relative to the result set
+        /// </summary>
+        public long RowId { get; }
+
+        /// <summary>
+        /// The result set that is associated with this row edit
+        /// </summary>
+        public ResultSet AssociatedResultSet { get; }
+
+        /// <summary>
+        /// The metadata for the table this edit is associated to
+        /// </summary>
+        public IEditTableMetadata AssociatedObjectMetadata { get; }
+
+        #endregion
+
+        /// <summary>
+        /// Converts the row edit into a SQL statement
+        /// </summary>
+        /// <returns>A SQL statement</returns>
+        public abstract string GetScript();
+
+        /// <summary>
+        /// Changes the value a cell in the row.
+        /// </summary>
+        /// <param name="columnId">Ordinal of the column in the row to update</param>
+        /// <param name="newValue">The new value for the cell</param>
+        /// <returns>The value of the cell after applying validation logic</returns>
+        public abstract EditUpdateCellResult SetCell(int columnId, string newValue);
+
+        /// <summary>
+        /// Performs validation of column ID and if column can be updated.
+        /// </summary>
+        /// <exception cref="ArgumentOutOfRangeException">
+        /// If <paramref name="columnId"/> is less than 0 or greater than the number of columns
+        /// in the row
+        /// </exception>
+        /// <exception cref="InvalidOperationException">If the column is not updatable</exception>
+        /// <param name="columnId">Ordinal of the column to update</param>
+        protected void ValidateColumnIsUpdatable(int columnId)
+        {
+            // Sanity check that the column ID is within the range of columns
+            if (columnId >= AssociatedResultSet.Columns.Length || columnId < 0)
+            {
+                throw new ArgumentOutOfRangeException(nameof(columnId), SR.EditDataColumnIdOutOfRange);
+            }
+
+            DbColumnWrapper column = AssociatedResultSet.Columns[columnId];
+            if (!column.IsUpdatable)
+            {
+                throw new InvalidOperationException(SR.EditDataColumnCannotBeEdited);
+            }
+        }
+
+        /// <summary>
+        /// Generates a WHERE clause that uses the key columns of the table to uniquely identity
+        /// the row that will be updated.
+        /// </summary>
+        /// <param name="parameterize">
+        /// Whether or not to generate a parameterized where clause. If <c>true</c> verbatim values
+        /// will be replaced with paremeters (like @Param12). The parameters must be added to the
+        /// SqlCommand used to execute the commit.
+        /// </param>
+        /// <returns>A <see cref="WhereClause"/> object</returns>
+        protected WhereClause GetWhereClause(bool parameterize)
+        {
+            WhereClause output = new WhereClause();
+
+            if (!AssociatedObjectMetadata.KeyColumns.Any())
+            {
+                throw new InvalidOperationException(SR.EditDataColumnNoKeyColumns);
+            }
+
+            IList<DbCellValue> row = AssociatedResultSet.GetRow(RowId);
+            foreach (EditColumnWrapper col in AssociatedObjectMetadata.KeyColumns)
+            {
+                // Put together a clause for the value of the cell
+                DbCellValue cellData = row[col.Ordinal];
+                string cellDataClause;
+                if (cellData.IsNull)
+                {
+                    cellDataClause = "IS NULL";
+                }
+                else
+                {
+                    if (cellData.RawObject is byte[] ||
+                        col.DbColumn.DataTypeName.Equals("TEXT", StringComparison.OrdinalIgnoreCase) ||
+                        col.DbColumn.DataTypeName.Equals("NTEXT", StringComparison.OrdinalIgnoreCase))
+                    {
+                        // Special cases for byte[] and TEXT/NTEXT types
+                        cellDataClause = "IS NOT NULL";
+                    }
+                    else
+                    {
+                        // General case is to just use the value from the cell
+                        if (parameterize)
+                        {
+                            // Add a parameter and parameterized clause component
+                            // NOTE: We include the row ID to make sure the parameter is unique if
+                            //       we execute multiple row edits at once.
+                            string paramName = $"@Param{RowId}{col.Ordinal}";
+                            cellDataClause = $"= {paramName}";
+                            output.Parameters.Add(new SqlParameter(paramName, col.DbColumn.SqlDbType));
+                        }
+                        else
+                        {
+                            // Add the clause component with the formatted value
+                            cellDataClause = $"= {SqlScriptFormatter.FormatValue(cellData, col.DbColumn)}";
+                        }
+                    }
+                }
+
+                string completeComponent = $"({col.EscapedName} {cellDataClause})";
+                output.ClauseComponents.Add(completeComponent);
+            }
+
+            return output;
+        }
+
+        /// <summary>
+        /// Represents a WHERE clause that can be used for identifying a row in a table.
+        /// </summary>
+        protected class WhereClause
+        {
+            /// <summary>
+            /// Constructs and initializes a new where clause
+            /// </summary>
+            public WhereClause()
+            {
+                Parameters = new List<DbParameter>();
+                ClauseComponents = new List<string>();
+            }
+
+            /// <summary>
+            /// SqlParameters used in a parameterized query. If this object was generated without
+            /// parameterization, this will be an empty list
+            /// </summary>
+            public List<DbParameter> Parameters { get; }
+
+            /// <summary>
+            /// Strings that make up the WHERE clause, such as <c>"([col1] = 'something')"</c>
+            /// </summary>
+            public List<string> ClauseComponents { get; }
+
+            /// <summary>
+            /// Total text of the WHERE clause that joins all the components with AND
+            /// </summary>
+            public string CommandText => $"WHERE {string.Join(" AND ", ClauseComponents)}";
+        }
+    }
+}

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

@@ -0,0 +1,110 @@
+//
+// Copyright (c) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+//
+
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Linq;
+using Microsoft.SqlTools.ServiceLayer.EditData.Contracts;
+using Microsoft.SqlTools.ServiceLayer.QueryExecution;
+using Microsoft.SqlTools.ServiceLayer.QueryExecution.Contracts;
+using Microsoft.SqlTools.ServiceLayer.Utility;
+
+namespace Microsoft.SqlTools.ServiceLayer.EditData.UpdateManagement
+{
+    /// <summary>
+    /// An update to apply to a row of a result set. This will generate an UPDATE statement.
+    /// </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 readonly Dictionary<int, CellUpdate> cellUpdates;
+        private readonly IList<DbCellValue> associatedRow;
+
+        /// <summary>
+        /// Constructs a new RowUpdate to be added to the cache.
+        /// </summary>
+        /// <param name="rowId">Internal ID of the row that will be updated with this object</param>
+        /// <param name="associatedResultSet">Result set for the rows of the object to update</param>
+        /// <param name="associatedMetadata">Metadata provider for the object to update</param>
+        public RowUpdate(long rowId, ResultSet associatedResultSet, IEditTableMetadata associatedMetadata)
+            : base(rowId, associatedResultSet, associatedMetadata)
+        {
+            cellUpdates = new Dictionary<int, CellUpdate>();
+            associatedRow = associatedResultSet.GetRow(rowId);
+        }
+
+        /// <summary>
+        /// Constructs an update statement to change the associated row.
+        /// </summary>
+        /// <returns>An UPDATE statement</returns>
+        public override string GetScript()
+        {
+            // Build the "SET" portion of the statement
+            IEnumerable<string> setComponents = cellUpdates.Values.Select(cellUpdate =>
+            {
+                string formattedColumnName = SqlScriptFormatter.FormatIdentifier(cellUpdate.Column.ColumnName);
+                string formattedValue = SqlScriptFormatter.FormatValue(cellUpdate.Value, cellUpdate.Column);
+                return $"{formattedColumnName} = {formattedValue}";
+            });
+            string setClause = string.Join(", ", setComponents);
+
+            // 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);
+        }
+
+        /// <summary>
+        /// Sets the value of the cell in the associated row. If <paramref name="newValue"/> is
+        /// identical to the original value, this will remove the cell update from the row update.
+        /// </summary>
+        /// <param name="columnId">Ordinal of the columns that will be set</param>
+        /// <param name="newValue">String representation of the value the user input</param>
+        /// <returns>
+        /// The string representation of the new value (after conversion to target object) if the
+        /// a change is made. <c>null</c> is returned if the cell is reverted to it's original value.
+        /// </returns>
+        public override EditUpdateCellResult SetCell(int columnId, string newValue)
+        {
+            // Validate the value and convert to object
+            ValidateColumnIsUpdatable(columnId);            
+            CellUpdate update = new CellUpdate(AssociatedResultSet.Columns[columnId], newValue);
+
+            // If the value is the same as the old value, we shouldn't make changes
+            // NOTE: We must use .Equals in order to ignore object to object comparisons
+            if (update.Value.Equals(associatedRow[columnId].RawObject))
+            {
+                // Remove any pending change and stop processing this
+                if (cellUpdates.ContainsKey(columnId))
+                {
+                    cellUpdates.Remove(columnId);
+                }
+                return new EditUpdateCellResult
+                {
+                    HasCorrections = false,
+                    NewValue = associatedRow[columnId].DisplayValue,
+                    IsRevert = true,
+                    IsNull = associatedRow[columnId].IsNull
+                };
+            }
+
+            // The change is real, so set it
+            cellUpdates[columnId] = update;
+            return new EditUpdateCellResult
+            {
+                HasCorrections = update.ValueAsString != newValue,
+                NewValue = update.ValueAsString != newValue ? update.ValueAsString : null,
+                IsNull = update.Value == DBNull.Value,
+                IsRevert = false            // If we're in this branch, it is not a revert
+            };
+        }
+    }
+}