How to open the query result grid programmatically

[mrpowerus]

I'm trying to build a extension for Azure Data Studio. Currently I'm working on a custom QueryProvider and I'm implementing the azdata.QueryProvider interface.

However, when I run my query no result is showed:

When I open a query with a random MSSQL database, the 'Results' tab opens:

Now, when I navigate back to my previous query, the columns are visible:

Now, suddenly, with the 'Results' tab open, the getQueryRows function in my QueryProvider starts to fire. Which is exactly what I want.

So, what am I doing wrong? How can I open the 'Results' tab programmatically? I find it very hard to find good documentation for this. I think what I'm trying to build is not very exotic, right?

My current QueryProvider:

import * as azdata from 'azdata';
import * as vscode from 'vscode';
import { OdbcService } from './odbcService';
import { Result } from 'odbc';

export class QueryProvider implements azdata.QueryProvider {

    private OnQueryCompleteEmitter: vscode.EventEmitter<azdata.QueryExecuteCompleteNotificationResult> = new vscode.EventEmitter();
    OnQueryComplete: vscode.Event<azdata.QueryExecuteCompleteNotificationResult> = this.OnQueryCompleteEmitter.event;

    private OnBatchStartEmitter: vscode.EventEmitter<azdata.QueryExecuteBatchNotificationParams> = new vscode.EventEmitter();
    OnBatchStart: vscode.Event<azdata.QueryExecuteBatchNotificationParams> = this.OnBatchStartEmitter.event;

    private OnBatchCompleteEmitter: vscode.EventEmitter<azdata.QueryExecuteBatchNotificationParams> = new vscode.EventEmitter();
    OnBatchComplete: vscode.Event<azdata.QueryExecuteBatchNotificationParams> = this.OnBatchCompleteEmitter.event;

    private OnResultSetAvailableEmitter: vscode.EventEmitter<azdata.QueryExecuteResultSetNotificationParams> = new vscode.EventEmitter();
    OnResultSetAvailable: vscode.Event<azdata.QueryExecuteResultSetNotificationParams> = this.OnResultSetAvailableEmitter.event;

    private OnResultSetUpdatedEmitter: vscode.EventEmitter<azdata.QueryExecuteResultSetNotificationParams> = new vscode.EventEmitter();
    OnResultSetUpdated: vscode.Event<azdata.QueryExecuteResultSetNotificationParams> = this.OnResultSetUpdatedEmitter.event;

    private OnMessageEmitter: vscode.EventEmitter<azdata.QueryExecuteMessageParams> = new vscode.EventEmitter();
    OnMessage: vscode.Event<azdata.QueryExecuteMessageParams> = this.OnMessageEmitter.event;

    private OnEditSessionReadyEmitter: vscode.EventEmitter<[string, boolean, string]> = new vscode.EventEmitter();
    OnEditSessionReady: vscode.Event<[string, boolean, string]> = this.OnEditSessionReadyEmitter.event;

    constructor(private odbcService: OdbcService) {}

