@malloydata/malloy 0.0.195-dev241003204819 → 0.0.195-dev241007154000

package/dist/lang/ast/expressions/expr-aggregate-function.js

@@ -27,7 +27,6 @@ const malloy_types_1 = require("../../../model/malloy_types");
 const utils_1 = require("../../../model/utils");
 const ast_utils_1 = require("../ast-utils");
 const static_space_1 = require("../field-space/static-space");
-const struct_space_field_base_1 = require("../field-space/struct-space-field-base");
 const fragtype_utils_1 = require("../fragtype-utils");
 const field_references_1 = require("../query-items/field-references");
 const expression_def_1 = require("../types/expression-def");
@@ -60,34 +59,34 @@ class ExprAggregateFunction extends expression_def_1.ExpressionDef {
         if (this.source) {
             const result = this.source.getField(inputFS);
             if (result.found) {
-                sourceRelationship = result.relationship;
+                sourceRelationship = result.joinPath;
                 const sourceFoot = result.found;
                 const footType = sourceFoot.typeDesc();
-                if ((0, malloy_types_1.isAtomicFieldType)(footType.dataType)) {
-                    expr = this.source;
-                    exprVal = {
-                        dataType: footType.dataType,
-                        expressionType: footType.expressionType,
-                        value: footType.evalSpace === 'output'
-                            ? { node: 'outputField', name: this.source.refString }
-                            : { node: 'field', path: this.source.path },
-                        evalSpace: footType.evalSpace,
-                    };
-                    structPath = this.source.path;
-                    // Here we handle a special case where you write `foo.agg()` and `foo` is a
-                    // dimension which uses only one distinct join path; in this case, we set the
-                    // locality to be that join path
-                    const joinUsage = this.getJoinUsage(inputFS);
-                    const allUsagesSame = joinUsage.length === 1 ||
-                        (joinUsage.length > 1 &&
-                            joinUsage.slice(1).every(p => joinPathEq(p, joinUsage[0])));
-                    if (allUsagesSame) {
-                        structPath = joinUsage[0].map(p => p.name);
-                        sourceRelationship = joinUsage[0];
+                if (!(sourceFoot instanceof static_space_1.StructSpaceField)) {
+                    if ((0, malloy_types_1.isAtomicFieldType)(footType.dataType)) {
+                        expr = this.source;
+                        exprVal = {
+                            dataType: footType.dataType,
+                            expressionType: footType.expressionType,
+                            value: footType.evalSpace === 'output'
+                                ? { node: 'outputField', name: this.source.refString }
+                                : { node: 'field', path: this.source.path },
+                            evalSpace: footType.evalSpace,
+                        };
+                        structPath = this.source.path;
+                        // Here we handle a special case where you write `foo.agg()` and `foo` is a
+                        // dimension which uses only one distinct join path; in this case, we set the
+                        // locality to be that join path
+                        const joinUsage = this.getJoinUsage(inputFS);
+                        const allUsagesSame = joinUsage.length === 1 ||
+                            (joinUsage.length > 1 &&
+                                joinUsage.slice(1).every(p => joinPathEq(p, joinUsage[0])));
+                        if (allUsagesSame) {
+                            structPath = joinUsage[0].map(p => p.name);
+                            sourceRelationship = joinUsage[0];
+                        }
                     }
-                }
-                else {
-                    if (!(sourceFoot instanceof struct_space_field_base_1.StructSpaceFieldBase)) {
+                    else {
                         return this.loggedErrorExpr('invalid-aggregate-source', `Aggregate source cannot be a ${footType.dataType}`);
                     }
                 }
@@ -185,7 +184,7 @@ function joinPathEq(a1, a2) {
 }
 function getJoinUsage(fs, expr) {
     const result = [];
-    const lookup = (fs, path) => {
+    const lookupWithPath = (fs, path) => {
         const head = path[0];
         const rest = path.slice(1);
         const def = fs.entry(head);
@@ -193,13 +192,10 @@ function getJoinUsage(fs, expr) {
             throw new Error(`Invalid field lookup ${head}`);
         }
         if (def instanceof static_space_1.StructSpaceField && rest.length > 0) {
-            const restDef = lookup(def.fieldSpace, rest);
+            const restDef = lookupWithPath(def.fieldSpace, rest);
             return {
                 ...restDef,
-                relationship: [
-                    { name: head, structRelationship: def.structRelationship },
-                    ...restDef.relationship,
-                ],
+                joinPath: [{ ...def.joinPathElement, name: head }, ...restDef.joinPath],
             };
         }
         else if (def instanceof space_field_1.SpaceField) {
@@ -211,7 +207,7 @@ function getJoinUsage(fs, expr) {
                 return {
                     fs,
                     def: fieldDef,
-                    relationship: [],
+                    joinPath: [],
                 };
             }
             throw new Error('No field def');
@@ -222,21 +218,22 @@ function getJoinUsage(fs, expr) {
     };
     for (const frag of (0, utils_1.exprWalk)(expr)) {
         if (frag.node === 'field') {
-            const def = lookup(fs, frag.path);
-            if (def.def.type !== 'struct' && def.def.type !== 'turtle') {
-                if (def.def.e) {
-                    const defUsage = getJoinUsage(def.fs, def.def.e);
-                    result.push(...defUsage.map(r => [...def.relationship, ...r]));
+            const def = lookupWithPath(fs, frag.path);
+            const field = def.def;
+            if ((0, malloy_types_1.isAtomic)(field) && !(0, malloy_types_1.isJoined)(field)) {
+                if ((0, malloy_types_1.hasExpression)(field)) {
+                    const defUsage = getJoinUsage(def.fs, field.e);
+                    result.push(...defUsage.map(r => [...def.joinPath, ...r]));
                 }
                 else {
-                    result.push(def.relationship);
+                    result.push(def.joinPath);
                 }
             }
         }
         else if (frag.node === 'source-reference') {
             if (frag.path) {
-                const def = lookup(fs, frag.path);
-                result.push(def.relationship);
+                const def = lookupWithPath(fs, frag.path);
+                result.push(def.joinPath);
             }
             else {
                 result.push([]);
@@ -245,19 +242,19 @@ function getJoinUsage(fs, expr) {
     }
     return result;
 }
-function getJoinUsagePaths(sourceRelationship, joinUsage) {
+function getJoinUsagePaths(joinPath, joinUsage) {
     const sourceToUsagePaths = [];
     for (const usage of joinUsage) {
         let overlap = 0;
-        for (let i = 0; i < sourceRelationship.length && i < usage.length; i++) {
-            if (sourceRelationship[i].name === usage[i].name) {
+        for (let i = 0; i < joinPath.length && i < usage.length; i++) {
+            if (joinPath[i].name === usage[i].name) {
                 overlap = i + 1;
             }
             else {
                 break;
             }
         }
-        const nonOverlapSource = sourceRelationship.slice(overlap);
+        const nonOverlapSource = joinPath.slice(overlap);
         const nonOverlapUsage = usage.slice(overlap);
         const sourceToUsagePath = [
             ...nonOverlapSource.map(r => ({ ...r, reverse: true })),
@@ -270,22 +267,22 @@ function getJoinUsagePaths(sourceRelationship, joinUsage) {
 function validateUsagePaths(functionName, usagePaths) {
     for (const path of usagePaths) {
         for (const step of path) {
-            if (step.structRelationship.type === 'cross') {
+            if (step.joinType === 'cross') {
                 return {
                     code: 'aggregate-traverses-join-cross',
                     message: `Cannot compute \`${functionName}\` across \`join_cross\` relationship \`${step.name}\``,
                 };
             }
-            else if (step.structRelationship.type === 'many' && !step.reverse) {
+            else if (step.joinElementType === 'array' && !step.reverse) {
                 return {
-                    code: 'aggregate-traverses-join-many',
-                    message: `Cannot compute \`${functionName}\` across \`join_many\` relationship \`${step.name}\``,
+                    code: 'aggregate-traverses-repeated-relationship',
+                    message: `Cannot compute \`${functionName}\` across repeated relationship \`${step.name}\``,
                 };
             }
-            else if (step.structRelationship.type === 'nested' && !step.reverse) {
+            else if (step.joinType === 'many' && !step.reverse) {
                 return {
-                    code: 'aggregate-traverses-repeated-relationship',
-                    message: `Cannot compute \`${functionName}\` across repeated relationship \`${step.name}\``,
+                    code: 'aggregate-traverses-join-many',
+                    message: `Cannot compute \`${functionName}\` across \`join_many\` relationship \`${step.name}\``,
                 };
             }
         }
@@ -313,8 +310,7 @@ function suggestNewVersion(joinError, joinUsage, expr, func) {
     const indexFromEndOfLastMany = longestOverlap
         .slice()
         .reverse()
-        .findIndex(x => x.structRelationship.type === 'many' ||
-        x.structRelationship.type === 'cross');
+        .findIndex(x => x.joinType === 'many' || x.joinType === 'cross');
     const numJoinsToLastMany = indexFromEndOfLastMany === -1
         ? 0
         : longestOverlap.length - indexFromEndOfLastMany;

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

@@ -34,9 +34,8 @@ class ExprCast extends expression_def_1.ExpressionDef {
         this.elementType = 'cast';
     }
     getExpression(fs) {
-        var _a, _b, _c;
         const expr = this.expr.getExpression(fs);
-        let dataType = 'sql native';
+        let dataType = 'error';
         if (typeof this.castType === 'string') {
             dataType = this.castType;
         }
@@ -46,8 +45,7 @@ class ExprCast extends expression_def_1.ExpressionDef {
                 if (dialect.validateTypeName(this.castType.raw)) {
                     // TODO theoretically `sqlTypeToMalloyType` can get number subtypes,
                     // but `TypeDesc` does not support them.
-                    dataType =
-                        (_c = (_b = (_a = fs.dialectObj()) === null || _a === void 0 ? void 0 : _a.sqlTypeToMalloyType(this.castType.raw)) === null || _b === void 0 ? void 0 : _b.type) !== null && _c !== void 0 ? _c : 'sql native';
+                    dataType = dialect.sqlTypeToMalloyType(this.castType.raw).type;
                 }
                 else {
                     this.logError('invalid-sql-native-type', `Cast type \`${this.castType.raw}\` is invalid for ${dialect.name} dialect`);

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

@@ -66,7 +66,7 @@ class ExprFunc extends expression_def_1.ExpressionDef {
             return { found: undefined, error: 'unknown function' };
         }
         else if (func.type !== 'function') {
-            this.logError(`${func.type}-not-callable`, `Cannot call '${this.name}', which is of type ${func.type}`);
+            this.logError('call-of-non-function', `'${this.name}' (with type ${func.type}) is not a function`);
             return { found: undefined, error: 'called non function' };
         }
         if (func.name !== this.name) {

package/dist/lang/ast/expressions/expr-granular-time.js

@@ -52,7 +52,7 @@ class ExprGranularTime extends expression_def_1.ExpressionDef {
     getExpression(fs) {
         const timeframe = this.units;
         const exprVal = this.expr.getExpression(fs);
-        if ((0, malloy_types_1.isTimeFieldType)(exprVal.dataType)) {
+        if ((0, malloy_types_1.isTemporalField)(exprVal.dataType)) {
             const tsVal = {
                 ...exprVal,
                 dataType: exprVal.dataType,

package/dist/lang/ast/expressions/expr-record-literal.d.ts

@@ -0,0 +1,16 @@
+import { ExprValue } from '../types/expr-value';
+import { ExpressionDef } from '../types/expression-def';
+import { FieldSpace } from '../types/field-space';
+import { MalloyElement } from '../types/malloy-element';
+export declare class RecordElement extends MalloyElement {
+    readonly key: string;
+    readonly value: ExpressionDef;
+    elementType: string;
+    constructor(key: string, value: ExpressionDef);
+}
+export declare class RecordLiteral extends ExpressionDef {
+    readonly pairs: RecordElement[];
+    elementType: string;
+    constructor(pairs: RecordElement[]);
+    getExpression(fs: FieldSpace): ExprValue;
+}

package/dist/lang/ast/expressions/expr-record-literal.js

@@ -0,0 +1,57 @@
+"use strict";
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ *  LICENSE file in the root directory of this source tree.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RecordLiteral = exports.RecordElement = void 0;
+const model_1 = require("../../../model");
+const expression_def_1 = require("../types/expression-def");
+const malloy_element_1 = require("../types/malloy-element");
+class RecordElement extends malloy_element_1.MalloyElement {
+    constructor(key, value) {
+        super();
+        this.key = key;
+        this.value = value;
+        this.elementType = 'record element';
+        this.has({ value });
+    }
+}
+exports.RecordElement = RecordElement;
+class RecordLiteral extends expression_def_1.ExpressionDef {
+    constructor(pairs) {
+        super();
+        this.pairs = pairs;
+        this.elementType = 'record literal';
+        this.has({ pairs });
+    }
+    getExpression(fs) {
+        const recLit = {
+            node: 'recordLiteral',
+            kids: {},
+        };
+        let resultExprType = 'scalar';
+        for (const el of this.pairs) {
+            const xVal = el.value.getExpression(fs);
+            const expr = { dataType: 'error', ...xVal.value };
+            if (expr.dataType === 'error' && (0, model_1.isAtomicFieldType)(xVal.dataType)) {
+                expr.dataType = xVal.dataType;
+            }
+            if (expr.dataType === 'error' && xVal.dataType !== 'error') {
+                this.logError('illegal-record-property-type', `Type '${xVal.dataType}' not a legal record value`);
+            }
+            recLit.kids[el.key] = expr;
+            resultExprType = (0, model_1.maxExpressionType)(xVal.expressionType, resultExprType);
+        }
+        return {
+            dataType: 'record',
+            value: recLit,
+            expressionType: resultExprType,
+            evalSpace: 'literal',
+        };
+    }
+}
+exports.RecordLiteral = RecordLiteral;
+//# sourceMappingURL=expr-record-literal.js.map

package/dist/lang/ast/expressions/expr-time-extract.js

@@ -63,10 +63,10 @@ class ExprTimeExtract extends expression_def_1.ExpressionDef {
                         value: (0, ast_utils_1.errorFor)('extract from error').value,
                     };
                 }
-                if (!(0, malloy_types_1.isTimeFieldType)(first.dataType)) {
+                if (!(0, malloy_types_1.isTemporalField)(first.dataType)) {
                     return from.first.loggedErrorExpr('invalid-type-for-time-extraction', `Can't extract ${extractTo} from '${first.dataType}'`);
                 }
-                if (!(0, malloy_types_1.isTimeFieldType)(last.dataType)) {
+                if (!(0, malloy_types_1.isTemporalField)(last.dataType)) {
                     return from.last.loggedErrorExpr('invalid-type-for-time-extraction', `Cannot extract ${extractTo} from '${last.dataType}'`);
                 }
                 let valueType = first.dataType;
@@ -113,7 +113,7 @@ class ExprTimeExtract extends expression_def_1.ExpressionDef {
             }
             else {
                 const argV = from.getExpression(fs);
-                if ((0, malloy_types_1.isTimeFieldType)(argV.dataType)) {
+                if ((0, malloy_types_1.isTemporalField)(argV.dataType)) {
                     return {
                         dataType: 'number',
                         expressionType: argV.expressionType,

package/dist/lang/ast/expressions/expr-time.d.ts

@@ -1,11 +1,11 @@
-import { Expr, ExpressionType, TimeFieldType } from '../../../model/malloy_types';
+import { Expr, ExpressionType, TemporalFieldType } from '../../../model/malloy_types';
 import { FieldSpace } from '../types/field-space';
 import { ExprValue } from '../types/expr-value';
 import { ExpressionDef } from '../types/expression-def';
 export declare class ExprTime extends ExpressionDef {
     elementType: string;
     readonly translationValue: ExprValue;
-    constructor(timeType: TimeFieldType, value: Expr, expressionType?: ExpressionType);
+    constructor(timeType: TemporalFieldType, value: Expr, expressionType?: ExpressionType);
     getExpression(_fs: FieldSpace): ExprValue;
-    static fromValue(timeType: TimeFieldType, expr: ExprValue): ExprTime;
+    static fromValue(timeType: TemporalFieldType, expr: ExprValue): ExprTime;
 }

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

@@ -49,7 +49,7 @@ class ExprTime extends expression_def_1.ExpressionDef {
                 dstType: timeType,
                 e: expr.value,
             };
-            if ((0, malloy_types_1.isTimeFieldType)(expr.dataType)) {
+            if ((0, malloy_types_1.isTemporalField)(expr.dataType)) {
                 toTs.srcType = expr.dataType;
             }
             value = toTs;

package/dist/lang/ast/expressions/time-literal.d.ts

@@ -1,4 +1,4 @@
-import { TimeFieldType, TimestampUnit, TimeLiteralNode } from '../../../model/malloy_types';
+import { TemporalFieldType, TimestampUnit, TimeLiteralNode } from '../../../model/malloy_types';
 import { ExprValue } from '../types/expr-value';
 import { FieldSpace } from '../types/field-space';
 import { ExpressionDef } from '../types/expression-def';
@@ -15,13 +15,13 @@ interface TimeText {
  */
 declare abstract class TimeLiteral extends ExpressionDef {
     readonly units: TimestampUnit | undefined;
-    readonly timeType: TimeFieldType;
+    readonly timeType: TemporalFieldType;
     literalPart: string;
     nextLit?: string;
     timeZone?: string;
-    constructor(tm: TimeText, units: TimestampUnit | undefined, timeType: TimeFieldType);
-    protected makeLiteral(val: string, typ: TimeFieldType): TimeLiteralNode;
-    protected makeValue(val: string, dataType: TimeFieldType): TimeResult;
+    constructor(tm: TimeText, units: TimestampUnit | undefined, timeType: TemporalFieldType);
+    protected makeLiteral(val: string, typ: TemporalFieldType): TimeLiteralNode;
+    protected makeValue(val: string, dataType: TemporalFieldType): TimeResult;
     getExpression(_fs: FieldSpace): ExprValue;
     getNext(): ExprValue | undefined;
     granular(): boolean;
@@ -38,7 +38,7 @@ export declare class LiteralTimestamp extends TimeLiteral {
 declare class GranularLiteral extends TimeLiteral {
     readonly nextLit: string;
     elementType: string;
-    constructor(tm: TimeText, units: TimestampUnit | undefined, timeType: TimeFieldType, nextLit: string);
+    constructor(tm: TimeText, units: TimestampUnit | undefined, timeType: TemporalFieldType, nextLit: string);
     apply(fs: FieldSpace, op: BinaryMalloyOperator, left: ExpressionDef): ExprValue;
 }
 export declare class LiteralHour extends GranularLiteral {

package/dist/lang/ast/expressions/time-literal.js

@@ -171,7 +171,7 @@ class GranularLiteral extends TimeLiteral {
                     return super.apply(fs, op, left);
                 }
             }
-            if ((0, malloy_types_1.isTimeFieldType)(testValue.dataType)) {
+            if ((0, malloy_types_1.isTemporalField)(testValue.dataType)) {
                 const rangeType = testValue.dataType;
                 const range = new range_1.Range(new expr_time_1.ExprTime(rangeType, rangeStart.value), new expr_time_1.ExprTime(rangeType, rangeEnd.value));
                 return range.apply(fs, op, left);

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

@@ -1,8 +1,9 @@
-import { FieldDef, FieldTypeDef, TypeDesc } from '../../../model/malloy_types';
+import { TypeDesc, AtomicFieldDef } from '../../../model/malloy_types';
 import { SpaceField } from '../types/space-field';
-export declare class ColumnSpaceField extends SpaceField {
-    haveFieldDef: FieldDef;
-    constructor(def: FieldTypeDef);
-    fieldDef(): FieldDef;
+export declare class ColumnSpaceField<T extends AtomicFieldDef> extends SpaceField {
+    sourceFieldDef: T;
+    constructor(sourceFieldDef: T);
+    fieldDef(): T;
     typeDesc(): TypeDesc;
+    constructorFieldDef(): T;
 }

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

@@ -25,15 +25,18 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ColumnSpaceField = void 0;
 const space_field_1 = require("../types/space-field");
 class ColumnSpaceField extends space_field_1.SpaceField {
-    constructor(def) {
+    constructor(sourceFieldDef) {
         super();
-        this.haveFieldDef = def;
+        this.sourceFieldDef = sourceFieldDef;
     }
     fieldDef() {
-        return this.haveFieldDef;
+        return this.sourceFieldDef;
     }
     typeDesc() {
-        return this.fieldTypeFromFieldDef(this.haveFieldDef);
+        return this.fieldTypeFromFieldDef(this.sourceFieldDef);
+    }
+    constructorFieldDef() {
+        return this.sourceFieldDef;
     }
 }
 exports.ColumnSpaceField = ColumnSpaceField;

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

@@ -2,17 +2,18 @@ import * as model from '../../../model/malloy_types';
 import { SpaceEntry } from '../types/space-entry';
 import { HasParameter } from '../parameters/has-parameter';
 import { MalloyElement } from '../types/malloy-element';
-import { SourceSpec, SpaceSeed } from '../space-seed';
 import { StaticSpace } from './static-space';
 import { ParameterSpace } from './parameter-space';
-export declare abstract class DynamicSpace extends StaticSpace {
-    protected final: model.StructDef | undefined;
-    protected source: SpaceSeed;
+import { SourceDef } from '../../../model/malloy_types';
+import { SourceFieldSpace } from '../types/field-space';
+export declare abstract class DynamicSpace extends StaticSpace implements SourceFieldSpace {
+    protected final: model.SourceDef | undefined;
+    protected fromSource: model.SourceDef;
     completions: (() => void)[];
     private complete;
     private parameters;
     protected newTimezone?: string;
-    constructor(extending: SourceSpec);
+    constructor(extending: SourceDef);
     isComplete(): void;
     protected setEntry(name: string, value: SpaceEntry): void;
     addParameters(parameters: HasParameter[]): DynamicSpace;
@@ -21,5 +22,6 @@ export declare abstract class DynamicSpace extends StaticSpace {
     renameEntry(oldName: string, newName: string, entry: SpaceEntry): void;
     addFieldDef(fd: model.FieldDef): void;
     setTimezone(tz: string): void;
-    structDef(): model.StructDef;
+    structDef(): model.SourceDef;
+    emptyStructDef(): SourceDef;
 }

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

@@ -21,27 +21,49 @@
  * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DynamicSpace = void 0;
+const model = __importStar(require("../../../model/malloy_types"));
 const field_utils_1 = require("../../field-utils");
 const error_factory_1 = require("../error-factory");
 const space_field_1 = require("../types/space-field");
 const join_space_field_1 = require("./join-space-field");
 const view_field_1 = require("./view-field");
 const space_param_1 = require("../types/space-param");
-const space_seed_1 = require("../space-seed");
 const static_space_1 = require("./static-space");
 const struct_space_field_base_1 = require("./struct-space-field-base");
 const parameter_space_1 = require("./parameter-space");
 class DynamicSpace extends static_space_1.StaticSpace {
     constructor(extending) {
-        const source = new space_seed_1.SpaceSeed(extending);
-        super(structuredClone(source.structDef));
+        super(structuredClone(extending));
         this.completions = [];
         this.complete = false;
         this.parameters = [];
+        this.fromSource = extending;
         this.final = undefined;
-        this.source = source;
     }
     isComplete() {
         this.complete = true;
@@ -91,11 +113,8 @@ class DynamicSpace extends static_space_1.StaticSpace {
                     parameters[name] = entry.parameter();
                 }
             }
-            this.final = {
-                ...this.fromStruct,
-                fields: [],
-                parameters,
-            };
+            this.final = { ...this.fromSource, fields: [] };
+            this.final.parameters = parameters;
             // Need to process the entities in specific order
             const fields = [];
             const joins = [];
@@ -117,7 +136,7 @@ class DynamicSpace extends static_space_1.StaticSpace {
             for (const [, field] of reorderFields) {
                 if (field instanceof join_space_field_1.JoinSpaceField) {
                     const joinStruct = field.join.structDef(parameterSpace);
-                    if (!error_factory_1.ErrorFactory.isErrorStructDef(joinStruct)) {
+                    if (!error_factory_1.ErrorFactory.didCreate(joinStruct)) {
                         this.final.fields.push(joinStruct);
                         fixupJoins.push([field.join, joinStruct]);
                     }
@@ -139,12 +158,17 @@ class DynamicSpace extends static_space_1.StaticSpace {
                 join.fixupJoinOn(this, missingOn);
             }
         }
-        if (this.newTimezone) {
+        if (this.newTimezone && model.isSourceDef(this.final)) {
             this.final.queryTimezone = this.newTimezone;
         }
         this.isComplete();
         return this.final;
     }
+    emptyStructDef() {
+        const ret = { ...this.fromSource };
+        ret.fields = [];
+        return ret;
+    }
 }
 exports.DynamicSpace = DynamicSpace;
 //# sourceMappingURL=dynamic-space.js.map

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

@@ -119,9 +119,12 @@ class IndexFieldSpace extends query_spaces_1.QueryOperationSpace {
                 wild.logError('name-conflict-in-wildcard-expansion', `Cannot expand '${name}' in '${wild.refString}' because a field with that name already exists${conflict ? ` (conflicts with ${conflict})` : ''}`);
             }
             else {
-                const eType = entry.typeDesc();
-                if ((0, malloy_types_1.isAtomicFieldType)(eType.dataType) &&
-                    (0, malloy_types_1.expressionIsScalar)(eType.expressionType) &&
+                const eTypeDesc = entry.typeDesc();
+                const eType = eTypeDesc.dataType;
+                // Don't index arrays and records
+                const canIndex = (0, malloy_types_1.isAtomicFieldType)(eType) && eType !== 'record' && eType !== 'array';
+                if (canIndex &&
+                    (0, malloy_types_1.expressionIsScalar)(eTypeDesc.expressionType) &&
                     (dialect === undefined || !dialect.ignoreInProject(name))) {
                     expandEntries.push({ name: indexName, entry });
                     this.expandedWild[indexName] = joinPath.concat(name);

package/dist/lang/ast/field-space/ir-view-field.d.ts

@@ -6,5 +6,6 @@ export declare class IRViewField extends ViewField {
     constructor(fs: FieldSpace, turtleDef: TurtleDef);
     rename(name: string): void;
     fieldDef(): TurtleDef;
+    constructorFieldDef(): TurtleDef;
     getQueryFieldDef(_fs: FieldSpace): QueryFieldDef | undefined;
 }

package/dist/lang/ast/field-space/ir-view-field.js

@@ -28,7 +28,6 @@ class IRViewField extends view_field_1.ViewField {
     constructor(fs, turtleDef) {
         super(fs);
         this.turtleDef = turtleDef;
-        this.haveFieldDef = turtleDef;
     }
     rename(name) {
         this.turtleDef = {
@@ -39,6 +38,9 @@ class IRViewField extends view_field_1.ViewField {
     fieldDef() {
         return this.turtleDef;
     }
+    constructorFieldDef() {
+        return this.turtleDef;
+    }
     getQueryFieldDef(_fs) {
         return this.fieldDef();
     }

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

@@ -1,8 +1,8 @@
-import { Join } from '../source-properties/joins';
+import { Join } from '../source-properties/join';
 import { ParameterSpace } from './parameter-space';
 import { StructSpaceField } from './static-space';
 export declare class JoinSpaceField extends StructSpaceField {
     readonly parameterSpace: ParameterSpace;
     readonly join: Join;
-    constructor(parameterSpace: ParameterSpace, join: Join);
+    constructor(parameterSpace: ParameterSpace, join: Join, parentDialect: string);
 }

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

@@ -25,8 +25,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.JoinSpaceField = void 0;
 const static_space_1 = require("./static-space");
 class JoinSpaceField extends static_space_1.StructSpaceField {
-    constructor(parameterSpace, join) {
-        super(join.structDef(parameterSpace));
+    constructor(parameterSpace, join, parentDialect) {
+        super(join.structDef(parameterSpace), parentDialect);
         this.parameterSpace = parameterSpace;
         this.join = join;
     }