/// <summary>
/// Process request to save a resultSet to a file in XML format
/// </summary>
internal async Task HandleSaveResultsAsXmlRequest(SaveResultsAsXmlRequestParams saveParams,
RequestContext <SaveResultRequestResult> requestContext)
{
// Use the default XML file factory if we haven't overridden it
IFileStreamFactory xmlFactory = XmlFileFactory ?? new SaveAsXmlFileStreamFactory
{
SaveRequestParams = saveParams,
QueryExecutionSettings = Settings.QueryExecutionSettings
};
await SaveResultsHelper(saveParams, requestContext, xmlFactory);
}
/// <summary>
/// Constructor, writes the header to the file, chains into the base constructor
/// </summary>
/// <param name="stream">FileStream to access the JSON file output</param>
/// <param name="requestParams">XML save as request parameters</param>
public SaveAsXmlFileStreamWriter(Stream stream, SaveResultsAsXmlRequestParams requestParams)
: base(stream, requestParams)
{
// Setup the internal state
var encoding = GetEncoding(requestParams);
xmlTextWriter = new XmlTextWriter(stream, encoding);
xmlTextWriter.Formatting = requestParams.Formatted ? Formatting.Indented : Formatting.None;
//Start the document and the root element
xmlTextWriter.WriteStartDocument();
xmlTextWriter.WriteStartElement(RootElementTag);
}
/// <summary>
/// Request to save query results as XML
/// </summary>
public async Task <SaveResultRequestResult> SaveAsXml(string ownerUri, string filename, int batchIndex, int resultSetIndex)
{
var saveParams = new SaveResultsAsXmlRequestParams
{
OwnerUri = ownerUri,
BatchIndex = batchIndex,
ResultSetIndex = resultSetIndex,
FilePath = filename
};
var result = await Driver.SendRequest(SaveResultsAsXmlRequest.Type, saveParams);
return(result);
}
private static IFileStreamFactory GetXmlStreamFactory(IDictionary <string, byte[]> storage,
SaveResultsAsXmlRequestParams saveParams)
{
Mock <IFileStreamFactory> mock = new Mock <IFileStreamFactory>();
mock.Setup(fsf => fsf.GetReader(It.IsAny <string>()))
.Returns <string>(output => new ServiceBufferFileStreamReader(new MemoryStream(storage[output]), new QueryExecutionSettings()));
mock.Setup(fsf => fsf.GetWriter(It.IsAny <string>()))
.Returns <string>(output =>
{
storage.Add(output, new byte[8192]);
return(new SaveAsXmlFileStreamWriter(new MemoryStream(storage[output]), saveParams));
});
return(mock.Object);
}
public async Task SaveResultAsXmlFailure()
{
// Given:
// ... A working query and workspace service
WorkspaceService <SqlToolsSettings> ws = Common.GetPrimedWorkspaceService(Constants.StandardQuery);
ConcurrentDictionary <string, byte[]> storage;
QueryExecutionService qes = Common.GetPrimedExecutionService(Common.StandardTestDataSet, true, false, false, ws, out storage);
// ... The query execution service has executed a query with results
var executeParams = new ExecuteDocumentSelectionParams {
QuerySelection = null, OwnerUri = Constants.OwnerUri
};
var executeRequest = RequestContextMocks.Create <ExecuteRequestResult>(null);
await qes.HandleExecuteRequest(executeParams, executeRequest.Object);
await qes.WorkTask;
await qes.ActiveQueries[Constants.OwnerUri].ExecutionTask;
// If: I attempt to save a result set and get it to throw because of invalid column selection
SaveResultsAsXmlRequestParams saveParams = new SaveResultsAsXmlRequestParams
{
BatchIndex = 0,
FilePath = "qqq",
OwnerUri = Constants.OwnerUri,
ResultSetIndex = 0,
ColumnStartIndex = -1,
ColumnEndIndex = 100,
RowStartIndex = 0,
RowEndIndex = 5
};
qes.XmlFileFactory = GetXmlStreamFactory(storage, saveParams);
var efv = new EventFlowValidator <SaveResultRequestResult>()
.AddStandardErrorValidation()
.Complete();
await qes.HandleSaveResultsAsXmlRequest(saveParams, efv.Object);
await qes.ActiveQueries[saveParams.OwnerUri]
.Batches[saveParams.BatchIndex]
.ResultSets[saveParams.ResultSetIndex]
.SaveTasks[saveParams.FilePath];
// Then:
// ... An error event should have been fired
// ... No success event should have been fired
efv.Validate();
}
public async Task SaveResultsAsXmlSuccess()
{
// Given:
// ... A working query and workspace service
WorkspaceService <SqlToolsSettings> ws = Common.GetPrimedWorkspaceService(Constants.StandardQuery);
ConcurrentDictionary <string, byte[]> storage;
QueryExecutionService qes = Common.GetPrimedExecutionService(Common.StandardTestDataSet, true, false, false, ws, out storage);
// ... The query execution service has executed a query with results
var executeParams = new ExecuteDocumentSelectionParams {
QuerySelection = null, OwnerUri = Constants.OwnerUri
};
var executeRequest = RequestContextMocks.Create <ExecuteRequestResult>(null);
await qes.HandleExecuteRequest(executeParams, executeRequest.Object);
await qes.WorkTask;
await qes.ActiveQueries[Constants.OwnerUri].ExecutionTask;
// If: I attempt to save a result set from a query
SaveResultsAsXmlRequestParams saveParams = new SaveResultsAsXmlRequestParams
{
OwnerUri = Constants.OwnerUri,
FilePath = "qqq",
BatchIndex = 0,
ResultSetIndex = 0,
Formatted = true
};
qes.XmlFileFactory = GetXmlStreamFactory(storage, saveParams);
var efv = new EventFlowValidator <SaveResultRequestResult>()
.AddStandardResultValidator()
.Complete();
await qes.HandleSaveResultsAsXmlRequest(saveParams, efv.Object);
await qes.ActiveQueries[saveParams.OwnerUri]
.Batches[saveParams.BatchIndex]
.ResultSets[saveParams.ResultSetIndex]
.SaveTasks[saveParams.FilePath];
// Then:
// ... I should have a successful result
// ... There should not have been an error
efv.Validate();
}
public async Task SaveResultsXmlNonExistentQuery()
{
// Given: A working query and workspace service
WorkspaceService <SqlToolsSettings> ws = Common.GetPrimedWorkspaceService(null);
QueryExecutionService qes = Common.GetPrimedExecutionService(null, false, false, false, ws);
// If: I attempt to save a result set from a query that doesn't exist
SaveResultsAsXmlRequestParams saveParams = new SaveResultsAsXmlRequestParams
{
OwnerUri = Constants.OwnerUri // Won't exist because nothing has executed
};
var efv = new EventFlowValidator <SaveResultRequestResult>()
.AddStandardErrorValidation()
.Complete();
await qes.HandleSaveResultsAsXmlRequest(saveParams, efv.Object);
// Then:
// ... An error event should have been fired
// ... No success event should have been fired
efv.Validate();
}
/// <summary>
/// Get the encoding for the XML file according to <param name="requestParams"></param>
/// </summary>
/// <param name="requestParams">XML save as request parameters</param>
/// <returns></returns>
private Encoding GetEncoding(SaveResultsAsXmlRequestParams requestParams)
{
Encoding.RegisterProvider(CodePagesEncodingProvider.Instance);
Encoding encoding;
try
{
if (int.TryParse(requestParams.Encoding, out var codepage))
{
encoding = Encoding.GetEncoding(codepage);
}
else
{
encoding = Encoding.GetEncoding(requestParams.Encoding);
}
}
catch
{
// Fallback encoding when specified codepage is invalid
encoding = Encoding.GetEncoding("utf-8");
}
return(encoding);
}
