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/Connection/ConnectionType.cs

@@ -15,5 +15,6 @@ namespace Microsoft.SqlTools.ServiceLayer.Connection
     {
         public const string Default = "Default";
         public const string Query = "Query";
+        public const string Edit = "Edit";
     }
 }

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
+            };
+        }
+    }
+}

src/Microsoft.SqlTools.ServiceLayer/HostLoader.cs

@@ -8,6 +8,7 @@ using System.Linq;
 using System.Threading.Tasks;
 using Microsoft.SqlTools.ServiceLayer.Connection;
 using Microsoft.SqlTools.ServiceLayer.Credentials;
+using Microsoft.SqlTools.ServiceLayer.EditData;
 using Microsoft.SqlTools.ServiceLayer.Extensibility;
 using Microsoft.SqlTools.ServiceLayer.Hosting;
 using Microsoft.SqlTools.ServiceLayer.Hosting.Protocol;
@@ -75,6 +76,9 @@ namespace Microsoft.SqlTools.ServiceLayer
             QueryExecutionService.Instance.InitializeService(serviceHost);
             serviceProvider.RegisterSingleService(QueryExecutionService.Instance);
 
+            EditDataService.Instance.InitializeService(serviceHost);
+            serviceProvider.RegisterSingleService(EditDataService.Instance);
+
             InitializeHostedServices(serviceProvider, serviceHost);
 
             serviceHost.InitializeRequestHandlers();

src/Microsoft.SqlTools.ServiceLayer/Localization/sr.Designer.cs

@@ -230,6 +230,15 @@ namespace Microsoft.SqlTools.ServiceLayer.Localization {
             }
         }
         
+        /// <summary>
+        ///    Looks up a localized string similar to Specified URI &apos;{0}&apos; does not have a default connection.
+        /// </summary>
+        public static string ConnectionServiceDbErrorDefaultNotConnected {
+            get {
+                return ResourceManager.GetString("ConnectionServiceDbErrorDefaultNotConnected", resourceCulture);
+            }
+        }
+        
         /// <summary>
         ///    Looks up a localized string similar to SpecifiedUri &apos;{0}&apos; does not have existing connection.
         /// </summary>

src/Microsoft.SqlTools.ServiceLayer/Localization/sr.cs

@@ -485,6 +485,134 @@ namespace Microsoft.SqlTools.ServiceLayer
             }
         }
 
+        public static string EditDataSessionNotFound
+        {
+            get
+            {
+                return Keys.GetString(Keys.EditDataSessionNotFound);
+            }
+        }
+
+        public static string EditDataQueryNotCompleted
+        {
+            get
+            {
+                return Keys.GetString(Keys.EditDataQueryNotCompleted);
+            }
+        }
+
+        public static string EditDataQueryImproperResultSets
+        {
+            get
+            {
+                return Keys.GetString(Keys.EditDataQueryImproperResultSets);
+            }
+        }
+
+        public static string EditDataFailedAddRow
+        {
+            get
+            {
+                return Keys.GetString(Keys.EditDataFailedAddRow);
+            }
+        }
+
+        public static string EditDataRowOutOfRange
+        {
+            get
+            {
+                return Keys.GetString(Keys.EditDataRowOutOfRange);
+            }
+        }
+
+        public static string EditDataUpdatePending
+        {
+            get
+            {
+                return Keys.GetString(Keys.EditDataUpdatePending);
+            }
+        }
+
+        public static string EditDataUpdateNotPending
+        {
+            get
+            {
+                return Keys.GetString(Keys.EditDataUpdateNotPending);
+            }
+        }
+
+        public static string EditDataObjectMetadataNotFound
+        {
+            get
+            {
+                return Keys.GetString(Keys.EditDataObjectMetadataNotFound);
+            }
+        }
+
+        public static string EditDataInvalidFormatBinary
+        {
+            get
+            {
+                return Keys.GetString(Keys.EditDataInvalidFormatBinary);
+            }
+        }
+
+        public static string EditDataInvalidFormatBoolean
+        {
+            get
+            {
+                return Keys.GetString(Keys.EditDataInvalidFormatBoolean);
+            }
+        }
+
+        public static string EditDataCreateScriptMissingValue
+        {
+            get
+            {
+                return Keys.GetString(Keys.EditDataCreateScriptMissingValue);
+            }
+        }
+
+        public static string EditDataDeleteSetCell
+        {
+            get
+            {
+                return Keys.GetString(Keys.EditDataDeleteSetCell);
+            }
+        }
+
+        public static string EditDataColumnIdOutOfRange
+        {
+            get
+            {
+                return Keys.GetString(Keys.EditDataColumnIdOutOfRange);
+            }
+        }
+
+        public static string EditDataColumnCannotBeEdited
+        {
+            get
+            {
+                return Keys.GetString(Keys.EditDataColumnCannotBeEdited);
+            }
+        }
+
+        public static string EditDataColumnNoKeyColumns
+        {
+            get
+            {
+                return Keys.GetString(Keys.EditDataColumnNoKeyColumns);
+            }
+        }
+
+        public static string EditDataScriptFilePathNull
+        {
+            get
+            {
+                return Keys.GetString(Keys.EditDataScriptFilePathNull);
+            }
+        }
+
         public static string EE_BatchSqlMessageNoProcedureInfo
         {
             get
@@ -790,6 +918,11 @@ namespace Microsoft.SqlTools.ServiceLayer
             return Keys.GetString(Keys.WorkspaceServiceBufferPositionOutOfOrder, sLine, sCol, eLine, eCol);
         }
 
