@malloydata/malloy 0.0.22-dev230207144036 → 0.0.22-dev230207180844

package/dist/connection_utils.d.ts

@@ -0,0 +1 @@
+export declare function toAsyncGenerator<T>(startStreaming: (onError: (error: Error) => void, onData: (data: T) => void, onEnd: () => void) => void): AsyncIterableIterator<T>;

package/dist/connection_utils.js

@@ -0,0 +1,66 @@
+"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 = void 0;
+async function* toAsyncGenerator(startStreaming) {
+    let done = false;
+    function getResults(startStreaming) {
+        let resolve;
+        const promise = new Promise((res) => {
+            resolve = res;
+        });
+        startStreaming((error) => {
+            resolve({ done: true, isError: true, error });
+        }, (data) => {
+            resolve({
+                done: false,
+                value: data,
+                isError: false,
+                next: new Promise((res) => {
+                    resolve = res;
+                }),
+            });
+        }, () => {
+            resolve({ done: true, isError: false });
+        });
+        return promise;
+    }
+    let next = getResults(startStreaming);
+    while (!done) {
+        const result = await next;
+        if (result.done) {
+            done = true;
+            if (result.isError) {
+                throw result.error;
+            }
+            break;
+        }
+        else {
+            next = result.next;
+            yield result.value;
+        }
+    }
+}
+exports.toAsyncGenerator = toAsyncGenerator;
+//# sourceMappingURL=connection_utils.js.map

package/dist/dialect/dialect.d.ts

@@ -0,0 +1,66 @@
+import { AtomicFieldType as AtomicFieldTypeInner, TimeFieldType, TimestampUnit, ExtractUnit, DialectFragment, TimeValue, Expr, Sampling, StructDef, TypecastFragment } from "../model/malloy_types";
+interface DialectField {
+    type: string;
+    sqlExpression: string;
+    sqlOutputName: string;
+}
+/**
+ * Someday this might be used to control how a function call in malloy is
+ * translated into a function call in SQL. Today this is just so that
+ * the expression compiler can know the output type of a function.
+ */
+export interface FunctionInfo {
+    returnType: AtomicFieldTypeInner;
+}
+export declare type DialectFieldList = DialectField[];
+export declare abstract class Dialect {
+    abstract name: string;
+    abstract defaultNumberType: string;
+    abstract udfPrefix: string;
+    abstract hasFinalStage: boolean;
+    abstract stringTypeName: string;
+    abstract divisionIsInteger: boolean;
+    abstract supportsSumDistinctFunction: boolean;
+    abstract unnestWithNumbers: boolean;
+    protected abstract functionInfo: Record<string, FunctionInfo>;
+    abstract defaultSampling: Sampling;
+    abstract supportUnnestArrayAgg: boolean;
+    abstract supportsCTEinCoorelatedSubQueries: boolean;
+    abstract dontUnionIndex: boolean;
+    abstract supportsQualify: boolean;
+    abstract quoteTablePath(tablePath: string): string;
+    abstract sqlGroupSetTable(groupSetCount: number): string;
+    abstract sqlAnyValue(groupSet: number, fieldName: string): string;
+    abstract sqlAggregateTurtle(groupSet: number, fieldList: DialectFieldList, orderBy: string | undefined, limit: number | undefined): string;
+    abstract sqlAnyValueTurtle(groupSet: number, fieldList: DialectFieldList): string;
+    abstract sqlAnyValueLastTurtle(name: string, groupSet: number, sqlName: string): string;
+    abstract sqlCoaleseMeasuresInline(groupSet: number, fieldList: DialectFieldList): string;
+    abstract sqlUnnestAlias(source: string, alias: string, fieldList: DialectFieldList, needDistinctKey: boolean, isArray: boolean): string;
+    abstract sqlSumDistinctHashedKey(sqlDistinctKey: string): string;
+    abstract sqlGenerateUUID(): string;
+    abstract sqlFieldReference(alias: string, fieldName: string, fieldType: string, isNested: boolean, isArray: boolean): string;
+    abstract sqlUnnestPipelineHead(isSingleton: boolean, sourceSQLExpression: string): string;
+    abstract sqlCreateFunction(id: string, funcText: string): string;
+    abstract sqlCreateFunctionCombineLastStage(lastStageName: string, structDef: StructDef): string;
+    abstract sqlCreateTableAsSelect(tableName: string, sql: string): string;
+    abstract sqlSelectAliasAsStruct(alias: string, physicalFieldNames: string[]): string;
+    sqlFinalStage(_lastStageName: string, _fields: string[]): string;
+    sqlDateToString(sqlDateExp: string): string;
+    abstract sqlMaybeQuoteIdentifier(identifier: string): string;
+    abstract sqlNow(): Expr;
+    abstract sqlTrunc(sqlTime: TimeValue, units: TimestampUnit): Expr;
+    abstract sqlExtract(sqlTime: TimeValue, units: ExtractUnit): Expr;
+    abstract sqlMeasureTime(from: TimeValue, to: TimeValue, units: TimestampUnit): Expr;
+    abstract sqlAlterTime(op: "+" | "-", expr: TimeValue, n: Expr, timeframe: TimestampUnit): Expr;
+    ignoreInProject(_fieldName: string): boolean;
+    abstract sqlCast(cast: TypecastFragment): Expr;
+    abstract sqlLiteralTime(timeString: string, type: TimeFieldType, timezone: string): string;
+    abstract sqlLiteralString(literak: string): string;
+    abstract sqlRegexpMatch(expr: Expr, regex: string): Expr;
+    getFunctionInfo(functionName: string): FunctionInfo | undefined;
+    dialectExpr(df: DialectFragment): Expr;
+    sqlSumDistinct(_key: string, _value: string): string;
+    sqlSampleTable(tableSQL: string, sample: Sampling | undefined): string;
+    sqlOrderBy(orderTerms: string[]): string;
+}
+export {};