    cancelQuery(ownerUri: string): Thenable<azdata.QueryCancelResult> {
        throw new Error('Method not implemented.');
    }
    async runQuery(ownerUri: string, selection: azdata.ISelectionData, runOptions?: azdata.ExecutionPlanOptions | undefined): Promise<void> {
        
        this.odbcService.hasConnection(ownerUri)
        var doc = vscode.window.visibleTextEditors.filter((e)=>e.document.fileName==ownerUri.split(':')[1])[0]
        var query = doc.document.getText()
        vscode.window.showInformationMessage(query)
        var r = await this.runQueryAndReturn(ownerUri, query)
        this.OnResultSetAvailableEmitter.fire({
            ownerUri: ownerUri,
            resultSetSummary: {
                batchId: 1,
                columnInfo: r.columnInfo,
                complete: true,
                id: 1,
                rowCount: r.rowCount,
            }
        })
        this.OnQueryCompleteEmitter.fire({
            ownerUri: ownerUri,
            batchSummaries: [{
                id: 1,
                executionElapsed: 'hoi',
                executionEnd: 'end',
                executionStart: 'start',
                hasError: false,
                resultSetSummaries: [{
                    batchId: 1,
                    columnInfo: r.columnInfo,
                    complete: true,
                    id: 1,
                    rowCount: r.rowCount,
                    visualization: {
                        type: 'table'
                    } 
                }],
                selection: {
                    endColumn: 1,
                    endLine: 1,
                    startColumn: 1, 
                    startLine: 1,
                }

            }]
        })
        return 
    }
    runQueryStatement(ownerUri: string, line: number, column: number): Thenable<void> {
        throw new Error('Method not implemented.');
    }
    runQueryString(ownerUri: string, queryString: string): Thenable<void> {
        throw new Error('Method not implemented.');
    }
    async runQueryAndReturn(ownerUri: string, queryString: string): Promise<azdata.SimpleExecuteResult> {

        //var res: [ { [Key: string]: string | number } ] = await this.odbcService.query(ownerUri, queryString)
        var res = await this.odbcService.query(ownerUri, queryString) as Result<{ [Key: string]: string | number }>
        
        var row_info = res.map((r)=>Object.entries(r).map(([k,v])=>({
            displayValue: v,
            isNull: false,
            invariantCultureDisplayValue: v
        }))) as azdata.DbCellValue[][]

        var column_info = res.columns.map((e)=>({
            columnName: e.name,
            dataType: String(e.dataType),
            udtAssemblyQualifiedName: e.name,
            baseCatalogName: e.name,
            baseColumnName: e.name,
            baseSchemaName: e.name,
            baseServerName: e.name,
            baseTableName: e.name,
            dataTypeName: e.dataTypeName 
        })) as azdata.IDbColumn[]

        return {
            columnInfo: column_info,
            rowCount: res.count,
            rows: row_info
        } as azdata.SimpleExecuteResult

    }
    parseSyntax(ownerUri: string, query: string): Thenable<azdata.SyntaxParseResult> {
        throw new Error('Method not implemented.');
    }
    getQueryRows(rowData: azdata.QueryExecuteSubsetParams): Thenable<azdata.QueryExecuteSubsetResult> {
        throw new Error('Method not implemented.');
    }
    disposeQuery(ownerUri: string): Thenable<void> {
        throw new Error('Method not implemented.');
    }
    saveResults(requestParams: azdata.SaveResultsRequestParams): Thenable<azdata.SaveResultRequestResult> {
        throw new Error('Method not implemented.');
    }
    setQueryExecutionOptions(ownerUri: string, options: azdata.QueryExecutionOptions): Thenable<void> {
        throw new Error('Method not implemented.');
    }
    registerOnQueryComplete(handler: (result: azdata.QueryExecuteCompleteNotificationResult) => any): void {
        this.OnQueryComplete((e)=>{
            handler(e);
        });
    }
    registerOnBatchStart(handler: (batchInfo: azdata.QueryExecuteBatchNotificationParams) => any): void {
        this.OnBatchStart((e)=>{
            handler(e);
        });
    }
    registerOnBatchComplete(handler: (batchInfo: azdata.QueryExecuteBatchNotificationParams) => any): void {
        this.OnBatchComplete((e)=>{
            handler(e)
        })
    }
    registerOnResultSetAvailable(handler: (resultSetInfo: azdata.QueryExecuteResultSetNotificationParams) => any): void {
        this.OnResultSetAvailable((e)=>{
            handler(e)
        })
    }
    registerOnResultSetUpdated(handler: (resultSetInfo: azdata.QueryExecuteResultSetNotificationParams) => any): void {
        this.OnResultSetUpdated((e)=>{
            handler(e)
        })
    }
    registerOnMessage(handler: (message: azdata.QueryExecuteMessageParams) => any): void {
        this.OnMessage((e)=>{
            handler(e)
        })
    }
    commitEdit(ownerUri: string): Thenable<void> {
        throw new Error('Method not implemented.');
    }
    createRow(ownerUri: string): Thenable<azdata.EditCreateRowResult> {
        throw new Error('Method not implemented.');
    }
    deleteRow(ownerUri: string, rowId: number): Thenable<void> {
        throw new Error('Method not implemented.');
    }
    disposeEdit(ownerUri: string): Thenable<void> {
        throw new Error('Method not implemented.');
    }
    initializeEdit(ownerUri: string, schemaName: string, objectName: string, objectType: string, rowLimit: number, queryString: string): Thenable<void> {
        throw new Error('Method not implemented.');
    }
    revertCell(ownerUri: string, rowId: number, columnId: number): Thenable<azdata.EditRevertCellResult> {
        throw new Error('Method not implemented.');
    }
    revertRow(ownerUri: string, rowId: number): Thenable<void> {
        throw new Error('Method not implemented.');
    }
    updateCell(ownerUri: string, rowId: number, columnId: number, newValue: string): Thenable<azdata.EditUpdateCellResult> {
        throw new Error('Method not implemented.');
    }
    getEditRows(rowData: azdata.EditSubsetParams): Thenable<azdata.EditSubsetResult> {
        throw new Error('Method not implemented.');
    }
    registerOnEditSessionReady(handler: (ownerUri: string, success: boolean, message: string) => any): void {
        this.OnEditSessionReady((e: [string, boolean, string])=>{
            handler(e[0], e[1], e[2])
        })
    }
    handle?: number | undefined;
    providerId: string = 'ODBC';
       
}