mirror of
https://github.com/ckaczor/sqltoolsservice.git
synced 2026-01-18 17:23:52 -05:00
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
This commit is contained in:
Benjamin Russell
@@ -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
|
||||
}
|
||||
}
|
||||
@@ -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;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -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);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -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)}";
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -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
|
||||
};
|
||||
}
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user