@malloydata/malloy 0.0.133-dev240319171426 → 0.0.133

package/dist/dialect/dialect_map.js

@@ -27,6 +27,7 @@ const duckdb_1 = require("./duckdb");
 const postgres_1 = require("./postgres");
 const snowflake_1 = require("./snowflake");
 const standardsql_1 = require("./standardsql");
+const trino_1 = require("./trino");
 const dialectMap = new Map();
 function getDialect(name) {
     const d = dialectMap.get(name);
@@ -44,6 +45,7 @@ registerDialect(new postgres_1.PostgresDialect());
 registerDialect(new standardsql_1.StandardSQLDialect());
 registerDialect(new duckdb_1.DuckDBDialect());
 registerDialect(new snowflake_1.SnowflakeDialect());
+registerDialect(new trino_1.TrinoDialect());
 function paramsEqual(a, b) {
     return (a.params.length === b.params.length &&
         a.params.every((param, i) => {

package/dist/dialect/index.d.ts

@@ -6,5 +6,6 @@ export { StandardSQLDialect } from './standardsql';
 export { PostgresDialect } from './postgres';
 export { DuckDBDialect } from './duckdb';
 export { SnowflakeDialect } from './snowflake';
+export { TrinoDialect } from './trino';
 export { getDialect, registerDialect, getDialectFunction } from './dialect_map';
 export { FUNCTIONS } from './functions';

package/dist/dialect/index.js

@@ -22,7 +22,7 @@
  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.FUNCTIONS = exports.getDialectFunction = exports.registerDialect = exports.getDialect = exports.SnowflakeDialect = exports.DuckDBDialect = exports.PostgresDialect = exports.StandardSQLDialect = exports.qtz = exports.Dialect = exports.sql = exports.literal = exports.params = exports.param = exports.sqlFragment = exports.spread = exports.maxScalar = exports.minAggregate = exports.minScalar = exports.overload = exports.makeParam = exports.anyExprType = exports.arg = void 0;
+exports.FUNCTIONS = exports.getDialectFunction = exports.registerDialect = exports.getDialect = exports.TrinoDialect = exports.SnowflakeDialect = exports.DuckDBDialect = exports.PostgresDialect = exports.StandardSQLDialect = exports.qtz = exports.Dialect = exports.sql = exports.literal = exports.params = exports.param = exports.sqlFragment = exports.spread = exports.maxScalar = exports.minAggregate = exports.minScalar = exports.overload = exports.makeParam = exports.anyExprType = exports.arg = void 0;
 var util_1 = require("./functions/util");
 Object.defineProperty(exports, "arg", { enumerable: true, get: function () { return util_1.arg; } });
 Object.defineProperty(exports, "anyExprType", { enumerable: true, get: function () { return util_1.anyExprType; } });
@@ -48,6 +48,8 @@ var duckdb_1 = require("./duckdb");
 Object.defineProperty(exports, "DuckDBDialect", { enumerable: true, get: function () { return duckdb_1.DuckDBDialect; } });
 var snowflake_1 = require("./snowflake");
 Object.defineProperty(exports, "SnowflakeDialect", { enumerable: true, get: function () { return snowflake_1.SnowflakeDialect; } });
+var trino_1 = require("./trino");
+Object.defineProperty(exports, "TrinoDialect", { enumerable: true, get: function () { return trino_1.TrinoDialect; } });
 var dialect_map_1 = require("./dialect_map");
 Object.defineProperty(exports, "getDialect", { enumerable: true, get: function () { return dialect_map_1.getDialect; } });
 Object.defineProperty(exports, "registerDialect", { enumerable: true, get: function () { return dialect_map_1.registerDialect; } });

package/dist/dialect/trino/functions/index.d.ts

@@ -0,0 +1 @@
+export { TRINO_FUNCTIONS } from './trino_functions';

package/dist/dialect/trino/functions/index.js

@@ -0,0 +1,28 @@
+"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.TRINO_FUNCTIONS = void 0;
+var trino_functions_1 = require("./trino_functions");
+Object.defineProperty(exports, "TRINO_FUNCTIONS", { enumerable: true, get: function () { return trino_functions_1.TRINO_FUNCTIONS; } });
+//# sourceMappingURL=index.js.map

package/dist/dialect/trino/functions/trino_functions.d.ts

@@ -0,0 +1 @@
+export declare const TRINO_FUNCTIONS: import("../../functions/function_map").FunctionMap;

package/dist/dialect/trino/functions/trino_functions.js

@@ -0,0 +1,29 @@
+"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.TRINO_FUNCTIONS = void 0;
+const functions_1 = require("../../functions");
+exports.TRINO_FUNCTIONS = functions_1.FUNCTIONS.clone();
+exports.TRINO_FUNCTIONS.seal();
+//# sourceMappingURL=trino_functions.js.map

package/dist/dialect/trino/index.d.ts

@@ -0,0 +1 @@
+export * from './trino';

package/dist/dialect/trino/index.js

@@ -0,0 +1,40 @@
+"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 __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+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 });
+__exportStar(require("./trino"), exports);
+//# sourceMappingURL=index.js.map

package/dist/dialect/trino/trino.d.ts

@@ -0,0 +1,60 @@
+import { Expr, ExtractUnit, Sampling, TimeValue, TimestampUnit, TypecastFragment, FieldAtomicTypeDef } from '../../model/malloy_types';
+import { DialectFunctionOverloadDef } from '../functions';
+import { Dialect, DialectFieldList, QueryInfo } from '../dialect';
+export declare class TrinoDialect extends Dialect {
+    name: string;
+    defaultNumberType: string;
+    defaultDecimalType: string;
+    udfPrefix: string;
+    hasFinalStage: boolean;
+    divisionIsInteger: boolean;
+    supportsSumDistinctFunction: boolean;
+    unnestWithNumbers: boolean;
+    defaultSampling: {
+        enable: boolean;
+    };
+    supportUnnestArrayAgg: boolean;
+    supportsAggDistinct: boolean;
+    supportsCTEinCoorelatedSubQueries: boolean;
+    dontUnionIndex: boolean;
+    supportsQualify: boolean;
+    supportsSafeCast: boolean;
+    supportsNesting: boolean;
+    cantPartitionWindowFunctionsOnExpressions: boolean;
+    quoteTablePath(tablePath: string): string;
+    sqlGroupSetTable(groupSetCount: number): string;
+    sqlAnyValue(groupSet: number, fieldName: string): string;
+    sqlAggregateTurtle(groupSet: number, fieldList: DialectFieldList, orderBy: string | undefined, limit: number | undefined): string;
+    sqlAnyValueTurtle(groupSet: number, fieldList: DialectFieldList): string;
+    sqlAnyValueLastTurtle(name: string, groupSet: number, sqlName: string): string;
+    sqlCoaleseMeasuresInline(groupSet: number, fieldList: DialectFieldList): string;
+    sqlUnnestAlias(source: string, alias: string, fieldList: DialectFieldList, needDistinctKey: boolean, isArray: boolean, _isInNestedPipeline: boolean): string;
+    sqlSumDistinctHashedKey(sqlDistinctKey: string): string;
+    sqlGenerateUUID(): string;
+    sqlFieldReference(alias: string, fieldName: string, _fieldType: string, _isNested: boolean, _isArray: boolean): string;
+    sqlUnnestPipelineHead(isSingleton: boolean, sourceSQLExpression: string): string;
+    sqlCreateFunction(id: string, funcText: string): string;
+    sqlCreateTableAsSelect(tableName: string, sql: string): string;
+    sqlCreateFunctionCombineLastStage(lastStageName: string): string;
+    sqlSelectAliasAsStruct(alias: string): string;
+    keywords: string[];
+    sqlMaybeQuoteIdentifier(identifier: string): string;
+    sqlNow(): Expr;
+    sqlTrunc(qi: QueryInfo, sqlTime: TimeValue, units: TimestampUnit): Expr;
+    sqlExtract(qi: QueryInfo, expr: TimeValue, units: ExtractUnit): Expr;
+    sqlAlterTime(op: '+' | '-', expr: TimeValue, n: Expr, timeframe: TimestampUnit): Expr;
+    ignoreInProject(fieldName: string): boolean;
+    sqlCast(qi: QueryInfo, cast: TypecastFragment): Expr;
+    sqlRegexpMatch(expr: Expr, regexp: Expr): Expr;
+    sqlLiteralTime(qi: QueryInfo, timeString: string, type: 'date' | 'timestamp', timezone: string | undefined): string;
+    sqlMeasureTime(from: TimeValue, to: TimeValue, units: string): Expr;
+    sqlSampleTable(tableSQL: string, sample: Sampling | undefined): string;
+    sqlLiteralString(literal: string): string;
+    sqlLiteralRegexp(literal: string): string;
+    getGlobalFunctionDef(name: string): DialectFunctionOverloadDef[] | undefined;
+    malloyTypeToSQLType(malloyType: FieldAtomicTypeDef): string;
+    sqlTypeToMalloyType(_sqlType: string): FieldAtomicTypeDef | undefined;
+    castToString(expression: string): string;
+    concat(...values: string[]): string;
+    validateTypeName(sqlType: string): boolean;
+}

package/dist/dialect/trino/trino.js

@@ -0,0 +1,456 @@
+"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.TrinoDialect = void 0;
+const utils_1 = require("../../model/utils");
+const malloy_types_1 = require("../../model/malloy_types");
+const functions_1 = require("./functions");
+const dialect_1 = require("../dialect");
+// These are the units that "TIMESTAMP_ADD" "TIMESTAMP_DIFF" accept
+function timestampMeasureable(units) {
+    return [
+        'microsecond',
+        'millisecond',
+        'second',
+        'minute',
+        'hour',
+        'day',
+    ].includes(units);
+}
+function dateMeasureable(units) {
+    return ['day', 'week', 'month', 'quarter', 'year'].includes(units);
+}
+const extractMap = {
+    'day_of_week': 'dayofweek',
+    'day_of_year': 'dayofyear',
+};
+/**
+ * Return a non UTC timezone, if one was specificed.
+ */
+function qtz(qi) {
+    const tz = qi.queryTimezone;
+    if (tz && tz !== 'UTC') {
+        return tz;
+    }
+}
+class TrinoDialect extends dialect_1.Dialect {
+    constructor() {
+        super(...arguments);
+        this.name = 'trino';
+        this.defaultNumberType = 'FLOAT64';
+        this.defaultDecimalType = 'NUMERIC';
+        this.udfPrefix = '__udf';
+        this.hasFinalStage = false;
+        this.divisionIsInteger = false;
+        this.supportsSumDistinctFunction = false;
+        this.unnestWithNumbers = false;
+        this.defaultSampling = { enable: false };
+        this.supportUnnestArrayAgg = false;
+        this.supportsAggDistinct = false;
+        this.supportsCTEinCoorelatedSubQueries = false;
+        this.dontUnionIndex = true; // bigquery can't use a sample table more than once in a query.
+        this.supportsQualify = true;
+        this.supportsSafeCast = true;
+        this.supportsNesting = true;
+        this.cantPartitionWindowFunctionsOnExpressions = true;
+        // TODO(figutierrez): update.
+        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) {
+        // TODO: look into escaping.
+        return `${tablePath.replace(/malloytest/g, 'malloy_demo.faa')}`;
+    }
+    sqlGroupSetTable(groupSetCount) {
+        return `CROSS JOIN (SELECT row_number() OVER() -1  group_set FROM UNNEST(SEQUENCE(0,${groupSetCount})))`;
+    }
+    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.sqlOutputName}' VALUE ${f.sqlExpression}`)
+            .join(', ');
+        return `cast(COALESCE(SLICE(COALESCE(ARRAY_AGG(CASE WHEN group_set=${groupSet} THEN JSON_PARSE(JSON_OBJECT(${fields})) END \n ${orderBy} -- ${tail}\n), ARRAY[]), 1, ${limit}), ARRAY[]) as json)`;
+    }
+    sqlAnyValueTurtle(groupSet, fieldList) {
+        const fields = fieldList
+            .map(f => `\n '${f.sqlOutputName}' VALUE ${f.sqlExpression}`)
+            .join(', ');
+        return `ANY_VALUE(CASE WHEN group_set=${groupSet} THEN JSON_OBJECT(${fields}))`;
+    }
+    sqlAnyValueLastTurtle(name, groupSet, sqlName) {
+        return `ANY_VALUE(CASE WHEN group_set=${groupSet} THEN ${name} 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, _isInNestedPipeline) {
+        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;
+        return identifier;
+        // TODO: may need to escape;
+        //return `"${identifier}"`;
+    }
+    sqlNow() {
+        return (0, malloy_types_1.mkExpr) `CURRENT_TIMESTAMP()`;
+    }
+    sqlTrunc(qi, sqlTime, units) {
+        const tz = qtz(qi);
+        const tzAdd = tz ? `, "${tz}"` : '';
+        if (sqlTime.valueType === 'date') {
+            if (dateMeasureable(units)) {
+                return (0, malloy_types_1.mkExpr) `DATE_TRUNC(${sqlTime.value},${units})`;
+            }
+            return (0, malloy_types_1.mkExpr) `TIMESTAMP(${sqlTime.value}${tzAdd})`;
+        }
+        return (0, malloy_types_1.mkExpr) `TIMESTAMP_TRUNC(${sqlTime.value},${units}${tzAdd})`;
+    }
+    sqlExtract(qi, expr, units) {
+        const extractTo = extractMap[units] || units;
+        const tz = expr.valueType === 'timestamp' && qtz(qi);
+        const tzAdd = tz ? ` AT TIME ZONE '${tz}'` : '';
+        return (0, malloy_types_1.mkExpr) `EXTRACT(${extractTo} FROM ${expr.value}${tzAdd})`;
+    }
+    sqlAlterTime(op, expr, n, timeframe) {
+        let theTime = expr.value;
+        let computeType = expr.valueType;
+        if (timeframe !== 'day' && timestampMeasureable(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})`;
+        if (computeType === expr.valueType) {
+            return newTime;
+        }
+        return (0, malloy_types_1.mkExpr) `${expr.valueType.toUpperCase()}(${newTime})`;
+    }
+    ignoreInProject(fieldName) {
+        return fieldName === '_PARTITIONTIME';
+    }
+    sqlCast(qi, cast) {
+        const op = `${cast.srcType}::${cast.dstType}`;
+        const tz = qtz(qi);
+        if (op === 'timestamp::date' && tz) {
+            return (0, malloy_types_1.mkExpr) `DATE(${cast.expr},'${tz}')`;
+        }
+        if (op === 'date::timestamp' && tz) {
+            return (0, malloy_types_1.mkExpr) `TIMESTAMP(${cast.expr}, '${tz}')`;
+        }
+        if (cast.srcType !== cast.dstType) {
+            const dstType = typeof cast.dstType === 'string'
+                ? this.malloyTypeToSQLType({ type: cast.dstType })
+                : cast.dstType.raw;
+            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}, ${regexp})`;
+    }
+    sqlLiteralTime(qi, timeString, type, timezone) {
+        if (type === 'date') {
+            return `DATE('${timeString}')`;
+        }
+        else if (type === 'timestamp') {
+            let timestampArgs = `'${timeString}'`;
+            const tz = timezone || qtz(qi);
+            if (tz && tz !== 'UTC') {
+                timestampArgs += `,'${tz}'`;
+            }
+            return `TIMESTAMP(${timestampArgs})`;
+        }
+        else {
+            throw new Error(`Unsupported Literal time format ${type}`);
+        }
+    }
+    sqlMeasureTime(from, to, units) {
+        const measureMap = {
+            'microsecond': { use: 'microsecond', ratio: 1 },
+            'millisecond': { use: 'microsecond', ratio: 1000 },
+            'second': { use: 'millisecond', ratio: 1000 },
+            'minute': { use: 'second', ratio: 60 },
+            'hour': { use: 'minute', ratio: 60 },
+            'day': { use: 'hour', ratio: 24 },
+            'week': { use: 'day', ratio: 7 },
+        };
+        let lVal = from.value;
+        let rVal = to.value;
+        if (measureMap[units]) {
+            const { use: measureIn, ratio } = measureMap[units];
+            if (!timestampMeasureable(measureIn)) {
+                throw new Error(`Measure in '${measureIn} not implemented`);
+            }
+            if (from.valueType !== to.valueType) {
+                throw new Error("Can't measure difference between different types");
+            }
+            if (from.valueType === 'date') {
+                lVal = (0, malloy_types_1.mkExpr) `TIMESTAMP(${lVal})`;
+                rVal = (0, malloy_types_1.mkExpr) `TIMESTAMP(${rVal})`;
+            }
+            let measured = (0, malloy_types_1.mkExpr) `TIMESTAMP_DIFF(${rVal},${lVal},${measureIn})`;
+            if (ratio !== 1) {
+                measured = (0, malloy_types_1.mkExpr) `FLOOR(${measured}/${ratio.toString()}.0)`;
+            }
+            return measured;
+        }
+        throw new Error(`Measure '${units} not implemented`);
+    }
+    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, "\\'") + "'";
+    }
+    sqlLiteralRegexp(literal) {
+        const noVirgule = literal.replace(/\\/g, '\\\\');
+        return "'" + noVirgule.replace(/'/g, "\\'") + "'";
+    }
+    getGlobalFunctionDef(name) {
+        // TODO: implement
+        return functions_1.TRINO_FUNCTIONS.get(name);
+    }
+    malloyTypeToSQLType(malloyType) {
+        if (malloyType.type === 'number') {
+            if (malloyType.numberType === 'integer') {
+                return 'INT64';
+            }
+            else {
+                return 'FLOAT64';
+            }
+        }
+        return malloyType.type;
+    }
+    sqlTypeToMalloyType(_sqlType) {
+        // TODO(figutierrez): unimplemented.
+        return undefined;
+    }
+    castToString(expression) {
+        return `CAST(${expression} as STRING)`;
+    }
+    concat(...values) {
+        return values.join(' || ');
+    }
+    validateTypeName(sqlType) {
+        // Letters:              BIGINT
+        // Numbers:              INT8
+        // Spaces,
+        // Parentheses, Commas:  NUMERIC(5, 2)
+        // Angle Brackets:       ARRAY<INT64>
+        return sqlType.match(/^[A-Za-z\s(),<>0-9]*$/) !== null;
+    }
+}
+exports.TrinoDialect = TrinoDialect;
+//# sourceMappingURL=trino.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@malloydata/malloy",
-  "version": "0.0.133-dev240319171426",
+  "version": "0.0.133",
   "license": "MIT",
   "exports": {
     ".": "./dist/index.js",