@malloydata/malloy 0.0.311 → 0.0.312

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/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/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.312";

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.312';
 //# sourceMappingURL=version.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@malloydata/malloy",
-  "version": "0.0.311",
+  "version": "0.0.312",
   "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.312",
+    "@malloydata/malloy-interfaces": "0.0.312",
+    "@malloydata/malloy-tag": "0.0.312",
     "antlr4ts": "^0.5.0-alpha.4",
     "assert": "^2.0.0",
     "jaro-winkler": "^0.2.8",