terrier-engine 4.42.0 → 4.44.2

package/data-dive/dives/dive-editor.ts

@@ -416,6 +416,7 @@ class DuplicateQueryModal extends ModalPart<DuplicateQueryState> {
         this.state.editor.queryTabs.showTab(query.id)
         this.pop()
         this.app.successToast("Duplicated Query", 'glyp-copy')
+        this.emitMessage(DiveEditor.diveChangedKey, {})
     }
 
     renderContent(parent: PartTag): void {

package/data-dive/dives/dive-runs.ts

@@ -1,3 +1,4 @@
+import Arrays from "tuff-core/arrays"
 import {ModalPart} from "../../terrier/modals"
 import {PartTag} from "tuff-core/parts"
 import {DdDive, DdDiveRun, UnpersistedDdDiveRun} from "../gen/models"
@@ -191,8 +192,12 @@ export class DiveRunModal extends ModalPart<{dive: DdDive }> {
             col.div('.tt-flex.collapsible.gap.tt-form', row => {
                 // inputs
                 row.div('.tt-flex.column.dd-dive-run-inputs', col => {
-                    for (const filter of this.filters) {
-                        this.renderInput(col, filter)
+                    const filtersByQuery = Arrays.groupBy(this.filters, 'query_name')
+                    for (const queryName of Object.keys(filtersByQuery).sort()) {
+                        col.h3(".glyp-data_dive_query").text(queryName)
+                        for (const filter of filtersByQuery[queryName]) {
+                            this.renderInput(col, filter)
+                        }
                     }
                 })
 
@@ -250,7 +255,7 @@ export class DiveRunModal extends ModalPart<{dive: DdDive }> {
     }
 
     renderFileOutput(parent: DivTag, fileOutput: RunFileOutput) {
-        parent.a('.file-output', {href: fileOutput.url}, row => {
+        parent.a('.file-output', { href: fileOutput.url, download: fileOutput.name }, row => {
             row.div('.name.glyp-file_spreadsheet.with-icon').text(fileOutput.name)
             row.div('.details.glyp-download.with-icon').text("Click to download")
         })

package/data-dive/dives/dives.ts

@@ -61,7 +61,7 @@ async function list(): Promise<DiveListResult> {
 function computeFilterInputs(schema: SchemaDef, dive: DdDive): FilterInput[] {
     const filters: Record<string, FilterInput> = {}
     for (const query of dive.query_data?.queries || []) {
-        Tables.computeFilterInputs(schema, query.from, filters)
+        Tables.computeFilterInputs(schema, query, query.from, filters)
     }
     return Object.values(filters)
 }

package/data-dive/queries/filters.ts

@@ -1,6 +1,7 @@
 import {PartTag} from "tuff-core/parts"
 import Dates, {DateLiteral, VirtualDatePeriod, VirtualDateRange} from "./dates"
 import {ColumnDef, ModelDef, SchemaDef} from "../../terrier/schema"
+import { Query } from "./queries"
 import {TableRef, TableView} from "./tables"
 import {Logger} from "tuff-core/logging"
 import * as inflection from "inflection"
@@ -683,6 +684,7 @@ class AddFilterDropdown extends Dropdown<{modelDef: ModelDef, callback: AddFilte
 ////////////////////////////////////////////////////////////////////////////////
 
 export type FilterInput = Filter & {
+    query_name: string
     input_name: string
     input_value: string
     possible_values?: string[]
@@ -694,12 +696,12 @@ export type FilterInput = Filter & {
  * @param table
  * @param filter
  */
-function toInput(schema: SchemaDef, table: TableRef, filter: Filter): FilterInput {
+function toInput(schema: SchemaDef, query: Query, table: TableRef, filter: Filter): FilterInput {
     if (!filter.id?.length) {
         filter.id = Ids.makeRandom(8)
     }
     const name = `${table.model}.${filter.column}`
-    const filterInput: FilterInput = {...filter, input_name: name, input_value: ''}
+    const filterInput: FilterInput = {...filter, query_name: query.name, input_name: name, input_value: ''}
     switch (filter.filter_type) {
         case 'inclusion':
             const modelDef = schema.models[table.model]

package/data-dive/queries/queries.ts

@@ -1,3 +1,4 @@
+import { Filter } from "./filters"
 import {TableRef} from "./tables"
 import api, {ApiResponse} from "../../terrier/api"
 import {PartTag} from "tuff-core/parts"
@@ -63,7 +64,7 @@ function eachTable(query: Query, fn: TableFunction) {
     eachChildTable(query.from, fn)
 }
 
-type ColumnFunction = (table: TableRef, col: ColumnRef) => any
+export type ColumnFunction = (table: TableRef, col: ColumnRef) => any
 
 function eachColumnForTable(table: TableRef, fn: ColumnFunction) {
     if (table.columns) {
@@ -87,14 +88,44 @@ function eachColumn(query: Query, fn: ColumnFunction) {
     eachColumnForTable(query.from, fn)
 }
 
+export type FilterFunction = (table: TableRef, filter: Filter) => any
+
+function eachFilterForTable(table: TableRef, fn: FilterFunction) {
+    if (table.filters) {
+        for (const filter of table.filters) {
+            fn(table, filter)
+        }
+    }
+    if (table.joins) {
+        for (const joinedTable of Object.values(table.joins)) {
+            eachFilterForTable(joinedTable, fn)
+        }
+    }
+}
+
 /**
- * Duplicates a query, including all of the nested data structures.
+ * Recursively iterates over all filters in the query and executes the given function for each.
+ * @param query
+ * @param fn a function to evaluate on each filter
+ */
+function eachFilter(query: Query, fn: FilterFunction) {
+    eachFilterForTable(query.from, fn)
+}
+
+/**
+ * Duplicates a query, including all the nested data structures.
  * @param query the query to duplicate
  * @return a completely new query
  */
 function duplicate(query: Query): Query {
     const newQuery = Objects.deepCopy(query)
     newQuery.id = Ids.makeUuid()
+
+    // filters need new IDs, otherwise they won't be able to be set differently than the original query's filters
+    eachFilter(newQuery, (_, filter) => {
+        filter.id = Ids.makeUuid()
+    })
+
     return newQuery
 }
 
@@ -332,6 +363,7 @@ export class QueryModelPicker extends TerrierPart<QueryModelPickerState> {
 const Queries = {
     eachColumn,
     eachTable,
+    eachFilter,
     duplicate,
     validate,
     preview,

package/data-dive/queries/row-order-modal.ts

@@ -1,4 +1,5 @@
 import {ModalPart} from "../../terrier/modals"
+import Columns from "./columns"
 import Queries, {OrderBy, Query} from "./queries"
 import Messages from "tuff-core/messages"
 import {PartTag} from "tuff-core/parts"
@@ -54,15 +55,19 @@ export default class RowOrderModal extends ModalPart<RowOrderState> {
 
         // collect the column options
         const query = this.state.query
-        Queries.eachColumn(query, (_, col) => {
-            this.columnOptions.push({title: col.name, value: col.name})
+        const existingColumns = new Set<string>()
+        Queries.eachColumn(query, (table, col) => {
+            const name = Columns.computeSelectName(table, col)
+            existingColumns.add(name)
+            this.columnOptions.push({title: name, value: name})
         })
 
-        // initialize the order=bys from the query, if present
+        // initialize the order-bys from the query, if present
         if (query.order_by?.length) {
-            this.orderBys = query.order_by
+            // filter out columns that are no longer present in the query
+            this.orderBys = query.order_by.filter(ob => existingColumns.has(ob.column))
         }
-        else {
+        if (!query.order_by?.length) { // this isn't an else because the previous clause might've resulted in no columns
             // start with something by default
             this.addClause()
         }

package/data-dive/queries/tables.ts

@@ -47,22 +47,19 @@ const updatedKey = Messages.typedKey<TableRef>()
 ////////////////////////////////////////////////////////////////////////////////
 
 /**
- * Recursively collect  s all of the filters for this and all joined tables.
- * Only keep one (the last one traversed) per table/column combination.
- * This means that some filters may clobber others, but I think it will yield
- * the desired result most of the time.
+ * Recursively collects all the filters for this and all joined tables.
  * @param schema
  * @param table
  * @param filters
  */
-function computeFilterInputs(schema: SchemaDef, table: TableRef, filters: Record<string, FilterInput>) {
+function computeFilterInputs(schema: SchemaDef, query: Query, table: TableRef, filters: Record<string, FilterInput>) {
     for (const f of table.filters || []) {
-        const fi = Filters.toInput(schema, table, f)
+        const fi = Filters.toInput(schema, query, table, f)
         filters[fi.id] = fi
     }
     if (table.joins) {
         for (const j of Object.values(table.joins)) {
-            computeFilterInputs(schema, j, filters)
+            computeFilterInputs(schema, query, j, filters)
         }
     }
 }

package/package.json

@@ -4,7 +4,7 @@
   "files": [
     "*"
   ],
-  "version": "4.42.0",
+  "version": "4.44.2",
   "repository": {
     "type": "git",
     "url": "https://github.com/Terrier-Tech/terrier-engine"