@malloydata/malloy 0.0.303 → 0.0.305

package/dist/model/field_instance.d.ts

@@ -0,0 +1,108 @@
+import type { QueryInfo } from '../dialect';
+import type { QueryStruct } from './query_node';
+import type { Expr, OrderBy, PipeSegment, TurtleDef, UniqueKeyRequirement } from './malloy_types';
+import { AndChain, type GenerateState } from './utils';
+import { JoinInstance } from './join_instance';
+import { type QueryField } from './query_node';
+import type * as Malloy from '@malloydata/malloy-interfaces';
+type InstanceFieldUsage = {
+    type: 'result';
+    resultIndex: number;
+} | {
+    type: 'where';
+} | {
+    type: 'dependant';
+};
+export declare class FieldInstanceField implements FieldInstance {
+    f: QueryField;
+    fieldUsage: InstanceFieldUsage;
+    parent: FieldInstanceResult;
+    readonly drillExpression: Malloy.Expression | undefined;
+    type: FieldInstanceType;
+    additionalGroupSets: number[];
+    analyticalSQL: string | undefined;
+    partitionSQL: string | undefined;
+    constructor(f: QueryField, fieldUsage: InstanceFieldUsage, parent: FieldInstanceResult, drillExpression: Malloy.Expression | undefined);
+    root(): FieldInstanceResultRoot;
+    static exprCompiler?: (field: QueryField, resultSet: FieldInstanceResult, context: QueryStruct, expr: Expr, state?: GenerateState) => string;
+    static registerExpressionCompiler(compiler: (field: QueryField, resultSet: FieldInstanceResult, context: QueryStruct, expr: Expr, state?: GenerateState) => string): void;
+    getSQL(): string;
+    generateExpression(): string;
+    private generateDistinctKeyExpression;
+    getAnalyticalSQL(forPartition: boolean): string;
+}
+type RepeatedResultType = 'nested' | 'inline_all_numbers' | 'inline';
+export type UngroupSet = {
+    type: 'all' | 'exclude';
+    fields: string[];
+    groupSet: number;
+};
+export declare class FieldInstanceResult implements FieldInstance {
+    turtleDef: TurtleDef;
+    parent: FieldInstanceResult | undefined;
+    type: FieldInstanceType;
+    allFields: Map<string, FieldInstance>;
+    groupSet: number;
+    depth: number;
+    childGroups: number[];
+    firstSegment: PipeSegment;
+    hasHaving: boolean;
+    ungroupedSets: Map<string, UngroupSet>;
+    resultUsesUngrouped: boolean;
+    constructor(turtleDef: TurtleDef, parent: FieldInstanceResult | undefined);
+    getLimit(): number | undefined;
+    /**
+     * Information about the query containing this result set. Invented
+     * to pass on timezone information, but maybe more things will
+     * eventually go in here.
+     * @returns QueryInfo
+     */
+    getQueryInfo(): QueryInfo;
+    addField(as: string, field: QueryField, usage: InstanceFieldUsage, drillExpression: Malloy.Expression | undefined): void;
+    parentGroupSet(): number;
+    add(name: string, f: FieldInstance): void;
+    hasField(name: string): boolean;
+    getField(name: string): FieldInstanceField;
+    getFieldByNumber(index: number): {
+        name: string;
+        fif: FieldInstanceField;
+    };
+    computeGroups(nextGroupSetNumber: number, depth: number): {
+        nextGroupSetNumber: number;
+        maxDepth: number;
+        children: number[];
+        isComplex: boolean;
+    };
+    fields(fn?: undefined | ((field: FieldInstanceField) => boolean)): FieldInstanceField[];
+    fieldNames(fn: undefined | ((field: FieldInstanceField) => boolean)): string[];
+    getRepeatedResultType(): RepeatedResultType;
+    structs(): FieldInstanceResult[];
+    selectStructs(result: FieldInstanceResult[], fn: (result: FieldInstanceResult) => boolean): FieldInstanceResult[];
+    calculateDefaultOrderBy(): OrderBy[];
+    addStructToJoin(qs: QueryStruct, uniqueKeyRequirement: UniqueKeyRequirement): void;
+    root(): FieldInstanceResultRoot;
+    getUngroupPartitions(ungroupSet: UngroupSet | undefined): FieldInstanceField[];
+    assignFieldsToGroups(): void;
+}
+type FieldInstanceType = 'field' | 'query';
+export interface FieldInstance {
+    type: FieldInstanceType;
+    root(): FieldInstanceResultRoot;
+}
+export declare class FieldInstanceResultRoot extends FieldInstanceResult {
+    joins: Map<string, JoinInstance>;
+    havings: AndChain;
+    isComplexQuery: boolean;
+    queryUsesPartitioning: boolean;
+    computeOnlyGroups: number[];
+    elimatedComputeGroups: boolean;
+    constructor(turtleDef: TurtleDef);
+    root(): FieldInstanceResultRoot;
+    eliminateComputeGroupsSQL(): string;
+    calculateSymmetricAggregates(): void;
+}
+export declare function sqlFullChildReference(struct: QueryStruct, name: string, expand: {
+    result: FieldInstanceResult;
+    field: QueryField;
+} | undefined): string;
+export {};

