Add alerts table to compare view if available

This adds the `alerts` result set to the compare view if an interpreted
result is available. This assumes that the user has opened the query
in the results view before opening the compare view. It will not
interpret the results if the interpreted results are not available.

Author: koesie10

extensions/ql-vscode/src/compare/compare-view.ts

@@ -25,13 +25,15 @@ import { App } from "../common/app";
 import {
   findCommonResultSetNames,
   findResultSetNames,
+  CompareQueryInfo,
+  getResultSetNames,
 } from "./result-set-names";
 
 interface ComparePair {
   from: CompletedLocalQueryInfo;
-  fromSchemas: BQRSInfo;
+  fromInfo: CompareQueryInfo;
   to: CompletedLocalQueryInfo;
-  toSchemas: BQRSInfo;
+  toInfo: CompareQueryInfo;
 
   commonResultSetNames: readonly string[];
 }
@@ -67,16 +69,41 @@ export class CompareView extends AbstractWebview<
       to.completedQuery.query.resultsPaths.resultsPath,
     );
 
+    const [fromSchemaNames, toSchemaNames] = await Promise.all([
+      getResultSetNames(
+        fromSchemas,
+        from.completedQuery.query.metadata,
+        from.completedQuery.query.resultsPaths.interpretedResultsPath,
+      ),
+      getResultSetNames(
+        toSchemas,
+        to.completedQuery.query.metadata,
+        to.completedQuery.query.resultsPaths.interpretedResultsPath,
+      ),
+    ]);
+
     const commonResultSetNames = await findCommonResultSetNames(
       fromSchemas,
       toSchemas,
     );
 
     this.comparePair = {
       from,
-      fromSchemas,
+      fromInfo: {
+        schemas: fromSchemas,
+        schemaNames: fromSchemaNames,
+        metadata: from.completedQuery.query.metadata,
+        interpretedResultsPath:
+          from.completedQuery.query.resultsPaths.interpretedResultsPath,
+      },
       to,
-      toSchemas,
+      toInfo: {
+        schemas: toSchemas,
+        schemaNames: toSchemaNames,
+        metadata: to.completedQuery.query.metadata,
+        interpretedResultsPath:
+          to.completedQuery.query.resultsPaths.interpretedResultsPath,
+      },
       commonResultSetNames,
     };
 
@@ -203,24 +230,24 @@ export class CompareView extends AbstractWebview<
   }
 
   private async findResultSetsToCompare(
-    { from, fromSchemas, to, toSchemas, commonResultSetNames }: ComparePair,
+    { from, fromInfo, to, toInfo, commonResultSetNames }: ComparePair,
     selectedResultSetName: string | undefined,
   ) {
     const { currentResultSetDisplayName, fromResultSetName, toResultSetName } =
       await findResultSetNames(
-        fromSchemas,
-        toSchemas,
+        fromInfo,
+        toInfo,
         commonResultSetNames,
         selectedResultSetName,
       );
 
     const fromResultSet = await this.getResultSet(
-      fromSchemas,
+      fromInfo.schemas,
       fromResultSetName,
       from.completedQuery.query.resultsPaths.resultsPath,
     );
     const toResultSet = await this.getResultSet(
-      toSchemas,
+      toInfo.schemas,
       toResultSetName,
       to.completedQuery.query.resultsPaths.resultsPath,
     );

extensions/ql-vscode/src/compare/result-set-names.ts

@@ -1,5 +1,27 @@
+import { pathExists } from "fs-extra";
+
 import { BQRSInfo } from "../common/bqrs-cli-types";
-import { getDefaultResultSetName } from "../common/interface-types";
+import {
+  getDefaultResultSetName,
+  ALERTS_TABLE_NAME,
+  QueryMetadata,
+} from "../common/interface-types";
+
+export async function getResultSetNames(
+  schemas: BQRSInfo,
+  metadata: QueryMetadata | undefined,
+  interpretedResultsPath: string | undefined,
+): Promise<string[]> {
+  const schemaNames = schemas["result-sets"].map((schema) => schema.name);
+
+  if (metadata?.kind !== "graph" && interpretedResultsPath) {
+    if (await pathExists(interpretedResultsPath)) {
+      schemaNames.push(ALERTS_TABLE_NAME);
+    }
+  }
+
+  return schemaNames;
+}
 
 export async function findCommonResultSetNames(
   fromSchemas: BQRSInfo,
@@ -13,16 +35,21 @@ export async function findCommonResultSetNames(
   return fromSchemaNames.filter((name) => toSchemaNames.includes(name));
 }
 
+export type CompareQueryInfo = {
+  schemas: BQRSInfo;
+  schemaNames: string[];
+  metadata: QueryMetadata | undefined;
+  interpretedResultsPath: string | undefined;
+};
+
 export async function findResultSetNames(
-  fromSchemas: BQRSInfo,
-  toSchemas: BQRSInfo,
+  from: CompareQueryInfo,
+  to: CompareQueryInfo,
   commonResultSetNames: readonly string[],
   selectedResultSetName: string | undefined,
 ) {
-  const fromSchemaNames = fromSchemas["result-sets"].map(
-    (schema) => schema.name,
-  );
-  const toSchemaNames = toSchemas["result-sets"].map((schema) => schema.name);
+  const fromSchemaNames = from.schemaNames;
+  const toSchemaNames = to.schemaNames;
 
   // Fall back on the default result set names if there are no common ones.
   const defaultFromResultSetName = fromSchemaNames.find((name) =>