Edit Data Service (#241)

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

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

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

* Initial stubs for edit data service

* Stubbing out update management code

* Adding rudimentary dispose request

* More stubbing out of update row code

* Adding complete edit command contracts, stubbing out request handlers

* Adding basic implementation of get script

* More in progress work to implement base of row edits

* More in progress work to implement base of row edits

* Adding string => object conversion logic and various cleanup

* Adding a formatter for using values in scripts

* Splitting IMessageSender into IEventSender and IRequestSender

* Adding inter-service method for executing queries

* Adding inter-service method for disposing of a query

* Changing edit contract to include the object to edit

* Fully fleshing out edit session initialization

* Generation of delete scripts is working

* Adding scripter for update statements

* Adding scripting functionality for INSERT statements

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

* Polishing for SqlScriptFormatter

* Unit tests and reworked byte[] conversion

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

* Fixing syntax error in generated UPDATE statements

* Adding unit tests for RowCreate

* Adding tests for the row edit base class

* Adding row delete tests

* Adding RowUpdate tests, validation for number of key columns

* Adding tests for the unit class

* Adding get script tests for the session

* Service integration tests, except initialization tests

* Service integration tests, except initialization tests

* Adding messages to sr.strings

* Adding messages to sr.strings

* Fixing broken unit tests

* Adding factory pattern for SMO metadata provider

* Copyright and other comments

* Addressing first round of comments

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

* More revisions as per pull request comments

src/Microsoft.SqlTools.ServiceLayer/EditData/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;
+        }
+    }
+}