@malloydata/malloy 0.0.22-dev230207144036 → 0.0.22-dev230207180844

package/dist/dialect/standardsql.js

@@ -0,0 +1,381 @@
+"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.StandardSQLDialect = void 0;
+const utils_1 = require("../model/utils");
+const malloy_types_1 = require("../model/malloy_types");
+const dialect_1 = require("./dialect");
+const castMap = {
+    number: "float64",
+};
+// These are the units that "TIMESTAMP_ADD" accepts
+const timestampAddUnits = [
+    "microsecond",
+    "millisecond",
+    "second",
+    "minute",
+    "hour",
+    "day",
+];
+const extractMap = {
+    day_of_week: "dayofweek",
+    day_of_year: "dayofyear",
+};
+class StandardSQLDialect extends dialect_1.Dialect {
+    constructor() {
+        super(...arguments);
+        this.name = "standardsql";
+        this.defaultNumberType = "FLOAT64";
+        this.udfPrefix = "__udf";
+        this.hasFinalStage = false;
+        this.stringTypeName = "STRING";
+        this.divisionIsInteger = false;
+        this.supportsSumDistinctFunction = false;
+        this.unnestWithNumbers = false;
+        this.defaultSampling = { enable: false };
+        this.supportUnnestArrayAgg = false;
+        this.supportsCTEinCoorelatedSubQueries = false;
+        this.dontUnionIndex = true; // bigquery can't use a sample table more than once in a query.
+        this.supportsQualify = true;
+        // I think we want an optional list of parameters types that we force a cast to.
+        this.functionInfo = {
+            timestamp_seconds: {
+                returnType: "timestamp",
+            },
+            concat: { returnType: "string" },
+        };
+        this.keywords = `
+  ALL
+  AND
+  ANY
+  ARRAY
+  AS
+  ASC
+  ASSERT_ROWS_MODIFIED
+  AT
+  BETWEEN
+  BY
+  CASE
+  CAST
+  COLLATE
+  CONTAINS
+  CREATE
+  CROSS
+  CUBE
+  CURRENT
+  DEFAULT
+  DEFINE
+  DESC
+  DISTINCT
+  ELSE
+  END
+  ENUM
+  ESCAPE
+  EXCEPT
+  EXCLUDE
+  EXISTS
+  EXTRACT
+  FALSE
+  FETCH
+  FOLLOWING
+  FOR
+  FROM
+  FULL
+  GROUP
+  GROUPING
+  GROUPS
+  HASH
+  HAVING
+  IF
+  IGNORE
+  IN
+  INNER
+  INTERSECT
+  INTERVAL
+  INTO
+  IS
+  JOIN
+  LATERAL
+  LEFT
+  LIKE
+  LIMIT
+  LOOKUP
+  MERGE
+  NATURAL
+  NEW
+  NO
+  NOT
+  NULL
+  NULLS
+  OF
+  ON
+  OR
+  ORDER
+  OUTER
+  OVER
+  PARTITION
+  PRECEDING
+  PROTO
+  RANGE
+  RECURSIVE
+  RESPECT
+  RIGHT
+  ROLLUP
+  ROWS
+  SELECT
+  SET
+  SOME
+  STRUCT
+  TABLESAMPLE
+  THEN
+  TO
+  TREAT
+  TRUE
+  UNBOUNDED
+  UNION
+  UNNEST
+  USING
+  WHEN
+  WHERE
+  WINDOW
+  WITH
+  WITHIN`.split(/\s/);
+    }
+    quoteTablePath(tablePath) {
+        return `\`${tablePath}\``;
+    }
+    sqlGroupSetTable(groupSetCount) {
+        return `CROSS JOIN (SELECT row_number() OVER() -1  group_set FROM UNNEST(GENERATE_ARRAY(0,${groupSetCount},1)))`;
+    }
+    sqlAnyValue(groupSet, fieldName) {
+        return `ANY_VALUE(CASE WHEN group_set=${groupSet} THEN ${fieldName} END)`;
+    }
+    // can array agg or any_value a struct...
+    sqlAggregateTurtle(groupSet, fieldList, orderBy, limit) {
+        let tail = "";
+        if (limit !== undefined) {
+            tail += ` LIMIT ${limit}`;
+        }
+        const fields = fieldList
+            .map((f) => `\n  ${f.sqlExpression} as ${f.sqlOutputName}`)
+            .join(", ");
+        return `ARRAY_AGG(CASE WHEN group_set=${groupSet} THEN STRUCT(${fields}\n  ) END IGNORE NULLS ${orderBy} ${tail})`;
+    }
+    sqlAnyValueTurtle(groupSet, fieldList) {
+        const fields = fieldList
+            .map((f) => `${f.sqlExpression} as ${f.sqlOutputName}`)
+            .join(", ");
+        return `ANY_VALUE(CASE WHEN group_set=${groupSet} THEN STRUCT(${fields}))`;
+    }
+    sqlAnyValueLastTurtle(name, groupSet, sqlName) {
+        return `ANY_VALUE(CASE WHEN group_set=${groupSet} THEN ${name}__${groupSet} END) as ${sqlName}`;
+    }
+    sqlCoaleseMeasuresInline(groupSet, fieldList) {
+        const fields = fieldList
+            .map((f) => `${f.sqlExpression} as ${f.sqlOutputName}`)
+            .join(", ");
+        const nullValues = fieldList
+            .map((f) => `NULL as ${f.sqlOutputName}`)
+            .join(", ");
+        return `COALESCE(ANY_VALUE(CASE WHEN group_set=${groupSet} THEN STRUCT(${fields}) END), STRUCT(${nullValues}))`;
+    }
+    //
+    // this code used to be:
+    //
+    //   from += `JOIN UNNEST(GENERATE_ARRAY(0,${this.maxGroupSet},1)) as group_set\n`;
+    //
+    // BigQuery will allocate more resources if we use a CROSS JOIN so we do that instead.
+    //
+    sqlUnnestAlias(source, alias, fieldList, needDistinctKey, isArray) {
+        if (isArray) {
+            if (needDistinctKey) {
+                return `LEFT JOIN UNNEST(ARRAY(( SELECT AS STRUCT row_number() over() as __row_id, value FROM UNNEST(${source}) value))) as ${alias}`;
+            }
+            else {
+                return `LEFT JOIN UNNEST(ARRAY((SELECT AS STRUCT value FROM unnest(${source}) value))) as ${alias}`;
+            }
+        }
+        else if (needDistinctKey) {
+            return `LEFT JOIN UNNEST(ARRAY(( SELECT AS STRUCT row_number() over() as __row_id, * FROM UNNEST(${source})))) as ${alias}`;
+        }
+        else {
+            return `LEFT JOIN UNNEST(${source}) as ${alias}`;
+        }
+    }
+    sqlSumDistinctHashedKey(sqlDistinctKey) {
+        sqlDistinctKey = `CAST(${sqlDistinctKey} AS STRING)`;
+        const upperPart = `cast(cast(concat('0x', substr(to_hex(md5(${sqlDistinctKey})), 1, 15)) as int64) as numeric) * 4294967296`;
+        const lowerPart = `cast(cast(concat('0x', substr(to_hex(md5(${sqlDistinctKey})), 16, 8)) as int64) as numeric)`;
+        // See the comment below on `sql_sum_distinct` for why we multiply by this decimal
+        const precisionShiftMultiplier = "0.000000001";
+        return `(${upperPart} + ${lowerPart}) * ${precisionShiftMultiplier}`;
+    }
+    sqlGenerateUUID() {
+        return `GENERATE_UUID()`;
+    }
+    sqlFieldReference(alias, fieldName, _fieldType, _isNested, _isArray) {
+        return `${alias}.${fieldName}`;
+    }
+    sqlUnnestPipelineHead(isSingleton, sourceSQLExpression) {
+        let p = sourceSQLExpression;
+        if (isSingleton) {
+            p = `[${p}]`;
+        }
+        return `UNNEST(${p})`;
+    }
+    sqlCreateFunction(id, funcText) {
+        return `CREATE TEMPORARY FUNCTION ${id}(__param ANY TYPE) AS ((\n${(0, utils_1.indent)(funcText)}));\n`;
+    }
+    sqlCreateTableAsSelect(tableName, sql) {
+        return `
+CREATE TABLE IF NOT EXISTS \`${tableName}\`
+OPTIONS (
+    expiration_timestamp=TIMESTAMP_ADD(current_timestamp(),  INTERVAL 1 hour)
+)
+AS (
+${(0, utils_1.indent)(sql)}
+);
+`;
+    }
+    sqlCreateFunctionCombineLastStage(lastStageName) {
+        return `SELECT ARRAY((SELECT AS STRUCT * FROM ${lastStageName}))\n`;
+    }
+    sqlSelectAliasAsStruct(alias) {
+        return `(SELECT AS STRUCT ${alias}.*)`;
+    }
+    sqlMaybeQuoteIdentifier(identifier) {
+        return this.keywords.indexOf(identifier.toUpperCase()) > 0
+            ? "`" + identifier + "`"
+            : identifier;
+    }
+    sqlNow() {
+        return (0, malloy_types_1.mkExpr) `CURRENT_TIMESTAMP()`;
+    }
+    sqlTrunc(sqlTime, units) {
+        if (sqlTime.valueType == "date") {
+            if ((0, malloy_types_1.isDateUnit)(units)) {
+                return (0, malloy_types_1.mkExpr) `DATE_TRUNC(${sqlTime.value},${units})`;
+            }
+            return (0, malloy_types_1.mkExpr) `TIMESTAMP(${sqlTime.value})`;
+        }
+        return (0, malloy_types_1.mkExpr) `TIMESTAMP_TRUNC(${sqlTime.value},${units})`;
+    }
+    sqlExtract(expr, units) {
+        const extractTo = extractMap[units] || units;
+        return (0, malloy_types_1.mkExpr) `EXTRACT(${extractTo} FROM ${expr.value})`;
+    }
+    sqlAlterTime(op, expr, n, timeframe) {
+        let theTime = expr.value;
+        let computeType = expr.valueType;
+        if (timeframe != "day" && timestampAddUnits.includes(timeframe)) {
+            // The units must be done in timestamp, no matter the input type
+            computeType = "timestamp";
+            if (expr.valueType != "timestamp") {
+                theTime = (0, malloy_types_1.mkExpr) `TIMESTAMP(${theTime})`;
+            }
+        }
+        else if (expr.valueType == "timestamp") {
+            theTime = (0, malloy_types_1.mkExpr) `DATETIME(${theTime})`;
+            computeType = "datetime";
+        }
+        const funcName = computeType.toUpperCase() + (op == "+" ? "_ADD" : "_SUB");
+        const newTime = (0, malloy_types_1.mkExpr) `${funcName}(${theTime}, INTERVAL ${n} ${timeframe})`;
+        return computeType == "datetime" ? (0, malloy_types_1.mkExpr) `TIMESTAMP(${newTime})` : newTime;
+    }
+    ignoreInProject(fieldName) {
+        return fieldName === "_PARTITIONTIME";
+    }
+    sqlCast(cast) {
+        if (cast.srcType !== cast.dstType) {
+            const dstType = castMap[cast.dstType] || cast.dstType;
+            // This just makes the code look a little prettier ...
+            if (!cast.safe && cast.srcType && (0, malloy_types_1.isTimeFieldType)(cast.srcType)) {
+                if (dstType == "date") {
+                    return (0, malloy_types_1.mkExpr) `DATE(${cast.expr})`;
+                }
+                return (0, malloy_types_1.mkExpr) `TIMESTAMP(${cast.expr})`;
+            }
+            const castFunc = cast.safe ? "SAFE_CAST" : "CAST";
+            return (0, malloy_types_1.mkExpr) `${castFunc}(${cast.expr}  AS ${dstType})`;
+        }
+        return cast.expr;
+    }
+    sqlRegexpMatch(expr, regexp) {
+        return (0, malloy_types_1.mkExpr) `REGEXP_CONTAINS(${expr}, r${regexp})`;
+    }
+    sqlLiteralTime(timeString, type, timezone) {
+        if (type === "date") {
+            return `DATE('${timeString}')`;
+        }
+        else if (type === "timestamp") {
+            return `TIMESTAMP('${timeString}', '${timezone}')`;
+        }
+        else {
+            throw new Error(`Unknown Liternal time format ${type}`);
+        }
+    }
+    sqlMeasureTime(from, to, units) {
+        let lVal = from.value;
+        let rVal = to.value;
+        let diffUsing = "TIMESTAMP_DIFF";
+        if (units == "second" || units == "minute" || units == "hour") {
+            if (from.valueType != "timestamp") {
+                lVal = (0, malloy_types_1.mkExpr) `TIMESTAMP(${lVal})`;
+            }
+            if (to.valueType != "timestamp") {
+                rVal = (0, malloy_types_1.mkExpr) `TIMESTAMP(${rVal})`;
+            }
+        }
+        else {
+            diffUsing = "DATE_DIFF";
+            if (from.valueType != "date") {
+                lVal = (0, malloy_types_1.mkExpr) `DATE(${lVal})`;
+            }
+            if (to.valueType != "date") {
+                rVal = (0, malloy_types_1.mkExpr) `DATE(${rVal})`;
+            }
+        }
+        return (0, malloy_types_1.mkExpr) `${diffUsing}(${rVal}, ${lVal}, ${units})`;
+    }
+    sqlSampleTable(tableSQL, sample) {
+        if (sample !== undefined) {
+            if ((0, malloy_types_1.isSamplingEnable)(sample) && sample.enable) {
+                sample = this.defaultSampling;
+            }
+            if ((0, malloy_types_1.isSamplingRows)(sample)) {
+                throw new Error(`StandardSQL doesn't support sampling by rows only percent`);
+            }
+            else if ((0, malloy_types_1.isSamplingPercent)(sample)) {
+                return `(SELECT * FROM ${tableSQL}  TABLESAMPLE SYSTEM (${sample.percent} PERCENT))`;
+            }
+        }
+        return tableSQL;
+    }
+    sqlLiteralString(literal) {
+        const noVirgule = literal.replace(/\\/g, "\\\\");
+        return "'" + noVirgule.replace(/'/g, "\\'") + "'";
+    }
+}
+exports.StandardSQLDialect = StandardSQLDialect;
+//# sourceMappingURL=standardsql.js.map

package/dist/index.d.ts

@@ -0,0 +1,10 @@
+export type { QueryDataRow, Fragment, StructDef, StructRelationship, NamedStructDefs, MalloyQueryData, AtomicFieldType as AtomicFieldTypeInner, DateUnit, ExtractUnit, TimestampUnit, TimeFieldType, QueryData, FieldTypeDef, Expr, DialectFragment, TimeValue, FilterExpression, SQLBlock, FieldDef, FilteredAliasedName, PipeSegment, QueryFieldDef, TurtleDef, SearchValueMapResult, SearchIndexResult, ModelDef, Query, NamedQuery, NamedModelObject, ExpressionType, } from "./model";
+export { Segment, isFilteredAliasedName, flattenQuery, expressionIsCalculation, } from "./model";
+export { HighlightType, MalloyTranslator, } from "./lang";
+export type { LogMessage, TranslateResponse } from "./lang";
+export { Malloy, Runtime, AtomicFieldType, ConnectionRuntime, SingleConnectionRuntime, EmptyURLReader, InMemoryURLReader, FixedConnectionMap, MalloyError, JoinRelationship, SourceRelationship, DateTimeframe, TimestampTimeframe, Result, parseTableURI, QueryMaterializer, CSVWriter, JSONWriter, DataWriter, } from "./malloy";
+export type { Explore, Model, PreparedQuery, PreparedResult, Field, AtomicField, ExploreField, QueryField, DataArray, DataRecord, DataColumn, DataArrayOrRecord, ModelMaterializer, DocumentSymbol, DocumentHighlight, ResultJSON, PreparedResultMaterializer, SQLBlockMaterializer, ExploreMaterializer, WriteStream, } from "./malloy";
+export type { RunSQLOptions } from "./run_sql_options";
+export type { URLReader, InfoConnection, LookupConnection, Connection, QueryString, ModelString, QueryURL, ModelURL, PooledConnection, TestableConnection, PersistSQLResults, StreamingConnection, } from "./runtime_types";
+export type { Loggable } from "./malloy";
+export { toAsyncGenerator } from "./connection_utils";

package/dist/index.js

@@ -0,0 +1,59 @@
+"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.toAsyncGenerator = exports.DataWriter = exports.JSONWriter = exports.CSVWriter = exports.QueryMaterializer = exports.parseTableURI = exports.Result = exports.TimestampTimeframe = exports.DateTimeframe = exports.SourceRelationship = exports.JoinRelationship = exports.MalloyError = exports.FixedConnectionMap = exports.InMemoryURLReader = exports.EmptyURLReader = exports.SingleConnectionRuntime = exports.ConnectionRuntime = exports.AtomicFieldType = exports.Runtime = exports.Malloy = exports.MalloyTranslator = exports.HighlightType = exports.expressionIsCalculation = exports.flattenQuery = exports.isFilteredAliasedName = exports.Segment = void 0;
+var model_1 = require("./model");
+// Used in Composer Demo
+Object.defineProperty(exports, "Segment", { enumerable: true, get: function () { return model_1.Segment; } });
+Object.defineProperty(exports, "isFilteredAliasedName", { enumerable: true, get: function () { return model_1.isFilteredAliasedName; } });
+Object.defineProperty(exports, "flattenQuery", { enumerable: true, get: function () { return model_1.flattenQuery; } });
+Object.defineProperty(exports, "expressionIsCalculation", { enumerable: true, get: function () { return model_1.expressionIsCalculation; } });
+var lang_1 = require("./lang");
+// Neede for VSCode extension
+Object.defineProperty(exports, "HighlightType", { enumerable: true, get: function () { return lang_1.HighlightType; } });
+// Needed for tests only
+Object.defineProperty(exports, "MalloyTranslator", { enumerable: true, get: function () { return lang_1.MalloyTranslator; } });
+var malloy_1 = require("./malloy");
+Object.defineProperty(exports, "Malloy", { enumerable: true, get: function () { return malloy_1.Malloy; } });
+Object.defineProperty(exports, "Runtime", { enumerable: true, get: function () { return malloy_1.Runtime; } });
+Object.defineProperty(exports, "AtomicFieldType", { enumerable: true, get: function () { return malloy_1.AtomicFieldType; } });
+Object.defineProperty(exports, "ConnectionRuntime", { enumerable: true, get: function () { return malloy_1.ConnectionRuntime; } });
+Object.defineProperty(exports, "SingleConnectionRuntime", { enumerable: true, get: function () { return malloy_1.SingleConnectionRuntime; } });
+Object.defineProperty(exports, "EmptyURLReader", { enumerable: true, get: function () { return malloy_1.EmptyURLReader; } });
+Object.defineProperty(exports, "InMemoryURLReader", { enumerable: true, get: function () { return malloy_1.InMemoryURLReader; } });
+Object.defineProperty(exports, "FixedConnectionMap", { enumerable: true, get: function () { return malloy_1.FixedConnectionMap; } });
+Object.defineProperty(exports, "MalloyError", { enumerable: true, get: function () { return malloy_1.MalloyError; } });
+Object.defineProperty(exports, "JoinRelationship", { enumerable: true, get: function () { return malloy_1.JoinRelationship; } });
+Object.defineProperty(exports, "SourceRelationship", { enumerable: true, get: function () { return malloy_1.SourceRelationship; } });
+Object.defineProperty(exports, "DateTimeframe", { enumerable: true, get: function () { return malloy_1.DateTimeframe; } });
+Object.defineProperty(exports, "TimestampTimeframe", { enumerable: true, get: function () { return malloy_1.TimestampTimeframe; } });
+Object.defineProperty(exports, "Result", { enumerable: true, get: function () { return malloy_1.Result; } });
+Object.defineProperty(exports, "parseTableURI", { enumerable: true, get: function () { return malloy_1.parseTableURI; } });
+Object.defineProperty(exports, "QueryMaterializer", { enumerable: true, get: function () { return malloy_1.QueryMaterializer; } });
+Object.defineProperty(exports, "CSVWriter", { enumerable: true, get: function () { return malloy_1.CSVWriter; } });
+Object.defineProperty(exports, "JSONWriter", { enumerable: true, get: function () { return malloy_1.JSONWriter; } });
+Object.defineProperty(exports, "DataWriter", { enumerable: true, get: function () { return malloy_1.DataWriter; } });
+var connection_utils_1 = require("./connection_utils");
+Object.defineProperty(exports, "toAsyncGenerator", { enumerable: true, get: function () { return connection_utils_1.toAsyncGenerator; } });
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,10 @@
+import { ExprValue } from "./types/expr-value";
+/**
+ * When a translation hits an error, log and return one of these as a value.
+ * This will allow the rest of the translation walk to complete. The
+ * generated SQL will have a reference to an impossible variable name
+ * with the reason embedded in it.
+ * @param reason very short phrase, only read by implementers
+ * @returns Fragment[] which a debugging humnan will regognize
+ */
+export declare function errorFor(reason: string): ExprValue;

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

@@ -0,0 +1,42 @@
+"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.errorFor = void 0;
+/**
+ * When a translation hits an error, log and return one of these as a value.
+ * This will allow the rest of the translation walk to complete. The
+ * generated SQL will have a reference to an impossible variable name
+ * with the reason embedded in it.
+ * @param reason very short phrase, only read by implementers
+ * @returns Fragment[] which a debugging humnan will regognize
+ */
+function errorFor(reason) {
+    return {
+        dataType: "unknown",
+        expressionType: "scalar",
+        value: [`_ERROR_${reason.replace(/ /g, "_")}`],
+    };
+}
+exports.errorFor = errorFor;
+//# sourceMappingURL=ast-utils.js.map

package/dist/lang/ast/elements/define-query.d.ts

@@ -0,0 +1,14 @@
+import { ModelDataRequest } from "../../translate-response";
+import { DocStatement, Document, MalloyElement, RunList } from "../types/malloy-element";
+import { QueryElement } from "../types/query-element";
+export declare class DefineQuery extends MalloyElement implements DocStatement {
+    readonly name: string;
+    readonly queryDetails: QueryElement;
+    elementType: string;
+    constructor(name: string, queryDetails: QueryElement);
+    execute(doc: Document): ModelDataRequest;
+}
+export declare class DefineQueryList extends RunList implements DocStatement {
+    constructor(queryList: DefineQuery[]);
+    execute(doc: Document): ModelDataRequest;
+}

package/dist/lang/ast/elements/define-query.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.DefineQueryList = exports.DefineQuery = void 0;
+const malloy_element_1 = require("../types/malloy-element");
+class DefineQuery extends malloy_element_1.MalloyElement {
+    constructor(name, queryDetails) {
+        super({ queryDetails });
+        this.name = name;
+        this.queryDetails = queryDetails;
+        this.elementType = "defineQuery";
+    }
+    execute(doc) {
+        const entry = {
+            ...this.queryDetails.query(),
+            type: "query",
+            name: this.name,
+            location: this.location,
+        };
+        const exported = false;
+        doc.setEntry(this.name, { entry, exported });
+        return undefined;
+    }
+}
+exports.DefineQuery = DefineQuery;
+class DefineQueryList extends malloy_element_1.RunList {
+    constructor(queryList) {
+        super("defineQueries", queryList);
+    }
+    execute(doc) {
+        return this.executeList(doc);
+    }
+}
+exports.DefineQueryList = DefineQueryList;
+//# sourceMappingURL=define-query.js.map

package/dist/lang/ast/elements/define-source.d.ts

@@ -0,0 +1,17 @@
+import { ModelDataRequest } from "../../translate-response";
+import { DocStatement, Document, MalloyElement, RunList } from "../types/malloy-element";
+import { HasParameter } from "../parameters/has-parameter";
+import { Source } from "./source";
+export declare class DefineSource extends MalloyElement implements DocStatement {
+    readonly name: string;
+    readonly theSource: Source;
+    readonly exported: boolean;
+    elementType: string;
+    readonly parameters?: HasParameter[];
+    constructor(name: string, theSource: Source, exported: boolean, params?: MalloyElement[]);
+    execute(doc: Document): ModelDataRequest;
+}
+export declare class DefineSourceList extends RunList implements DocStatement {
+    constructor(sourceList: DefineSource[]);
+    execute(doc: Document): ModelDataRequest;
+}

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

@@ -0,0 +1,79 @@
+"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.DefineSourceList = exports.DefineSource = void 0;
+const malloy_element_1 = require("../types/malloy-element");
+const has_parameter_1 = require("../parameters/has-parameter");
+const error_factory_1 = require("../error-factory");
+class DefineSource extends malloy_element_1.MalloyElement {
+    constructor(name, theSource, exported, params) {
+        super({ explore: theSource });
+        this.name = name;
+        this.theSource = theSource;
+        this.exported = exported;
+        this.elementType = "defineSource";
+        if (params) {
+            this.parameters = [];
+            for (const el of params) {
+                if (el instanceof has_parameter_1.HasParameter) {
+                    this.parameters.push(el);
+                }
+                else {
+                    this.log(`Unexpected element type in define statement: ${el.elementType}`);
+                }
+            }
+            this.has({ parameters: this.parameters });
+        }
+    }
+    execute(doc) {
+        if (doc.modelEntry(this.name)) {
+            this.log(`Cannot redefine '${this.name}'`);
+        }
+        else {
+            const structDef = this.theSource.withParameters(this.parameters);
+            if (error_factory_1.ErrorFactory.isErrorStructDef(structDef)) {
+                return;
+            }
+            doc.setEntry(this.name, {
+                entry: {
+                    ...structDef,
+                    as: this.name,
+                    location: this.location,
+                },
+                exported: this.exported,
+            });
+        }
+    }
+}
+exports.DefineSource = DefineSource;
+class DefineSourceList extends malloy_element_1.RunList {
+    constructor(sourceList) {
+        super("defineSources", sourceList);
+    }
+    execute(doc) {
+        return this.executeList(doc);
+    }
+}
+exports.DefineSourceList = DefineSourceList;
+//# sourceMappingURL=define-source.js.map