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/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
 
     }