+        public static string EditDataUnsupportedObjectType(string typeName)
+        {
+            return Keys.GetString(Keys.EditDataUnsupportedObjectType, typeName);
+        }
+
         [System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
         public class Keys
         {
@@ -1008,6 +1141,57 @@ namespace Microsoft.SqlTools.ServiceLayer
             public const string WorkspaceServiceBufferPositionOutOfOrder = "WorkspaceServiceBufferPositionOutOfOrder";
 
 
+            public const string EditDataSessionNotFound = "EditDataSessionNotFound";
+
+
+            public const string EditDataUnsupportedObjectType = "EditDataUnsupportedObjectType";
+
+
+            public const string EditDataQueryNotCompleted = "EditDataQueryNotCompleted";
+
+
+            public const string EditDataQueryImproperResultSets = "EditDataQueryImproperResultSets";
+
+
+            public const string EditDataFailedAddRow = "EditDataFailedAddRow";
+
+
+            public const string EditDataRowOutOfRange = "EditDataRowOutOfRange";
+
+
+            public const string EditDataUpdatePending = "EditDataUpdatePending";
+
+
+            public const string EditDataUpdateNotPending = "EditDataUpdateNotPending";
+
+
+            public const string EditDataObjectMetadataNotFound = "EditDataObjectMetadataNotFound";
+
+
+            public const string EditDataInvalidFormatBinary = "EditDataInvalidFormatBinary";
+
+
+            public const string EditDataInvalidFormatBoolean = "EditDataInvalidFormatBoolean";
+
+
+            public const string EditDataCreateScriptMissingValue = "EditDataCreateScriptMissingValue";
+
+
+            public const string EditDataDeleteSetCell = "EditDataDeleteSetCell";
+
+
+            public const string EditDataColumnIdOutOfRange = "EditDataColumnIdOutOfRange";
+
+
+            public const string EditDataColumnCannotBeEdited = "EditDataColumnCannotBeEdited";
+
+
+            public const string EditDataColumnNoKeyColumns = "EditDataColumnNoKeyColumns";
+
+
+            public const string EditDataScriptFilePathNull = "EditDataScriptFilePathNull";
+
+
             public const string EE_BatchSqlMessageNoProcedureInfo = "EE_BatchSqlMessageNoProcedureInfo";
 
 

src/Microsoft.SqlTools.ServiceLayer/Localization/sr.resx

@@ -410,6 +410,75 @@
     <comment>.
  Parameters: 0 - sLine (int), 1 - sCol (int), 2 - eLine (int), 3 - eCol (int) </comment>
   </data>
+  <data name="EditDataSessionNotFound" xml:space="preserve">
+    <value>Edit session does not exist.</value>
+    <comment></comment>
+  </data>
+  <data name="EditDataUnsupportedObjectType" xml:space="preserve">
+    <value>Database object {0} cannot be used for editing.</value>
+    <comment>.
+ Parameters: 0 - typeName (string) </comment>
+  </data>
+  <data name="EditDataQueryNotCompleted" xml:space="preserve">
+    <value>Query has not completed execution</value>
+    <comment></comment>
+  </data>
+  <data name="EditDataQueryImproperResultSets" xml:space="preserve">
+    <value>Query did not generate exactly one result set</value>
+    <comment></comment>
+  </data>
+  <data name="EditDataFailedAddRow" xml:space="preserve">
+    <value>Failed to add new row to update cache</value>
+    <comment></comment>
+  </data>
+  <data name="EditDataRowOutOfRange" xml:space="preserve">
+    <value>Given row ID is outside the range of rows in the edit cache</value>
+    <comment></comment>
+  </data>
+  <data name="EditDataUpdatePending" xml:space="preserve">
+    <value>An update is already pending for this row and must be reverted first</value>
+    <comment></comment>
+  </data>
+  <data name="EditDataUpdateNotPending" xml:space="preserve">
+    <value>Given row ID does not have pending updated</value>
+    <comment></comment>
+  </data>
+  <data name="EditDataObjectMetadataNotFound" xml:space="preserve">
+    <value>Table or view metadata could not be found</value>
+    <comment></comment>
+  </data>
+  <data name="EditDataInvalidFormatBinary" xml:space="preserve">
+    <value>Invalid format for binary column</value>
+    <comment></comment>
+  </data>
+  <data name="EditDataInvalidFormatBoolean" xml:space="preserve">
+    <value>Allowed values for boolean columns are 0, 1, "true", or "false"</value>
+    <comment></comment>
+  </data>
+  <data name="EditDataCreateScriptMissingValue" xml:space="preserve">
+    <value>A required cell value is missing</value>
+    <comment></comment>
+  </data>
+  <data name="EditDataDeleteSetCell" xml:space="preserve">
+    <value>A delete is pending for this row, a cell update cannot be applied.</value>
+    <comment></comment>
+  </data>
+  <data name="EditDataColumnIdOutOfRange" xml:space="preserve">
+    <value>Column ID must be in the range of columns for the query</value>
+    <comment></comment>
+  </data>
+  <data name="EditDataColumnCannotBeEdited" xml:space="preserve">
+    <value>Column cannot be edited</value>
+    <comment></comment>
+  </data>
+  <data name="EditDataColumnNoKeyColumns" xml:space="preserve">
+    <value>No key columns were found</value>
+    <comment></comment>
+  </data>
+  <data name="EditDataScriptFilePathNull" xml:space="preserve">
+    <value>An output filename must be provided</value>
+    <comment></comment>
+  </data>
   <data name="EE_BatchSqlMessageNoProcedureInfo" xml:space="preserve">
     <value>Msg {0}, Level {1}, State {2}, Line {3}</value>
     <comment></comment>

src/Microsoft.SqlTools.ServiceLayer/Localization/sr.strings

@@ -201,6 +201,43 @@ WorkspaceServicePositionColumnOutOfRange(int line) = Position is outside of colu
 
 WorkspaceServiceBufferPositionOutOfOrder(int sLine, int sCol, int eLine, int eCol) = Start position ({0}, {1}) must come before or be equal to the end position ({2}, {3})
 
+############################################################################
+# Edit Data Service
+
+EditDataSessionNotFound = Edit session does not exist.
+
+EditDataUnsupportedObjectType(string typeName) = Database object {0} cannot be used for editing.
+
+EditDataQueryNotCompleted = Query has not completed execution
+
+EditDataQueryImproperResultSets = Query did not generate exactly one result set
+
+EditDataFailedAddRow = Failed to add new row to update cache
+
+EditDataRowOutOfRange = Given row ID is outside the range of rows in the edit cache
+
+EditDataUpdatePending = An update is already pending for this row and must be reverted first
+
+EditDataUpdateNotPending = Given row ID does not have pending updated
+
+EditDataObjectMetadataNotFound = Table or view metadata could not be found
+
+EditDataInvalidFormatBinary = Invalid format for binary column
+
+EditDataInvalidFormatBoolean = Allowed values for boolean columns are 0, 1, "true", or "false"
+
+EditDataCreateScriptMissingValue = A required cell value is missing
+
+EditDataDeleteSetCell = A delete is pending for this row, a cell update cannot be applied.
+
+EditDataColumnIdOutOfRange = Column ID must be in the range of columns for the query
+
+EditDataColumnCannotBeEdited = Column cannot be edited
+
+EditDataColumnNoKeyColumns = No key columns were found
+
+EditDataScriptFilePathNull = An output filename must be provided
+
 ############################################################################
 # DacFx Resources
 

src/Microsoft.SqlTools.ServiceLayer/Localization/sr.xlf

@@ -509,6 +509,92 @@
         <target state="new">Replacement of an empty string by an empty string.</target>
         <note></note>
       </trans-unit>
+      <trans-unit id="EditDataSessionNotFound">
+        <source>Edit session does not exist.</source>
+        <target state="new">Edit session does not exist.</target>
+        <note></note>
+      </trans-unit>
+      <trans-unit id="EditDataQueryNotCompleted">
+        <source>Query has not completed execution</source>
+        <target state="new">Query has not completed execution</target>
+        <note></note>
+      </trans-unit>
+      <trans-unit id="EditDataQueryImproperResultSets">
+        <source>Query did not generate exactly one result set</source>
+        <target state="new">Query did not generate exactly one result set</target>
+        <note></note>
+      </trans-unit>
+      <trans-unit id="EditDataFailedAddRow">
+        <source>Failed to add new row to update cache</source>
+        <target state="new">Failed to add new row to update cache</target>
+        <note></note>
+      </trans-unit>
+      <trans-unit id="EditDataRowOutOfRange">
+        <source>Given row ID is outside the range of rows in the edit cache</source>
+        <target state="new">Given row ID is outside the range of rows in the edit cache</target>
+        <note></note>
+      </trans-unit>
+      <trans-unit id="EditDataUpdatePending">
+        <source>An update is already pending for this row and must be reverted first</source>
+        <target state="new">An update is already pending for this row and must be reverted first</target>
+        <note></note>
+      </trans-unit>
+      <trans-unit id="EditDataUpdateNotPending">
+        <source>Given row ID does not have pending updated</source>
+        <target state="new">Given row ID does not have pending updated</target>
+        <note></note>
+      </trans-unit>
+      <trans-unit id="EditDataObjectMetadataNotFound">
+        <source>Table or view metadata could not be found</source>
+        <target state="new">Table or view metadata could not be found</target>
+        <note></note>
+      </trans-unit>
+      <trans-unit id="EditDataInvalidFormatBinary">
+        <source>Invalid format for binary column</source>
+        <target state="new">Invalid format for binary column</target>
+        <note></note>
+      </trans-unit>
+      <trans-unit id="EditDataInvalidFormatBoolean">
+        <source>Allowed values for boolean columns are 0, 1, "true", or "false"</source>
+        <target state="new">Boolean columns must be numeric 1 or 0, or string true or false</target>
+        <note></note>
+      </trans-unit>
+      <trans-unit id="EditDataCreateScriptMissingValue">
+        <source>A required cell value is missing</source>
+        <target state="new">A required cell value is missing</target>
+        <note></note>
+      </trans-unit>
+      <trans-unit id="EditDataDeleteSetCell">
+        <source>A delete is pending for this row, a cell update cannot be applied.</source>
+        <target state="new">A delete is pending for this row, a cell update cannot be applied.</target>
+        <note></note>
+      </trans-unit>
+      <trans-unit id="EditDataColumnIdOutOfRange">
+        <source>Column ID must be in the range of columns for the query</source>
+        <target state="new">Column ID must be in the range of columns for the query</target>
+        <note></note>
+      </trans-unit>
+      <trans-unit id="EditDataColumnCannotBeEdited">
+        <source>Column cannot be edited</source>
+        <target state="new">Column cannot be edited</target>
+        <note></note>
+      </trans-unit>
+      <trans-unit id="EditDataColumnNoKeyColumns">
+        <source>No key columns were found</source>
+        <target state="new">No key columns were found</target>
+        <note></note>
+      </trans-unit>
+      <trans-unit id="EditDataScriptFilePathNull">
+        <source>An output filename must be provided</source>
+        <target state="new">An output filename must be provided</target>
+        <note></note>
+      </trans-unit>
+      <trans-unit id="EditDataUnsupportedObjectType">
+        <source>Database object {0} cannot be used for editing.</source>
+        <target state="new">Database object {0} cannot be used for editing.</target>
+        <note>.
+ Parameters: 0 - typeName (string) </note>
+      </trans-unit>
     </body>
   </file>
 </xliff>

src/Microsoft.SqlTools.ServiceLayer/QueryExecution/Contracts/DbCellValue.cs

@@ -15,6 +15,11 @@ namespace Microsoft.SqlTools.ServiceLayer.QueryExecution.Contracts
         /// </summary>
         public string DisplayValue { get; set; }
 
+        /// <summary>
+        /// Whether or not the cell is NULL
+        /// </summary>
+        public bool IsNull { get; set; }
+
         /// <summary>
         /// The raw object for the cell, for use internally
         /// </summary>

src/Microsoft.SqlTools.ServiceLayer/QueryExecution/Contracts/DbColumnWrapper.cs

@@ -4,9 +4,11 @@
 
 using System;
 using System.Collections.Generic;
+using System.Data;
 using System.Data.Common;
 using System.Data.SqlTypes;
 using System.Diagnostics;
+using Microsoft.SqlTools.ServiceLayer.Utility;
 
 namespace Microsoft.SqlTools.ServiceLayer.QueryExecution.Contracts
 {
@@ -16,10 +18,12 @@ namespace Microsoft.SqlTools.ServiceLayer.QueryExecution.Contracts
     /// </summary>
     public class DbColumnWrapper : DbColumn
     {
+        #region Constants
+
         /// <summary>
         /// All types supported by the server, stored as a hash set to provide O(1) lookup
         /// </summary>
-        internal static readonly HashSet<string> AllServerDataTypes = new HashSet<string>
+        private static readonly HashSet<string> AllServerDataTypes = new HashSet<string>
         {
             "bigint",
             "binary",
@@ -52,6 +56,12 @@ namespace Microsoft.SqlTools.ServiceLayer.QueryExecution.Contracts
             "datetime2"
         };
 
+        private const string SqlXmlDataTypeName = "xml";
+        private const string DbTypeXmlDataTypeName = "DBTYPE_XML";
+        private const string UnknownTypeName = "unknown";
+
+        #endregion
+
         /// <summary>
         /// Constructor for a DbColumnWrapper
         /// </summary>
@@ -81,21 +91,49 @@ namespace Microsoft.SqlTools.ServiceLayer.QueryExecution.Contracts
             NumericScale = column.NumericScale;
             UdtAssemblyQualifiedName = column.UdtAssemblyQualifiedName;
             DataType = column.DataType;
-            DataTypeName = column.DataTypeName;
+            DataTypeName = column.DataTypeName.ToLowerInvariant();
+
+            // Determine the SqlDbType
+            SqlDbType type;
+            if (Enum.TryParse(DataTypeName, true, out type))
+            {
+                SqlDbType = type;
+            }
+            else
+            {
+                switch (DataTypeName)
+                {
+                    case "numeric":
+                        SqlDbType = SqlDbType.Decimal;
+                        break;
+                    case "sql_variant":
+                        SqlDbType = SqlDbType.Variant;
+                        break;
+                    case "timestamp":
+                        SqlDbType = SqlDbType.VarBinary;
+                        break;
+                    case "sysname":
+                        SqlDbType = SqlDbType.NVarChar;
+                        break;
+                    default:
+                        SqlDbType = DataTypeName.EndsWith(".sys.hierarchyid") ? SqlDbType.NVarChar : SqlDbType.Udt;
+                        break;
+                }
+            }
 
             // We want the display name for the column to always exist
             ColumnName = string.IsNullOrEmpty(column.ColumnName)
                 ? SR.QueryServiceColumnNull
                 : column.ColumnName;
 
-            switch (column.DataTypeName)
+            switch (DataTypeName)
             {
                 case "varchar":
                 case "nvarchar":
                     IsChars = true;
 
-                    Debug.Assert(column.ColumnSize.HasValue);
-                    if (column.ColumnSize.Value == int.MaxValue)
+                    Debug.Assert(ColumnSize.HasValue);
+                    if (ColumnSize.Value == int.MaxValue)
                     {
                         //For Yukon, special case nvarchar(max) with column name == "Microsoft SQL Server 2005 XML Showplan" -
                         //assume it is an XML showplan.
@@ -131,8 +169,8 @@ namespace Microsoft.SqlTools.ServiceLayer.QueryExecution.Contracts
                 case "rowversion":
                     IsBytes = true;
 
-                    Debug.Assert(column.ColumnSize.HasValue);
-                    if (column.ColumnSize.Value == int.MaxValue)
+                    Debug.Assert(ColumnSize.HasValue);
+                    if (ColumnSize.Value == int.MaxValue)
                     {
                         IsLong = true;
                     }
@@ -141,7 +179,7 @@ namespace Microsoft.SqlTools.ServiceLayer.QueryExecution.Contracts
                     IsSqlVariant = true;
                     break;
                 default:
-                    if (!AllServerDataTypes.Contains(column.DataTypeName))
+                    if (!AllServerDataTypes.Contains(DataTypeName))
                     {
                         // treat all UDT's as long/bytes data types to prevent the CLR from attempting
                         // to load the UDT assembly into our process to call ToString() on the object.
@@ -216,6 +254,43 @@ namespace Microsoft.SqlTools.ServiceLayer.QueryExecution.Contracts
         /// </summary>
         public bool IsJson { get; set; }
 
+        /// <summary>
+        /// The SqlDbType of the column, for use in a SqlParameter
+        /// </summary>
+        public SqlDbType SqlDbType { get; private set; }
+
+        /// <summary>
+        /// Whether or not the column is an XML Reader type.
+        /// </summary>
+        /// <remarks>
+        /// Logic taken from SSDT determination of whether a column is a SQL XML type. It may not
+        /// be possible to have XML readers from .NET Core SqlClient.
+        /// </remarks>
+        public bool IsSqlXmlType => DataTypeName.Equals(SqlXmlDataTypeName, StringComparison.OrdinalIgnoreCase) ||
+                                    DataTypeName.Equals(DbTypeXmlDataTypeName, StringComparison.OrdinalIgnoreCase) ||
+                                    DataType == typeof(System.Xml.XmlReader);
+
+        /// <summary>
+        /// Whether or not the column is an unknown type
+        /// </summary>
+        /// <remarks>
+        /// Logic taken from SSDT determination of unknown columns. It may not even be possible to
+        /// have "unknown" column types with the .NET Core SqlClient.
+        /// </remarks>
+        public bool IsUnknownType => DataType == typeof(object) &&
+                                     DataTypeName.Equals(UnknownTypeName, StringComparison.OrdinalIgnoreCase);
+
+        /// <summary>
+        /// Whether or not the column can be updated, based on whether it's an auto increment
+        /// column, is an XML reader column, and if it's read only.
+        /// </summary>
+        /// <remarks>
+        /// Logic taken from SSDT determination of updatable columns
+        /// </remarks>
+        public bool IsUpdatable => !IsAutoIncrement.HasTrue() && 
+                                   !IsReadOnly.HasTrue() && 
+                                   !IsSqlXmlType;
+
         #endregion
 
     }

src/Microsoft.SqlTools.ServiceLayer/QueryExecution/DataStorage/ServiceBufferFileStreamReader.cs

@@ -199,6 +199,7 @@ namespace Microsoft.SqlTools.ServiceLayer.QueryExecution.DataStorage
             {
                 result.RawObject = null;
                 result.DisplayValue = null;
+                result.IsNull = true;
             }
             else
             {
@@ -207,6 +208,7 @@ namespace Microsoft.SqlTools.ServiceLayer.QueryExecution.DataStorage
                 T resultObject = convertFunc(length.ValueLength);
                 result.RawObject = resultObject;
                 result.DisplayValue = toStringFunc == null ? result.RawObject.ToString() : toStringFunc(resultObject);
+                result.IsNull = false;
             }
 
             return new FileStreamReadResult(result, length.TotalLength);

src/Microsoft.SqlTools.ServiceLayer/QueryExecution/QueryExecutionService.cs

@@ -151,11 +151,14 @@ namespace Microsoft.SqlTools.ServiceLayer.QueryExecution
             RequestContext<ExecuteRequestResult> requestContext)
         {
             // Setup actions to perform upon successful start and on failure to start
-            Func<Task> queryCreationAction = () => requestContext.SendResult(new ExecuteRequestResult());
-            Func<string, Task> queryFailAction = requestContext.SendError;
+            Func<Query, Task<bool>> queryCreateSuccessAction = async q => {
+                await requestContext.SendResult(new ExecuteRequestResult());
+                return true;
+            };
+            Func<string, Task> queryCreateFailureAction = requestContext.SendError;
 
             // Use the internal handler to launch the query
-            return InterServiceExecuteQuery(executeParams, requestContext, queryCreationAction, queryFailAction);
+            return InterServiceExecuteQuery(executeParams, requestContext, queryCreateSuccessAction, queryCreateFailureAction, null, null);
         }
 
         /// <summary>
@@ -328,26 +331,59 @@ namespace Microsoft.SqlTools.ServiceLayer.QueryExecution
         /// Query execution meant to be called from another service. Utilizes callbacks to allow
         /// custom actions to be taken upon creation of query and failure to create query.
         /// </summary>
-        /// <param name="executeParams">Params for creating the new query</param>
-        /// <param name="eventSender">Object that can send events for query execution progress</param>
-        /// <param name="queryCreatedAction">
-        /// Action to perform when query has been successfully created, right before execution of 
-        /// the query
+        /// <param name="executeParams">Parameters for execution</param>
+        /// <param name="queryEventSender">Event sender that will send progressive events during execution of the query</param>
+        /// <param name="queryCreateSuccessFunc">
+        /// Callback for when query has been created successfully. If result is <c>true</c>, query
+        /// will be executed asynchronously. If result is <c>false</c>, query will be disposed. May
+        /// be <c>null</c>
         /// </param>
-        /// <param name="failureAction">Action to perform if query was not successfully created</param>
-        public async Task InterServiceExecuteQuery(ExecuteRequestParamsBase executeParams, IEventSender eventSender,
-            Func<Task> queryCreatedAction, Func<string, Task> failureAction)
+        /// <param name="queryCreateFailFunc">
+        /// Callback for when query failed to be created successfully. Error message is provided.
+        /// May be <c>null</c>.
+        /// </param>
+        /// <param name="querySuccessFunc">
+        /// Callback to call when query has completed execution successfully. May be <c>null</c>.
+        /// </param>
+        /// <param name="queryFailureFunc">
+        /// Callback to call when query has completed execution with errors. May be <c>null</c>.
+        /// </param>
+        public async Task InterServiceExecuteQuery(ExecuteRequestParamsBase executeParams, 
+            IEventSender queryEventSender,
+            Func<Query, Task<bool>> queryCreateSuccessFunc,
+            Func<string, Task> queryCreateFailFunc,
+            Query.QueryAsyncEventHandler querySuccessFunc, 
+            Query.QueryAsyncEventHandler queryFailureFunc)
         {
             Validate.IsNotNull(nameof(executeParams), executeParams);
-            Validate.IsNotNull(nameof(eventSender), eventSender);
-            Validate.IsNotNull(nameof(queryCreatedAction), queryCreatedAction);
-            Validate.IsNotNull(nameof(failureAction), failureAction);
-
-            // Get a new active query
-            Query newQuery = await CreateAndActivateNewQuery(executeParams, queryCreatedAction, failureAction);
+            Validate.IsNotNull(nameof(queryEventSender), queryEventSender);
+            
+            Query newQuery;
+            try
+            {
+                // Get a new active query
+                newQuery = CreateQuery(executeParams);
+                if (queryCreateSuccessFunc != null && !await queryCreateSuccessFunc(newQuery))
+                {
+                    // The callback doesn't want us to continue, for some reason
+                    // It's ok if we leave the query behind in the active query list, the next call
+                    // to execute will replace it.
+                    newQuery.Dispose();
+                    return;
+                }
+            }
+            catch (Exception e)
+            {
+                // Call the failure callback if it was provided
+                if (queryCreateFailFunc != null)
+                {
+                    await queryCreateFailFunc(e.Message);
+                }
+                return;
+            }
 
             // Execute the query asynchronously
-            ExecuteAndCompleteQuery(executeParams.OwnerUri, eventSender, newQuery);
+            ExecuteAndCompleteQuery(executeParams.OwnerUri, newQuery, queryEventSender, querySuccessFunc, queryFailureFunc);
         }
 
         /// <summary>
@@ -390,63 +426,47 @@ namespace Microsoft.SqlTools.ServiceLayer.QueryExecution
 
         #region Private Helpers
 
-        private async Task<Query> CreateAndActivateNewQuery(ExecuteRequestParamsBase executeParams, Func<Task> successAction, Func<string, Task> failureAction)
+        private Query CreateQuery(ExecuteRequestParamsBase executeParams)
         {
-            try
+            // Attempt to get the connection for the editor
+            ConnectionInfo connectionInfo;
+            if (!ConnectionService.TryFindConnection(executeParams.OwnerUri, out connectionInfo))
             {
-                // Attempt to get the connection for the editor
-                ConnectionInfo connectionInfo;
-                if (!ConnectionService.TryFindConnection(executeParams.OwnerUri, out connectionInfo))
-                {
-                    await failureAction(SR.QueryServiceQueryInvalidOwnerUri);
-                    return null;
-                }
-
-                // Attempt to clean out any old query on the owner URI
-                Query oldQuery;
-                if (ActiveQueries.TryGetValue(executeParams.OwnerUri, out oldQuery) && oldQuery.HasExecuted)
-                {
-                    oldQuery.Dispose();
-                    ActiveQueries.TryRemove(executeParams.OwnerUri, out oldQuery);
-                }
-
-                // Retrieve the current settings for executing the query with
-                QueryExecutionSettings querySettings = Settings.QueryExecutionSettings;
-
-                // Apply execution parameter settings 
-                querySettings.ExecutionPlanOptions = executeParams.ExecutionPlanOptions;
-
-                // If we can't add the query now, it's assumed the query is in progress
-                Query newQuery = new Query(GetSqlText(executeParams), connectionInfo, querySettings, BufferFileFactory);
-                if (!ActiveQueries.TryAdd(executeParams.OwnerUri, newQuery))
-                {
-                    await failureAction(SR.QueryServiceQueryInProgress);
-                    newQuery.Dispose();
-                    return null;
-                }
-
-                // Successfully created query
-                await successAction();
-
-                return newQuery;
+                throw new ArgumentOutOfRangeException(nameof(executeParams.OwnerUri), SR.QueryServiceQueryInvalidOwnerUri);
             }
-            catch (Exception e)
+
+            // Attempt to clean out any old query on the owner URI
+            Query oldQuery;
+            if (ActiveQueries.TryGetValue(executeParams.OwnerUri, out oldQuery) && oldQuery.HasExecuted)
             {
-                await failureAction(e.Message);
-                return null;
+                oldQuery.Dispose();
+                ActiveQueries.TryRemove(executeParams.OwnerUri, out oldQuery);
             }
+
+            // Retrieve the current settings for executing the query with
+            QueryExecutionSettings settings = Settings.QueryExecutionSettings;
+
+            // Apply execution parameter settings 
+            settings.ExecutionPlanOptions = executeParams.ExecutionPlanOptions;
+
+            // If we can't add the query now, it's assumed the query is in progress
+            Query newQuery = new Query(GetSqlText(executeParams), connectionInfo, settings, BufferFileFactory);
+            if (!ActiveQueries.TryAdd(executeParams.OwnerUri, newQuery))
+            {
+                newQuery.Dispose();
+                throw new InvalidOperationException(SR.QueryServiceQueryInProgress);
+            }
+
+            return newQuery;
         }
 
-        private static void ExecuteAndCompleteQuery(string ownerUri, IEventSender eventSender, Query query)
+        private static void ExecuteAndCompleteQuery(string ownerUri, Query query,
+            IEventSender eventSender,
+            Query.QueryAsyncEventHandler querySuccessCallback,
+            Query.QueryAsyncEventHandler queryFailureCallback)
         {
-            // Skip processing if the query is null
-            if (query == null)
-            {
-                return;
-            }
-
-            // Setup the query completion/failure callbacks
-            Query.QueryAsyncEventHandler callback = async q =>
+            // Setup the callback to send the complete event
+            Query.QueryAsyncEventHandler completeCallback = async q =>
             {
                 // Send back the results
                 QueryCompleteParams eventParams = new QueryCompleteParams
@@ -457,9 +477,13 @@ namespace Microsoft.SqlTools.ServiceLayer.QueryExecution
 
                 await eventSender.SendEvent(QueryCompleteEvent.Type, eventParams);
             };
+            query.QueryCompleted += completeCallback;
+            query.QueryFailed += completeCallback;
 
-            query.QueryCompleted += callback;
-            query.QueryFailed += callback;
+            // Add the callbacks that were provided by the caller
+            // If they're null, that's no problem
+            query.QueryCompleted += querySuccessCallback;
+            query.QueryFailed += queryFailureCallback;
 
             // Setup the batch callbacks
             Batch.BatchAsyncEventHandler batchStartCallback = async b =>

src/Microsoft.SqlTools.ServiceLayer/QueryExecution/ResultSet.cs

@@ -183,6 +183,26 @@ namespace Microsoft.SqlTools.ServiceLayer.QueryExecution
 
         #region Public Methods
 
+        public IList<DbCellValue> GetRow(long rowId)
+        {
+            // Sanity check to make sure that results have been read beforehand
+            if (!hasBeenRead)
+            {
+                throw new InvalidOperationException(SR.QueryServiceResultSetNotRead);
+            }
+
+            // Sanity check to make sure that the row exists
+            if (rowId >= RowCount)
+            {
+                throw new ArgumentOutOfRangeException(nameof(rowId), SR.QueryServiceResultSetStartRowOutOfRange);
+            }
+
+            using (IFileStreamReader fileStreamReader = fileStreamFactory.GetReader(outputFileName))
+            {
+                return fileStreamReader.ReadRow(fileOffsets[rowId], Columns);
+            }
+        }
+
         /// <summary>
         /// Generates a subset of the rows from the result set
         /// </summary>

src/Microsoft.SqlTools.ServiceLayer/Utility/Extensions.cs

@@ -39,4 +39,21 @@ namespace Microsoft.SqlTools.ServiceLayer.Utility
             return isTrue ? "1" : "0";
         }
     }
+
+    internal static class NullableExtensions
+    {
+        /// <summary>
+        /// Extension method to evaluate a bool? and determine if it has the value and is true.
+        /// This way we avoid throwing if the bool? doesn't have a value.
+        /// </summary>
+        /// <param name="obj">The <c>bool?</c> to process</param>
+        /// <returns>
+        /// <c>true</c> if <paramref name="obj"/> has a value and it is <c>true</c>
+        /// <c>false</c> otherwise.
+        /// </returns>
+        public static bool HasTrue(this bool? obj)
+        {
+            return obj.HasValue && obj.Value;
+        }
+    }
 }

src/Microsoft.SqlTools.ServiceLayer/Utility/SqlScriptFormatter.cs

@@ -0,0 +1,263 @@
+//
+// 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.Globalization;
+using System.Linq;
+using System.Text;
+using Microsoft.SqlTools.ServiceLayer.QueryExecution.Contracts;
+
+namespace Microsoft.SqlTools.ServiceLayer.Utility
+{
+    /// <summary>
+    /// Provides utility for converting arbitrary objects into strings that are ready to be
+    /// inserted into SQL strings
+    /// </summary>
+    public class SqlScriptFormatter
+    {
+        #region Constants
+
+        public const string NullString = "NULL";
+
+        private static readonly Dictionary<string, Func<object, DbColumn, string>> FormatFunctions =
+           new Dictionary<string, Func<object, DbColumn, string>>
+           {                                                                                       // CLR Type --------
+                {"bigint", (val, col) => SimpleFormatter(val)},                                     // long
+                {"bit", (val, col) => FormatBool(val)},                                             // bool
+                {"int", (val, col) => SimpleFormatter(val)},                                        // int
+                {"smallint", (val, col) => SimpleFormatter(val)},                                   // short
+                {"tinyint", (val, col) => SimpleFormatter(val)},                                    // byte
+                {"money", (val, col) => FormatMoney(val, "MONEY")},                                 // Decimal
+                {"smallmoney", (val, col) => FormatMoney(val, "SMALLMONEY")},                       // Decimal
+                {"decimal", (val, col) => FormatPreciseNumeric(val, col, "DECIMAL")},               // Decimal
+                {"numeric", (val, col) => FormatPreciseNumeric(val, col, "NUMERIC")},               // Decimal
+                {"real", (val, col) => FormatFloat(val)},                                           // float
+                {"float", (val, col) => FormatDouble(val)},                                         // double
+                {"smalldatetime", (val, col) => FormatDateTime(val, "yyyy-MM-dd HH:mm:ss")},        // DateTime
+                {"datetime", (val, col) => FormatDateTime(val, "yyyy-MM-dd HH:mm:ss.FFF") },        // DateTime
+                {"datetime2", (val, col) => FormatDateTime(val, "yyyy-MM-dd HH:mm:ss.FFFFFFF")},    // DateTime
+                {"date", (val, col) => FormatDateTime(val, "yyyy-MM-dd")},                          // DateTime
+                {"datetimeoffset", (val, col) => FormatDateTimeOffset(val)},                        // DateTimeOffset
+                {"time", (val, col) => FormatTimeSpan(val)},                                        // TimeSpan
+                {"char", (val, col) => SimpleStringFormatter(val)},                                 // string
+                {"nchar", (val, col) => SimpleStringFormatter(val)},                                // string
+                {"varchar", (val, col) => SimpleStringFormatter(val)},                              // string
+                {"nvarchar", (val, col) => SimpleStringFormatter(val)},                             // string
+                {"text", (val, col) => SimpleStringFormatter(val)},                                 // string                     
+                {"ntext", (val, col) => SimpleStringFormatter(val)},                                // string
+                {"xml", (val, col) => SimpleStringFormatter(val)},                                  // string
+                {"binary", (val, col) => FormatBinary(val)},                                        // byte[]
+                {"varbinary", (val, col) => FormatBinary(val)},                                     // byte[]
+                {"image", (val, col) => FormatBinary(val)},                                         // byte[]
+                {"uniqueidentifier", (val, col) => SimpleStringFormatter(val)},                     // Guid
+                // Unsupported types:
+                // *.sys.hierarchyid - cannot cast byte string to hierarchyid
+                // geography         - cannot cast byte string to geography
+                // geometry          - cannot cast byte string to geometry
+                // timestamp         - cannot insert/update timestamp columns
+                // sql_variant       - casting logic isn't good enough
+                // sysname           - it doesn't appear possible to insert a sysname column
+           };
+
+        #endregion
+
+        /// <summary>
+        /// Converts an object into a string for SQL script
+        /// </summary>
+        /// <param name="value">The object to convert</param>
+        /// <param name="column">The column metadata for the cell to insert</param>
+        /// <returns>String version of the cell value for use in SQL scripts</returns>
+        public static string FormatValue(object value, DbColumn column)
+        {
+            Validate.IsNotNull(nameof(column), column);
+
+            // Handle nulls firstly
+            if (value == null)
+            {
+                return NullString;
+            }
+
+            // Determine how to format based on the column type
+            string dataType = column.DataTypeName.ToLowerInvariant();
+            if (!FormatFunctions.ContainsKey(dataType))
+            {
+                // Attempt to handle UDTs
+
+                // @TODO: to constants file
+                throw new ArgumentOutOfRangeException(nameof(column.DataTypeName), "A converter for {column type} is not available");
+            }
+            return FormatFunctions[dataType](value, column);
+        }
+
+        /// <summary>
+        /// Converts a cell value into a string for SQL script
+        /// </summary>
+        /// <param name="value">The cell to convert</param>
+        /// <param name="column">The column metadata for the cell to insert</param>
+        /// <returns>String version of the cell value for use in SQL scripts</returns>
+        public static string FormatValue(DbCellValue value, DbColumn column)
+        {
+            Validate.IsNotNull(nameof(value), value);
+
+            return FormatValue(value.RawObject, column);
+        }
+
+        /// <summary>
+        /// Escapes an identifier such as a table name or column name by wrapping it in square brackets
+        /// </summary>
+        /// <param name="identifier">The identifier to format</param>
+        /// <returns>Identifier formatted for use in a SQL script</returns>
+        public static string FormatIdentifier(string identifier)
+        {
+            return $"[{EscapeString(identifier, ']')}]";
+        }
+
+        /// <summary>
+        /// Escapes a multi-part identifier such as a table name or column name with multiple
+        /// parts split by '.'
+        /// </summary>
+        /// <param name="identifier">The identifier to escape</param>
+        /// <returns>The escaped identifier</returns>
+        public static string FormatMultipartIdentifier(string identifier)
+        {
+            // If the object is a multi-part identifier (eg, dbo.tablename) split it, and escape as necessary
+            return FormatMultipartIdentifier(identifier.Split('.'));
+        }
+
+        /// <summary>
+        /// Escapes a multipart identifier such as a table name, given an array of the parts of the
+        /// multipart identifier.
+        /// </summary>
+        /// <param name="identifiers">The parts of the identifier to escape</param>
+        /// <returns>An escaped version of the multipart identifier</returns>
+        public static string FormatMultipartIdentifier(string[] identifiers)
+        {
+            IEnumerable<string> escapedParts = identifiers.Select(FormatIdentifier);
+            return string.Join(".", escapedParts);
+        }
+
+        #region Private Helpers
+
+        private static string SimpleFormatter(object value)
+        {
+            return value.ToString();
+        }
+
+        private static string SimpleStringFormatter(object value)
+        {
+            return EscapeQuotedSqlString(value.ToString());
+        }
+
+        private static string FormatMoney(object value, string type)
+        {
+            // we have to manually format the string by ToStringing the value first, and then converting 
+            // the potential (European formatted) comma to a period.
+            string numericString = ((decimal)value).ToString(CultureInfo.InvariantCulture);
+            return $"CAST({numericString} AS {type})";
+        }
+
+        private static string FormatFloat(object value)
+        {
+            // The "R" formatting means "Round Trip", which preserves fidelity
+            return ((float)value).ToString("R");
+        }
+
+        private static string FormatDouble(object value)
+        {
+            // The "R" formatting means "Round Trip", which preserves fidelity
+            return ((double)value).ToString("R");
+        }
+
+        private static string FormatBool(object value)
+        {
+            // Attempt to cast to bool
+            bool boolValue = (bool)value;
+            return boolValue ? "1" : "0";
+        }
+
+        private static string FormatPreciseNumeric(object value, DbColumn column, string type)
+        {
+            // Make sure we have numeric precision and numeric scale
+            if (!column.NumericPrecision.HasValue || !column.NumericScale.HasValue)
+            {
+                // @TODO Move to constants
+                throw new InvalidOperationException("Decimal column is missing numeric precision or numeric scale");
+            }
+
+            // Convert the value to a decimal, then convert that to a string
+            string numericString = ((decimal)value).ToString(CultureInfo.InvariantCulture);
+            return string.Format(CultureInfo.InvariantCulture, "CAST({0} AS {1}({2}, {3}))",
+                numericString, type, column.NumericPrecision.Value, column.NumericScale.Value);
+        }
+
+        private static string FormatTimeSpan(object value)
+        {
+            // "c" provides "HH:mm:ss.FFFFFFF", and time column accepts up to 7 precision
+            string timeSpanString = ((TimeSpan)value).ToString("c", CultureInfo.InvariantCulture);
+            return EscapeQuotedSqlString(timeSpanString);
+        }
+
+        private static string FormatDateTime(object value, string format)
+        {
+            string dateTimeString = ((DateTime)value).ToString(format, CultureInfo.InvariantCulture);
+            return EscapeQuotedSqlString(dateTimeString);
+        }
+
+        private static string FormatDateTimeOffset(object value)
+        {
+            string dateTimeString = ((DateTimeOffset)value).ToString(CultureInfo.InvariantCulture);
+            return EscapeQuotedSqlString(dateTimeString);
+        }
+
+        private static string FormatBinary(object value)
+        {
+            byte[] bytes = value as byte[];
+            if (bytes == null)
+            {
+                // Bypass processing if we can't turn this into a byte[]
+                return "NULL";
+            }
+
+            return "0x" + BitConverter.ToString(bytes).Replace("-", string.Empty);
+        }
+
+        /// <summary>
+        /// Returns a valid SQL string packaged in single quotes with single quotes inside escaped
+        /// </summary>
+        /// <param name="rawString">String to be formatted</param>
+        /// <returns>Formatted SQL string</returns>
+        private static string EscapeQuotedSqlString(string rawString)
+        {
+            return $"N'{EscapeString(rawString, '\'')}'";
+        }
+
+        /// <summary>
+        /// Replaces all instances of <paramref name="escapeCharacter"/> with a duplicate of 
+        /// <paramref name="escapeCharacter"/>. For example "can't" becomes "can''t"
+        /// </summary>
+        /// <param name="value">The string to escape</param>
+        /// <param name="escapeCharacter">The character to escape</param>
+        /// <returns>The escaped string</returns>
+        private static string EscapeString(string value, char escapeCharacter)
+        {
+            Validate.IsNotNull(nameof(value), value);
+
+            StringBuilder sb = new StringBuilder();
+            foreach (char c in value)
+            {
+                sb.Append(c);
+                if (escapeCharacter == c)
+                {
+                    sb.Append(c);
+                }
+            }
+            return sb.ToString();
+        }
+
+        #endregion
+    }
+}