terrier-engine 4.7.0 → 4.7.4

package/data-dive/queries/columns.ts

@@ -11,6 +11,7 @@ import {Dropdown} from "../../terrier/dropdowns"
 import DiveEditor from "../dives/dive-editor"
 import Messages from "tuff-core/messages"
 import Arrays from "tuff-core/arrays"
+import {ColumnValidationError} from "./validation"
 
 const log = new Logger("Columns")
 
@@ -57,9 +58,25 @@ export type ColumnRef = {
     alias?: string
     grouped?: boolean
     function?: AggFunction | DateFunction
+    errors?: ColumnValidationError[]
 }
 
 
+/**
+ * Computes the name of the resulting select clause.
+ * @param table
+ * @param col
+ */
+function computeSelectName(table: TableRef, col: ColumnRef): string {
+    if (col.alias?.length) {
+        return col.alias
+    } else if (table.prefix?.length) {
+        return `${table.prefix}${col.name}`
+    } else {
+        return col.name
+    }
+}
+
 
 ////////////////////////////////////////////////////////////////////////////////
 // Rendering
@@ -405,7 +422,8 @@ class SelectColumnsDropdown extends Dropdown<{modelDef: ModelDef, callback: Sele
 
 const Columns = {
     render,
-    functionType
+    functionType,
+    computeSelectName
 }
 
 export default Columns

package/data-dive/queries/filters.ts

@@ -13,6 +13,7 @@ import Format from "../../terrier/format"
 import DiveEditor from "../dives/dive-editor"
 import Messages from "tuff-core/messages"
 import Arrays from "tuff-core/arrays"
+import {SelectOptions} from "tuff-core/forms"
 
 const log = new Logger("Filters")
 
@@ -27,8 +28,33 @@ type BaseFilter = {
     edit_label?: string
 }
 
-export const DirectOperators = ['eq', 'ne', 'ilike', 'lt', 'gt', 'lte', 'gte'] as const
-export type DirectOperator = typeof DirectOperators[number]
+const directOperators = ['eq', 'ne', 'ilike', 'lt', 'gt', 'lte', 'gte'] as const
+export type DirectOperator = typeof directOperators[number]
+
+/**
+ * Computes the operator options for the given column type.
+ * @param type
+ */
+function operatorOptions(type: string): SelectOptions {
+    let operators: DirectOperator[] = ['eq', 'ne'] // equality is the only thing we can assume for any type
+    switch (type) {
+        case 'text':
+        case 'string':
+            operators = ['eq', 'ne', 'ilike']
+            break
+        case 'float':
+        case 'integer':
+        case 'cents':
+            operators = ['eq', 'ne', 'lt', 'gt', 'lte', 'gte']
+            break
+    }
+    return operators.map(op => {
+        return {
+            value: op,
+            title: operatorDisplay(op)
+        }
+    })
+}
 
 export type DirectFilter = BaseFilter & {
     filter_type: 'direct'
@@ -73,7 +99,7 @@ function operatorDisplay(op: DirectOperator): string {
         case 'ne':
             return '≠'
         case 'ilike':
-            return '~'
+            return '≈'
         case 'lt':
             return '<'
         case 'lte':
@@ -369,10 +395,8 @@ class DirectFilterEditor extends FilterEditor<DirectFilter> {
             col.div('.tt-readonly-field', {text: this.state.column})
         })
         parent.div('.operator', col => {
-            const operatorOptions = DirectOperators.map(op => {
-                return {title: operatorDisplay(op), value: op}
-            })
-            this.select(col, 'operator', operatorOptions)
+            const opts = operatorOptions(this.columnDef?.type || 'text')
+            this.select(col, 'operator', opts)
         })
         parent.div('.filter', col => {
             switch (this.state.column_type) {

package/data-dive/queries/queries.ts

@@ -11,6 +11,7 @@ import inflection from "inflection"
 import Messages from "tuff-core/messages"
 import Strings from "tuff-core/strings"
 import Arrays from "tuff-core/arrays"
+import {ColumnRef} from "./columns"
 
 const log = new Logger("Queries")
 
@@ -28,13 +29,41 @@ export type Query = {
 
 
 ////////////////////////////////////////////////////////////////////////////////
-// Validation
+// Utilities
+////////////////////////////////////////////////////////////////////////////////
+
+type ColumnFunction = (table: TableRef, col: ColumnRef) => any
+
+function eachColumnForTable(table: TableRef, fn: ColumnFunction) {
+    if (table.columns) {
+        for (const col of table.columns) {
+            fn(table, col)
+        }
+    }
+    if (table.joins) {
+        for (const joinedTable of Object.values(table.joins)) {
+            eachColumnForTable(joinedTable, fn)
+        }
+    }
+}
+
+/**
+ * Recursively iterates over all columns in a query.
+ * @param query
+ */
+function eachColumn(query: Query, fn: ColumnFunction) {
+    eachColumnForTable(query.from, fn)
+}
+
+
+////////////////////////////////////////////////////////////////////////////////
+// Server-Side Validation
 ////////////////////////////////////////////////////////////////////////////////
 
 /**
  * Type for the response to a server-side query validation.
  */
-export type QueryValidation = ApiResponse & {
+export type QueryServerValidation = ApiResponse & {
     query: Query
     sql?: string
     sql_html?: string
@@ -47,8 +76,8 @@ export type QueryValidation = ApiResponse & {
  * Has the server validate the given query and generate SQL for it.
  * @param query
  */
-async function validate(query: Query): Promise<QueryValidation> {
-    return await api.post<QueryValidation>("/data_dive/validate_query.json", {query})
+async function validate(query: Query): Promise<QueryServerValidation> {
+    return await api.post<QueryServerValidation>("/data_dive/validate_query.json", {query})
 }
 
 
@@ -258,6 +287,7 @@ export class QueryModelPicker extends TerrierPart<QueryModelPickerState> {
 ////////////////////////////////////////////////////////////////////////////////
 
 const Queries = {
+    eachColumn,
     validate,
     preview,
     renderPreview

package/data-dive/queries/query-editor.ts

@@ -1,5 +1,5 @@
 import {PartTag} from "tuff-core/parts"
-import Queries, {Query, QueryResult, QueryValidation} from "./queries"
+import Queries, {Query, QueryResult, QueryServerValidation} from "./queries"
 import Tables, {FromTableView} from "./tables"
 import {Logger} from "tuff-core/logging"
 import QueryForm, {QuerySettings, QuerySettingsColumns} from "./query-form"
@@ -9,6 +9,7 @@ import Html from "tuff-core/html"
 import ContentPart from "../../terrier/parts/content-part"
 import {TabContainerPart} from "../../terrier/tabs"
 import Messages from "tuff-core/messages"
+import Validation, {QueryClientValidation} from "./validation"
 
 const log = new Logger("QueryEditor")
 
@@ -17,7 +18,7 @@ const log = new Logger("QueryEditor")
 // Keys
 ////////////////////////////////////////////////////////////////////////////////
 
-const validationKey = Messages.typedKey<QueryValidation>()
+const validationKey = Messages.typedKey<QueryServerValidation>()
 
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -60,9 +61,9 @@ class SettingsPart extends ContentPart<SubEditorState> {
 
 class SqlPart extends ContentPart<SubEditorState> {
 
-    validation?: QueryValidation
+    validation?: QueryServerValidation
 
-    setValidation(validation: QueryValidation) {
+    setValidation(validation: QueryServerValidation) {
         this.validation = validation
         this.dirty()
     }
@@ -156,11 +157,13 @@ export default class QueryEditor extends ContentPart<QueryEditorState> {
     settingsPart!: SettingsPart
     sqlPart!: SqlPart
     previewPart!: PreviewPart
+    clientValidation!: QueryClientValidation
 
     updatePreviewKey = Messages.untypedKey()
 
     async init() {
         const query = this.state.query
+        this.clientValidation = Validation.validateQuery(query)
 
         log.info("Initializing query editor", query)
 
@@ -180,7 +183,7 @@ export default class QueryEditor extends ContentPart<QueryEditorState> {
         this.previewPart = this.tabs.upsertTab({key: 'preview', title: 'Preview', icon: 'glyp-table', classes: ['no-padding'], click: {key: this.updatePreviewKey}},
             PreviewPart, {editor: this, query})
 
-        this.tableEditor = this.makePart(FromTableView, {schema: this.state.schema, table: this.state.query.from})
+        this.tableEditor = this.makePart(FromTableView, {schema: this.state.schema, queryEditor: this, table: this.state.query.from})
 
         this.listenMessage(Tables.updatedKey, m => {
             log.info(`Table ${m.data.model} updated`, m.data)
@@ -219,10 +222,14 @@ export default class QueryEditor extends ContentPart<QueryEditorState> {
     }
 
     async validate() {
+        // server-side validation
         const res = await Queries.validate(this.state.query)
         log.info(`Query validated`, res)
         this.emitMessage(validationKey, res)
         this.sqlPart.setValidation(res)
+
+        // client-side validation
+        this.clientValidation = Validation.validateQuery(this.state.query)
         this.dirty()
     }
 

package/data-dive/queries/tables.ts

@@ -11,6 +11,7 @@ import TerrierFormPart from "../../terrier/parts/terrier-form-part"
 import DiveEditor from "../dives/dive-editor"
 import Messages from "tuff-core/messages"
 import Arrays from "tuff-core/arrays"
+import QueryEditor from "./query-editor"
 
 const log = new Logger("Tables")
 
@@ -48,7 +49,9 @@ const updatedKey = Messages.typedKey<TableRef>()
  * 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.
+ * @param schema
  * @param table
+ * @param filters
  */
 function computeFilterInputs(schema: SchemaDef, table: TableRef, filters: Record<string, FilterInput>) {
     for (const f of table.filters || []) {
@@ -67,7 +70,7 @@ function computeFilterInputs(schema: SchemaDef, table: TableRef, filters: Record
 // View
 ////////////////////////////////////////////////////////////////////////////////
 
-export class TableView<T extends TableRef> extends ContentPart<{ schema: SchemaDef, table: T }> {
+export class TableView<T extends TableRef> extends ContentPart<{ schema: SchemaDef, queryEditor: QueryEditor, table: T }> {
 
     schema!: SchemaDef
     table!: T
@@ -88,7 +91,7 @@ export class TableView<T extends TableRef> extends ContentPart<{ schema: SchemaD
         this.modelDef = this.schema.models[this.table.model]
         this.tableName = inflection.titleize(inflection.tableize(this.table.model))
         this.displayName = this.tableName
-        this.updatedJoinedViews()
+        this.updateJoinedViews()
 
         this.onClick(this.editColumnsKey, _ => {
             log.info(`Edit ${this.displayName} Columns`)
@@ -155,7 +158,7 @@ export class TableView<T extends TableRef> extends ContentPart<{ schema: SchemaD
                     log.info(`Creating joined table`, newTable)
                     this.table.joins ||= {}
                     this.table.joins[newTable.belongs_to] = newTable
-                    this.updatedJoinedViews()
+                    this.updateJoinedViews()
                 }
                 this.app.showModal(JoinedTableEditorModal, {table, belongsTo, callback, parentTable: this.state.table as TableRef})
             }
@@ -165,9 +168,9 @@ export class TableView<T extends TableRef> extends ContentPart<{ schema: SchemaD
     /**
      * Re-generates all views for the joined tables.
      */
-    updatedJoinedViews() {
+    updateJoinedViews() {
         const states = Object.values(this.table.joins || {}).map(table => {
-            return {schema: this.schema, table}
+            return {schema: this.schema, queryEditor: this.state.queryEditor, table}
         })
         this.assignCollection('joined', JoinedTableView, states)
         for (const part of this.getCollectionParts('joined')) {
@@ -242,6 +245,12 @@ export class TableView<T extends TableRef> extends ContentPart<{ schema: SchemaD
                 for (const col of this.table.columns) {
                     section.div('.column.line', line => {
                         Columns.render(line, col)
+                        if (col.errors?.length) {
+                            line.class('error')
+                            for (const error of col.errors) {
+                                line.div('.error-message').text(error.message)
+                            }
+                        }
                     })
                 }
             }

package/data-dive/queries/validation.ts

@@ -0,0 +1,73 @@
+import Queries, {Query} from "./queries"
+import Columns, {ColumnRef} from "./columns"
+
+export type ColumnValidationError = {
+    message: string
+}
+
+export type QueryClientValidation = {
+    columns: ColumnValidationError[]
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// Client-Side Validation
+////////////////////////////////////////////////////////////////////////////////
+
+/**
+ * Validates that a query will produce valid SQL.
+ */
+function validateQuery(query: Query): QueryClientValidation {
+
+    const validation: QueryClientValidation = {
+        columns: []
+    }
+
+    function addColumnError(col: ColumnRef, message: string) {
+        const error = {message}
+        col.errors ||= []
+        col.errors.push(error)
+        validation.columns.push(error)
+    }
+
+    const usedNames: Set<string> = new Set<string>()
+
+    let isGrouped = false
+    Queries.eachColumn(query, (table, col) => {
+        // clear the errors
+        col.errors = undefined
+
+        // determine if there's a _group by_ in the query
+        if (col.grouped) {
+            isGrouped = true
+        }
+
+        // each select name should only be used once
+        const selectName = Columns.computeSelectName(table, col)
+        if (usedNames.has(selectName)) {
+            addColumnError(col, `<strong>${selectName}</strong> has already been selected for a different column`)
+        }
+        usedNames.add(selectName)
+    })
+
+    // if the query is grouped, ensure that all other column refs
+    // are either grouped or have an aggregate function
+    if (isGrouped) {
+        Queries.eachColumn(query, (_, col) => {
+            if (!col.grouped && !col.function) {
+                addColumnError(col, `<strong>${col.name}</strong> must be grouped or have an aggregate function`)
+            }
+        })
+    }
+
+    return validation
+}
+
+
+////////////////////////////////////////////////////////////////////////////////
+// Export
+////////////////////////////////////////////////////////////////////////////////
+
+const Validation = {
+    validateQuery
+}
+export default Validation

package/package.json

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

package/terrier/theme.ts

@@ -102,7 +102,7 @@ export default class Theme {
                 if (action.subtitle?.length) {
                     a.div('.subtitle', {text: action.subtitle})
                 }
-                else {
+                if (!(action.title?.length || action.subtitle?.length)) {
                     a.class('icon-only')
                 }
                 if (action.href?.length) {