@malloydata/malloy 0.0.80-dev230903192621 → 0.0.80-dev230905212201

package/dist/lang/ast/field-space/query-spaces.d.ts

@@ -17,6 +17,7 @@ export declare abstract class QuerySpace extends RefinedSpace implements QueryFi
     private exprSpace;
     astEl?: MalloyElement | undefined;
     abstract readonly segmentType: 'reduce' | 'project' | 'index';
+    expandedWild: Record<string, string[]>;
     constructor(queryInputSpace: FieldSpace, refineThis: model.PipeSegment | undefined);
     private addRefineFromFields;
     log(s: string): void;

package/dist/lang/ast/field-space/query-spaces.js

@@ -65,6 +65,7 @@ class QuerySpace extends refined_space_1.RefinedSpace {
     constructor(queryInputSpace, refineThis) {
         super(queryInputSpace.emptyStructDef());
         this.queryInputSpace = queryInputSpace;
+        this.expandedWild = {};
         this.exprSpace = new query_input_space_1.QueryInputSpace(queryInputSpace, this);
         if (refineThis)
             this.addRefineFromFields(refineThis);
@@ -111,93 +112,49 @@ class QuerySpace extends refined_space_1.RefinedSpace {
     }
     setEntry(name, value) {
         super.setEntry(name, value);
-        // Everything in this namespace is and output field
+        // Everything in this namespace is an output field
         value.outputField = true;
     }
     addWild(wild) {
-        let success = true;
+        var _a;
         let current = this.exprSpace;
-        const parts = wild.refString.split('.');
-        const conflictMap = {};
-        function logConflict(name, parentRef) {
-            const conflict = conflictMap[name];
-            wild.log(`Cannot expand '${name}'${parentRef ? ` in ${parentRef}` : ''} because a field with that name already exists${conflict ? ` (conflicts with ${conflict})` : ''}`);
-            success = false;
-        }
-        for (let pi = 0; pi < parts.length; pi++) {
-            const part = parts[pi];
-            const prevParts = parts.slice(0, pi);
-            const parentRef = pi > 0 ? prevParts.join('.') : undefined;
-            const fullName = [...prevParts.join('.'), part].join('.');
-            if (part === '*') {
-                for (const [name, entry] of current.entries()) {
-                    if (this.entry(name)) {
-                        logConflict(name, parentRef);
-                        success = false;
-                    }
-                    if (model.expressionIsScalar(entry.typeDesc().expressionType)) {
-                        this.setEntry(name, entry);
-                        conflictMap[name] = fullName;
-                    }
-                }
-            }
-            else if (part === '**') {
-                // TODO actually handle **
-                wild.log('** is currently broken');
-                success = false;
-                // const spaces: {space: FieldSpace; ref: string | undefined}[] = [
-                //   {space: current, ref: undefined},
-                // ];
-                // let toExpand: {space: FieldSpace; ref: string | undefined} | undefined;
-                // while ((toExpand = spaces.pop())) {
-                //   for (const [name, entry] of toExpand.space.entries()) {
-                //     if (this.entry(name)) {
-                //       logConflict(name, toExpand.ref);
-                //       success = false;
-                //     }
-                //     if (model.expressionIsScalar(entry.typeDesc().expressionType)) {
-                //       this.setEntry(name, entry);
-                //       conflictMap[name] = toExpand.ref
-                //         ? `${toExpand.ref}.${name}`
-                //         : name;
-                //     }
-                //     if (entry instanceof StructSpaceField) {
-                //       spaces.push({
-                //         space: entry.fieldSpace,
-                //         ref: [
-                //           ...(parentRef ? [parentRef] : []),
-                //           ...(toExpand.ref ? [toExpand.ref] : []),
-                //           name,
-                //         ].join('.'),
-                //       });
-                //     }
-                //   }
-                // }
-            }
-            else {
+        const joinPath = [];
+        if (wild.joinPath) {
+            // walk path to determine namespace for *
+            for (const pathPart of wild.joinPath.list) {
+                const part = pathPart.refString;
+                joinPath.push(part);
                 const ent = current.entry(part);
                 if (ent) {
                     if (ent instanceof static_space_1.StructSpaceField) {
                         current = ent.fieldSpace;
                     }
                     else {
-                        wild.log(`Field '${part}'${parentRef ? ` in ${parentRef}` : ''} is not a struct`);
-                        success = false;
+                        pathPart.log(`Field '${part}' does not contain rows and cannot be expanded with '*'`);
+                        return;
                     }
                 }
                 else {
-                    wild.log(`No such field '${part}'${parentRef ? ` in ${parentRef}` : ''}`);
-                    success = false;
+                    pathPart.log(`No such field as '${part}'`);
+                    return;
                 }
             }
         }
-        if (success) {
-            // TODO perform the entire replacement of * and ** here in the parser.
-            // Today, we add all the fields to the output space, and then still add * to
-            // the query. The compiler then does a second * expansion. Instead, we should
-            // just add all the fields to the query here and then remove the code in the compiler
-            // for expanding the *.
-            this.setEntry(wild.refString, new wild_space_field_1.WildSpaceField(wild.refString));
+        const dialect = this.dialectObj();
+        for (const [name, entry] of current.entries()) {
+            if (this.entry(name)) {
+                const conflict = (_a = this.expandedWild[name]) === null || _a === void 0 ? void 0 : _a.join('.');
+                wild.log(`Cannot expand '${name}' in '${wild.refString}' because a field with that name already exists${conflict ? ` (conflicts with ${conflict})` : ''}`);
+            }
+            else {
+                const eType = entry.typeDesc();
+                if (model.isAtomicFieldType(eType.dataType) &&
+                    model.expressionIsScalar(eType.expressionType) &&
+                    (dialect === undefined || !dialect.ignoreInProject(name))) {
+                    this.setEntry(name, entry);
+                    this.expandedWild[name] = joinPath.concat(name);
+                }
+            }
         }
     }
     /**
@@ -232,8 +189,13 @@ class QuerySpace extends refined_space_1.RefinedSpace {
     }
     queryFieldDefs() {
         const fields = [];
-        for (const [, field] of this.entries()) {
+        for (const [name, field] of this.entries()) {
             if (field instanceof space_field_1.SpaceField) {
+                const wildPath = this.expandedWild[name];
+                if (wildPath) {
+                    fields.push(wildPath.join('.'));
+                    continue;
+                }
                 const fieldQueryDef = field.getQueryFieldDef(this.exprSpace);
                 if (fieldQueryDef) {
                     if (field instanceof wild_space_field_1.WildSpaceField) {

package/dist/lang/ast/query-items/field-references.d.ts

@@ -62,12 +62,11 @@ export declare class DimensionFieldReference extends FieldReference {
 }
 export declare class WildcardFieldReference extends MalloyElement implements Noteable {
     readonly joinPath: FieldReference | undefined;
-    readonly star: '*' | '**';
     elementType: string;
     note?: Annotation;
     readonly isNoteableObj = true;
     extendNote: typeof extendNoteMethod;
-    constructor(joinPath: FieldReference | undefined, star: '*' | '**');
+    constructor(joinPath: FieldReference | undefined);
     getFieldDef(): FieldDef;
     get refString(): string;
 }

package/dist/lang/ast/query-items/field-references.js

@@ -177,10 +177,9 @@ class DimensionFieldReference extends FieldReference {
 }
 exports.DimensionFieldReference = DimensionFieldReference;
 class WildcardFieldReference extends malloy_element_1.MalloyElement {
-    constructor(joinPath, star) {
+    constructor(joinPath) {
         super();
         this.joinPath = joinPath;
-        this.star = star;
         this.elementType = 'wildcardFieldReference';
         this.isNoteableObj = true;
         this.extendNote = noteable_1.extendNoteMethod;
@@ -190,9 +189,7 @@ class WildcardFieldReference extends malloy_element_1.MalloyElement {
         throw this.internalError('fielddef request from wildcard reference');
     }
     get refString() {
-        return this.joinPath
-            ? `${this.joinPath.refString}.${this.star}`
-            : this.star;
+        return this.joinPath ? `${this.joinPath.refString}.*` : '*';
     }
 }
 exports.WildcardFieldReference = WildcardFieldReference;

package/dist/lang/lib/Malloy/MalloyParser.d.ts

@@ -1595,7 +1595,6 @@ export declare class IndexElementContext extends ParserRuleContext {
     fieldPath(): FieldPathContext | undefined;
     DOT(): TerminalNode | undefined;
     STAR(): TerminalNode | undefined;
-    STARSTAR(): TerminalNode | undefined;
     constructor(parent: ParserRuleContext | undefined, invokingState: number);
     get ruleIndex(): number;
     enterRule(listener: MalloyParserListener): void;
@@ -2232,8 +2231,7 @@ export declare class FieldCollectionContext extends ParserRuleContext {
     accept<Result>(visitor: MalloyParserVisitor<Result>): Result;
 }
 export declare class CollectionWildCardContext extends ParserRuleContext {
-    STAR(): TerminalNode | undefined;
-    STARSTAR(): TerminalNode | undefined;
+    STAR(): TerminalNode;
     fieldPath(): FieldPathContext | undefined;
     DOT(): TerminalNode | undefined;
     constructor(parent: ParserRuleContext | undefined, invokingState: number);