ckaczor/azuredatastudio
1
0
Fork 0
mirror of https://github.com/ckaczor/azuredatastudio.git synced 2026-01-16 09:35:36 -05:00
Code Issues Packages Projects Releases Wiki Activity

Support Save As CSV/JSON/Excel/XML from Notebooks (#6627)

Browse Source 
Updated existing serialization code so it actually supports serialization. Still needs work to replace the saveAs function when a QueryProvider doesn't support save as, but want to handle in separate PR.
Removed separate MainThread/ExtHostSerializationProvider code as the DataProtocol code is the right place to put this code
Plumbed support through the gridOutputComponent to use the new serialize method in the serialization provider
Refactored the resultSerializer so majority of code can be shared between both implementations (for example file save dialog -> save -> show file on completion)

* Update to latest SQLToolsService release
This commit is contained in:
Kevin Cunnane
2019-08-09 11:37:53 -07:00
committed by GitHub
parent b589abbea5
commit fb7ece006d
20 changed files with 482 additions and 253 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
src/sql/workbench/api/browser/extensionHost.contribution.common.ts
View File

@@ -19,5 +19,4 @@ import './mainThreadNotebookDocumentsAndEditors';
import './mainThreadObjectExplorer';
import './mainThreadQueryEditor';
import './mainThreadResourceProvider';
import './mainThreadSerializationProvider';
import './mainThreadTasks';

20
src/sql/workbench/api/browser/mainThreadDataProtocol.ts
View File

@@ -134,11 +134,11 @@ export class MainThreadDataProtocol implements MainThreadDataProtocolShape {
return self._proxy.$disposeQuery(handle, ownerUri);
},
saveResults(requestParams: azdata.SaveResultsRequestParams): Thenable<azdata.SaveResultRequestResult> {
let serializationProvider = self._serializationService.getSerializationFeatureMetadataProvider(requestParams.ownerUri);
if (serializationProvider && serializationProvider.enabled) {
let saveResultsFeatureInfo = self._serializationService.getSaveResultsFeatureMetadataProvider(requestParams.ownerUri);
if (saveResultsFeatureInfo && saveResultsFeatureInfo.enabled) {
return self._proxy.$saveResults(handle, requestParams);
}
else if (serializationProvider && !serializationProvider.enabled) {
else if (saveResultsFeatureInfo && !saveResultsFeatureInfo.enabled) {
return self._serializationService.disabledSaveAs();
}
else {
@@ -499,6 +499,20 @@ export class MainThreadDataProtocol implements MainThreadDataProtocolShape {
return undefined;
}
public $registerSerializationProvider(providerId: string, handle: number): Promise<any> {
const self = this;
this._serializationService.registerProvider(providerId, <azdata.SerializationProvider>{
startSerialization(requestParams: azdata.SerializeDataStartRequestParams): Thenable<azdata.SerializeDataResult> {
return self._proxy.$startSerialization(handle, requestParams);
},
continueSerialization(requestParams: azdata.SerializeDataContinueRequestParams): Thenable<azdata.SerializeDataResult> {
return self._proxy.$continueSerialization(handle, requestParams);
},
});
return undefined;
}
// Connection Management handlers
public $onConnectionComplete(handle: number, connectionInfoSummary: azdata.ConnectionInfoSummary): void {
this._connectionManagementService.onConnectionComplete(handle, connectionInfoSummary);

59
src/sql/workbench/api/browser/mainThreadSerializationProvider.ts
View File

@@ -1,59 +0,0 @@
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the Source EULA. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
import { IDisposable, dispose } from 'vs/base/common/lifecycle';
import {
SqlExtHostContext, ExtHostSerializationProviderShape,
MainThreadSerializationProviderShape, SqlMainContext
} from 'sql/workbench/api/common/sqlExtHost.protocol';
import { ISerializationService } from 'sql/platform/serialization/common/serializationService';
import * as azdata from 'azdata';
import { IExtHostContext } from 'vs/workbench/api/common/extHost.protocol';
import { extHostNamedCustomer } from 'vs/workbench/api/common/extHostCustomers';
@extHostNamedCustomer(SqlMainContext.MainThreadSerializationProvider)
export class MainThreadSerializationProvider implements MainThreadSerializationProviderShape {
private _proxy: ExtHostSerializationProviderShape;
private _toDispose: IDisposable[];
private _registrations: { [handle: number]: IDisposable; } = Object.create(null);
constructor(
extHostContext: IExtHostContext,
@ISerializationService private serializationService: ISerializationService
) {
if (extHostContext) {
this._proxy = extHostContext.getProxy(SqlExtHostContext.ExtHostSerializationProvider);
}
}
public dispose(): void {
this._toDispose = dispose(this._toDispose);
}
public $registerSerializationProvider(handle: number): Promise<any> {
let self = this;
this._registrations[handle] = this.serializationService.addEventListener(handle, {
onSaveAs(saveFormat: string, savePath: string, results: string, appendToFile: boolean): Thenable<azdata.SaveResultRequestResult> {
return self._proxy.$saveAs(saveFormat, savePath, results, appendToFile);
}
});
return undefined;
}
public $unregisterSerializationProvider(handle: number): Promise<any> {
let registration = this._registrations[handle];
if (registration) {
registration.dispose();
delete this._registrations[handle];
}
return undefined;
}
}