@malloydata/malloy 0.0.393 → 0.0.395

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

@@ -55,9 +55,12 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ExprLegacyIn = exports.ExprEquality = exports.ExprCompare = void 0;
+exports.ExprInGiven = exports.ExprLegacyIn = exports.ExprEquality = exports.ExprCompare = void 0;
+const malloy_types_1 = require("../../../model/malloy_types");
+const utils_1 = require("../../../model/utils");
 const TDU = __importStar(require("../typedesc-utils"));
 const expr_value_1 = require("../types/expr-value");
+const expr_value_2 = require("../types/expr-value");
 const expression_def_1 = require("../types/expression-def");
 const binary_boolean_1 = require("./binary-boolean");
 const compareTypes = {
@@ -112,7 +115,7 @@ class ExprLegacyIn extends expression_def_1.ExpressionDef {
     getExpression(fs) {
         const lookFor = this.expr.getExpression(fs);
         const oneOf = this.choices.map(e => e.getExpression(fs));
-        return (0, expr_value_1.computedExprValue)({
+        return (0, expr_value_2.computedExprValue)({
             dataType: { type: 'boolean' },
             value: {
                 node: 'in',
@@ -124,4 +127,81 @@ class ExprLegacyIn extends expression_def_1.ExpressionDef {
     }
 }
 exports.ExprLegacyIn = ExprLegacyIn;
+/**
+ * `expr in $ARRAY_GIVEN` — runtime test of a basic-typed expression
+ * against the elements of a runtime-bound array given. The translator
+ * verifies the given is `T[]` and the LHS is the same basic `T`; SQL
+ * emission expands the bound array's elements at compile time.
+ */
+class ExprInGiven extends expression_def_1.ExpressionDef {
+    constructor(expr, notIn, givenRef) {
+        super();
+        this.expr = expr;
+        this.notIn = notIn;
+        this.givenRef = givenRef;
+        this.elementType = 'inGiven';
+        this.has({ expr, givenRef });
+    }
+    getExpression(fs) {
+        const lookFor = this.expr.getExpression(fs);
+        const givenVal = this.givenRef.getExpression(fs);
+        // `in` is logically a boolean — every error path returns a
+        // boolean-typed error so a `where:` clause around us doesn't pile a
+        // "filter must be boolean" complaint on top of our own diagnostic.
+        const boolError = () => (0, expr_value_1.computedErrorExprValue)({
+            dataType: { type: 'boolean' },
+            error: 'in-given type error',
+            from: [lookFor, givenVal],
+        });
+        if (lookFor.type === 'error' || givenVal.type === 'error') {
+            return boolError();
+        }
+        // GivenReference only ever returns a `given` ExprValue on the
+        // success path; the error branch is filtered above. No other case
+        // is reachable here.
+        const givenNode = givenVal.value;
+        if (givenNode.node !== 'given') {
+            throw this.internalError(`expected GivenReference to produce a 'given' node, got '${givenNode.node}'`);
+        }
+        if (!malloy_types_1.TD.isAtomic(givenVal) || givenVal.type !== 'array') {
+            this.logError('in-given-rhs-not-array', {
+                givenName: this.givenRef.name,
+                actualType: malloy_types_1.TD.isAtomic(givenVal)
+                    ? (0, utils_1.typeDefToString)(givenVal)
+                    : givenVal.type,
+            });
+            return boolError();
+        }
+        if ((0, malloy_types_1.isRepeatedRecord)(givenVal)) {
+            this.logError('in-given-rhs-not-basic-array', {
+                givenName: this.givenRef.name,
+                elementType: (0, utils_1.typeDefToString)(givenVal),
+            });
+            return boolError();
+        }
+        // givenVal is BasicArrayTypeDef-shaped — the union for array
+        // AtomicTypeDefs is BasicArray | RepeatedRecord, and the
+        // RepeatedRecord branch returned above.
+        const elemType = givenVal.elementTypeDef;
+        if (!malloy_types_1.TD.isBasicAtomic(lookFor) || lookFor.type !== elemType.type) {
+            this.logError('in-given-type-mismatch', {
+                lhsType: malloy_types_1.TD.isAtomic(lookFor) ? (0, utils_1.typeDefToString)(lookFor) : lookFor.type,
+                elementType: (0, utils_1.typeDefToString)(elemType),
+            });
+            return boolError();
+        }
+        const inGivenNode = {
+            node: 'inGiven',
+            not: this.notIn,
+            givenRef: givenNode,
+            e: lookFor.value,
+        };
+        return (0, expr_value_2.computedExprValue)({
+            dataType: { type: 'boolean' },
+            value: inGivenNode,
+            from: [lookFor, givenVal],
+        });
+    }
+}
+exports.ExprInGiven = ExprInGiven;
 //# sourceMappingURL=expr-compare.js.map

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

@@ -3,7 +3,7 @@ import { Source } from './source';
 import type { ModelEntryReference } from '../types/malloy-element';
 type TableInfo = {
     tablePath: string;
-    connectionName?: string | undefined;
+    connectionName: string;
 };
 export declare abstract class TableSource extends Source {
     abstract getTableInfo(): TableInfo | undefined;
@@ -16,10 +16,4 @@ export declare class TableMethodSource extends TableSource {
     constructor(connectionName: ModelEntryReference, tablePath: string);
     getTableInfo(): TableInfo | undefined;
 }
-export declare class TableFunctionSource extends TableSource {
-    readonly tableURI: string;
-    elementType: string;
-    constructor(tableURI: string);
-    getTableInfo(): TableInfo | undefined;
-}
 export {};

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

@@ -22,24 +22,38 @@
  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TableFunctionSource = exports.TableMethodSource = exports.TableSource = void 0;
+exports.TableMethodSource = exports.TableSource = void 0;
 const find_external_references_1 = require("../../parse-tree-walkers/find-external-references");
 const source_1 = require("./source");
 const error_factory_1 = require("../error-factory");
+const dialect_1 = require("../../../dialect");
 class TableSource extends source_1.Source {
     getSourceDef() {
-        var _a, _b, _c;
+        var _a, _b, _c, _d;
         const info = this.getTableInfo();
         if (info === undefined) {
             return error_factory_1.ErrorFactory.structDef;
         }
-        const { tablePath, connectionName } = info;
+        const { tablePath: rawTablePath, connectionName } = info;
+        // Re-validate the table path. ImportsAndTablesStep validated and
+        // silently skipped invalid entries; we re-validate here so we can
+        // log a precise translator error at the AST element's location.
+        let tablePath = rawTablePath;
+        const dialectName = (_a = this.translator()) === null || _a === void 0 ? void 0 : _a.root.connectionDialectZone.get(connectionName);
+        if (dialectName !== undefined) {
+            const validation = (0, dialect_1.getDialect)(dialectName).sqlValidateTableName(rawTablePath);
+            if (!validation.ok) {
+                this.logError('invalid-table-path', validation.error);
+                return error_factory_1.ErrorFactory.structDef;
+            }
+            tablePath = validation.canonical;
+        }
         const key = (0, find_external_references_1.constructTableKey)(connectionName, tablePath);
-        const tableDefEntry = (_a = this.translator()) === null || _a === void 0 ? void 0 : _a.root.schemaZone.getEntry(key);
+        const tableDefEntry = (_b = this.translator()) === null || _b === void 0 ? void 0 : _b.root.schemaZone.getEntry(key);
         let msg = `Schema read failure for table '${tablePath}' for connection '${connectionName}'`;
         if (tableDefEntry) {
             if (tableDefEntry.status === 'present') {
-                (_b = this.document()) === null || _b === void 0 ? void 0 : _b.checkExperimentalDialect(this, tableDefEntry.value.dialect);
+                (_c = this.document()) === null || _c === void 0 ? void 0 : _c.checkExperimentalDialect(this, tableDefEntry.value.dialect);
                 tableDefEntry.value.location = this.location;
                 tableDefEntry.value.fields.forEach(field => {
                     field.location = this.location;
@@ -58,7 +72,7 @@ class TableSource extends source_1.Source {
                     }),
                     location: this.location,
                 };
-                (_c = this.document()) === null || _c === void 0 ? void 0 : _c.rememberToAddModelAnnotations(ret);
+                (_d = this.document()) === null || _d === void 0 ? void 0 : _d.rememberToAddModelAnnotations(ret);
                 return ret;
             }
             if (tableDefEntry.status === 'error') {
@@ -96,17 +110,4 @@ class TableMethodSource extends TableSource {
     }
 }
 exports.TableMethodSource = TableMethodSource;
-class TableFunctionSource extends TableSource {
-    constructor(tableURI) {
-        super();
-        this.tableURI = tableURI;
-        this.elementType = 'tableFunctionSource';
-    }
-    getTableInfo() {
-        // This use of `deprecatedParseTableURI` is ok because it is for handling the
-        // old, soon-to-be-deprecated table syntax.
-        return (0, find_external_references_1.deprecatedParseTableURI)(this.tableURI);
-    }
-}
-exports.TableFunctionSource = TableFunctionSource;
 //# sourceMappingURL=table-source.js.map

package/dist/lang/ast/statements/define-given.d.ts

@@ -7,12 +7,13 @@ import { extendNoteMethod } from '../types/noteable';
 export declare class GivenDeclaration extends MalloyElement implements DocStatement, Noteable {
     readonly name: string;
     readonly typeDef: GivenTypeDef;
+    readonly inline: boolean;
     elementType: string;
     readonly isNoteableObj = true;
     extendNote: typeof extendNoteMethod;
     note?: Annotation;
     readonly default?: ConstantExpression;
-    constructor(name: string, typeDef: GivenTypeDef, defaultExpr?: ConstantExpression);
+    constructor(name: string, typeDef: GivenTypeDef, defaultExpr?: ConstantExpression, inline?: boolean);
     protected varInfo(): string;
     execute(doc: Document): void;
 }

package/dist/lang/ast/statements/define-given.js

@@ -6,6 +6,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DefineGivens = exports.GivenDeclaration = void 0;
 const malloy_types_1 = require("../../../model/malloy_types");
+const inline_expr_1 = require("../../../model/inline_expr");
 const source_def_utils_1 = require("../../../model/source_def_utils");
 const utils_1 = require("../../../model/utils");
 const expression_def_1 = require("../types/expression-def");
@@ -20,11 +21,43 @@ function filterTypeMismatch(declared, constVal) {
     return ((declared.type === 'filter expression') !==
         (constVal.type === 'filter expression'));
 }
+/**
+ * Walk an Expr tree and collect every node string that isn't in the
+ * allowed inline operator/leaf sets.
+ *
+ * The translator caller is gated on a clean translation of the default
+ * (`constVal.type !== 'error'`): we don't pile bad-operator errors on
+ * top of a default that didn't translate cleanly for more fundamental
+ * reasons (an unknown `$REF`, a type mismatch, etc.). Every bad node
+ * is collected so the author sees the full list in one diagnostic.
+ */
+function collectInlineBadOps(e, bad) {
+    if (!inline_expr_1.INLINE_OPS.has(e.node) && !inline_expr_1.INLINE_LEAVES.has(e.node)) {
+        bad.add(e.node);
+    }
+    if ((0, malloy_types_1.exprHasE)(e)) {
+        collectInlineBadOps(e.e, bad);
+    }
+    else if ((0, malloy_types_1.exprHasKids)(e)) {
+        for (const kid of Object.values(e.kids)) {
+            if (kid === null)
+                continue;
+            if (Array.isArray(kid)) {
+                for (const k of kid)
+                    collectInlineBadOps(k, bad);
+            }
+            else {
+                collectInlineBadOps(kid, bad);
+            }
+        }
+    }
+}
 class GivenDeclaration extends malloy_element_1.MalloyElement {
-    constructor(name, typeDef, defaultExpr) {
+    constructor(name, typeDef, defaultExpr, inline = false) {
         super();
         this.name = name;
         this.typeDef = typeDef;
+        this.inline = inline;
         this.elementType = 'given';
         this.isNoteableObj = true;
         this.extendNote = noteable_1.extendNoteMethod;
@@ -44,6 +77,12 @@ class GivenDeclaration extends malloy_element_1.MalloyElement {
             this.logError('given-definition-name-conflict', `Cannot redefine '${this.name}'`);
             return;
         }
+        // An inline given with no default has nothing to evaluate at bind
+        // time. Log and keep going — the given still registers in the
+        // namespace so downstream errors don't cascade pointlessly.
+        if (this.inline && !this.default) {
+            this.logError('inline-no-default', { name: this.name });
+        }
         // Default expression. ConstantExpression evaluates through a
         // ConstantFieldSpace that errors on every name lookup, so any
         // non-constant subexpression (field refs, aggregates, etc.) gets
@@ -112,6 +151,17 @@ class GivenDeclaration extends malloy_element_1.MalloyElement {
                     }
                     givenUsage = closure;
                 }
+                // Ensure inline expression is resolveable at compile time.
+                if (this.inline) {
+                    const bad = new Set();
+                    collectInlineBadOps(defaultExpr, bad);
+                    if (bad.size > 0) {
+                        this.default.logError('inline-bad-operator', {
+                            name: this.name,
+                            operators: [...bad].sort().join(', '),
+                        });
+                    }
+                }
             }
         }
         const id = (0, source_def_utils_1.mkGivenID)(this.name, (_c = this.location) === null || _c === void 0 ? void 0 : _c.url);
@@ -124,6 +174,7 @@ class GivenDeclaration extends malloy_element_1.MalloyElement {
             givenUsage,
             location: this.location,
             annotation: this.note,
+            ...(this.inline ? { inline: true } : {}),
         };
         doc.documentGivens.set(id, givenIR);
         const entry = { type: 'given', name: this.name, id };

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

@@ -239,10 +239,12 @@ class MalloyElement {
             const kiddle = this.children[kidLabel];
             if (kiddle instanceof MalloyElement) {
                 yield kiddle;
+                yield* kiddle.walk();
             }
             else {
                 for (const k of kiddle) {
                     yield k;
+                    yield* k.walk();
                 }
             }
         }