mirror of
https://github.com/ckaczor/sqltoolsservice.git
synced 2026-01-14 17:23:27 -05:00
795eba3da6
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
85 lines
3.2 KiB
C#
85 lines
3.2 KiB
C#
//
|
|
// 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.Text.RegularExpressions;
|
|
using Microsoft.SqlTools.ServiceLayer.EditData;
|
|
using Microsoft.SqlTools.ServiceLayer.EditData.UpdateManagement;
|
|
using Microsoft.SqlTools.ServiceLayer.QueryExecution;
|
|
using Xunit;
|
|
|
|
namespace Microsoft.SqlTools.ServiceLayer.Test.EditData
|
|
{
|
|
public class RowCreateTests
|
|
{
|
|
[Fact]
|
|
public void RowCreateConstruction()
|
|
{
|
|
// Setup: Create the values to store
|
|
const long rowId = 100;
|
|
ResultSet rs = QueryExecution.Common.GetBasicExecutedBatch().ResultSets[0];
|
|
IEditTableMetadata etm = Common.GetMetadata(rs.Columns);
|
|
|
|
// If: I create a RowCreate instance
|
|
RowCreate rc = new RowCreate(rowId, rs, etm);
|
|
|
|
// Then: The values I provided should be available
|
|
Assert.Equal(rowId, rc.RowId);
|
|
Assert.Equal(rs, rc.AssociatedResultSet);
|
|
Assert.Equal(etm, rc.AssociatedObjectMetadata);
|
|
}
|
|
|
|
[Theory]
|
|
[InlineData(true)]
|
|
[InlineData(false)]
|
|
public void GetScript(bool includeIdentity)
|
|
{
|
|
// Setup: Generate the parameters for the row create
|
|
const long rowId = 100;
|
|
DbColumn[] columns = Common.GetColumns(includeIdentity);
|
|
ResultSet rs = Common.GetResultSet(columns, includeIdentity);
|
|
IEditTableMetadata etm = Common.GetMetadata(columns);
|
|
|
|
// If: I ask for a script to be generated without an identity column
|
|
RowCreate rc = new RowCreate(rowId, rs, etm);
|
|
Common.AddCells(rc, includeIdentity);
|
|
string script = rc.GetScript();
|
|
|
|
// Then:
|
|
// ... The script should not be null,
|
|
Assert.NotNull(script);
|
|
|
|
// ... It should be formatted as an insert script
|
|
Regex r = new Regex(@"INSERT INTO (.+)\((.*)\) VALUES \((.*)\)");
|
|
var m = r.Match(script);
|
|
Assert.True(m.Success);
|
|
|
|
// ... It should have 3 columns and 3 values (regardless of the presence of an identity col)
|
|
string tbl = m.Groups[1].Value;
|
|
string cols = m.Groups[2].Value;
|
|
string vals = m.Groups[3].Value;
|
|
Assert.Equal(etm.EscapedMultipartName, tbl);
|
|
Assert.Equal(3, cols.Split(',').Length);
|
|
Assert.Equal(3, vals.Split(',').Length);
|
|
}
|
|
|
|
[Fact]
|
|
public void GetScriptMissingCell()
|
|
{
|
|
// Setup: Generate the parameters for the row create
|
|
const long rowId = 100;
|
|
DbColumn[] columns = Common.GetColumns(false);
|
|
ResultSet rs = Common.GetResultSet(columns, false);
|
|
IEditTableMetadata etm = Common.GetMetadata(columns);
|
|
|
|
// If: I ask for a script to be generated without setting any values
|
|
// Then: An exception should be thrown for missing cells
|
|
RowCreate rc = new RowCreate(rowId, rs, etm);
|
|
Assert.Throws<InvalidOperationException>(() => rc.GetScript());
|
|
}
|
|
}
|
|
}
|