ckaczor/sqltoolsservice
1
0
Fork 0
mirror of https://github.com/ckaczor/sqltoolsservice.git synced 2026-01-23 01:25:42 -05:00
Code Issues Packages Projects Releases Wiki Activity

Edit Data Service (#241)

Browse Source 
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
This commit is contained in:
Benjamin Russell
2017-02-22 17:32:57 -08:00
committed by GitHub
parent 2b15890b00
commit 795eba3da6
49 changed files with 4370 additions and 137 deletions
Download Patch File Download Diff File Expand all files Collapse all files

202
src/Microsoft.SqlTools.ServiceLayer/EditData/UpdateManagement/CellUpdate.cs Normal file
View File

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