package/dist/dialect/dialect.js

@@ -0,0 +1,85 @@
+"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.Dialect = void 0;
+const malloy_types_1 = require("../model/malloy_types");
+class Dialect {
+    sqlFinalStage(_lastStageName, _fields) {
+        throw new Error("Dialect has no final Stage but called Anyway");
+    }
+    // default implementation will probably work most of the time
+    sqlDateToString(sqlDateExp) {
+        return `CAST(DATE(${sqlDateExp}) AS ${this.stringTypeName} )`;
+    }
+    // BigQuery has some fieldNames that are Pseudo Fields and shouldn't be
+    //  included in projections.
+    ignoreInProject(_fieldName) {
+        return false;
+    }
+    getFunctionInfo(functionName) {
+        return this.functionInfo[functionName.toLowerCase()];
+    }
+    dialectExpr(df) {
+        switch (df.function) {
+            case "now":
+                return this.sqlNow();
+            case "timeDiff":
+                return this.sqlMeasureTime(df.left, df.right, df.units);
+            case "delta":
+                return this.sqlAlterTime(df.op, df.base, df.delta, df.units);
+            case "trunc":
+                return this.sqlTrunc(df.expr, df.units);
+            case "extract":
+                return this.sqlExtract(df.expr, df.units);
+            case "cast":
+                return this.sqlCast(df);
+            case "regexpMatch":
+                return this.sqlRegexpMatch(df.expr, df.regexp);
+            case "div": {
+                if (this.divisionIsInteger) {
+                    return (0, malloy_types_1.mkExpr) `${df.numerator}*1.0/${df.denominator}`;
+                }
+                return (0, malloy_types_1.mkExpr) `${df.numerator}/${df.denominator}`;
+            }
+            case "timeLiteral":
+                return [this.sqlLiteralTime(df.literal, df.literalType, df.timezone)];
+            case "stringLiteral":
+                return [this.sqlLiteralString(df.literal)];
+        }
+    }
+    sqlSumDistinct(_key, _value) {
+        return "sqlSumDistinct called bu not implemented";
+    }
+    sqlSampleTable(tableSQL, sample) {
+        if (sample !== undefined) {
+            throw new Error(`Sampling is not supported on dialect ${this.name}.`);
+        }
+        return tableSQL;
+    }
+    sqlOrderBy(orderTerms) {
+        return `ORDER BY ${orderTerms.join(",")}`;
+    }
+}
+exports.Dialect = Dialect;
+//# sourceMappingURL=dialect.js.map

package/dist/dialect/dialect_map.d.ts

@@ -0,0 +1,3 @@
+import { Dialect } from "./dialect";
+export declare function getDialect(name: string): Dialect;
+export declare function registerDialect(d: Dialect): void;

