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

Move protocol client out (#643)

Browse Source 
* close

* connection is working

* formatting

* adds all

* formatting

* formatting and changing how features are initialized

* formatting

* changed named of typings file

* update

* updated to use dataprotocol npm

* formatting

* removed unneeded logging

* readd npm shrinkwrap

* still not working

* removed unnecessary codfe

* addressed comments

* readded azure resource provider

* fix capabilities cacheing

* added backwards capat for older protocol

* update shrinkwrap

* update shrinkwrap

* updated shrinkwrap

* fixed tests

* removed dead code

* remove dead code

* fix compile

* remove backcompat stuff

* change location of npm

* vbump sqltools

* merge master

* fix imports

* fix build breaks

* update for sqlops

* update yarn dependencies
This commit is contained in:
Anthony Dresser
2018-02-20 13:38:16 -08:00
committed by GitHub
parent 8a9ee40524
commit 8570910a43
159 changed files with 4421 additions and 7180 deletions
Download Patch File Download Diff File Expand all files Collapse all files

127
src/sql/workbench/api/node/mainThreadDataProtocol.ts
View File

@@ -13,7 +13,7 @@ import {
import { IConnectionManagementService } from 'sql/parts/connection/common/connectionManagement';
import { ICapabilitiesService } from 'sql/services/capabilities/capabilitiesService';
import { IQueryManagementService } from 'sql/parts/query/common/queryManagement';
import * as data from 'data';
import * as sqlops from 'sqlops';
import { IMetadataService } from 'sql/services/metadata/metadataService';
import { IObjectExplorerService } from 'sql/parts/registeredServer/common/objectExplorerService';
import { IScriptingService } from 'sql/services/scripting/scriptingService';
@@ -26,6 +26,8 @@ import { ISerializationService } from 'sql/services/serialization/serializationS
import { IFileBrowserService } from 'sql/parts/fileBrowser/common/interfaces';
import { IExtHostContext } from 'vs/workbench/api/node/extHost.protocol';
import { extHostNamedCustomer } from 'vs/workbench/api/electron-browser/extHostCustomers';
import { IMessageService } from 'vs/platform/message/common/message';
import severity from 'vs/base/common/severity';
/**
* Main thread class for handling data protocol management registration.
@@ -53,7 +55,8 @@ export class MainThreadDataProtocol implements MainThreadDataProtocolShape {
@ITaskService private _taskService: ITaskService,
@IProfilerService private _profilerService: IProfilerService,
@ISerializationService private _serializationService: ISerializationService,
@IFileBrowserService private _fileBrowserService: IFileBrowserService
@IFileBrowserService private _fileBrowserService: IFileBrowserService,
@IMessageService private _messageService: IMessageService
) {
if (extHostContext) {
this._proxy = extHostContext.get(SqlExtHostContext.ExtHostDataProtocol);
@@ -69,8 +72,8 @@ export class MainThreadDataProtocol implements MainThreadDataProtocolShape {
public $registerConnectionProvider(providerId: string, handle: number): TPromise<any> {
const self = this;
this._connectionManagementService.registerProvider(providerId, <data.ConnectionProvider>{
connect(connectionUri: string, connectionInfo: data.ConnectionInfo): Thenable<boolean> {
this._connectionManagementService.registerProvider(providerId, <sqlops.ConnectionProvider>{
connect(connectionUri: string, connectionInfo: sqlops.ConnectionInfo): Thenable<boolean> {
return self._proxy.$connect(handle, connectionUri, connectionInfo);
},
disconnect(connectionUri: string): Thenable<boolean> {
@@ -82,7 +85,7 @@ export class MainThreadDataProtocol implements MainThreadDataProtocolShape {
cancelConnect(connectionUri: string): Thenable<boolean> {
return self._proxy.$cancelConnect(handle, connectionUri);
},
listDatabases(connectionUri: string): Thenable<data.ListDatabasesResult> {
listDatabases(connectionUri: string): Thenable<sqlops.ListDatabasesResult> {
return self._proxy.$listDatabases(handle, connectionUri);
},
rebuildIntelliSenseCache(connectionUri: string): Thenable<void> {
@@ -96,10 +99,10 @@ export class MainThreadDataProtocol implements MainThreadDataProtocolShape {
public $registerQueryProvider(providerId: string, handle: number): TPromise<any> {
const self = this;
this._queryManagementService.addQueryRequestHandler(providerId, {
cancelQuery(ownerUri: string): Thenable<data.QueryCancelResult> {
cancelQuery(ownerUri: string): Thenable<sqlops.QueryCancelResult> {
return self._proxy.$cancelQuery(handle, ownerUri);
},
runQuery(ownerUri: string, selection: data.ISelectionData, runOptions?: data.ExecutionPlanOptions): Thenable<void> {
runQuery(ownerUri: string, selection: sqlops.ISelectionData, runOptions?: sqlops.ExecutionPlanOptions): Thenable<void> {
return self._proxy.$runQuery(handle, ownerUri, selection, runOptions);
},
runQueryStatement(ownerUri: string, line: number, column: number): Thenable<void> {
@@ -108,16 +111,16 @@ export class MainThreadDataProtocol implements MainThreadDataProtocolShape {
runQueryString(ownerUri: string, queryString: string): Thenable<void> {
return self._proxy.$runQueryString(handle, ownerUri, queryString);
},
runQueryAndReturn(ownerUri: string, queryString: string): Thenable<data.SimpleExecuteResult> {
runQueryAndReturn(ownerUri: string, queryString: string): Thenable<sqlops.SimpleExecuteResult> {
return self._proxy.$runQueryAndReturn(handle, ownerUri, queryString);
},
getQueryRows(rowData: data.QueryExecuteSubsetParams): Thenable<data.QueryExecuteSubsetResult> {
getQueryRows(rowData: sqlops.QueryExecuteSubsetParams): Thenable<sqlops.QueryExecuteSubsetResult> {
return self._proxy.$getQueryRows(handle, rowData);
},
disposeQuery(ownerUri: string): Thenable<void> {
return self._proxy.$disposeQuery(handle, ownerUri);
},
saveResults(requestParams: data.SaveResultsRequestParams): Thenable<data.SaveResultRequestResult> {
saveResults(requestParams: sqlops.SaveResultsRequestParams): Thenable<sqlops.SaveResultRequestResult> {
let serializationProvider = self._serializationService.getSerializationFeatureMetadataProvider(requestParams.ownerUri);
if (serializationProvider && serializationProvider.enabled) {
return self._proxy.$saveResults(handle, requestParams);
@@ -132,13 +135,13 @@ export class MainThreadDataProtocol implements MainThreadDataProtocolShape {
initializeEdit(ownerUri: string, schemaName: string, objectName: string, objectType: string, rowLimit: number): Thenable<void> {
return self._proxy.$initializeEdit(handle, ownerUri, schemaName, objectName, objectType, rowLimit);
},
updateCell(ownerUri: string, rowId: number, columnId: number, newValue: string): Thenable<data.EditUpdateCellResult> {
updateCell(ownerUri: string, rowId: number, columnId: number, newValue: string): Thenable<sqlops.EditUpdateCellResult> {
return self._proxy.$updateCell(handle, ownerUri, rowId, columnId, newValue);
},
commitEdit(ownerUri): Thenable<void> {
return self._proxy.$commitEdit(handle, ownerUri);
},
createRow(ownerUri: string): Thenable<data.EditCreateRowResult> {
createRow(ownerUri: string): Thenable<sqlops.EditCreateRowResult> {
return self._proxy.$createRow(handle, ownerUri);
},
deleteRow(ownerUri: string, rowId: number): Thenable<void> {
@@ -147,13 +150,13 @@ export class MainThreadDataProtocol implements MainThreadDataProtocolShape {
disposeEdit(ownerUri: string): Thenable<void> {
return self._proxy.$disposeEdit(handle, ownerUri);
},
revertCell(ownerUri: string, rowId: number, columnId: number): Thenable<data.EditRevertCellResult> {
revertCell(ownerUri: string, rowId: number, columnId: number): Thenable<sqlops.EditRevertCellResult> {
return self._proxy.$revertCell(handle, ownerUri, rowId, columnId);
},
revertRow(ownerUri: string, rowId: number): Thenable<void> {
return self._proxy.$revertRow(handle, ownerUri, rowId);
},
getEditRows(rowData: data.EditSubsetParams): Thenable<data.EditSubsetResult> {
getEditRows(rowData: sqlops.EditSubsetParams): Thenable<sqlops.EditSubsetResult> {
return self._proxy.$getEditRows(handle, rowData);
}
});
@@ -163,11 +166,11 @@ export class MainThreadDataProtocol implements MainThreadDataProtocolShape {
public $registerBackupProvider(providerId: string, handle: number): TPromise<any> {
const self = this;
this._backupService.registerProvider(providerId, <data.BackupProvider>{
backup(connectionUri: string, backupInfo: { [key: string]: any }, taskExecutionMode: data.TaskExecutionMode): Thenable<data.BackupResponse> {
this._backupService.registerProvider(providerId, <sqlops.BackupProvider>{
backup(connectionUri: string, backupInfo: { [key: string]: any }, taskExecutionMode: sqlops.TaskExecutionMode): Thenable<sqlops.BackupResponse> {
return self._proxy.$backup(handle, connectionUri, backupInfo, taskExecutionMode);
},
getBackupConfigInfo(connectionUri: string): Thenable<data.BackupConfigInfo> {
getBackupConfigInfo(connectionUri: string): Thenable<sqlops.BackupConfigInfo> {
return self._proxy.$getBackupConfigInfo(handle, connectionUri);
}
});
@@ -177,17 +180,17 @@ export class MainThreadDataProtocol implements MainThreadDataProtocolShape {
public $registerRestoreProvider(providerId: string, handle: number): TPromise<any> {
const self = this;
this._restoreService.registerProvider(providerId, <data.RestoreProvider>{
getRestorePlan(connectionUri: string, restoreInfo: data.RestoreInfo): Thenable<data.RestorePlanResponse> {
this._restoreService.registerProvider(providerId, <sqlops.RestoreProvider>{
getRestorePlan(connectionUri: string, restoreInfo: sqlops.RestoreInfo): Thenable<sqlops.RestorePlanResponse> {
return self._proxy.$getRestorePlan(handle, connectionUri, restoreInfo);
},
cancelRestorePlan(connectionUri: string, restoreInfo: data.RestoreInfo): Thenable<boolean> {
cancelRestorePlan(connectionUri: string, restoreInfo: sqlops.RestoreInfo): Thenable<boolean> {
return self._proxy.$cancelRestorePlan(handle, connectionUri, restoreInfo);
},
restore(connectionUri: string, restoreInfo: data.RestoreInfo): Thenable<data.RestoreResponse> {
restore(connectionUri: string, restoreInfo: sqlops.RestoreInfo): Thenable<sqlops.RestoreResponse> {
return self._proxy.$restore(handle, connectionUri, restoreInfo);
},
getRestoreConfigInfo(connectionUri: string): Thenable<data.RestoreConfigInfo> {
getRestoreConfigInfo(connectionUri: string): Thenable<sqlops.RestoreConfigInfo> {
return self._proxy.$getRestoreConfigInfo(handle, connectionUri);
}
});
@@ -197,17 +200,17 @@ export class MainThreadDataProtocol implements MainThreadDataProtocolShape {
public $registerMetadataProvider(providerId: string, handle: number): TPromise<any> {
const self = this;
this._metadataService.registerProvider(providerId, <data.MetadataProvider>{
getMetadata(connectionUri: string): Thenable<data.ProviderMetadata> {
this._metadataService.registerProvider(providerId, <sqlops.MetadataProvider>{
getMetadata(connectionUri: string): Thenable<sqlops.ProviderMetadata> {
return self._proxy.$getMetadata(handle, connectionUri);
},
getDatabases(connectionUri: string): Thenable<string[]> {
return self._proxy.$getDatabases(handle, connectionUri);
},
getTableInfo(connectionUri: string, metadata: data.ObjectMetadata): Thenable<data.ColumnMetadata[]> {
getTableInfo(connectionUri: string, metadata: sqlops.ObjectMetadata): Thenable<sqlops.ColumnMetadata[]> {
return self._proxy.$getTableInfo(handle, connectionUri, metadata);
},
getViewInfo(connectionUri: string, metadata: data.ObjectMetadata): Thenable<data.ColumnMetadata[]> {
getViewInfo(connectionUri: string, metadata: sqlops.ObjectMetadata): Thenable<sqlops.ColumnMetadata[]> {
return self._proxy.$getViewInfo(handle, connectionUri, metadata);
}
});
@@ -217,17 +220,17 @@ export class MainThreadDataProtocol implements MainThreadDataProtocolShape {
public $registerObjectExplorerProvider(providerId: string, handle: number): TPromise<any> {
const self = this;
this._objectExplorerService.registerProvider(providerId, <data.ObjectExplorerProvider>{
createNewSession(connection: data.ConnectionInfo): Thenable<data.ObjectExplorerSessionResponse> {
this._objectExplorerService.registerProvider(providerId, <sqlops.ObjectExplorerProvider>{
createNewSession(connection: sqlops.ConnectionInfo): Thenable<sqlops.ObjectExplorerSessionResponse> {
return self._proxy.$createObjectExplorerSession(handle, connection);
},
expandNode(nodeInfo: data.ExpandNodeInfo): Thenable<boolean> {
expandNode(nodeInfo: sqlops.ExpandNodeInfo): Thenable<boolean> {
return self._proxy.$expandObjectExplorerNode(handle, nodeInfo);
},
refreshNode(nodeInfo: data.ExpandNodeInfo): Thenable<boolean> {
refreshNode(nodeInfo: sqlops.ExpandNodeInfo): Thenable<boolean> {
return self._proxy.$refreshObjectExplorerNode(handle, nodeInfo);
},
closeSession(closeSessionInfo: data.ObjectExplorerCloseSessionInfo): Thenable<data.ObjectExplorerCloseSessionResponse> {
closeSession(closeSessionInfo: sqlops.ObjectExplorerCloseSessionInfo): Thenable<sqlops.ObjectExplorerCloseSessionResponse> {
return self._proxy.$closeObjectExplorerSession(handle, closeSessionInfo);
}
});
@@ -237,11 +240,11 @@ export class MainThreadDataProtocol implements MainThreadDataProtocolShape {
public $registerTaskServicesProvider(providerId: string, handle: number): TPromise<any> {
const self = this;
this._taskService.registerProvider(providerId, <data.TaskServicesProvider>{
getAllTasks(listTasksParams: data.ListTasksParams): Thenable<data.ListTasksResponse> {
this._taskService.registerProvider(providerId, <sqlops.TaskServicesProvider>{
getAllTasks(listTasksParams: sqlops.ListTasksParams): Thenable<sqlops.ListTasksResponse> {
return self._proxy.$getAllTasks(handle, listTasksParams);
},
cancelTask(cancelTaskParams: data.CancelTaskParams): Thenable<boolean> {
cancelTask(cancelTaskParams: sqlops.CancelTaskParams): Thenable<boolean> {
return self._proxy.$cancelTask(handle, cancelTaskParams);
}
});
@@ -251,8 +254,8 @@ export class MainThreadDataProtocol implements MainThreadDataProtocolShape {
public $registerScriptingProvider(providerId: string, handle: number): TPromise<any> {
const self = this;
this._scriptingService.registerProvider(providerId, <data.ScriptingProvider>{
scriptAsOperation(connectionUri: string, operation: data.ScriptOperation, metadata: data.ObjectMetadata, paramDetails: data.ScriptingParamDetails): Thenable<data.ScriptingResult> {
this._scriptingService.registerProvider(providerId, <sqlops.ScriptingProvider>{
scriptAsOperation(connectionUri: string, operation: sqlops.ScriptOperation, metadata: sqlops.ObjectMetadata, paramDetails: sqlops.ScriptingParamDetails): Thenable<sqlops.ScriptingResult> {
return self._proxy.$scriptAsOperation(handle, connectionUri, operation, metadata, paramDetails);
}
});
@@ -262,7 +265,7 @@ export class MainThreadDataProtocol implements MainThreadDataProtocolShape {
public $registerFileBrowserProvider(providerId: string, handle: number): TPromise<any> {
const self = this;
this._fileBrowserService.registerProvider(providerId, <data.FileBrowserProvider>{
this._fileBrowserService.registerProvider(providerId, <sqlops.FileBrowserProvider>{
openFileBrowser(ownerUri: string, expandPath: string, fileFilters: string[], changeFilter: boolean): Thenable<boolean> {
return self._proxy.$openFileBrowser(handle, ownerUri, expandPath, fileFilters, changeFilter);
},
@@ -272,7 +275,7 @@ export class MainThreadDataProtocol implements MainThreadDataProtocolShape {
validateFilePaths(ownerUri: string, serviceType: string, selectedFiles: string[]): Thenable<boolean> {
return self._proxy.$validateFilePaths(handle, ownerUri, serviceType, selectedFiles);
},
closeFileBrowser(ownerUri: string): Thenable<data.FileBrowserCloseResponse> {
closeFileBrowser(ownerUri: string): Thenable<sqlops.FileBrowserCloseResponse> {
return self._proxy.$closeFileBrowser(handle, ownerUri);
}
});
@@ -282,7 +285,7 @@ export class MainThreadDataProtocol implements MainThreadDataProtocolShape {
public $registerProfilerProvider(providerId: string, handle: number): TPromise<any> {
const self = this;
this._profilerService.registerProvider(providerId, <data.ProfilerProvider>{
this._profilerService.registerProvider(providerId, <sqlops.ProfilerProvider>{
startSession(sessionId: string): Thenable<boolean> {
return self._proxy.$startSession(handle, sessionId);
},
@@ -305,17 +308,17 @@ export class MainThreadDataProtocol implements MainThreadDataProtocolShape {
public $registerAdminServicesProvider(providerId: string, handle: number): TPromise<any> {
const self = this;
this._adminService.registerProvider(providerId, <data.AdminServicesProvider>{
createDatabase(connectionUri: string, database: data.DatabaseInfo): Thenable<data.CreateDatabaseResponse> {
this._adminService.registerProvider(providerId, <sqlops.AdminServicesProvider>{
createDatabase(connectionUri: string, database: sqlops.DatabaseInfo): Thenable<sqlops.CreateDatabaseResponse> {
return self._proxy.$createDatabase(handle, connectionUri, database);
},
getDefaultDatabaseInfo(connectionUri: string): Thenable<data.DatabaseInfo> {
getDefaultDatabaseInfo(connectionUri: string): Thenable<sqlops.DatabaseInfo> {
return self._proxy.$getDefaultDatabaseInfo(handle, connectionUri);
},
getDatabaseInfo(connectionUri: string): Thenable<data.DatabaseInfo> {
getDatabaseInfo(connectionUri: string): Thenable<sqlops.DatabaseInfo> {
return self._proxy.$getDatabaseInfo(handle, connectionUri);
},
createLogin(connectionUri: string, login: data.LoginInfo): Thenable<data.CreateLoginResponse> {
createLogin(connectionUri: string, login: sqlops.LoginInfo): Thenable<sqlops.CreateLoginResponse> {
return self._proxy.$createLogin(handle, connectionUri, login);
}
});
@@ -325,8 +328,8 @@ export class MainThreadDataProtocol implements MainThreadDataProtocolShape {
public $registerCapabilitiesServiceProvider(providerId: string, handle: number): TPromise<any> {
const self = this;
this._capabilitiesService.registerProvider(<data.CapabilitiesProvider>{
getServerCapabilities(client: data.DataProtocolClientCapabilities): Thenable<data.DataProtocolServerCapabilities> {
this._capabilitiesService.registerProvider(<sqlops.CapabilitiesProvider>{
getServerCapabilities(client: sqlops.DataProtocolClientCapabilities): Thenable<sqlops.DataProtocolServerCapabilities> {
return self._proxy.$getServerCapabilities(handle, client);
}
});
@@ -335,7 +338,7 @@ export class MainThreadDataProtocol implements MainThreadDataProtocolShape {
}
// Connection Management handlers
public $onConnectionComplete(handle: number, connectionInfoSummary: data.ConnectionInfoSummary): void {
public $onConnectionComplete(handle: number, connectionInfoSummary: sqlops.ConnectionInfoSummary): void {
this._connectionManagementService.onConnectionComplete(handle, connectionInfoSummary);
}
@@ -343,24 +346,24 @@ export class MainThreadDataProtocol implements MainThreadDataProtocolShape {
this._connectionManagementService.onIntelliSenseCacheComplete(handle, connectionUri);
}
public $onConnectionChangeNotification(handle: number, changedConnInfo: data.ChangedConnectionInfo): void {
public $onConnectionChangeNotification(handle: number, changedConnInfo: sqlops.ChangedConnectionInfo): void {
this._connectionManagementService.onConnectionChangedNotification(handle, changedConnInfo);
}
// Query Management handlers
public $onQueryComplete(handle: number, result: data.QueryExecuteCompleteNotificationResult): void {
public $onQueryComplete(handle: number, result: sqlops.QueryExecuteCompleteNotificationResult): void {
this._queryManagementService.onQueryComplete(result);
}
public $onBatchStart(handle: number, batchInfo: data.QueryExecuteBatchNotificationParams): void {
public $onBatchStart(handle: number, batchInfo: sqlops.QueryExecuteBatchNotificationParams): void {
this._queryManagementService.onBatchStart(batchInfo);
}
public $onBatchComplete(handle: number, batchInfo: data.QueryExecuteBatchNotificationParams): void {
public $onBatchComplete(handle: number, batchInfo: sqlops.QueryExecuteBatchNotificationParams): void {
this._queryManagementService.onBatchComplete(batchInfo);
}
public $onResultSetComplete(handle: number, resultSetInfo: data.QueryExecuteResultSetCompleteNotificationParams): void {
public $onResultSetComplete(handle: number, resultSetInfo: sqlops.QueryExecuteResultSetCompleteNotificationParams): void {
this._queryManagementService.onResultSetComplete(resultSetInfo);
}
public $onQueryMessage(handle: number, message: data.QueryExecuteMessageParams): void {
public $onQueryMessage(handle: number, message: sqlops.QueryExecuteMessageParams): void {
this._queryManagementService.onMessage(message);
}
public $onEditSessionReady(handle: number, ownerUri: string, success: boolean, message: string): void {
@@ -368,43 +371,43 @@ export class MainThreadDataProtocol implements MainThreadDataProtocolShape {
}
// Script Handlers
public $onScriptingComplete(handle: number, scriptingCompleteResult: data.ScriptingCompleteResult): void {
public $onScriptingComplete(handle: number, scriptingCompleteResult: sqlops.ScriptingCompleteResult): void {
this._scriptingService.onScriptingComplete(handle, scriptingCompleteResult);
}
//OE handlers
public $onObjectExplorerSessionCreated(handle: number, sessionResponse: data.ObjectExplorerSession): void {
public $onObjectExplorerSessionCreated(handle: number, sessionResponse: sqlops.ObjectExplorerSession): void {
this._objectExplorerService.onSessionCreated(handle, sessionResponse);
}
public $onObjectExplorerNodeExpanded(handle: number, expandResponse: data.ObjectExplorerExpandInfo): void {
public $onObjectExplorerNodeExpanded(handle: number, expandResponse: sqlops.ObjectExplorerExpandInfo): void {
this._objectExplorerService.onNodeExpanded(handle, expandResponse);
}
//Tasks handlers
public $onTaskCreated(handle: number, taskInfo: data.TaskInfo): void {
public $onTaskCreated(handle: number, taskInfo: sqlops.TaskInfo): void {
this._taskService.onNewTaskCreated(handle, taskInfo);
}
public $onTaskStatusChanged(handle: number, taskProgressInfo: data.TaskProgressInfo): void {
public $onTaskStatusChanged(handle: number, taskProgressInfo: sqlops.TaskProgressInfo): void {
this._taskService.onTaskStatusChanged(handle, taskProgressInfo);
}
//File browser handlers
public $onFileBrowserOpened(handle: number, response: data.FileBrowserOpenedParams): void {
public $onFileBrowserOpened(handle: number, response: sqlops.FileBrowserOpenedParams): void {
this._fileBrowserService.onFileBrowserOpened(handle, response);
}
public $onFolderNodeExpanded(handle: number, response: data.FileBrowserExpandedParams): void {
public $onFolderNodeExpanded(handle: number, response: sqlops.FileBrowserExpandedParams): void {
this._fileBrowserService.onFolderNodeExpanded(handle, response);
}
public $onFilePathsValidated(handle: number, response: data.FileBrowserValidatedParams): void {
public $onFilePathsValidated(handle: number, response: sqlops.FileBrowserValidatedParams): void {
this._fileBrowserService.onFilePathsValidated(handle, response);
}
// Profiler handlers
public $onSessionEventsAvailable(handle: number, response: data.ProfilerSessionEvents): void {
public $onSessionEventsAvailable(handle: number, response: sqlops.ProfilerSessionEvents): void {
this._profilerService.onMoreRows(response);
}