@malloydata/malloy 0.0.436 → 0.0.437

package/dist/dialect/postgres/postgres.js

@@ -281,14 +281,18 @@ class PostgresDialect extends pg_impl_1.PostgresBase {
         // PostgreSQL requires CAST to NUMERIC before ROUND, which is different
         // than the generic implementation of sqlSumDistinct, but is OK in
         // PostgreSQL because NUMERIC has arbitrary precision.
+        // The sum stays NUMERIC so later stages and derived expressions see the
+        // exact value. A DOUBLE PRECISION cast would keep only ~16 digits. The
+        // ROUND(..., 9) leaves a scale of 9, which would show up in string
+        // conversions as trailing zeros; trim_scale removes it.
         const roundedValue = `ROUND(CAST(COALESCE(${value}, 0) AS NUMERIC), 9)`;
         const sumSQL = `SUM(DISTINCT ${roundedValue} + ${hashKey}) - SUM(DISTINCT ${hashKey})`;
-        const ret = `CAST(${sumSQL} AS DOUBLE PRECISION)`;
+        const ret = `trim_scale(${sumSQL})`;
         if (funcName === 'SUM') {
             return ret;
         }
         else if (funcName === 'AVG') {
-            return `(${ret})/NULLIF(COUNT(DISTINCT CASE WHEN ${value} IS NOT NULL THEN ${key} END), 0)`;
+            return `trim_scale((${sumSQL})/NULLIF(COUNT(DISTINCT CASE WHEN ${value} IS NOT NULL THEN ${key} END), 0))`;
         }
         throw new Error(`Unknown Symmetric Aggregate function ${funcName}`);
     }

package/dist/lang/ast/expressions/expr-props.js

@@ -67,7 +67,7 @@ class ExprProps extends expression_def_1.ExpressionDef {
             for (const where of wheres) {
                 const testList = where.getFilterList(fs);
                 if (testList.find(cond => (0, malloy_types_1.expressionIsCalculation)(cond.expressionType))) {
-                    where.logError('aggregate-filter-expression-not-scalar', 'Cannot filter an expresion with an aggregate or analytical computation');
+                    where.logError('aggregate-filter-expression-not-scalar', 'Cannot filter an expression with an aggregate or analytical computation');
                     return expr;
                 }
                 filterList.push(...testList);

package/dist/lang/ast/expressions/time-literal.js

@@ -53,7 +53,12 @@ class TimeLiteral extends expression_def_1.ExpressionDef {
         }
     }
     makeLiteral(fs, val, typ, units) {
-        return dialect_1.Dialect.makeTimeLiteralNode(fs.dialectObj(), val, this.timeZone, units, typ);
+        let timeZone = this.timeZone;
+        if (timeZone !== undefined && !dialect_1.Dialect.isSafeTimezoneName(timeZone)) {
+            this.logError('invalid-timezone', { timezone: timeZone });
+            timeZone = undefined;
+        }
+        return dialect_1.Dialect.makeTimeLiteralNode(fs.dialectObj(), val, timeZone, units, typ);
     }
     makeValue(fs, val, dataType) {
         const value = this.makeLiteral(fs, val, dataType, this.units);

package/dist/lang/ast/query-properties/drill.js

@@ -89,6 +89,7 @@ class Drill extends filters_1.Filter {
         let previousName = viewName;
         let fieldDef = undefined;
         let compareField = undefined;
+        let compareUsage = undefined;
         const requiredDimensions = [];
         const pathSoFar = [viewName.name];
         for (const name of path) {
@@ -189,6 +190,9 @@ class Drill extends filters_1.Filter {
                     if (theFieldDef === undefined || (0, malloy_types_1.isAtomic)(theFieldDef)) {
                         fieldDef = theFieldDef;
                         compareField = { node: 'field', path: field.path };
+                        // theFieldDef's refSummary is relative to the struct it lives in;
+                        // use the full path, as `where:` does, so joins along it activate.
+                        compareUsage = [{ path: field.path, at: reference.location }];
                     }
                     else {
                         name.logError('drill-field-reference-not-field', 'Final element of drill path must be a field');
@@ -268,7 +272,9 @@ class Drill extends filters_1.Filter {
             ...fieldDef,
             evalSpace: 'output',
             expressionType: (_b = fieldDef.expressionType) !== null && _b !== void 0 ? _b : 'scalar',
-            refSummary: fieldDef.refSummary,
+            refSummary: compareUsage
+                ? (0, malloy_types_1.mkRefSummary)({ fieldUsage: compareUsage })
+                : fieldDef.refSummary,
         });
         filter.has({ drillField });
         const fExpression = new expr_compare_1.ExprCompare(drillField, '=', value);