@malloydata/malloy 0.0.126-dev240221165840 → 0.0.126-dev240305182920

package/dist/dialect/snowflake/functions/strpos.js

@@ -0,0 +1,35 @@
+"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.fnStrpos = void 0;
+const util_1 = require("../../functions/util");
+function fnStrpos() {
+    const testString = (0, util_1.makeParam)('test_string', (0, util_1.anyExprType)('string'));
+    const searchString = (0, util_1.makeParam)('search_string', (0, util_1.anyExprType)('string'));
+    return [
+        (0, util_1.overload)((0, util_1.minScalar)('number'), [testString.param, searchString.param], (0, util_1.sql) `POSITION(${searchString.arg}, ${testString.arg})`),
+    ];
+}
+exports.fnStrpos = fnStrpos;
+//# sourceMappingURL=strpos.js.map

package/dist/dialect/snowflake/functions/trunc.d.ts

@@ -0,0 +1,2 @@
+import { DialectFunctionOverloadDef } from '../../functions/util';
+export declare function fnTrunc(): DialectFunctionOverloadDef[];

package/dist/dialect/snowflake/functions/trunc.js

@@ -0,0 +1,39 @@
+"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.fnTrunc = void 0;
+const util_1 = require("../../functions/util");
+function fnTrunc() {
+    const value = (0, util_1.makeParam)('value', (0, util_1.anyExprType)('number'));
+    const precision = (0, util_1.makeParam)('precision', (0, util_1.anyExprType)('number'));
+    // trunc function doesn't exist in Snowflake, so we emulate it.
+    // For both overloads, we switch between CEIL and FLOOR based on the sign of the arugment
+    // For the overload with precision, we multiply by a power of 10 before rounding, then divide.
+    return [
+        (0, util_1.overload)((0, util_1.minScalar)('number'), [value.param], (0, util_1.sql) `CASE WHEN ${value.arg} < 0 THEN CEIL(${value.arg}) ELSE FLOOR(${value.arg}) END`),
+        (0, util_1.overload)((0, util_1.minScalar)('number'), [value.param, precision.param], (0, util_1.sql) `CASE WHEN ${value.arg} < 0 THEN CEIL(${value.arg} * POW(10, ${precision.arg})) / POW(10, ${precision.arg}) ELSE FLOOR(${value.arg} * POW(10, ${precision.arg})) / POW(10, ${precision.arg}) END`),
+    ];
+}
+exports.fnTrunc = fnTrunc;
+//# sourceMappingURL=trunc.js.map

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

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

package/dist/dialect/snowflake/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("./snowflake"), exports);
+//# sourceMappingURL=index.js.map

package/dist/dialect/snowflake/snowflake.d.ts

