@malloydata/malloy 0.0.22-dev230207144036 → 0.0.22-dev230207180844

package/dist/model/malloy_types.js

@@ -0,0 +1,378 @@
+"use strict";
+/*
+ * Copyright 2023 Google LLC
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files
+ * (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isMeasureLike = exports.getPhysicalFields = exports.getDimensions = exports.isPhysical = exports.isDimensional = exports.isTurtleDef = exports.getIdentifier = exports.isFieldStructDef = exports.isFieldTimeBased = exports.isFieldTypeDef = exports.isSQLBlock = exports.isSQLFragment = exports.isJoinOn = exports.isIndexSegment = exports.isSamplingEnable = exports.isSamplingPercent = exports.isSamplingRows = exports.isQuerySegment = exports.isProjectSegment = exports.isReduceSegment = exports.refIsStructDef = exports.isByExpression = exports.isByName = exports.ValueType = exports.isExtractUnit = exports.isTimestampUnit = exports.isDateUnit = exports.FieldIsIntrinsic = exports.isAtomicFieldType = exports.isTimeFieldType = exports.hasExpression = exports.maxExpressionType = exports.expressionIsCalculation = exports.expressionIsAggregate = exports.mkExpr = exports.isApplyFragment = exports.isApplyValue = exports.isParameterFragment = exports.isFieldFragment = exports.isAnalyticFragment = exports.malloyFunctions = exports.isUngroupFragment = exports.isAsymmetricFragment = exports.isAggregateFragment = exports.isDialectFragment = exports.isFilterFragment = exports.isFilteredAliasedName = exports.paramHasValue = exports.isConditionParameter = exports.isValueParameter = void 0;
+exports.isValueDate = exports.isValueTimestamp = exports.isValueBoolean = exports.isValueNumber = exports.isValueString = void 0;
+function isValueParameter(p) {
+    return p.value !== undefined;
+}
+exports.isValueParameter = isValueParameter;
+function isConditionParameter(p) {
+    return p.condition !== undefined;
+}
+exports.isConditionParameter = isConditionParameter;
+function paramHasValue(p) {
+    return isValueParameter(p) || p.condition !== null;
+}
+exports.paramHasValue = paramHasValue;
+function isFilteredAliasedName(f) {
+    for (const prop of Object.keys(f)) {
+        if (!["name", "as", "filterList"].includes(prop)) {
+            return false;
+        }
+    }
+    return true;
+}
+exports.isFilteredAliasedName = isFilteredAliasedName;
+function isFilterFragment(f) {
+    return (f === null || f === void 0 ? void 0 : f.type) === "filterExpression";
+}
+exports.isFilterFragment = isFilterFragment;
+function isDialectFragment(f) {
+    return (f === null || f === void 0 ? void 0 : f.type) === "dialect";
+}
+exports.isDialectFragment = isDialectFragment;
+function isAggregateFragment(f) {
+    return (f === null || f === void 0 ? void 0 : f.type) === "aggregate";
+}
+exports.isAggregateFragment = isAggregateFragment;
+function isAsymmetricFragment(f) {
+    return isAggregateFragment(f) && ["sum", "avg", "count"].includes(f.function);
+}
+exports.isAsymmetricFragment = isAsymmetricFragment;
+function isUngroupFragment(f) {
+    const ftype = f === null || f === void 0 ? void 0 : f.type;
+    return ftype == "all" || ftype == "exclude";
+}
+exports.isUngroupFragment = isUngroupFragment;
+exports.malloyFunctions = {
+    row_number: {
+        returnType: "number",
+        parameters: "none",
+        expressionType: "analytic",
+    },
+    rank: {
+        returnType: "number",
+        parameters: "none",
+        expressionType: "analytic",
+    },
+    dense_rank: {
+        returnType: "number",
+        parameters: "none",
+        expressionType: "analytic",
+    },
+    first_value_in_column: {
+        returnType: "number",
+        parameters: "any",
+        expressionType: "analytic",
+        sqlName: "first_value",
+    },
+    last_value_in_column: {
+        returnType: "number",
+        parameters: "any",
+        expressionType: "analytic",
+        sqlName: "last_value",
+    },
+    min_in_column: {
+        returnType: "number",
+        parameters: "any",
+        expressionType: "analytic",
+        sqlName: "min",
+    },
+    max_in_column: {
+        returnType: "number",
+        parameters: "any",
+        expressionType: "analytic",
+        sqlName: "max",
+    },
+    ntile: {
+        returnType: "number",
+        parameters: ["nconst"],
+        expressionType: "analytic",
+    },
+    lag: {
+        returnType: "number",
+        parameters: ["number", "nconst"],
+        expressionType: "analytic",
+    },
+};
+function isAnalyticFragment(f) {
+    return (f === null || f === void 0 ? void 0 : f.type) === "analytic";
+}
+exports.isAnalyticFragment = isAnalyticFragment;
+function isFieldFragment(f) {
+    return (f === null || f === void 0 ? void 0 : f.type) === "field";
+}
+exports.isFieldFragment = isFieldFragment;
+function isParameterFragment(f) {
+    return (f === null || f === void 0 ? void 0 : f.type) === "parameter";
+}
+exports.isParameterFragment = isParameterFragment;
+function isApplyValue(f) {
+    return (f === null || f === void 0 ? void 0 : f.type) === "applyVal";
+}
+exports.isApplyValue = isApplyValue;
+function isApplyFragment(f) {
+    return (f === null || f === void 0 ? void 0 : f.type) === "apply";
+}
+exports.isApplyFragment = isApplyFragment;
+/**
+ * Return an Expr based on the string template, subsittutions can be
+ * either strings, or other Exprs.
+
+ * ```
+ * units = "inches"
+ * len: Expr = [ "something", "returning", "a length "]
+ * computeExpr = mkExpr`MEASURE(${len} in ${units})`;
+ * ```
+ */
+function mkExpr(src, ...exprs) {
+    const ret = [];
+    let index;
+    for (index = 0; index < exprs.length; index++) {
+        const el = exprs[index];
+        if (src[index].length > 0) {
+            ret.push(src[index]);
+        }
+        if (typeof el == "string") {
+            ret.push(el);
+        }
+        else {
+            ret.push(...el);
+        }
+    }
+    if (src[index].length > 0) {
+        ret.push(src[index]);
+    }
+    return ret;
+}
+exports.mkExpr = mkExpr;
+function expressionIsAggregate(e) {
+    return e === "aggregate";
+}
+exports.expressionIsAggregate = expressionIsAggregate;
+function expressionIsCalculation(e) {
+    return e === "aggregate" || e === "analytic";
+}
+exports.expressionIsCalculation = expressionIsCalculation;
+function maxExpressionType(e1, e2) {
+    let ret = "scalar";
+    if (e1 === "aggregate" || e2 === "aggregate") {
+        ret = "aggregate";
+    }
+    if (e1 === "analytic" || e2 === "analytic") {
+        ret = "analytic";
+    }
+    return ret;
+}
+exports.maxExpressionType = maxExpressionType;
+/**  Grants access to the expression property of a FielfDef */
+function hasExpression(f) {
+    return f.e !== undefined;
+}
+exports.hasExpression = hasExpression;
+function isTimeFieldType(s) {
+    return s == "date" || s == "timestamp";
+}
+exports.isTimeFieldType = isTimeFieldType;
+function isAtomicFieldType(s) {
+    return ["string", "number", "date", "timestamp", "boolean", "json"].includes(s);
+}
+exports.isAtomicFieldType = isAtomicFieldType;
+// this field definition represents something in the database.
+function FieldIsIntrinsic(f) {
+    if (isAtomicFieldType(f.type) && !hasExpression(f)) {
+        return true;
+    }
+    else if (f.type === "struct" &&
+        (f.structSource.type === "inline" || f.structSource.type === "nested")) {
+        return true;
+    }
+    else {
+        return false;
+    }
+}
+exports.FieldIsIntrinsic = FieldIsIntrinsic;
+function isDateUnit(str) {
+    return ["day", "week", "month", "quarter", "year"].includes(str);
+}
+exports.isDateUnit = isDateUnit;
+function isTimestampUnit(s) {
+    return isDateUnit(s) || ["hour", "minute", "second"].includes(s);
+}
+exports.isTimestampUnit = isTimestampUnit;
+function isExtractUnit(s) {
+    return isTimestampUnit(s) || s == "day_of_week" || s == "day_of_year";
+}
+exports.isExtractUnit = isExtractUnit;
+/** Value types distinguished by their usage in generated SQL, particularly with respect to filters. */
+var ValueType;
+(function (ValueType) {
+    ValueType["Date"] = "date";
+    ValueType["Timestamp"] = "timestamp";
+    ValueType["Number"] = "number";
+    ValueType["String"] = "string";
+})(ValueType = exports.ValueType || (exports.ValueType = {}));
+function isByName(by) {
+    if (by === undefined) {
+        return false;
+    }
+    return by.by === "name";
+}
+exports.isByName = isByName;
+function isByExpression(by) {
+    if (by === undefined) {
+        return false;
+    }
+    return by.by === "name";
+}
+exports.isByExpression = isByExpression;
+function refIsStructDef(ref) {
+    return typeof ref !== "string" && ref.type === "struct";
+}
+exports.refIsStructDef = refIsStructDef;
+function isReduceSegment(pe) {
+    return pe.type === "reduce";
+}
+exports.isReduceSegment = isReduceSegment;
+function isProjectSegment(pe) {
+    return pe.type === "project";
+}
+exports.isProjectSegment = isProjectSegment;
+function isQuerySegment(pe) {
+    return isProjectSegment(pe) || isReduceSegment(pe);
+}
+exports.isQuerySegment = isQuerySegment;
+function isSamplingRows(s) {
+    return s.rows !== undefined;
+}
+exports.isSamplingRows = isSamplingRows;
+function isSamplingPercent(s) {
+    return s.percent !== undefined;
+}
+exports.isSamplingPercent = isSamplingPercent;
+function isSamplingEnable(s) {
+    return s.enable !== undefined;
+}
+exports.isSamplingEnable = isSamplingEnable;
+function isIndexSegment(pe) {
+    return pe.type === "index";
+}
+exports.isIndexSegment = isIndexSegment;
+function isJoinOn(sr) {
+    return ["one", "many", "cross"].includes(sr.type);
+}
+exports.isJoinOn = isJoinOn;
+function isSQLFragment(f) {
+    return f.sql !== undefined;
+}
+exports.isSQLFragment = isSQLFragment;
+function isSQLBlock(sd) {
+    const src = sd.structSource;
+    return src.type == "sql" && src.method == "subquery";
+}
+exports.isSQLBlock = isSQLBlock;
+function isFieldTypeDef(f) {
+    return (f.type === "string" ||
+        f.type === "date" ||
+        f.type === "number" ||
+        f.type === "timestamp" ||
+        f.type === "boolean" ||
+        f.type === "json");
+}
+exports.isFieldTypeDef = isFieldTypeDef;
+function isFieldTimeBased(f) {
+    return f.type === "date" || f.type === "timestamp";
+}
+exports.isFieldTimeBased = isFieldTimeBased;
+function isFieldStructDef(f) {
+    return f.type === "struct";
+}
+exports.isFieldStructDef = isFieldStructDef;
+/** Get the output name for a NamedObject */
+function getIdentifier(n) {
+    if (n.as !== undefined) {
+        return n.as;
+    }
+    return n.name;
+}
+exports.getIdentifier = getIdentifier;
+function isTurtleDef(def) {
+    return def.type === "turtle";
+}
+exports.isTurtleDef = isTurtleDef;
+function isDimensional(field) {
+    var _a;
+    if ("resultMetadata" in field) {
+        return ((_a = field.resultMetadata) === null || _a === void 0 ? void 0 : _a.fieldKind) === "dimension";
+    }
+    return false;
+}
+exports.isDimensional = isDimensional;
+function isPhysical(field) {
+    return ((isFieldTypeDef(field) && field.e === undefined) ||
+        (isFieldStructDef(field) &&
+            (field.structSource.type === "nested" ||
+                field.structSource.type == "inline")));
+}
+exports.isPhysical = isPhysical;
+function getDimensions(structDef) {
+    return structDef.fields.filter(isDimensional);
+}
+exports.getDimensions = getDimensions;
+function getPhysicalFields(structDef) {
+    return structDef.fields.filter(isPhysical);
+}
+exports.getPhysicalFields = getPhysicalFields;
+function isMeasureLike(field) {
+    var _a, _b;
+    if ("resultMetadata" in field) {
+        return (((_a = field.resultMetadata) === null || _a === void 0 ? void 0 : _a.fieldKind) === "measure" ||
+            ((_b = field.resultMetadata) === null || _b === void 0 ? void 0 : _b.fieldKind) === "struct");
+    }
+    return false;
+}
+exports.isMeasureLike = isMeasureLike;
+function isValueString(value, field) {
+    return field.type === "string";
+}
+exports.isValueString = isValueString;
+function isValueNumber(value, field) {
+    return field.type === "number";
+}
+exports.isValueNumber = isValueNumber;
+function isValueBoolean(value, field) {
+    return field.type === "boolean";
+}
+exports.isValueBoolean = isValueBoolean;
+function isValueTimestamp(value, field) {
+    return field.type === "timestamp";
+}
+exports.isValueTimestamp = isValueTimestamp;
+function isValueDate(value, field) {
+    return field.type === "date";
+}
+exports.isValueDate = isValueDate;
+// clang-format on
+//# sourceMappingURL=malloy_types.js.map

