Fix SQL errors in initialization of tracks that are already filtered out (#130)

The process summary tracks can have dynamically defined tables that they
create dropped during the sequence of asynchronous initialization steps
in which they create those tables and query them.

Implement an abstraction to simplify the management of these tables:
- track the created table and existence thereof
- easily drop the table on destruction of the track controller
- execute queries on the table if and only if it exists, with fall-back
  options for when it doesn't

Apply the DynamicTable mechanism to manage dynamic tables for the
process summary tracks and also the counter tracks that previously
neglected to drop their tables (thus fixing a latent bug).

Signed-off-by: Christian W. Damus <[email protected]>

Author: cdamus

ui/src/controller/track_controller.ts

@@ -15,6 +15,7 @@
 import {BigintMath} from '../base/bigint_math';
 import {assertExists} from '../base/logging';
 import {Engine} from '../common/engine';
+import {QueryResult} from '../common/query_result';
 import {Registry} from '../common/registry';
 import {TraceTime, TrackState} from '../common/state';
 import {
@@ -34,6 +35,10 @@ interface TrackConfig {}
 
 type TrackConfigWithNamespace = TrackConfig&{namespace: string};
 
+// Helper type that asserts that two vararg parameters have the same length
+type SameLength<T extends unknown[], U extends unknown[]> =
+T extends { length: U['length'] } ? T : never;
+
 // TrackController is a base class overridden by track implementations (e.g.,
 // sched slices, nestable slices, counters).
 export abstract class TrackController<
@@ -105,6 +110,96 @@ export abstract class TrackController<
     return `${prefix}_${idSuffix}`;
   }
 
+  /**
+   * Create a dynamic table with an automatically assigned name with
+   * convenient clean-up and handling of attempts to query the table
+   * after it has been dropped.
+   *
+   * @param {string} key to distinguish this table from other tables
+   *        and views dynamically created by the track
+   * @param {string|Function} ddl a function that generates the
+   *        table DDL using the dynamically assigned name of the
+   *        table and its dependencies from which it extracts data.
+   *        The DDL factory must accept a parameter for each dependency,
+   *        in order, to get its name
+   * @param {DynamicTable[]} withDependencies optional dynamic tables
+   *        from which the new table extracts data, thus being dependencies
+   * @return {DynamicTable} the dynamic table manager
+   */
+  protected createDynamicTable
+      <DN extends string[], DT extends DynamicTable[]>(
+      key: string,
+      ddl: (name: string, ...dependencies: DN) => string,
+      ...withDependencies: SameLength<DT, DN>): DynamicTable {
+    return this.createDynamicTableOrView('table', key, ddl, ...withDependencies);
+  }
+  /**
+   * Create a dynamic view with an automatically assigned name with
+   * convenient clean-up and handling of attempts to query the view
+   * after it has been dropped.
+   *
+   * @param {string} key to distinguish this view from other tables
+   *        and views dynamically created by the track
+   * @param {string|Function} ddl a function that generates the
+   *        view DDL using the dynamically assigned name of the
+   *        view and its dependencies from which it extracts data.
+   *        The DDL factory must accept a parameter for each dependency,
+   *        in order, to get its name
+   * @param {DynamicTable[]} withDependencies optional dynamic tables
+   *        from which the new view extracts data, thus being dependencies
+   * @return {DynamicTable} the dynamic view manager
+   */
+  protected createDynamicView
+      <DN extends string[], DT extends DynamicTable[]>(
+      key: string,
+      ddl: (name: string, ...dependencies: DN) => string,
+      ...withDependencies: SameLength<DT, DN>): DynamicTable {
+    return this.createDynamicTableOrView('view', key, ddl, ...withDependencies);
+  }
+  private createDynamicTableOrView
+      <DN extends string[], DT extends DynamicTable[]>(
+      type: DynamicTable['type'],
+      key: string,
+      ddl: (name: string, ...dependencies: DN) => string,
+      ...withDependencies: SameLength<DT, DN>): DynamicTable {
+    const name = this.tableName(key);
+    if (withDependencies.some((dep) => !dep.exists)) {
+      return DynamicTable.NONE;
+    }
+
+    const dependencyNames = withDependencies.map((dep) => dep.name) as DN;
+
+    let tableExists = true;
+    const pendingCreation = this.query(ddl(name, ...dependencyNames));
+    return {
+      type,
+      name,
+      get exists() {
+        return tableExists;
+      },
+      drop: async () => {
+        tableExists = false;
+        await pendingCreation;
+        await this.query(`drop ${type} if exists ${name}`);
+      },
+      query: async <T, E = undefined>(
+            query: string | ((tableName: string) => string),
+            resultCase?: (result: QueryResult) => T,
+            elseCase?: () => E) => {
+          if (!tableExists) {
+            return resultCase ? false : elseCase?.call(this);
+          }
+          const sql = typeof query === 'function' ? query(name) : query;
+          await pendingCreation;
+          const result = await this.query(sql);
+          if (!resultCase) {
+            return true;
+          }
+          return resultCase.call(this, result);
+      },
+    };
+  }
+
   shouldSummarize(resolution: number): boolean {
     // |resolution| is in s/px (to nearest power of 10) assuming a display
     // of ~1000px 0.0008 is 0.8s.
@@ -279,6 +374,77 @@ export abstract class TrackController<
   }
 }
 
