DatasetSliceTrack - Dynamic Datasets (#1638)

This change modifies the interface to `DatasetSliceTrack`, allowing it
to take either a static dataset or a dynamic dataset (a function that
returns a dataset, called on the track's onUpdate() hook).

This allows the dataset to be tweaked by the plugin that registers the
track depending on some other internal state of the plugin.

If the dataset's resultant query changes from frame to frame, the
track's internal state and any tables are dropped, and the track data is
reloaded.

Author: stevegolton

ui/src/components/tracks/base_slice_track.ts

@@ -310,7 +310,12 @@ export abstract class BaseSliceTrack<
     return `slice_${this.trackUuid}`;
   }
 
-  async onCreate(): Promise<void> {
+  private oldQuery?: string;
+
+  private async initialize(): Promise<void> {
+    // This disposes all already initialized stuff and empties the trash.
+    await this.trash.asyncDispose();
+
     const result = await this.onInit();
     result && this.trash.use(result);
 
@@ -390,10 +395,18 @@ export abstract class BaseSliceTrack<
 
     this.trash.defer(async () => {
       await this.engine.tryQuery(`drop table ${this.getTableName()}`);
+      this.oldQuery = undefined;
+      this.slicesKey = CacheKey.zero();
     });
   }
 
   async onUpdate({visibleWindow, size}: TrackRenderContext): Promise<void> {
+    const query = this.getSqlSource();
+    if (query !== this.oldQuery) {
+      await this.initialize();
+      this.oldQuery = query;
+    }
+
     const windowSizePx = Math.max(1, size.width);
     const timespan = visibleWindow.toTimeSpan();
     const rawSlicesKey = CacheKey.create(

ui/src/components/tracks/dataset_slice_track.ts

@@ -14,7 +14,6 @@
 
 import m from 'mithril';
 import {ColorScheme} from '../../base/color_scheme';
-import {assertTrue} from '../../base/logging';
 import {Time} from '../../base/time';
 import {TrackEventDetailsPanel} from '../../public/details_panel';
 import {TrackEventDetails, TrackEventSelection} from '../../public/selection';
@@ -96,7 +95,7 @@ export interface DatasetSliceTrackAttrs<T extends DatasetSchema> {
    *   different layers will be mipmapped independency of each other, and the
    *   buckets of higher layers will be rendered on top of lower layers.
    */
-  readonly dataset: SourceDataset<T>;
+  readonly dataset: SourceDataset<T> | (() => SourceDataset<T>);
 
   /**
    * An optional initial estimate for the maximum depth value. Helps minimize
@@ -182,41 +181,39 @@ export type ROW_SCHEMA = typeof rowSchema;
 // resolved properly.
 type SliceWithRow<T> = Slice & {row: T};
 
+function getDataset<T extends DatasetSchema>(
+  attrs: DatasetSliceTrackAttrs<T>,
+): SourceDataset<T> {
+  const dataset = attrs.dataset;
+  return typeof dataset === 'function' ? dataset() : dataset;
+}
+
 export class DatasetSliceTrack<T extends ROW_SCHEMA> extends BaseSliceTrack<
   SliceWithRow<T>,
   BaseRow & T
 > {
-  protected readonly sqlSource: string;
   readonly rootTableName?: string;
 
   constructor(private readonly attrs: DatasetSliceTrackAttrs<T>) {
+    const dataset = getDataset(attrs);
     super(
       attrs.trace,
       attrs.uri,
-      {...BASE_ROW, ...attrs.dataset.schema},
+      {...BASE_ROW, ...dataset.schema},
       attrs.sliceLayout,
       attrs.initialMaxDepth,
       attrs.instantStyle?.width,
     );
-    const {dataset} = attrs;
-
-    // This is the minimum viable implementation that the source dataset must
-    // implement for the track to work properly. Typescript should enforce this
-    // now, but typescript can be worked around, and checking it is cheap.
-    // Better to error out early.
-    assertTrue(this.attrs.dataset.implements(rowSchema));
-
-    this.sqlSource = this.generateRenderQuery(dataset);
     this.rootTableName = attrs.rootTableName;
   }
 
   override rowToSlice(row: BaseRow & T): SliceWithRow<T> {
     const slice = this.rowToSliceBase(row);
     const title = this.getTitle(row);
     const color = this.getColor(row, title);
-
+    const dataset = getDataset(this.attrs);
     // Take a copy of the row, only copying the keys listed in the schema.
-    const cols = Object.keys(this.attrs.dataset.schema);
+    const cols = Object.keys(dataset.schema);
     const clonedRow = Object.fromEntries(
       Object.entries(row).filter(([key]) => cols.includes(key)),
     ) as T;
@@ -276,11 +273,15 @@ export class DatasetSliceTrack<T extends ROW_SCHEMA> extends BaseSliceTrack<
   }
 
   override getSqlSource(): string {
-    return this.sqlSource;
+    const dataset =
+      typeof this.attrs.dataset === 'function'
+        ? this.attrs.dataset()
+        : this.attrs.dataset;
+    return this.generateRenderQuery(dataset);
   }
 
   getDataset() {
-    return this.attrs.dataset;
+    return getDataset(this.attrs);
   }
 
   detailsPanel(sel: TrackEventSelection): TrackEventDetailsPanel | undefined {
@@ -301,7 +302,8 @@ export class DatasetSliceTrack<T extends ROW_SCHEMA> extends BaseSliceTrack<
   async getSelectionDetails(
     id: number,
   ): Promise<TrackEventDetails | undefined> {
-    const {trace, dataset} = this.attrs;
+    const {trace} = this.attrs;
+    const dataset = getDataset(this.attrs);
     const result = await trace.engine.query(`
       SELECT *
       FROM (${dataset.query()})