package/dist/model/sql_block.d.ts

@@ -0,0 +1,7 @@
+import { SQLBlockSource, SQLPhrase } from "./malloy_types";
+/**
+ * The factory for SQLBlocks. Exists because the name is computed
+ * from the components of the block and that name needs to be
+ * unique, but predictable.
+ */
+export declare function makeSQLBlock(select: SQLPhrase[], connection?: string): SQLBlockSource;

package/dist/model/sql_block.js

@@ -0,0 +1,56 @@
+"use strict";
+/*
+ * Copyright 2023 Google LLC
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files
+ * (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeSQLBlock = void 0;
+const malloy_types_1 = require("./malloy_types");
+const utils_1 = require("./utils");
+/**
+ * The factory for SQLBlocks. Exists because the name is computed
+ * from the components of the block and that name needs to be
+ * unique, but predictable.
+ */
+function makeSQLBlock(select, connection) {
+    const theBlock = {
+        name: `md5:/${connection || "$default"}//${nameFor(select)}`,
+        select,
+    };
+    if (connection) {
+        theBlock.connection = connection;
+    }
+    return theBlock;
+}
+exports.makeSQLBlock = makeSQLBlock;
+// This feels like wrongness on toast, before SQL contained a query we
+// could compute a stable hash from the select property to use to
+// indentify this piece of SQL. Now the actual SQL isn't known until
+// runtime and I am not certain what the right thing to do is, and
+// at this moment when I am still trying to imagine how this is all
+// going to work, I am using stringify(), but I suspect I will be back
+// here for later, and that the whole "how to determine the name of a query"
+// algorithm needs to change
+function nameFor(select) {
+    const phrases = select.map((el) => (0, malloy_types_1.isSQLFragment)(el) ? el.sql : JSON.stringify(el));
+    return (0, utils_1.generateHash)(phrases.join(";"));
+}
+//# sourceMappingURL=sql_block.js.map