+/**
+ * A wrapper for access to a dynamic-defined table or view
+ * that may or may not exist at any given time.
+ */
+export interface DynamicTable {
+  /** What kind of dynamic object that is encapsulated. */
+  readonly type: 'table'|'view';
+  /** The name of the dynamic object that is encapsulated. */
+  readonly name: string;
+  /** Whether the dynamic object that is encapsulated currently exists. */
+  readonly exists: boolean;
+  /**
+   * Drop the dynamically-defined table or view.
+   * From this point on, the query APIs will shunt to the else case.
+   */
+  drop(): Promise<void>;
+  /**
+   * Perform an UPDATE, DELETE, or other statement that does not return
+   * results, if and only if the dynamic table exists.
+   */
+  query(
+    query: string | ((tableName: string) => string)): Promise<boolean>;
+  /**
+   * Perform a SELECT query, if and only if the dynamic table exists, in
+   * which case the query result is sent to the given call-back function
+   * to process. There is no else-case call-back.
+   *
+   * @param query a query string or factory, which latter accepts the
+   *        dynamically-assigned table or view name as a parameter
+   * @param resultCase a call-back function to process the query result
+   */
+  query<T>(
+    query: string | ((tableName: string) => string),
+    resultCase: (result: QueryResult) => T): Promise<T | undefined>;
+  /**
+   * Perform a SELECT query, if and only if the dynamic table exists, in
+   * which case the query result is sent to the given call-back function
+   * to process. If the table does not exist, return the result of the
+   * else-case call-back function, instead.
+   *
+   * @param query a query string or factory, which latter accepts the
+   *        dynamically-assigned table or view name as a parameter
+   * @param resultCase a call-back function to process the query result
+   * @param elseCase a call-back function to call in the eventuality
+            that the table has already been dropped
+   */
+  query<T, E>(
+    query: string | ((tableName: string) => string),
+    resultCase: (result: QueryResult) => T,
+    elseCase: () => E): Promise<T | E>;
+}
+
+export namespace DynamicTable {
+  /** Placeholder for a dynamic table that has never (yet) been created. */
+  export const NONE: DynamicTable = {
+      type: 'view',
+      name: '<none>',
+      exists: false,
+      drop: () => Promise.resolve(),
+      query: async <T, E = undefined>(
+        _query: string | ((tableName: string) => string),
+        resultCase?: (result: QueryResult) => T,
+        elseCase?: () => E) => {
+          if (resultCase === undefined) {
+            return false;
+          }
+          return elseCase?.();
+        },
+  };
+}
+
 export interface TrackControllerArgs {
   trackId: string;
   engine: Engine;