package/dist/model/field_instance.js

@@ -0,0 +1,520 @@
+"use strict";
+/*
+ * Copyright Contributors to the Malloy project
+ * SPDX-License-Identifier: MIT
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FieldInstanceResultRoot = exports.FieldInstanceResult = exports.FieldInstanceField = void 0;
+exports.sqlFullChildReference = sqlFullChildReference;
+const malloy_types_1 = require("./malloy_types");
+const utils_1 = require("./utils");
+const join_instance_1 = require("./join_instance");
+const query_node_1 = require("./query_node");
+class FieldInstanceField {
+    constructor(f, fieldUsage, parent, drillExpression) {
+        this.f = f;
+        this.fieldUsage = fieldUsage;
+        this.parent = parent;
+        this.drillExpression = drillExpression;
+        this.type = 'field';
+        this.additionalGroupSets = [];
+    }
+    root() {
+        return this.parent.root();
+    }
+    static registerExpressionCompiler(compiler) {
+        FieldInstanceField.exprCompiler = compiler;
+    }
+    getSQL() {
+        let exp = this.generateExpression(); // Changed from this.f.generateExpression(this.parent)
+        if ((0, query_node_1.isScalarField)(this.f)) {
+            exp = (0, utils_1.caseGroup)(this.parent.groupSet > 0
+                ? this.parent.childGroups.concat(this.additionalGroupSets)
+                : [], exp);
+        }
+        return exp;
+    }
+    generateExpression() {
+        if (!FieldInstanceField.exprCompiler) {
+            throw new Error('Expression compiler not registered with FieldInstanceField');
+        }
+        // Check for distinct key by its characteristic properties
+        if (this.f.fieldDef.type === 'string' &&
+            this.f.fieldDef.name === '__distinct_key') {
+            return this.generateDistinctKeyExpression();
+        }
+        // Normal field expression generation
+        if ((0, malloy_types_1.hasExpression)(this.f.fieldDef)) {
+            return FieldInstanceField.exprCompiler(this.f, this.parent, this.f.parent, this.f.fieldDef.e);
+        }
+        // Walk the tree and compute record aliases if needed
+        for (let ancestor = this.f.parent; ancestor !== undefined; ancestor = ancestor.parent) {
+            if (ancestor.structDef.type === 'record' &&
+                (0, malloy_types_1.hasExpression)(ancestor.structDef) &&
+                ancestor.recordAlias === undefined) {
+                if (!ancestor.parent) {
+                    throw new Error('Inconceivable record ancestor with expression but no parent');
+                }
+                const aliasValue = FieldInstanceField.exprCompiler(this.f, this.parent, ancestor.parent, ancestor.structDef.e);
+                ancestor.informOfAliasValue(aliasValue);
+            }
+        }
+        return sqlFullChildReference(this.f.parent, this.f.fieldDef.name, this.f.parent.structDef.type === 'record'
+            ? {
+                result: this.parent,
+                field: this.f,
+            }
+            : undefined);
+    }
+    generateDistinctKeyExpression() {
+        var _a;
+        if (this.f.parent.primaryKey()) {
+            const pk = this.f.parent.getPrimaryKeyField(this.f.fieldDef);
+            const pkName = pk.fieldDef.as || pk.fieldDef.name;
+            const pkField = this.parent.getField(pkName);
+            return pkField.generateExpression();
+        }
+        else if (this.f.parent.structDef.type === 'array') {
+            const parentDistinctKey = (_a = this.f.parent.parent) === null || _a === void 0 ? void 0 : _a.getDistinctKey();
+            if (parentDistinctKey && this.parent.parent) {
+                const keyField = this.parent.parent.getField('__distinct_key');
+                const parentKeySQL = keyField.generateExpression();
+                return this.f.parent.dialect.sqlMakeUnnestKey(parentKeySQL, this.f.parent.dialect.sqlFieldReference(this.f.parent.getIdentifier(), 'table', '__row_id', 'string'));
+            }
+            return this.f.parent.dialect.sqlMakeUnnestKey('', this.f.parent.dialect.sqlFieldReference(this.f.parent.getIdentifier(), 'table', '__row_id', 'string'));
+        }
+        else {
+            return this.f.parent.dialect.sqlFieldReference(this.f.parent.getIdentifier(), 'table', '__distinct_key', 'string');
+        }
+    }
+    getAnalyticalSQL(forPartition) {
+        if (this.analyticalSQL === undefined) {
+            return this.getSQL();
+        }
+        else if (forPartition && this.partitionSQL) {
+            return this.partitionSQL;
+        }
+        else {
+            return this.analyticalSQL;
+        }
+    }
+}
+exports.FieldInstanceField = FieldInstanceField;
+class FieldInstanceResult {
+    constructor(turtleDef, parent) {
+        this.turtleDef = turtleDef;
+        this.parent = parent;
+        this.type = 'query';
+        this.allFields = new Map();
+        this.groupSet = 0;
+        this.depth = 0;
+        this.childGroups = [];
+        this.hasHaving = false;
+        this.ungroupedSets = new Map();
+        // query: QueryQuery;
+        this.resultUsesUngrouped = false;
+        this.firstSegment = turtleDef.pipeline[0];
+    }
+    // Gets a limit if it has one.
+    getLimit() {
+        if (this.firstSegment.type === 'reduce' ||
+            this.firstSegment.type === 'project') {
+            return this.firstSegment.limit;
+        }
+        else {
+            return undefined;
+        }
+    }
+    /**
+     * Information about the query containing this result set. Invented
+     * to pass on timezone information, but maybe more things will
+     * eventually go in here.
+     * @returns QueryInfo
+     */
+    getQueryInfo() {
+        if (!(0, malloy_types_1.isIndexSegment)(this.firstSegment) &&
+            !(0, malloy_types_1.isRawSegment)(this.firstSegment)) {
+            const { queryTimezone } = this.firstSegment;
+            if (queryTimezone) {
+                return { queryTimezone };
+            }
+        }
+        return {};
+    }
+    addField(as, field, usage, drillExpression) {
+        const fi = this.allFields.get(as);
+        if (fi) {
+            if (fi.type === 'query') {
+                throw new Error(`Redefinition of field ${field.fieldDef.name} as struct`);
+            }
+            const fif = fi;
+            if (fif.fieldUsage.type === 'result') {
+                if (usage.type !== 'result') {
+                    // its already in the result, we can just ignore it.
+                    return;
+                }
+                else {
+                    throw new Error(`Ambiguous output field name '${field.fieldDef.name}'.`);
+                }
+            }
+        }
+        this.add(as, new FieldInstanceField(field, usage, this, drillExpression));
+    }
+    parentGroupSet() {
+        if (this.parent) {
+            return this.parent.groupSet;
+        }
+        else {
+            return 0;
+        }
+    }
+    add(name, f) {
+        this.allFields.set(name, f);
+    }
+    hasField(name) {
+        const fi = this.allFields.get(name);
+        return fi !== undefined && fi instanceof FieldInstanceField;
+    }
+    getField(name) {
+        const fi = this.allFields.get(name);
+        if (fi === undefined) {
+            throw new Error(`Internal Error, field Not defined ${name}`);
+        }
+        else if (fi instanceof FieldInstanceField) {
+            return fi;
+        }
+        throw new Error(`can't use a query here ${name}`);
+    }
+    getFieldByNumber(index) {
+        for (const [name, fi] of this.allFields) {
+            if (fi instanceof FieldInstanceField) {
+                if (fi.fieldUsage.type === 'result' &&
+                    fi.fieldUsage.resultIndex === index) {
+                    return { name, fif: fi };
+                }
+            }
+        }
+        throw new Error(`Invalid Order By index '${index}`);
+    }
+    // loops through all the turtled queries and computes recomputes the group numbers
+    computeGroups(nextGroupSetNumber, depth) {
+        // if the root node uses a total, start at 1.
+        if (nextGroupSetNumber === 0 && this.resultUsesUngrouped) {
+            this.root().computeOnlyGroups.push(nextGroupSetNumber++);
+        }
+        // make a groupset for each unique ungrouping expression
+        for (const [_key, grouping] of this.ungroupedSets) {
+            const groupSet = nextGroupSetNumber++;
+            grouping.groupSet = groupSet;
+            this.root().computeOnlyGroups.push(groupSet);
+        }
+        this.groupSet = nextGroupSetNumber++;
+        this.depth = depth;
+        let maxDepth = depth;
+        let isComplex = false;
+        let children = [this.groupSet];
+        for (const [_name, fi] of this.allFields) {
+            if (fi.type === 'query') {
+                const fir = fi;
+                isComplex = true;
+                if (fir.firstSegment.type === 'reduce') {
+                    const r = fir.computeGroups(nextGroupSetNumber, depth + 1);
+                    children = children.concat(r.children);
+                    nextGroupSetNumber = r.nextGroupSetNumber;
+                    if (r.maxDepth > maxDepth) {
+                        maxDepth = r.maxDepth;
+                    }
+                }
+            }
+        }
+        this.childGroups = children;
+        return { nextGroupSetNumber, maxDepth, children, isComplex };
+    }
+    fields(fn = undefined) {
+        const ret = [];
+        for (const e of this.allFields.values()) {
+            if (e instanceof FieldInstanceField) {
+                if (fn === undefined || fn(e)) {
+                    ret.push(e);
+                }
+            }
+        }
+        return ret;
+    }
+    fieldNames(fn) {
+        const ret = [];
+        for (const [name, fi] of this.allFields) {
+            if (fi instanceof FieldInstanceField) {
+                if (fn === undefined || fn(fi)) {
+                    ret.push(name);
+                }
+            }
+        }
+        return ret;
+    }
+    // if a turtled result is all measures, we emit use ANY_VALUE for the aggregation
+    //  and emit the resulting structure as a RECORD instead of REPEATED
+    //  if we have all numbers, we need to know because we'll have to conjur a record.
+    getRepeatedResultType() {
+        let ret = 'inline_all_numbers';
+        for (const f of this.fields()) {
+            if (f.fieldUsage.type === 'result') {
+                if ((0, query_node_1.isBasicScalar)(f.f)) {
+                    return 'nested';
+                }
+                if (f.f instanceof query_node_1.QueryFieldStruct) {
+                    ret = 'inline';
+                }
+            }
+        }
+        return ret;
+    }
+    structs() {
+        const ret = [];
+        for (const e of this.allFields.values()) {
+            if (e instanceof FieldInstanceResult) {
+                ret.push(e);
+            }
+        }
+        return ret;
+    }
+    // return a list of structs that match the criteria
+    //  specified in the function.
+    selectStructs(result, fn) {
+        if (fn(this)) {
+            result.push(this);
+        }
+        for (const e of this.structs()) {
+            e.selectStructs(result, fn);
+        }
+        return result;
+    }
+    calculateDefaultOrderBy() {
+        // LookML rules for default ordering.
+        //  Date or time  or ordnal based fields, that field ascending
+        //  First Measure Descending.
+        let firstField;
+        for (const [_name, fi] of this.allFields) {
+            if (fi instanceof FieldInstanceField) {
+                if (fi.fieldUsage.type === 'result') {
+                    if (fi.f.fieldDef.type === 'turtle' ||
+                        (0, malloy_types_1.isJoined)(fi.f.fieldDef) ||
+                        (0, malloy_types_1.expressionIsAnalytic)(fi.f.fieldDef.expressionType)) {
+                        continue;
+                    }
+                    firstField || (firstField = fi.fieldUsage.resultIndex);
+                    if (['date', 'timestamp'].indexOf(fi.f.fieldDef.type) > -1) {
+                        return [{ dir: 'desc', field: fi.fieldUsage.resultIndex }];
+                    }
+                    else if ((0, query_node_1.isBasicAggregate)(fi.f)) {
+                        return [{ dir: 'desc', field: fi.fieldUsage.resultIndex }];
+                    }
+                }
+            }
+        }
+        if (firstField) {
+            return [{ dir: 'asc', field: firstField }];
+        }
+        return [];
+    }
+    addStructToJoin(qs, uniqueKeyRequirement) {
+        var _a;
+        const name = qs.getIdentifier();
+        let join = this.root().joins.get(name);
+        if (join) {
+            join.uniqueKeyRequirement = (0, malloy_types_1.mergeUniqueKeyRequirement)(join.uniqueKeyRequirement, uniqueKeyRequirement);
+            return;
+        }
+        // if we have a parent, join it first.
+        let parent;
+        const parentStruct = (_a = qs.parent) === null || _a === void 0 ? void 0 : _a.getJoinableParent();
+        if (parentStruct) {
+            // add dependant expressions first...
+            this.addStructToJoin(parentStruct, undefined);
+            parent = this.root().joins.get(parentStruct.getIdentifier());
+        }
+        if (!(join = this.root().joins.get(name))) {
+            join = new join_instance_1.JoinInstance(qs, name, parent);
+            this.root().joins.set(name, join);
+        }
+        join.uniqueKeyRequirement = (0, malloy_types_1.mergeUniqueKeyRequirement)(join.uniqueKeyRequirement, uniqueKeyRequirement);
+    }
+    root() {
+        if (this.parent) {
+            return this.parent.root();
+        }
+        throw new Error('Internal Error, Null parent FieldInstanceResult');
+    }
+    getUngroupPartitions(ungroupSet) {
+        let ret = [];
+        let p = this;
+        let excludeFields = [];
+        let inScopeFieldNames = [];
+        // all defaults to all fields at the current level.
+        if (ungroupSet === undefined || ungroupSet.type === 'all') {
+            // fields specified an an all, convert it to an exclude set.
+            const allFields = (ungroupSet === null || ungroupSet === void 0 ? void 0 : ungroupSet.fields) || [];
+            // convert an All into the equivalent exclude
+            excludeFields = this.fields(fi => (0, query_node_1.isBasicScalar)(fi.f) &&
+                fi.fieldUsage.type === 'result' &&
+                allFields.indexOf(fi.f.getIdentifier()) === -1).map(fi => fi.f.getIdentifier());
+        }
+        else {
+            excludeFields = ungroupSet.fields;
+        }
+        let firstScope = true;
+        while (p !== undefined) {
+            // get a list of valid fieldnames for the current scope.
+            if (firstScope || (ungroupSet === null || ungroupSet === void 0 ? void 0 : ungroupSet.type) === 'exclude') {
+                inScopeFieldNames = inScopeFieldNames.concat(p
+                    .fields(fi => (0, query_node_1.isScalarField)(fi.f) && fi.fieldUsage.type === 'result')
+                    .map(fi => fi.f.getIdentifier()));
+            }
+            ret = ret.concat(p.fields(fi => (0, query_node_1.isScalarField)(fi.f) &&
+                fi.fieldUsage.type === 'result' &&
+                excludeFields.indexOf(fi.f.getIdentifier()) === -1));
+            p = p.parent;
+            firstScope = false;
+        }
+        // verify that all names specified are available in the current scope.
+        for (const fieldName of (ungroupSet === null || ungroupSet === void 0 ? void 0 : ungroupSet.fields) || []) {
+            if (inScopeFieldNames.indexOf(fieldName) === -1) {
+                throw new Error(`${ungroupSet === null || ungroupSet === void 0 ? void 0 : ungroupSet.type}(): unknown field name "${fieldName}" or name not in scope.`);
+            }
+        }
+        return ret;
+    }
+    assignFieldsToGroups() {
+        for (const [_key, grouping] of this.ungroupedSets) {
+            for (const fieldInstance of this.getUngroupPartitions(grouping)) {
+                fieldInstance.additionalGroupSets.push(grouping.groupSet);
+            }
+        }
+        for (const child of this.structs()) {
+            child.assignFieldsToGroups();
+        }
+    }
+}
+exports.FieldInstanceResult = FieldInstanceResult;
+/* Root Result as opposed to a turtled result */
+class FieldInstanceResultRoot extends FieldInstanceResult {
+    constructor(turtleDef) {
+        super(turtleDef, undefined);
+        this.joins = new Map();
+        this.havings = new utils_1.AndChain();
+        this.isComplexQuery = false;
+        this.queryUsesPartitioning = false;
+        this.computeOnlyGroups = [];
+        this.elimatedComputeGroups = false;
+    }
+    root() {
+        return this;
+    }
+    // in the stage immediately following stage0 we need to elimiate any of the
+    //  groups that were used in ungroup calculations.  We need to do this only
+    //  once and in the very next stage.
+    eliminateComputeGroupsSQL() {
+        if (this.elimatedComputeGroups || this.computeOnlyGroups.length === 0) {
+            return '';
+        }
+        else {
+            this.elimatedComputeGroups = true;
+            return `group_set NOT IN (${this.computeOnlyGroups.join(',')})`;
+        }
+    }
+    // look at all the fields again in the structs in the query
+    calculateSymmetricAggregates() {
+        var _a;
+        let leafiest;
+        for (const [name, join] of this.joins) {
+            // first join is by default the
+            const relationship = join.parentRelationship();
+            if (relationship === 'many_to_many' ||
+                join.forceAllSymmetricCalculations()) {
+                // everything must be calculated with symmetric aggregates
+                leafiest = '0never';
+            }
+            else if (leafiest === undefined) {
+                leafiest = name;
+            }
+            else if (join.parentRelationship() === 'one_to_many') {
+                // check up the parent relationship until you find
+                //  the current leafiest node.  If it isn't in the direct path
+                //  we need symmetric aggregate for everything.
+                //  if it is in the path, than this one becomes leafiest
+                const s = join.queryStruct;
+                if (s.parent && s.parent.getIdentifier() === leafiest) {
+                    leafiest = name;
+                }
+                else {
+                    // we have more than on one_to_many join chain, all bets are off.
+                    leafiest = '0never';
+                }
+            }
+        }
+        // console.log(`LEAFIEST: ${leafiest}`);
+        for (const [name, join] of this.joins) {
+            join.leafiest = name === leafiest;
+        }
+        // figure out which joins we need to manufacture distinct keys for.
+        //  Nested Unique keys are dependant on the primary key of the parent
+        //  and the table.
+        for (const [_name, join] of this.joins) {
+            // in a one_to_many join we need a key to count there may be a failed
+            //  match in a left join.
+            // users -> {
+            //   group_by: user_id
+            //   aggregate: order_count is orders.count()
+            if (
+            // we have a leafiest count() joined subtree
+            (join.leafiest &&
+                join.parent !== undefined &&
+                ((_a = join.uniqueKeyRequirement) === null || _a === void 0 ? void 0 : _a.isCount)) ||
+                // or not leafiest and we use an asymetric function
+                (!join.leafiest && join.uniqueKeyRequirement)) {
+                let j = join;
+                while (j) {
+                    if (!j.queryStruct.primaryKey()) {
+                        j.makeUniqueKey = true;
+                    }
+                    if (j.queryStruct.structDef.type === 'array') {
+                        j = j.parent;
+                    }
+                    else {
+                        j = undefined;
+                    }
+                }
+            }
+        }
+    }
+}
+exports.FieldInstanceResultRoot = FieldInstanceResultRoot;
+function sqlFullChildReference(struct, name, expand) {
+    let parentRef = struct.getSQLIdentifier();
+    if (expand && (0, malloy_types_1.isAtomic)(struct.structDef) && (0, malloy_types_1.hasExpression)(struct.structDef)) {
+        if (!struct.parent) {
+            throw new Error(`Cannot expand reference to ${name} without parent`);
+        }
+        if (!FieldInstanceField.exprCompiler) {
+            throw new Error('Expression compiler not registered with FieldInstanceField');
+        }
+        parentRef = FieldInstanceField.exprCompiler(expand.field, expand.result, struct.parent, struct.structDef.e);
+    }
+    let refType = 'table';
+    if (struct.structDef.type === 'record') {
+        refType = 'record';
+    }
+    else if (struct.structDef.type === 'array') {
+        refType =
+            struct.structDef.elementTypeDef.type === 'record_element'
+                ? 'array[record]'
+                : 'array[scalar]';
+    }
+    else if (struct.structDef.type === 'nest_source') {
+        refType = 'nest source';
+    }
+    const child = struct.getChildByName(name);
+    const childType = (child === null || child === void 0 ? void 0 : child.fieldDef.type) || 'unknown';
+    return struct.dialect.sqlFieldReference(parentRef, refType, name, childType);
+}
+//# sourceMappingURL=field_instance.js.map