@@ -0,0 +1,62 @@
+import { DateUnit, Expr, ExtractUnit, Sampling, TimeFieldType, TimeValue, TimestampUnit, TypecastFragment, FieldAtomicTypeDef } from '../../model/malloy_types';
+import { DialectFunctionOverloadDef } from '../functions';
+import { Dialect, DialectFieldList, QueryInfo } from '../dialect';
+export declare class SnowflakeDialect extends Dialect {
+    name: string;
+    defaultNumberType: string;
+    defaultDecimalType: string;
+    udfPrefix: string;
+    hasFinalStage: boolean;
+    divisionIsInteger: boolean;
+    supportsSumDistinctFunction: boolean;
+    defaultSampling: {
+        rows: number;
+    };
+    globalFunctions: import("../functions/function_map").FunctionMap;
+    unnestWithNumbers: boolean;
+    supportUnnestArrayAgg: boolean;
+    supportsAggDistinct: boolean;
+    supportsCTEinCoorelatedSubQueries: boolean;
+    supportsSafeCast: boolean;
+    dontUnionIndex: boolean;
+    supportsQualify: boolean;
+    supportsNesting: boolean;
+    quoteTablePath(tablePath: string): string;
+    sqlGroupSetTable(groupSetCount: number): string;
+    sqlAnyValue(groupSet: number, fieldName: string): string;
+    mapFields(fieldList: DialectFieldList): string;
+    mapFieldsForObjectConstruct(fieldList: DialectFieldList): 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;
+    sqlCreateFunctionCombineLastStage(_lastStageName: string): string;
+    sqlSelectAliasAsStruct(alias: string): string;
+    sqlMaybeQuoteIdentifier(identifier: string): string;
+    sqlCreateTableAsSelect(tableName: string, sql: string): string;
+    sqlTrunc(qi: QueryInfo, sqlTime: TimeValue, units: TimestampUnit): Expr;
+    sqlExtract(qi: QueryInfo, from: TimeValue, units: ExtractUnit): Expr;
+    sqlAlterTime(op: '+' | '-', expr: TimeValue, n: Expr, timeframe: DateUnit): Expr;
+    private atTz;
+    sqlNow(): Expr;
+    sqlCast(qi: QueryInfo, cast: TypecastFragment): Expr;
+    sqlLiteralTime(qi: QueryInfo, timeString: string, type: TimeFieldType, timezone: string | undefined): string;
+    sqlMeasureTime(from: TimeValue, to: TimeValue, units: string): Expr;
+    sqlRegexpMatch(expr: Expr, regexp: Expr): Expr;
+    sqlSampleTable(tableSQL: string, sample: Sampling | undefined): string;
+    sqlOrderBy(orderTerms: string[]): 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/snowflake/snowflake.js

@@ -0,0 +1,408 @@
+"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.SnowflakeDialect = 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");
+const extractionMap = {
+    'day_of_week': 'dayofweek',
+    'day_of_year': 'dayofyear',
+};
+const snowflakeToMalloyTypes = {
+    // string
+    'varchar': { type: 'string' },
+    'text': { type: 'string' },
+    'string': { type: 'string' },
+    'char': { type: 'string' },
+    'character': { type: 'string' },
+    'nvarchar': { type: 'string' },
+    'nvarchar2': { type: 'string' },
+    'char varying': { type: 'string' },
+    'nchar varying': { type: 'string' },
+    // numbers
+    'number': { type: 'number', numberType: 'integer' },
+    'numeric': { type: 'number', numberType: 'integer' },
+    'decimal': { type: 'number', numberType: 'integer' },
+    'dec': { type: 'number', numberType: 'integer' },
+    'integer': { type: 'number', numberType: 'integer' },
+    'int': { type: 'number', numberType: 'integer' },
+    'bigint': { type: 'number', numberType: 'integer' },
+    'smallint': { type: 'number', numberType: 'integer' },
+    'tinyint': { type: 'number', numberType: 'integer' },
+    'byteint': { type: 'number', numberType: 'integer' },
+    'float': { type: 'number', numberType: 'float' },
+    'float4': { type: 'number', numberType: 'float' },
+    'float8': { type: 'number', numberType: 'float' },
+    'double': { type: 'number', numberType: 'float' },
+    'double precision': { type: 'number', numberType: 'float' },
+    'real': { type: 'number', numberType: 'float' },
+    'boolean': { type: 'boolean' },
+    // time and date
+    'date': { type: 'date' },
+    'timestamp': { type: 'timestamp' },
+    'timestampntz': { type: 'timestamp' },
+    'timestamp_ntz': { type: 'timestamp' },
+    'timestamp without time zone': { type: 'timestamp' },
+    'timestamptz': { type: 'timestamp' },
+    'timestamp_tz': { type: 'timestamp' },
+    'timestamp with time zone': { type: 'timestamp' },
+    /* timestamp_ltz is not supported in malloy snowflake dialect */
+};
+class SnowflakeDialect extends dialect_1.Dialect {
+    constructor() {
+        super(...arguments);
+        this.name = 'snowflake';
+        this.defaultNumberType = 'NUMBER';
+        this.defaultDecimalType = 'NUMBER';
+        this.udfPrefix = '__udf';
+        this.hasFinalStage = false;
+        this.divisionIsInteger = false;
+        this.supportsSumDistinctFunction = false;
+        this.defaultSampling = { rows: 50000 };
+        this.globalFunctions = functions_1.SNOWFLAKE_FUNCTIONS;
+        // NOTE: safely setting all these to false for now
+        // more many be implemented in future
+        this.unnestWithNumbers = false;
+        this.supportUnnestArrayAgg = false;
+        this.supportsAggDistinct = false;
+        this.supportsCTEinCoorelatedSubQueries = false;
+        this.supportsSafeCast = false;
+        this.dontUnionIndex = false;
+        this.supportsQualify = false;
+        this.supportsNesting = true;
+    }
+    // don't mess with the table pathing.
+    quoteTablePath(tablePath) {
+        return tablePath;
+    }
+    sqlGroupSetTable(groupSetCount) {
+        return `CROSS JOIN (SELECT seq4() as group_set FROM TABLE(GENERATOR(ROWCOUNT => ${groupSetCount + 1}))) as group_set`;
+    }
+    /*
+    // this just returns null in snowflake
+    select
+    any_value (t is not null) as av
+  from
+    (
+      select
+        case
+          when group_set = 1 then 'one'
+        end as t
+      from
+        (
+          SELECT
+            seq4 () as group_set
+          FROM
+            TABLE (GENERATOR (ROWCOUNT => 3))
+        ) as tbl
+    );
+    */
+    sqlAnyValue(groupSet, fieldName) {
+        return `(ARRAY_AGG(CASE WHEN group_set=${groupSet} THEN ${fieldName} END) WITHIN GROUP (ORDER BY ${fieldName} ASC NULLS LAST))[0]`;
+    }
+    mapFields(fieldList) {
+        return fieldList
+            .map(f => `\n  ${f.sqlExpression} as ${f.sqlOutputName}`)
+            .join(', ');
+    }
+    mapFieldsForObjectConstruct(fieldList) {
+        return fieldList
+            .map(f => `'${f.rawName}', (${f.sqlExpression})`)
+            .join(', ');
+    }
+    sqlAggregateTurtle(groupSet, fieldList, orderBy, limit) {
+        const fields = this.mapFieldsForObjectConstruct(fieldList);
+        const orderByClause = orderBy ? ` WITHIN GROUP (${orderBy})` : '';
+        const aggClause = `ARRAY_AGG(CASE WHEN group_set=${groupSet} THEN OBJECT_CONSTRUCT(${fields}) END)${orderByClause}`;
+        if (limit === undefined) {
+            return `COALESCE(${aggClause}, [])`;
+        }
+        return `COALESCE(ARRAY_SLICE(${aggClause}, 0, ${limit}), [])`;
+    }
+    sqlAnyValueTurtle(groupSet, fieldList) {
+        const fields = this.mapFieldsForObjectConstruct(fieldList);
+        return `(ARRAY_AGG(CASE WHEN group_set=${groupSet} THEN OBJECT_CONSTRUCT(${fields}) END) WITHIN GROUP (ORDER BY 1 ASC NULLS LAST))[0]`;
+    }
+    sqlAnyValueLastTurtle(name, groupSet, sqlName) {
+        return `(ARRAY_AGG(CASE WHEN group_set=${groupSet} THEN ${name} END) WITHIN GROUP (ORDER BY ${name} ASC NULLS LAST))[0] AS ${sqlName}`;
+    }
+    sqlCoaleseMeasuresInline(groupSet, fieldList) {
+        const fields = this.mapFieldsForObjectConstruct(fieldList);
+        const nullValues = fieldList
+            .map(f => `'${f.sqlOutputName}', NULL`)
+            .join(', ');
+        return `COALESCE(ARRAY_AGG(CASE WHEN group_set=${groupSet} THEN OBJECT_CONSTRUCT(${fields}) END)[0], OBJECT_CONSTRUCT_KEEP_NULL(${nullValues}))`;
+    }
+    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}`;
+            // }
+            throw new Error('not implemented yet');
+        }
+        else {
+            // have to have a non empty row or it treats it like an inner join :barf-emoji:
+            return `LEFT JOIN LATERAL FLATTEN(INPUT => ifnull(${source},[1])) AS ${alias}`;
+            //   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}`;
+            // }
+        }
+    }
+    /*
+    // For comparison against the equivalent function implemented in standardsql dialect
+    select
+      (
+        to_number (
+          substr (md5_hex ('hello'), 1, 15),
+          repeat ('X', 15)
+        ) * 4294967296 + to_number (
+          substr (md5_hex ('hello'), 16, 8),
+          repeat ('X', 8)
+        )
+      ) * 0.000000001 as hash;
+    +-------------------------------+
+    |                          HASH |
+    |-------------------------------|
+    | 1803811819465386377.040304601 |
+    +-------------------------------+
+    */
+    sqlSumDistinctHashedKey(sqlDistinctKey) {
+        sqlDistinctKey = `${sqlDistinctKey}::STRING`;
+        const upperPart = `to_number(substr(md5_hex(${sqlDistinctKey}), 1, 15), repeat('X', 15)) * 4294967296`;
+        const lowerPart = `to_number(substr(md5_hex(${sqlDistinctKey}), 16, 8), repeat('X', 8))`;
+        const precisionShiftMultiplier = '0.000000001';
+        return `(${upperPart} + ${lowerPart}) * ${precisionShiftMultiplier}`;
+    }
+    sqlGenerateUUID() {
+        return 'UUID_STRING()';
+    }
+    sqlFieldReference(alias, fieldName, fieldType, isNested, _isArray) {
+        if (fieldName === '__row_id') {
+            return `${alias}.INDEX::varchar`;
+        }
+        else if (!isNested) {
+            return `${alias}."${fieldName}"`;
+        }
+        else {
+            let snowflakeType = fieldType;
+            if (fieldType === 'string') {
+                snowflakeType = 'varchar';
+            }
+            return `${alias}.value:"${fieldName}"::${snowflakeType}`;
+        }
+    }
+    sqlUnnestPipelineHead(isSingleton, sourceSQLExpression) {
+        let p = sourceSQLExpression;
+        if (isSingleton) {
+            p = `[${p}]`;
+        }
+        return `TABLE(FLATTEN(input =>${p}))`;
+    }
+    sqlCreateFunction(_id, _funcText) {
+        throw new Error('not implemented yet');
+    }
+    sqlCreateFunctionCombineLastStage(_lastStageName) {
+        throw new Error('not implemented yet');
+    }
+    sqlSelectAliasAsStruct(alias) {
+        return `OBJECT_CONSTRUCT(${alias}.*)`;
+    }
+    sqlMaybeQuoteIdentifier(identifier) {
+        return `"${identifier}"`;
+    }
+    sqlCreateTableAsSelect(tableName, sql) {
+        return `
+CREATE TEMP TABLE IF NOT EXISTS \`${tableName}\`
+AS (
+${(0, utils_1.indent)(sql)}
+);
+`;
+    }
+    sqlTrunc(qi, sqlTime, units) {
+        const tz = (0, dialect_1.qtz)(qi);
+        let truncThis = sqlTime.value;
+        if (tz && sqlTime.valueType === 'timestamp') {
+            truncThis = (0, malloy_types_1.mkExpr) `CONVERT_TIMEZONE('${tz}', ${truncThis})`;
+        }
+        return (0, malloy_types_1.mkExpr) `DATE_TRUNC('${units}', ${truncThis})`;
+    }
+    sqlExtract(qi, from, units) {
+        const extractUnits = extractionMap[units] || units;
+        let extractFrom = from.value;
+        const tz = (0, dialect_1.qtz)(qi);
+        if (tz && from.valueType === 'timestamp') {
+            extractFrom = (0, malloy_types_1.mkExpr) `CONVERT_TIMEZONE('${tz}', ${extractFrom})`;
+        }
+        const extracted = (0, malloy_types_1.mkExpr) `EXTRACT(${extractUnits} FROM ${extractFrom})`;
+        return extracted;
+    }
+    sqlAlterTime(op, expr, n, timeframe) {
+        const interval = (0, malloy_types_1.mkExpr) `INTERVAL '${n} ${timeframe}'`;
+        return (0, malloy_types_1.mkExpr) `((${expr.value})${op}${interval})`;
+    }
+    atTz(expr, tz) {
+        if (tz !== undefined) {
+            return (0, malloy_types_1.mkExpr) `(
+      TO_CHAR(${expr}::TIMESTAMP_NTZ, 'YYYY-MM-DD HH24:MI:SS.FF9') ||
+      TO_CHAR(CONVERT_TIMEZONE('${tz}', '1970-01-01 00:00:00'), 'TZHTZM')
+    )::TIMESTAMP_TZ`;
+        }
+        return (0, malloy_types_1.mkExpr) `${expr}::TIMESTAMP_NTZ`;
+    }
+    sqlNow() {
+        return (0, malloy_types_1.mkExpr) `CURRENT_TIMESTAMP()`;
+    }
+    sqlCast(qi, cast) {
+        if (cast.srcType === cast.dstType) {
+            return cast.expr;
+        }
+        if (cast.safe) {
+            // safe cast is only supported for a few combinations of src -> dst types
+            // so we will not support it in the general case
+            throw new Error("Snowflake dialect doesn't support safe cast for a few types");
+        }
+        const tz = (0, dialect_1.qtz)(qi);
+        // casting timestamps and dates
+        if (cast.dstType === 'date' && cast.srcType === 'timestamp') {
+            let castExpr = cast.expr;
+            if (tz) {
+                castExpr = (0, malloy_types_1.mkExpr) `CONVERT_TIMEZONE('${tz}', ${castExpr})`;
+            }
+            return (0, malloy_types_1.mkExpr) `TO_DATE(${castExpr})`;
+        }
+        else if (cast.dstType === 'timestamp' && cast.srcType === 'date') {
+            const retExpr = (0, malloy_types_1.mkExpr) `TO_TIMESTAMP(${cast.expr})`;
+            return this.atTz(retExpr, tz);
+        }
+        const dstType = typeof cast.dstType === 'string'
+            ? this.malloyTypeToSQLType({ type: cast.dstType })
+            : cast.dstType.raw;
+        return (0, malloy_types_1.mkExpr) `CAST(${cast.expr} AS ${dstType})`;
+    }
+    sqlLiteralTime(qi, timeString, type, timezone) {
+        const tz = (0, dialect_1.qtz)(qi);
+        // just making it explicit that timestring does not have timezone info
+        let ret = `'${timeString}'::TIMESTAMP_NTZ`;
+        // now do the hack to add timezone to a timestamp ntz
+        const targetTimeZone = timezone !== null && timezone !== void 0 ? timezone : tz;
+        if (targetTimeZone) {
+            const targetTimeZoneSuffix = `TO_CHAR(CONVERT_TIMEZONE('${targetTimeZone}', '1970-01-01 00:00:00'), 'TZHTZM')`;
+            const retTimeString = `TO_CHAR(${ret}, 'YYYY-MM-DD HH24:MI:SS.FF9')`;
+            ret = `${retTimeString} || ${targetTimeZoneSuffix}`;
+            ret = `(${ret})::TIMESTAMP_TZ`;
+        }
+        switch (type) {
+            case 'date':
+                return `TO_DATE(${ret})`;
+            case 'timestamp': {
+                return ret;
+            }
+        }
+    }
+    sqlMeasureTime(from, to, units) {
+        let extractUnits = 'nanoseconds';
+        if (from.valueType === 'date' || to.valueType === 'date') {
+            extractUnits = 'seconds';
+        }
+        return (0, malloy_types_1.mkExpr) `TIMESTAMPDIFF(
+      '${units}',
+      '1970-01-01 00:00:00'::TIMESTAMP_NTZ,
+      TIMESTAMPADD(
+        '${extractUnits}',
+        EXTRACT('epoch_${extractUnits}', ${to.value}) - EXTRACT('epoch_${extractUnits}', ${from.value}),
+        '1970-01-01 00:00:00'::TIMESTAMP_NTZ
+      )
+    )`;
+    }
+    sqlRegexpMatch(expr, regexp) {
+        // regexp_match captures any partial match
+        return (0, malloy_types_1.mkExpr) `(REGEXP_INSTR(${expr}, ${regexp}) != 0)`;
+    }
+    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)) {
+                return `(SELECT * FROM ${tableSQL} TABLESAMPLE (${sample.rows} ROWS))`;
+            }
+            else if ((0, malloy_types_1.isSamplingPercent)(sample)) {
+                return `(SELECT * FROM ${tableSQL} TABLESAMPLE (${sample.percent}))`;
+            }
+        }
+        return tableSQL;
+    }
+    sqlOrderBy(orderTerms) {
+        return `ORDER BY ${orderTerms.map(t => `${t} NULLS LAST`).join(',')}`;
+    }
+    sqlLiteralString(literal) {
+        const noVirgule = literal.replace(/\\/g, '\\\\');
+        return "'" + noVirgule.replace(/'/g, "\\'") + "'";
+    }
+    sqlLiteralRegexp(literal) {
+        const noVirgule = literal.replace(/\\/g, '\\\\');
+        return "'" + noVirgule.replace(/'/g, "\\'") + "'";
+    }
+    getGlobalFunctionDef(name) {
+        return functions_1.SNOWFLAKE_FUNCTIONS.get(name);
+    }
+    malloyTypeToSQLType(malloyType) {
+        if (malloyType.type === 'number') {
+            if (malloyType.numberType === 'integer') {
+                return 'integer';
+            }
+            else {
+                return 'double';
+            }
+        }
+        return malloyType.type;
+    }
+    sqlTypeToMalloyType(sqlType) {
+        var _a, _b;
+        // Remove trailing params
+        const baseSqlType = (_b = (_a = sqlType.match(/^([\w\s]+)/)) === null || _a === void 0 ? void 0 : _a.at(0)) !== null && _b !== void 0 ? _b : sqlType;
+        return snowflakeToMalloyTypes[baseSqlType.trim().toLowerCase()];
+    }
+    castToString(expression) {
+        return `TO_VARCHAR(${expression})`;
+    }
+    concat(...values) {
+        return values.join(' || ');
+    }
+    validateTypeName(sqlType) {
+        // Letters:              BIGINT
+        // Numbers:              INT8
+        // Spaces:               TIMESTAMP WITH TIME ZONE
+        // Parentheses, Commas:  NUMERIC(5, 2)
+        // Square Brackets:      INT64[]
+        return sqlType.match(/^[A-Za-z\s(),[\]0-9]*$/) !== null;
+    }
+}
+exports.SnowflakeDialect = SnowflakeDialect;
+//# sourceMappingURL=snowflake.js.map

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-export { DuckDBDialect, StandardSQLDialect, PostgresDialect, registerDialect, arg, qtz, overload, minScalar, anyExprType, minAggregate, maxScalar, sql, makeParam, sqlFragment, param, params, literal, spread, Dialect, FUNCTIONS, } from './dialect';
+export { DuckDBDialect, StandardSQLDialect, PostgresDialect, SnowflakeDialect, registerDialect, arg, qtz, overload, minScalar, anyExprType, minAggregate, maxScalar, sql, makeParam, sqlFragment, param, params, literal, spread, Dialect, FUNCTIONS, } from './dialect';
 export type { DialectFieldList, DialectFunctionOverloadDef, QueryInfo, } from './dialect';
 export type { QueryDataRow, Fragment, StructDef, StructRelationship, NamedStructDefs, MalloyQueryData, AtomicFieldType as AtomicFieldTypeInner, DateUnit, ExtractUnit, TimestampUnit, TimeFieldType, QueryData, QueryValue, FieldTypeDef, Expr, DialectFragment, TimeValue, FilterExpression, SQLBlock, FieldAtomicDef, FieldDef, PipeSegment, QueryFieldDef, IndexFieldDef, TurtleDef, SearchValueMapResult, SearchIndexResult, ModelDef, Query, QueryResult, QueryRunStats, NamedQuery, NamedModelObject, ExpressionType, FunctionDef, FunctionOverloadDef, FunctionParameterDef, ExpressionValueType, TypeDesc, FieldValueType, ExpressionTypeDesc, FunctionParamTypeDesc, DocumentLocation, DocumentRange, DocumentPosition, Sampling, TypecastFragment, Annotation, FieldAtomicTypeDef, SQLBlockStructDef, } from './model';
 export { Segment, isSamplingEnable, isSamplingPercent, isSamplingRows, mkExpr, expressionIsCalculation, indent, } from './model';

package/dist/index.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Explore = exports.DataWriter = exports.Parse = exports.JSONWriter = exports.CSVWriter = exports.QueryMaterializer = exports.Result = exports.PreparedResult = 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.indent = exports.expressionIsCalculation = exports.mkExpr = exports.isSamplingRows = exports.isSamplingPercent = exports.isSamplingEnable = exports.Segment = exports.FUNCTIONS = exports.Dialect = exports.spread = exports.literal = exports.params = exports.param = exports.sqlFragment = exports.makeParam = exports.sql = exports.maxScalar = exports.minAggregate = exports.anyExprType = exports.minScalar = exports.overload = exports.qtz = exports.arg = exports.registerDialect = exports.PostgresDialect = exports.StandardSQLDialect = exports.DuckDBDialect = void 0;
-exports.Tag = exports.toAsyncGenerator = void 0;
+exports.DataWriter = exports.Parse = exports.JSONWriter = exports.CSVWriter = exports.QueryMaterializer = exports.Result = exports.PreparedResult = 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.indent = exports.expressionIsCalculation = exports.mkExpr = exports.isSamplingRows = exports.isSamplingPercent = exports.isSamplingEnable = exports.Segment = exports.FUNCTIONS = exports.Dialect = exports.spread = exports.literal = exports.params = exports.param = exports.sqlFragment = exports.makeParam = exports.sql = exports.maxScalar = exports.minAggregate = exports.anyExprType = exports.minScalar = exports.overload = exports.qtz = exports.arg = exports.registerDialect = exports.SnowflakeDialect = exports.PostgresDialect = exports.StandardSQLDialect = exports.DuckDBDialect = void 0;
+exports.Tag = exports.toAsyncGenerator = exports.Explore = void 0;
 /*
  * Copyright 2023 Google LLC
  *
@@ -28,6 +28,7 @@ var dialect_1 = require("./dialect");
 Object.defineProperty(exports, "DuckDBDialect", { enumerable: true, get: function () { return dialect_1.DuckDBDialect; } });
 Object.defineProperty(exports, "StandardSQLDialect", { enumerable: true, get: function () { return dialect_1.StandardSQLDialect; } });
 Object.defineProperty(exports, "PostgresDialect", { enumerable: true, get: function () { return dialect_1.PostgresDialect; } });
+Object.defineProperty(exports, "SnowflakeDialect", { enumerable: true, get: function () { return dialect_1.SnowflakeDialect; } });
 Object.defineProperty(exports, "registerDialect", { enumerable: true, get: function () { return dialect_1.registerDialect; } });
 Object.defineProperty(exports, "arg", { enumerable: true, get: function () { return dialect_1.arg; } });
 Object.defineProperty(exports, "qtz", { enumerable: true, get: function () { return dialect_1.qtz; } });

package/dist/malloy.d.ts

@@ -850,6 +850,8 @@ export declare class SingleConnectionRuntime<T extends Connection = Connection>
     constructor(urls: URLReader, connection: T);
     constructor(connection: T);
     get supportsNesting(): boolean;
+    quote(column: string): string;
+    getQuoter(): (arg: TemplateStringsArray) => string;
 }
 declare class FluentState<T> {
     protected runtime: Runtime;

package/dist/malloy.js

@@ -1754,6 +1754,13 @@ class SingleConnectionRuntime extends Runtime {
     get supportsNesting() {
         return (0, dialect_1.getDialect)(this.connection.dialectName).supportsNesting;
     }
+    // quote a column name
+    quote(column) {
+        return (0, dialect_1.getDialect)(this.connection.dialectName).sqlMaybeQuoteIdentifier(column);
+    }
+    getQuoter() {
+        return (x) => this.quote(x.toString());
+    }
 }
 exports.SingleConnectionRuntime = SingleConnectionRuntime;
 class FluentState {