@malloydata/render 0.0.119-dev240116200529 → 0.0.119-dev240118211537

package/dist/bundle/bundled_renderer.js

@@ -3612,16 +3612,16 @@ ${(0, utils_1.indent)(sql)}
           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;
@@ -4678,6 +4678,16 @@ ${hackSplitComment}
       function identifierNormalize(s8) {
         return s8.replace(/[^a-zA-Z0-9_]/g, "_o_");
       }
+      var UniqueKeyUse = class extends Set {
+        add_use(k2) {
+          if (k2 !== void 0) {
+            return this.add(k2);
+          }
+        }
+        hasAsymetricFunctions() {
+          return this.has("sum") || this.has("avg") || this.has("count");
+        }
+      };
       var StageWriter = class {
         constructor(useCTE = true, parent) {
           this.parent = parent;
@@ -4809,8 +4819,8 @@ ${(0, utils_1.indent)(sql)})
           this.parent = parent;
           this.fieldDef = fieldDef;
         }
-        mayNeedUniqueKey() {
-          return false;
+        uniqueKeyPossibleUse() {
+          return void 0;
         }
         getJoinableParent() {
           const parent = this.parent;
@@ -5027,10 +5037,18 @@ ${(0, utils_1.indent)(sql)})
         generateCountFragment(resultSet, context3, expr2, state) {
           let func = "COUNT(";
           let thing = "1";
-          const distinctKeySQL = this.generateDistinctKeyIfNecessary(resultSet, context3, expr2.structPath);
-          if (distinctKeySQL) {
+          let struct = context3;
+          if (expr2.structPath) {
+            struct = this.parent.root().getStructByName(expr2.structPath);
+          }
+          const joinName = struct.getJoinableParent().getIdentifier();
+          const join3 = resultSet.root().joins.get(joinName);
+          if (!join3) {
+            throw new Error(`Join ${joinName} not found in result set`);
+          }
+          if (!join3.leafiest || join3.makeUniqueKey) {
             func = "COUNT(DISTINCT";
-            thing = distinctKeySQL;
+            thing = struct.getDistinctKey().generateExpression(resultSet);
           }
           if (state.whereSQL) {
             return `${func} CASE WHEN ${state.whereSQL} THEN ${thing} END)`;
@@ -5293,7 +5311,12 @@ ${(0, utils_1.indent)(sql)})
             return pk.generateExpression(resultSet);
           } 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.dialect.sqlFieldReference(this.parent.getIdentifier(), "__distinct_key", "string", this.parent.fieldDef.structRelationship.type === "nested", false);
           }
@@ -5531,7 +5554,7 @@ ${(0, utils_1.indent)(sql)})
           }
           return [];
         }
-        addStructToJoin(qs, query, mayNeedUniqueKey, joinStack) {
+        addStructToJoin(qs, query, uniqueKeyPossibleUse, joinStack) {
           var _a;
           const name = qs.getIdentifier();
           if (joinStack.indexOf(name) !== -1) {
@@ -5539,13 +5562,13 @@ ${(0, utils_1.indent)(sql)})
           }
           let join3;
           if (join3 = this.root().joins.get(name)) {
-            join3.mayNeedUniqueKey || (join3.mayNeedUniqueKey = mayNeedUniqueKey);
+            join3.uniqueKeyPossibleUses.add_use(uniqueKeyPossibleUse);
             return;
           }
           let parent;
           const parentStruct = (_a = qs.parent) === null || _a === void 0 ? void 0 : _a.getJoinableParent();
           if (parentStruct) {
-            this.addStructToJoin(parentStruct, query, false, joinStack);
+            this.addStructToJoin(parentStruct, query, void 0, joinStack);
             parent = this.root().joins.get(parentStruct.getIdentifier());
           }
           const sr = qs.fieldDef.structRelationship;
@@ -5560,11 +5583,11 @@ ${(0, utils_1.indent)(sql)})
             join3 = new JoinInstance(qs, name, parent);
             this.root().joins.set(name, join3);
           }
