@finos/legend-cube-builder 0.0.4 → 0.0.5

package/src/stores/source-picker/CubeDirectConnectionTabState.ts

@@ -20,6 +20,7 @@ import {
   type ModelContext,
   RELATIONAL_TABLE_SOURCE_DEFINITION,
   RelationalTableSource,
+  Schema,
 } from '@finos/legend-cube';
 import { assertErrorThrown, type GeneratorFn } from '@finos/legend-shared';
 import {
@@ -63,6 +64,8 @@ import {
 import {
   type CubeSourcePickerTab,
   CubeSourcePickerTabKey,
+  CUBE_TABLE_PREVIEW_DELAY_MS,
+  generateCubeNodeIds,
 } from './CubeSourcePickerTab.js';
 
 /** An error as the tab shows it: its first line, with the rest on demand (R48) */
@@ -147,11 +150,19 @@ export class CubeDirectConnectionTabState implements CubeSourcePickerTab {
   /** The schema's tables; none until they are listed */
   schemaTables: readonly CubeExploredTable[] | undefined;
   /** The picked table, by its stored (quoted) name */
-  tableName: string | undefined;
+  /** The picked tables' stored names, in the order picked; several are added at once */
+  tableNames: readonly string[] = [];
   tableSearch = '';
   isTesting = false;
   isListing = false;
   isResolving = false;
+  /** The table, by its stored name, whose columns the tab shows under the list: the one picked last */
+  previewTableName: string | undefined;
+  /** The columns of each table previewed, or why they couldn't be read, by schema and stored name */
+  previewSchemas: ReadonlyMap<string, Schema | string> = new Map();
+  /** Counts the connection's changes, so a late preview is dropped */
+  private previewGeneration = 0;
+  private previewTimer: ReturnType<typeof setTimeout> | undefined;
   error: CubeDirectConnectionError | undefined;
   /** DuckDB only: a CSV to add to the setup SQL as a table, pasted or read from a file */
   csvText = '';
@@ -176,11 +187,16 @@ export class CubeDirectConnectionTabState implements CubeSourcePickerTab {
       schemas: observable.ref,
       schemaName: observable,
       schemaTables: observable.ref,
-      tableName: observable,
+      tableNames: observable.ref,
+      tableName: computed,
       tableSearch: observable,
       isTesting: observable,
       isListing: observable,
       isResolving: observable,
+      previewTableName: observable,
+      previewSchemas: observable.ref,
+      previewedColumns: computed,
+      loadPreview: flow,
       error: observable.ref,
       csvText: observable,
       csvTableName: observable,
@@ -203,6 +219,7 @@ export class CubeDirectConnectionTabState implements CubeSourcePickerTab {
       setDuckDbPath: action,
       selectSchema: action,
       selectTable: action,
+      toggleTable: action,
       setTableSearch: action,
       setCsvText: action,
       setCsvTableName: action,
@@ -303,9 +320,20 @@ export class CubeDirectConnectionTabState implements CubeSourcePickerTab {
     );
   }
 
+  /** The one picked table's stored name; none when several are */
+  get tableName(): string | undefined {
+    return this.tableNames.length === 1 ? this.tableNames[0] : undefined;
+  }
+
+  /** How many tables Add adds */
+  get pickedCount(): number {
+    return this.tableNames.length;
+  }
+
   get canConfirm(): boolean {
-    const table = this.schemaTables?.find(
-      (candidate) => candidate.storedName === this.tableName,
+    // a picked table hidden by the search still counts
+    const tables = this.tableNames.map((name) =>
+      this.schemaTables?.find((candidate) => candidate.storedName === name),
     );
     return (
       this.isOffered &&
@@ -315,8 +343,10 @@ export class CubeDirectConnectionTabState implements CubeSourcePickerTab {
       this.connection !== undefined &&
       this.connection === this.testedConnection &&
       this.schemaName !== undefined &&
-      table !== undefined &&
-      isExploredTableSelectable(table)
+      tables.length > 0 &&
+      tables.every(
+        (table) => table !== undefined && isExploredTableSelectable(table),
+      )
     );
   }
 
@@ -434,9 +464,101 @@ export class CubeDirectConnectionTabState implements CubeSourcePickerTab {
     }
   }
 
+  /** Picks the table alone, in place of any picked, and previews its columns */
   selectTable(storedName: string | undefined): void {
-    this.tableName = storedName;
+    this.tableNames = storedName === undefined ? [] : [storedName];
+    this.error = undefined;
+    this.preview(storedName);
+  }
+
+  /** Adds the table to the picked ones, previewing it, or takes it out */
+  toggleTable(storedName: string): void {
+    const adding = !this.tableNames.includes(storedName);
+    this.tableNames = adding
+      ? [...this.tableNames, storedName]
+      : this.tableNames.filter((each) => each !== storedName);
     this.error = undefined;
+    this.preview(adding ? storedName : this.tableNames.at(-1));
+  }
+
+  private previewKey(storedName: string): string {
+    return `${this.schemaName ?? ''}\u0000${storedName}`;
+  }
+
+  /** The previewed table's columns, `undefined` while they load, or why they couldn't be read */
+  get previewedColumns(): Schema | string | undefined {
+    const name = this.previewTableName;
+    return name === undefined
+      ? undefined
+      : this.previewSchemas.get(this.previewKey(name));
+  }
+
+  /** Previews the table once the clicks pause (`CUBE_TABLE_PREVIEW_DELAY_MS`) */
+  private preview(storedName: string | undefined): void {
+    this.previewTableName = storedName;
+    this.cancelPreview();
+    if (storedName !== undefined) {
+      this.previewTimer = setTimeout(() => {
+        this.previewTimer = undefined;
+        flowResult(this.loadPreview(storedName)).catch(
+          this.editorState.host.applicationStore.alertUnhandledError,
+        );
+      }, CUBE_TABLE_PREVIEW_DELAY_MS);
+    }
+  }
+
+  private cancelPreview(): void {
+    if (this.previewTimer !== undefined) {
+      clearTimeout(this.previewTimer);
+      this.previewTimer = undefined;
+    }
+  }
+
+  /** Reads a table's columns from the engine, over the connection tested */
+  *loadPreview(storedName: string): GeneratorFn<void> {
+    const key = this.previewKey(storedName);
+    const table = this.schemaTables?.find(
+      (candidate) => candidate.storedName === storedName,
+    );
+    const connection = this.testedConnection;
+    const schemaName = this.schemaName;
+    if (
+      this.previewSchemas.has(key) ||
+      !table ||
+      !connection ||
+      schemaName === undefined
+    ) {
+      return;
+    }
+    const model =
+      this.editorState.document.context?.model ??
+      createCubeDirectModel(connection);
+    const coordinates = getCubeDirectTableCoordinates(schemaName, table);
+    const generation = this.previewGeneration;
+    const id = this.editorState.document.query.generateId(
+      RelationalTableSource.TYPE,
+    );
+    let answer: Schema | string;
+    try {
+      const typed = (yield this.editorState.host.engine.resolveSchemas(
+        model,
+        new Map([
+          [id, [coordinates.database, coordinates.schema, coordinates.table]],
+        ]),
+      )) as Awaited<
+        ReturnType<typeof this.editorState.host.engine.resolveSchemas>
+      >;
+      const schema = typed.get(id);
+      answer =
+        schema instanceof Schema
+          ? schema
+          : (schema?.message ?? CUBE_DIRECT_MESSAGE.NO_TABLE_SCHEMA);
+    } catch (error) {
+      answer = toError(error).message;
+    }
+    if (generation === this.previewGeneration) {
+      this.previewSchemas = new Map(this.previewSchemas).set(key, answer);
+    }
   }
 
   setTableSearch(search: string): void {
@@ -476,6 +598,7 @@ export class CubeDirectConnectionTabState implements CubeSourcePickerTab {
     this.isTesting = false;
     this.isListing = false;
     this.isResolving = false;
+    this.cancelPreview();
   }
 
   /** Lists the connection's schemas; with a single one, lists its tables */
@@ -558,58 +681,130 @@ export class CubeDirectConnectionTabState implements CubeSourcePickerTab {
     const model: ModelContext =
       contextBefore?.model ??
       createCubeDirectModel(this.connection as CubeDirectConnection);
-    const table = this.schemaTables?.find(
-      (candidate) => candidate.storedName === this.tableName,
-    ) as CubeExploredTable;
-    const coordinates = getCubeDirectTableCoordinates(
-      this.schemaName as string,
-      table,
+    const tables = this.tableNames.map(
+      (name) =>
+        this.schemaTables?.find(
+          (candidate) => candidate.storedName === name,
+        ) as CubeExploredTable,
     );
-    // the engine stamps the table's accessor with its node id, so the id comes first
-    const id = editorState.document.query.generateId(
+    const schemaName = this.schemaName as string;
+    // the engine stamps each table's accessor with its node id, so the ids come first
+    const ids = generateCubeNodeIds(
+      editorState.document.query,
       RelationalTableSource.TYPE,
+      tables.length,
     );
+    this.cancelPreview();
     const request = ++this.confirmRequest;
     this.isResolving = true;
     this.error = undefined;
     try {
-      const typed = (yield editorState.host.engine.resolveSchemas(
-        model,
-        new Map([
-          [id, [coordinates.database, coordinates.schema, coordinates.table]],
-        ]),
-      )) as Awaited<ReturnType<typeof editorState.host.engine.resolveSchemas>>;
+      // a table previewed has its columns already: the engine types the others
+      const typed = new Map<string, Schema | CubeEngineError>();
+      const toType = new Map<string, readonly [string, string, string]>();
+      tables.forEach((table, index) => {
+        const id = ids[index] as string;
+        const schema = this.previewSchemas.get(
+          this.previewKey(table.storedName),
+        );
+        if (schema instanceof Schema) {
+          typed.set(id, schema);
+        } else {
+          const coordinates = getCubeDirectTableCoordinates(schemaName, table);
+          toType.set(id, [
+            coordinates.database,
+            coordinates.schema,
+            coordinates.table,
+          ]);
+        }
+      });
+      if (toType.size) {
+        const answer = (yield editorState.host.engine.resolveSchemas(
+          model,
+          toType,
+        )) as Awaited<
+          ReturnType<typeof editorState.host.engine.resolveSchemas>
+        >;
+        answer.forEach((schema, id) => typed.set(id, schema));
+      }
       if (request !== this.confirmRequest) {
         return false;
       }
-      const schema = typed.get(id);
-      if (schema === undefined || schema instanceof CubeEngineError) {
-        throw (
-          schema ??
-          new CubeEngineError(
-            CubeEngineErrorKind.COMPILE,
-            CUBE_DIRECT_MESSAGE.NO_TABLE_SCHEMA,
-          )
-        );
-      }
-      const node = RELATIONAL_TABLE_SOURCE_DEFINITION.resolve(
-        RELATIONAL_TABLE_SOURCE_DEFINITION.fromCoordinates(id, coordinates),
-        { kind: 'resolved', schema },
-      );
       const { document } = editorState;
-      if (document.context !== contextBefore || !document.query.canAdd(node)) {
+      if (document.context !== contextBefore) {
         throw new Error(CUBE_DIRECT_MESSAGE.CUBE_CHANGED);
       }
-      const query = document.query.add(node);
-      editorState.applyDocument(
-        document.context
-          ? document.withQuery(query)
-          : document
-              .withContext({ model, runtime: CUBE_DIRECT_RUNTIME_PATH })
-              .withQuery(query),
-      );
-      // what was tested is now the cube's connection
-      this.testedConnection = this.connection;
+      // each table typed is added, in the order picked; the first one picked
+      // is the one that runs on an empty cube, as a single table would be
+      let query = document.query;
+      const added: string[] = [];
+      const failed: CubeDirectConnectionError[] = [];
+      // with several tables, each failure names its table
+      const named = (
+        table: CubeExploredTable,
+        error: CubeDirectConnectionError,
+      ): CubeDirectConnectionError =>
+        tables.length > 1
+          ? { ...error, message: `${table.name}: ${error.message}` }
+          : error;
+      tables.forEach((table, index) => {
+        const id = ids[index] as string;
+        const schema = typed.get(id);
+        if (schema === undefined || schema instanceof CubeEngineError) {
+          failed.push(
+            named(
+              table,
+              toError(
+                schema ??
+                  new CubeEngineError(
+                    CubeEngineErrorKind.COMPILE,
+                    CUBE_DIRECT_MESSAGE.NO_TABLE_SCHEMA,
+                  ),
+              ),
+            ),
+          );
+          return;
+        }
+        const node = RELATIONAL_TABLE_SOURCE_DEFINITION.resolve(
+          RELATIONAL_TABLE_SOURCE_DEFINITION.fromCoordinates(
+            id,
+            getCubeDirectTableCoordinates(schemaName, table),
+          ),
+          { kind: 'resolved', schema },
+        );
+        if (!query.canAdd(node)) {
+          failed.push(
+            named(table, { message: CUBE_DIRECT_MESSAGE.CUBE_CHANGED }),
+          );
+          return;
+        }
+        query = query.add(node);
+        added.push(table.storedName);
+      });
+      if (added.length) {
+        editorState.applyDocument(
+          document.context
+            ? document.withQuery(query)
+            : document
+                .withContext({ model, runtime: CUBE_DIRECT_RUNTIME_PATH })
+                .withQuery(query),
+        );
+        // what was tested is now the cube's connection
+        this.testedConnection = this.connection;
+      }
+      if (failed.length) {
+        // the tables added aren't picked any more, so Add again adds only the others
+        this.tableNames = this.tableNames.filter(
+          (name) => !added.includes(name),
+        );
+        this.error =
+          failed.length === 1
+            ? failed[0]
+            : {
+                message: failed.map((each) => each.message).join('\n'),
+              };
+        return false;
+      }
       this.resetTable();
       return true;
     } catch (error) {
@@ -626,6 +821,8 @@ export class CubeDirectConnectionTabState implements CubeSourcePickerTab {
 
   /** Forgets what was read from the connection: it changed, or its answers are stale */
   private resetResults(): void {
+    this.previewGeneration++;
+    this.previewSchemas = new Map();
     this.testRequest++;
     this.listRequest++;
     this.confirmRequest++;
@@ -641,7 +838,9 @@ export class CubeDirectConnectionTabState implements CubeSourcePickerTab {
   }
 
   private resetTable(): void {
-    this.tableName = undefined;
+    this.tableNames = [];
     this.tableSearch = '';
+    this.previewTableName = undefined;
+    this.cancelPreview();
   }
 }

package/src/stores/source-picker/CubeIngestTabState.ts

@@ -53,6 +53,7 @@ import type { CubeEditorState } from '../CubeEditorState.js';
 import {
   type CubeSourcePickerTab,
   CubeSourcePickerTabKey,
+  generateCubeNodeIds,
 } from './CubeSourcePickerTab.js';
 
 /** What failed in the tab: its first line, and the rest on demand */
@@ -79,10 +80,10 @@ const toError = (error: unknown): CubeIngestTabError => {
 /**
  * The source dialog's Ingest tab (PLAN §6.7), as Data Cube's producer
  * source picks: the Mode (class), the viewer's environment for it, a
- * producer deployment, one of its SDLC-deployed definitions, then a data
- * set, typed from what the definition declares. The first Add saves the
- * class, the producer deployment and the warehouse as the cube's model;
- * then the tab offers only that deployment's definitions.
+ * producer deployment, one of its SDLC-deployed definitions, then one or
+ * several of its data sets, typed from what the definition declares. The
+ * first Add saves the class, the producer deployment and the warehouse as
+ * the cube's model; then the tab offers only that deployment's definitions.
  */
 export class CubeIngestTabState implements CubeSourcePickerTab {
   readonly key = CubeSourcePickerTabKey.INGEST;
@@ -97,7 +98,8 @@ export class CubeIngestTabState implements CubeSourcePickerTab {
   definitionSearch = '';
   definition: CubeIngestDefinitionCandidate | undefined;
   dataSets: readonly CubeIngestDataSet[] | undefined;
-  dataSetName: string | undefined;
+  /** The picked data sets, by name, in the order picked; several are added at once */
+  dataSetNames: readonly string[] = [];
   /** The warehouse of a cube without one yet: the one the viewer last picked, else the default */
   warehouse = CUBE_DEFAULT_CONSUMER_WAREHOUSE;
   isLoadingEnvironment = false;
@@ -124,7 +126,9 @@ export class CubeIngestTabState implements CubeSourcePickerTab {
       definitionSearch: observable,
       definition: observable.ref,
       dataSets: observable.ref,
-      dataSetName: observable,
+      dataSetNames: observable.ref,
+      dataSetName: computed,
+      pickedDataSets: computed,
       warehouse: observable,
       isLoadingEnvironment: observable,
       isListingDefinitions: observable,
@@ -143,6 +147,7 @@ export class CubeIngestTabState implements CubeSourcePickerTab {
       setDefinitionSearch: action,
       selectDefinition: action,
       selectDataSet: action,
+      toggleDataSet: action,
       setWarehouse: action,
       retry: action,
       open: action,
@@ -194,8 +199,34 @@ export class CubeIngestTabState implements CubeSourcePickerTab {
     );
   }
 
+  /** The data set picked last, the one previewed */
+  get dataSetName(): string | undefined {
+    return this.dataSetNames.at(-1);
+  }
+
+  /** The data set picked last, the one previewed */
   get dataSet(): CubeIngestDataSet | undefined {
-    return this.dataSets?.find((each) => each.name === this.dataSetName);
+    return this.findDataSet(this.dataSetName);
+  }
+
+  /** The picked data sets, in the order picked */
+  get pickedDataSets(): readonly (CubeIngestDataSet | undefined)[] {
+    return this.dataSetNames.map((name) => this.findDataSet(name));
+  }
+
+  /** How many data sets Add adds */
+  get pickedCount(): number {
+    return this.dataSetNames.length;
+  }
+
+  isDataSetPicked(name: string): boolean {
+    return this.dataSetNames.includes(name);
+  }
+
+  private findDataSet(name: string | undefined): CubeIngestDataSet | undefined {
+    return name === undefined
+      ? undefined
+      : this.dataSets?.find((each) => each.name === name);
   }
 
   get canConfirm(): boolean {
@@ -206,7 +237,8 @@ export class CubeIngestTabState implements CubeSourcePickerTab {
       !this.isAdding &&
       this.producerDeploymentId !== undefined &&
       this.definition !== undefined &&
-      this.dataSet?.isPickable === true &&
+      this.pickedDataSets.length > 0 &&
+      this.pickedDataSets.every((each) => each?.isPickable === true) &&
       this.warehouse.trim() !== ''
     );
   }
@@ -255,10 +287,19 @@ export class CubeIngestTabState implements CubeSourcePickerTab {
     }
   }
 
-  /** Picks a data set that can be added */
+  /** Picks a data set that can be added, alone, in place of any picked */
   selectDataSet(name: string): void {
-    if (this.dataSets?.find((each) => each.name === name)?.isPickable) {
-      this.dataSetName = name;
+    if (this.findDataSet(name)?.isPickable) {
+      this.dataSetNames = [name];
+    }
+  }
+
+  /** Adds a data set that can be added to the picked ones, or takes it out */
+  toggleDataSet(name: string): void {
+    if (this.isDataSetPicked(name)) {
+      this.dataSetNames = this.dataSetNames.filter((each) => each !== name);
+    } else if (this.findDataSet(name)?.isPickable) {
+      this.dataSetNames = [...this.dataSetNames, name];
     }
   }
 
@@ -364,6 +405,20 @@ export class CubeIngestTabState implements CubeSourcePickerTab {
       }
       this.environment = environment;
       this.producers = producers;
+      // a new cube starts on the environment's own warehouse, when it has one
+      if (!this.fixedSettings && environment.warehouse) {
+        this.warehouse = environment.warehouse;
+      }
+      // the only producer deployment is the one to read
+      const [onlyProducer] = producers;
+      if (
+        this.producerDeploymentId === undefined &&
+        producers.length === 1 &&
+        onlyProducer
+      ) {
+        this.producerDeploymentId = onlyProducer.deploymentId;
+        this.resetDefinitions();
+      }
     } catch (error) {
       if (request === this.environmentRequest) {
         this.loadedEnvironmentType = undefined;
@@ -427,9 +482,11 @@ export class CubeIngestTabState implements CubeSourcePickerTab {
       if (request === this.describeRequest) {
         this.dataSets = dataSets;
         // the only data set that can be added is picked
-        const pickable = dataSets.filter((each) => each.isPickable);
-        this.dataSetName =
-          pickable.length === 1 ? pickable[0]?.name : undefined;
+        const [onlyPickable, ...otherPickable] = dataSets.filter(
+          (each) => each.isPickable,
+        );
+        this.dataSetNames =
+          onlyPickable && !otherPickable.length ? [onlyPickable.name] : [];
       }
     } catch (error) {
       if (request === this.describeRequest) {
@@ -443,9 +500,10 @@ export class CubeIngestTabState implements CubeSourcePickerTab {
   }
 
   /**
-   * Adds the data set, already typed; the first saves the class, the
-   * producer deployment and the warehouse as the cube's model, in the same
-   * undo step, and remembers the warehouse for the viewer's next cubes
+   * Adds the picked data sets, already typed, in one undo step; the first
+   * saves the class, the producer deployment and the warehouse as the cube's
+   * model, in the same undo step, and remembers the warehouse for the
+   * viewer's next cubes
    */
   *confirm(): GeneratorFn<boolean> {
     if (!this.canConfirm) {
@@ -453,7 +511,7 @@ export class CubeIngestTabState implements CubeSourcePickerTab {
     }
     const { editorState } = this;
     const definition = this.definition as CubeIngestDefinitionCandidate;
-    const dataSet = this.dataSet as CubeIngestDataSet;
+    const picked = this.pickedDataSets as readonly CubeIngestDataSet[];
     const producerDeploymentId = this.producerDeploymentId as string;
     const warehouse = this.warehouse.trim();
     const request = ++this.confirmRequest;
@@ -466,29 +524,45 @@ export class CubeIngestTabState implements CubeSourcePickerTab {
         return false;
       }
       const { document } = editorState;
-      const id = document.query.generateId(IngestDatasetSource.TYPE);
-      const node = INGEST_DATASET_SOURCE_DEFINITION.resolve(
-        INGEST_DATASET_SOURCE_DEFINITION.fromCoordinates(id, {
-          ingestDefinitionUrn: definition.urn,
-          ingestDefinition: definition.definition,
-          dataSet: dataSet.name,
-        }),
-        {
-          kind: 'resolved',
-          schema: dataSet.schema as NonNullable<CubeIngestDataSet['schema']>,
-        },
+      const ids = generateCubeNodeIds(
+        document.query,
+        IngestDatasetSource.TYPE,
+        picked.length,
+      );
+      const nodes = picked.map((dataSet, index) =>
+        INGEST_DATASET_SOURCE_DEFINITION.resolve(
+          INGEST_DATASET_SOURCE_DEFINITION.fromCoordinates(
+            ids[index] as string,
+            {
+              ingestDefinitionUrn: definition.urn,
+              ingestDefinition: definition.definition,
+              dataSet: dataSet.name,
+            },
+          ),
+          {
+            kind: 'resolved',
+            schema: dataSet.schema as NonNullable<CubeIngestDataSet['schema']>,
+          },
+        ),
       );
       const settings = this.fixedSettings;
       if (
-        (document.context !== undefined &&
-          (!settings ||
-            settings.environmentType !== this.environmentType ||
-            settings.producerDeploymentId !== producerDeploymentId)) ||
-        !document.query.canAdd(node)
+        document.context !== undefined &&
+        (!settings ||
+          settings.environmentType !== this.environmentType ||
+          settings.producerDeploymentId !== producerDeploymentId)
       ) {
         throw new Error(CUBE_INGEST_TAB_MESSAGE.CUBE_CHANGED);
       }
-      const query = document.query.add(node);
+      // each data set is added in the order picked; the first one picked is
+      // the one that runs on an empty cube, as a single one would be
+      let query = document.query;
+      for (const node of nodes) {
+        if (!query.canAdd(node)) {
+          throw new Error(CUBE_INGEST_TAB_MESSAGE.CUBE_CHANGED);
+        }
+        query = query.add(node);
+      }
       editorState.applyDocument(
         document.context
           ? document.withQuery(query)
@@ -506,8 +580,8 @@ export class CubeIngestTabState implements CubeSourcePickerTab {
       if (!settings) {
         editorState.dataProductRuntime.remember(warehouse);
       }
-      // the definition stays open, to add another of its data sets
-      this.dataSetName = undefined;
+      // the definition stays open, to add others of its data sets
+      this.dataSetNames = [];
       return true;
     } catch (error) {
       if (request === this.confirmRequest) {
@@ -546,6 +620,6 @@ export class CubeIngestTabState implements CubeSourcePickerTab {
     this.isDescribing = false;
     this.definition = undefined;
     this.dataSets = undefined;
-    this.dataSetName = undefined;
+    this.dataSetNames = [];
   }
 }