@malloydata/malloy 0.0.22-dev230207144036 → 0.0.22-dev230207180844

package/dist/dialect/index.d.ts

@@ -0,0 +1,6 @@
+export { Dialect } from "./dialect";
+export type { DialectFieldList } from "./dialect";
+export { StandardSQLDialect } from "./standardsql";
+export { PostgresDialect } from "./postgres";
+export { DuckDBDialect } from "./duckdb";
+export { getDialect, registerDialect } from "./dialect_map";

package/dist/dialect/index.js

@@ -0,0 +1,37 @@
+"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 = exports.DuckDBDialect = exports.PostgresDialect = exports.StandardSQLDialect = exports.Dialect = void 0;
+var dialect_1 = require("./dialect");
+Object.defineProperty(exports, "Dialect", { enumerable: true, get: function () { return dialect_1.Dialect; } });
+var standardsql_1 = require("./standardsql");
+Object.defineProperty(exports, "StandardSQLDialect", { enumerable: true, get: function () { return standardsql_1.StandardSQLDialect; } });
+var postgres_1 = require("./postgres");
+Object.defineProperty(exports, "PostgresDialect", { enumerable: true, get: function () { return postgres_1.PostgresDialect; } });
+var duckdb_1 = require("./duckdb");
+Object.defineProperty(exports, "DuckDBDialect", { enumerable: true, get: function () { return duckdb_1.DuckDBDialect; } });
+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; } });
+//# sourceMappingURL=index.js.map

package/dist/dialect/postgres.d.ts

