@malloydata/malloy 0.0.119-dev240116200529 → 0.0.119-dev240118211537

package/dist/dialect/postgres/postgres.js

@@ -193,16 +193,16 @@ class PostgresDialect extends dialect_1.Dialect {
         return 'GEN_RANDOM_UUID()';
     }
     sqlFieldReference(alias, fieldName, fieldType, isNested, _isArray) {
-        let ret = `${alias}->>'${fieldName}'`;
+        let ret = `(${alias}->>'${fieldName}')`;
         if (isNested) {
             switch (fieldType) {
                 case 'string':
                     break;
                 case 'number':
-                    ret = `(${ret})::double precision`;
+                    ret = `${ret}::double precision`;
                     break;
                 case 'struct':
-                    ret = `(${ret})::jsonb`;
+                    ret = `${ret}::jsonb`;
                     break;
             }
             return ret;

package/dist/lang/ast/expressions/expr-aggregate-function.d.ts

@@ -1,16 +1,16 @@
-import { FieldValueType, StructRelationship } from '../../../model/malloy_types';
+import { AggregateFunctionType, FieldValueType, StructRelationship } from '../../../model/malloy_types';
 import { FieldReference } from '../query-items/field-references';
 import { ExprValue } from '../types/expr-value';
 import { ExpressionDef } from '../types/expression-def';
 import { FieldSpace } from '../types/field-space';
 export declare abstract class ExprAggregateFunction extends ExpressionDef {
-    readonly func: string;
+    readonly func: AggregateFunctionType;
     elementType: string;
     source?: FieldReference;
     expr?: ExpressionDef;
     explicitSource?: boolean;
     legalChildTypes: import("../../../model/malloy_types").TypeDesc[];
-    constructor(func: string, expr?: ExpressionDef, explicitSource?: boolean);
+    constructor(func: AggregateFunctionType, expr?: ExpressionDef, explicitSource?: boolean);
     returns(_forExpression: ExprValue): FieldValueType;
     getExpression(fs: FieldSpace): ExprValue;
     isSymmetricFunction(): boolean;

package/dist/model/malloy_query.d.ts

@@ -1,5 +1,5 @@
 import { Dialect, DialectFieldList } from '../dialect';
-import { AggregateFragment, CompiledQuery, DialectFragment, Expr, FieldDef, FieldFragment, FieldRef, Filtered, FilterExpression, FilterFragment, FunctionCallFragment, FunctionOverloadDef, JoinRelationship, ModelDef, OrderBy, OutputFieldFragment, Parameter, ParameterFragment, PipeSegment, Query, QueryFieldDef, QuerySegment, ResultMetadataDef, ResultStructMetadataDef, SearchIndexResult, SpreadFragment, SQLExpressionFragment, StructDef, StructRef, TurtleDef, UngroupFragment } from './malloy_types';
+import { AggregateFragment, AggregateFunctionType, CompiledQuery, DialectFragment, Expr, FieldDef, FieldFragment, FieldRef, Filtered, FilterExpression, FilterFragment, FunctionCallFragment, FunctionOverloadDef, JoinRelationship, ModelDef, OrderBy, OutputFieldFragment, Parameter, ParameterFragment, PipeSegment, Query, QueryFieldDef, QuerySegment, ResultMetadataDef, ResultStructMetadataDef, SearchIndexResult, SpreadFragment, SQLExpressionFragment, StructDef, StructRef, TurtleDef, UngroupFragment } from './malloy_types';
 import { Connection } from '../runtime_types';
 import { AndChain } from './utils';
 import { QueryInfo } from '../dialect/dialect';
@@ -17,6 +17,11 @@ interface OutputPipelinedSQL {
     sqlFieldName: string;
     pipelineSQL: string;
 }
+type UniqueKeyPossibleUse = AggregateFunctionType | 'generic_aggregate';
+declare class UniqueKeyUse extends Set<UniqueKeyPossibleUse> {
+    add_use(k: UniqueKeyPossibleUse | undefined): this | undefined;
+    hasAsymetricFunctions(): boolean;
+}
 declare class StageWriter {
     parent: StageWriter | undefined;
     withs: string[];
@@ -57,7 +62,7 @@ declare class QueryField extends QueryNode {
     fieldDef: FieldDef;
     parent: QueryStruct;
     constructor(fieldDef: FieldDef, parent: QueryStruct);
-    mayNeedUniqueKey(): boolean;
+    uniqueKeyPossibleUse(): UniqueKeyPossibleUse | undefined;
     getJoinableParent(): QueryStruct;
     caseGroup(groupSets: number[], s: string): string;
     getFullOutputName(): string;
@@ -166,7 +171,7 @@ declare class FieldInstanceResult implements FieldInstance {
     structs(): FieldInstanceResult[];
     selectStructs(result: FieldInstanceResult[], fn: (result: FieldInstanceResult) => boolean): FieldInstanceResult[];
     calculateDefaultOrderBy(): OrderBy[];
-    addStructToJoin(qs: QueryStruct, query: QueryQuery, mayNeedUniqueKey: boolean, joinStack: string[]): void;
+    addStructToJoin(qs: QueryStruct, query: QueryQuery, uniqueKeyPossibleUse: UniqueKeyPossibleUse | undefined, joinStack: string[]): void;
     findJoins(query: QueryQuery): void;
     root(): FieldInstanceResultRoot;
     getUngroupPartitions(ungroupSet: UngroupSet | undefined): FieldInstanceField[];
@@ -188,7 +193,7 @@ declare class JoinInstance {
     queryStruct: QueryStruct;
     alias: string;
     parent: JoinInstance | undefined;
-    mayNeedUniqueKey: boolean;
+    uniqueKeyPossibleUses: UniqueKeyUse;
     makeUniqueKey: boolean;
     leafiest: boolean;
     joinFilterConditions?: QueryFieldBoolean[];
@@ -243,7 +248,7 @@ declare class QueryQuery extends QueryField {
     expandDependantField(resultStruct: FieldInstanceResult, fieldRef: FieldRef): void;
     expandWildCardStruct(struct: QueryStruct, expandChildren: boolean, filter?: ((qf: QueryNode) => boolean) | undefined): string[];
     expandWildCards(fields: QueryFieldDef[], filter?: ((qf: QueryNode) => boolean) | undefined): QueryFieldDef[];
-    addDependantPath(resultStruct: FieldInstanceResult, context: QueryStruct, path: string, mayNeedUniqueKey: boolean, joinStack: string[]): void;
+    addDependantPath(resultStruct: FieldInstanceResult, context: QueryStruct, path: string, uniqueKeyPossibleUse: UniqueKeyPossibleUse | undefined, joinStack: string[]): void;
     addDependantExpr(resultStruct: FieldInstanceResult, context: QueryStruct, e: Expr, joinStack: string[]): void;
     addDependancies(resultStruct: FieldInstanceResult, field: QueryField): void;
     expandFields(resultStruct: FieldInstanceResult): void;

package/dist/model/malloy_query.js

@@ -34,6 +34,16 @@ function generateSQLStringLiteral(sourceString) {
 function identifierNormalize(s) {
     return s.replace(/[^a-zA-Z0-9_]/g, '_o_');
 }
+class UniqueKeyUse extends Set {
+    add_use(k) {
+        if (k !== undefined) {
+            return this.add(k);
+        }
+    }
+    hasAsymetricFunctions() {
+        return this.has('sum') || this.has('avg') || this.has('count');
+    }
+}
 class StageWriter {
     constructor(useCTE = true, parent) {
         this.parent = parent;
@@ -173,8 +183,8 @@ class QueryField extends QueryNode {
         this.parent = parent;
         this.fieldDef = fieldDef;
     }
-    mayNeedUniqueKey() {
-        return false;
+    uniqueKeyPossibleUse() {
+        return undefined;
     }
     getJoinableParent() {
         // if it is inline it should always have a parent
@@ -436,11 +446,28 @@ class QueryField extends QueryNode {
     generateCountFragment(resultSet, context, expr, state) {
         let func = 'COUNT(';
         let thing = '1';
-        const distinctKeySQL = this.generateDistinctKeyIfNecessary(resultSet, context, expr.structPath);
-        if (distinctKeySQL) {
-            func = 'COUNT(DISTINCT';
-            thing = distinctKeySQL;
+        let struct = context;
+        if (expr.structPath) {
+            struct = this.parent.root().getStructByName(expr.structPath);
         }
+        const joinName = struct.getJoinableParent().getIdentifier();
+        const join = resultSet.root().joins.get(joinName);
+        if (!join) {
+            throw new Error(`Join ${joinName} not found in result set`);
+        }
+        if (!join.leafiest || join.makeUniqueKey) {
+            func = 'COUNT(DISTINCT';
+            thing = struct.getDistinctKey().generateExpression(resultSet);
+        }
+        // const distinctKeySQL = this.generateDistinctKeyIfNecessary(
+        //   resultSet,
+        //   context,
+        //   expr.structPath
+        // );
+        // if (distinctKeySQL) {
+        //   func = 'COUNT(DISTINCT';
+        //   thing = distinctKeySQL;
+        // }
         // find the structDef and return the path to the field...
         if (state.whereSQL) {
             return `${func} CASE WHEN ${state.whereSQL} THEN ${thing} END)`;
@@ -746,7 +773,8 @@ class QueryFieldDistinctKey extends QueryAtomicField {
         }
         else if (this.parent.fieldDef.structSource.type === 'nested') {
             const parentKey = (_a = this.parent.parent) === null || _a === void 0 ? void 0 : _a.getDistinctKey().generateExpression(resultSet);
-            return `CONCAT(${parentKey}, 'x', ${this.parent.dialect.sqlFieldReference(this.parent.getIdentifier(), '__row_id', 'string', true, false)})`;
+            return this.parent.dialect.concat(parentKey || '', // shouldn't have to do this...
+            "'x'", this.parent.dialect.sqlFieldReference(this.parent.getIdentifier(), '__row_id', 'string', true, false));
         }
         else {
             // return this.parent.getIdentifier() + "." + "__distinct_key";
@@ -1003,7 +1031,7 @@ class FieldInstanceResult {
         }
         return [];
     }
-    addStructToJoin(qs, query, mayNeedUniqueKey, joinStack) {
+    addStructToJoin(qs, query, uniqueKeyPossibleUse, joinStack) {
         var _a;
         const name = qs.getIdentifier();
         // we're already chasing the dependency for this join.
@@ -1012,7 +1040,7 @@ class FieldInstanceResult {
         }
         let join;
         if ((join = this.root().joins.get(name))) {
-            join.mayNeedUniqueKey || (join.mayNeedUniqueKey = mayNeedUniqueKey);
+            join.uniqueKeyPossibleUses.add_use(uniqueKeyPossibleUse);
             return;
         }
         // if we have a parent, join it first.
@@ -1020,7 +1048,7 @@ class FieldInstanceResult {
         const parentStruct = (_a = qs.parent) === null || _a === void 0 ? void 0 : _a.getJoinableParent();
         if (parentStruct) {
             // add dependant expressions first...
-            this.addStructToJoin(parentStruct, query, false, joinStack);
+            this.addStructToJoin(parentStruct, query, undefined, joinStack);
             parent = this.root().joins.get(parentStruct.getIdentifier());
         }
         // add any dependant joins based on the ON
@@ -1038,11 +1066,11 @@ class FieldInstanceResult {
             join = new JoinInstance(qs, name, parent);
             this.root().joins.set(name, join);
         }
-        join.mayNeedUniqueKey || (join.mayNeedUniqueKey = mayNeedUniqueKey);
+        join.uniqueKeyPossibleUses.add_use(uniqueKeyPossibleUse);
     }
     findJoins(query) {
         for (const dim of this.fields()) {
-            this.addStructToJoin(dim.f.getJoinableParent(), query, dim.f.mayNeedUniqueKey(), []);
+            this.addStructToJoin(dim.f.getJoinableParent(), query, dim.f.uniqueKeyPossibleUse(), []);
         }
         for (const s of this.structs()) {
             s.findJoins(query);
@@ -1167,8 +1195,20 @@ class FieldInstanceResultRoot extends FieldInstanceResult {
         //  Nested Unique keys are dependant on the primary key of the parent
         //  and the table.
         for (const [_name, join] of this.joins) {
-            // don't need keys on leafiest
-            if (!join.leafiest && join.mayNeedUniqueKey) {
+            // in a one_to_many join we need a key to count there may be a failed
+            //  match in a left join.
+            // users -> {
+            //   group_by: user_id
+            //   aggregate: order_count is orders.count()
+            if (join.leafiest) {
+                if (join.parent !== null &&
+                    join.uniqueKeyPossibleUses.has('count') &&
+                    !join.queryStruct.primaryKey()) {
+                    join.makeUniqueKey = true;
+                }
+            }
+            else if (!join.leafiest &&
+                join.uniqueKeyPossibleUses.hasAsymetricFunctions()) {
                 let j = join;
                 while (j) {
                     if (!j.queryStruct.primaryKey()) {
@@ -1190,7 +1230,7 @@ class JoinInstance {
         this.queryStruct = queryStruct;
         this.alias = alias;
         this.parent = parent;
-        this.mayNeedUniqueKey = false;
+        this.uniqueKeyPossibleUses = new UniqueKeyUse();
         this.makeUniqueKey = false;
         this.leafiest = false;
         this.children = [];
@@ -1474,7 +1514,7 @@ class QueryQuery extends QueryField {
         }
         return ret;
     }
-    addDependantPath(resultStruct, context, path, mayNeedUniqueKey, joinStack) {
+    addDependantPath(resultStruct, context, path, uniqueKeyPossibleUse, joinStack) {
         const node = context.getFieldByName(path);
         let struct;
         if (node instanceof QueryField) {
@@ -1488,7 +1528,7 @@ class QueryQuery extends QueryField {
         }
         resultStruct
             .root()
-            .addStructToJoin(struct.getJoinableParent(), this, mayNeedUniqueKey, joinStack);
+            .addStructToJoin(struct.getJoinableParent(), this, uniqueKeyPossibleUse, joinStack);
     }
     addDependantExpr(resultStruct, context, e, joinStack) {
         for (const expr of e) {
@@ -1523,7 +1563,7 @@ class QueryQuery extends QueryField {
                 else {
                     resultStruct
                         .root()
-                        .addStructToJoin(field.parent.getJoinableParent(), this, false, joinStack);
+                        .addStructToJoin(field.parent.getJoinableParent(), this, undefined, joinStack);
                     // this.addDependantPath(resultStruct, field.parent, expr.path, false);
                 }
             }
@@ -1572,18 +1612,18 @@ class QueryQuery extends QueryField {
             else if ((0, malloy_types_1.isAggregateFragment)(expr)) {
                 if ((0, malloy_types_1.isAsymmetricFragment)(expr)) {
                     if (expr.structPath) {
-                        this.addDependantPath(resultStruct, context, expr.structPath, true, joinStack);
+                        this.addDependantPath(resultStruct, context, expr.structPath, expr.function, joinStack);
                     }
                     else {
                         // we are doing a sum in the root.  It may need symetric aggregates
-                        resultStruct.addStructToJoin(context, this, true, joinStack);
+                        resultStruct.addStructToJoin(context, this, expr.function, joinStack);
                     }
                 }
                 this.addDependantExpr(resultStruct, context, expr.e, joinStack);
             }
             else if ((0, malloy_types_1.isFunctionCallFragment)(expr)) {
                 if (expr.structPath) {
-                    this.addDependantPath(resultStruct, context, expr.structPath, true, joinStack);
+                    this.addDependantPath(resultStruct, context, expr.structPath, 'generic_aggregate', joinStack);
                 }
                 // TODO Do we need to call `addStructToJoin` here in the case when there is no `structPath`
                 // and the function is an aggregate function?
@@ -1688,7 +1728,7 @@ class QueryQuery extends QueryField {
     prepare(_stageWriter) {
         if (!this.prepared) {
             this.expandFields(this.rootResult);
-            this.rootResult.addStructToJoin(this.parent, this, false, []);
+            this.rootResult.addStructToJoin(this.parent, this, undefined, []);
             this.rootResult.findJoins(this);
             this.rootResult.calculateSymmetricAggregates();
             this.prepared = true;

package/dist/model/malloy_types.d.ts

@@ -108,9 +108,10 @@ export interface FilterFragment {
 }
 export declare function isFilterFragment(f: Fragment): f is FilterFragment;
 export declare function isDialectFragment(f: Fragment): f is DialectFragment;
+export type AggregateFunctionType = 'sum' | 'avg' | 'count' | 'count_distinct' | 'max' | 'min';
 export interface AggregateFragment {
     type: 'aggregate';
-    function: string;
+    function: AggregateFunctionType;
     e: Expr;
     structPath?: string;
 }

package/package.json

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