@malloydata/malloy 0.0.81-dev230910202545 → 0.0.81

package/dist/lang/ast/expressions/expr-aggregate-function.js

@@ -124,7 +124,7 @@ class ExprAggregateFunction extends expression_def_1.ExpressionDef {
                 const noJoinField = !this.source && joinUsage.every(usage => usage.length === 0);
                 if (!noJoinField && !this.isSymmetricFunction()) {
                     const usagePaths = getJoinUsagePaths(sourceRelationship, joinUsage);
-                    const joinError = validateUsagePaths(usagePaths);
+                    const joinError = validateUsagePaths(this.elementType, usagePaths);
                     const message = sourceSpecified
                         ? joinError
                         : 'Join path is required for this calculation';
@@ -254,14 +254,17 @@ function getJoinUsagePaths(sourceRelationship, joinUsage) {
     }
     return sourceToUsagePaths;
 }
-function validateUsagePaths(usagePaths) {
+function validateUsagePaths(functionName, usagePaths) {
     for (const path of usagePaths) {
         for (const step of path) {
             if (step.structRelationship.type === 'cross') {
-                return `Cannot compute asymmetric aggregate across \`join_cross\` relationship \`${step.name}\``;
+                return `Cannot compute \`${functionName}\` across \`join_cross\` relationship \`${step.name}\``;
             }
             else if (step.structRelationship.type === 'many' && !step.reverse) {
-                return `Cannot compute asymmetric aggregate across forward \`join_many\` relationship \`${step.name}\``;
+                return `Cannot compute \`${functionName}\` across \`join_many\` relationship \`${step.name}\``;
+            }
+            else if (step.structRelationship.type === 'nested' && !step.reverse) {
+                return `Cannot compute \`${functionName}\` across repeated relationship \`${step.name}\``;
             }
         }
     }
@@ -283,7 +286,7 @@ function suggestNewVersion(joinError, joinUsage, expr, func) {
         }
     }
     const usagePaths = getJoinUsagePaths(longestOverlap, joinUsage);
-    const usageError = validateUsagePaths(usagePaths);
+    const usageError = validateUsagePaths(func, usagePaths);
     // get rid of everything after the last many/cross
     const indexFromEndOfLastMany = longestOverlap
         .slice()
@@ -295,7 +298,7 @@ function suggestNewVersion(joinError, joinUsage, expr, func) {
         : longestOverlap.length - indexFromEndOfLastMany;
     const shortestOverlapWithMany = longestOverlap.slice(0, numJoinsToLastMany);
     const shortUsagePaths = getJoinUsagePaths(shortestOverlapWithMany, joinUsage);
-    const shortUsageError = validateUsagePaths(shortUsagePaths);
+    const shortUsageError = validateUsagePaths(func, shortUsagePaths);
     const longLocality = longestOverlap.length > 0
         ? longestOverlap.map(r => r.name).join('.')
         : 'source';

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

@@ -76,18 +76,22 @@ class Filter extends malloy_element_1.ListOf {
             // Aggregates are ALSO checked at SQL generation time, but checking
             // here allows better reflection of errors back to user.
             if (this.havingClause !== undefined) {
-                const needHaving = (0, malloy_types_1.expressionIsCalculation)(fExpr.expressionType);
+                const isAggregate = (0, malloy_types_1.expressionIsAggregate)(fExpr.expressionType);
+                const isAnalytic = (0, malloy_types_1.expressionIsAnalytic)(fExpr.expressionType);
                 if (this.havingClause) {
-                    if (!needHaving) {
-                        oneElement.log('Aggregate or analytic expression expected in HAVING filter');
+                    if (isAnalytic) {
+                        oneElement.log('Analytic expressions are not allowed in `having:`');
                         continue;
                     }
                 }
                 else {
-                    if (needHaving) {
-                        oneElement.log('Aggregate or analytic expressions not allowed in WHERE');
+                    if (isAnalytic) {
+                        oneElement.log('Analytic expressions are not allowed in `where:`');
                         continue;
                     }
+                    else if (isAggregate) {
+                        oneElement.log('Aggregate expressions are not allowed in `where:`; use `having:`');
+                    }
                 }
             }
             checked.push(fExpr);

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

@@ -176,6 +176,7 @@ describe('expressions', () => {
       source: root is a {
         rename: column is ai
         rename: nested is astruct
+        rename: inline is aninline
         dimension: field is column * 2
         dimension: many_field is many.column * 2
         dimension: many_one_field is many.column + one.column
@@ -277,7 +278,7 @@ describe('expressions', () => {
             expect(modelX `sum(many.column)`).translationToFailWith('Join path is required for this calculation; use `many.column.sum()`');
         });
         test('source.sum(many.column)', () => {
-            expect(modelX `source.sum(many.column)`).translationToFailWith('Cannot compute asymmetric aggregate across forward `join_many` relationship `many`; use `many.column.sum()`');
+            expect(modelX `source.sum(many.column)`).translationToFailWith('Cannot compute `sum` across `join_many` relationship `many`; use `many.column.sum()`');
         });
         test('many.column.sum()', () => {
             expect(modelX `many.column.sum()`).toTranslate();
@@ -295,19 +296,28 @@ describe('expressions', () => {
             expect(modelX `source.sum(many.constant)`).toTranslate();
         });
         test('sum(nested.column)', () => {
-            expect(modelX `sum(nested.column)`).toTranslateWithWarnings('Join path is required for this calculation; use `nested.column.sum()` or `source.sum(nested.column)` to get a result weighted with respect to `source`');
+            expect(modelX `sum(nested.column)`).translationToFailWith('Join path is required for this calculation; use `nested.column.sum()`');
         });
         test('nested.column.sum()', () => {
             expect(modelX `nested.column.sum()`).toTranslate();
         });
         test('source.sum(nested.column)', () => {
-            expect(modelX `source.sum(nested.column)`).toTranslate();
+            expect(modelX `source.sum(nested.column)`).translationToFailWith('Cannot compute `sum` across repeated relationship `nested`; use `nested.column.sum()`');
+        });
+        test('sum(inline.column)', () => {
+            expect(modelX `sum(inline.column)`).toTranslateWithWarnings('Join path is required for this calculation; use `inline.column.sum()` or `source.sum(inline.column)` to get a result weighted with respect to `source`');
+        });
+        test('inline.column.sum()', () => {
+            expect(modelX `inline.column.sum()`).toTranslate();
+        });
+        test('source.sum(inline.column)', () => {
+            expect(modelX `source.sum(inline.column)`).toTranslate();
         });
         test('sum(many.field)', () => {
             expect(modelX `sum(many.field)`).translationToFailWith('Join path is required for this calculation; use `many.field.sum()`');
         });
         test('source.sum(many.field)', () => {
-            expect(modelX `source.sum(many.field)`).translationToFailWith('Cannot compute asymmetric aggregate across forward `join_many` relationship `many`; use `many.field.sum()`');
+            expect(modelX `source.sum(many.field)`).translationToFailWith('Cannot compute `sum` across `join_many` relationship `many`; use `many.field.sum()`');
         });
         test('many.field.sum()', () => {
             expect(modelX `many.field.sum()`).toTranslate();
@@ -319,7 +329,7 @@ describe('expressions', () => {
             expect(modelX `sum(many.field + many.field)`).translationToFailWith('Join path is required for this calculation; use `many.sum(many.field + many.field)`');
         });
         test('source.sum(many.field + many.field)', () => {
-            expect(modelX `source.sum(many.field + many.field)`).translationToFailWith('Cannot compute asymmetric aggregate across forward `join_many` relationship `many`; use `many.sum(many.field + many.field)`');
+            expect(modelX `source.sum(many.field + many.field)`).translationToFailWith('Cannot compute `sum` across `join_many` relationship `many`; use `many.sum(many.field + many.field)`');
         });
         test('many.field + many.field.sum()', () => {
             expect(modelX `many.field + many.field.sum()`).toTranslate();
@@ -331,7 +341,7 @@ describe('expressions', () => {
             expect(modelX `sum(many_field)`).translationToFailWith('Join path is required for this calculation; use `many_field.sum()`');
         });
         test('source.sum(many_field)', () => {
-            expect(modelX `source.sum(many_field)`).translationToFailWith('Cannot compute asymmetric aggregate across forward `join_many` relationship `many`; use `many_field.sum()`');
+            expect(modelX `source.sum(many_field)`).translationToFailWith('Cannot compute `sum` across `join_many` relationship `many`; use `many_field.sum()`');
         });
         test('many_field.sum()', () => {
             expect(modelX `many_field.sum()`).toTranslate();
@@ -343,7 +353,7 @@ describe('expressions', () => {
             expect(modelX `sum(one.many_field)`).translationToFailWith('Join path is required for this calculation; use `one.many_field.sum()`');
         });
         test('source.sum(one.many_field)', () => {
-            expect(modelX `source.sum(one.many_field)`).translationToFailWith('Cannot compute asymmetric aggregate across forward `join_many` relationship `many`; use `one.many_field.sum()`');
+            expect(modelX `source.sum(one.many_field)`).translationToFailWith('Cannot compute `sum` across `join_many` relationship `many`; use `one.many_field.sum()`');
         });
         test('one.many_field.sum()', () => {
             expect(modelX `one.many_field.sum()`).toTranslate();
@@ -382,7 +392,7 @@ describe('expressions', () => {
             expect(modelX `one.avg(field)`).toTranslate();
         });
         test('cross.avg(field)', () => {
-            expect(modelX `cross.avg(field)`).translationToFailWith('Cannot compute asymmetric aggregate across `join_cross` relationship `cross`; use `field.avg()`');
+            expect(modelX `cross.avg(field)`).translationToFailWith('Cannot compute `avg` across `join_cross` relationship `cross`; use `field.avg()`');
         });
         test('cross.avg(cross.field)', () => {
             expect(modelX `cross.avg(cross.field)`).toTranslate();

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

@@ -805,6 +805,15 @@ describe('query:', () => {
         }
       `).toTranslate();
         });
+        test('agg cannot be used in where', () => {
+            expect('query:ab->{ aggregate: acount; group_by: astr; where: acount > 10 }').translationToFailWith('Aggregate expressions are not allowed in `where:`; use `having:`');
+        });
+        test('analytic cannot be used in where', () => {
+            expect('query:ab->{ calculate: prevc is lag(count()); group_by: astr; where: prevc > 10 }').translationToFailWith("'prevc' is not defined");
+        });
+        test('analytic cannot be used in having', () => {
+            expect('query:ab->{ calculate: prevc is lag(count()); group_by: astr; having: prevc > 10 }').translationToFailWith('Analytic expressions are not allowed in `having:`');
+        });
         test('where single', () => {
             expect('query:a->{ group_by: astr; where: af > 10 }').toTranslate();
         });

package/dist/lang/test/test-translator.js

@@ -55,6 +55,14 @@ const mockSchema = {
                 type: 'struct',
                 name: 'astruct',
                 structSource: { type: 'nested' },
+                structRelationship: { type: 'nested', isArray: true, field: 'foo' },
+                fields: [{ type: 'number', name: 'column', numberType: 'integer' }],
+                dialect: 'standardsql',
+            },
+            {
+                type: 'struct',
+                name: 'aninline',
+                structSource: { type: 'nested' },
                 structRelationship: { type: 'inline' },
                 fields: [{ type: 'number', name: 'column', numberType: 'integer' }],
                 dialect: 'standardsql',

package/package.json

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