@malloydata/malloy 0.0.3 → 0.0.4

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

@@ -141,7 +141,6 @@ export declare class ExprParens extends ExpressionDef {
     readonly expr: ExpressionDef;
     elementType: string;
     constructor(expr: ExpressionDef);
-    apply(fs: FieldSpace, op: string, expr: ExpressionDef): ExprValue;
     requestExpression(fs: FieldSpace): ExprValue | undefined;
     getExpression(fs: FieldSpace): ExprValue;
 }

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

@@ -303,9 +303,9 @@ export declare class WildcardFieldReference extends MalloyElement {
 }
 export declare class OrderBy extends MalloyElement {
     readonly field: number | FieldName;
-    readonly dir?: "desc" | "asc" | undefined;
+    readonly dir?: "asc" | "desc" | undefined;
     elementType: string;
-    constructor(field: number | FieldName, dir?: "desc" | "asc" | undefined);
+    constructor(field: number | FieldName, dir?: "asc" | "desc" | undefined);
     get modelField(): string | number;
     getOrderBy(_fs: FieldSpace): model.OrderBy;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@malloydata/malloy",
-  "version": "0.0.3",
+  "version": "0.0.4",
   "license": "GPL-2.0",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/dist/connection_utils.js

@@ -1,56 +0,0 @@
-"use strict";
-/*
- * Copyright 2022 Google LLC
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License
- * version 2 as published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- */
-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.js

@@ -1,77 +0,0 @@
-"use strict";
-/*
- * Copyright 2021 Google LLC
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License
- * version 2 as published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Dialect = void 0;
-// Can't get these from "../model" because model includes this file
-// and that can create a circular reference problem. This is a patch
-// and really indicates a problem in the relationship between
-// dialect and model, it's going to come up again some time.
-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)];
-        }
-    }
-    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.js

@@ -1,35 +0,0 @@
-"use strict";
-/*
- * Copyright 2021 Google LLC
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License
- * version 2 as published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.registerDialect = exports.getDialect = void 0;
-const _1 = require(".");
-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 _1.DuckDBDialect());
-//# sourceMappingURL=dialect_map.js.map

package/dist/dialect/duckdb.js

@@ -1,347 +0,0 @@
-"use strict";
-/*
- * Copyright 2021 Google LLC
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License
- * version 2 as published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DuckDBDialect = void 0;
-const model_1 = require("../model");
-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.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})`;
-    }
-    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, model_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, model_1.mkExpr) `EXTRACT(EPOCH FROM ${lVal})`;
-            rVal = (0, model_1.mkExpr) `EXTRACT(EPOCH FROM ${rVal})`;
-            const duration = (0, model_1.mkExpr) `(${rVal} - ${lVal})`;
-            return units == "second"
-                ? duration
-                : (0, model_1.mkExpr) `FLOOR(${duration}/${inSeconds[units].toString()})`;
-        }
-        if (from.valueType != "date") {
-            lVal = (0, model_1.mkExpr) `CAST((${lVal}) AS DATE)`;
-        }
-        if (to.valueType != "date") {
-            rVal = (0, model_1.mkExpr) `CAST((${rVal}) AS DATE)`;
-        }
-        if (units == "week") {
-            // DuckDB's weeks start on Monday, but Malloy's weeks start on Sunday
-            lVal = (0, model_1.mkExpr) `(${lVal} + INTERVAL 1 DAY)`;
-            rVal = (0, model_1.mkExpr) `(${rVal} + INTERVAL 1 DAY)`;
-        }
-        return (0, model_1.mkExpr) `DATE_DIFF('${units}', ${lVal}, ${rVal})`;
-    }
-    sqlNow() {
-        return (0, model_1.mkExpr) `CURRENT_TIMESTAMP`;
-    }
-    sqlTrunc(sqlTime, units) {
-        // adjusting for monday/sunday weeks
-        const week = units == "week";
-        const truncThis = week
-            ? (0, model_1.mkExpr) `${sqlTime.value} + INTERVAL 1 DAY`
-            : sqlTime.value;
-        const trunced = (0, model_1.mkExpr) `DATE_TRUNC('${units}', ${truncThis})`;
-        return week ? (0, model_1.mkExpr) `(${trunced} - INTERVAL 1 DAY)` : trunced;
-    }
-    sqlExtract(from, units) {
-        const pgUnits = pgExtractionMap[units] || units;
-        const extracted = (0, model_1.mkExpr) `EXTRACT(${pgUnits} FROM ${from.value})`;
-        return units == "day_of_week" ? (0, model_1.mkExpr) `(${extracted}+1)` : extracted;
-    }
-    sqlAlterTime(op, expr, n, timeframe) {
-        if (timeframe == "quarter") {
-            timeframe = "month";
-            n = (0, model_1.mkExpr) `${n}*3`;
-        }
-        if (timeframe == "week") {
-            timeframe = "day";
-            n = (0, model_1.mkExpr) `${n}*7`;
-        }
-        const interval = (0, model_1.mkExpr) `INTERVAL (${n}) ${timeframe}`;
-        return (0, model_1.mkExpr) `((${expr.value})) ${op} ${interval}`;
-    }
-    sqlCast(cast) {
-        if (cast.dstType !== cast.srcType) {
-            const castTo = castMap[cast.dstType] || cast.dstType;
-            return (0, model_1.mkExpr) `cast(${cast.expr} as ${castTo})`;
-        }
-        return cast.expr;
-    }
-    sqlRegexpMatch(expr, regexp) {
-        return (0, model_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, model_1.isSamplingEnable)(sample) && sample.enable) {
-                sample = this.defaultSampling;
-            }
-            if ((0, model_1.isSamplingRows)(sample)) {
-                return `(SELECT * FROM ${tableSQL} USING SAMPLE ${sample.rows})`;
-            }
-            else if ((0, model_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(",")}`;
-    }
-}
-exports.DuckDBDialect = DuckDBDialect;
-//# sourceMappingURL=duckdb.js.map

package/dist/dialect/index.js

@@ -1,27 +0,0 @@
-"use strict";
-/*
- * Copyright 2021 Google LLC
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License
- * version 2 as published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- */
-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