package/dist/model/index.d.ts

@@ -1,3 +1,7 @@
 export * from './malloy_types';
-export { Segment, QueryModel } from './malloy_query';
+import { QueryField, QueryStruct } from './query_node';
+import { QueryQuery } from './query_query';
+import { QueryModelImpl } from './query_model_impl';
+export { QueryField, QueryStruct, QueryQuery, QueryModelImpl as QueryModel };
+export { getResultStructDefForQuery, getResultStructDefForView, } from './query_model_impl';
 export { indent, composeSQLExpr } from './utils';

package/dist/model/index.js

@@ -36,11 +36,32 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.composeSQLExpr = exports.indent = exports.QueryModel = exports.Segment = void 0;
+exports.composeSQLExpr = exports.indent = exports.getResultStructDefForView = exports.getResultStructDefForQuery = exports.QueryModel = exports.QueryQuery = exports.QueryStruct = exports.QueryField = void 0;
 __exportStar(require("./malloy_types"), exports);
-var malloy_query_1 = require("./malloy_query");
-Object.defineProperty(exports, "Segment", { enumerable: true, get: function () { return malloy_query_1.Segment; } });
-Object.defineProperty(exports, "QueryModel", { enumerable: true, get: function () { return malloy_query_1.QueryModel; } });
+const query_node_1 = require("./query_node");
+Object.defineProperty(exports, "QueryField", { enumerable: true, get: function () { return query_node_1.QueryField; } });
+Object.defineProperty(exports, "QueryStruct", { enumerable: true, get: function () { return query_node_1.QueryStruct; } });
+const expression_compiler_1 = require("./expression_compiler");
+const query_query_1 = require("./query_query");
+Object.defineProperty(exports, "QueryQuery", { enumerable: true, get: function () { return query_query_1.QueryQuery; } });
+const field_instance_1 = require("./field_instance");
+const query_model_impl_1 = require("./query_model_impl");
+Object.defineProperty(exports, "QueryModel", { enumerable: true, get: function () { return query_model_impl_1.QueryModelImpl; } });
+// We have a circular dependency issue, and this is the minimal
+// dependency injection needed to get around it. Ideally, we would
+// like to avoid this, and I think a thoughtful pass through
+// FieldInstance and QueryField might eliminate the need for this.
+function getLookupFun(mri) {
+    if (mri instanceof query_model_impl_1.QueryModelImpl) {
+        return (name) => mri.structs.get(name);
+    }
+    return () => undefined;
+}
+field_instance_1.FieldInstanceField.registerExpressionCompiler(expression_compiler_1.exprToSQL);
+query_node_1.QueryStruct.registerTurtleFieldMaker((field, parent) => query_query_1.QueryQuery.makeQuery(field, parent, undefined, false, getLookupFun(parent.getModel())));
+var query_model_impl_2 = require("./query_model_impl");
+Object.defineProperty(exports, "getResultStructDefForQuery", { enumerable: true, get: function () { return query_model_impl_2.getResultStructDefForQuery; } });
+Object.defineProperty(exports, "getResultStructDefForView", { enumerable: true, get: function () { return query_model_impl_2.getResultStructDefForView; } });
 var utils_1 = require("./utils");
 Object.defineProperty(exports, "indent", { enumerable: true, get: function () { return utils_1.indent; } });
 Object.defineProperty(exports, "composeSQLExpr", { enumerable: true, get: function () { return utils_1.composeSQLExpr; } });