@malloydata/malloy 0.0.435 → 0.0.437

package/dist/lang/ast/types/malloy-element.js

@@ -9,6 +9,7 @@ exports.isDocStatement = isDocStatement;
 exports.isDocStatementOrDocStatementList = isDocStatementOrDocStatementList;
 const dialect_1 = require("../../../dialect");
 const malloy_types_1 = require("../../../model/malloy_types");
+const sql_compiled_1 = require("../../../model/sql_compiled");
 const utils_1 = require("../../../model/utils");
 const malloy_tag_1 = require("@malloydata/malloy-tag");
 const parse_log_1 = require("../../parse-log");
@@ -436,6 +437,10 @@ class Document extends MalloyElement {
         this.documentModel = new Map();
         this.documentSrcRegistry = {};
         this.documentGivens = new Map();
+        /** Every persistent source an `import` brought within reach of this model's
+         *  builder, with the import that did so. Checked at end of compile: the
+         *  model has to be able to supply every given their SQL reads. */
+        this.importedPersistSources = new Map();
         /** {@link ModelAnnotationEntry} of every imported/extended model in the
          *  closure, keyed by ModelID, accumulated as imports/extends are processed;
          *  copied into the result `modelAnnotations` in {@link modelDef}, which then
@@ -512,6 +517,7 @@ class Document extends MalloyElement {
         if (needs === undefined) {
             this.checkGivenAliasCollisions();
             this.checkQueryGivenSatisfiability();
+            this.checkPersistSourceGivenSatisfiability();
         }
         const ret = {
             modelDef: {
@@ -553,40 +559,46 @@ class Document extends MalloyElement {
                 `with a default-chain reference: \`given: NEW_NAME :: T is $${sourceName}\`.`);
         }
     }
+    /**
+     * The givens in `usage` this model can neither supply nor default: not
+     * surfaced in the namespace and declared without a default. The set checked
+     * is each id plus its precomputed default-chain closure (`Given.givenUsage`),
+     * which is already transitive, so there is no recursion here.
+     */
+    unsatisfiedGivens(usage) {
+        var _a, _b;
+        const namespaceGivens = new Set();
+        for (const m of this.documentModel.values()) {
+            if (m.entry.type === 'given')
+                namespaceGivens.add(m.entry.id);
+        }
+        const allIds = new Set();
+        for (const g of usage) {
+            allIds.add(g.id);
+            const decl = this.documentGivens.get(g.id);
+            for (const t of (_a = decl === null || decl === void 0 ? void 0 : decl.givenUsage) !== null && _a !== void 0 ? _a : [])
+                allIds.add(t.id);
+        }
+        const unsatisfied = [];
+        for (const id of allIds) {
+            if (namespaceGivens.has(id))
+                continue;
+            if (((_b = this.documentGivens.get(id)) === null || _b === void 0 ? void 0 : _b.default) !== undefined)
+                continue;
+            unsatisfied.push(id);
+        }
+        return unsatisfied;
+    }
     checkQueryGivenSatisfiability() {
         // Always runs at end-of-compile, not gated on imports — a notebook cell
         // that calls `extendModel` with a prior modelDef inherits that model's
         // queries and givens, and a query inherited from cell N can become
         // unsatisfiable in cell N+1 if the satisfying given is removed (or
         // never re-supplied). Cheap when there's nothing to check.
-        const namespaceGivens = new Set();
-        for (const m of this.documentModel.values()) {
-            if (m.entry.type === 'given')
-                namespaceGivens.add(m.entry.id);
-        }
         const checkOne = (q, label) => {
             var _a;
-            const usage = q.givenUsage;
-            if (!usage || usage.length === 0)
-                return;
-            // Build the full set of ids the query transitively needs: each id
-            // in Q.givenUsage, plus each id's precomputed default-chain closure
-            // (Given.givenUsage). Since the closure is already transitive, no
-            // recursion at check time.
-            const allIds = new Set();
-            for (const g of usage) {
-                allIds.add(g.id);
-                const decl = this.documentGivens.get(g.id);
-                for (const t of (_a = decl === null || decl === void 0 ? void 0 : decl.givenUsage) !== null && _a !== void 0 ? _a : [])
-                    allIds.add(t.id);
-            }
-            for (const id of allIds) {
-                if (namespaceGivens.has(id))
-                    continue;
-                const decl = this.documentGivens.get(id);
-                if ((decl === null || decl === void 0 ? void 0 : decl.default) !== undefined)
-                    continue;
-                this.logError('unsatisfied-given-in-query', unsatisfiedGivenMessage(label, decl, id), { at: q.location });
+            for (const id of this.unsatisfiedGivens((_a = q.givenUsage) !== null && _a !== void 0 ? _a : [])) {
+                this.logError('unsatisfied-given-in-query', unsatisfiedGivenMessage(label, this.documentGivens.get(id), id), { at: q.location });
             }
         };
         // Named queries in the namespace (locally defined OR imported).
@@ -599,6 +611,31 @@ class Document extends MalloyElement {
             checkOne(q, 'run: statement');
         }
     }
+    /**
+     * A persisted source is built from whatever model a builder is handed, so a
+     * model that imports one has to be able to supply every given its SQL reads;
+     * an import that cannot is a source no build or query here could ever use.
+     * Checked at end of compile rather than at the import, since the given may
+     * be imported by a later statement. A locally declared source cannot fail
+     * this: `$NAME` only resolves to a given in scope.
+     */
+    checkPersistSourceGivenSatisfiability() {
+        var _a;
+        // One import routinely reaches several sources that share a table — a
+        // persisted source and its extensions — so each given is reported once
+        // per import, against the first source that reads it.
+        const reported = new Map();
+        for (const { source, at } of this.importedPersistSources.values()) {
+            const seen = (_a = reported.get(at)) !== null && _a !== void 0 ? _a : new Set();
+            reported.set(at, seen);
+            for (const id of this.unsatisfiedGivens((0, sql_compiled_1.givenUsageOfRelation)(source))) {
+                if (seen.has(id))
+                    continue;
+                seen.add(id);
+                this.logError('unsatisfied-given-in-persist-source', unsatisfiedGivenMessage(`Imported persisted source \`${(0, malloy_types_1.activeName)(source)}\``, this.documentGivens.get(id), id), { at });
+            }
+        }
+    }
     hasAnnotation() {
         return ((this.annotations.notes && this.annotations.notes.length > 0) ||
             this.annotations.inherits !== undefined);

package/dist/lang/ast/view-elements/reference-view.js

@@ -8,6 +8,7 @@ exports.ReferenceView = void 0;
 const composite_source_utils_1 = require("../../composite-source-utils");
 const malloy_types_1 = require("../../../model/malloy_types");
 const error_factory_1 = require("../error-factory");
+const boolean_value_1 = require("../expressions/boolean-value");
 const drill_1 = require("../query-properties/drill");
 const space_field_1 = require("../types/space-field");
 const refine_utils_1 = require("./refine-utils");
@@ -55,6 +56,9 @@ class ReferenceView extends view_1.View {
             throw new Error('Expected field to have definition');
         }
         if ((0, malloy_types_1.isAtomic)(fieldDef)) {
+            if ((0, boolean_value_1.booleanValueError)(fs, fieldDef, 'as a result column', this.reference, (0, boolean_value_1.resultColumnHint)(this.reference.refString))) {
+                return oops();
+            }
             const name = this.reference.nameString;
             const outputStruct = {
                 ...(0, malloy_types_1.sourceBase)(fs.structDef()),

package/dist/lang/ast/view-elements/refine-utils.js

@@ -33,6 +33,7 @@ function refine(logTo, refineTo, refineFrom) {
             if (from.orderBy !== undefined && !from.defaultOrderBy) {
                 if (to.orderBy === undefined || to.defaultOrderBy) {
                     to.orderBy = from.orderBy;
+                    delete to.defaultOrderBy;
                 }
                 else {
                     logTo.logError('ordering-overridden-in-refinement', 'refinement cannot override existing ordering');

package/dist/lang/composite-source-utils.js

@@ -28,6 +28,7 @@ exports.pathBegins = pathBegins;
 exports.hasCompositesAnywhere = hasCompositesAnywhere;
 exports.logCompositeError = logCompositeError;
 const malloy_filter_1 = require("@malloydata/malloy-filter");
+const sql_compiled_1 = require("../model/sql_compiled");
 const malloy_types_1 = require("../model/malloy_types");
 const utils_1 = require("./utils");
 const utils_2 = require("../model/utils");
@@ -1214,9 +1215,12 @@ function computeQueryGivenUsage(pipeline) {
     return result;
 }
 // Returns every given a SourceDef references — its own filterList plus any
-// givens hiding inside an embedded Query. The single point of knowledge for
-// "where can a Query embed in a SourceDef" — when a future SourceDef variant
-// grows an embedded Query, teach this helper.
+// givens hiding inside an embedded Query. For a persistable source the
+// embedded part is `givenUsageOfRelation` (model/sql_compiled.ts), which is
+// also what persistence keys a table on; the filterList is added here because
+// a query over the source applies it, but a table built from the source does
+// not. When a future SourceDef variant grows an embedded Query, teach that
+// helper or this one.
 //
 // Composite sources: composite-source support across the codebase is
 // partial; the givens work isn't chasing it. The `composite` arm here is
@@ -1226,23 +1230,12 @@ function computeQueryGivenUsage(pipeline) {
 // reaches here (e.g. composites in join positions if/when those work),
 // the conservative union over all branches is the safe fallback.
 function givenUsageOfSource(sd) {
-    var _a, _b, _c;
+    var _a;
     const fromFilters = ((_a = sd.filterList) !== null && _a !== void 0 ? _a : []).flatMap(f => (0, malloy_types_1.givenUsageFrom)(f.refSummary));
     switch (sd.type) {
         case 'query_source':
-            return [...fromFilters, ...((_b = sd.query.givenUsage) !== null && _b !== void 0 ? _b : [])];
-        case 'sql_select': {
-            const fromSegments = ((_c = sd.selectSegments) !== null && _c !== void 0 ? _c : []).flatMap(seg => {
-                var _a;
-                if ((0, malloy_types_1.isSegmentSQL)(seg))
-                    return [];
-                if ((0, malloy_types_1.isSegmentSource)(seg))
-                    return givenUsageOfSource(seg);
-                // Remaining variant of SQLPhraseSegment is `Query`
-                return (_a = seg.givenUsage) !== null && _a !== void 0 ? _a : [];
-            });
-            return [...fromFilters, ...fromSegments];
-        }
+        case 'sql_select':
+            return [...fromFilters, ...(0, sql_compiled_1.givenUsageOfRelation)(sd)];
         case 'composite':
             return [
                 ...fromFilters,