@@ -0,0 +1,52 @@
+import { DateUnit, ExtractUnit, TimeFieldType, TimestampUnit, Expr, TimeValue, TypecastFragment, Sampling } from "../model/malloy_types";
+import { Dialect, DialectFieldList, FunctionInfo } from "./dialect";
+export declare class PostgresDialect extends Dialect {
+    name: string;
+    defaultNumberType: string;
+    udfPrefix: 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>;
+    quoteTablePath(tablePath: 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, isArray: 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;
+    sqlFinalStage(lastStageName: string, _fields: string[]): string;
+    sqlSelectAliasAsStruct(alias: string): string;
+    sqlMaybeQuoteIdentifier(identifier: string): string;
+    sqlCreateTableAsSelect(_tableName: string, _sql: string): string;
+    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;
+    getFunctionInfo(functionName: string): FunctionInfo | undefined;
+    sqlMeasureTime(from: TimeValue, to: TimeValue, units: string): Expr;
+    sqlSumDistinct(key: string, value: string): string;
+    sqlSampleTable(tableSQL: string, sample: Sampling | undefined): string;
+    sqlOrderBy(orderTerms: string[]): string;
+    sqlLiteralString(literal: string): string;
+}

package/dist/dialect/postgres.js

@@ -0,0 +1,330 @@
+"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.PostgresDialect = void 0;
+const utils_1 = require("../model/utils");
+const malloy_types_1 = require("../model/malloy_types");
+const dialect_1 = require("./dialect");
+const castMap = {
+    number: "double precision",
+    string: "varchar",
+};
+const pgExtractionMap = {
+    day_of_week: "dow",
+    day_of_year: "doy",
+};
+const pgMakeIntervalMap = {
+    year: "years",
+    month: "months",
+    week: "weeks",
+    day: "days",
+    hour: "hours",
+    minute: "mins",
+    second: "secs",
+};
+const inSeconds = {
+    second: 1,
+    minute: 60,
+    hour: 3600,
+};
+class PostgresDialect extends dialect_1.Dialect {
+    constructor() {
+        super(...arguments);
+        this.name = "postgres";
+        this.defaultNumberType = "DOUBLE PRECISION";
+        this.udfPrefix = "pg_temp.__udf";
+        this.hasFinalStage = true;
+        this.stringTypeName = "VARCHAR";
+        this.divisionIsInteger = true;
+        this.supportsSumDistinctFunction = false;
+        this.unnestWithNumbers = false;
+        this.defaultSampling = { rows: 50000 };
+        this.supportUnnestArrayAgg = true;
+        this.supportsCTEinCoorelatedSubQueries = true;
+        this.dontUnionIndex = false;
+        this.supportsQualify = false;
+        this.functionInfo = {
+            concat: { returnType: "string" },
+        };
+    }
+    quoteTablePath(tablePath) {
+        return tablePath
+            .split(".")
+            .map((part) => `"${part}"`)
+            .join(".");
+    }
+    sqlGroupSetTable(groupSetCount) {
+        return `CROSS JOIN GENERATE_SERIES(0,${groupSetCount},1) as group_set`;
+    }
+    sqlAnyValue(groupSet, fieldName) {
+        return `MAX(${fieldName})`;
+    }
+    mapFields(fieldList) {
+        return fieldList
+            .map((f) => `\n  ${f.sqlExpression}${f.type == "number" ? `::${this.defaultNumberType}` : ""} as ${f.sqlOutputName}`
+        //`${f.sqlExpression} ${f.type} as ${f.sqlOutputName}`
+        )
+            .join(", ");
+    }
+    sqlAggregateTurtle(groupSet, fieldList, orderBy, limit) {
+        let tail = "";
+        if (limit !== undefined) {
+            tail += `[1:${limit}]`;
+        }
+        const fields = this.mapFields(fieldList);
+        // return `(ARRAY_AGG((SELECT __x FROM (SELECT ${fields}) as __x) ${orderBy} ) FILTER (WHERE group_set=${groupSet}))${tail}`;
+        return `COALESCE(TO_JSONB((ARRAY_AGG((SELECT TO_JSONB(__x) FROM (SELECT ${fields}\n  ) as __x) ${orderBy} ) FILTER (WHERE group_set=${groupSet}))${tail}),'[]'::JSONB)`;
+    }
+    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 `(ARRAY_AGG(${name}__${groupSet}) FILTER (WHERE group_set=${groupSet} AND ${name}__${groupSet} IS NOT NULL))[1] as ${sqlName}`;
+    }
+    sqlCoaleseMeasuresInline(groupSet, fieldList) {
+        const fields = this.mapFields(fieldList);
+        return `TO_JSONB((ARRAY_AGG((SELECT __x FROM (SELECT ${fields}) as __x)) FILTER (WHERE group_set=${groupSet}))[1])`;
+    }
+    // UNNEST((select ARRAY((SELECT ROW(gen_random_uuid()::text, state, airport_count) FROM UNNEST(base.by_state) as by_state(state text, airport_count numeric, by_fac_type record[]))))) as by_state(__distinct_key text, state text, airport_count numeric)
+    // sqlUnnestAlias(
+    //   source: string,
+    //   alias: string,
+    //   fieldList: DialectFieldList,
+    //   needDistinctKey: boolean
+    // ): string {
+    //   const fields = [];
+    //   for (const f of fieldList) {
+    //     let t = undefined;
+    //     switch (f.type) {
+    //       case "string":
+    //         t = "text";
+    //         break;
+    //       case "number":
+    //         t = this.defaultNumberType;
+    //         break;
+    //       case "struct":
+    //         t = "record[]";
+    //         break;
+    //     }
+    //     fields.push(`${f.sqlOutputName} ${t || f.type}`);
+    //   }
+    //   if (needDistinctKey) {
+    //     return `UNNEST((select ARRAY((SELECT ROW(gen_random_uuid()::text, ${fieldList
+    //       .map((f) => f.sqlOutputName)
+    //       .join(", ")}) FROM UNNEST(${source}) as ${alias}(${fields.join(
+    //       ", "
+    //     )}))))) as ${alias}(__distinct_key text, ${fields.join(", ")})`;
+    //   } else {
+    //     return `UNNEST(${source}) as ${alias}(${fields.join(", ")})`;
+    //   }
+    // }
+    sqlUnnestAlias(source, alias, fieldList, needDistinctKey, isArray) {
+        if (isArray) {
+            if (needDistinctKey) {
+                return `LEFT JOIN UNNEST(ARRAY((SELECT jsonb_build_object('__row_id', row_number() over (), 'value', v) FROM UNNEST(${source}) as v))) as ${alias} ON true`;
+            }
+            else {
+                return `LEFT JOIN UNNEST(ARRAY((SELECT jsonb_build_object('value', v) FROM UNNEST(${source}) as v))) as ${alias} ON true`;
+            }
+        }
+        else if (needDistinctKey) {
+            // return `UNNEST(ARRAY(( SELECT AS STRUCT GENERATE_UUID() as __distinct_key, * FROM UNNEST(${source})))) as ${alias}`;
+            return `LEFT JOIN UNNEST(ARRAY((SELECT jsonb_build_object('__row_number', row_number() over())|| __xx::jsonb as b FROM  JSONB_ARRAY_ELEMENTS(${source}) __xx ))) as ${alias} ON true`;
+        }
+        else {
+            // return `CROSS JOIN LATERAL JSONB_ARRAY_ELEMENTS(${source}) as ${alias}`;
+            return `LEFT JOIN JSONB_ARRAY_ELEMENTS(${source}) as ${alias} ON true`;
+        }
+    }
+    sqlSumDistinctHashedKey(sqlDistinctKey) {
+        return `('x' || MD5(${sqlDistinctKey}::varchar))::bit(64)::bigint::DECIMAL(65,0)  *18446744073709551616 + ('x' || SUBSTR(MD5(${sqlDistinctKey}::varchar),17))::bit(64)::bigint::DECIMAL(65,0)`;
+    }
+    sqlGenerateUUID() {
+        return `GEN_RANDOM_UUID()`;
+    }
+    sqlFieldReference(alias, fieldName, fieldType, isNested, _isArray) {
+        let ret = `${alias}->>'${fieldName}'`;
+        if (isNested) {
+            switch (fieldType) {
+                case "string":
+                    break;
+                case "number":
+                    ret = `(${ret})::double precision`;
+                    break;
+                case "struct":
+                    ret = `(${ret})::jsonb`;
+                    break;
+            }
+            return ret;
+        }
+        else {
+            return `${alias}."${fieldName}"`;
+        }
+    }
+    sqlUnnestPipelineHead(isSingleton, sourceSQLExpression) {
+        if (isSingleton) {
+            return `UNNEST(ARRAY((SELECT ${sourceSQLExpression})))`;
+        }
+        else {
+            return `JSONB_ARRAY_ELEMENTS(${sourceSQLExpression})`;
+        }
+    }
+    sqlCreateFunction(id, funcText) {
+        return `CREATE FUNCTION ${id}(JSONB) RETURNS JSONB AS $$\n${(0, utils_1.indent)(funcText)}\n$$ LANGUAGE SQL;\n`;
+    }
+    sqlCreateFunctionCombineLastStage(lastStageName) {
+        return `SELECT JSONB_AGG(__stage0) FROM ${lastStageName}\n`;
+    }
+    sqlFinalStage(lastStageName, _fields) {
+        return `SELECT row_to_json(finalStage) as row FROM ${lastStageName} AS finalStage`;
+    }
+    sqlSelectAliasAsStruct(alias) {
+        return `ROW(${alias})`;
+    }
+    // TODO
+    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");
+    }
+    sqlNow() {
+        return (0, malloy_types_1.mkExpr) `CURRENT_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`;
+        }
+        const interval = (0, malloy_types_1.mkExpr) `make_interval(${pgMakeIntervalMap[timeframe]}=>${n})`;
+        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) `(${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}`);
+        }
+    }
+    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) `TRUNC(${duration}/${inSeconds[units].toString()})`;
+        }
+        if (units === "day") {
+            return (0, malloy_types_1.mkExpr) `${rVal}::date - ${lVal}::date`;
+        }
+        const yearDiff = (0, malloy_types_1.mkExpr) `(DATE_PART('year', ${rVal}) - DATE_PART('year', ${lVal}))`;
+        if (units == "year") {
+            return yearDiff;
+        }
+        if (units == "week") {
+            const dayDiffForWeekStart = (0, malloy_types_1.mkExpr) `(DATE_TRUNC('week', ${rVal} + '1 day'::interval)::date - DATE_TRUNC('week', ${lVal} + '1 day'::interval)::date)`;
+            return (0, malloy_types_1.mkExpr) `${dayDiffForWeekStart} / 7`;
+        }
+        if (units == "month") {
+            const monthDiff = (0, malloy_types_1.mkExpr) `DATE_PART('month', ${rVal}) - DATE_PART('month', ${lVal})`;
+            return (0, malloy_types_1.mkExpr) `${yearDiff} * 12 + ${monthDiff}`;
+        }
+        if (units == "quarter") {
+            const qDiff = (0, malloy_types_1.mkExpr) `DATE_PART('quarter', ${rVal}) - DATE_PART('quarter', ${lVal})`;
+            return (0, malloy_types_1.mkExpr) `${yearDiff} * 4 + ${qDiff}`;
+        }
+        throw new Error(`Unknown or unhandled postgres time unit: ${units}`);
+    }
+    sqlSumDistinct(key, value) {
+        // return `sum_distinct(list({key:${key}, val: ${value}}))`;
+        return `(
+      SELECT sum((a::json->>'f2')::DOUBLE PRECISION) as value
+      FROM (
+        SELECT UNNEST(array_agg(distinct row_to_json(row(${key},${value}))::text)) a
+      ) a
+    )`;
+    }
+    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 SYSTEM_ROWS(${sample.rows}))`;
+            }
+            else if ((0, malloy_types_1.isSamplingPercent)(sample)) {
+                return `(SELECT * FROM ${tableSQL} TABLESAMPLE SYSTEM (${sample.percent}))`;
+            }
+        }
+        return tableSQL;
+    }
+    sqlOrderBy(orderTerms) {
+        return `ORDER BY ${orderTerms.map((t) => `${t} NULLS LAST`).join(",")}`;
+    }
+    sqlLiteralString(literal) {
+        return "'" + literal.replace(/'/g, "''") + "'";
+    }
+}
+exports.PostgresDialect = PostgresDialect;
+//# sourceMappingURL=postgres.js.map

package/dist/dialect/standardsql.d.ts

@@ -0,0 +1,49 @@
+import { TimestampUnit, ExtractUnit, Expr, TimeValue, TypecastFragment, Sampling } from "../model/malloy_types";
+import { Dialect, DialectFieldList, FunctionInfo } from "./dialect";
+export declare class StandardSQLDialect extends Dialect {
+    name: string;
+    defaultNumberType: string;
+    udfPrefix: string;
+    hasFinalStage: boolean;
+    stringTypeName: string;
+    divisionIsInteger: boolean;
+    supportsSumDistinctFunction: boolean;
+    unnestWithNumbers: boolean;
+    defaultSampling: {
+        enable: boolean;
+    };
+    supportUnnestArrayAgg: boolean;
+    supportsCTEinCoorelatedSubQueries: boolean;
+    dontUnionIndex: boolean;
+    supportsQualify: boolean;
+    functionInfo: Record<string, FunctionInfo>;
+    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): 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(sqlTime: TimeValue, units: TimestampUnit): Expr;
+    sqlExtract(expr: TimeValue, units: ExtractUnit): Expr;
+    sqlAlterTime(op: "+" | "-", expr: TimeValue, n: Expr, timeframe: TimestampUnit): Expr;
+    ignoreInProject(fieldName: string): boolean;
+    sqlCast(cast: TypecastFragment): Expr;
+    sqlRegexpMatch(expr: Expr, regexp: string): Expr;
+    sqlLiteralTime(timeString: string, type: "date" | "timestamp", timezone: string): string;
+    sqlMeasureTime(from: TimeValue, to: TimeValue, units: string): Expr;
+    sqlSampleTable(tableSQL: string, sample: Sampling | undefined): string;
+    sqlLiteralString(literal: string): string;
+}