package/dist/model/utils.d.ts

@@ -0,0 +1,22 @@
+/** simple indent function */
+export declare function indent(s: string): string;
+/**
+ * Generate a SQL string literal from a given `input` string, safe, e.g., to be used in `WHERE` clauses.
+ */
+export declare function generateSQLStringLiteral(input: string): string;
+/**
+ * WHERE and HAVING clauses are built out of a chain of boolean experssions
+ * joined with AND.
+ */
+export declare class AndChain {
+    private clauses;
+    constructor(intial?: string);
+    clone(): AndChain;
+    add(clause: string): AndChain;
+    addChain(andChain: AndChain): AndChain;
+    empty(): boolean;
+    present(): boolean;
+    sqlOr(): string;
+    sql(whereOrHaving?: "where" | "having"): string;
+}
+export declare function generateHash(input: string): string;

package/dist/model/utils.js

@@ -0,0 +1,102 @@
+"use strict";
+/*
+ * Copyright 2023 Google LLC
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files
+ * (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateHash = exports.AndChain = exports.generateSQLStringLiteral = exports.indent = void 0;
+const md5_1 = __importDefault(require("md5"));
+/** simple indent function */
+function indent(s) {
+    const re = /(^|\n)/g;
+    const lastNewline = /\n {2}$/;
+    return s.replace(re, "$1  ").replace(lastNewline, "\n");
+}
+exports.indent = indent;
+/**
+ * Generate a SQL string literal from a given `input` string, safe, e.g., to be used in `WHERE` clauses.
+ */
+function generateSQLStringLiteral(input) {
+    const escapedString = input.replace(/\\/g, "\\\\").replace(/'/g, "\\'");
+    return `'${escapedString}'`;
+}
+exports.generateSQLStringLiteral = generateSQLStringLiteral;
+/**
+ * WHERE and HAVING clauses are built out of a chain of boolean experssions
+ * joined with AND.
+ */
+class AndChain {
+    constructor(intial) {
+        this.clauses = [];
+        if (intial) {
+            this.clauses.push(intial);
+        }
+    }
+    clone() {
+        const theClone = new AndChain();
+        theClone.addChain(this);
+        return theClone;
+    }
+    add(clause) {
+        this.clauses.push(clause);
+        return this;
+    }
+    addChain(andChain) {
+        this.clauses.push(...andChain.clauses);
+        return this;
+    }
+    empty() {
+        return this.clauses.length === 0;
+    }
+    present() {
+        return this.clauses.length > 0;
+    }
+    sqlOr() {
+        if (this.empty()) {
+            return "";
+        }
+        return this.clauses.map((c) => `(${c})`).join("OR ") + "\n";
+    }
+    sql(whereOrHaving) {
+        if (this.empty()) {
+            return "";
+        }
+        let prefix = "";
+        let postfix = "";
+        if (whereOrHaving) {
+            prefix = whereOrHaving.toUpperCase() + " ";
+            postfix = "\n";
+        }
+        if (this.clauses.length === 1) {
+            return prefix + this.clauses[0] + postfix;
+        }
+        return prefix + this.clauses.map((c) => `(${c})`).join("\nAND ") + postfix;
+    }
+}
+exports.AndChain = AndChain;
+function generateHash(input) {
+    return (0, md5_1.default)(input);
+}
+exports.generateHash = generateHash;
+//# sourceMappingURL=utils.js.map

package/dist/run_sql_options.d.ts

@@ -0,0 +1,3 @@
+export interface RunSQLOptions {
+    rowLimit?: number;
+}

package/dist/run_sql_options.js

@@ -0,0 +1,25 @@
+"use strict";
+/*
+ * Copyright 2023 Google LLC
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files
+ * (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=run_sql_options.js.map