@malloydata/malloy 0.0.195-dev241003204905 → 0.0.195-dev241007154000

package/dist/lang/ast/source-properties/{joins.js → join.js}

@@ -22,14 +22,14 @@
  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Joins = exports.ExpressionJoin = exports.KeyJoin = exports.Join = void 0;
+exports.JoinStatement = exports.ExpressionJoin = exports.KeyJoin = exports.Join = void 0;
 const malloy_types_1 = require("../../../model/malloy_types");
 const join_space_field_1 = require("../field-space/join-space-field");
 const definition_list_1 = require("../types/definition-list");
 const malloy_element_1 = require("../types/malloy-element");
 const noteable_1 = require("../types/noteable");
-const query_property_interface_1 = require("../types/query-property-interface");
 const error_factory_1 = require("../error-factory");
+const query_property_interface_1 = require("../types/query-property-interface");
 class Join extends malloy_element_1.MalloyElement {
     constructor() {
         super(...arguments);
@@ -37,7 +37,7 @@ class Join extends malloy_element_1.MalloyElement {
         this.extendNote = noteable_1.extendNoteMethod;
     }
     makeEntry(fs) {
-        fs.newEntry(this.name.refString, this, new join_space_field_1.JoinSpaceField(fs.parameterSpace(), this));
+        fs.newEntry(this.name.refString, this, new join_space_field_1.JoinSpaceField(fs.parameterSpace(), this, fs.dialect));
     }
     getStructDefFromExpr(parameterSpace) {
         const source = this.sourceExpr.getSource();
@@ -45,7 +45,7 @@ class Join extends malloy_element_1.MalloyElement {
             this.sourceExpr.sqLog('invalid-join-source', 'Cannot create a source to join from');
             return error_factory_1.ErrorFactory.structDef;
         }
-        return source.structDef(parameterSpace);
+        return source.getSourceDef(parameterSpace);
     }
 }
 exports.Join = Join;
@@ -60,22 +60,18 @@ class KeyJoin extends Join {
     structDef(parameterSpace) {
         var _a;
         const sourceDef = this.getStructDefFromExpr(parameterSpace);
+        if (!(0, malloy_types_1.isJoinable)(sourceDef)) {
+            throw this.internalError(`Cannot join struct type '${sourceDef.type}'`);
+        }
         const joinStruct = {
             ...sourceDef,
-            structRelationship: {
-                type: 'one',
-                matrixOperation: 'left',
-                onExpression: { node: 'error', message: "('join fixup'='not done yet')" },
-            },
+            name: this.name.refString,
+            join: 'one',
+            matrixOperation: 'left',
+            onExpression: { node: 'error', message: "('join fixup'='not done yet')" },
             location: this.location,
         };
-        if (sourceDef.structSource.type === 'query') {
-            // the name from query does not need to be preserved
-            joinStruct.name = this.name.refString;
-        }
-        else {
-            joinStruct.as = this.name.refString;
-        }
+        delete joinStruct.as;
         if (this.note) {
             joinStruct.annotation = this.note;
         }
@@ -84,22 +80,19 @@ class KeyJoin extends Join {
     }
     fixupJoinOn(outer, inStruct) {
         const exprX = this.keyExpr.getExpression(outer);
-        if (inStruct.primaryKey) {
+        if ((0, malloy_types_1.isSourceDef)(inStruct) && inStruct.primaryKey) {
             const pkey = inStruct.fields.find(f => (f.as || f.name) === inStruct.primaryKey);
             if (pkey) {
                 if (pkey.type === exprX.dataType) {
-                    inStruct.structRelationship = {
-                        type: 'one',
-                        matrixOperation: 'left',
-                        onExpression: {
-                            node: '=',
-                            kids: {
-                                left: {
-                                    node: 'field',
-                                    path: [this.name.refString, inStruct.primaryKey],
-                                },
-                                right: exprX.value,
+                    inStruct.join = 'one';
+                    inStruct.onExpression = {
+                        node: '=',
+                        kids: {
+                            left: {
+                                node: 'field',
+                                path: [this.name.refString, inStruct.primaryKey],
                             },
+                            right: exprX.value,
                         },
                     };
                     return;
@@ -143,40 +136,31 @@ class ExpressionJoin extends Join {
             this.logError('non-boolean-join-on', 'join conditions must be boolean expressions');
             return;
         }
-        const joinRel = inStruct.structRelationship;
-        if ((0, malloy_types_1.isJoinOn)(joinRel)) {
-            joinRel.onExpression = exprX.value;
-        }
+        inStruct.onExpression = exprX.value;
     }
     structDef(parameterSpace) {
         var _a;
         const source = this.sourceExpr.getSource();
         if (!source) {
             this.sourceExpr.sqLog('invalid-join-source', 'Cannot create a source to join from');
-            return error_factory_1.ErrorFactory.structDef;
+            return error_factory_1.ErrorFactory.joinDef;
         }
-        const sourceDef = source.structDef(parameterSpace);
+        const sourceDef = source.getSourceDef(parameterSpace);
         let matrixOperation = 'left';
         if (this.inExperiment('join_types', true)) {
             matrixOperation = this.matrixOperation;
         }
+        if (!(0, malloy_types_1.isJoinable)(sourceDef)) {
+            throw this.internalError(`Can't join struct type ${sourceDef.type}`);
+        }
         const joinStruct = {
             ...sourceDef,
-            // MTOY: add matrix type here
-            structRelationship: {
-                type: this.joinType,
-                matrixOperation,
-            },
+            name: this.name.refString,
+            join: this.joinType,
+            matrixOperation,
             location: this.location,
         };
-        if (sourceDef.structSource.type === 'query') {
-            // the name from query does not need to be preserved
-            joinStruct.name = this.name.refString;
-            delete joinStruct.as;
-        }
-        else {
-            joinStruct.as = this.name.refString;
-        }
+        delete joinStruct.as;
         if (this.note) {
             joinStruct.annotation = this.note;
         }
@@ -185,11 +169,10 @@ class ExpressionJoin extends Join {
     }
 }
 exports.ExpressionJoin = ExpressionJoin;
-// mtoy todo m0 goes away
-class Joins extends definition_list_1.DefinitionList {
+class JoinStatement extends definition_list_1.DefinitionList {
     constructor(joins) {
         super(joins);
-        this.elementType = 'joinList';
+        this.elementType = 'joinStatement';
         this.forceQueryClass = undefined;
         this.queryRefinementStage = query_property_interface_1.LegalRefinementStage.Single;
     }
@@ -199,5 +182,5 @@ class Joins extends definition_list_1.DefinitionList {
         }
     }
 }
-exports.Joins = Joins;
-//# sourceMappingURL=joins.js.map
+exports.JoinStatement = JoinStatement;
+//# sourceMappingURL=join.js.map

package/dist/lang/ast/source-query-elements/sq-reference.js

@@ -27,6 +27,7 @@ const source_query_element_1 = require("./source-query-element");
 const query_source_1 = require("../source-elements/query-source");
 const named_source_1 = require("../source-elements/named-source");
 const query_reference_1 = require("../query-elements/query-reference");
+const model_1 = require("../../../model");
 /**
  * A reference to either a source or a query.
  *
@@ -51,7 +52,7 @@ class SQReference extends source_query_element_1.SourceQueryElement {
                 return query;
             }
             else {
-                this.sqLog(`cannot-use-${entry.type}-as-query`, `Illegal reference to '${entry.as || entry.name}', query expected`);
+                this.sqLog('cannot-use-as-query', `Illegal reference to '${entry.as || entry.name}', query expected`);
             }
         }
         else {
@@ -61,8 +62,8 @@ class SQReference extends source_query_element_1.SourceQueryElement {
         return;
     }
     isSource() {
-        var _a;
-        return ((_a = this.ref.getNamed()) === null || _a === void 0 ? void 0 : _a.type) === 'struct';
+        const refTo = this.ref.getNamed();
+        return refTo !== undefined && (0, model_1.modelObjIsSource)(refTo);
     }
     getSource() {
         if (this.asSource) {
@@ -81,11 +82,11 @@ class SQReference extends source_query_element_1.SourceQueryElement {
             const existingQuery = new query_reference_1.QueryReference(this.ref);
             this.asSource = new query_source_1.QuerySource(existingQuery);
         }
-        else if (entry.type === 'struct') {
+        else if ((0, model_1.modelObjIsSource)(entry)) {
             this.asSource = new named_source_1.NamedSource(this.ref, undefined, this.args);
         }
         else {
-            this.sqLog(`cannot-use-${entry.type}-as-source`, `Expected '${this.ref.refString}' to be of type query or source, not '${entry.type}'`);
+            this.sqLog('cannot-use-struct-as-source', `Expected '${this.ref.refString}' to be of type query or source, not '${entry.type}'`);
             return;
         }
         this.has({ asSource: this.asSource });

package/dist/lang/ast/sql-elements/sql-string.d.ts

@@ -1,4 +1,4 @@
-import { SQLPhrase } from '../../../model/malloy_types';
+import { SQLPhraseSegment } from '../../../model/malloy_types';
 import { MalloyElement } from '../types/malloy-element';
 import { SourceQueryElement } from '../source-query-elements/source-query-element';
 type SQLStringSegment = string | SourceQueryElement;
@@ -8,6 +8,6 @@ export declare class SQLString extends MalloyElement {
     containsQueries: boolean;
     complete(): void;
     push(el: string | MalloyElement): void;
-    sqlPhrases(): SQLPhrase[];
+    sqlPhrases(): SQLPhraseSegment[];
 }
 export {};

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

@@ -56,7 +56,7 @@ class DefineSource extends malloy_element_1.MalloyElement {
             const parameters = this.deduplicatedParameters();
             const structDef = theSource.withParameters(undefined, this.parameters);
             this.validateParameterShadowing(parameters, structDef);
-            if (error_factory_1.ErrorFactory.isErrorStructDef(structDef)) {
+            if (error_factory_1.ErrorFactory.didCreate(structDef)) {
                 return;
             }
             const entry = {

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

@@ -1,5 +1,5 @@
-import { FieldDef, PipeSegment, StructDef } from '../../model/malloy_types';
+import { FieldDef, PipeSegment, SourceDef, StructDef } from '../../model/malloy_types';
 import { MalloyElement } from './types/malloy-element';
-export declare function opOutputStruct(logTo: MalloyElement, inputStruct: StructDef, opDesc: PipeSegment): StructDef;
-export declare function getFinalStruct(logTo: MalloyElement, walkStruct: StructDef, pipeline: PipeSegment[]): StructDef;
+export declare function opOutputStruct(logTo: MalloyElement, inputStruct: SourceDef, opDesc: PipeSegment): SourceDef;
+export declare function getFinalStruct(logTo: MalloyElement, walkStruct: SourceDef, pipeline: PipeSegment[]): SourceDef;
 export declare function getStructFieldDef(s: StructDef, fn: string): FieldDef | undefined;

package/dist/lang/ast/struct-utils.js

@@ -28,7 +28,7 @@ const malloy_query_1 = require("../../model/malloy_query");
 const malloy_types_1 = require("../../model/malloy_types");
 const error_factory_1 = require("./error-factory");
 function opOutputStruct(logTo, inputStruct, opDesc) {
-    const badModel = error_factory_1.ErrorFactory.isErrorStructDef(inputStruct) || (0, malloy_types_1.structHasErrors)(inputStruct);
+    const badModel = error_factory_1.ErrorFactory.didCreate(inputStruct) || (0, malloy_types_1.structHasErrors)(inputStruct);
     // We don't want to expose partial segments to the compiler
     if ((0, malloy_types_1.isPartialSegment)(opDesc)) {
         opDesc = { ...opDesc, type: 'reduce' };
@@ -37,14 +37,23 @@ function opOutputStruct(logTo, inputStruct, opDesc) {
     // Don't call into the model code with a broken model
     if (!badModel && !badOpDesc) {
         try {
-            return malloy_query_1.Segment.nextStructDef(inputStruct, opDesc);
+            const pipeOutputStruct = malloy_query_1.Segment.nextStructDef(inputStruct, opDesc);
+            if ((0, malloy_types_1.isSourceDef)(pipeOutputStruct)) {
+                return pipeOutputStruct;
+            }
+            // Inconcievable, a pipe deosnt output a record or an array
+            logTo.logError('failed-to-compute-output-schema', 'INTERNAL ERROR model/Segment.nextStructDef: RETURNED A NON SOURCE\n' +
+                `STRUCTDEF: ${(0, util_1.inspect)(pipeOutputStruct, {
+                    breakLength: 72,
+                    depth: Infinity,
+                })}`);
         }
         catch (e) {
             logTo.logError('failed-to-compute-output-schema', `INTERNAL ERROR model/Segment.nextStructDef: ${e.message}\n` +
                 `QUERY: ${(0, util_1.inspect)(opDesc, { breakLength: 72, depth: Infinity })}`);
         }
     }
-    return { ...error_factory_1.ErrorFactory.structDef, dialect: inputStruct.dialect };
+    return error_factory_1.ErrorFactory.structDef;
 }
 exports.opOutputStruct = opOutputStruct;
 function getFinalStruct(logTo, walkStruct, pipeline) {

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

@@ -1,10 +1,10 @@
-import { Expr, TimeFieldType, TimestampUnit, FieldValueType, CastType, TypecastExpr, TimeDeltaExpr } from '../../model/malloy_types';
+import { Expr, TemporalFieldType, TimestampUnit, FieldValueType, CastType, TypecastExpr, TimeDeltaExpr } from '../../model/malloy_types';
 import { TimeResult } from './types/time-result';
-export declare function timeOffset(timeType: TimeFieldType, from: Expr, op: '+' | '-', n: Expr, timeframe: TimestampUnit): TimeDeltaExpr;
+export declare function timeOffset(timeType: TemporalFieldType, from: Expr, op: '+' | '-', n: Expr, timeframe: TimestampUnit): TimeDeltaExpr;
 export declare function castTo(castType: CastType | {
     raw: string;
 }, from: Expr, fromType: FieldValueType, safe?: boolean): TypecastExpr;
 export declare function castTimestampToDate(from: Expr, safe?: boolean): TypecastExpr;
 export declare function castDateToTimestamp(from: Expr, safe?: boolean): TypecastExpr;
-export declare function resolution(timeframe: string): TimeFieldType;
+export declare function resolution(timeframe: string): TemporalFieldType;
 export declare function timeResult(t: TimeResult, tt: TimestampUnit | undefined): TimeResult;

package/dist/lang/ast/types/document-compile-result.d.ts

@@ -1,8 +1,8 @@
-import { ModelDef, Query, SQLBlockStructDef } from '../../../model/malloy_types';
+import { ModelDef, Query, SQLSourceDef } from '../../../model/malloy_types';
 import { ModelDataRequest } from '../../translate-response';
 export interface DocumentCompileResult {
     modelDef: ModelDef;
     queryList: Query[];
-    sqlBlocks: SQLBlockStructDef[];
+    sqlBlocks: SQLSourceDef[];
     needs: ModelDataRequest;
 }

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

@@ -116,7 +116,7 @@ class ExprDuration extends ExpressionDef {
     apply(fs, op, left) {
         const lhs = left.getExpression(fs);
         this.typeCheck(this, lhs);
-        if ((0, malloy_types_1.isTimeFieldType)(lhs.dataType) && (op === '+' || op === '-')) {
+        if ((0, malloy_types_1.isTemporalField)(lhs.dataType) && (op === '+' || op === '-')) {
             const num = this.n.getExpression(fs);
             if (!fragtype_utils_1.FT.typeEq(num, fragtype_utils_1.FT.numberT)) {
                 this.logError('invalid-duration-quantity', `Duration quantity needs number not '${num.dataType}`);
@@ -182,8 +182,8 @@ function getMorphicValue(mv, mt) {
 }
 exports.getMorphicValue = getMorphicValue;
 function timeCompare(left, lhs, op, rhs) {
-    const leftIsTime = (0, malloy_types_1.isTimeFieldType)(lhs.dataType);
-    const rightIsTime = (0, malloy_types_1.isTimeFieldType)(rhs.dataType);
+    const leftIsTime = (0, malloy_types_1.isTemporalField)(lhs.dataType);
+    const rightIsTime = (0, malloy_types_1.isTemporalField)(rhs.dataType);
     const node = (0, binary_operators_1.getExprNode)(op);
     if (leftIsTime && rightIsTime) {
         if (lhs.dataType !== rhs.dataType) {
@@ -349,7 +349,7 @@ function delta(fs, left, op, right) {
     if (noGo) {
         return noGo;
     }
-    const timeLHS = (0, malloy_types_1.isTimeFieldType)(lhs.dataType);
+    const timeLHS = (0, malloy_types_1.isTemporalField)(lhs.dataType);
     const err = errorCascade(timeLHS ? 'error' : 'number', lhs, rhs);
     if (err)
         return err;

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

@@ -1,5 +1,5 @@
 import { Dialect } from '../../../dialect/dialect';
-import { StructDef } from '../../../model/malloy_types';
+import { SourceDef, StructDef } from '../../../model/malloy_types';
 import { QueryOperationSpace } from '../field-space/query-spaces';
 import { LookupResult } from './lookup-result';
 import { MalloyElement } from './malloy-element';
@@ -16,11 +16,16 @@ export interface FieldSpace {
     entry(symbol: string): SpaceEntry | undefined;
     entries(): [string, SpaceEntry][];
     dialectObj(): Dialect | undefined;
+    dialectName(): string;
     isQueryFieldSpace(): this is QueryFieldSpace;
 }
-export interface QueryFieldSpace extends FieldSpace {
+export interface SourceFieldSpace extends FieldSpace {
+    structDef(): SourceDef;
+    emptyStructDef(): SourceDef;
+}
+export interface QueryFieldSpace extends SourceFieldSpace {
     outputSpace(): QueryOperationSpace;
-    inputSpace(): FieldSpace;
+    inputSpace(): SourceFieldSpace;
 }
 export declare class FieldName extends MalloyElement {
     readonly name: string;

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

@@ -1,12 +1,15 @@
-import { StructRelationship } from '../../../model';
+import { JoinElementType, JoinType } from '../../../model';
 import { MessageCode } from '../../parse-log';
 import { SpaceEntry } from './space-entry';
+export interface JoinPathElement {
+    name: string;
+    joinElementType: JoinElementType;
+    joinType: JoinType;
+}
+export type JoinPath = JoinPathElement[];
 export interface LookupFound {
     found: SpaceEntry;
-    relationship: {
-        name: string;
-        structRelationship: StructRelationship;
-    }[];
+    joinPath: JoinPath;
     error: undefined;
     isOutputField: boolean;
 }

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

@@ -1,4 +1,4 @@
-import { Annotation, DocumentLocation, DocumentReference, ModelDef, ModelAnnotation, NamedModelObject, Query, SQLBlockStructDef, StructDef } from '../../../model/malloy_types';
+import { Annotation, DocumentLocation, DocumentReference, ModelDef, ModelAnnotation, NamedModelObject, Query, SQLSourceDef, StructDef } from '../../../model/malloy_types';
 import { Tag } from '../../../tags';
 import { LogMessageOptions, MessageLogger, MessageParameterType, MessageCode } from '../../parse-log';
 import { MalloyTranslation } from '../../parse-malloy';
@@ -121,7 +121,7 @@ export declare class Document extends MalloyElement implements NameSpace {
     globalNameSpace: NameSpace;
     documentModel: Record<string, ModelEntry>;
     queryList: Query[];
-    sqlBlocks: SQLBlockStructDef[];
+    sqlBlocks: SQLSourceDef[];
     statements: DocStatementList;
     didInitModel: boolean;
     annotation: Annotation;
@@ -134,7 +134,7 @@ export declare class Document extends MalloyElement implements NameSpace {
     hasAnnotation(): boolean;
     currentModelAnnotation(): ModelAnnotation | undefined;
     modelDef(): ModelDef;
-    defineSQL(sql: SQLBlockStructDef, name?: string): boolean;
+    defineSQL(sql: SQLSourceDef, name?: string): boolean;
     getEntry(str: string): ModelEntry;
     setEntry(str: string, ent: ModelEntry): void;
     /**

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

@@ -120,23 +120,13 @@ class MalloyElement {
                     location: reference.location,
                 });
             }
-            else if ((result === null || result === void 0 ? void 0 : result.entry.type) === 'struct') {
-                if ((0, malloy_types_1.isSQLBlockStruct)(result.entry) && result.entry.declaredSQLBlock) {
-                    this.addReference({
-                        type: 'sqlBlockReference',
-                        text: key,
-                        definition: result.entry,
-                        location: reference.location,
-                    });
-                }
-                else {
-                    this.addReference({
-                        type: 'exploreReference',
-                        text: key,
-                        definition: result.entry,
-                        location: reference.location,
-                    });
-                }
+            else if (result && (0, malloy_types_1.modelObjIsSource)(result.entry)) {
+                this.addReference({
+                    type: 'exploreReference',
+                    text: key,
+                    definition: result.entry,
+                    location: reference.location,
+                });
             }
         }
         return result;
@@ -462,7 +452,7 @@ class Document extends MalloyElement {
             }
             for (const [nm, orig] of Object.entries(extendingModelDef.contents)) {
                 const entry = structuredClone(orig);
-                if (entry.type === 'struct' ||
+                if ((0, malloy_types_1.modelObjIsSource)(entry) ||
                     entry.type === 'query' ||
                     entry.type === 'function') {
                     const exported = extendingModelDef.exports.includes(nm);
@@ -521,7 +511,7 @@ class Document extends MalloyElement {
         }
         for (const entry in this.documentModel) {
             const entryDef = this.documentModel[entry].entry;
-            if (entryDef.type === 'struct' || entryDef.type === 'query') {
+            if ((0, malloy_types_1.modelObjIsSource)(entryDef) || entryDef.type === 'query') {
                 if (this.documentModel[entry].exported) {
                     def.exports.push(entry);
                 }
@@ -538,7 +528,6 @@ class Document extends MalloyElement {
         const ret = {
             ...sql,
             as: `$${this.sqlBlocks.length}`,
-            declaredSQLBlock: true,
         };
         if (name) {
             if (this.getEntry(name)) {
@@ -559,7 +548,7 @@ class Document extends MalloyElement {
         if (this.globalNameSpace.getEntry(str) !== undefined) {
             this.logError('name-conflict-with-global', `Cannot redefine '${str}', which is in global namespace`);
         }
-        if (ent.entry.type === 'struct') {
+        if ((0, malloy_types_1.modelObjIsSource)(ent.entry)) {
             this.checkExperimentalDialect(this, ent.entry.dialect);
         }
         this.documentModel[str] = ent;

package/dist/lang/ast/types/op-desc.d.ts

@@ -1,6 +1,6 @@
 import { PipeSegment } from '../../../model/malloy_types';
-import { FieldSpace } from './field-space';
+import { SourceFieldSpace } from './field-space';
 export interface OpDesc {
     segment: PipeSegment;
-    outputSpace: () => FieldSpace;
+    outputSpace: () => SourceFieldSpace;
 }

package/dist/lang/ast/types/pipeline-comp.d.ts

@@ -1,6 +1,6 @@
-import { Annotation, PipeSegment, StructDef } from '../../../model/malloy_types';
+import { Annotation, PipeSegment, SourceDef } from '../../../model/malloy_types';
 export interface PipelineComp {
-    outputStruct: StructDef;
+    outputStruct: SourceDef;
     pipeline: PipeSegment[];
     annotation?: Annotation;
     name?: string;

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

@@ -1,6 +1,6 @@
-import { Query, StructDef } from '../../../model/malloy_types';
+import { Query, SourceDef } from '../../../model/malloy_types';
 export interface QueryComp {
-    outputStruct: StructDef;
+    outputStruct: SourceDef;
     query: Query;
-    inputStruct: StructDef;
+    inputStruct: SourceDef;
 }

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

@@ -1,6 +1,5 @@
 import { Dimensions } from '../source-properties/dimensions';
-import { Joins } from '../source-properties/joins';
 import { Measures } from '../source-properties/measures';
 import { MalloyElement } from './malloy-element';
-export type QueryExtendProperty = Dimensions | Measures | Joins;
+export type QueryExtendProperty = Dimensions | Measures;
 export declare function isQueryExtendProperty(q: MalloyElement): q is QueryExtendProperty;

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

@@ -24,10 +24,12 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isQueryExtendProperty = void 0;
 const dimensions_1 = require("../source-properties/dimensions");
-const joins_1 = require("../source-properties/joins");
+const join_1 = require("../source-properties/join");
 const measures_1 = require("../source-properties/measures");
 function isQueryExtendProperty(q) {
-    return q instanceof dimensions_1.Dimensions || q instanceof measures_1.Measures || q instanceof joins_1.Joins;
+    return (q instanceof dimensions_1.Dimensions ||
+        q instanceof measures_1.Measures ||
+        q instanceof join_1.JoinStatement);
 }
 exports.isQueryExtendProperty = isQueryExtendProperty;
 //# sourceMappingURL=query-extend-property.js.map

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

@@ -1,5 +1,4 @@
 import { Filter } from '../query-properties/filters';
-import { Joins } from '../source-properties/joins';
 import { DeclareFields } from '../query-properties/declare-fields';
 import { FieldListEdit } from '../source-properties/field-list-edit';
 import { Renames } from '../source-properties/renames';
@@ -8,5 +7,6 @@ import { Views } from '../source-properties/views';
 import { MalloyElement } from './malloy-element';
 import { TimezoneStatement } from '../source-properties/timezone-statement';
 import { ObjectAnnotation } from './annotation-elements';
-export type SourceProperty = Filter | Joins | DeclareFields | FieldListEdit | Renames | PrimaryKey | ObjectAnnotation | Views | TimezoneStatement;
+import { JoinStatement } from '../source-properties/join';
+export type SourceProperty = Filter | JoinStatement | DeclareFields | FieldListEdit | Renames | PrimaryKey | ObjectAnnotation | Views | TimezoneStatement;
 export declare function isSourceProperty(p: MalloyElement): p is SourceProperty;

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

@@ -24,7 +24,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isSourceProperty = void 0;
 const filters_1 = require("../query-properties/filters");
-const joins_1 = require("../source-properties/joins");
 const declare_fields_1 = require("../query-properties/declare-fields");
 const field_list_edit_1 = require("../source-properties/field-list-edit");
 const renames_1 = require("../source-properties/renames");
@@ -32,9 +31,10 @@ const primary_key_1 = require("../source-properties/primary-key");
 const views_1 = require("../source-properties/views");
 const timezone_statement_1 = require("../source-properties/timezone-statement");
 const annotation_elements_1 = require("./annotation-elements");
+const join_1 = require("../source-properties/join");
 function isSourceProperty(p) {
     return (p instanceof filters_1.Filter ||
-        p instanceof joins_1.Joins ||
+        p instanceof join_1.JoinStatement ||
         p instanceof declare_fields_1.DeclareFields ||
         p instanceof field_list_edit_1.FieldListEdit ||
         p instanceof renames_1.Renames ||

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

@@ -1,10 +1,17 @@
-import { FieldDef, QueryFieldDef, TypeDesc } from '../../../model/malloy_types';
+import { FieldDef, QueryFieldDef, TypeDesc, AtomicFieldDef } from '../../../model/malloy_types';
 import { SpaceEntry } from './space-entry';
 import { FieldSpace } from './field-space';
 export declare abstract class SpaceField extends SpaceEntry {
     readonly refType = "field";
-    haveFieldDef?: FieldDef;
-    protected fieldTypeFromFieldDef(def: FieldDef): TypeDesc;
+    protected fieldTypeFromFieldDef(def: AtomicFieldDef): TypeDesc;
     getQueryFieldDef(_fs: FieldSpace): QueryFieldDef | undefined;
     fieldDef(): FieldDef | undefined;
+    /**
+     * Called by field reference code generation to gain access to the
+     * annotation properties on the field being referenced. ColumnSpaceFields
+     * will have the original field def, and will implement this method,
+     * nothing else should be referencable, but if somehow one of those is
+     * referenced, don't bother to compute the fieldDef.
+     */
+    constructorFieldDef(): FieldDef | undefined;
 }

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

@@ -23,7 +23,6 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SpaceField = void 0;
-const malloy_types_1 = require("../../../model/malloy_types");
 const space_entry_1 = require("./space-entry");
 class SpaceField extends space_entry_1.SpaceEntry {
     constructor() {
@@ -36,7 +35,7 @@ class SpaceField extends space_entry_1.SpaceEntry {
             expressionType: 'scalar',
             evalSpace: 'input',
         };
-        if ((0, malloy_types_1.isFieldTypeDef)(def) && def.expressionType) {
+        if (def.expressionType) {
             ref.expressionType = def.expressionType;
         }
         if (ref.dataType === 'sql native' &&
@@ -52,6 +51,16 @@ class SpaceField extends space_entry_1.SpaceEntry {
     fieldDef() {
         return undefined;
     }
+    /**
+     * Called by field reference code generation to gain access to the
+     * annotation properties on the field being referenced. ColumnSpaceFields
+     * will have the original field def, and will implement this method,
+     * nothing else should be referencable, but if somehow one of those is
+     * referenced, don't bother to compute the fieldDef.
+     */
+    constructorFieldDef() {
+        return undefined;
+    }
 }
 exports.SpaceField = SpaceField;
 //# sourceMappingURL=space-field.js.map

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

@@ -1,6 +1,6 @@
-import { TimeFieldType, TimestampUnit } from '../../../model/malloy_types';
+import { TemporalFieldType, TimestampUnit } from '../../../model/malloy_types';
 import { ExprResult } from './expr-result';
 export interface TimeResult extends ExprResult {
-    dataType: TimeFieldType;
+    dataType: TemporalFieldType;
     timeframe?: TimestampUnit;
 }