@malloydata/malloy 0.0.311 → 0.0.313

package/dist/dialect/mysql/mysql.js

@@ -231,10 +231,10 @@ class MySQLDialect extends dialect_1.Dialect {
     }
     sqlSumDistinct(key, value, funcName) {
         const sqlDistinctKey = `CONCAT(${key}, '')`;
-        const upperPart = `CAST(CONV(SUBSTRING(MD5(${sqlDistinctKey}), 1, 16), 16, 10) AS DECIMAL(65, 0)) * 4294967296`;
-        const lowerPart = `CAST(CONV(SUBSTRING(MD5(${sqlDistinctKey}), 16, 8), 16, 10) AS DECIMAL(65, 0))`;
+        const upperPart = `CAST(CONV(SUBSTRING(MD5(${sqlDistinctKey}), 1, 16), 16, 10) AS DECIMAL(55, 10)) * 4294967296`;
+        const lowerPart = `CAST(CONV(SUBSTRING(MD5(${sqlDistinctKey}), 16, 8), 16, 10) AS DECIMAL(55, 10))`;
         const hashkey = `(${upperPart} + ${lowerPart})`;
-        const v = `COALESCE(${value},0)`;
+        const v = `CAST(COALESCE(${value},0) as DECIMAL(55, 10))`;
         const sqlSum = `(SUM(DISTINCT ${hashkey} + ${v}) - SUM(DISTINCT ${hashkey}))`;
         if (funcName === 'SUM') {
             return sqlSum;

package/dist/dialect/pg_impl.js

@@ -26,13 +26,18 @@ class PostgresBase extends dialect_1.Dialect {
         if (malloy_types_1.TD.isTimestamp(df.e.typeDef)) {
             const tz = (0, dialect_1.qtz)(qi);
             if (tz) {
+                // get a civil version of the time in the query time zone
                 const civilSource = `(${truncThis}::TIMESTAMPTZ AT TIME ZONE '${tz}')`;
+                // do truncation in that time space
                 let civilTrunc = `DATE_TRUNC('${df.units}', ${civilSource})`;
                 if (week) {
                     civilTrunc = `(${civilTrunc} - INTERVAL '1' DAY)`;
                 }
-                // Convert the truncated civil time back to UTC by treating it as being IN the query timezone
+                // make a tstz from the civil time ... "AT TIME ZONE" of
+                // a TIMESTAMP will produce a TIMESTAMPTZ in that zone
+                // where the civi appeareance is the same as the TIMESTAMP
                 const truncTsTz = `${civilTrunc} AT TIME ZONE '${tz}'`;
+                // Now just make a system TIMESTAMP from that
                 return `(${truncTsTz})::TIMESTAMP`;
             }
         }

package/dist/dialect/trino/trino.d.ts

@@ -1,4 +1,4 @@
-import type { Expr, Sampling, AtomicTypeDef, TimeDeltaExpr, TypecastExpr, RegexMatchExpr, MeasureTimeExpr, TimeLiteralNode, TimeExtractExpr, BasicAtomicTypeDef, RecordLiteralNode } from '../../model/malloy_types';
+import type { Expr, Sampling, AtomicTypeDef, TimeDeltaExpr, TypecastExpr, RegexMatchExpr, MeasureTimeExpr, TimeLiteralNode, TimeExtractExpr, TimeTruncExpr, BasicAtomicTypeDef, RecordLiteralNode } from '../../model/malloy_types';
 import type { DialectFunctionOverloadDef } from '../functions';
 import type { DialectFieldList, OrderByClauseType, QueryInfo } from '../dialect';
 import { PostgresBase } from '../pg_impl';
@@ -72,6 +72,7 @@ export declare class TrinoDialect extends PostgresBase {
     sqlStringAggDistinct(distinctKey: string, valueSQL: string, separatorSQL: string): string;
     validateTypeName(sqlType: string): boolean;
     sqlLiteralTime(qi: QueryInfo, lit: TimeLiteralNode): string;
+    sqlTruncExpr(qi: QueryInfo, df: TimeTruncExpr): string;
     sqlTimeExtractExpr(qi: QueryInfo, from: TimeExtractExpr): string;
     sqlLiteralRecord(lit: RecordLiteralNode): string;
 }

package/dist/dialect/trino/trino.js

@@ -498,6 +498,36 @@ ${(0, utils_1.indent)(sql)}
         }
         return `TIMESTAMP '${lit.literal}'`;
     }
+    sqlTruncExpr(qi, df) {
+        // adjusting for monday/sunday weeks
+        const week = df.units === 'week';
+        const truncThis = week ? `${df.e.sql} + INTERVAL '1' DAY` : df.e.sql;
+        // Only do timezone conversion for timestamps, not dates
+        if (malloy_types_1.TD.isTimestamp(df.e.typeDef)) {
+            const tz = qtz(qi);
+            if (tz) {
+                // get a civil version of the time in the query time zone
+                const civilSource = `(CAST(${truncThis} AS TIMESTAMP WITH TIME ZONE) AT TIME ZONE '${tz}')`;
+                // do truncation in that time space
+                let civilTrunc = `DATE_TRUNC('${df.units}', ${civilSource})`;
+                if (week) {
+                    civilTrunc = `(${civilTrunc} - INTERVAL '1' DAY)`;
+                }
+                // make a tstz from the civil time ... "AT TIME ZONE" of
+                // a TIMESTAMP will produce a TIMESTAMP WITH TIME ZONE in that zone
+                // where the civil appearance is the same as the TIMESTAMP
+                const truncTsTz = `${civilTrunc} AT TIME ZONE '${tz}'`;
+                // Now just make a system TIMESTAMP from that
+                return `CAST(${truncTsTz} AS TIMESTAMP)`;
+            }
+        }
+        // For dates (civil time) or timestamps without query timezone
+        let result = `DATE_TRUNC('${df.units}', ${truncThis})`;
+        if (week) {
+            result = `(${result} - INTERVAL '1' DAY)`;
+        }
+        return result;
+    }
     sqlTimeExtractExpr(qi, from) {
         const pgUnits = pg_impl_1.timeExtractMap[from.units] || from.units;
         let extractFrom = from.e.sql || '';

package/dist/malloy.d.ts

@@ -757,6 +757,7 @@ export declare class ExploreField extends Explore {
     isAtomicField(): this is AtomicField;
     get parentExplore(): Explore;
     get sourceClasses(): string[];
+    get queryTimezone(): string | undefined;
 }
 type Connectionable = {
     connection: Connection;

package/dist/malloy.js

@@ -1715,6 +1715,14 @@ class ExploreField extends Explore {
         const sourceField = this.structDef.name || this.structDef.as;
         return sourceField ? [sourceField] : [];
     }
+    get queryTimezone() {
+        // For ExploreField, check the structDef directly first
+        if ((0, model_1.isRecordOrRepeatedRecord)(this._structDef)) {
+            return this._structDef.queryTimezone;
+        }
+        // Fall back to the parent implementation
+        return super.queryTimezone;
+    }
 }
 exports.ExploreField = ExploreField;
 /**

package/dist/model/expression_compiler.js

@@ -212,14 +212,14 @@ function exprToSQL(resultSet, context, exprToTranslate, state = new utils_1.Gene
         case 'compositeField':
             return '{COMPOSITE_FIELD}';
         case 'filterMatch':
-            return generateAppliedFilter(context, expr);
+            return generateAppliedFilter(context, expr, qi);
         case 'filterLiteral':
             return 'INTERNAL ERROR FILTER EXPRESSION VALUE SHOULD NOT BE USED';
         default:
             throw new Error(`Internal Error: Unknown expression node '${expr.node}' ${JSON.stringify(expr, undefined, 2)}`);
     }
 }
-function generateAppliedFilter(context, filterMatchExpr) {
+function generateAppliedFilter(context, filterMatchExpr, qi) {
     var _a;
     let filterExpr = filterMatchExpr.kids.filterExpr;
     while (filterExpr.node === '()') {
@@ -261,7 +261,7 @@ function generateAppliedFilter(context, filterMatchExpr) {
     if (fParse.log.length > 0) {
         throw new Error(`Filter expression parse error: ${fParse.log[0]}`);
     }
-    return filter_compilers_1.FilterCompilers.compile(filterMatchExpr.dataType, fParse.parsed, filterMatchExpr.kids.expr.sql || '', context.dialect);
+    return filter_compilers_1.FilterCompilers.compile(filterMatchExpr.dataType, fParse.parsed, filterMatchExpr.kids.expr.sql || '', context.dialect, qi);
 }
 // Helper functions for generateFunctionCallExpression
 function getParameterMap(overload, numArgs) {

package/dist/model/field_instance.d.ts

@@ -55,6 +55,9 @@ export declare class FieldInstanceResult implements FieldInstance {
      * Information about the query containing this result set. Invented
      * to pass on timezone information, but maybe more things will
      * eventually go in here.
+     *
+     * For nested queries, this walks up the FieldInstanceResult parent chain
+     * to find the most specific (innermost) query timezone that applies.
      * @returns QueryInfo
      */
     getQueryInfo(): QueryInfo;

package/dist/model/field_instance.js

@@ -117,6 +117,9 @@ class FieldInstanceResult {
      * Information about the query containing this result set. Invented
      * to pass on timezone information, but maybe more things will
      * eventually go in here.
+     *
+     * For nested queries, this walks up the FieldInstanceResult parent chain
+     * to find the most specific (innermost) query timezone that applies.
      * @returns QueryInfo
      */
     getQueryInfo() {
@@ -127,6 +130,9 @@ class FieldInstanceResult {
                 return { queryTimezone };
             }
         }
+        if (this.parent) {
+            return this.parent.getQueryInfo();
+        }
         return {};
     }
     addField(as, field, usage, drillExpression) {

package/dist/model/filter_compilers.d.ts

@@ -1,11 +1,11 @@
 import type { BooleanFilter, FilterExpression, NumberFilter, StringFilter, TemporalFilter } from '@malloydata/malloy-filter';
-import type { Dialect } from '../dialect';
+import type { Dialect, QueryInfo } from '../dialect';
 export declare const FilterCompilers: {
-    compile(t: string, c: FilterExpression | null, x: string, d: Dialect): string;
+    compile(t: string, c: FilterExpression | null, x: string, d: Dialect, qi?: QueryInfo): string;
     numberCompile(nc: NumberFilter, x: string, d: Dialect): string;
     booleanCompile(bc: BooleanFilter, x: string, _d: Dialect): string;
     stringCompile(sc: StringFilter, x: string, d: Dialect): string;
-    temporalCompile(tc: TemporalFilter, x: string, d: Dialect, t: "date" | "timestamp"): string;
+    temporalCompile(tc: TemporalFilter, x: string, d: Dialect, t: "date" | "timestamp", qi?: QueryInfo): string;
 };
 /**
  * I felt like there was enough "helpful functions needed to make everything
@@ -17,7 +17,8 @@ export declare class TemporalFilterCompiler {
     readonly expr: string;
     readonly timetype: 'timestamp' | 'date';
     readonly d: Dialect;
-    constructor(expr: string, dialect: Dialect, timetype?: 'timestamp' | 'date');
+    readonly qi: QueryInfo;
+    constructor(expr: string, dialect: Dialect, timetype?: 'timestamp' | 'date', queryInfo?: QueryInfo);
     time(timeSQL: string): string;
     compile(tc: TemporalFilter): string;
     private expandLiteral;

package/dist/model/filter_compilers.js

@@ -37,7 +37,7 @@ function unlike(disLiked, x) {
  * XXXXFilterCompiler.compile() will move to XXXFilterExpression.compile()
  */
 exports.FilterCompilers = {
-    compile(t, c, x, d) {
+    compile(t, c, x, d, qi = {}) {
         if (c === null) {
             return 'true';
         }
@@ -51,7 +51,7 @@ exports.FilterCompilers = {
             return exports.FilterCompilers.booleanCompile(c, x, d);
         }
         else if ((t === 'date' || t === 'timestamp') && (0, malloy_filter_1.isTemporalFilter)(c)) {
-            return exports.FilterCompilers.temporalCompile(c, x, d, t);
+            return exports.FilterCompilers.temporalCompile(c, x, d, t, qi);
         }
         throw new Error('INTERNAL ERROR: No filter compiler for ' + t);
     },
@@ -251,8 +251,8 @@ exports.FilterCompilers = {
         }
     },
     // mtoy todo figure out what to do about dates
-    temporalCompile(tc, x, d, t) {
-        const c = new TemporalFilterCompiler(x, d, t);
+    temporalCompile(tc, x, d, t, qi = {}) {
+        const c = new TemporalFilterCompiler(x, d, t, qi);
         return c.compile(tc);
     },
 };
@@ -269,10 +269,11 @@ const fTimestamp = `${fMinute}:ss`;
  * a dialect as an argument?
  */
 class TemporalFilterCompiler {
-    constructor(expr, dialect, timetype = 'timestamp') {
+    constructor(expr, dialect, timetype = 'timestamp', queryInfo = {}) {
         this.expr = expr;
         this.timetype = timetype;
         this.d = dialect;
+        this.qi = queryInfo;
     }
     time(timeSQL) {
         if (this.timetype === 'timestamp') {
@@ -430,7 +431,10 @@ class TemporalFilterCompiler {
             typeDef: { type: 'timestamp' },
             literal,
         };
-        return { ...literalNode, sql: this.d.sqlLiteralTime({}, literalNode) };
+        if (this.qi.queryTimezone) {
+            literalNode.timezone = this.qi.queryTimezone;
+        }
+        return { ...literalNode, sql: this.d.sqlLiteralTime(this.qi, literalNode) };
     }
     nowExpr() {
         return {
@@ -460,7 +464,7 @@ class TemporalFilterCompiler {
             e: (0, malloy_types_1.mkTemporal)(e, 'timestamp'),
             units: 'day_of_week',
         };
-        return { ...t, sql: this.d.sqlTimeExtractExpr({}, t) };
+        return { ...t, sql: this.d.sqlTimeExtractExpr(this.qi, t) };
     }
     nowDot(units) {
         const nowTruncExpr = {
@@ -468,7 +472,7 @@ class TemporalFilterCompiler {
             e: this.nowExpr(),
             units,
         };
-        return { ...nowTruncExpr, sql: this.d.sqlTruncExpr({}, nowTruncExpr) };
+        return { ...nowTruncExpr, sql: this.d.sqlTruncExpr(this.qi, nowTruncExpr) };
     }
     thisUnit(units) {
         const thisUnit = this.nowDot(units);
@@ -562,17 +566,24 @@ class TemporalFilterCompiler {
         const destDayZeroBased = destDay - 1;
         // dow is 1-7, convert to 0-6 for the arithmetic
         const dowZeroBased = `(${dow.sql}-1)`;
-        let daysOffset;
+        let beginOffset;
+        let endOffset;
+        // "dayname" and "last dayname" both refer to the most recent,
+        // already complete day of that name. So if today is Sunday,
+        // "next sunday" is "today", and "last sunday" is 7 days ago.
         if (direction === 'next') {
-            // Days forward: ((destDay - dow + 6) % 7) + 1
-            daysOffset = `${this.mod7(`${destDayZeroBased}-${dowZeroBased}+6`)}+1`;
+            // Days forward: ((destDay - currentDay + 6) % 7) + 1
+            beginOffset = `${this.mod7(`${destDayZeroBased}-${dowZeroBased}+6`)}+1`;
+            endOffset = `${this.mod7(`${destDayZeroBased}-${dowZeroBased}+6`)}+2`;
         }
         else {
-            // Days back: ((dow - destDay + 6) % 7) + 1
-            daysOffset = `${this.mod7(`${dowZeroBased}-${destDayZeroBased}+6`)}+1`;
+            // Days back: ((currentDay - destDay + 6) % 7) + 1
+            beginOffset = `${this.mod7(`${dowZeroBased}-${destDayZeroBased}+6`)}+1`;
+            // End offset is one day less (closer to today)
+            endOffset = `${this.mod7(`${dowZeroBased}-${destDayZeroBased}+6`)}`;
         }
-        const begin = this.delta(todayBegin, direction === 'next' ? '+' : '-', daysOffset, 'day');
-        const end = this.delta(begin, '+', '1', 'day');
+        const begin = this.delta(todayBegin, direction === 'next' ? '+' : '-', beginOffset, 'day');
+        const end = this.delta(todayBegin, direction === 'next' ? '+' : '-', endOffset, 'day');
         return { begin, end: end.sql };
     }
 }

package/dist/model/malloy_types.d.ts

@@ -441,6 +441,7 @@ export interface RecordTypeDef {
 export interface RecordDef extends RecordTypeDef, StructDefBase, JoinBase, FieldBase {
     type: 'record';
     join: 'one';
+    queryTimezone?: string;
 }
 export interface RecordElementTypeDef {
     type: 'record_element';
@@ -453,11 +454,13 @@ export interface RepeatedRecordTypeDef {
 export interface RepeatedRecordDef extends RepeatedRecordTypeDef, StructDefBase, JoinBase, FieldBase {
     type: 'array';
     join: 'many';
+    queryTimezone?: string;
 }
 export type ArrayTypeDef = BasicArrayTypeDef | RepeatedRecordTypeDef;
 export type ArrayDef = BasicArrayDef | RepeatedRecordDef;
 export declare function isRepeatedRecordFunctionParam(paramT: FunctionParameterTypeDef): paramT is RepeatedRecordFunctionParameterTypeDef;
 export declare function isRepeatedRecord(fd: FieldDef | QueryFieldDef | StructDef | AtomicTypeDef): fd is RepeatedRecordTypeDef;
+export declare function isRecordOrRepeatedRecord(fd: FieldDef | StructDef): fd is RecordDef | RepeatedRecordDef;
 export declare function isBasicArray(td: AtomicTypeDef | FieldDef | QueryFieldDef | StructDef): td is BasicArrayTypeDef;
 export interface ErrorTypeDef {
     type: 'error';

package/dist/model/malloy_types.js

@@ -52,6 +52,7 @@ exports.mkFieldDef = mkFieldDef;
 exports.mkArrayDef = mkArrayDef;
 exports.isRepeatedRecordFunctionParam = isRepeatedRecordFunctionParam;
 exports.isRepeatedRecord = isRepeatedRecord;
+exports.isRecordOrRepeatedRecord = isRecordOrRepeatedRecord;
 exports.isBasicArray = isBasicArray;
 exports.isMatrixOperation = isMatrixOperation;
 exports.isJoinable = isJoinable;
@@ -303,6 +304,12 @@ function isRepeatedRecordFunctionParam(paramT) {
 function isRepeatedRecord(fd) {
     return fd.type === 'array' && fd.elementTypeDef.type === 'record_element';
 }
+function isRecordOrRepeatedRecord(fd) {
+    return (fd.type === 'record' ||
+        (fd.type === 'array' &&
+            'elementTypeDef' in fd &&
+            fd.elementTypeDef.type === 'record_element'));
+}
 function isBasicArray(td) {
     return td.type === 'array' && td.elementTypeDef.type !== 'record_element';
 }

package/dist/model/query_query.js

@@ -388,24 +388,37 @@ class QueryQuery extends query_node_1.QueryField {
             const resultMetadata = this.getResultMetadata(fi);
             if (fi instanceof field_instance_1.FieldInstanceResult) {
                 const { structDef, repeatedResultType } = this.generateTurtlePipelineSQL(fi, new stage_writer_1.StageWriter(true, undefined), '<nosource>');
+                // Get the timezone from the nested query
+                const nestedQueryInfo = fi.getQueryInfo();
+                const queryTimezone = nestedQueryInfo.queryTimezone;
                 if (repeatedResultType === 'nested') {
                     const multiLineNest = {
-                        ...structDef,
                         type: 'array',
                         elementTypeDef: { type: 'record_element' },
                         join: 'many',
                         name,
+                        fields: structDef.fields,
+                        ...(structDef.annotation && { annotation: structDef.annotation }),
+                        ...(structDef.modelAnnotation && {
+                            modelAnnotation: structDef.modelAnnotation,
+                        }),
                         resultMetadata,
+                        ...(queryTimezone && { queryTimezone }),
                     };
                     fields.push(multiLineNest);
                 }
                 else {
                     const oneLineNest = {
-                        ...structDef,
                         type: 'record',
                         join: 'one',
                         name,
+                        fields: structDef.fields,
+                        ...(structDef.annotation && { annotation: structDef.annotation }),
+                        ...(structDef.modelAnnotation && {
+                            modelAnnotation: structDef.modelAnnotation,
+                        }),
                         resultMetadata,
+                        ...(queryTimezone && { queryTimezone }),
                     };
                     fields.push(oneLineNest);
                 }

package/dist/to_stable.js

@@ -213,9 +213,17 @@ function convertFieldInfos(source, fields) {
             const resultMetadataAnnotation = field.resultMetadata
                 ? getResultMetadataAnnotation(field, field.resultMetadata)
                 : undefined;
+            // Check if this field has queryTimezone information (for RecordDef/RepeatedRecordDef)
+            let timezoneAnnotation;
+            if ((0, model_1.isRecordOrRepeatedRecord)(field) && field.queryTimezone) {
+                const timezoneTag = malloy_tag_1.Tag.withPrefix('#(malloy) ');
+                timezoneTag.set(['query_timezone'], field.queryTimezone);
+                timezoneAnnotation = { value: timezoneTag.toString() };
+            }
             const fieldAnnotations = [
                 ...(annotations !== null && annotations !== void 0 ? annotations : []),
                 ...(resultMetadataAnnotation ? [resultMetadataAnnotation] : []),
+                ...(timezoneAnnotation ? [timezoneAnnotation] : []),
             ];
             const fieldInfo = {
                 kind: aggregate ? 'measure' : 'dimension',
@@ -343,6 +351,11 @@ function getResultStructMetadataAnnotation(field, resultMetadata) {
         }
         hasAny = true;
     }
+    // Include queryTimezone if present on the field
+    if (field.queryTimezone) {
+        tag.set(['query_timezone'], field.queryTimezone);
+        hasAny = true;
+    }
     return hasAny
         ? {
             value: tag.toString(),

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const MALLOY_VERSION = "0.0.311";
+export declare const MALLOY_VERSION = "0.0.313";

package/dist/version.js

@@ -2,5 +2,5 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MALLOY_VERSION = void 0;
 // generated with 'generate-version-file' script; do not edit manually
-exports.MALLOY_VERSION = '0.0.311';
+exports.MALLOY_VERSION = '0.0.313';
 //# sourceMappingURL=version.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@malloydata/malloy",
-  "version": "0.0.311",
+  "version": "0.0.313",
   "license": "MIT",
   "exports": {
     ".": "./dist/index.js",
@@ -41,9 +41,9 @@
     "generate-version-file": "VERSION=$(npm pkg get version --workspaces=false | tr -d \\\")\necho \"// generated with 'generate-version-file' script; do not edit manually\\nexport const MALLOY_VERSION = '$VERSION';\" > src/version.ts"
   },
   "dependencies": {
-    "@malloydata/malloy-filter": "0.0.311",
-    "@malloydata/malloy-interfaces": "0.0.311",
-    "@malloydata/malloy-tag": "0.0.311",
+    "@malloydata/malloy-filter": "0.0.313",
+    "@malloydata/malloy-interfaces": "0.0.313",
+    "@malloydata/malloy-tag": "0.0.313",
     "antlr4ts": "^0.5.0-alpha.4",
     "assert": "^2.0.0",
     "jaro-winkler": "^0.2.8",