@malloydata/malloy 0.0.38-dev230602001052 → 0.0.38-dev230606045241

package/dist/dialect/standardsql.js

@@ -364,13 +364,13 @@ ${(0, utils_1.indent)(sql)}
     }
     sqlMeasureTime(from, to, units) {
         const measureMap = {
-            microsecond: { use: 'microsecond', ratio: 1 },
-            millisecond: { use: 'microsecond', ratio: 1000 },
-            second: { use: 'millisecond', ratio: 1000 },
-            minute: { use: 'second', ratio: 60 },
-            hour: { use: 'minute', ratio: 60 },
-            day: { use: 'hour', ratio: 24 },
-            week: { use: 'day', ratio: 7 },
+            'microsecond': { use: 'microsecond', ratio: 1 },
+            'millisecond': { use: 'microsecond', ratio: 1000 },
+            'second': { use: 'millisecond', ratio: 1000 },
+            'minute': { use: 'second', ratio: 60 },
+            'hour': { use: 'minute', ratio: 60 },
+            'day': { use: 'hour', ratio: 24 },
+            'week': { use: 'day', ratio: 7 },
         };
         let lVal = from.value;
         let rVal = to.value;

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-export type { QueryDataRow, Fragment, StructDef, StructRelationship, NamedStructDefs, MalloyQueryData, AtomicFieldType as AtomicFieldTypeInner, DateUnit, ExtractUnit, TimestampUnit, TimeFieldType, QueryData, FieldTypeDef, Expr, DialectFragment, TimeValue, FilterExpression, SQLBlock, FieldDef, FilteredAliasedName, PipeSegment, QueryFieldDef, TurtleDef, SearchValueMapResult, SearchIndexResult, ModelDef, Query, NamedQuery, NamedModelObject, ExpressionType, DocumentLocation, DocumentRange, DocumentPosition, } from './model';
+export type { QueryDataRow, Fragment, StructDef, StructRelationship, NamedStructDefs, MalloyQueryData, AtomicFieldType as AtomicFieldTypeInner, DateUnit, ExtractUnit, TimestampUnit, TimeFieldType, QueryData, FieldTypeDef, Expr, DialectFragment, TimeValue, FilterExpression, SQLBlock, FieldDef, FilteredAliasedName, PipeSegment, QueryFieldDef, TurtleDef, SearchValueMapResult, SearchIndexResult, ModelDef, Query, QueryRunStats, NamedQuery, NamedModelObject, ExpressionType, DocumentLocation, DocumentRange, DocumentPosition, } from './model';
 export { Segment, isFilteredAliasedName, flattenQuery, expressionIsCalculation, } from './model';
 export { HighlightType, MalloyTranslator, } from './lang';
 export type { LogMessage, TranslateResponse } from './lang';

package/dist/lang/ast/expressions/pick-when.js

@@ -29,6 +29,9 @@ const fragtype_utils_1 = require("../fragtype-utils");
 const expression_def_1 = require("../types/expression-def");
 const malloy_element_1 = require("../types/malloy-element");
 const utils_1 = require("./utils");
+function typeCoalesce(ev1, ev2) {
+    return ev1 === undefined || ev1.dataType === 'null' ? ev2 : ev1;
+}
 class Pick extends expression_def_1.ExpressionDef {
     constructor(choices, elsePick) {
         super({ choices });
@@ -65,21 +68,17 @@ class Pick extends expression_def_1.ExpressionDef {
                 ? choice.pick.getExpression(fs)
                 : expr.getExpression(fs);
             anyExpressionType = (0, malloy_types_1.maxExpressionType)(anyExpressionType, (0, malloy_types_1.maxExpressionType)(whenExpr.expressionType, thenExpr.expressionType));
-            if (returnType) {
-                if (!fragtype_utils_1.FT.typeEq(returnType, thenExpr, true)) {
-                    const whenType = fragtype_utils_1.FT.inspect(thenExpr);
-                    this.log(`pick type '${whenType}', expected '${returnType.dataType}'`);
-                    return (0, ast_utils_1.errorFor)('pick when type');
-                }
-            }
-            else {
-                returnType = thenExpr;
+            if (returnType && !fragtype_utils_1.FT.typeEq(returnType, thenExpr, true)) {
+                const whenType = fragtype_utils_1.FT.inspect(thenExpr);
+                this.log(`pick type '${whenType}', expected '${returnType.dataType}'`);
+                return (0, ast_utils_1.errorFor)('pick when type');
             }
+            returnType = typeCoalesce(returnType, thenExpr);
             caseValue.push(' WHEN ', ...whenExpr.value, ' THEN ', ...thenExpr.value);
         }
         const elsePart = this.elsePick || expr;
         const elseVal = elsePart.getExpression(fs);
-        returnType || (returnType = elseVal);
+        returnType = typeCoalesce(returnType, elseVal);
         if (!fragtype_utils_1.FT.typeEq(returnType, elseVal, true)) {
             const errSrc = this.elsePick ? 'else' : 'pick default';
             this.log(`${errSrc} type '${fragtype_utils_1.FT.inspect(elseVal)}', expected '${returnType.dataType}'`);
@@ -112,24 +111,26 @@ class Pick extends expression_def_1.ExpressionDef {
                 when: c.when.getExpression(fs),
             });
         }
-        const returnType = choiceValues[0].pick;
+        let returnType;
         const caseValue = ['CASE'];
-        let anyExpressionType = returnType.expressionType;
+        let anyExpressionType = 'scalar';
         for (const aChoice of choiceValues) {
             if (!fragtype_utils_1.FT.typeEq(aChoice.when, fragtype_utils_1.FT.boolT)) {
                 this.log(`when expression must be boolean, not '${fragtype_utils_1.FT.inspect(aChoice.when)}`);
                 return (0, ast_utils_1.errorFor)('pick when type');
             }
-            if (!fragtype_utils_1.FT.typeEq(returnType, aChoice.pick, true)) {
+            if (returnType && !fragtype_utils_1.FT.typeEq(returnType, aChoice.pick, true)) {
                 const whenType = fragtype_utils_1.FT.inspect(aChoice.pick);
                 this.log(`pick type '${whenType}', expected '${returnType.dataType}'`);
                 return (0, ast_utils_1.errorFor)('pick value type');
             }
+            returnType = typeCoalesce(returnType, aChoice.pick);
             anyExpressionType = (0, malloy_types_1.maxExpressionType)(anyExpressionType, (0, malloy_types_1.maxExpressionType)(aChoice.pick.expressionType, aChoice.when.expressionType));
             caseValue.push(' WHEN ', ...aChoice.when.value, ' THEN ', ...aChoice.pick.value);
         }
         const defVal = this.elsePick.getExpression(fs);
         anyExpressionType = (0, malloy_types_1.maxExpressionType)(anyExpressionType, defVal.expressionType);
+        returnType = typeCoalesce(returnType, defVal);
         if (!fragtype_utils_1.FT.typeEq(returnType, defVal, true)) {
             this.elsePick.log(`else type '${fragtype_utils_1.FT.inspect(defVal)}', expected '${returnType.dataType}'`);
             return (0, ast_utils_1.errorFor)('pick value type mismatch');

package/dist/lang/test/parse.spec.js

@@ -37,6 +37,14 @@ function exprOK(s) {
         return undefined;
     };
 }
+function exprType(s, t) {
+    return () => {
+        const expr = new test_translator_1.BetaExpression(s);
+        expect(expr).modelParsed();
+        expect(expr.generated().dataType).toBe(t);
+        return undefined;
+    };
+}
 function modelOK(s) {
     return () => {
         const m = new test_translator_1.TestTranslator(s);
@@ -720,6 +728,9 @@ describe('expressions', () => {
         test('filtering', exprOK(`
         astr ? pick 'missing value' when NULL
     `));
+        test('null branch with else', exprType("astr ? pick null when = '42' else 3", 'number'));
+        test('null branch no else', exprType("astr ? pick null when = '42'", 'string'));
+        test('null branch no apply', exprType('pick null when 1 = 1 else 3', 'number'));
         test('tiering', exprOK(`
       ai ?
         pick 1 when < 10

package/dist/malloy.d.ts

@@ -121,6 +121,14 @@ export declare class Malloy {
         sqlStruct: SQLBlockStructDef;
         options?: RunSQLOptions;
     }): AsyncIterableIterator<DataRecord>;
+    static estimateQueryCost(params: {
+        connections: LookupConnection<Connection>;
+        preparedResult: PreparedResult;
+    }): Promise<QueryRunStats>;
+    static estimateQueryCost(params: {
+        connections: LookupConnection<Connection>;
+        sqlStruct: SQLBlockStructDef;
+    }): Promise<QueryRunStats>;
 }
 /**
  * A Malloy error, which may contain log messages produced during compilation.
@@ -930,6 +938,12 @@ export declare class QueryMaterializer extends FluentState<PreparedQuery> {
      * @return A promise of the `PreparedQuery`.
      */
     getPreparedQuery(): Promise<PreparedQuery>;
+    /**
+     * Estimates the cost of this loaded `Query`.
+     *
+     * @return The estimated cost of running this loaded query.
+     */
+    estimateQueryCost(): Promise<QueryRunStats>;
 }
 /**
  * An object representing the task of loading a `PreparedResult`, capable of
@@ -986,6 +1000,7 @@ export declare class SQLBlockMaterializer extends FluentState<SQLBlockStructDef>
      * @return A promise to the SQL string.
      */
     getSQL(): Promise<string>;
+    estimateQueryCost(): Promise<QueryRunStats>;
 }
 /**
  * An object representing the task of loading an `Explore`, capable of

package/dist/malloy.js

@@ -281,6 +281,23 @@ class Malloy {
             index += 1;
         }
     }
+    static async estimateQueryCost({ connections, preparedResult, sqlStruct, }) {
+        const sqlBlock = sqlStruct === null || sqlStruct === void 0 ? void 0 : sqlStruct.structSource.sqlBlock;
+        if (!connections) {
+            throw new Error('Internal Error: Connection or LookupConnection<Connection> must be provided.');
+        }
+        const connectionName = (sqlBlock === null || sqlBlock === void 0 ? void 0 : sqlBlock.connection) || (preparedResult === null || preparedResult === void 0 ? void 0 : preparedResult.connectionName);
+        const connection = await connections.lookupConnection(connectionName);
+        if (sqlBlock) {
+            return await connection.estimateQueryCost(sqlBlock === null || sqlBlock === void 0 ? void 0 : sqlBlock.selectStr);
+        }
+        else if (preparedResult) {
+            return await connection.estimateQueryCost(preparedResult === null || preparedResult === void 0 ? void 0 : preparedResult.sql);
+        }
+        else {
+            throw new Error('Internal error: sqlStruct or preparedResult must be provided.');
+        }
+    }
 }
 exports.Malloy = Malloy;
 /**
@@ -1878,6 +1895,16 @@ class QueryMaterializer extends FluentState {
     getPreparedQuery() {
         return this.materialize();
     }
+    /**
+     * Estimates the cost of this loaded `Query`.
+     *
+     * @return The estimated cost of running this loaded query.
+     */
+    async estimateQueryCost() {
+        const connections = this.runtime.connections;
+        const preparedResult = await this.getPreparedResult();
+        return Malloy.estimateQueryCost({ connections, preparedResult });
+    }
 }
 exports.QueryMaterializer = QueryMaterializer;
 /**
@@ -1967,6 +1994,11 @@ class SQLBlockMaterializer extends FluentState {
         const sqlStruct = await this.getSQLBlock();
         return sqlStruct.structSource.sqlBlock.selectStr;
     }
+    async estimateQueryCost() {
+        const connections = this.runtime.connections;
+        const sqlStruct = await this.getSQLBlock();
+        return Malloy.estimateQueryCost({ connections, sqlStruct });
+    }
 }
 exports.SQLBlockMaterializer = SQLBlockMaterializer;
 /**

package/dist/runtime_types.d.ts

@@ -1,5 +1,5 @@
 import { RunSQLOptions } from './run_sql_options';
-import { MalloyQueryData, QueryDataRow, SQLBlock, StructDef } from './model/malloy_types';
+import { MalloyQueryData, QueryDataRow, QueryRunStats, SQLBlock, StructDef } from './model/malloy_types';
 /**
  * The contents of a Malloy query document.
  */
@@ -77,6 +77,7 @@ export interface Connection extends InfoConnection {
     canPersist(): this is PersistSQLResults;
     canStream(): this is StreamingConnection;
     close(): Promise<void>;
+    estimateQueryCost(sqlCommand: string): Promise<QueryRunStats>;
 }
 export interface TestableConnection extends Connection {
     test(): Promise<void>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@malloydata/malloy",
-  "version": "0.0.38-dev230602001052",
+  "version": "0.0.38-dev230606045241",
   "license": "MIT",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",