-          join3.mayNeedUniqueKey || (join3.mayNeedUniqueKey = mayNeedUniqueKey);
+          join3.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 s8 of this.structs()) {
             s8.findJoins(query);
@@ -5660,7 +5683,11 @@ ${(0, utils_1.indent)(sql)})
             join3.leafiest = name === leafiest;
           }
           for (const [_name, join3] of this.joins) {
-            if (!join3.leafiest && join3.mayNeedUniqueKey) {
+            if (join3.leafiest) {
+              if (join3.parent !== null && join3.uniqueKeyPossibleUses.has("count") && !join3.queryStruct.primaryKey()) {
+                join3.makeUniqueKey = true;
+              }
+            } else if (!join3.leafiest && join3.uniqueKeyPossibleUses.hasAsymetricFunctions()) {
               let j2 = join3;
               while (j2) {
                 if (!j2.queryStruct.primaryKey()) {
@@ -5681,7 +5708,7 @@ ${(0, utils_1.indent)(sql)})
           this.queryStruct = queryStruct;
           this.alias = alias;
           this.parent = parent;
-          this.mayNeedUniqueKey = false;
+          this.uniqueKeyPossibleUses = new UniqueKeyUse();
           this.makeUniqueKey = false;
           this.leafiest = false;
           this.children = [];
@@ -5914,7 +5941,7 @@ ${(0, utils_1.indent)(sql)})
           }
           return ret;
         }
-        addDependantPath(resultStruct, context3, path3, mayNeedUniqueKey, joinStack) {
+        addDependantPath(resultStruct, context3, path3, uniqueKeyPossibleUse, joinStack) {
           const node = context3.getFieldByName(path3);
           let struct;
           if (node instanceof QueryField) {
@@ -5924,7 +5951,7 @@ ${(0, utils_1.indent)(sql)})
           } else {
             throw new Error("Internal Error:  Unknown object type");
           }
-          resultStruct.root().addStructToJoin(struct.getJoinableParent(), this, mayNeedUniqueKey, joinStack);
+          resultStruct.root().addStructToJoin(struct.getJoinableParent(), this, uniqueKeyPossibleUse, joinStack);
         }
         addDependantExpr(resultStruct, context3, e12, joinStack) {
           for (const expr2 of e12) {
@@ -5952,7 +5979,7 @@ ${(0, utils_1.indent)(sql)})
               if ((0, malloy_types_1.hasExpression)(field3.fieldDef)) {
                 this.addDependantExpr(resultStruct, field3.parent, field3.fieldDef.e, joinStack);
               } else {
-                resultStruct.root().addStructToJoin(field3.parent.getJoinableParent(), this, false, joinStack);
+                resultStruct.root().addStructToJoin(field3.parent.getJoinableParent(), this, void 0, joinStack);
               }
             } else if ((0, malloy_types_1.isFilterFragment)(expr2)) {
               for (const filterCond of expr2.filterList) {
@@ -5997,15 +6024,15 @@ ${(0, utils_1.indent)(sql)})
             } else if ((0, malloy_types_1.isAggregateFragment)(expr2)) {
               if ((0, malloy_types_1.isAsymmetricFragment)(expr2)) {
                 if (expr2.structPath) {
-                  this.addDependantPath(resultStruct, context3, expr2.structPath, true, joinStack);
+                  this.addDependantPath(resultStruct, context3, expr2.structPath, expr2.function, joinStack);
                 } else {
-                  resultStruct.addStructToJoin(context3, this, true, joinStack);
+                  resultStruct.addStructToJoin(context3, this, expr2.function, joinStack);
                 }
               }
               this.addDependantExpr(resultStruct, context3, expr2.e, joinStack);
             } else if ((0, malloy_types_1.isFunctionCallFragment)(expr2)) {
               if (expr2.structPath) {
-                this.addDependantPath(resultStruct, context3, expr2.structPath, true, joinStack);
+                this.addDependantPath(resultStruct, context3, expr2.structPath, "generic_aggregate", joinStack);
               }
               for (const e13 of expr2.args) {
                 this.addDependantExpr(resultStruct, context3, e13, joinStack);
@@ -6082,7 +6109,7 @@ ${(0, utils_1.indent)(sql)})
         prepare(_stageWriter) {
           if (!this.prepared) {
             this.expandFields(this.rootResult);
-            this.rootResult.addStructToJoin(this.parent, this, false, []);
+            this.rootResult.addStructToJoin(this.parent, this, void 0, []);
             this.rootResult.findJoins(this);
             this.rootResult.calculateSymmetricAggregates();
             this.prepared = true;