@malloydata/malloy 0.0.88-dev231002231014 → 0.0.88-dev231002235732

package/dist/lang/ast/elements/define-query.d.ts

@@ -1,12 +1,12 @@
 import { Annotation } from '../../../model/malloy_types';
 import { DocStatement, Document, MalloyElement, DocStatementList } from '../types/malloy-element';
-import { QueryElement } from '../types/query-element';
 import { Noteable, extendNoteMethod } from '../types/noteable';
+import { SourceQueryNode } from './source-query';
 export declare class DefineQuery extends MalloyElement implements DocStatement, Noteable {
     readonly name: string;
-    readonly queryDetails: QueryElement;
+    readonly queryExpr: SourceQueryNode;
     elementType: string;
-    constructor(name: string, queryDetails: QueryElement);
+    constructor(name: string, queryExpr: SourceQueryNode);
     readonly isNoteableObj = true;
     extendNote: typeof extendNoteMethod;
     note?: Annotation;

package/dist/lang/ast/elements/define-query.js

@@ -26,10 +26,10 @@ exports.DefineQueryList = exports.DefineQuery = void 0;
 const malloy_element_1 = require("../types/malloy-element");
 const noteable_1 = require("../types/noteable");
 class DefineQuery extends malloy_element_1.MalloyElement {
-    constructor(name, queryDetails) {
-        super({ queryDetails: queryDetails });
+    constructor(name, queryExpr) {
+        super({ queryExpr });
         this.name = name;
-        this.queryDetails = queryDetails;
+        this.queryExpr = queryExpr;
         this.elementType = 'defineQuery';
         this.isNoteableObj = true;
         this.extendNote = noteable_1.extendNoteMethod;
@@ -40,8 +40,13 @@ class DefineQuery extends malloy_element_1.MalloyElement {
             this.log(`'${this.name}' is already defined, cannot redefine`);
             return;
         }
+        const queryEl = this.queryExpr.getQuery();
+        if (!queryEl) {
+            this.queryExpr.sqLog('Cannot define a query from this expression');
+            return;
+        }
         const entry = {
-            ...this.queryDetails.query(),
+            ...queryEl.query(),
             type: 'query',
             name: this.name,
             location: this.location,

package/dist/lang/ast/elements/define-source.d.ts

@@ -2,14 +2,14 @@ import { Annotation } from '../../../model/malloy_types';
 import { HasParameter } from '../parameters/has-parameter';
 import { DocStatement, Document, MalloyElement, DocStatementList } from '../types/malloy-element';
 import { Noteable, extendNoteMethod } from '../types/noteable';
-import { Source } from './source';
+import { SourceQueryNode } from './source-query';
 export declare class DefineSource extends MalloyElement implements DocStatement, Noteable {
     readonly name: string;
-    readonly theSource: Source;
+    readonly sourceExpr: SourceQueryNode | undefined;
     readonly exported: boolean;
     elementType: string;
     readonly parameters?: HasParameter[];
-    constructor(name: string, theSource: Source, exported: boolean, params?: MalloyElement[]);
+    constructor(name: string, sourceExpr: SourceQueryNode | undefined, exported: boolean, params?: MalloyElement[]);
     readonly isNoteableObj = true;
     extendNote: typeof extendNoteMethod;
     note?: Annotation;

package/dist/lang/ast/elements/define-source.js

@@ -28,14 +28,17 @@ const has_parameter_1 = require("../parameters/has-parameter");
 const malloy_element_1 = require("../types/malloy-element");
 const noteable_1 = require("../types/noteable");
 class DefineSource extends malloy_element_1.MalloyElement {
-    constructor(name, theSource, exported, params) {
-        super({ explore: theSource });
+    constructor(name, sourceExpr, exported, params) {
+        super();
         this.name = name;
-        this.theSource = theSource;
+        this.sourceExpr = sourceExpr;
         this.exported = exported;
         this.elementType = 'defineSource';
         this.isNoteableObj = true;
         this.extendNote = noteable_1.extendNoteMethod;
+        if (sourceExpr) {
+            this.has({ sourceExpr });
+        }
         if (params) {
             this.parameters = [];
             for (const el of params) {
@@ -50,11 +53,16 @@ class DefineSource extends malloy_element_1.MalloyElement {
         }
     }
     execute(doc) {
+        var _a;
         if (doc.modelEntry(this.name)) {
             this.log(`Cannot redefine '${this.name}'`);
         }
         else {
-            const structDef = this.theSource.withParameters(this.parameters);
+            const theSource = (_a = this.sourceExpr) === null || _a === void 0 ? void 0 : _a.getSource();
+            if (theSource === undefined) {
+                return;
+            }
+            const structDef = theSource.withParameters(this.parameters);
             if (error_factory_1.ErrorFactory.isErrorStructDef(structDef)) {
                 return;
             }

package/dist/lang/ast/elements/pipeline-desc.d.ts

@@ -16,6 +16,7 @@ export declare abstract class PipelineDesc extends MalloyElement {
     protected withRefinement?: QOPDesc;
     protected qops: QOPDesc[];
     nestedInQuerySpace?: QueryInputSpace;
+    alreadyRefined(): boolean;
     refineWith(refinement: QOPDesc): void;
     addSegments(...segDesc: QOPDesc[]): void;
     protected appendOps(pipelineOutput: FieldSpace, modelPipe: PipeSegment[]): AppendResult;

package/dist/lang/ast/elements/pipeline-desc.js

@@ -38,6 +38,9 @@ class PipelineDesc extends malloy_element_1.MalloyElement {
         super(...arguments);
         this.qops = [];
     }
+    alreadyRefined() {
+        return this.withRefinement !== undefined;
+    }
     refineWith(refinement) {
         this.withRefinement = refinement;
         this.has({ withRefinement: refinement });

package/dist/lang/ast/elements/source-query-nodes.d.ts

@@ -0,0 +1,72 @@
+import { RefinedSource } from './refined-source';
+import { MalloyElement, ModelEntryReference } from '../types/malloy-element';
+import { Source } from './source';
+import { SourceQueryNode } from './source-query';
+import { QueryElement } from '../types/query-element';
+import { QuerySource } from '../sources/query-source';
+import { SourceDesc } from '../types/source-desc';
+import { QOPDesc } from '../query-properties/qop-desc';
+import { FullQuery } from '../query-elements/full-query';
+import { ViewFieldReference } from '../query-items/field-references';
+export declare class SQReference extends SourceQueryNode {
+    readonly ref: ModelEntryReference;
+    elementType: string;
+    asSource?: Source;
+    constructor(ref: ModelEntryReference);
+    getQuery(): QueryElement | undefined;
+    isSource(): boolean;
+    getSource(): Source | undefined;
+}
+export declare class SQLegacyModify extends SourceQueryNode {
+    readonly sourceQuery: SourceQueryNode;
+    readonly plus: MalloyElement[];
+    readonly hasPlus: boolean;
+    readonly m4Warnings: boolean;
+    elementType: string;
+    constructor(sourceQuery: SourceQueryNode, plus: MalloyElement[], hasPlus: boolean, m4Warnings: boolean);
+    getQuery(): QueryElement | undefined;
+    getSource(): Source | undefined;
+    isSource(): boolean;
+}
+export declare class SQExtendedSource extends SourceQueryNode {
+    readonly sqSrc: SourceQueryNode;
+    readonly extend: SourceDesc;
+    elementType: string;
+    asSource?: RefinedSource;
+    constructor(sqSrc: SourceQueryNode, extend: SourceDesc);
+    getSource(): RefinedSource | undefined;
+    isSource(): boolean;
+}
+export type ArrowViewComponent = ViewFieldReference | QOPDesc;
+export declare class SQAppendView extends SourceQueryNode {
+    readonly applyTo: SourceQueryNode;
+    readonly viewList: ArrowViewComponent[];
+    elementType: string;
+    constructor(applyTo: SourceQueryNode, viewList: ArrowViewComponent[]);
+    getQuery(): QueryElement | undefined;
+    getSource(): Source | undefined;
+}
+export declare class SQRefinedQuery extends SourceQueryNode {
+    readonly toRefine: SourceQueryNode;
+    readonly refine: QOPDesc;
+    elementType: string;
+    constructor(toRefine: SourceQueryNode, refine: QOPDesc);
+    getQuery(): QueryElement | undefined;
+    getSource(): QuerySource | undefined;
+}
+export declare class SQFrom extends SourceQueryNode {
+    readonly from: SourceQueryNode;
+    elementType: string;
+    constructor(from: SourceQueryNode);
+    getSource(): Source | undefined;
+    getQuery(): QueryElement | undefined;
+    isSource(): boolean;
+}
+export declare class SQSourceWrapper extends SourceQueryNode {
+    readonly theSource: Source;
+    elementType: string;
+    constructor(theSource: Source);
+    isSource(): boolean;
+    getSource(): Source;
+    getQuery(): FullQuery | undefined;
+}

package/dist/lang/ast/elements/source-query-nodes.js

@@ -0,0 +1,368 @@
+"use strict";
+/*
+ * Copyright 2023 Google LLC
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files
+ * (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SQSourceWrapper = exports.SQFrom = exports.SQRefinedQuery = exports.SQAppendView = exports.SQExtendedSource = exports.SQLegacyModify = exports.SQReference = void 0;
+const refined_source_1 = require("./refined-source");
+const source_query_1 = require("./source-query");
+const existing_query_1 = require("../query-elements/existing-query");
+const query_source_1 = require("../sources/query-source");
+const named_source_1 = require("../sources/named-source");
+const source_desc_1 = require("../types/source-desc");
+const qop_desc_1 = require("../query-properties/qop-desc");
+const full_query_1 = require("../query-elements/full-query");
+const field_references_1 = require("../query-items/field-references");
+const query_property_1 = require("../types/query-property");
+const source_property_1 = require("../types/source-property");
+const sql_source_1 = require("../sources/sql-source");
+class SQReference extends source_query_1.SourceQueryNode {
+    constructor(ref) {
+        super({ ref });
+        this.ref = ref;
+        this.elementType = 'sqReference';
+    }
+    getQuery() {
+        const entry = this.ref.getNamed();
+        if (entry) {
+            if (entry.type === 'query') {
+                const query = new existing_query_1.ExistingQuery();
+                query.head = this.ref.name;
+                this.has({ query });
+                return query;
+            }
+            else {
+                this.sqLog(`Illegal reference to '${entry.as || entry.name}', query expected`);
+            }
+        }
+        else {
+            this.ref.log(`Reference to undefined object '${this.ref.refString}'`);
+            this.errored = true;
+        }
+        return;
+    }
+    isSource() {
+        var _a;
+        return ((_a = this.ref.getNamed()) === null || _a === void 0 ? void 0 : _a.type) === 'struct';
+    }
+    getSource() {
+        if (this.asSource) {
+            return this.asSource;
+        }
+        const entry = this.ref.getNamed();
+        if (!entry) {
+            this.ref.log(`Reference to undefined object '${this.ref.refString}'`);
+            this.errored = true;
+            return;
+        }
+        if (entry.type === 'query') {
+            const existingQuery = new existing_query_1.ExistingQuery();
+            existingQuery.head = this.ref.name;
+            this.asSource = new query_source_1.QuerySource(existingQuery);
+        }
+        else if (entry.type === 'struct') {
+            this.asSource = new named_source_1.NamedSource(this.ref);
+        }
+        else {
+            this.sqLog(`Expected '${this.ref.refString}' to be of type query or source, not '${entry.type}'`);
+            return;
+        }
+        this.has({ asSource: this.asSource });
+        return this.asSource;
+    }
+}
+exports.SQReference = SQReference;
+class SQLegacyModify extends source_query_1.SourceQueryNode {
+    constructor(sourceQuery, plus, hasPlus, m4Warnings) {
+        super({ sourceQuery, plus });
+        this.sourceQuery = sourceQuery;
+        this.plus = plus;
+        this.hasPlus = hasPlus;
+        this.m4Warnings = m4Warnings;
+        this.elementType = 'sqLogacyModify';
+    }
+    getQuery() {
+        const asQuery = this.sourceQuery.getQuery();
+        if (!asQuery) {
+            return;
+        }
+        if (!this.hasPlus && this.m4Warnings) {
+            this.log('Implicit query refinement is deprecated, use the `+` operator', 'warn');
+        }
+        const stmts = [];
+        for (const stmt of this.plus) {
+            if ((0, query_property_1.isQueryProperty)(stmt)) {
+                stmts.push(stmt);
+            }
+            else {
+                // just for typing, should never happen because this is an ambiguous modification
+                stmt.log('Unable to add this refinement to query');
+            }
+        }
+        asQuery.refineWith(new qop_desc_1.QOPDesc(stmts));
+        this.has({ asQuery });
+        return asQuery;
+    }
+    getSource() {
+        let asSource = this.sourceQuery.getSource();
+        if (!asSource) {
+            return;
+        }
+        if (this.m4Warnings) {
+            if (this.hasPlus) {
+                this.log('Source extension with "+" is deprecated, use the "extend" operator', 'warn');
+            }
+            else {
+                this.log('Implicit source extension is deprecated, use the `extend` operator.', 'warn');
+            }
+        }
+        const stmts = [];
+        for (const stmt of this.plus) {
+            if ((0, source_property_1.isSourceProperty)(stmt)) {
+                stmts.push(stmt);
+            }
+            else {
+                // just for typing, should never happen because this is an ambiguous modification
+                stmt.log('Unable to add this extension to source');
+            }
+        }
+        const extend = new source_desc_1.SourceDesc(stmts);
+        asSource = new refined_source_1.RefinedSource(asSource, extend);
+        this.has({ asSource });
+        return asSource;
+    }
+    isSource() {
+        return this.sourceQuery.isSource();
+    }
+}
+exports.SQLegacyModify = SQLegacyModify;
+class SQExtendedSource extends source_query_1.SourceQueryNode {
+    constructor(sqSrc, extend) {
+        super({ sqSrc, extend });
+        this.sqSrc = sqSrc;
+        this.extend = extend;
+        this.elementType = 'sqExtendedSource';
+    }
+    getSource() {
+        if (this.asSource) {
+            return this.asSource;
+        }
+        const src = this.sqSrc.getSource();
+        if (src) {
+            this.asSource = new refined_source_1.RefinedSource(src, this.extend);
+            this.has({ asSource: this.asSource });
+            return this.asSource;
+        }
+        this.sqLog('Could not compute source to extend');
+    }
+    isSource() {
+        return true;
+    }
+}
+exports.SQExtendedSource = SQExtendedSource;
+class SQAppendView extends source_query_1.SourceQueryNode {
+    constructor(applyTo, viewList) {
+        super({ applyTo, viewList });
+        this.applyTo = applyTo;
+        this.viewList = viewList;
+        this.elementType = 'sqAppendView';
+    }
+    /*
+  
+      if the thing we are applying a view to as a query ... just add a segment
+        if the view is a segment
+  
+      if it is a source then the first segment is allowed to be a string
+  
+      all the rest of the segments are refinements to the first segment
+  
+      which are usually illegal ... so patterns
+  
+      src -> turtle // ok
+      src -> turtle + qop // ok second thing is a refinement
+      src -> qop // ok
+      query -> qop // ok
+  
+      the grammar allows for a list of views and refinements ... these are not translated yet
+  
+  
+    */
+    getQuery() {
+        let theQuery;
+        const views = [...this.viewList];
+        if (this.applyTo.isSource()) {
+            const querySrc = this.applyTo.getSource();
+            if (!querySrc) {
+                this.sqLog('Could not get source for query');
+                return;
+            }
+            this.has({ querySrc });
+            theQuery = new full_query_1.FullQuery(querySrc);
+            this.has({ theQuery });
+            const head = views[0];
+            if (head instanceof field_references_1.ViewFieldReference) {
+                theQuery.turtleName = head.list[0];
+                if (views.length === 1) {
+                    return theQuery;
+                }
+                if (views.length === 2) {
+                    if (views[1] instanceof qop_desc_1.QOPDesc) {
+                        theQuery.refineWith(views[1]);
+                        return theQuery;
+                    }
+                    else {
+                        this.sqLog('Cannot refine with a named view');
+                        return;
+                    }
+                }
+                else {
+                    this.sqLog('Cannot have multiple refinements');
+                }
+            }
+            else if (views.length === 1) {
+                if (head instanceof qop_desc_1.QOPDesc) {
+                    theQuery.addSegments(head);
+                    return theQuery;
+                }
+            }
+            if (views.length > 0) {
+                this.sqLog('Cannot have multiple refinements');
+                return;
+            }
+            return theQuery;
+        }
+        const found = this.applyTo.getQuery();
+        if (!found) {
+            this.sqLog('Could not create query to extend');
+            return;
+        }
+        theQuery = found;
+        this.has({ theQuery });
+        const head = views[0];
+        if (views.length === 1) {
+            if (head instanceof qop_desc_1.QOPDesc) {
+                theQuery.addSegments(head);
+                views.shift();
+            }
+            else {
+                this.sqLog(`Cannot reference view '${head}' in output of query`);
+                return;
+            }
+        }
+        else {
+            this.sqLog('query definition by combining not yet supported');
+            return;
+        }
+        return theQuery;
+    }
+    getSource() {
+        const query = this.getQuery();
+        if (!query) {
+            this.sqLog("Couldn't comprehend query well enough to make a source");
+            return;
+        }
+        const asSource = new query_source_1.QuerySource(query);
+        this.has({ asSource });
+        return asSource;
+    }
+}
+exports.SQAppendView = SQAppendView;
+class SQRefinedQuery extends source_query_1.SourceQueryNode {
+    constructor(toRefine, refine) {
+        super({ toRefine, refine });
+        this.toRefine = toRefine;
+        this.refine = refine;
+        this.elementType = 'sqRefinedQuery';
+    }
+    getQuery() {
+        if (this.toRefine.isSource()) {
+            if (this.toRefine instanceof SQReference) {
+                this.sqLog(`Cannot add view refinements to '${this.toRefine.ref.refString}' because it is a source`);
+            }
+            else {
+                this.sqLog('Cannot add view refinements to a source');
+            }
+            return;
+        }
+        const refinedQuery = this.toRefine.getQuery();
+        if (refinedQuery) {
+            if (refinedQuery.alreadyRefined()) {
+                this.sqLog('Cannot refine a refined query');
+                return;
+            }
+            refinedQuery.refineWith(this.refine);
+            this.has({ query: refinedQuery });
+            return refinedQuery;
+        }
+    }
+    getSource() {
+        const query = this.getQuery();
+        if (query) {
+            const queryAsSource = new query_source_1.QuerySource(query);
+            this.has({ queryAsSource });
+            return queryAsSource;
+        }
+    }
+}
+exports.SQRefinedQuery = SQRefinedQuery;
+class SQFrom extends source_query_1.SourceQueryNode {
+    constructor(from) {
+        super({ from });
+        this.from = from;
+        this.elementType = 'sqFrom';
+    }
+    getSource() {
+        return this.from.getSource();
+    }
+    getQuery() {
+        return this.from.getQuery();
+    }
+    isSource() {
+        return true;
+    }
+}
+exports.SQFrom = SQFrom;
+class SQSourceWrapper extends source_query_1.SourceQueryNode {
+    constructor(theSource) {
+        super({ theSource });
+        this.theSource = theSource;
+        this.elementType = 'SQtable';
+    }
+    isSource() {
+        return true;
+    }
+    getSource() {
+        return this.theSource;
+    }
+    getQuery() {
+        if (this.theSource instanceof sql_source_1.SQLSource) {
+            const queryObj = new full_query_1.FullQuery(this.theSource);
+            this.has({ sqlAsQUery: queryObj });
+            return queryObj;
+        }
+        if (this.theSource instanceof named_source_1.NamedSource) {
+            this.sqLog(`Illegal reference to '${this.theSource.refName}', query expected`);
+        }
+    }
+}
+exports.SQSourceWrapper = SQSourceWrapper;
+//# sourceMappingURL=source-query-nodes.js.map

package/dist/lang/ast/elements/source-query.d.ts

@@ -0,0 +1,11 @@
+import { QueryElement } from '../types/query-element';
+import { MalloyElement } from '../types/malloy-element';
+import { Source } from './source';
+export declare abstract class SourceQueryNode extends MalloyElement {
+    errored: boolean;
+    getSource(): Source | undefined;
+    getQuery(): QueryElement | undefined;
+    isSource(): boolean;
+    sqLog(message: string): void;
+    isErrorFree(): boolean;
+}

package/dist/lang/ast/{query-elements/run-query.js → elements/source-query.js}

@@ -22,30 +22,41 @@
  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RunQuery = void 0;
+exports.SourceQueryNode = void 0;
 const malloy_element_1 = require("../types/malloy-element");
-const noteable_1 = require("../types/noteable");
-class RunQuery extends malloy_element_1.MalloyElement {
-    constructor(theQuery) {
-        super();
-        this.theQuery = theQuery;
-        this.elementType = 'runQuery';
-        this.isNoteableObj = true;
-        this.extendNote = noteable_1.extendNoteMethod;
-        this.has({ query: theQuery });
+class SourceQueryNode extends malloy_element_1.MalloyElement {
+    constructor() {
+        super(...arguments);
+        this.errored = false;
     }
-    execute(doc) {
-        let modelQuery = this.theQuery.query();
-        const annotation = this.note || {};
-        if (modelQuery.annotation) {
-            annotation.inherits = modelQuery.annotation;
+    getSource() {
+        return;
+    }
+    getQuery() {
+        return;
+    }
+    isSource() {
+        return false;
+    }
+    sqLog(message) {
+        if (this.isErrorFree()) {
+            this.log(message);
+        }
+        this.errored = true;
+    }
+    isErrorFree() {
+        if (this.errored) {
+            return false;
         }
-        if (annotation.notes || annotation.blockNotes || annotation.inherits) {
-            modelQuery = { ...modelQuery, annotation };
+        let clean = true;
+        for (const child of this.walk()) {
+            if (child instanceof SourceQueryNode && child.errored) {
+                clean = false;
+                break;
+            }
         }
-        doc.queryList.push(modelQuery);
-        return undefined;
+        return clean;
     }
 }
-exports.RunQuery = RunQuery;
-//# sourceMappingURL=run-query.js.map
+exports.SourceQueryNode = SourceQueryNode;
+//# sourceMappingURL=source-query.js.map

package/dist/lang/ast/index.d.ts

@@ -3,6 +3,8 @@ export * from './elements/define-source';
 export * from './elements/define-query';
 export * from './elements/source';
 export * from './elements/refined-source';
+export * from './elements/source-query';
+export * from './elements/source-query-nodes';
 export * from './source-properties/field-list-edit';
 export * from './source-properties/primary-key';
 export * from './source-properties/renames';
@@ -53,7 +55,6 @@ export * from './elements/import-statement';
 export * from './query-properties/extend';
 export * from './parameters/has-parameter';
 export * from './query-elements/anonymous-query';
-export * from './query-elements/run-query';
 export * from './query-elements/existing-query';
 export * from './query-elements/full-query';
 export * from './query-items/field-declaration';
@@ -77,7 +78,6 @@ export * from './query-properties/qop-desc';
 export * from './query-properties/sampling';
 export * from './query-properties/top';
 export * from './sources/named-source';
-export * from './sources/named-source-or-query';
 export * from './sources/query-source';
 export * from './sources/from-sql-source';
 export * from './sources/sql-source';