@malloydata/malloy 0.0.39-dev230613161129 → 0.0.39

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

@@ -0,0 +1,33 @@
+"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.Calculate = void 0;
+const malloy_element_1 = require("../types/malloy-element");
+class Calculate extends malloy_element_1.ListOf {
+    constructor(members) {
+        super('calculate', members);
+    }
+}
+exports.Calculate = Calculate;
+//# sourceMappingURL=calculate.js.map

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

@@ -27,9 +27,6 @@ const declare_fields_1 = require("./declare-fields");
 class Dimensions extends declare_fields_1.DeclareFields {
     constructor(dimensions) {
         super(dimensions, 'dimension');
-        for (const dim of dimensions) {
-            dim.isMeasure = false;
-        }
     }
 }
 exports.Dimensions = Dimensions;

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

@@ -68,14 +68,17 @@ class Filter extends malloy_element_1.ListOf {
             // here allows better reflection of errors back to user.
             if (this.havingClause !== undefined) {
                 if (this.havingClause) {
+                    // TODO I don't understand how this is working currently? This seems to imply
+                    // that a calculation is NOT allowed, but it is...? It appears maybe this code
+                    // just isn't being called.
                     if ((0, malloy_types_1.expressionIsCalculation)(fExpr.expressionType)) {
-                        oneElement.log('Aggregate or Analytical expression expected in HAVING filter');
+                        oneElement.log('Aggregate or analytic expression expected in HAVING filter');
                         continue;
                     }
                 }
                 else {
-                    if (fExpr.expressionType !== 'scalar') {
-                        oneElement.log('Aggregate or Analytical expressions not allowed in WHERE');
+                    if ((0, malloy_types_1.expressionIsCalculation)(fExpr.expressionType)) {
+                        oneElement.log('Aggregate or analytic expressions not allowed in WHERE');
                         continue;
                     }
                 }

package/dist/lang/ast/query-properties/group-by.js

@@ -23,16 +23,10 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GroupBy = void 0;
-const field_declaration_1 = require("../query-items/field-declaration");
 const malloy_element_1 = require("../types/malloy-element");
 class GroupBy extends malloy_element_1.ListOf {
     constructor(members) {
         super('groupBy', members);
-        for (const el of members) {
-            if (el instanceof field_declaration_1.FieldDeclaration) {
-                el.isMeasure = false;
-            }
-        }
     }
 }
 exports.GroupBy = GroupBy;

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

@@ -27,9 +27,6 @@ const declare_fields_1 = require("./declare-fields");
 class Measures extends declare_fields_1.DeclareFields {
     constructor(measures) {
         super(measures, 'measure');
-        for (const dim of measures) {
-            dim.isMeasure = true;
-        }
     }
 }
 exports.Measures = Measures;

package/dist/lang/ast/query-properties/nest-reference.d.ts

@@ -1,7 +1,9 @@
+import { TypeDesc } from '../../../model';
 import { FieldReference } from '../query-items/field-references';
 import { FieldName } from '../types/field-space';
 export declare class NestReference extends FieldReference {
     readonly name: FieldName;
     elementType: string;
     constructor(name: FieldName);
+    typecheck(type: TypeDesc): void;
 }

package/dist/lang/ast/query-properties/nest-reference.js

@@ -23,6 +23,7 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.NestReference = void 0;
+const model_1 = require("../../../model");
 const field_references_1 = require("../query-items/field-references");
 class NestReference extends field_references_1.FieldReference {
     constructor(name) {
@@ -30,6 +31,28 @@ class NestReference extends field_references_1.FieldReference {
         this.name = name;
         this.elementType = 'nestReference';
     }
+    typecheck(type) {
+        if (type.dataType !== 'turtle') {
+            let useInstead;
+            let kind;
+            if ((0, model_1.expressionIsAnalytic)(type.expressionType)) {
+                useInstead = 'a calculate';
+                kind = 'an analytic';
+            }
+            else if ((0, model_1.expressionIsScalar)(type.expressionType)) {
+                useInstead = 'a group_by or project';
+                kind = 'a scalar';
+            }
+            else if ((0, model_1.expressionIsAggregate)(type.expressionType)) {
+                useInstead = 'an aggregate';
+                kind = 'an aggregate';
+            }
+            else {
+                throw new Error(`Unexpected expression type ${type} not handled here`);
+            }
+            this.log(`Cannot use ${kind} field in a nest operation, did you mean to use ${useInstead} operation instead?`);
+        }
+    }
 }
 exports.NestReference = NestReference;
 //# sourceMappingURL=nest-reference.js.map

package/dist/lang/ast/query-properties/ordering.d.ts

@@ -7,7 +7,7 @@ export declare class OrderBy extends MalloyElement {
     elementType: string;
     constructor(field: number | FieldName, dir?: "asc" | "desc" | undefined);
     get modelField(): string | number;
-    getOrderBy(_fs: FieldSpace): ModelOrderBy;
+    getOrderBy(fs: FieldSpace): ModelOrderBy;
 }
 export declare class Ordering extends ListOf<OrderBy> {
     constructor(list: OrderBy[]);

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

@@ -23,6 +23,7 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Ordering = exports.OrderBy = void 0;
+const malloy_types_1 = require("../../../model/malloy_types");
 const field_space_1 = require("../types/field-space");
 const malloy_element_1 = require("../types/malloy-element");
 class OrderBy extends malloy_element_1.MalloyElement {
@@ -38,14 +39,23 @@ class OrderBy extends malloy_element_1.MalloyElement {
     get modelField() {
         return typeof this.field === 'number' ? this.field : this.field.refString;
     }
-    getOrderBy(_fs) {
-        // TODO jump-to-definition `fs` cannot currently `lookup` fields in the output space
-        // if (this.field instanceof FieldName) {
-        //   const entry = this.field.getField(_fs);
-        //   if (entry.error) {
-        //     this.field.log(entry.error);
-        //   }
-        // }
+    getOrderBy(fs) {
+        var _a, _b;
+        // TODO jump-to-definition now that we can lookup fields in the output space,
+        // we need to actually add the reference when we do so.
+        if (this.field instanceof field_space_1.FieldName && fs.isQueryFieldSpace()) {
+            const output = fs.outputSpace();
+            const entry = this.field.getField(output);
+            if (entry.error) {
+                this.field.log(entry.error);
+            }
+            if (((_a = entry.found) === null || _a === void 0 ? void 0 : _a.typeDesc().evalSpace) === 'input') {
+                this.log(`Unknown field ${this.field.refString} in output space`);
+            }
+            if ((0, malloy_types_1.expressionIsAnalytic)((_b = entry.found) === null || _b === void 0 ? void 0 : _b.typeDesc().expressionType)) {
+                this.log(`Illegal order by of analytic field ${this.field.refString}`);
+            }
+        }
         const orderElement = { field: this.modelField };
         if (this.dir) {
             orderElement.dir = this.dir;

package/dist/lang/ast/query-properties/qop-desc.js

@@ -97,11 +97,11 @@ class QOPDesc extends malloy_element_1.ListOf {
         switch (this.computeType()) {
             case 'aggregate':
             case 'grouping':
-                return new reduce_executor_1.ReduceExecutor(baseFS);
+                return new reduce_executor_1.ReduceExecutor(baseFS, this.refineThis);
             case 'project':
-                return new project_executor_1.ProjectExecutor(baseFS);
+                return new project_executor_1.ProjectExecutor(baseFS, this.refineThis);
             case 'index':
-                return new index_executor_1.IndexExecutor(baseFS);
+                return new index_executor_1.IndexExecutor(baseFS, this.refineThis);
         }
     }
     getOp(inputFS, forPipeline) {
@@ -116,7 +116,11 @@ class QOPDesc extends malloy_element_1.ListOf {
         const segment = qex.finalize(this.refineThis);
         return {
             segment,
-            outputSpace: () => new static_space_1.StaticSpace((0, struct_utils_1.opOutputStruct)(this, inputFS.structDef(), segment)),
+            outputSpace: () => 
+            // TODO someday we'd like to get rid of the call to opOutputStruct here.
+            // If the `qex.resultFS` is correct, then we should be able to just use that
+            // in a more direct way.
+            new static_space_1.StaticSpace((0, struct_utils_1.opOutputStruct)(this, inputFS.structDef(), segment)),
         };
     }
 }

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

@@ -36,19 +36,33 @@ class Top extends malloy_element_1.MalloyElement {
         this.has({ by: by });
     }
     getBy(fs) {
+        var _a, _b;
         if (this.by) {
             if (this.by instanceof field_space_1.FieldName) {
-                // TODO jump-to-definition `fs` cannot currently `lookup` fields in the output space
-                // const entry = this.by.getField(fs);
-                // if (entry.error) {
-                //   this.by.log(entry.error);
-                // }
+                if (fs.isQueryFieldSpace()) {
+                    // TODO jump-to-definition now that we can lookup fields in the output space,
+                    // we need to actually add the reference when we do so.
+                    const output = fs.outputSpace();
+                    const entry = this.by.getField(output);
+                    if (entry.error) {
+                        this.by.log(entry.error);
+                    }
+                    if (((_a = entry.found) === null || _a === void 0 ? void 0 : _a.typeDesc().evalSpace) === 'input') {
+                        this.by.log(`Unknown field ${this.by.refString} in output space`);
+                    }
+                    if ((0, malloy_types_1.expressionIsAnalytic)((_b = entry.found) === null || _b === void 0 ? void 0 : _b.typeDesc().expressionType)) {
+                        this.by.log(`Illegal order by of analytic field ${this.by.refString}`);
+                    }
+                }
                 return { by: 'name', name: this.by.refString };
             }
             else {
                 const byExpr = this.by.getExpression(fs);
                 if ((0, malloy_types_1.expressionIsAggregate)(byExpr.expressionType)) {
-                    this.log('top by expression must be an aggregate');
+                    this.by.log('top by expression must be an aggregate');
+                }
+                if (byExpr.evalSpace === 'output') {
+                    this.by.log('top by expression must be an output expression');
                 }
                 return { by: 'expression', e: (0, utils_1.compressExpr)(byExpr.value) };
             }

package/dist/lang/ast/sources/named-source.js

@@ -77,6 +77,10 @@ class NamedSource extends source_1.Source {
             this.log(`Must use 'from()' for query source '${this.refName}`);
             return;
         }
+        else if (entry.type === 'function') {
+            this.log(`Cannot construct a source from a function '${this.refName}`);
+            return;
+        }
         else if ((0, malloy_types_1.isSQLBlockStruct)(entry) && entry.declaredSQLBlock) {
             this.log(`Must use 'from_sql()' for sql source '${this.refName}`);
             return;

package/dist/lang/ast/sources/sql-source.js

@@ -40,7 +40,11 @@ class SQLSource extends named_source_1.NamedSource {
             this.log(`Undefined from_sql source '${this.refName}'`);
             return;
         }
-        if (entry.type === 'query') {
+        if (entry.type === 'function') {
+            this.log(`Cannot construct a source from a function '${this.refName}'`);
+            return;
+        }
+        else if (entry.type === 'query') {
             this.log(`Cannot use 'from_sql()' with a query '${this.refName}'`);
             return;
         }

package/dist/lang/ast/time-utils.d.ts

@@ -1,6 +1,5 @@
-import { AtomicFieldType, Expr, Fragment, TimeFieldType, TimestampUnit } from '../../model/malloy_types';
+import { AtomicFieldType, Expr, Fragment, TimeFieldType, TimestampUnit, FieldValueType } from '../../model/malloy_types';
 import { TimeResult } from './types/time-result';
-import { FieldValueType } from './types/type-desc';
 export declare function timeOffset(timeType: TimeFieldType, from: Expr, op: '+' | '-', n: Expr, timeframe: TimestampUnit): Expr;
 export declare function castTo(castType: AtomicFieldType, from: Expr, fromType: FieldValueType, safe?: boolean): Expr;
 export declare function castTimestampToDate(from: Expr, safe?: boolean): Expr;

package/dist/lang/ast/types/expr-result.d.ts

@@ -1,5 +1,4 @@
-import { Fragment } from '../../../model/malloy_types';
-import { TypeDesc } from './type-desc';
+import { Fragment, TypeDesc } from '../../../model/malloy_types';
 declare type MorphicValues = Record<string, Fragment[]>;
 export interface ExprResult extends TypeDesc {
     value: Fragment[];

package/dist/lang/ast/types/expression-def.d.ts

@@ -1,7 +1,6 @@
-import { TimestampUnit } from '../../../model/malloy_types';
+import { TimestampUnit, FieldValueType } from '../../../model/malloy_types';
 import { ExprValue } from './expr-value';
 import { FieldSpace } from './field-space';
-import { FieldValueType } from './type-desc';
 import { MalloyElement } from './malloy-element';
 /**
  * Root node for any element in an expression. These essentially
@@ -19,7 +18,7 @@ export declare abstract class ExpressionDef extends MalloyElement {
      * @param space Namespace for looking up field references
      */
     abstract getExpression(fs: FieldSpace): ExprValue;
-    legalChildTypes: import("./type-desc").TypeDesc[];
+    legalChildTypes: import("../../../model/malloy_types").TypeDesc[];
     /**
      * Some operators want to give the right hand value a chance to
      * rewrite itself. This requests a translation for a rewrite,
@@ -51,7 +50,7 @@ export declare class ExprDuration extends ExpressionDef {
     readonly n: ExpressionDef;
     readonly timeframe: TimestampUnit;
     elementType: string;
-    legalChildTypes: import("./type-desc").TypeDesc[];
+    legalChildTypes: import("../../../model/malloy_types").TypeDesc[];
     constructor(n: ExpressionDef, timeframe: TimestampUnit);
     apply(fs: FieldSpace, op: string, left: ExpressionDef): ExprValue;
     getExpression(_fs: FieldSpace): ExprValue;

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

@@ -117,6 +117,7 @@ class ExprDuration extends ExpressionDef {
                 return (0, time_utils_1.timeResult)({
                     dataType: 'timestamp',
                     expressionType: (0, malloy_types_1.maxExpressionType)(lhs.expressionType, num.expressionType),
+                    evalSpace: (0, malloy_types_1.mergeEvalSpaces)(lhs.evalSpace, num.evalSpace),
                     value: result,
                 }, resultGranularity);
             }
@@ -124,6 +125,7 @@ class ExprDuration extends ExpressionDef {
                 return (0, time_utils_1.timeResult)({
                     dataType: 'date',
                     expressionType: (0, malloy_types_1.maxExpressionType)(lhs.expressionType, num.expressionType),
+                    evalSpace: (0, malloy_types_1.mergeEvalSpaces)(lhs.evalSpace, num.evalSpace),
                     value: (0, time_utils_1.timeOffset)('date', lhs.value, op, num.value, this.timeframe),
                 }, resultGranularity);
             }
@@ -139,6 +141,7 @@ class ExprDuration extends ExpressionDef {
             dataType: 'duration',
             expressionType: 'scalar',
             value: ['__ERROR_DURATION_IS_NOT_A_VALUE__'],
+            evalSpace: 'constant',
         };
     }
 }
@@ -193,7 +196,7 @@ function regexEqual(left, right) {
                     type: 'dialect',
                     function: 'regexpMatch',
                     expr: left.value,
-                    regexp: right.value[0].replace(/^r'/, "'"),
+                    regexp: right.value,
                 },
             ];
         }
@@ -205,7 +208,7 @@ function regexEqual(left, right) {
                     type: 'dialect',
                     function: 'regexpMatch',
                     expr: right.value,
-                    regexp: left.value[0].replace(/^r'/, "'"),
+                    regexp: left.value,
                 },
             ];
         }
@@ -275,6 +278,7 @@ function equality(fs, left, op, right) {
     return {
         dataType: 'boolean',
         expressionType: (0, malloy_types_1.maxExpressionType)(lhs.expressionType, rhs.expressionType),
+        evalSpace: (0, malloy_types_1.mergeEvalSpaces)(lhs.evalSpace, rhs.evalSpace),
         value,
     };
 }
@@ -290,6 +294,7 @@ function compare(fs, left, op, right) {
     return {
         dataType: 'boolean',
         expressionType,
+        evalSpace: (0, malloy_types_1.mergeEvalSpaces)(lhs.evalSpace, rhs.evalSpace),
         value: value,
     };
 }
@@ -317,6 +322,7 @@ function numeric(fs, left, op, right) {
             dataType: 'number',
             expressionType,
             value: (0, utils_1.compose)(lhs.value, op, rhs.value),
+            evalSpace: (0, malloy_types_1.mergeEvalSpaces)(lhs.evalSpace, rhs.evalSpace),
         };
     }
     left.log(`Non numeric('${lhs.dataType},${rhs.dataType}') value with '${op}'`);
@@ -395,6 +401,7 @@ function applyBinary(fs, left, op, right) {
             return {
                 dataType: 'number',
                 expressionType: (0, malloy_types_1.maxExpressionType)(num.expressionType, denom.expressionType),
+                evalSpace: (0, malloy_types_1.mergeEvalSpaces)(num.evalSpace, denom.evalSpace),
                 value: [div],
             };
         }
@@ -412,6 +419,7 @@ function unsupportError(l, lhs, r, rhs) {
         dataType: lhs.dataType,
         expressionType: (0, malloy_types_1.maxExpressionType)(lhs.expressionType, rhs.expressionType),
         value: ["'unsupported operation'"],
+        evalSpace: (0, malloy_types_1.mergeEvalSpaces)(lhs.evalSpace, rhs.evalSpace),
     };
     if (lhs.dataType === 'unsupported') {
         l.log('Unsupported type not allowed in expression');

package/dist/lang/ast/types/field-space.d.ts

@@ -2,6 +2,7 @@ import { Dialect } from '../../../dialect/dialect';
 import { StructDef } from '../../../model/malloy_types';
 import { LookupResult } from './lookup-result';
 import { MalloyElement } from './malloy-element';
+import { SpaceEntry } from './space-entry';
 /**
  * A FieldSpace is a hierarchy of namespaces, where the leaf nodes
  * are fields. A FieldSpace can lookup fields, and generate a StructDef
@@ -11,8 +12,14 @@ export interface FieldSpace {
     structDef(): StructDef;
     emptyStructDef(): StructDef;
     lookup(symbol: FieldName[]): LookupResult;
+    entry(symbol: string): SpaceEntry | undefined;
+    entries(): [string, SpaceEntry][];
     dialectObj(): Dialect | undefined;
     whenComplete: (step: () => void) => void;
+    isQueryFieldSpace(): this is QueryFieldSpace;
+}
+export interface QueryFieldSpace extends FieldSpace {
+    outputSpace(): FieldSpace;
 }
 export declare class FieldName extends MalloyElement {
     readonly name: string;

package/dist/lang/ast/types/global-name-space.d.ts

@@ -0,0 +1,12 @@
+import { ModelEntry } from './model-entry';
+import { NameSpace } from './name-space';
+/**
+ * We may want to remove this in the future...
+ *
+ * This is a global namespace which exists in the root of all Documents
+ * and includes SQL function definitions.
+ */
+export declare class GlobalNameSpace implements NameSpace {
+    getEntry(name: string): ModelEntry | undefined;
+    setEntry(_name: string, _value: ModelEntry, _exported: boolean): void;
+}

package/dist/lang/ast/types/global-name-space.js

@@ -0,0 +1,51 @@
+"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.GlobalNameSpace = void 0;
+const dialect_1 = require("../../../dialect");
+/**
+ * We may want to remove this in the future...
+ *
+ * This is a global namespace which exists in the root of all Documents
+ * and includes SQL function definitions.
+ */
+class GlobalNameSpace {
+    getEntry(name) {
+        // TODO cache this or precompute this so we're not comparing/merging dialect
+        // overloads on every usage
+        const func = (0, dialect_1.getDialectFunction)(name);
+        if (func === undefined) {
+            return undefined;
+        }
+        return {
+            entry: func,
+            exported: false,
+        };
+    }
+    setEntry(_name, _value, _exported) {
+        throw new Error('The global namespace is immutable!');
+    }
+}
+exports.GlobalNameSpace = GlobalNameSpace;
+//# sourceMappingURL=global-name-space.js.map

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

@@ -90,6 +90,7 @@ export declare class RunList extends ListOf<DocStatement> {
  */
 export declare class Document extends MalloyElement implements NameSpace {
     elementType: string;
+    globalNameSpace: NameSpace;
     documentModel: Record<string, ModelEntry>;
     queryList: Query[];
     sqlBlocks: SQLBlockStructDef[];

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

@@ -28,6 +28,7 @@ exports.Document = exports.RunList = exports.ListOf = exports.isDocStatement = e
  */
 const cloneDeep_1 = __importDefault(require("lodash/cloneDeep"));
 const malloy_types_1 = require("../../../model/malloy_types");
+const global_name_space_1 = require("./global-name-space");
 class MalloyElement {
     /**
      * @param kids All children passed to the constructor are not optional
@@ -297,6 +298,10 @@ class RunList extends ListOf {
     executeList(doc) {
         while (this.execCursor < this.elements.length) {
             if (doc.errorsExist()) {
+                // TODO make a better way to stop cascading errors -- this way means that if there are
+                // actual different errors in multiple places, we only see the first one. A better way
+                // might be to make things that have error pass all kinds of typechecks, which prevents
+                // the real cascade.
                 // This stops cascading errors
                 return;
             }
@@ -330,6 +335,7 @@ class Document extends MalloyElement {
     constructor(statements) {
         super();
         this.elementType = 'document';
+        this.globalNameSpace = new global_name_space_1.GlobalNameSpace();
         this.documentModel = {};
         this.queryList = [];
         this.sqlBlocks = [];
@@ -347,7 +353,9 @@ class Document extends MalloyElement {
         if (extendingModelDef) {
             for (const [nm, orig] of Object.entries(extendingModelDef.contents)) {
                 const entry = (0, cloneDeep_1.default)(orig);
-                if (entry.type === 'struct' || entry.type === 'query') {
+                if (entry.type === 'struct' ||
+                    entry.type === 'query' ||
+                    entry.type === 'function') {
                     const exported = extendingModelDef.exports.includes(nm);
                     this.setEntry(nm, { entry, exported });
                 }
@@ -395,9 +403,14 @@ class Document extends MalloyElement {
         return true;
     }
     getEntry(str) {
-        return this.documentModel[str];
+        var _a;
+        return (_a = this.globalNameSpace.getEntry(str)) !== null && _a !== void 0 ? _a : this.documentModel[str];
     }
     setEntry(str, ent) {
+        // TODO this error message is going to be in the wrong place everywhere...
+        if (this.globalNameSpace.getEntry(str) !== undefined) {
+            this.log(`Cannot redefine '${str}', which is in global namespace`);
+        }
         this.documentModel[str] = ent;
     }
 }

package/dist/lang/ast/types/query-property.d.ts

@@ -13,6 +13,5 @@ import { Ordering } from '../query-properties/ordering';
 import { ProjectStatement } from '../query-properties/project-statement';
 import { SampleProperty } from '../query-properties/sampling';
 import { Top } from '../query-properties/top';
-import { TimezoneStatement } from '../source-properties/timezone-statement';
-export declare type QueryProperty = Ordering | Top | Limit | Filter | Index | SampleProperty | Joins | DeclareFields | ProjectStatement | NestReference | NestDefinition | NestReference | Nests | Aggregate | GroupBy | TimezoneStatement;
+export declare type QueryProperty = Ordering | Top | Limit | Filter | Index | SampleProperty | Joins | DeclareFields | ProjectStatement | NestReference | NestDefinition | NestReference | Nests | Aggregate | GroupBy;
 export declare function isQueryProperty(q: MalloyElement): q is QueryProperty;

package/dist/lang/ast/types/query-property.js

@@ -37,6 +37,7 @@ const project_statement_1 = require("../query-properties/project-statement");
 const sampling_1 = require("../query-properties/sampling");
 const top_1 = require("../query-properties/top");
 const timezone_statement_1 = require("../source-properties/timezone-statement");
+const calculate_1 = require("../query-properties/calculate");
 function isQueryProperty(q) {
     return (q instanceof ordering_1.Ordering ||
         q instanceof top_1.Top ||
@@ -48,6 +49,7 @@ function isQueryProperty(q) {
         q instanceof declare_fields_1.DeclareFields ||
         q instanceof project_statement_1.ProjectStatement ||
         q instanceof aggregate_1.Aggregate ||
+        q instanceof calculate_1.Calculate ||
         q instanceof nests_1.Nests ||
         (0, nest_1.isNestedQuery)(q) ||
         q instanceof group_by_1.GroupBy ||

package/dist/lang/ast/types/space-entry.d.ts

@@ -1,4 +1,4 @@
-import { TypeDesc } from './type-desc';
+import { TypeDesc } from '../../../model';
 export declare abstract class SpaceEntry {
     abstract typeDesc(): TypeDesc;
     abstract refType: 'field' | 'parameter';

package/dist/lang/ast/types/space-field.d.ts

@@ -1,7 +1,6 @@
-import { FieldDef, QueryFieldDef } from '../../../model/malloy_types';
+import { FieldDef, QueryFieldDef, TypeDesc } from '../../../model/malloy_types';
 import { SpaceEntry } from './space-entry';
 import { FieldSpace } from './field-space';
-import { TypeDesc } from './type-desc';
 export declare abstract class SpaceField extends SpaceEntry {
     readonly refType = "field";
     protected fieldTypeFromFieldDef(def: FieldDef): TypeDesc;

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

@@ -31,7 +31,11 @@ class SpaceField extends space_entry_1.SpaceEntry {
         this.refType = 'field';
     }
     fieldTypeFromFieldDef(def) {
-        const ref = { dataType: def.type, expressionType: 'scalar' };
+        const ref = {
+            dataType: def.type,
+            expressionType: 'scalar',
+            evalSpace: 'input',
+        };
         if ((0, malloy_types_1.isFieldTypeDef)(def) && def.expressionType) {
             ref.expressionType = def.expressionType;
         }

package/dist/lang/ast/types/space-param.d.ts

@@ -1,7 +1,6 @@
-import { Parameter } from '../../../model/malloy_types';
+import { Parameter, TypeDesc } from '../../../model/malloy_types';
 import { SpaceEntry } from './space-entry';
 import { HasParameter } from '../parameters/has-parameter';
-import { TypeDesc } from './type-desc';
 export declare abstract class SpaceParam extends SpaceEntry {
     abstract parameter(): Parameter;
     readonly refType = "parameter";