@malloydata/malloy 0.0.304 → 0.0.306

package/dist/model/query_node.js

@@ -0,0 +1,638 @@
+"use strict";
+/*
+ * Copyright Contributors to the Malloy project
+ * SPDX-License-Identifier: MIT
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QueryStruct = exports.QueryFieldUnsupported = exports.QueryFieldTimestamp = exports.QueryFieldStruct = exports.QueryFieldString = exports.QueryFieldNumber = exports.QueryFieldJSON = exports.QueryFieldDistinctKey = exports.QueryFieldDate = exports.QueryFieldBoolean = exports.QueryAtomicField = exports.QueryField = void 0;
+exports.isAggregateField = isAggregateField;
+exports.isCalculatedField = isCalculatedField;
+exports.isScalarField = isScalarField;
+exports.isBasicAggregate = isBasicAggregate;
+exports.isBasicCalculation = isBasicCalculation;
+exports.isBasicScalar = isBasicScalar;
+const uuid_1 = require("uuid");
+const malloy_types_1 = require("./malloy_types");
+const annotation_1 = require("../annotation");
+const dialect_1 = require("../dialect");
+const utils_1 = require("./utils");
+class QueryNode {
+    constructor(referenceId) {
+        this.referenceId = referenceId !== null && referenceId !== void 0 ? referenceId : (0, uuid_1.v4)();
+    }
+    getChildByName(_name) {
+        return undefined;
+    }
+}
+class QueryField extends QueryNode {
+    constructor(fieldDef, parent, referenceId) {
+        super(referenceId);
+        this.fieldDef = fieldDef;
+        this.parent = parent;
+        this.fieldDef = fieldDef;
+    }
+    getIdentifier() {
+        return (0, malloy_types_1.getIdentifier)(this.fieldDef);
+    }
+    getJoinableParent() {
+        const parent = this.parent;
+        if (parent.structDef.type === 'record') {
+            return parent.getJoinableParent();
+        }
+        return parent;
+    }
+    isAtomic() {
+        return (0, malloy_types_1.isAtomic)(this.fieldDef);
+    }
+    getFullOutputName() {
+        return this.parent.getFullOutputName() + this.getIdentifier();
+    }
+    isNestedInParent(parentDef) {
+        switch (parentDef.type) {
+            case 'record':
+            case 'array':
+                return true;
+                return true;
+            default:
+                return false;
+        }
+    }
+    isArrayElement(parentDef) {
+        return (parentDef.type === 'array' &&
+            parentDef.elementTypeDef.type !== 'record_element');
+    }
+    includeInWildcard() {
+        return false;
+    }
+}
+exports.QueryField = QueryField;
+class QueryAtomicField extends QueryField {
+    constructor(fieldDef, parent, refId) {
+        super(fieldDef, parent, refId);
+        this.fieldDef = fieldDef; // wish I didn't have to do this
+    }
+    includeInWildcard() {
+        return this.fieldDef.name !== '__distinct_key';
+    }
+    getFilterList() {
+        return [];
+    }
+}
+exports.QueryAtomicField = QueryAtomicField;
+class QueryFieldBoolean extends QueryAtomicField {
+}
+exports.QueryFieldBoolean = QueryFieldBoolean;
+class QueryFieldDate extends QueryAtomicField {
+}
+exports.QueryFieldDate = QueryFieldDate;
+class QueryFieldDistinctKey extends QueryAtomicField {
+}
+exports.QueryFieldDistinctKey = QueryFieldDistinctKey;
+class QueryFieldJSON extends QueryAtomicField {
+}
+exports.QueryFieldJSON = QueryFieldJSON;
+class QueryFieldNumber extends QueryAtomicField {
+}
+exports.QueryFieldNumber = QueryFieldNumber;
+class QueryFieldString extends QueryAtomicField {
+}
+exports.QueryFieldString = QueryFieldString;
+/*
+ * The input to a query will always be a QueryStruct. A QueryStruct is also a namespace
+ * for tracking joins, and so a QueryFieldStruct is a QueryField which has a QueryStruct.
+ *
+ * This is a result of it being impossible to inherit both from QueryStruct and QueryField
+ * for array and record types.
+ */
+class QueryFieldStruct extends QueryField {
+    constructor(jfd, sourceArguments, parent, prepareResultOptions, referenceId) {
+        super(jfd, parent, referenceId);
+        this.fieldDef = jfd;
+        this.queryStruct = new QueryStruct(jfd, sourceArguments, { struct: parent }, prepareResultOptions);
+    }
+    /*
+     * Proxy the field-like methods that QueryStruct implements, eventually
+     * those probably should be in here ... I thought this would be important
+     * but maybe it isn't, it doesn't fix the problem I am working on ...
+     */
+    getJoinableParent() {
+        return this.queryStruct.getJoinableParent();
+    }
+    getFullOutputName() {
+        return this.queryStruct.getFullOutputName();
+    }
+    includeInWildcard() {
+        return this.isAtomic();
+    }
+}
+exports.QueryFieldStruct = QueryFieldStruct;
+class QueryFieldTimestamp extends QueryAtomicField {
+}
+exports.QueryFieldTimestamp = QueryFieldTimestamp;
+class QueryFieldUnsupported extends QueryAtomicField {
+}
+exports.QueryFieldUnsupported = QueryFieldUnsupported;
+// ============================================================================
+// QueryField utility functions (consolidated from is_* files)
+// ============================================================================
+function isAggregateField(f) {
+    if (f.isAtomic() && (0, malloy_types_1.hasExpression)(f.fieldDef)) {
+        return (0, malloy_types_1.expressionIsAggregate)(f.fieldDef.expressionType);
+    }
+    return false;
+}
+function isCalculatedField(f) {
+    if (f.isAtomic() && (0, malloy_types_1.hasExpression)(f.fieldDef)) {
+        return (0, malloy_types_1.expressionIsCalculation)(f.fieldDef.expressionType);
+    }
+    return false;
+}
+function isScalarField(f) {
+    if (f.isAtomic()) {
+        if ((0, malloy_types_1.hasExpression)(f.fieldDef)) {
+            const et = f.fieldDef.expressionType;
+            if ((0, malloy_types_1.expressionIsCalculation)(et) || (0, malloy_types_1.expressionIsAggregate)(et)) {
+                return false;
+            }
+        }
+        return true;
+    }
+    return false;
+}
+function isBasicAggregate(f) {
+    return f instanceof QueryAtomicField && isAggregateField(f);
+}
+function isBasicCalculation(f) {
+    return f instanceof QueryAtomicField && isCalculatedField(f);
+}
+function isBasicScalar(f) {
+    return f instanceof QueryAtomicField && isScalarField(f);
+}
+function identifierNormalize(s) {
+    return s.replace(/[^a-zA-Z0-9_]/g, '_o_');
+}
+/** Structure object as it is used to build a query */
+class QueryStruct {
+    constructor(structDef, sourceArguments, parent, prepareResultOptions) {
+        this.structDef = structDef;
+        this.sourceArguments = sourceArguments;
+        this.prepareResultOptions = prepareResultOptions;
+        this.nameMap = new Map();
+        this._modelTag = undefined;
+        this._arguments = undefined;
+        this.setParent(parent);
+        if ('model' in parent) {
+            this.model = parent.model;
+            this.pathAliasMap = new Map();
+            if ((0, malloy_types_1.isSourceDef)(structDef)) {
+                this.connectionName = structDef.connection;
+            }
+            else {
+                throw new Error('All root StructDefs should be a baseTable');
+            }
+        }
+        else {
+            this.model = this.getModel();
+            this.pathAliasMap = this.root().pathAliasMap;
+            this.connectionName = this.root().connectionName;
+        }
+        this.dialect = (0, dialect_1.getDialect)(this.findFirstDialect());
+        this.addFieldsFromFieldList(structDef.fields);
+    }
+    static registerTurtleFieldMaker(maker) {
+        QueryStruct.turtleFieldMaker = maker;
+    }
+    modelCompilerFlags() {
+        if (this._modelTag === undefined) {
+            const annotation = this.structDef.modelAnnotation;
+            const { tag } = (0, annotation_1.annotationToTag)(annotation, { prefix: /^##!\s*/ });
+            this._modelTag = tag;
+        }
+        return this._modelTag;
+    }
+    findFirstDialect() {
+        if ((0, malloy_types_1.isSourceDef)(this.structDef)) {
+            return this.structDef.dialect;
+        }
+        if (this.parent) {
+            return this.parent.findFirstDialect();
+        }
+        throw new Error('Cannot create QueryStruct from record with model parent');
+    }
+    informOfAliasValue(av) {
+        this.recordAlias = av;
+    }
+    maybeEmitParameterizedSourceUsage() {
+        var _a;
+        if ((0, malloy_types_1.isSourceDef)(this.structDef)) {
+            const paramsAndArgs = {
+                ...this.structDef.parameters,
+                ...this.structDef.arguments,
+            };
+            if (Object.values(paramsAndArgs).length === 0)
+                return;
+            (_a = this.eventStream) === null || _a === void 0 ? void 0 : _a.emit('parameterized-source-compiled', {
+                parameters: paramsAndArgs,
+            });
+        }
+    }
+    resolveParentParameterReferences(param) {
+        return {
+            ...param,
+            value: param.value === null
+                ? null
+                : (0, utils_1.exprMap)(param.value, frag => {
+                    if (frag.node === 'parameter') {
+                        const resolved1 = (this.parent ? this.parent.arguments() : this.arguments())[frag.path[0]];
+                        const resolved2 = this.parent
+                            ? this.parent.resolveParentParameterReferences(resolved1)
+                            : resolved1;
+                        if (resolved2.value === null) {
+                            throw new Error('Invalid parameter value');
+                        }
+                        else {
+                            return resolved2.value;
+                        }
+                    }
+                    return frag;
+                }),
+        };
+    }
+    arguments() {
+        var _a;
+        if (this._arguments !== undefined) {
+            return this._arguments;
+        }
+        this._arguments = {};
+        if ((0, malloy_types_1.isSourceDef)(this.structDef)) {
+            // First, copy over all parameters, to get default values
+            const params = (_a = this.structDef.parameters) !== null && _a !== void 0 ? _a : {};
+            for (const parameterName in params) {
+                this._arguments[parameterName] = params[parameterName];
+            }
+            // Then, copy over arguments to override default values
+            const args = { ...this.structDef.arguments, ...this.sourceArguments };
+            for (const parameterName in args) {
+                const orig = args[parameterName];
+                this._arguments[parameterName] =
+                    this.resolveParentParameterReferences(orig);
+            }
+        }
+        return this._arguments;
+    }
+    addFieldsFromFieldList(fields) {
+        for (const field of fields) {
+            const as = (0, malloy_types_1.getIdentifier)(field);
+            if (field.type === 'turtle') {
+                if (!QueryStruct.turtleFieldMaker) {
+                    throw new Error('INTERNAL ERROR: QueryQuery must initialize QueryStruct nested factory method');
+                }
+                this.addFieldToNameMap(as, QueryStruct.turtleFieldMaker(field, this));
+            }
+            else if ((0, malloy_types_1.isAtomic)(field) || (0, malloy_types_1.isJoinedSource)(field)) {
+                this.addFieldToNameMap(as, this.makeQueryField(field));
+            }
+            else {
+                throw new Error('mtoy did nit add field');
+            }
+        }
+        // if we don't have distinct key yet for this struct, add it.
+        if (!this.nameMap.has('__distinct_key')) {
+            this.addFieldToNameMap('__distinct_key', new QueryFieldDistinctKey({ type: 'string', name: '__distinct_key' }, this));
+        }
+    }
+    // generate unique string for the alias.
+    // return a string that can be used to represent the full
+    //  join path to a struct.
+    getAliasIdentifier() {
+        const path = this.getFullOutputName();
+        const ret = this.pathAliasMap.get(path);
+        // make a unique alias name
+        if (ret === undefined) {
+            const aliases = Array.from(this.pathAliasMap.values());
+            const base = identifierNormalize((0, malloy_types_1.getIdentifier)(this.structDef));
+            let name = `${base}_0`;
+            let n = 1;
+            while (aliases.includes(name) && n < 1000) {
+                n++;
+                name = `${base}_${n}`;
+            }
+            if (n < 1000) {
+                this.pathAliasMap.set(path, name);
+                return name;
+            }
+            else {
+                throw new Error('Internal Error: cannot create unique alias name');
+            }
+            // get the malloy name for this struct (will include a trailing dot)
+            // return this.getFullOutputName().replace(/\.$/, "").replace(/\./g, "_o_");
+        }
+        else {
+            return ret;
+        }
+    }
+    getSQLIdentifier() {
+        if (this.unnestWithNumbers() && this.parent !== undefined) {
+            const x = this.parent.getSQLIdentifier() +
+                '.' +
+                (0, malloy_types_1.getIdentifier)(this.structDef) +
+                `[${this.getIdentifier()}.__row_id]`;
+            return x;
+        }
+        else {
+            return this.getIdentifier();
+        }
+    }
+    sqlSimpleChildReference(name) {
+        const parentRef = this.getSQLIdentifier();
+        let refType = 'table';
+        if (this.structDef.type === 'record') {
+            refType = 'record';
+        }
+        else if (this.structDef.type === 'array') {
+            refType =
+                this.structDef.elementTypeDef.type === 'record_element'
+                    ? 'array[record]'
+                    : 'array[scalar]';
+        }
+        else if (this.structDef.type === 'nest_source') {
+            refType = 'nest source';
+        }
+        const child = this.getChildByName(name);
+        const childType = (child === null || child === void 0 ? void 0 : child.fieldDef.type) || 'unknown';
+        return this.dialect.sqlFieldReference(parentRef, refType, name, childType);
+    }
+    // return the name of the field in SQL
+    getIdentifier() {
+        // if it is the root table, use provided alias if we have one.
+        if ((0, malloy_types_1.isBaseTable)(this.structDef)) {
+            return 'base';
+        }
+        // If this is a synthetic column, return the expression rather than the name
+        // because the name will not exist. Only for records because the other types
+        // will have joins and thus be in the namespace. We can't compute it here
+        // because we don't have access to the Query to call exprToSQL.
+        if (this.structDef.type === 'record' && (0, malloy_types_1.hasExpression)(this.structDef)) {
+            if (this.recordAlias) {
+                return this.recordAlias;
+            }
+            throw new Error('INTERNAL ERROR, record field alias not pre-computed');
+        }
+        // if this is an inline object, include the parents alias.
+        if (this.structDef.type === 'record' && this.parent) {
+            return this.parent.sqlSimpleChildReference((0, malloy_types_1.getIdentifier)(this.structDef));
+        }
+        // we are somewhere in the join tree.  Make sure the alias is unique.
+        return this.getAliasIdentifier();
+    }
+    // return the name of the field in Malloy
+    getFullOutputName() {
+        if (this.parent) {
+            return (this.parent.getFullOutputName() + (0, malloy_types_1.getIdentifier)(this.structDef) + '.');
+        }
+        else {
+            return '';
+        }
+    }
+    unnestWithNumbers() {
+        return this.dialect.unnestWithNumbers && this.structDef.type === 'array';
+    }
+    getJoinableParent() {
+        // if it is inline it should always have a parent
+        if (this.structDef.type === 'record') {
+            if (this.parent) {
+                return this.parent.getJoinableParent();
+            }
+            else {
+                throw new Error('Internal Error: inline struct cannot be root');
+            }
+        }
+        return this;
+    }
+    addFieldToNameMap(as, n) {
+        if (this.nameMap.has(as)) {
+            throw new Error(`Redefinition of ${as}`);
+        }
+        this.nameMap.set(as, n);
+    }
+    /** the the primary key or throw an error. */
+    getPrimaryKeyField(fieldDef) {
+        let pk;
+        if ((pk = this.primaryKey())) {
+            return pk;
+        }
+        else {
+            throw new Error(`Missing primary key for ${fieldDef}`);
+        }
+    }
+    /**
+     * called after all structure has been loaded.  Examine this structure to see
+     * if if it is based on a query and if it is, add the output fields (unless
+     * they exist) to the structure.
+     *
+     * finalOutputStruct exists so that query_node doesn't need to
+     * to import query_query
+     */
+    resolveQueryFields(finalOutputStruct) {
+        if (this.structDef.type === 'query_source' && finalOutputStruct) {
+            const resultStruct = finalOutputStruct(this.structDef.query, this.prepareResultOptions);
+            // should never happen.
+            if (!resultStruct) {
+                throw new Error("Internal Error, query didn't produce a struct");
+            }
+            const structDef = { ...this.structDef };
+            for (const f of resultStruct.fields) {
+                const as = (0, malloy_types_1.getIdentifier)(f);
+                if (!this.nameMap.has(as)) {
+                    structDef.fields.push(f);
+                    this.nameMap.set(as, this.makeQueryField(f));
+                }
+            }
+            this.structDef = structDef;
+            if (!this.structDef.primaryKey && resultStruct.primaryKey) {
+                this.structDef.primaryKey = resultStruct.primaryKey;
+            }
+        }
+        for (const [, v] of this.nameMap) {
+            if (v instanceof QueryFieldStruct) {
+                v.queryStruct.resolveQueryFields(finalOutputStruct);
+            }
+        }
+    }
+    getModel() {
+        if (this.model) {
+            return this.model;
+        }
+        else {
+            if (this.parent === undefined) {
+                throw new Error('Expected this query struct to have a parent, as no model was present.');
+            }
+            return this.parent.getModel();
+        }
+    }
+    get eventStream() {
+        return this.getModel().eventStream;
+    }
+    setParent(parent) {
+        if ('struct' in parent) {
+            this.parent = parent.struct;
+        }
+        if ('model' in parent) {
+            this.model = parent.model;
+        }
+        else {
+            this.model = this.getModel();
+        }
+    }
+    /** makes a new queryable field object from a fieldDef */
+    makeQueryField(field, referenceId) {
+        switch (field.type) {
+            case 'array':
+            case 'record':
+            case 'query_source':
+            case 'table':
+            case 'sql_select':
+            case 'composite':
+                return new QueryFieldStruct(field, undefined, this, this.prepareResultOptions);
+            case 'string':
+                return new QueryFieldString(field, this, referenceId);
+            case 'date':
+                return new QueryFieldDate(field, this, referenceId);
+            case 'timestamp':
+                return new QueryFieldTimestamp(field, this, referenceId);
+            case 'number':
+                return new QueryFieldNumber(field, this, referenceId);
+            case 'boolean':
+                return new QueryFieldBoolean(field, this, referenceId);
+            case 'json':
+                return new QueryFieldJSON(field, this, referenceId);
+            case 'sql native':
+                return new QueryFieldUnsupported(field, this, referenceId);
+            case 'turtle':
+                if (!QueryStruct.turtleFieldMaker) {
+                    throw new Error('INTERNAL ERROR: QueryQuery must initialize QueryStruct nested factory method');
+                }
+                return QueryStruct.turtleFieldMaker(field, this);
+            default:
+                throw new Error(`unknown field definition ${(JSON.stringify(field), undefined, 2)}`);
+        }
+    }
+    root() {
+        return this.parent ? this.parent.root() : this;
+    }
+    primaryKey() {
+        if ((0, malloy_types_1.isSourceDef)(this.structDef) && this.structDef.primaryKey) {
+            return this.getDimensionByName([this.structDef.primaryKey]);
+        }
+        else {
+            return undefined;
+        }
+    }
+    getChildByName(name) {
+        return this.nameMap.get(name);
+    }
+    /** convert a path into a field reference */
+    getFieldByName(path) {
+        let found = undefined;
+        let lookIn = this;
+        let notFound = path[0];
+        for (const n of path) {
+            found = lookIn === null || lookIn === void 0 ? void 0 : lookIn.getChildByName(n);
+            if (!found) {
+                notFound = n;
+                break;
+            }
+            lookIn =
+                found instanceof QueryFieldStruct ? found.queryStruct : undefined;
+        }
+        if (found === undefined) {
+            const pathErr = path.length > 1 ? ` in ${path.join('.')}` : '';
+            throw new Error(`${notFound} not found${pathErr}`);
+        }
+        return found;
+    }
+    // structs referenced in queries are converted to fields.
+    getQueryFieldByName(name) {
+        const field = this.getFieldByName(name);
+        if (field instanceof QueryFieldStruct) {
+            throw new Error(`Cannot reference ${name.join('.')} as a scalar'`);
+        }
+        return field;
+    }
+    getQueryFieldReference(f) {
+        const { path, annotation, drillExpression } = f;
+        const field = this.getFieldByName(path);
+        if (annotation || drillExpression) {
+            if (field.parent === undefined) {
+                throw new Error('Inconcievable, field reference to orphaned query field');
+            }
+            // Made a field object from the source, but the annotations were computed by the compiler
+            // when it generated the reference, and has both the source and reference annotations included.
+            if (field instanceof QueryFieldStruct) {
+                const newDef = { ...field.fieldDef, annotation, drillExpression };
+                return new QueryFieldStruct(newDef, undefined, field.parent, field.parent.prepareResultOptions, field.referenceId);
+            }
+            else {
+                const newDef = { ...field.fieldDef, annotation, drillExpression };
+                return field.parent.makeQueryField(newDef, field.referenceId);
+            }
+        }
+        return field;
+    }
+    getDimensionOrMeasureByName(name) {
+        const field = this.getFieldByName(name);
+        if (!field.isAtomic()) {
+            throw new Error(`${name} is not an atomic field? Inconceivable!`);
+        }
+        return field;
+    }
+    /** returns a query object for the given name */
+    getDimensionByName(name) {
+        const field = this.getFieldByName(name);
+        if (isBasicScalar(field)) {
+            return field;
+        }
+        throw new Error(`${name} is not an atomic scalar field? Inconceivable!`);
+    }
+    /** returns a query object for the given name */
+    getStructByName(name) {
+        if (name.length === 0) {
+            return this;
+        }
+        const struct = this.getFieldByName(name);
+        if (struct instanceof QueryFieldStruct) {
+            return struct.queryStruct;
+        }
+        throw new Error(`Error: Path to structure not found '${name.join('.')}'`);
+    }
+    getDistinctKey() {
+        if (this.structDef.type !== 'record') {
+            return this.getDimensionByName(['__distinct_key']);
+        }
+        else if (this.parent) {
+            return this.parent.getDistinctKey();
+        }
+        else {
+            throw new Error('Asking a record for a primary key? Inconceivable!');
+        }
+    }
+    applyStructFiltersToTurtleDef(turtleDef) {
+        const pipeline = [...turtleDef.pipeline];
+        const annotation = turtleDef.annotation;
+        const addedFilters = turtleDef.filterList || [];
+        pipeline[0] = {
+            ...pipeline[0],
+            filterList: addedFilters.concat(pipeline[0].filterList || [], (0, malloy_types_1.isSourceDef)(this.structDef) ? this.structDef.filterList || [] : []),
+        };
+        const flatTurtleDef = {
+            type: 'turtle',
+            name: turtleDef.name,
+            pipeline,
+            annotation,
+            location: turtleDef.location,
+        };
+        return flatTurtleDef;
+    }
+}
+exports.QueryStruct = QueryStruct;
+//# sourceMappingURL=query_node.js.map