@malloydata/malloy 0.0.435 → 0.0.436

package/dist/lang/ast/expressions/expr-minus.js

@@ -38,7 +38,6 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ExprMinus = void 0;
-const ast_utils_1 = require("../ast-utils");
 const TDU = __importStar(require("../typedesc-utils"));
 const expression_def_1 = require("../types/expression-def");
 class ExprMinus extends expression_def_1.ExpressionDef {
@@ -50,6 +49,10 @@ class ExprMinus extends expression_def_1.ExpressionDef {
     }
     computeExpression(fs) {
         const expr = this.expr.getExpression(fs);
+        // An error is already logged; it stays an error so nothing else logs it
+        if (expr.type === 'error') {
+            return expr;
+        }
         if (TDU.typeIn(expr, this.legalChildTypes)) {
             return {
                 ...expr,
@@ -57,7 +60,7 @@ class ExprMinus extends expression_def_1.ExpressionDef {
                 value: { node: 'unary-', e: expr.value },
             };
         }
-        return (0, ast_utils_1.errorFor)('negate requires number');
+        return this.expr.loggedErrorExpr('expression-type-error', `'${this.elementType}' Can't use type ${TDU.inspect(expr)}`);
     }
 }
 exports.ExprMinus = ExprMinus;

package/dist/lang/ast/expressions/expr-null.js

@@ -7,11 +7,15 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ExprIsNull = exports.PartialIsNull = exports.ExprNULL = void 0;
 const expr_value_1 = require("../types/expr-value");
 const expression_def_1 = require("../types/expression-def");
+const boolean_value_1 = require("./boolean-value");
 function doIsNull(fs, op, expr) {
     // Build a new value rather than retyping the operand's in place: what
     // getExpression hands back is shared, and the operand is usually asked for
     // its value again after this.
     const nullCmp = expr.getExpression(fs);
+    const noTest = (0, boolean_value_1.booleanValueError)(fs, nullCmp, 'in a null test', expr, boolean_value_1.CONDITION_HINT);
+    if (noTest)
+        return noTest;
     return (0, expr_value_1.computedExprValue)({
         dataType: { type: 'boolean' },
         value: {

package/dist/lang/ast/expressions/pick-when.js

@@ -42,6 +42,7 @@ const TDU = __importStar(require("../typedesc-utils"));
 const expr_value_1 = require("../types/expr-value");
 const expression_def_1 = require("../types/expression-def");
 const malloy_element_1 = require("../types/malloy-element");
+const boolean_value_1 = require("./boolean-value");
 function typeCoalesce(ev1, ev2) {
     if (ev1 === undefined || ev1.type === 'null' || ev1.type === 'error') {
         return ev2;
@@ -131,6 +132,9 @@ class Pick extends expression_def_1.ExpressionDef {
         if (definedReturnType.type === 'filter expression') {
             return this.loggedErrorExpr('filter-expression-error', 'Pick statments cannot have filter expression values');
         }
+        const noPick = (0, boolean_value_1.booleanValueError)(fs, definedReturnType, 'as the result of a pick', this, boolean_value_1.CHOICE_HINT);
+        if (noPick)
+            return noPick;
         caseValue.kids.caseElse = defaultVal.value;
         return (0, expr_value_1.computedExprValue)({
             dataType: definedReturnType,
@@ -193,6 +197,9 @@ class Pick extends expression_def_1.ExpressionDef {
         if (definedReturnType.type === 'filter expression') {
             return this.loggedErrorExpr('filter-expression-error', 'Pick statments cannot have filter expression values');
         }
+        const noPick = (0, boolean_value_1.booleanValueError)(fs, definedReturnType, 'as the result of a pick', this, boolean_value_1.CHOICE_HINT);
+        if (noPick)
+            return noPick;
         pick.kids.caseElse = defVal.value;
         return (0, expr_value_1.computedExprValue)({
             dataType: definedReturnType,

package/dist/lang/ast/field-space/index-field-space.js

@@ -8,6 +8,7 @@ exports.IndexFieldSpace = 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 field_references_1 = require("../query-items/field-references");
 const space_field_1 = require("../types/space-field");
 const query_spaces_1 = require("./query-spaces");
@@ -98,10 +99,21 @@ class IndexFieldSpace extends query_spaces_1.QueryOperationSpace {
             }
             else {
                 const eTypeDesc = entry.typeDesc();
+                if (
                 // Don't index arrays and records
-                if (malloy_types_1.TD.isBasicAtomic(eTypeDesc) &&
+                malloy_types_1.TD.isBasicAtomic(eTypeDesc) &&
                     (0, malloy_types_1.expressionIsScalar)(eTypeDesc.expressionType) &&
                     (dialect === undefined || !dialect.ignoreInProject(name))) {
+                    if (eTypeDesc.type === 'boolean' && (dialect === null || dialect === void 0 ? void 0 : dialect.booleanType) === 'none') {
+                        const path = [...joinPath, name].join('.');
+                        wild.logWarning('wildcard-omits-boolean', {
+                            dialect: dialect.name,
+                            wildcard: wild.refString,
+                            name: path,
+                            hint: (0, boolean_value_1.resultColumnHint)(path),
+                        });
+                        continue;
+                    }
                     expandEntries.push({ name: indexName, entry });
                     this.expandedWild.set(indexName, {
                         path: joinPath.concat(name),

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

@@ -48,6 +48,7 @@ const static_space_1 = require("./static-space");
 const query_input_space_1 = require("./query-input-space");
 const composite_source_utils_1 = require("../../composite-source-utils");
 const error_factory_1 = require("../error-factory");
+const boolean_value_1 = require("../expressions/boolean-value");
 const reference_field_1 = require("./reference-field");
 const refine_from_space_field_1 = require("./refine-from-space-field");
 /**
@@ -158,6 +159,16 @@ class QueryOperationSpace extends refined_space_1.RefinedSpace {
                 if (model.TD.isAtomic(eType) &&
                     model.expressionIsScalar(eType.expressionType) &&
                     (dialect === undefined || !dialect.ignoreInProject(name))) {
+                    if (eType.type === 'boolean' && (dialect === null || dialect === void 0 ? void 0 : dialect.booleanType) === 'none') {
+                        const path = joinPath.concat(name).join('.');
+                        wild.logWarning('wildcard-omits-boolean', {
+                            dialect: dialect.name,
+                            wildcard: wild.refString,
+                            name: path,
+                            hint: (0, boolean_value_1.resultColumnHint)(path),
+                        });
+                        continue;
+                    }
                     expandEntries.push({ name, entry });
                     this.expandedWild.set(name, {
                         path: joinPath.concat(name),

package/dist/lang/ast/query-builders/reduce-builder.js

@@ -55,7 +55,7 @@ class QuerySegmentBuilder {
     }
     refineFrom(from, to) {
         if (from && from.type !== 'index' && from.type !== 'raw') {
-            if (!this.limit && from.orderBy && !from.defaultOrderBy) {
+            if (!this.order && from.orderBy && !from.defaultOrderBy) {
                 to.orderBy = from.orderBy;
             }
             if (!this.limit && from.limit) {

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

@@ -19,24 +19,29 @@ export declare abstract class AtomicFieldDeclaration extends MalloyElement imple
     fieldDef(fs: FieldSpace, exprName: string): FieldDef;
     abstract typecheckExprValue(expr: ExprValue): void;
     executesInOutputSpace(): boolean;
+    outputsValue(): boolean;
     queryFieldDef(exprFS: FieldSpace, exprName: string): AtomicFieldDef;
     makeEntry(fs: DynamicSpace): void;
 }
 export declare class CalculateFieldDeclaration extends AtomicFieldDeclaration {
     elementType: string;
+    outputsValue(): boolean;
     typecheckExprValue(expr: ExprValue): void;
     executesInOutputSpace(): boolean;
 }
 export declare class AggregateFieldDeclaration extends AtomicFieldDeclaration {
     elementType: string;
+    outputsValue(): boolean;
     typecheckExprValue(expr: ExprValue): void;
 }
 export declare class GroupByFieldDeclaration extends AtomicFieldDeclaration {
     elementType: string;
+    outputsValue(): boolean;
     typecheckExprValue(expr: ExprValue): void;
 }
 export declare class ProjectFieldDeclaration extends AtomicFieldDeclaration {
     elementType: string;
+    outputsValue(): boolean;
     typecheckExprValue(expr: ExprValue): void;
 }
 export declare class DeclareFieldDeclaration extends AtomicFieldDeclaration {

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

@@ -45,6 +45,7 @@ const malloy_element_1 = require("../types/malloy-element");
 const typecheck_utils_1 = require("./typecheck_utils");
 const space_field_1 = require("../types/space-field");
 const def_space_1 = require("../field-space/def-space");
+const boolean_value_1 = require("../expressions/boolean-value");
 class AtomicFieldDeclaration extends malloy_element_1.MalloyElement {
     constructor(expr, defineName, exprSrc) {
         super({ expr: expr });
@@ -71,6 +72,10 @@ class AtomicFieldDeclaration extends malloy_element_1.MalloyElement {
     executesInOutputSpace() {
         return false;
     }
+    // The declaration is a result column of a query
+    outputsValue() {
+        return false;
+    }
     queryFieldDef(exprFS, exprName) {
         var _a;
         let exprValue;
@@ -105,27 +110,16 @@ class AtomicFieldDeclaration extends malloy_element_1.MalloyElement {
         }
         if ((0, malloy_types_1.isAtomicFieldType)(exprValue.type) && exprValue.type !== 'error') {
             this.typecheckExprValue(exprValue);
+            if (this.outputsValue() &&
+                (0, boolean_value_1.booleanValueError)(exprFS, exprValue, 'as a result column', this.expr, (0, boolean_value_1.resultColumnHint)((_a = this.exprSrc) !== null && _a !== void 0 ? _a : '…'))) {
+                return { name: exprName, type: 'error' };
+            }
             const ret = (0, malloy_types_1.mkFieldDef)(TDU.atomicDef(exprValue), exprName);
             if (malloy_types_1.TD.isTemporal(ret) && (0, granular_result_1.isGranularResult)(exprValue)) {
                 ret.timeframe = exprValue.timeframe;
             }
             ret.location = this.location;
-            if (exprValue.type === 'boolean' &&
-                ((_a = exprFS.dialectObj()) === null || _a === void 0 ? void 0 : _a.booleanType) === 'none') {
-                // when generating a boolean field on a database without boolean support
-                // map it to integers
-                ret.e = {
-                    node: 'case',
-                    kids: {
-                        caseWhen: [exprValue.value],
-                        caseThen: [{ node: 'numberLiteral', literal: '1' }],
-                        caseElse: { node: 'numberLiteral', literal: '0' },
-                    },
-                };
-            }
-            else {
-                ret.e = exprValue.value;
-            }
+            ret.e = exprValue.value;
             ret.drillExpression = this.expr.drillExpression();
             ret.refSummary = exprValue.refSummary;
             ret.ungroupings = exprValue.ungroupings;
@@ -163,6 +157,9 @@ class CalculateFieldDeclaration extends AtomicFieldDeclaration {
         super(...arguments);
         this.elementType = 'calculateFieldDeclaration';
     }
+    outputsValue() {
+        return true;
+    }
     typecheckExprValue(expr) {
         (0, typecheck_utils_1.typecheckCalculate)(expr, this);
     }
@@ -176,6 +173,9 @@ class AggregateFieldDeclaration extends AtomicFieldDeclaration {
         super(...arguments);
         this.elementType = 'aggregateFieldDeclaration';
     }
+    outputsValue() {
+        return true;
+    }
     typecheckExprValue(expr) {
         (0, typecheck_utils_1.typecheckAggregate)(expr, this);
     }
@@ -186,6 +186,9 @@ class GroupByFieldDeclaration extends AtomicFieldDeclaration {
         super(...arguments);
         this.elementType = 'groupByFieldDeclaration';
     }
+    outputsValue() {
+        return true;
+    }
     typecheckExprValue(expr) {
         (0, typecheck_utils_1.typecheckGroupBy)(expr, this);
     }
@@ -196,6 +199,9 @@ class ProjectFieldDeclaration extends AtomicFieldDeclaration {
         super(...arguments);
         this.elementType = 'projectFieldDeclaration';
     }
+    outputsValue() {
+        return true;
+    }
     typecheckExprValue(expr) {
         (0, typecheck_utils_1.typecheckProject)(expr, this);
     }

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

@@ -25,6 +25,7 @@ export declare abstract class FieldReference extends ListOf<FieldName> implement
     get sourceString(): string | undefined;
     get nameString(): string;
     abstract typecheck(type: TypeDesc): void;
+    outputsValue(): boolean;
     getField(fs: FieldSpace): LookupResult;
 }
 export declare class AcceptExceptFieldReference extends FieldReference {
@@ -61,27 +62,32 @@ export declare class DrillFieldReference extends FieldReference {
 }
 export declare class CalculateFieldReference extends FieldReference {
     elementType: string;
+    outputsValue(): boolean;
     protected autoRenameDeclarationCtor(): typeof CalculateFieldDeclaration;
     typecheck(type: TypeDesc): void;
 }
 export declare class IndexFieldReference extends FieldReference {
     elementType: string;
+    outputsValue(): boolean;
     typecheck(type: TypeDesc): void;
     static indexOutputName(path: string[]): string;
     get outputName(): string;
 }
 export declare class AggregateFieldReference extends FieldReference {
     elementType: string;
+    outputsValue(): boolean;
     protected autoRenameDeclarationCtor(): typeof AggregateFieldDeclaration;
     typecheck(type: TypeDesc): void;
 }
 export declare class GroupByFieldReference extends FieldReference {
     elementType: string;
+    outputsValue(): boolean;
     protected autoRenameDeclarationCtor(): typeof GroupByFieldDeclaration;
     typecheck(type: TypeDesc): void;
 }
 export declare class ProjectFieldReference extends FieldReference {
     elementType: string;
+    outputsValue(): boolean;
     protected autoRenameDeclarationCtor(): typeof ProjectFieldDeclaration;
     typecheck(type: TypeDesc): void;
 }

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

@@ -10,6 +10,7 @@ const definition_list_1 = require("../types/definition-list");
 const field_space_1 = require("../types/field-space");
 const malloy_element_1 = require("../types/malloy-element");
 const expr_id_reference_1 = require("../expressions/expr-id-reference");
+const boolean_value_1 = require("../expressions/boolean-value");
 const field_declaration_1 = require("./field-declaration");
 const typecheck_utils_1 = require("./typecheck_utils");
 class FieldReference extends malloy_element_1.ListOf {
@@ -108,11 +109,18 @@ class FieldReference extends malloy_element_1.ListOf {
     get nameString() {
         return this.list[this.list.length - 1].refString;
     }
+    // The reference is a result column of a query
+    outputsValue() {
+        return false;
+    }
     getField(fs) {
         const result = fs.lookup(this.list);
         if (result.found) {
             const actualType = result.found.typeDesc();
             this.typecheck(actualType);
+            if (this.outputsValue()) {
+                (0, boolean_value_1.booleanValueError)(fs, actualType, 'as a result column', this, (0, boolean_value_1.resultColumnHint)(this.refString));
+            }
         }
         return result;
     }
@@ -210,6 +218,9 @@ class CalculateFieldReference extends FieldReference {
         super(...arguments);
         this.elementType = 'calculateFieldReference';
     }
+    outputsValue() {
+        return true;
+    }
     autoRenameDeclarationCtor() {
         return field_declaration_1.CalculateFieldDeclaration;
     }
@@ -223,6 +234,9 @@ class IndexFieldReference extends FieldReference {
         super(...arguments);
         this.elementType = 'indexFieldReference';
     }
+    outputsValue() {
+        return true;
+    }
     typecheck(type) {
         (0, typecheck_utils_1.typecheckIndex)(type, this);
     }
@@ -240,6 +254,9 @@ class AggregateFieldReference extends FieldReference {
         super(...arguments);
         this.elementType = 'aggregateFieldReference';
     }
+    outputsValue() {
+        return true;
+    }
     autoRenameDeclarationCtor() {
         return field_declaration_1.AggregateFieldDeclaration;
     }
@@ -253,6 +270,9 @@ class GroupByFieldReference extends FieldReference {
         super(...arguments);
         this.elementType = 'groupByFieldReference';
     }
+    outputsValue() {
+        return true;
+    }
     autoRenameDeclarationCtor() {
         return field_declaration_1.GroupByFieldDeclaration;
     }
@@ -266,6 +286,9 @@ class ProjectFieldReference extends FieldReference {
         super(...arguments);
         this.elementType = 'projectFieldReference';
     }
+    outputsValue() {
+        return true;
+    }
     autoRenameDeclarationCtor() {
         return field_declaration_1.ProjectFieldDeclaration;
     }

package/dist/lang/ast/query-properties/filters.js

@@ -50,7 +50,9 @@ class FilterElement extends malloy_element_1.MalloyElement {
     filterCondition(fs) {
         const exprVal = this.expr.getExpression(fs);
         if (exprVal.type !== 'boolean') {
-            this.expr.logError('non-boolean-filter', 'Filter expression must have boolean value');
+            if (exprVal.type !== 'error') {
+                this.expr.logError('non-boolean-filter', 'Filter expression must have boolean value');
+            }
             return {
                 node: 'filterCondition',
                 code: this.exprSrc,

package/dist/lang/ast/statements/import-statement.js

@@ -161,9 +161,22 @@ class ImportStatement extends malloy_element_1.ListOf {
                             // persistent ones. A `#@ -persist` wrapper that adds a join is
                             // not a table, but it can be the only way to reach the tables
                             // under it, and this model has to be able to take the same route.
+                            //
+                            // The persistent ones are also what a builder will build from
+                            // this model, so the document checks at the end of compile that
+                            // this model can supply every given their SQL reads.
                             if ((0, malloy_types_1.isSourceDef)(importMe) && (0, malloy_types_1.isPersistableSourceDef)(importMe)) {
                                 for (const found of (0, persist_utils_1.walkPersistentDependencies)([importMe], importedModel)) {
                                     neededSourceIDs.add(found.sourceID);
+                                    if (!found.persistent)
+                                        continue;
+                                    const def = (0, source_def_utils_1.resolveSourceID)(importedModel, found.sourceID);
+                                    if (def && !doc.importedPersistSources.has(found.sourceID)) {
+                                        doc.importedPersistSources.set(found.sourceID, {
+                                            source: def,
+                                            at: this.location,
+                                        });
+                                    }
                                 }
                             }
                         }

package/dist/lang/ast/types/expression-def.js

@@ -49,6 +49,7 @@ const granular_result_1 = require("./granular-result");
 const malloy_element_1 = require("./malloy-element");
 const binary_operators_1 = require("./binary_operators");
 const malloy_filter_1 = require("@malloydata/malloy-filter");
+const boolean_value_1 = require("../expressions/boolean-value");
 class TypeMismatch extends Error {
 }
 /**
@@ -341,11 +342,21 @@ function regexEqual(left, right) {
     }
     return undefined;
 }
+/**
+ * A boolean can only be compared, with anything, on a dialect with boolean
+ * values. Every comparison operator, applied plainly, as a partial, or
+ * through an alternation, arrives here through equality() or compare().
+ */
+function booleanCompare(fs, left, lhs, op, right, rhs) {
+    const [side, val] = lhs.type === 'boolean' ? [left, lhs] : [right, rhs];
+    return (0, boolean_value_1.booleanValueError)(fs, val, `compared with ${op}`, side, boolean_value_1.COMPARE_HINT);
+}
 function equality(fs, left, op, right) {
     const lhs = left.getExpression(fs);
     const rhs = right.getExpression(fs);
     const node = (0, binary_operators_1.getExprNode)(op);
-    const err = errorCascade('boolean', lhs, rhs);
+    const err = errorCascade('boolean', lhs, rhs) ||
+        booleanCompare(fs, left, lhs, op, right, rhs);
     if (err)
         return err;
     // Unsupported types can be compare with null
@@ -365,6 +376,9 @@ function equality(fs, left, op, right) {
         if (op !== '~' && op !== '!~') {
             return right.loggedErrorExpr('filter-expression-error', `Cannot use the '${op}' operator with a filter expression`);
         }
+        const noMatch = (0, boolean_value_1.booleanValueError)(fs, lhs, 'matched with a filter expression', left, 'test the condition itself');
+        if (noMatch)
+            return noMatch;
         if ((0, malloy_filter_1.isFilterable)(lhs.type)) {
             let actualFilter = rhs.value;
             while (actualFilter.node === '()') {
@@ -419,7 +433,8 @@ function equality(fs, left, op, right) {
 function compare(fs, left, op, right) {
     const lhs = left.getExpression(fs);
     const rhs = right.getExpression(fs);
-    const err = errorCascade('boolean', lhs, rhs);
+    const err = errorCascade('boolean', lhs, rhs) ||
+        booleanCompare(fs, left, lhs, op, right, rhs);
     if (err)
         return err;
     const noCompare = unsupportError(left, lhs, right, rhs);

package/dist/lang/ast/types/malloy-element.d.ts

@@ -1,4 +1,4 @@
-import type { AnnotationsDef, DocumentLocation, DocumentReference, Given, ModelDef, ModelAnnotationEntry, ModelID, NamedModelObject, Query, SourceID, SourceRegistryValue } from '../../../model/malloy_types';
+import type { AnnotationsDef, DocumentLocation, DocumentReference, Given, ModelDef, ModelAnnotationEntry, ModelID, NamedModelObject, PersistableSourceDef, Query, SourceID, SourceRegistryValue } from '../../../model/malloy_types';
 import { Tag } from '@malloydata/malloy-tag';
 import type { LogMessageOptions, MessageLogger, MessageParameterType, MessageCode } from '../../parse-log';
 import type { MalloyTranslation } from '../../parse-malloy';
@@ -116,6 +116,13 @@ export declare class Document extends MalloyElement implements NameSpace {
     documentModel: Map<string, ModelEntry>;
     documentSrcRegistry: Record<SourceID, SourceRegistryValue>;
     documentGivens: Map<string, Given>;
+    /** 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. */
+    importedPersistSources: Map<string, {
+        source: PersistableSourceDef;
+        at: DocumentLocation;
+    }>;
     /** {@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
@@ -146,7 +153,23 @@ export declare class Document extends MalloyElement implements NameSpace {
     initModelDef(extendingModelDef: ModelDef | undefined): void;
     compile(): DocumentCompileResult;
     private checkGivenAliasCollisions;
+    /**
+     * 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.
+     */
+    private unsatisfiedGivens;
     private checkQueryGivenSatisfiability;
+    /**
+     * 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.
+     */
+    private checkPersistSourceGivenSatisfiability;
     hasAnnotation(): boolean;
     currentModelAnnotation(): AnnotationsDef | undefined;
     modelDef(): ModelDef;

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()),