@malloydata/malloy 0.0.24-dev230224184907 → 0.0.24-dev230228224434

package/dist/connection_utils.js

@@ -27,22 +27,22 @@ async function* toAsyncGenerator(startStreaming) {
     let done = false;
     function getResults(startStreaming) {
         let resolve;
-        const promise = new Promise((res) => {
+        const promise = new Promise(res => {
             resolve = res;
         });
-        startStreaming((error) => {
-            resolve({ "done": true, "isError": true, error });
-        }, (data) => {
+        startStreaming(error => {
+            resolve({ done: true, isError: true, error });
+        }, data => {
             resolve({
-                "done": false,
-                "value": data,
-                "isError": false,
-                "next": new Promise((res) => {
+                done: false,
+                value: data,
+                isError: false,
+                next: new Promise(res => {
                     resolve = res;
-                })
+                }),
             });
         }, () => {
-            resolve({ "done": true, "isError": false });
+            resolve({ done: true, isError: false });
         });
         return promise;
     }

package/dist/dialect/dialect.d.ts

@@ -1,4 +1,4 @@
-import { AtomicFieldType as AtomicFieldTypeInner, DialectFragment, Expr, ExtractUnit, Sampling, StructDef, TimeFieldType, TimeValue, TimestampUnit, TypecastFragment } from "../model/malloy_types";
+import { AtomicFieldType as AtomicFieldTypeInner, DialectFragment, Expr, ExtractUnit, Sampling, StructDef, TimeFieldType, TimeValue, TimestampUnit, TypecastFragment } from '../model/malloy_types';
 interface DialectField {
     type: string;
     sqlExpression: string;
@@ -51,7 +51,7 @@ export declare abstract class Dialect {
     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;
+    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;

package/dist/dialect/dialect.js

@@ -26,7 +26,7 @@ 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");
+        throw new Error('Dialect has no final Stage but called Anyway');
     }
     // default implementation will probably work most of the time
     sqlDateToString(sqlDateExp) {
@@ -42,34 +42,34 @@ class Dialect {
     }
     dialectExpr(df) {
         switch (df.function) {
-            case "now":
+            case 'now':
                 return this.sqlNow();
-            case "timeDiff":
+            case 'timeDiff':
                 return this.sqlMeasureTime(df.left, df.right, df.units);
-            case "delta":
+            case 'delta':
                 return this.sqlAlterTime(df.op, df.base, df.delta, df.units);
-            case "trunc":
+            case 'trunc':
                 return this.sqlTrunc(df.expr, df.units);
-            case "extract":
+            case 'extract':
                 return this.sqlExtract(df.expr, df.units);
-            case "cast":
+            case 'cast':
                 return this.sqlCast(df);
-            case "regexpMatch":
+            case 'regexpMatch':
                 return this.sqlRegexpMatch(df.expr, df.regexp);
-            case "div": {
+            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":
+            case 'timeLiteral':
                 return [this.sqlLiteralTime(df.literal, df.literalType, df.timezone)];
-            case "stringLiteral":
+            case 'stringLiteral':
                 return [this.sqlLiteralString(df.literal)];
         }
     }
     sqlSumDistinct(_key, _value) {
-        return "sqlSumDistinct called bu not implemented";
+        return 'sqlSumDistinct called bu not implemented';
     }
     sqlSampleTable(tableSQL, sample) {
         if (sample !== undefined) {
@@ -78,7 +78,7 @@ class Dialect {
         return tableSQL;
     }
     sqlOrderBy(orderTerms) {
-        return `ORDER BY ${orderTerms.join(",")}`;
+        return `ORDER BY ${orderTerms.join(',')}`;
     }
 }
 exports.Dialect = Dialect;

package/dist/dialect/dialect_map.d.ts

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

package/dist/dialect/duckdb.d.ts

@@ -1,5 +1,5 @@
-import { DateUnit, Expr, ExtractUnit, Sampling, StructDef, TimeFieldType, TimeValue, TimestampUnit, TypecastFragment } from "../model/malloy_types";
-import { Dialect, DialectFieldList, FunctionInfo } from "./dialect";
+import { DateUnit, Expr, ExtractUnit, Sampling, StructDef, TimeFieldType, TimeValue, TimestampUnit, TypecastFragment } from '../model/malloy_types';
+import { Dialect, DialectFieldList, FunctionInfo } from './dialect';
 export declare class DuckDBDialect extends Dialect {
     name: string;
     defaultNumberType: string;
@@ -41,7 +41,7 @@ export declare class DuckDBDialect extends Dialect {
     sqlNow(): Expr;
     sqlTrunc(sqlTime: TimeValue, units: TimestampUnit): Expr;
     sqlExtract(from: TimeValue, units: ExtractUnit): Expr;
-    sqlAlterTime(op: "+" | "-", expr: TimeValue, n: Expr, timeframe: DateUnit): 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;

package/dist/dialect/duckdb.js

@@ -27,8 +27,8 @@ 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 = `
+const hackSplitComment = '-- hack: split on this';
+const _keywords = `
 ALL
 ANALYSE
 ANALYZE
@@ -108,35 +108,35 @@ WINDOW
 WITH
 `.split(/\s/);
 const castMap = {
-    "number": "double precision",
-    "string": "varchar"
+    number: 'double precision',
+    string: 'varchar',
 };
 const pgExtractionMap = {
-    "day_of_week": "dow",
-    "day_of_year": "doy"
+    day_of_week: 'dow',
+    day_of_year: 'doy',
 };
 const inSeconds = {
-    "second": 1,
-    "minute": 60,
-    "hour": 3600
+    second: 1,
+    minute: 60,
+    hour: 3600,
 };
 class DuckDBDialect extends dialect_1.Dialect {
     constructor() {
         super(...arguments);
-        this.name = "duckdb";
-        this.defaultNumberType = "DOUBLE";
+        this.name = 'duckdb';
+        this.defaultNumberType = 'DOUBLE';
         this.hasFinalStage = false;
-        this.stringTypeName = "VARCHAR";
+        this.stringTypeName = 'VARCHAR';
         this.divisionIsInteger = true;
         this.supportsSumDistinctFunction = true;
         this.unnestWithNumbers = true;
-        this.defaultSampling = { "rows": 50000 };
+        this.defaultSampling = { rows: 50000 };
         this.supportUnnestArrayAgg = true;
         this.supportsCTEinCoorelatedSubQueries = true;
         this.dontUnionIndex = false;
         this.supportsQualify = true;
         this.functionInfo = {
-            "concat": { "returnType": "string" }
+            concat: { returnType: 'string' },
         };
     }
     // hack until they support temporary macros.
@@ -153,22 +153,22 @@ class DuckDBDialect extends dialect_1.Dialect {
         return `FIRST(${fieldName}) FILTER (WHERE ${fieldName} IS NOT NULL)`;
     }
     mapFields(fieldList) {
-        return fieldList.join(", ");
+        return fieldList.join(', ');
     }
     sqlAggregateTurtle(groupSet, fieldList, orderBy, limit) {
-        let tail = "";
+        let tail = '';
         if (limit !== undefined) {
             tail += `[1:${limit}]`;
         }
         const fields = fieldList
-            .map((f) => `\n  ${f.sqlOutputName}: ${f.sqlExpression}`)
-            .join(", ");
+            .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(", ");
+            .map(f => `${f.sqlExpression} as ${f.sqlOutputName}`)
+            .join(', ');
         return `ANY_VALUE(CASE WHEN group_set=${groupSet} THEN ROW(${fields}))`;
     }
     sqlAnyValueLastTurtle(name, groupSet, sqlName) {
@@ -176,11 +176,11 @@ class DuckDBDialect extends dialect_1.Dialect {
     }
     sqlCoaleseMeasuresInline(groupSet, fieldList) {
         const fields = fieldList
-            .map((f) => `${f.sqlOutputName}: ${f.sqlExpression} `)
-            .join(", ");
+            .map(f => `${f.sqlOutputName}: ${f.sqlExpression} `)
+            .join(', ');
         const nullValues = fieldList
-            .map((f) => `${f.sqlOutputName}: NULL`)
-            .join(", ");
+            .map(f => `${f.sqlOutputName}: NULL`)
+            .join(', ');
         return `COALESCE(FIRST({${fields}}) FILTER(WHERE group_set=${groupSet}), {${nullValues}})`;
     }
     sqlUnnestAlias(source, alias, _fieldList, _needDistinctKey) {
@@ -192,10 +192,10 @@ class DuckDBDialect extends dialect_1.Dialect {
         //return `,(select UNNEST(generate_series(1, length(${source}),1))) as ${alias}(__row_id)`;
     }
     sqlSumDistinctHashedKey(_sqlDistinctKey) {
-        return "uses sumDistinctFunction, should not be called";
+        return 'uses sumDistinctFunction, should not be called';
     }
     sqlGenerateUUID() {
-        return `GEN_RANDOM_UUID()`;
+        return 'GEN_RANDOM_UUID()';
     }
     sqlDateToString(sqlDateExp) {
         return `(${sqlDateExp})::date::varchar`;
@@ -220,13 +220,13 @@ class DuckDBDialect extends dialect_1.Dialect {
     }
     sqlCreateFunctionCombineLastStage(lastStageName, structDef) {
         return `SELECT LIST(ROW(${structDef.fields
-            .map((fieldDef) => this.sqlMaybeQuoteIdentifier((0, malloy_types_1.getIdentifier)(fieldDef)))
-            .join(",")})) FROM ${lastStageName}\n`;
+            .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(", ")})`;
+            .map(name => `${alias}.${name}`)
+            .join(', ')})`;
     }
     // TODO
     // sqlMaybeQuoteIdentifier(identifier: string): string {
@@ -242,7 +242,7 @@ class DuckDBDialect extends dialect_1.Dialect {
     //  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");
+        throw new Error('Not implemented Yet');
     }
     getFunctionInfo(functionName) {
         return this.functionInfo[functionName];
@@ -254,17 +254,17 @@ class DuckDBDialect extends dialect_1.Dialect {
             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"
+            return units === 'second'
                 ? duration
                 : (0, malloy_types_1.mkExpr) `FLOOR(${duration}/${inSeconds[units].toString()})`;
         }
-        if (from.valueType != "date") {
+        if (from.valueType !== 'date') {
             lVal = (0, malloy_types_1.mkExpr) `CAST((${lVal}) AS DATE)`;
         }
-        if (to.valueType != "date") {
+        if (to.valueType !== 'date') {
             rVal = (0, malloy_types_1.mkExpr) `CAST((${rVal}) AS DATE)`;
         }
-        if (units == "week") {
+        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)`;
@@ -276,7 +276,7 @@ class DuckDBDialect extends dialect_1.Dialect {
     }
     sqlTrunc(sqlTime, units) {
         // adjusting for monday/sunday weeks
-        const week = units == "week";
+        const week = units === 'week';
         const truncThis = week
             ? (0, malloy_types_1.mkExpr) `${sqlTime.value} + INTERVAL 1 DAY`
             : sqlTime.value;
@@ -286,15 +286,15 @@ class DuckDBDialect extends dialect_1.Dialect {
     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;
+        return units === 'day_of_week' ? (0, malloy_types_1.mkExpr) `(${extracted}+1)` : extracted;
     }
     sqlAlterTime(op, expr, n, timeframe) {
-        if (timeframe == "quarter") {
-            timeframe = "month";
+        if (timeframe === 'quarter') {
+            timeframe = 'month';
             n = (0, malloy_types_1.mkExpr) `${n}*3`;
         }
-        if (timeframe == "week") {
-            timeframe = "day";
+        if (timeframe === 'week') {
+            timeframe = 'day';
             n = (0, malloy_types_1.mkExpr) `${n}*7`;
         }
         const interval = (0, malloy_types_1.mkExpr) `INTERVAL (${n}) ${timeframe}`;
@@ -311,10 +311,10 @@ class DuckDBDialect extends dialect_1.Dialect {
         return (0, malloy_types_1.mkExpr) `REGEXP_MATCHES(${expr}, ${regexp})`;
     }
     sqlLiteralTime(timeString, type, _timezone) {
-        if (type == "date") {
+        if (type === 'date') {
             return `DATE '${timeString}'`;
         }
-        else if (type == "timestamp") {
+        else if (type === 'timestamp') {
             return `TIMESTAMP '${timeString}'`;
         }
         else {
@@ -354,7 +354,7 @@ class DuckDBDialect extends dialect_1.Dialect {
         return tableSQL;
     }
     sqlOrderBy(orderTerms) {
-        return `ORDER BY ${orderTerms.map((t) => `${t} NULLS LAST`).join(",")}`;
+        return `ORDER BY ${orderTerms.map(t => `${t} NULLS LAST`).join(',')}`;
     }
     sqlLiteralString(literal) {
         return "'" + literal.replace(/'/g, "''") + "'";

package/dist/dialect/index.d.ts

@@ -1,6 +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";
+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/postgres.d.ts

@@ -1,5 +1,5 @@
-import { DateUnit, Expr, ExtractUnit, Sampling, TimeFieldType, TimeValue, TimestampUnit, TypecastFragment } from "../model/malloy_types";
-import { Dialect, DialectFieldList, FunctionInfo } from "./dialect";
+import { DateUnit, Expr, ExtractUnit, Sampling, TimeFieldType, TimeValue, TimestampUnit, TypecastFragment } from '../model/malloy_types';
+import { Dialect, DialectFieldList, FunctionInfo } from './dialect';
 export declare class PostgresDialect extends Dialect {
     name: string;
     defaultNumberType: string;
@@ -39,7 +39,7 @@ export declare class PostgresDialect extends Dialect {
     sqlNow(): Expr;
     sqlTrunc(sqlTime: TimeValue, units: TimestampUnit): Expr;
     sqlExtract(from: TimeValue, units: ExtractUnit): Expr;
-    sqlAlterTime(op: "+" | "-", expr: TimeValue, n: Expr, timeframe: DateUnit): 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;

package/dist/dialect/postgres.js

@@ -27,52 +27,52 @@ 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"
+    number: 'double precision',
+    string: 'varchar',
 };
 const pgExtractionMap = {
-    "day_of_week": "dow",
-    "day_of_year": "doy"
+    day_of_week: 'dow',
+    day_of_year: 'doy',
 };
 const pgMakeIntervalMap = {
-    "year": "years",
-    "month": "months",
-    "week": "weeks",
-    "day": "days",
-    "hour": "hours",
-    "minute": "mins",
-    "second": "secs"
+    year: 'years',
+    month: 'months',
+    week: 'weeks',
+    day: 'days',
+    hour: 'hours',
+    minute: 'mins',
+    second: 'secs',
 };
 const inSeconds = {
-    "second": 1,
-    "minute": 60,
-    "hour": 3600
+    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.name = 'postgres';
+        this.defaultNumberType = 'DOUBLE PRECISION';
+        this.udfPrefix = 'pg_temp.__udf';
         this.hasFinalStage = true;
-        this.stringTypeName = "VARCHAR";
+        this.stringTypeName = 'VARCHAR';
         this.divisionIsInteger = true;
         this.supportsSumDistinctFunction = false;
         this.unnestWithNumbers = false;
-        this.defaultSampling = { "rows": 50000 };
+        this.defaultSampling = { rows: 50000 };
         this.supportUnnestArrayAgg = true;
         this.supportsCTEinCoorelatedSubQueries = true;
         this.dontUnionIndex = false;
         this.supportsQualify = false;
         this.functionInfo = {
-            "concat": { "returnType": "string" }
+            concat: { returnType: 'string' },
         };
     }
     quoteTablePath(tablePath) {
         return tablePath
-            .split(".")
-            .map((part) => `"${part}"`)
-            .join(".");
+            .split('.')
+            .map(part => `"${part}"`)
+            .join('.');
     }
     sqlGroupSetTable(groupSetCount) {
         return `CROSS JOIN GENERATE_SERIES(0,${groupSetCount},1) as group_set`;
@@ -82,13 +82,13 @@ class PostgresDialect extends dialect_1.Dialect {
     }
     mapFields(fieldList) {
         return fieldList
-            .map((f) => `\n  ${f.sqlExpression}${f.type == "number" ? `::${this.defaultNumberType}` : ""} as ${f.sqlOutputName}`
+            .map(f => `\n  ${f.sqlExpression}${f.type === 'number' ? `::${this.defaultNumberType}` : ''} as ${f.sqlOutputName}`
         //`${f.sqlExpression} ${f.type} as ${f.sqlOutputName}`
         )
-            .join(", ");
+            .join(', ');
     }
     sqlAggregateTurtle(groupSet, fieldList, orderBy, limit) {
-        let tail = "";
+        let tail = '';
         if (limit !== undefined) {
             tail += `[1:${limit}]`;
         }
@@ -98,8 +98,8 @@ class PostgresDialect extends dialect_1.Dialect {
     }
     sqlAnyValueTurtle(groupSet, fieldList) {
         const fields = fieldList
-            .map((f) => `${f.sqlExpression} as ${f.sqlOutputName}`)
-            .join(", ");
+            .map(f => `${f.sqlExpression} as ${f.sqlOutputName}`)
+            .join(', ');
         return `ANY_VALUE(CASE WHEN group_set=${groupSet} THEN STRUCT(${fields}))`;
     }
     sqlAnyValueLastTurtle(name, groupSet, sqlName) {
@@ -164,18 +164,18 @@ class PostgresDialect extends dialect_1.Dialect {
         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()`;
+        return 'GEN_RANDOM_UUID()';
     }
     sqlFieldReference(alias, fieldName, fieldType, isNested, _isArray) {
         let ret = `${alias}->>'${fieldName}'`;
         if (isNested) {
             switch (fieldType) {
-                case "string":
+                case 'string':
                     break;
-                case "number":
+                case 'number':
                     ret = `(${ret})::double precision`;
                     break;
-                case "struct":
+                case 'struct':
                     ret = `(${ret})::jsonb`;
                     break;
             }
@@ -213,14 +213,14 @@ class PostgresDialect extends dialect_1.Dialect {
     //  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");
+        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 week = units === 'week';
         const truncThis = week
             ? (0, malloy_types_1.mkExpr) `${sqlTime.value}+interval'1'day`
             : sqlTime.value;
@@ -230,11 +230,11 @@ class PostgresDialect extends dialect_1.Dialect {
     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;
+        return units === 'day_of_week' ? (0, malloy_types_1.mkExpr) `(${extracted}+1)` : extracted;
     }
     sqlAlterTime(op, expr, n, timeframe) {
-        if (timeframe == "quarter") {
-            timeframe = "month";
+        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})`;
@@ -251,10 +251,10 @@ class PostgresDialect extends dialect_1.Dialect {
         return (0, malloy_types_1.mkExpr) `(${expr} ~ ${regexp})`;
     }
     sqlLiteralTime(timeString, type, _timezone) {
-        if (type == "date") {
+        if (type === 'date') {
             return `DATE('${timeString}')`;
         }
-        else if (type == "timestamp") {
+        else if (type === 'timestamp') {
             return `TIMESTAMP '${timeString}'`;
         }
         else {
@@ -271,26 +271,26 @@ class PostgresDialect extends dialect_1.Dialect {
             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"
+            return units === 'second'
                 ? duration
                 : (0, malloy_types_1.mkExpr) `TRUNC(${duration}/${inSeconds[units].toString()})`;
         }
-        if (units === "day") {
+        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") {
+        if (units === 'year') {
             return yearDiff;
         }
-        if (units == "week") {
+        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") {
+        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") {
+        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}`;
         }
@@ -320,7 +320,7 @@ class PostgresDialect extends dialect_1.Dialect {
         return tableSQL;
     }
     sqlOrderBy(orderTerms) {
-        return `ORDER BY ${orderTerms.map((t) => `${t} NULLS LAST`).join(",")}`;
+        return `ORDER BY ${orderTerms.map(t => `${t} NULLS LAST`).join(',')}`;
     }
     sqlLiteralString(literal) {
         return "'" + literal.replace(/'/g, "''") + "'";

package/dist/dialect/standardsql.d.ts

@@ -1,5 +1,5 @@
-import { Expr, ExtractUnit, Sampling, TimeValue, TimestampUnit, TypecastFragment } from "../model/malloy_types";
-import { Dialect, DialectFieldList, FunctionInfo } from "./dialect";
+import { Expr, ExtractUnit, Sampling, TimeValue, TimestampUnit, TypecastFragment } from '../model/malloy_types';
+import { Dialect, DialectFieldList, FunctionInfo } from './dialect';
 export declare class StandardSQLDialect extends Dialect {
     name: string;
     defaultNumberType: string;
@@ -38,11 +38,11 @@ export declare class StandardSQLDialect extends Dialect {
     sqlNow(): Expr;
     sqlTrunc(sqlTime: TimeValue, units: TimestampUnit): Expr;
     sqlExtract(expr: TimeValue, units: ExtractUnit): Expr;
-    sqlAlterTime(op: "+" | "-", expr: TimeValue, n: Expr, timeframe: TimestampUnit): 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;
+    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;