package/dist/dialect/dialect_map.js

@@ -0,0 +1,45 @@
+"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.registerDialect = exports.getDialect = void 0;
+const duckdb_1 = require("./duckdb");
+const postgres_1 = require("./postgres");
+const standardsql_1 = require("./standardsql");
+const dialectMap = new Map();
+function getDialect(name) {
+    const d = dialectMap.get(name);
+    if (d === undefined) {
+        throw new Error(`Unknown Dialect ${name}`);
+    }
+    return d;
+}
+exports.getDialect = getDialect;
+function registerDialect(d) {
+    dialectMap.set(d.name, d);
+}
+exports.registerDialect = registerDialect;
+registerDialect(new postgres_1.PostgresDialect());
+registerDialect(new standardsql_1.StandardSQLDialect());
+registerDialect(new duckdb_1.DuckDBDialect());
+//# sourceMappingURL=dialect_map.js.map

package/dist/dialect/duckdb.d.ts

@@ -0,0 +1,52 @@
+import { DateUnit, Expr, ExtractUnit, Sampling, StructDef, TimeFieldType, TimestampUnit, TimeValue, TypecastFragment } from "../model/malloy_types";
+import { Dialect, DialectFieldList, FunctionInfo } from "./dialect";
+export declare class DuckDBDialect extends Dialect {
+    name: string;
+    defaultNumberType: string;
+    hasFinalStage: boolean;
+    stringTypeName: string;
+    divisionIsInteger: boolean;
+    supportsSumDistinctFunction: boolean;
+    unnestWithNumbers: boolean;
+    defaultSampling: {
+        rows: number;
+    };
+    supportUnnestArrayAgg: boolean;
+    supportsCTEinCoorelatedSubQueries: boolean;
+    dontUnionIndex: boolean;
+    supportsQualify: boolean;
+    functionInfo: Record<string, FunctionInfo>;
+    get udfPrefix(): string;
+    quoteTablePath(tableName: string): string;
+    sqlGroupSetTable(groupSetCount: number): string;
+    sqlAnyValue(groupSet: number, fieldName: string): string;
+    mapFields(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): string;
+    sqlSumDistinctHashedKey(_sqlDistinctKey: string): string;
+    sqlGenerateUUID(): string;
+    sqlDateToString(sqlDateExp: string): 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, structDef: StructDef): string;
+    sqlSelectAliasAsStruct(alias: string, physicalFieldNames: string[]): string;
+    sqlMaybeQuoteIdentifier(identifier: string): string;
+    sqlCreateTableAsSelect(_tableName: string, _sql: string): string;
+    getFunctionInfo(functionName: string): FunctionInfo | undefined;
+    sqlMeasureTime(from: TimeValue, to: TimeValue, units: string): Expr;
+    sqlNow(): Expr;
+    sqlTrunc(sqlTime: TimeValue, units: TimestampUnit): Expr;
+    sqlExtract(from: TimeValue, units: ExtractUnit): Expr;
+    sqlAlterTime(op: "+" | "-", expr: TimeValue, n: Expr, timeframe: DateUnit): Expr;
+    sqlCast(cast: TypecastFragment): Expr;
+    sqlRegexpMatch(expr: Expr, regexp: string): Expr;
+    sqlLiteralTime(timeString: string, type: TimeFieldType, _timezone: string): string;
+    sqlSumDistinct(key: string, value: string): string;
+    sqlSampleTable(tableSQL: string, sample: Sampling | undefined): string;
+    sqlOrderBy(orderTerms: string[]): string;
+    sqlLiteralString(literal: string): string;
+}

package/dist/dialect/duckdb.js

