@malloydata/malloy 0.0.22-dev230119001546 → 0.0.22-dev230119193053

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

@@ -1,6 +1,5 @@
 import { By, ExpressionType } from "../../model/malloy_types";
-import { FieldSpace } from "../field-space";
-import { BinaryBoolean, ExpressionDef, ExprCompare, FieldName, FieldReference, Filter, MalloyElement } from "./ast-main";
+import { BinaryBoolean, ExpressionDef, ExprCompare, FieldName, FieldReference, FieldSpace, Filter, MalloyElement } from "./ast-main";
 import { ExprValue, FieldValueType, FragType } from "./ast-types";
 export declare class ExprString extends ExpressionDef {
     elementType: string;

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

@@ -28,11 +28,9 @@ exports.Apply = exports.Pick = exports.PickWhen = exports.TopBy = exports.ExprCa
  ** evaluation.
  */
 const malloy_types_1 = require("../../model/malloy_types");
-const field_space_1 = require("../field-space");
 const ast_main_1 = require("./ast-main");
 const ast_types_1 = require("./ast-types");
 const apply_expr_1 = require("./apply-expr");
-const space_field_1 = require("../space-field");
 const time_utils_1 = require("./time-utils");
 class ExprString extends ast_main_1.ExpressionDef {
     constructor(src) {
@@ -154,7 +152,7 @@ class ExprIdReference extends ast_main_1.ExpressionDef {
     }
     apply(fs, op, expr) {
         const entry = this.fieldReference.getField(fs).found;
-        if (entry instanceof space_field_1.SpaceParam) {
+        if (entry instanceof ast_main_1.SpaceParam) {
             const cParam = entry.parameter();
             if ((0, malloy_types_1.isConditionParameter)(cParam)) {
                 const lval = expr.getExpression(fs);
@@ -306,7 +304,7 @@ class ExprAggregateFunction extends ast_main_1.ExpressionDef {
                     structPath = this.source.sourceString;
                 }
                 else {
-                    if (!(sourceFoot instanceof space_field_1.StructSpaceField)) {
+                    if (!(sourceFoot instanceof ast_main_1.StructSpaceField)) {
                         this.log(`Aggregate source cannot be a ${footType.type}`);
                         return (0, ast_types_1.errorFor)(`Aggregate source cannot be a ${footType.type}`);
                     }
@@ -456,10 +454,10 @@ class ExprUngroup extends ast_main_1.ExpressionDef {
         if (this.typeCheck(this.expr, { ...exprVal, expressionType: "scalar" })) {
             if (this.fields.length > 0) {
                 let qs = fs;
-                if (fs instanceof field_space_1.DefSpace) {
+                if (fs instanceof ast_main_1.DefSpace) {
                     qs = fs.realFS;
                 }
-                if (!(qs instanceof field_space_1.QuerySpace)) {
+                if (!(qs instanceof ast_main_1.QuerySpace)) {
                     this.log(`${this.control}() must be in a query -- weird internal error`);
                     return (0, ast_types_1.errorFor)("ungroup query check");
                 }

package/dist/lang/ast/ast-main.d.ts

@@ -1,8 +1,8 @@
 import * as model from "../../model/malloy_types";
+import { Dialect } from "../../dialect/dialect";
 import { AtomicFieldType, ExpressionType, FieldTypeDef, Fragment, TimeFieldType, TimestampUnit } from "../../model/malloy_types";
-import { FieldSpace, QuerySpace, LookupResult } from "../field-space";
 import { MalloyTranslation, ModelDataRequest } from "../parse-malloy";
-import { Comparison, ExprValue } from "./ast-types";
+import { Comparison, ExprValue, FieldValueType } from "./ast-types";
 export declare class ErrorFactory {
     static get structDef(): model.StructDef;
     static isErrorStructDef(s: model.StructDef): boolean;
@@ -658,4 +658,258 @@ export declare class Range extends ExpressionDef {
     requestExpression(_fs: FieldSpace): ExprValue | undefined;
     getExpression(_fs: FieldSpace): ExprValue;
 }
+/**
+ * A FieldSpace is a hierarchy of namespaces, where the leaf nodes
+ * are fields. A FieldSpace can lookup fields, and generate a StructDef
+ */
+export interface FieldSpace {
+    type: "fieldSpace";
+    structDef(): model.StructDef;
+    emptyStructDef(): model.StructDef;
+    lookup(symbol: FieldName[]): LookupResult;
+    dialectObj(): Dialect | undefined;
+    whenComplete: (step: () => void) => void;
+}
+/**
+ * Used to detect references to fields in the statement which defines them
+ */
+export declare class DefSpace implements FieldSpace {
+    readonly realFS: FieldSpace;
+    readonly circular: FieldDeclaration;
+    readonly type = "fieldSpace";
+    foundCircle: boolean;
+    constructor(realFS: FieldSpace, circular: FieldDeclaration);
+    structDef(): model.StructDef;
+    emptyStructDef(): model.StructDef;
+    lookup(symbol: FieldName[]): LookupResult;
+    dialectObj(): Dialect | undefined;
+    whenComplete(step: () => void): void;
+}
+export declare class StaticSpace implements FieldSpace {
+    readonly type = "fieldSpace";
+    private memoMap?;
+    protected fromStruct: model.StructDef;
+    constructor(sourceStructDef: model.StructDef);
+    whenComplete(step: () => void): void;
+    dialectObj(): Dialect | undefined;
+    fromFieldDef(from: model.FieldDef): SpaceField;
+    private get map();
+    protected dropEntries(): void;
+    protected dropEntry(name: string): void;
+    protected entry(name: string): SpaceEntry | undefined;
+    protected setEntry(name: string, value: SpaceEntry): void;
+    protected entries(): [string, SpaceEntry][];
+    structDef(): model.StructDef;
+    emptyStructDef(): model.StructDef;
+    lookup(path: FieldName[]): LookupResult;
+}
+/**
+ * A FieldSpace which may undergo modification
+ */
+export declare class DynamicSpace extends StaticSpace {
+    protected final: model.StructDef | undefined;
+    protected source: SpaceSeed;
+    outputFS?: QuerySpace;
+    completions: (() => void)[];
+    private complete;
+    constructor(extending: SourceSpec);
+    /**
+     * Factory for DynamicSpace when there are accept/except edits
+     * @param from A structdef which seeds this space
+     * @param choose A accept/except edit of the "from" fields
+     */
+    static filteredFrom(from: model.StructDef, choose?: FieldListEdit): DynamicSpace;
+    whenComplete(finalizeStep: () => void): void;
+    isComplete(): void;
+    protected setEntry(name: string, value: SpaceEntry): void;
+    addParameters(params: HasParameter[]): DynamicSpace;
+    newEntry(name: string, astEl: MalloyElement, entry: SpaceEntry): void;
+    addField(...defs: ExploreField[]): void;
+    addFieldDef(fd: model.FieldDef): void;
+    structDef(): model.StructDef;
+}
+export declare abstract class ResultSpace extends DynamicSpace {
+    readonly queryInputSpace: FieldSpace;
+    readonly exprSpace: QuerySpace;
+    astEl?: MalloyElement | undefined;
+    abstract readonly segmentType: "reduce" | "project" | "index";
+    constructor(queryInputSpace: FieldSpace);
+    log(s: string): void;
+    addMembers(members: FieldCollectionMember[]): void;
+    addReference(ref: FieldReference): void;
+    addWild(wild: WildcardFieldReference): void;
+    /**
+     * Check for the definition of an ungrouping reference in the result space,
+     * or in the case of an exclude reference, if this query is nested
+     * in another query, in the result space of a query that this query
+     * is nested inside of.
+     */
+    checkUngroup(fn: FieldName, isExclude: boolean): void;
+    addQueryItems(...qiList: QueryItem[]): void;
+    canContain(_qd: model.QueryFieldDef): boolean;
+    protected queryFieldDefs(): model.QueryFieldDef[];
+    getQuerySegment(rf: model.QuerySegment | undefined): model.QuerySegment;
+    getPipeSegment(refineFrom: model.QuerySegment | undefined): model.PipeSegment;
+}
+/**
+ * Reduce and project queries use a "QuerySpace"
+ */
+export declare class ReduceFieldSpace extends ResultSpace {
+    readonly segmentType = "reduce";
+}
+export declare class ProjectFieldSpace extends ResultSpace {
+    readonly segmentType = "project";
+    canContain(qd: model.QueryFieldDef): boolean;
+}
+export declare abstract class SpaceEntry {
+    abstract type(): FieldType;
+    abstract refType: "field" | "parameter";
+}
+export declare abstract class SpaceField extends SpaceEntry {
+    readonly refType = "field";
+    protected fieldTypeFromFieldDef(def: model.FieldDef): FieldType;
+    getQueryFieldDef(_fs: FieldSpace): model.QueryFieldDef | undefined;
+    fieldDef(): model.FieldDef | undefined;
+}
+export interface FieldType {
+    type: FieldValueType;
+    expressionType?: model.ExpressionType;
+}
+export declare class StructSpaceField extends SpaceField {
+    protected sourceDef: model.StructDef;
+    protected space?: FieldSpace;
+    constructor(sourceDef: model.StructDef);
+    get fieldSpace(): FieldSpace;
+    fieldDef(): model.FieldDef;
+    type(): FieldType;
+}
+export declare abstract class QueryField extends SpaceField {
+    protected inSpace: FieldSpace;
+    constructor(inSpace: FieldSpace);
+    abstract getQueryFieldDef(fs: FieldSpace): model.QueryFieldDef | undefined;
+    abstract fieldDef(): model.FieldDef;
+    type(): FieldType;
+}
+export declare class QueryFieldStruct extends QueryField {
+    protected turtleDef: model.TurtleDef;
+    constructor(fs: FieldSpace, turtleDef: model.TurtleDef);
+    rename(name: string): void;
+    fieldDef(): model.TurtleDef;
+    getQueryFieldDef(_fs: FieldSpace): model.QueryFieldDef | undefined;
+}
+export declare class ColumnSpaceField extends SpaceField {
+    protected def: model.FieldTypeDef;
+    constructor(def: model.FieldTypeDef);
+    fieldDef(): model.FieldDef;
+    type(): FieldType;
+}
+export declare abstract class SpaceParam extends SpaceEntry {
+    abstract parameter(): model.Parameter;
+    readonly refType = "parameter";
+}
+export declare class DefinedParameter extends SpaceParam {
+    readonly paramDef: model.Parameter;
+    constructor(paramDef: model.Parameter);
+    parameter(): model.Parameter;
+    type(): FieldType;
+}
+/**
+ * Based on how things are constructed, the starting field space
+ * can either be another field space or an existing structdef.
+ * Using a SpaceSeed allows a class to accept either one
+ * and use either version at some future time.
+ */
+export declare class SpaceSeed {
+    readonly sourceSpec: SourceSpec;
+    private spaceSpec;
+    private asFS?;
+    private asStruct?;
+    constructor(sourceSpec: SourceSpec);
+    get structDef(): model.StructDef;
+    get fieldSpace(): FieldSpace;
+}
+export declare type SourceSpec = model.StructDef | FieldSpace;
+export declare class AbstractParameter extends SpaceParam {
+    readonly astParam: HasParameter;
+    constructor(astParam: HasParameter);
+    parameter(): model.Parameter;
+    type(): FieldType;
+}
+export declare class ExpressionFieldFromAst extends SpaceField {
+    readonly space: DynamicSpace;
+    readonly exprDef: FieldDeclaration;
+    fieldName: string;
+    defType?: FieldType;
+    constructor(space: DynamicSpace, exprDef: FieldDeclaration);
+    get name(): string;
+    fieldDef(): model.FieldDef;
+    getQueryFieldDef(fs: FieldSpace): model.QueryFieldDef;
+    type(): FieldType;
+}
+export declare class QueryFieldAST extends QueryField {
+    readonly turtle: TurtleDecl;
+    protected name: string;
+    renameAs?: string;
+    nestParent?: QuerySpace;
+    constructor(fs: FieldSpace, turtle: TurtleDecl, name: string);
+    getQueryFieldDef(fs: FieldSpace): model.QueryFieldDef;
+    fieldDef(): model.TurtleDef;
+}
+export declare class RenameSpaceField extends SpaceField {
+    private readonly otherField;
+    private readonly newName;
+    private readonly location;
+    constructor(otherField: SpaceField, newName: string, location: model.DocumentLocation);
+    fieldDef(): model.FieldDef | undefined;
+    type(): FieldType;
+}
+export declare class JoinSpaceField extends StructSpaceField {
+    readonly intoFS: FieldSpace;
+    readonly join: Join;
+    constructor(intoFS: FieldSpace, join: Join);
+}
+/**
+ * Unlike a source, which is a refinement of a namespace, a query
+ * is creating a new unrelated namespace. The query starts with a
+ * source, which it might modify. This set of fields used to resolve
+ * expressions in the query is called the "input space". There is a
+ * specialized QuerySpace for each type of query operation.
+ *
+ * The query output is managed by an instance of ResultSpace.
+ */
+export declare class QuerySpace extends DynamicSpace {
+    readonly result: ResultSpace;
+    nestParent?: QuerySpace;
+    extendList: string[];
+    constructor(input: SourceSpec, result: ResultSpace);
+    extendSource(extendField: Join | FieldDeclaration): void;
+}
+export declare class ReferenceField extends SpaceField {
+    readonly fieldRef: FieldReference;
+    constructor(fieldRef: FieldReference);
+    getQueryFieldDef(fs: FieldSpace): model.QueryFieldDef | undefined;
+    type(): FieldType;
+}
+export declare class WildSpaceField extends SpaceField {
+    readonly wildText: string;
+    constructor(wildText: string);
+    type(): FieldType;
+    getQueryFieldDef(_fs: FieldSpace): model.QueryFieldDef;
+}
+interface LookupFound {
+    found: SpaceEntry;
+    error: undefined;
+}
+interface LookupError {
+    error: string;
+    found: undefined;
+}
+export declare type LookupResult = LookupFound | LookupError;
+export declare class IndexFieldSpace extends ResultSpace {
+    readonly segmentType = "index";
+    fieldList: Set<string>;
+    addReference(ref: FieldReference): void;
+    addWild(wild: WildcardFieldReference): void;
+    getPipeSegment(refineIndex?: model.PipeSegment): model.IndexSegment;
+}
 export {};