@malloydata/malloy 0.0.435 → 0.0.436

package/dist/dialect/trino/trino.js

@@ -23,15 +23,6 @@ function timestampMeasureable(units) {
         'day',
     ].includes(units);
 }
-/**
- * Return a non UTC timezone, if one was specificed.
- */
-function qtz(qi) {
-    const tz = qi.queryTimezone;
-    if (tz && tz !== 'UTC') {
-        return tz;
-    }
-}
 const trinoToMalloyTypes = {
     'varchar': { type: 'string' },
     'integer': { type: 'number', numberType: 'integer' },
@@ -57,6 +48,33 @@ const trinoToMalloyTypes = {
     // TIME
     // GEOGRAPHY
 };
+function trinoTrunc(expr, unit) {
+    // Weeks start on Monday here, so truncate the following day
+    if (unit === 'week') {
+        return `(DATE_TRUNC('${unit}', (${expr} + INTERVAL '1' DAY)) - INTERVAL '1' DAY)`;
+    }
+    return `DATE_TRUNC('${unit}', ${expr})`;
+}
+function trinoDateAdd(expr, op, magnitude, unit) {
+    // DATE_ADD has no quarter or week
+    let offsetUnit = unit;
+    let offsetMag = magnitude;
+    if (unit === 'quarter') {
+        offsetUnit = 'month';
+        offsetMag = `${magnitude}*3`;
+    }
+    else if (unit === 'week') {
+        offsetUnit = 'day';
+        offsetMag = `${magnitude}*7`;
+    }
+    const n = op === '-' ? `(${offsetMag})*-1` : offsetMag;
+    return `DATE_ADD('${offsetUnit}', ${n}, ${expr})`;
+}
+function trinoExtract(expr, units) {
+    const extracted = `EXTRACT(${pg_impl_1.timeExtractMap[units] || units} FROM ${expr})`;
+    // Trino counts the days of a week from 1 on Monday
+    return units === 'day_of_week' ? `mod(${extracted}+1,7)` : extracted;
+}
 class TrinoDialect extends pg_impl_1.PostgresBase {
     constructor() {
         super(...arguments);
@@ -339,87 +357,34 @@ ${(0, utils_1.indent)(sql)}
         const definitions = this.buildTypeExpression(fieldList);
         return `CAST(ROW(${fields}) as ROW(${definitions}))`;
     }
+    // Civil time is a TIMESTAMP, which Trino keeps without a zone
     sqlConvertToCivilTime(expr, timezone, typeDef) {
-        // Trino civil time = TIMESTAMPTZ with query timezone as stored timezone
-        // Operations (extract, truncate, etc.) happen in the stored timezone
-        if (typeDef.type === 'timestamp') {
-            // TIMESTAMP (UTC wall clock) → TIMESTAMPTZ in query timezone
-            return {
-                sql: `at_timezone(with_timezone(${expr}, 'UTC'), ${this.sqlTimezoneLiteral(timezone)})`,
-                typeDef: { type: 'timestamptz' },
-            };
+        const tz = this.sqlTimezoneLiteral(timezone);
+        if (malloy_types_1.TD.isTimestamptz(typeDef)) {
+            return `CAST(at_timezone(${expr}, ${tz}) AS TIMESTAMP)`;
         }
-        // TIMESTAMPTZ → TIMESTAMPTZ in query timezone (same instant, different stored tz)
-        return {
-            sql: `at_timezone(${expr}, ${this.sqlTimezoneLiteral(timezone)})`,
-            typeDef: { type: 'timestamptz' },
-        };
+        return timezone === 'UTC'
+            ? expr
+            : `CAST(at_timezone(with_timezone(${expr}, 'UTC'), ${tz}) AS TIMESTAMP)`;
     }
-    sqlConvertFromCivilTime(expr, _timezone, destTypeDef) {
-        // From civil TIMESTAMPTZ (in query timezone) to destination type
-        if (destTypeDef.type === 'timestamptz') {
-            // Already TIMESTAMPTZ, keep as-is
-            return expr;
-        }
-        // To TIMESTAMP: convert to UTC and cast to plain TIMESTAMP
-        return `CAST(at_timezone(${expr}, 'UTC') AS TIMESTAMP)`;
-    }
-    sqlTruncate(expr, unit, _typeDef, _inCivilTime, _timezone) {
-        // Trino starts weeks on Monday, Malloy wants Sunday
-        // Add 1 day before truncating, subtract 1 day after
-        if (unit === 'week') {
-            return `(DATE_TRUNC('${unit}', (${expr} + INTERVAL '1' DAY)) - INTERVAL '1' DAY)`;
+    sqlConvertFromCivilTime(expr, timezone, destTypeDef) {
+        const tz = this.sqlTimezoneLiteral(timezone);
+        if (malloy_types_1.TD.isTimestamptz(destTypeDef)) {
+            return `with_timezone(${expr}, ${tz})`;
         }
-        return `DATE_TRUNC('${unit}', ${expr})`;
-    }
-    sqlOffsetTime(expr, op, magnitude, unit, _typeDef, _inCivilTime, _timezone) {
-        // Convert quarter/week to supported units
-        let offsetUnit = unit;
-        let offsetMag = magnitude;
-        if (unit === 'quarter') {
-            offsetUnit = 'month';
-            offsetMag = `${magnitude}*3`;
-        }
-        else if (unit === 'week') {
-            offsetUnit = 'day';
-            offsetMag = `${magnitude}*7`;
-        }
-        // Handle subtraction by negating
-        const n = op === '-' ? `(${offsetMag})*-1` : offsetMag;
-        return `DATE_ADD('${offsetUnit}', ${n}, ${expr})`;
+        return timezone === 'UTC'
+            ? expr
+            : `CAST(at_timezone(with_timezone(${expr}, ${tz}), 'UTC') AS TIMESTAMP)`;
+    }
+    sqlTruncate(expr, unit, _civilType) {
+        return trinoTrunc(expr, unit);
     }
-    sqlCast(qi, cast) {
+    sqlOffsetTime(expr, op, magnitude, unit, _civilType) {
+        return trinoDateAdd(expr, op, magnitude, unit);
+    }
+    sqlCast(_qi, cast) {
         const { srcTypeDef, dstTypeDef, dstSQLType } = this.sqlCastPrep(cast);
-        const tz = qtz(qi);
         const expr = cast.e.sql || '';
-        // Timezone-aware casts when query timezone is set
-        if (tz && srcTypeDef && dstTypeDef) {
-            // TIMESTAMP → DATE: interpret as UTC, convert to query timezone
-            if (malloy_types_1.TD.isTimestamp(srcTypeDef) && malloy_types_1.TD.isDate(dstTypeDef)) {
-                return `CAST(at_timezone(with_timezone(${expr}, 'UTC'), ${this.sqlTimezoneLiteral(tz)}) AS DATE)`;
-            }
-            // TIMESTAMPTZ → DATE: convert to query timezone
-            if (malloy_types_1.TD.isTimestamptz(srcTypeDef) && malloy_types_1.TD.isDate(dstTypeDef)) {
-                return `CAST(at_timezone(${expr}, ${this.sqlTimezoneLiteral(tz)}) AS DATE)`;
-            }
-            // DATE → TIMESTAMP: interpret date in query timezone, return UTC wall clock
-            if (malloy_types_1.TD.isDate(srcTypeDef) && malloy_types_1.TD.isTimestamp(dstTypeDef)) {
-                return `CAST(at_timezone(with_timezone(CAST(${expr} AS TIMESTAMP), ${this.sqlTimezoneLiteral(tz)}), 'UTC') AS TIMESTAMP)`;
-            }
-            // DATE → TIMESTAMPTZ: interpret date in query timezone
-            if (malloy_types_1.TD.isDate(srcTypeDef) && malloy_types_1.TD.isTimestamptz(dstTypeDef)) {
-                return `with_timezone(CAST(${expr} AS TIMESTAMP), ${this.sqlTimezoneLiteral(tz)})`;
-            }
-            // TIMESTAMPTZ → TIMESTAMP: convert to query timezone wall clock
-            if (malloy_types_1.TD.isTimestamptz(srcTypeDef) && malloy_types_1.TD.isTimestamp(dstTypeDef)) {
-                return `CAST(at_timezone(${expr}, ${this.sqlTimezoneLiteral(tz)}) AS TIMESTAMP)`;
-            }
-            // TIMESTAMP → TIMESTAMPTZ: interpret TIMESTAMP as being in query timezone
-            if (malloy_types_1.TD.isTimestamp(srcTypeDef) && malloy_types_1.TD.isTimestamptz(dstTypeDef)) {
-                return `with_timezone(${expr}, ${this.sqlTimezoneLiteral(tz)})`;
-            }
-        }
-        // No special handling needed, or no query timezone
         if (!malloy_types_1.TD.eq(srcTypeDef, dstTypeDef)) {
             const castFunc = cast.safe ? 'TRY_CAST' : 'CAST';
             return `${castFunc}(${expr} AS ${dstSQLType})`;
@@ -567,37 +532,12 @@ ${(0, utils_1.indent)(sql)}
     sqlDateLiteral(_qi, literal) {
         return `DATE '${literal}'`;
     }
-    sqlTimestampLiteral(qi, literal, timezone) {
-        const tz = timezone || qtz(qi);
-        if (tz) {
-            // Interpret wall clock time in timezone, convert to UTC wall clock, cast to TIMESTAMP
-            return `CAST(at_timezone(with_timezone(TIMESTAMP '${literal}', ${this.sqlTimezoneLiteral(tz)}), 'UTC') AS TIMESTAMP)`;
-        }
-        return `TIMESTAMP '${literal}'`;
-    }
     sqlTimestamptzLiteral(_qi, literal, timezone) {
         // Use with_timezone to create a TIMESTAMP WITH TIME ZONE
         return `with_timezone(TIMESTAMP '${literal}', ${this.sqlTimezoneLiteral(timezone)})`;
     }
-    sqlTimeExtractExpr(qi, from) {
-        const pgUnits = pg_impl_1.timeExtractMap[from.units] || from.units;
-        let extractFrom = from.e.sql || '';
-        if (malloy_types_1.TD.isAnyTimestamp(from.e.typeDef)) {
-            const tz = qtz(qi);
-            if (tz) {
-                // Convert both TIMESTAMP and TIMESTAMPTZ to query timezone for extraction
-                if (from.e.typeDef.type === 'timestamp') {
-                    // TIMESTAMP: interpret as UTC, convert to query timezone
-                    extractFrom = `at_timezone(with_timezone(${extractFrom}, 'UTC'), ${this.sqlTimezoneLiteral(tz)})`;
-                }
-                else {
-                    // TIMESTAMPTZ: convert to query timezone
-                    extractFrom = `at_timezone(${extractFrom}, ${this.sqlTimezoneLiteral(tz)})`;
-                }
-            }
-        }
-        const extracted = `EXTRACT(${pgUnits} FROM ${extractFrom})`;
-        return from.units === 'day_of_week' ? `mod(${extracted}+1,7)` : extracted;
+    sqlCivilExtract(expr, units, _civilType) {
+        return trinoExtract(expr, units);
     }
     sqlLiteralRecord(lit) {
         var _a, _b;
@@ -630,91 +570,97 @@ class PrestoDialect extends TrinoDialect {
         return `DATE '${literal}'`;
     }
     sqlTimestampLiteral(qi, literal, timezone) {
-        const tz = timezone || qtz(qi);
-        if (tz) {
-            return `CAST(TIMESTAMP '${literal} ${this.checkedTimezoneName(tz)}' AT TIME ZONE 'UTC' AS TIMESTAMP)`;
+        const tz = timezone !== null && timezone !== void 0 ? timezone : (0, dialect_1.queryZone)(qi);
+        if (tz === 'UTC') {
+            return `TIMESTAMP '${literal}'`;
         }
-        return `TIMESTAMP '${literal}'`;
+        return `CAST(TIMESTAMP '${literal} ${this.checkedTimezoneName(tz)}' AS TIMESTAMP)`;
     }
     sqlTimestamptzLiteral(_qi, literal, timezone) {
         return `TIMESTAMP '${literal} ${this.checkedTimezoneName(timezone)}'`;
     }
-    sqlConvertToCivilTime(expr, timezone, _typeDef) {
-        // Presto's AT TIME ZONE operator (not function) produces TIMESTAMPTZ
-        // Reinterprets the instant in the target timezone
-        return {
-            sql: `${expr} AT TIME ZONE ${this.sqlTimezoneLiteral(timezone)}`,
-            typeDef: { type: 'timestamptz' },
-        };
-    }
-    sqlConvertFromCivilTime(expr, _timezone, destTypeDef) {
-        if (destTypeDef.type === 'timestamptz') {
+    /*
+     * Presto cannot meet the civil contract: its only way to read a date and
+     * time of day as an instant in a zone is to parse a string, which fails
+     * on a time the zone skips. So Presto never converts to civil time. It
+     * places an instant in the zone as a TIMESTAMP WITH TIME ZONE, whose
+     * functions read the clock in that zone and resolve any skipped or
+     * repeated time themselves. A Presto TIMESTAMP is an instant shown in the
+     * session zone, which is UTC.
+     */
+    sqlConvertToCivilTime() {
+        throw new Error('Presto has no civil time');
+    }
+    sqlConvertFromCivilTime() {
+        throw new Error('Presto has no civil time');
+    }
+    /** The instant `expr`, showing the clock of `timezone` */
+    inZone(expr, typeDef, timezone) {
+        if (malloy_types_1.TD.isTimestamp(typeDef) && timezone === 'UTC') {
             return expr;
         }
-        return `CAST(${expr} AT TIME ZONE 'UTC' AS TIMESTAMP)`;
+        return `(${expr}) AT TIME ZONE ${this.sqlTimezoneLiteral(timezone)}`;
     }
-    sqlCast(qi, cast) {
-        const { srcTypeDef, dstTypeDef, dstSQLType } = this.sqlCastPrep(cast);
-        const tz = qtz(qi);
-        const expr = cast.e.sql || '';
-        // Timezone-aware casts when query timezone is set
-        // Presto uses AT TIME ZONE operator instead of Trino's with_timezone/at_timezone functions
-        if (tz && srcTypeDef && dstTypeDef) {
-            // TIMESTAMP → DATE: interpret as UTC, convert to query timezone
-            if (malloy_types_1.TD.isTimestamp(srcTypeDef) && malloy_types_1.TD.isDate(dstTypeDef)) {
-                return `CAST((${expr} AT TIME ZONE 'UTC') AT TIME ZONE ${this.sqlTimezoneLiteral(tz)} AS DATE)`;
-            }
-            // TIMESTAMPTZ → DATE: convert to query timezone
-            if (malloy_types_1.TD.isTimestamptz(srcTypeDef) && malloy_types_1.TD.isDate(dstTypeDef)) {
-                return `CAST(${expr} AT TIME ZONE ${this.sqlTimezoneLiteral(tz)} AS DATE)`;
-            }
-            // DATE → TIMESTAMP: interpret date in query timezone, return UTC wall clock
-            // Presto doesn't have a way to interpret TIMESTAMP in a non-UTC timezone,
-            // so we build a TIMESTAMPTZ literal string and cast it
-            if (malloy_types_1.TD.isDate(srcTypeDef) && malloy_types_1.TD.isTimestamp(dstTypeDef)) {
-                const tstzLiteral = `CAST(CAST(${expr} AS VARCHAR) || ' 00:00:00 ${this.checkedTimezoneName(tz)}' AS TIMESTAMP WITH TIME ZONE)`;
-                return `CAST(${tstzLiteral} AS TIMESTAMP)`;
-            }
-            // DATE → TIMESTAMPTZ: interpret date in query timezone
-            if (malloy_types_1.TD.isDate(srcTypeDef) && malloy_types_1.TD.isTimestamptz(dstTypeDef)) {
-                return `CAST(CAST(${expr} AS VARCHAR) || ' 00:00:00 ${this.checkedTimezoneName(tz)}' AS TIMESTAMP WITH TIME ZONE)`;
-            }
-            // TIMESTAMPTZ → TIMESTAMP: convert to query timezone wall clock
-            if (malloy_types_1.TD.isTimestamptz(srcTypeDef) && malloy_types_1.TD.isTimestamp(dstTypeDef)) {
-                return `CAST(${expr} AT TIME ZONE ${this.sqlTimezoneLiteral(tz)} AS TIMESTAMP)`;
-            }
-            // TIMESTAMP → TIMESTAMPTZ: interpret TIMESTAMP as UTC
-            if (malloy_types_1.TD.isTimestamp(srcTypeDef) && malloy_types_1.TD.isTimestamptz(dstTypeDef)) {
-                return `${expr} AT TIME ZONE 'UTC'`;
-            }
-        }
-        // No special handling needed, or no query timezone
-        if (!malloy_types_1.TD.eq(srcTypeDef, dstTypeDef)) {
-            const castFunc = cast.safe ? 'TRY_CAST' : 'CAST';
-            return `${castFunc}(${expr} AS ${dstSQLType})`;
+    /** An instant from inZone, as a value of `typeDef` */
+    fromZone(expr, typeDef, timezone) {
+        if (malloy_types_1.TD.isTimestamp(typeDef) && timezone !== 'UTC') {
+            return `CAST(${expr} AS TIMESTAMP)`;
         }
         return expr;
     }
     sqlTimeExtractExpr(qi, from) {
-        const pgUnits = pg_impl_1.timeExtractMap[from.units] || from.units;
-        let extractFrom = from.e.sql || '';
-        if (malloy_types_1.TD.isAnyTimestamp(from.e.typeDef)) {
-            const tz = qtz(qi);
-            if (tz) {
-                // Convert both TIMESTAMP and TIMESTAMPTZ to query timezone for extraction
-                if (from.e.typeDef.type === 'timestamp') {
-                    // TIMESTAMP: interpret as UTC, convert to query timezone
-                    // Presto uses AT TIME ZONE operator
-                    extractFrom = `(${extractFrom} AT TIME ZONE 'UTC') AT TIME ZONE ${this.sqlTimezoneLiteral(tz)}`;
-                }
-                else {
-                    // TIMESTAMPTZ: convert to query timezone
-                    extractFrom = `${extractFrom} AT TIME ZONE ${this.sqlTimezoneLiteral(tz)}`;
-                }
+        const time = from.e;
+        const expr = malloy_types_1.TD.isAnyTimestamp(time.typeDef)
+            ? this.inZone(time.sql, time.typeDef, (0, dialect_1.queryZone)(qi))
+            : time.sql;
+        return trinoExtract(expr, from.units);
+    }
+    sqlTruncAndOffset(baseExpr, qi, truncateTo, offset) {
+        const timeType = baseExpr.typeDef;
+        // Adding hours, minutes or seconds to an instant needs no zone
+        const usesQueryZone = malloy_types_1.TD.isAnyTimestamp(timeType) &&
+            (truncateTo !== undefined ||
+                (offset !== undefined && (0, malloy_types_1.isDateUnit)(offset.unit)));
+        const zone = (0, dialect_1.queryZone)(qi);
+        let sql = usesQueryZone
+            ? this.inZone(baseExpr.sql, timeType, zone)
+            : baseExpr.sql;
+        if (truncateTo) {
+            sql = trinoTrunc(sql, truncateTo);
+        }
+        if (offset) {
+            sql = trinoDateAdd(sql, offset.op, offset.magnitude, offset.unit);
+        }
+        return usesQueryZone ? this.fromZone(sql, timeType, zone) : sql;
+    }
+    sqlTimeCast(qi, cast) {
+        var _a;
+        const { srcTypeDef, dstTypeDef } = this.sqlCastPrep(cast);
+        const expr = (_a = cast.e.sql) !== null && _a !== void 0 ? _a : '';
+        const zone = (0, dialect_1.queryZone)(qi);
+        if (malloy_types_1.TD.isAnyTimestamp(srcTypeDef)) {
+            if (malloy_types_1.TD.isDate(dstTypeDef)) {
+                return `CAST(${this.inZone(expr, srcTypeDef, zone)} AS DATE)`;
+            }
+            if (malloy_types_1.TD.isTimestamp(dstTypeDef) && malloy_types_1.TD.isTimestamptz(srcTypeDef)) {
+                return `CAST(${expr} AS TIMESTAMP)`;
+            }
+            if (malloy_types_1.TD.isTimestamptz(dstTypeDef) && malloy_types_1.TD.isTimestamp(srcTypeDef)) {
+                return `(${expr}) AT TIME ZONE 'UTC'`;
+            }
+        }
+        if (malloy_types_1.TD.isDate(srcTypeDef) && malloy_types_1.TD.isAnyTimestamp(dstTypeDef)) {
+            if (zone === 'UTC') {
+                const midnight = `CAST(${expr} AS TIMESTAMP)`;
+                return malloy_types_1.TD.isTimestamp(dstTypeDef)
+                    ? midnight
+                    : `(${midnight}) AT TIME ZONE 'UTC'`;
             }
+            // Fails in a zone which skips the midnight starting the date
+            const midnight = `CAST(CAST(${expr} AS VARCHAR) || ' 00:00:00 ${this.checkedTimezoneName(zone)}' AS TIMESTAMP WITH TIME ZONE)`;
+            return this.fromZone(midnight, dstTypeDef, zone);
         }
-        const extracted = `EXTRACT(${pgUnits} FROM ${extractFrom})`;
-        return from.units === 'day_of_week' ? `mod(${extracted}+1,7)` : extracted;
+        return undefined;
     }
     sqlUnnestAlias(source, alias, _fieldList, needDistinctKey, isArray, _isInNestedPipeline) {
         if (isArray) {

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-export { DuckDBDialect, StandardSQLDialect, TrinoDialect, PostgresDialect, SnowflakeDialect, MySQLDialect, DatabricksDialect, SQLServerDialect, registerDialect, getDialect, arg, qtz, overload, minScalar, anyExprType, minAggregate, maxScalar, sql, makeParam, param, variadicParam, literal, spread, Dialect, decodeDottedTablePath, validateDottedTablePath, } from './dialect';
+export { DuckDBDialect, StandardSQLDialect, TrinoDialect, PostgresDialect, SnowflakeDialect, MySQLDialect, DatabricksDialect, SQLServerDialect, registerDialect, getDialect, arg, queryZone, overload, minScalar, anyExprType, minAggregate, maxScalar, sql, makeParam, param, variadicParam, literal, spread, Dialect, decodeDottedTablePath, validateDottedTablePath, } from './dialect';
 export type { DialectFieldList, DialectFunctionOverloadDef, QueryInfo, MalloyStandardFunctionImplementations, DefinitionBlueprint, DefinitionBlueprintMap, OverloadedDefinitionBlueprint, DecodeDottedTablePathResult, DottedTablePathOptions, TablePathEscapeStyle, TablePathSegment, ValidateTablePathResult, } from './dialect';
 export type { QueryRecord, StructDef, TableSourceDef, SQLSourceDef, SourceDef, JoinFieldDef, NamedSourceDefs, MalloyQueryData, DateUnit, ExtractUnit, TimestampUnit, TemporalFieldType, QueryData, QueryValue, Expr, FilterCondition, Argument, Parameter, FieldDef, PipeSegment, QueryFieldDef, IndexFieldDef, TurtleDef, SearchValueMapResult, SearchIndexResult, ModelDef, Query, QueryResult, QueryResultDef, QueryRunStats, QueryScalar, NamedQueryDef, NamedModelObject, ExpressionType, FunctionDef, FunctionOverloadDef, FunctionParameterDef, ExpressionValueType, TypeDesc, FunctionParamTypeDesc, DocumentLocation, DocumentRange, DocumentPosition, Sampling, BasicAtomicTypeDef, BasicAtomicDef, AtomicTypeDef, AtomicFieldDef, ArrayDef, ArrayTypeDef, RecordTypeDef, RepeatedRecordTypeDef, RecordDef, RepeatedRecordDef, RecordLiteralNode, StringLiteralNode, ArrayLiteralNode, SourceComponentInfo, DateLiteralNode, TimestampLiteralNode, TimestamptzLiteralNode, TimeLiteralExpr, TypecastExpr, BuildID, BuildManifest, BuildManifestEntry, GivenValue, VirtualMap, } from './model';
 export { isSourceDef, isAtomic, isBasicAtomic, isCompoundArrayData, isJoined, isJoinedSource, isSamplingEnable, isSamplingPercent, isSamplingRows, isRepeatedRecord, isBasicArray, mkArrayDef, mkFieldDef, expressionIsAggregate, expressionIsAnalytic, expressionIsCalculation, expressionIsScalar, expressionIsUngroupedAggregate, indent, composeSQLExpr, isTimestampUnit, isDateUnit, constantExprToSQL, } from './model';
@@ -25,7 +25,7 @@ export { routeOf, payloadOf, annotationsForRoute, tagFromAnnotations, } from './
 /** @deprecated — use the `.annotations` view on a Foundation entity
  *  (`entity.annotations.parseAsTag(route)` / `.texts(route)`). */
 export { annotationToTag, annotationToTaglines, } from './api/foundation/annotation';
-export type { BuildGraph, BuildNode, BuildPlan, BuildTarget, BuildTargets, ConnectionBuild, } from './api/foundation';
+export type { BuildGraph, BuildNode, BuildPlan, BuildTarget, BuildTargetOptions, BuildTargets, ConnectionBuild, UnbuildableSource, } from './api/foundation';
 export { PersistSource, EMPTY_BUILD_MANIFEST } from './api/foundation';
 export { Reference } from './api/foundation';
 export type { ReferenceKind } from './api/foundation';

package/dist/index.js

@@ -37,7 +37,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.malloyToQuery = exports.constantExprToSQL = exports.isDateUnit = exports.isTimestampUnit = exports.composeSQLExpr = exports.indent = exports.expressionIsUngroupedAggregate = exports.expressionIsScalar = exports.expressionIsCalculation = exports.expressionIsAnalytic = exports.expressionIsAggregate = exports.mkFieldDef = exports.mkArrayDef = exports.isBasicArray = exports.isRepeatedRecord = exports.isSamplingRows = exports.isSamplingPercent = exports.isSamplingEnable = exports.isJoinedSource = exports.isJoined = exports.isCompoundArrayData = exports.isBasicAtomic = exports.isAtomic = exports.isSourceDef = exports.validateDottedTablePath = exports.decodeDottedTablePath = exports.Dialect = exports.spread = exports.literal = exports.variadicParam = exports.param = exports.makeParam = exports.sql = exports.maxScalar = exports.minAggregate = exports.anyExprType = exports.minScalar = exports.overload = exports.qtz = exports.arg = exports.getDialect = exports.registerDialect = exports.SQLServerDialect = exports.DatabricksDialect = exports.MySQLDialect = exports.SnowflakeDialect = exports.PostgresDialect = exports.TrinoDialect = exports.StandardSQLDialect = exports.DuckDBDialect = void 0;
+exports.malloyToQuery = exports.constantExprToSQL = exports.isDateUnit = exports.isTimestampUnit = exports.composeSQLExpr = exports.indent = exports.expressionIsUngroupedAggregate = exports.expressionIsScalar = exports.expressionIsCalculation = exports.expressionIsAnalytic = exports.expressionIsAggregate = exports.mkFieldDef = exports.mkArrayDef = exports.isBasicArray = exports.isRepeatedRecord = exports.isSamplingRows = exports.isSamplingPercent = exports.isSamplingEnable = exports.isJoinedSource = exports.isJoined = exports.isCompoundArrayData = exports.isBasicAtomic = exports.isAtomic = exports.isSourceDef = exports.validateDottedTablePath = exports.decodeDottedTablePath = exports.Dialect = exports.spread = exports.literal = exports.variadicParam = exports.param = exports.makeParam = exports.sql = exports.maxScalar = exports.minAggregate = exports.anyExprType = exports.minScalar = exports.overload = exports.queryZone = exports.arg = exports.getDialect = exports.registerDialect = exports.SQLServerDialect = exports.DatabricksDialect = exports.MySQLDialect = exports.SnowflakeDialect = exports.PostgresDialect = exports.TrinoDialect = exports.StandardSQLDialect = exports.DuckDBDialect = void 0;
 exports.PersistSource = exports.annotationToTaglines = exports.annotationToTag = exports.tagFromAnnotations = exports.annotationsForRoute = exports.payloadOf = exports.routeOf = exports.RoutedNote = exports.Annotations = exports.sqlKey = exports.API = exports.sourceDefToSourceInfo = exports.modelDefToModelInfo = exports.toAsyncGenerator = exports.createConnectionsFromConfig = exports.getRegisteredConnectionTypes = exports.getConnectionTypeDisplayName = exports.getConnectionProperties = exports.registerConnectionType = exports.discoverConfig = exports.defaultConfigOverlays = exports.contextOverlay = exports.envOverlay = exports.MalloyConfig = exports.Manifest = exports.CacheManager = exports.InMemoryModelCache = exports.Explore = exports.DataWriter = exports.Parse = exports.JSONWriter = exports.CSVWriter = exports.QueryMaterializer = exports.Result = exports.PreparedResult = exports.TimestampTimeframe = exports.DateTimeframe = exports.SourceRelationship = exports.JoinRelationship = exports.MalloyError = exports.FixedConnectionMap = exports.InMemoryURLReader = exports.EmptyURLReader = exports.SingleConnectionRuntime = exports.ConnectionRuntime = exports.AtomicFieldType = exports.Runtime = exports.Malloy = exports.Model = exports.MalloyTranslator = void 0;
 exports.makeDigest = exports.Reference = exports.EMPTY_BUILD_MANIFEST = void 0;
 var dialect_1 = require("./dialect");
@@ -52,7 +52,7 @@ Object.defineProperty(exports, "SQLServerDialect", { enumerable: true, get: func
 Object.defineProperty(exports, "registerDialect", { enumerable: true, get: function () { return dialect_1.registerDialect; } });
 Object.defineProperty(exports, "getDialect", { enumerable: true, get: function () { return dialect_1.getDialect; } });
 Object.defineProperty(exports, "arg", { enumerable: true, get: function () { return dialect_1.arg; } });
-Object.defineProperty(exports, "qtz", { enumerable: true, get: function () { return dialect_1.qtz; } });
+Object.defineProperty(exports, "queryZone", { enumerable: true, get: function () { return dialect_1.queryZone; } });
 Object.defineProperty(exports, "overload", { enumerable: true, get: function () { return dialect_1.overload; } });
 Object.defineProperty(exports, "minScalar", { enumerable: true, get: function () { return dialect_1.minScalar; } });
 Object.defineProperty(exports, "anyExprType", { enumerable: true, get: function () { return dialect_1.anyExprType; } });

package/dist/lang/ast/expressions/boolean-value.d.ts

@@ -0,0 +1,24 @@
+import type { ExprValue } from '../types/expr-value';
+import type { FieldSpace } from '../types/field-space';
+import type { MalloyElement } from '../types/malloy-element';
+/**
+ * On a dialect with booleanType 'none' a boolean is a condition and never a
+ * value. When `type` is a boolean about to be used as a value, logs an error
+ * at `logTo` and returns an error-typed value for the caller to return in
+ * place of what it was building, so the enclosing expressions see an error
+ * and stay quiet. Otherwise returns undefined. `where` says how the boolean
+ * was used, `hint` what to write instead.
+ */
+export declare function booleanValueError(fs: FieldSpace, type: {
+    type: string;
+} | undefined, where: string, logTo: MalloyElement, hint: string): ExprValue | undefined;
+/** The hint where a boolean's unknown state is examined: `is null`, `??` */
+export declare const CONDITION_HINT = "test the condition itself; unknown already tests as false";
+/** The hint for a boolean compared with anything */
+export declare const COMPARE_HINT = "test the condition itself, or its not";
+/** The hint where a number would do: a function argument, a cast */
+export declare const NUMBER_HINT = "write the value, pick 1 when \u2026 else 0";
+/** The hint for a boolean as a result column, from the source text it came from */
+export declare function resultColumnHint(src: string): string;
+/** The hint for a `pick` or `case` whose result is a boolean */
+export declare const CHOICE_HINT = "write values, pick 'yes' when \u2026 else 'no', or the condition itself with and, or and not";

package/dist/lang/ast/expressions/boolean-value.js

@@ -0,0 +1,41 @@
+"use strict";
+/*
+ * Copyright Contributors to the Malloy project
+ * SPDX-License-Identifier: MIT
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CHOICE_HINT = exports.NUMBER_HINT = exports.COMPARE_HINT = exports.CONDITION_HINT = void 0;
+exports.booleanValueError = booleanValueError;
+exports.resultColumnHint = resultColumnHint;
+/**
+ * On a dialect with booleanType 'none' a boolean is a condition and never a
+ * value. When `type` is a boolean about to be used as a value, logs an error
+ * at `logTo` and returns an error-typed value for the caller to return in
+ * place of what it was building, so the enclosing expressions see an error
+ * and stay quiet. Otherwise returns undefined. `where` says how the boolean
+ * was used, `hint` what to write instead.
+ */
+function booleanValueError(fs, type, where, logTo, hint) {
+    const dialect = fs.dialectObj();
+    if ((type === null || type === void 0 ? void 0 : type.type) !== 'boolean' || (dialect === null || dialect === void 0 ? void 0 : dialect.booleanType) !== 'none') {
+        return undefined;
+    }
+    return logTo.loggedErrorExpr('boolean-value-unsupported', {
+        dialect: dialect.name,
+        where,
+        hint,
+    });
+}
+/** The hint where a boolean's unknown state is examined: `is null`, `??` */
+exports.CONDITION_HINT = 'test the condition itself; unknown already tests as false';
+/** The hint for a boolean compared with anything */
+exports.COMPARE_HINT = 'test the condition itself, or its not';
+/** The hint where a number would do: a function argument, a cast */
+exports.NUMBER_HINT = 'write the value, pick 1 when … else 0';
+/** The hint for a boolean as a result column, from the source text it came from */
+function resultColumnHint(src) {
+    return `write the value, pick 'yes' when ${src} else 'no'`;
+}
+/** The hint for a `pick` or `case` whose result is a boolean */
+exports.CHOICE_HINT = "write values, pick 'yes' when … else 'no', or the condition itself with and, or and not";
+//# sourceMappingURL=boolean-value.js.map

package/dist/lang/ast/expressions/case.js

@@ -42,6 +42,7 @@ const expr_value_1 = require("../types/expr-value");
 const expression_def_1 = require("../types/expression-def");
 const malloy_element_1 = require("../types/malloy-element");
 const TDU = __importStar(require("../typedesc-utils"));
+const boolean_value_1 = require("./boolean-value");
 function typeCoalesce(ev1, ev2) {
     return ev1 === undefined || ev1.type === 'null' || ev1.type === 'error'
         ? ev2
@@ -68,6 +69,9 @@ class Case extends expression_def_1.ExpressionDef {
         let value = undefined;
         if (this.value) {
             const v = this.value.getExpression(fs);
+            const noSubject = (0, boolean_value_1.booleanValueError)(fs, v, 'as the subject of a case', this.value, 'write the conditions, case when … then …');
+            if (noSubject)
+                return noSubject;
             dependents.push(v);
             resultExpr.kids.caseValue = v.value;
             value = v;
@@ -118,6 +122,9 @@ class Case extends expression_def_1.ExpressionDef {
             dependents.push(elseValue);
             resultExpr.kids.caseElse = elseValue.value;
         }
+        const noCase = (0, boolean_value_1.booleanValueError)(fs, returnType, 'as the result of a case', this, boolean_value_1.CHOICE_HINT);
+        if (noCase)
+            return noCase;
         return (0, expr_value_1.computedExprValue)({
             value: resultExpr,
             dataType: returnType ? TDU.atomicDef(returnType) : { type: 'null' },

package/dist/lang/ast/expressions/expr-alternation-tree.js

@@ -8,6 +8,7 @@ exports.ExprAlternationTree = void 0;
 const expr_value_1 = require("../types/expr-value");
 const expression_def_1 = require("../types/expression-def");
 const binary_operators_1 = require("../types/binary_operators");
+const boolean_value_1 = require("./boolean-value");
 /**
  * Return a flattened version of an alternation tree, if the tree is
  * composed entirely values and "or"s.
@@ -58,6 +59,16 @@ class ExprAlternationTree extends expression_def_1.ExpressionDef {
             if (inList.length > 0 && (applyOp === '=' || applyOp === '!=')) {
                 const isIn = expr.getExpression(fs);
                 const values = inList.map(v => v.getExpression(fs));
+                // A boolean on either side of the comparison, the tested value or
+                // any of the choices, is a boolean compared with something.
+                for (const [el, val] of [
+                    [expr, isIn],
+                    ...inList.map((el, i) => [el, values[i]]),
+                ]) {
+                    const noIn = (0, boolean_value_1.booleanValueError)(fs, val, `compared with ${applyOp}`, el, boolean_value_1.COMPARE_HINT);
+                    if (noIn)
+                        return noIn;
+                }
                 return (0, expr_value_1.computedExprValue)({
                     dataType: { type: 'boolean' },
                     value: {

package/dist/lang/ast/expressions/expr-cast.js

@@ -8,6 +8,7 @@ exports.ExprCast = void 0;
 const time_utils_1 = require("../time-utils");
 const expr_value_1 = require("../types/expr-value");
 const expression_def_1 = require("../types/expression-def");
+const boolean_value_1 = require("./boolean-value");
 class ExprCast extends expression_def_1.ExpressionDef {
     constructor(expr, castType, safe = false) {
         super({ expr: expr });
@@ -38,6 +39,10 @@ class ExprCast extends expression_def_1.ExpressionDef {
                 }
             }
         }
+        const noCast = (0, boolean_value_1.booleanValueError)(fs, expr, 'in a cast', this, boolean_value_1.NUMBER_HINT) ||
+            (0, boolean_value_1.booleanValueError)(fs, dataType, 'as the type of a cast', this, 'write a comparison');
+        if (noCast)
+            return noCast;
         return (0, expr_value_1.computedExprValue)({
             dataType,
             value: (0, time_utils_1.castTo)(this.castType, expr.value, expr.type, this.safe),

package/dist/lang/ast/expressions/expr-coalesce.js

@@ -42,6 +42,7 @@ const model_1 = require("../../../model");
 const composite_source_utils_1 = require("../../composite-source-utils");
 const TDU = __importStar(require("../typedesc-utils"));
 const expression_def_1 = require("../types/expression-def");
+const boolean_value_1 = require("./boolean-value");
 class ExprCoalesce extends expression_def_1.ExpressionDef {
     constructor(expr, altExpr) {
         super({ expr, altExpr });
@@ -53,6 +54,9 @@ class ExprCoalesce extends expression_def_1.ExpressionDef {
     computeExpression(fs) {
         const maybeNull = this.expr.getExpression(fs);
         const whenNull = this.altExpr.getExpression(fs);
+        const noCoalesce = (0, boolean_value_1.booleanValueError)(fs, maybeNull, 'in ??', this, boolean_value_1.CONDITION_HINT);
+        if (noCoalesce)
+            return noCoalesce;
         if (maybeNull.type === 'null') {
             return whenNull;
         }

package/dist/lang/ast/expressions/expr-func.js

@@ -48,6 +48,7 @@ const field_space_1 = require("../types/field-space");
 const utils_2 = require("../../../model/utils");
 const TDU = __importStar(require("../typedesc-utils"));
 const composite_source_utils_1 = require("../../composite-source-utils");
+const boolean_value_1 = require("./boolean-value");
 // Built-in functions that take a string literal of user-supplied SQL
 // and emit it directly. Gated by experimental.sql_functions in plain
 // Malloy; rejected unconditionally in restricted queries because they
@@ -111,9 +112,14 @@ class ExprFunc extends expression_def_1.ExpressionDef {
         return { found: func, error: undefined };
     }
     getPropsExpression(fs, props) {
-        var _a, _b, _c, _d, _e;
+        var _a, _b, _c, _d, _e, _f;
         const argExprsWithoutImplicit = this.args.map(arg => arg.getExpression(fs));
         if (this.isRaw) {
+            for (const [i, argExpr] of argExprsWithoutImplicit.entries()) {
+                const noArg = (0, boolean_value_1.booleanValueError)(fs, argExpr, `as an argument of ${this.name}`, this.args[i], boolean_value_1.NUMBER_HINT);
+                if (noArg)
+                    return noArg;
+            }
             const funcCall = [`${this.name}(`];
             argExprsWithoutImplicit.forEach((expr, i) => {
                 if (i !== 0) {
@@ -182,6 +188,11 @@ class ExprFunc extends expression_def_1.ExpressionDef {
                 .join(', ')})`);
         }
         const { overload, expressionTypeErrors, evalSpaceErrors, nullabilityErrors, returnType, } = result;
+        for (const [i, argExpr] of argExprs.entries()) {
+            const noArg = (0, boolean_value_1.booleanValueError)(fs, argExpr, `as an argument of ${this.name}`, (_e = this.args[i - (implicitExpr ? 1 : 0)]) !== null && _e !== void 0 ? _e : this, boolean_value_1.NUMBER_HINT);
+            if (noArg)
+                return noArg;
+        }
         // Report errors for expression type mismatch
         for (const error of expressionTypeErrors) {
             const adjustedIndex = error.argIndex - (implicitExpr ? 1 : 0);
@@ -214,7 +225,7 @@ class ExprFunc extends expression_def_1.ExpressionDef {
         }
         const type = overload.returnType;
         const expressionType = (0, malloy_types_1.maxOfExpressionTypes)([
-            (_e = type.expressionType) !== null && _e !== void 0 ? _e : 'scalar',
+            (_f = type.expressionType) !== null && _f !== void 0 ? _f : 'scalar',
             ...argExprs.map(e => e.expressionType),
         ]);
         if (!(0, malloy_types_1.expressionIsAggregate)(overload.returnType.expressionType) &&