@@ -0,0 +1,364 @@
+"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.DuckDBDialect = void 0;
+const malloy_types_1 = require("../model/malloy_types");
+const utils_1 = require("../model/utils");
+const dialect_1 = require("./dialect");
+// need to refactor runSQL to take a SQLBlock instead of just a sql string.
+const hackSplitComment = "-- hack: split on this";
+const keywords = `
+ALL
+ANALYSE
+ANALYZE
+AND
+ANY
+ARRAY
+AS
+ASC_P
+ASYMMETRIC
+BOTH
+CASE
+CAST
+CHECK_P
+COLLATE
+COLUMN
+CONSTRAINT
+CREATE_P
+CURRENT_CATALOG
+CURRENT_DATE
+CURRENT_ROLE
+CURRENT_TIME
+CURRENT_TIMESTAMP
+CURRENT_USER
+DEFAULT
+DEFERRABLE
+DESC_P
+DISTINCT
+DO
+ELSE
+END_P
+EXCEPT
+FALSE_P
+FETCH
+FOR
+FOREIGN
+FROM
+GRANT
+GROUP_P
+HAVING
+IN_P
+INITIALLY
+INTERSECT
+INTO
+LATERAL_P
+LEADING
+LIMIT
+LOCALTIME
+LOCALTIMESTAMP
+NOT
+NULL_P
+OFFSET
+ON
+ONLY
+OR
+ORDER
+PLACING
+PRIMARY
+REFERENCES
+RETURNING
+SELECT
+SESSION_USER
+SOME
+SYMMETRIC
+TABLE
+THEN
+TO
+TRAILING
+TRUE_P
+UNION
+UNIQUE
+USER
+USING
+VARIADIC
+WHEN
+WHERE
+WINDOW
+WITH
+`.split(/\s/);
+const castMap = {
+    number: "double precision",
+    string: "varchar",
+};
+const pgExtractionMap = {
+    day_of_week: "dow",
+    day_of_year: "doy",
+};
+const inSeconds = {
+    second: 1,
+    minute: 60,
+    hour: 3600,
+};
+class DuckDBDialect extends dialect_1.Dialect {
+    constructor() {
+        super(...arguments);
+        this.name = "duckdb";
+        this.defaultNumberType = "DOUBLE";
+        this.hasFinalStage = false;
+        this.stringTypeName = "VARCHAR";
+        this.divisionIsInteger = true;
+        this.supportsSumDistinctFunction = true;
+        this.unnestWithNumbers = true;
+        this.defaultSampling = { rows: 50000 };
+        this.supportUnnestArrayAgg = true;
+        this.supportsCTEinCoorelatedSubQueries = true;
+        this.dontUnionIndex = false;
+        this.supportsQualify = true;
+        this.functionInfo = {
+            concat: { returnType: "string" },
+        };
+    }
+    // hack until they support temporary macros.
+    get udfPrefix() {
+        return `__udf${Math.floor(Math.random() * 100000)}`;
+    }
+    quoteTablePath(tableName) {
+        return tableName.match(/\//) ? `'${tableName}'` : tableName;
+    }
+    sqlGroupSetTable(groupSetCount) {
+        return `CROSS JOIN (SELECT UNNEST(GENERATE_SERIES(0,${groupSetCount},1)) as group_set  ) as group_set`;
+    }
+    sqlAnyValue(groupSet, fieldName) {
+        return `FIRST(${fieldName}) FILTER (WHERE ${fieldName} IS NOT NULL)`;
+    }
+    mapFields(fieldList) {
+        return fieldList.join(", ");
+    }
+    sqlAggregateTurtle(groupSet, fieldList, orderBy, limit) {
+        let tail = "";
+        if (limit !== undefined) {
+            tail += `[1:${limit}]`;
+        }
+        const fields = fieldList
+            .map((f) => `\n  ${f.sqlOutputName}: ${f.sqlExpression}`)
+            .join(", ");
+        return `COALESCE(LIST({${fields}} ${orderBy}) FILTER (WHERE group_set=${groupSet})${tail},[])`;
+    }
+    sqlAnyValueTurtle(groupSet, fieldList) {
+        const fields = fieldList
+            .map((f) => `${f.sqlExpression} as ${f.sqlOutputName}`)
+            .join(", ");
+        return `ANY_VALUE(CASE WHEN group_set=${groupSet} THEN ROW(${fields}))`;
+    }
+    sqlAnyValueLastTurtle(name, groupSet, sqlName) {
+        return `MAX(CASE WHEN group_set=${groupSet} THEN ${name}__${groupSet} END) as ${sqlName}`;
+    }
+    sqlCoaleseMeasuresInline(groupSet, fieldList) {
+        const fields = fieldList
+            .map((f) => `${f.sqlOutputName}: ${f.sqlExpression} `)
+            .join(", ");
+        const nullValues = fieldList
+            .map((f) => `${f.sqlOutputName}: NULL`)
+            .join(", ");
+        return `COALESCE(FIRST({${fields}}) FILTER(WHERE group_set=${groupSet}), {${nullValues}})`;
+    }
+    sqlUnnestAlias(source, alias, _fieldList, _needDistinctKey) {
+        return `LEFT JOIN (select UNNEST(generate_series(1,
+        100000, --
+        -- (SELECT genres_length FROM movies limit 1),
+        1)) as __row_id) as ${alias} ON  ${alias}.__row_id <= array_length(${source})`;
+        // When DuckDB supports lateral joins...
+        //return `,(select UNNEST(generate_series(1, length(${source}),1))) as ${alias}(__row_id)`;
+    }
+    sqlSumDistinctHashedKey(_sqlDistinctKey) {
+        return "uses sumDistinctFunction, should not be called";
+    }
+    sqlGenerateUUID() {
+        return `GEN_RANDOM_UUID()`;
+    }
+    sqlDateToString(sqlDateExp) {
+        return `(${sqlDateExp})::date::varchar`;
+    }
+    sqlFieldReference(alias, fieldName, _fieldType, _isNested, isArray) {
+        if (isArray) {
+            return alias;
+        }
+        else {
+            return `${alias}.${this.sqlMaybeQuoteIdentifier(fieldName)}`;
+        }
+    }
+    sqlUnnestPipelineHead(isSingleton, sourceSQLExpression) {
+        let p = sourceSQLExpression;
+        if (isSingleton) {
+            p = `[${p}]`;
+        }
+        return `(SELECT UNNEST(${p}) as base)`;
+    }
+    sqlCreateFunction(id, funcText) {
+        return `DROP MACRO IF EXISTS ${id}; \n${hackSplitComment}\n CREATE MACRO ${id}(_param) AS (\n${(0, utils_1.indent)(funcText)}\n);\n${hackSplitComment}\n`;
+    }
+    sqlCreateFunctionCombineLastStage(lastStageName, structDef) {
+        return `SELECT LIST(ROW(${structDef.fields
+            .map((fieldDef) => this.sqlMaybeQuoteIdentifier((0, malloy_types_1.getIdentifier)(fieldDef)))
+            .join(",")})) FROM ${lastStageName}\n`;
+    }
+    sqlSelectAliasAsStruct(alias, physicalFieldNames) {
+        return `ROW(${physicalFieldNames
+            .map((name) => `${alias}.${name}`)
+            .join(", ")})`;
+    }
+    // TODO
+    // sqlMaybeQuoteIdentifier(identifier: string): string {
+    //   return keywords.indexOf(identifier.toUpperCase()) > 0 ||
+    //     identifier.match(/[a-zA-Z][a-zA-Z0-9]*/) === null || true
+    //     ? '"' + identifier + '"'
+    //     : identifier;
+    // }
+    sqlMaybeQuoteIdentifier(identifier) {
+        return '"' + identifier + '"';
+    }
+    // The simple way to do this is to add a comment on the table
+    //  with the expiration time. https://www.postgresql.org/docs/current/sql-comment.html
+    //  and have a reaper that read comments.
+    sqlCreateTableAsSelect(_tableName, _sql) {
+        throw new Error("Not implemented Yet");
+    }
+    getFunctionInfo(functionName) {
+        return this.functionInfo[functionName];
+    }
+    sqlMeasureTime(from, to, units) {
+        let lVal = from.value;
+        let rVal = to.value;
+        if (inSeconds[units]) {
+            lVal = (0, malloy_types_1.mkExpr) `EXTRACT(EPOCH FROM ${lVal})`;
+            rVal = (0, malloy_types_1.mkExpr) `EXTRACT(EPOCH FROM ${rVal})`;
+            const duration = (0, malloy_types_1.mkExpr) `(${rVal} - ${lVal})`;
+            return units == "second"
+                ? duration
+                : (0, malloy_types_1.mkExpr) `FLOOR(${duration}/${inSeconds[units].toString()})`;
+        }
+        if (from.valueType != "date") {
+            lVal = (0, malloy_types_1.mkExpr) `CAST((${lVal}) AS DATE)`;
+        }
+        if (to.valueType != "date") {
+            rVal = (0, malloy_types_1.mkExpr) `CAST((${rVal}) AS DATE)`;
+        }
+        if (units == "week") {
+            // DuckDB's weeks start on Monday, but Malloy's weeks start on Sunday
+            lVal = (0, malloy_types_1.mkExpr) `(${lVal} + INTERVAL 1 DAY)`;
+            rVal = (0, malloy_types_1.mkExpr) `(${rVal} + INTERVAL 1 DAY)`;
+        }
+        return (0, malloy_types_1.mkExpr) `DATE_DIFF('${units}', ${lVal}, ${rVal})`;
+    }
+    sqlNow() {
+        return (0, malloy_types_1.mkExpr) `CURRENT_TIMESTAMP::TIMESTAMP`;
+    }
+    sqlTrunc(sqlTime, units) {
+        // adjusting for monday/sunday weeks
+        const week = units == "week";
+        const truncThis = week
+            ? (0, malloy_types_1.mkExpr) `${sqlTime.value} + INTERVAL 1 DAY`
+            : sqlTime.value;
+        const trunced = (0, malloy_types_1.mkExpr) `DATE_TRUNC('${units}', ${truncThis})`;
+        return week ? (0, malloy_types_1.mkExpr) `(${trunced} - INTERVAL 1 DAY)` : trunced;
+    }
+    sqlExtract(from, units) {
+        const pgUnits = pgExtractionMap[units] || units;
+        const extracted = (0, malloy_types_1.mkExpr) `EXTRACT(${pgUnits} FROM ${from.value})`;
+        return units == "day_of_week" ? (0, malloy_types_1.mkExpr) `(${extracted}+1)` : extracted;
+    }
+    sqlAlterTime(op, expr, n, timeframe) {
+        if (timeframe == "quarter") {
+            timeframe = "month";
+            n = (0, malloy_types_1.mkExpr) `${n}*3`;
+        }
+        if (timeframe == "week") {
+            timeframe = "day";
+            n = (0, malloy_types_1.mkExpr) `${n}*7`;
+        }
+        const interval = (0, malloy_types_1.mkExpr) `INTERVAL (${n}) ${timeframe}`;
+        return (0, malloy_types_1.mkExpr) `((${expr.value})) ${op} ${interval}`;
+    }
+    sqlCast(cast) {
+        if (cast.dstType !== cast.srcType) {
+            const castTo = castMap[cast.dstType] || cast.dstType;
+            return (0, malloy_types_1.mkExpr) `cast(${cast.expr} as ${castTo})`;
+        }
+        return cast.expr;
+    }
+    sqlRegexpMatch(expr, regexp) {
+        return (0, malloy_types_1.mkExpr) `REGEXP_MATCHES(${expr}, ${regexp})`;
+    }
+    sqlLiteralTime(timeString, type, _timezone) {
+        if (type == "date") {
+            return `DATE '${timeString}'`;
+        }
+        else if (type == "timestamp") {
+            return `TIMESTAMP '${timeString}'`;
+        }
+        else {
+            throw new Error(`Unknown Literal time format ${type}`);
+        }
+    }
+    sqlSumDistinct(key, value) {
+        // return `sum_distinct(list({key:${key}, val: ${value}}))`;
+        return `(
+      SELECT sum(a.val) as value
+      FROM (
+        SELECT UNNEST(list(distinct {key:${key}, val: ${value}})) a
+      )
+    )`;
+    }
+    // sqlSumDistinct(key: string, value: string): string {
+    //   const _factor = 32;
+    //   const precision = 0.000001;
+    //   const keySQL = `md5_number_lower(${key}::varchar)::int128`;
+    //   return `
+    //   (SUM(DISTINCT ${keySQL} + FLOOR(IFNULL(${value},0)/${precision})::int128) -  SUM(DISTINCT ${keySQL}))*${precision}
+    //   `;
+    // }
+    // default duckdb to sampling 50K rows.
+    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} USING SAMPLE ${sample.rows})`;
+            }
+            else if ((0, malloy_types_1.isSamplingPercent)(sample)) {
+                return `(SELECT * FROM ${tableSQL} USING SAMPLE ${sample.percent} PERCENT (bernoulli))`;
+            }
+        }
+        return tableSQL;
+    }
+    sqlOrderBy(orderTerms) {
+        return `ORDER BY ${orderTerms.map((t) => `${t} NULLS LAST`).join(",")}`;
+    }
+    sqlLiteralString(literal) {
+        return "'" + literal.replace(/'/g, "''") + "'";
+    }
+}
+exports.DuckDBDialect = DuckDBDialect;
+//# sourceMappingURL=duckdb.js.map