ckaczor/sqltoolsservice
1
0
Fork 0
mirror of https://github.com/ckaczor/sqltoolsservice.git synced 2026-01-18 01:25:41 -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

286
src/Microsoft.SqlTools.ServiceLayer/EditData/EditDataService.cs Normal file
View File

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