@malloydata/malloy 0.0.253-dev250330190957 → 0.0.253-dev250401001016

package/dist/dialect/dialect.d.ts

@@ -1,18 +1,11 @@
-import type { Expr, Sampling, AtomicTypeDef, MeasureTimeExpr, TimeTruncExpr, TimeExtractExpr, TimeDeltaExpr, TypecastExpr, RegexMatchExpr, TimeLiteralNode, RecordLiteralNode, ArrayLiteralNode, LeafAtomicTypeDef, OrderBy } from '../model/malloy_types';
+import type { Expr, Sampling, AtomicTypeDef, MeasureTimeExpr, TimeTruncExpr, TimeExtractExpr, TimeDeltaExpr, TypecastExpr, RegexMatchExpr, TimeLiteralNode, RecordLiteralNode, ArrayLiteralNode, BasicAtomicTypeDef, OrderBy } from '../model/malloy_types';
 import type { DialectFunctionOverloadDef } from './functions';
-type DialectFieldTypes = string | 'struct';
 interface DialectField {
-    type: DialectFieldTypes;
+    typeDef: AtomicTypeDef;
     sqlExpression: string;
     rawName: string;
     sqlOutputName: string;
 }
-export interface DialectFieldTypeStruct extends DialectField {
-    type: 'struct';
-    nestedStruct: DialectFieldList;
-    isArray: boolean;
-}
-export declare function isDialectFieldStruct(d: DialectField): d is DialectFieldTypeStruct;
 export type DialectFieldList = DialectField[];
 /**
  * Data which dialect methods need in order to correctly generate SQL.
@@ -131,7 +124,7 @@ export declare abstract class Dialect {
     sqlTzStr(qi: QueryInfo): string;
     sqlMakeUnnestKey(key: string, rowKey: string): string;
     sqlStringAggDistinct(distinctKey: string, valueSQL: string, separatorSQL: string): string;
-    abstract sqlTypeToMalloyType(sqlType: string): LeafAtomicTypeDef;
+    abstract sqlTypeToMalloyType(sqlType: string): BasicAtomicTypeDef;
     abstract malloyTypeToSQLType(malloyType: AtomicTypeDef): string;
     abstract validateTypeName(sqlType: string): boolean;
     /**
@@ -141,8 +134,8 @@ export declare abstract class Dialect {
      */
     sqlCastPrep(cast: TypecastExpr): {
         op: string;
-        srcTypeDef: LeafAtomicTypeDef | undefined;
-        dstTypeDef: LeafAtomicTypeDef | undefined;
+        srcTypeDef: BasicAtomicTypeDef | undefined;
+        dstTypeDef: BasicAtomicTypeDef | undefined;
         dstSQLType: string;
     };
     /**

package/dist/dialect/dialect.js

@@ -22,12 +22,8 @@
  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Dialect = exports.qtz = exports.inDays = exports.dayIndex = exports.isDialectFieldStruct = void 0;
+exports.Dialect = exports.qtz = exports.inDays = exports.dayIndex = void 0;
 const malloy_types_1 = require("../model/malloy_types");
-function isDialectFieldStruct(d) {
-    return d.type === 'struct';
-}
-exports.isDialectFieldStruct = isDialectFieldStruct;
 const allUnits = [
     'microsecond',
     'millisecond',
@@ -212,7 +208,7 @@ class Dialect {
     sqlCastPrep(cast) {
         let srcTypeDef = cast.srcType || cast.e.typeDef;
         const src = (srcTypeDef === null || srcTypeDef === void 0 ? void 0 : srcTypeDef.type) || 'unknown';
-        if (srcTypeDef && !(0, malloy_types_1.isLeafAtomic)(srcTypeDef)) {
+        if (srcTypeDef && !(0, malloy_types_1.isBasicAtomic)(srcTypeDef)) {
             srcTypeDef = undefined;
         }
         if ((0, malloy_types_1.isRawCast)(cast)) {

package/dist/dialect/duckdb/duckdb.d.ts

@@ -1,4 +1,4 @@
-import type { Sampling, AtomicTypeDef, TimeDeltaExpr, RegexMatchExpr, MeasureTimeExpr, LeafAtomicTypeDef, RecordLiteralNode, OrderBy } from '../../model/malloy_types';
+import type { Sampling, AtomicTypeDef, TimeDeltaExpr, RegexMatchExpr, MeasureTimeExpr, BasicAtomicTypeDef, RecordLiteralNode, OrderBy } from '../../model/malloy_types';
 import type { DialectFunctionOverloadDef } from '../functions';
 import type { DialectFieldList, FieldReferenceType } from '../dialect';
 import { PostgresBase } from '../pg_impl';
@@ -56,7 +56,7 @@ export declare class DuckDBDialect extends PostgresBase {
     };
     malloyTypeToSQLType(malloyType: AtomicTypeDef): string;
     parseDuckDBType(sqlType: string): AtomicTypeDef;
-    sqlTypeToMalloyType(sqlType: string): LeafAtomicTypeDef;
+    sqlTypeToMalloyType(sqlType: string): BasicAtomicTypeDef;
     castToString(expression: string): string;
     concat(...values: string[]): string;
     validateTypeName(sqlType: string): boolean;

package/dist/dialect/duckdb/duckdb.js

@@ -108,9 +108,9 @@ class DuckDBDialect extends pg_impl_1.PostgresBase {
     }
     sqlAnyValueTurtle(groupSet, fieldList) {
         const fields = fieldList
-            .map(f => `${f.sqlExpression} as ${f.sqlOutputName}`)
+            .map(f => `${f.sqlOutputName}:=${f.sqlExpression}`)
             .join(', ');
-        return `ANY_VALUE(CASE WHEN group_set=${groupSet} THEN STRUCT_PACK(${fields}))`;
+        return `ANY_VALUE(CASE WHEN group_set=${groupSet} THEN STRUCT_PACK(${fields}) END)`;
     }
     sqlAnyValueLastTurtle(name, groupSet, sqlName) {
         return `MAX(CASE WHEN group_set=${groupSet} THEN ${name} END) as ${sqlName}`;

package/dist/dialect/functions/util.d.ts

@@ -1,4 +1,4 @@
-import type { FunctionParameterDef, TypeDesc, Expr, FunctionParamTypeDesc, LeafExpressionType, FunctionReturnTypeDesc, FunctionParameterTypeDef, ExpressionType, EvalSpace, FunctionGenericTypeDef } from '../../model/malloy_types';
+import type { FunctionParameterDef, TypeDesc, Expr, FunctionParamTypeDesc, BasicExpressionType, FunctionReturnTypeDesc, FunctionParameterTypeDef, ExpressionType, EvalSpace, FunctionGenericTypeDef } from '../../model/malloy_types';
 import type { SQLExprElement } from '../../model/utils';
 export interface DialectFunctionOverloadDef {
     returnType: FunctionReturnTypeDesc;
@@ -72,7 +72,7 @@ export interface RecordBlueprint {
 export interface SQLNativeTypeBlueprint {
     sql_native: string;
 }
-export type LeafPlusType = LeafExpressionType | 'any';
+export type LeafPlusType = BasicExpressionType | 'any';
 export type TypeDescElementBlueprint = LeafPlusType | ArrayBlueprint | RecordBlueprint | SQLNativeTypeBlueprint;
 export type NamedGeneric = {
     generic: string;

package/dist/dialect/mysql/mysql.d.ts

@@ -1,4 +1,4 @@
-import type { Sampling, MeasureTimeExpr, TimeLiteralNode, RegexMatchExpr, TimeDeltaExpr, TimeTruncExpr, TimeExtractExpr, TypecastExpr, LeafAtomicTypeDef, AtomicTypeDef, ArrayLiteralNode, RecordLiteralNode } from '../../model/malloy_types';
+import type { Sampling, MeasureTimeExpr, TimeLiteralNode, RegexMatchExpr, TimeDeltaExpr, TimeTruncExpr, TimeExtractExpr, TypecastExpr, BasicAtomicTypeDef, AtomicTypeDef, ArrayLiteralNode, RecordLiteralNode } from '../../model/malloy_types';
 import type { DialectFieldList, FieldReferenceType, OrderByClauseType, QueryInfo } from '../dialect';
 import { Dialect } from '../dialect';
 import type { DialectFunctionOverloadDef } from '../functions';
@@ -32,7 +32,7 @@ export declare class MySQLDialect extends Dialect {
     booleanAsNumbers: boolean;
     orderByClause: OrderByClauseType;
     malloyTypeToSQLType(malloyType: AtomicTypeDef): string;
-    sqlTypeToMalloyType(sqlType: string): LeafAtomicTypeDef;
+    sqlTypeToMalloyType(sqlType: string): BasicAtomicTypeDef;
     quoteTablePath(tablePath: string): string;
     sqlGroupSetTable(groupSetCount: number): string;
     sqlAnyValue(_groupSet: number, fieldName: string): string;

package/dist/dialect/mysql/mysql.js

@@ -101,7 +101,10 @@ class MySQLDialect extends dialect_1.Dialect {
             case 'number':
                 return malloyType.numberType === 'integer' ? 'BIGINT' : 'DOUBLE';
             case 'string':
-                return 'CHAR';
+                return 'TEXT';
+            case 'record':
+            case 'array':
+                return 'JSON';
             case 'date':
             case 'timestamp':
             default:
@@ -175,9 +178,16 @@ class MySQLDialect extends dialect_1.Dialect {
             return t;
     }
     unnestColumns(fieldList) {
+        var _a;
         const fields = [];
         for (const f of fieldList) {
-            fields.push(`${this.sqlMaybeQuoteIdentifier(f.sqlOutputName)} ${this.malloyToSQL(f.type)} PATH "$.${f.rawName}"`);
+            let fType = this.malloyTypeToSQLType(f.typeDef);
+            if (f.typeDef.type === 'sql native' &&
+                f.typeDef.rawType &&
+                ((_a = f.typeDef.rawType) === null || _a === void 0 ? void 0 : _a.match(/json/))) {
+                fType = f.typeDef.rawType.toUpperCase();
+            }
+            fields.push(`${this.sqlMaybeQuoteIdentifier(f.sqlOutputName)} ${fType}  PATH "$.${f.rawName}"`);
         }
         return fields.join(',\n');
     }

package/dist/dialect/postgres/postgres.d.ts

@@ -1,4 +1,4 @@
-import type { Sampling, AtomicTypeDef, TimeDeltaExpr, TypecastExpr, MeasureTimeExpr, LeafAtomicTypeDef, RecordLiteralNode, ArrayLiteralNode } from '../../model/malloy_types';
+import type { Sampling, AtomicTypeDef, TimeDeltaExpr, TypecastExpr, MeasureTimeExpr, BasicAtomicTypeDef, RecordLiteralNode, ArrayLiteralNode } from '../../model/malloy_types';
 import type { DialectFunctionOverloadDef } from '../functions';
 import type { DialectFieldList, FieldReferenceType, QueryInfo } from '../dialect';
 import { PostgresBase } from '../pg_impl';
@@ -60,7 +60,7 @@ export declare class PostgresDialect extends PostgresBase {
         [name: string]: DialectFunctionOverloadDef[];
     };
     malloyTypeToSQLType(malloyType: AtomicTypeDef): string;
-    sqlTypeToMalloyType(sqlType: string): LeafAtomicTypeDef;
+    sqlTypeToMalloyType(sqlType: string): BasicAtomicTypeDef;
     castToString(expression: string): string;
     concat(...values: string[]): string;
     validateTypeName(sqlType: string): boolean;

package/dist/dialect/postgres/postgres.js

@@ -110,9 +110,7 @@ class PostgresDialect extends pg_impl_1.PostgresBase {
     }
     mapFields(fieldList) {
         return fieldList
-            .map(f => `\n  ${f.sqlExpression}${f.type === 'number' ? `::${this.defaultNumberType}` : ''} as ${f.sqlOutputName}`
-        //`${f.sqlExpression} ${f.type} as ${f.sqlOutputName}`
-        )
+            .map(f => `\n  ${f.sqlExpression}${f.typeDef.type === 'number' ? `::${this.defaultNumberType}` : ''} as ${f.sqlOutputName}`)
             .join(', ');
     }
     sqlAggregateTurtle(groupSet, fieldList, orderBy, limit) {
@@ -121,7 +119,6 @@ class PostgresDialect extends pg_impl_1.PostgresBase {
             tail += `[1:${limit}]`;
         }
         const fields = this.mapFields(fieldList);
-        // return `(ARRAY_AGG((SELECT __x FROM (SELECT ${fields}) as __x) ${orderBy} ) FILTER (WHERE group_set=${groupSet}))${tail}`;
         return `COALESCE(TO_JSONB((ARRAY_AGG((SELECT TO_JSONB(__x) FROM (SELECT ${fields}\n  ) as __x) ${orderBy} ) FILTER (WHERE group_set=${groupSet}))${tail}),'[]'::JSONB)`;
     }
     sqlAnyValueTurtle(groupSet, fieldList) {
@@ -137,39 +134,6 @@ class PostgresDialect extends pg_impl_1.PostgresBase {
         const fields = this.mapFields(fieldList);
         return `TO_JSONB((ARRAY_AGG((SELECT __x FROM (SELECT ${fields}) as __x)) FILTER (WHERE group_set=${groupSet}))[1])`;
     }
-    // UNNEST((select ARRAY((SELECT ROW(gen_random_uuid()::text, state, airport_count) FROM UNNEST(base.by_state) as by_state(state text, airport_count numeric, by_fac_type record[]))))) as by_state(__distinct_key text, state text, airport_count numeric)
-    // sqlUnnestAlias(
-    //   source: string,
-    //   alias: string,
-    //   fieldList: DialectFieldList,
-    //   needDistinctKey: boolean
-    // ): string {
-    //   const fields = [];
-    //   for (const f of fieldList) {
-    //     let t = undefined;
-    //     switch (f.type) {
-    //       case "string":
-    //         t = "text";
-    //         break;
-    //       case "number":
-    //         t = this.defaultNumberType;
-    //         break;
-    //       case "struct":
-    //         t = "record[]";
-    //         break;
-    //     }
-    //     fields.push(`${f.sqlOutputName} ${t || f.type}`);
-    //   }
-    //   if (needDistinctKey) {
-    //     return `UNNEST((select ARRAY((SELECT ROW(gen_random_uuid()::text, ${fieldList
-    //       .map((f) => f.sqlOutputName)
-    //       .join(", ")}) FROM UNNEST(${source}) as ${alias}(${fields.join(
-    //       ", "
-    //     )}))))) as ${alias}(__distinct_key text, ${fields.join(", ")})`;
-    //   } else {
-    //     return `UNNEST(${source}) as ${alias}(${fields.join(", ")})`;
-    //   }
-    // }
     sqlUnnestAlias(source, alias, fieldList, needDistinctKey, isArray, _isInNestedPipeline) {
         if (isArray) {
             if (needDistinctKey) {
@@ -210,6 +174,7 @@ class PostgresDialect extends pg_impl_1.PostgresBase {
                 case 'array':
                 case 'record':
                 case 'array[record]':
+                case 'sql native':
                     ret = `JSONB_EXTRACT_PATH(${parentAlias},'${childName}')`;
                     break;
             }

package/dist/dialect/snowflake/snowflake.d.ts

@@ -1,4 +1,4 @@
-import type { Sampling, AtomicTypeDef, TimeTruncExpr, TimeExtractExpr, TimeDeltaExpr, TypecastExpr, TimeLiteralNode, MeasureTimeExpr, RegexMatchExpr, LeafAtomicTypeDef, ArrayLiteralNode, RecordLiteralNode } from '../../model/malloy_types';
+import type { Sampling, AtomicTypeDef, TimeTruncExpr, TimeExtractExpr, TimeDeltaExpr, TypecastExpr, TimeLiteralNode, MeasureTimeExpr, RegexMatchExpr, BasicAtomicTypeDef, ArrayLiteralNode, RecordLiteralNode } from '../../model/malloy_types';
 import type { DialectFunctionOverloadDef } from '../functions';
 import type { DialectFieldList, FieldReferenceType, QueryInfo } from '../dialect';
 import { Dialect } from '../dialect';
@@ -65,7 +65,7 @@ export declare class SnowflakeDialect extends Dialect {
         [name: string]: DialectFunctionOverloadDef[];
     };
     malloyTypeToSQLType(malloyType: AtomicTypeDef): string;
-    sqlTypeToMalloyType(sqlType: string): LeafAtomicTypeDef;
+    sqlTypeToMalloyType(sqlType: string): BasicAtomicTypeDef;
     castToString(expression: string): string;
     concat(...values: string[]): string;
     validateTypeName(sqlType: string): boolean;

package/dist/dialect/snowflake/snowflake.js

@@ -412,7 +412,7 @@ ${(0, utils_1.indent)(sql)}
                 ? recordScehma
                 : `ARRAY(${recordScehma})`;
         }
-        else if ((0, malloy_types_1.isScalarArray)(malloyType)) {
+        else if ((0, malloy_types_1.isBasicArray)(malloyType)) {
             return `ARRAY(${this.malloyTypeToSQLType(malloyType.elementTypeDef)})`;
         }
         return malloyType.type;

package/dist/dialect/standardsql/standardsql.d.ts

@@ -1,4 +1,4 @@
-import type { Sampling, AtomicTypeDef, TimeTruncExpr, TimeExtractExpr, TimeDeltaExpr, TypecastExpr, RegexMatchExpr, TimeLiteralNode, MeasureTimeExpr, LeafAtomicTypeDef, RecordLiteralNode, ArrayLiteralNode } from '../../model/malloy_types';
+import type { Sampling, AtomicTypeDef, TimeTruncExpr, TimeExtractExpr, TimeDeltaExpr, TypecastExpr, RegexMatchExpr, TimeLiteralNode, MeasureTimeExpr, BasicAtomicTypeDef, RecordLiteralNode, ArrayLiteralNode } from '../../model/malloy_types';
 import type { DialectFunctionOverloadDef } from '../functions';
 import type { DialectFieldList, OrderByRequest, QueryInfo } from '../dialect';
 import { Dialect } from '../dialect';
@@ -64,7 +64,7 @@ export declare class StandardSQLDialect extends Dialect {
         [name: string]: DialectFunctionOverloadDef[];
     };
     malloyTypeToSQLType(malloyType: AtomicTypeDef): string;
-    sqlTypeToMalloyType(sqlType: string): LeafAtomicTypeDef;
+    sqlTypeToMalloyType(sqlType: string): BasicAtomicTypeDef;
     castToString(expression: string): string;
     concat(...values: string[]): string;
     validateTypeName(sqlType: string): boolean;

package/dist/dialect/standardsql/standardsql.js

@@ -131,7 +131,7 @@ class StandardSQLDialect extends dialect_1.Dialect {
         const fields = fieldList
             .map(f => `${f.sqlExpression} as ${f.sqlOutputName}`)
             .join(', ');
-        return `ANY_VALUE(CASE WHEN group_set=${groupSet} THEN STRUCT(${fields}))`;
+        return `ANY_VALUE(CASE WHEN group_set=${groupSet} THEN STRUCT(${fields}) END)`;
     }
     sqlAnyValueLastTurtle(name, groupSet, sqlName) {
         return `ANY_VALUE(CASE WHEN group_set=${groupSet} THEN ${name} END) as ${sqlName}`;

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

@@ -1,4 +1,4 @@
-import type { Expr, Sampling, AtomicTypeDef, TimeDeltaExpr, TypecastExpr, RegexMatchExpr, MeasureTimeExpr, TimeLiteralNode, TimeExtractExpr, LeafAtomicTypeDef, RecordLiteralNode } from '../../model/malloy_types';
+import type { Expr, Sampling, AtomicTypeDef, TimeDeltaExpr, TypecastExpr, RegexMatchExpr, MeasureTimeExpr, TimeLiteralNode, TimeExtractExpr, BasicAtomicTypeDef, RecordLiteralNode } from '../../model/malloy_types';
 import type { DialectFunctionOverloadDef } from '../functions';
 import type { DialectFieldList, OrderByClauseType, QueryInfo } from '../dialect';
 import { PostgresBase } from '../pg_impl';
@@ -65,7 +65,7 @@ export declare class TrinoDialect extends PostgresBase {
         [name: string]: DialectFunctionOverloadDef[];
     };
     malloyTypeToSQLType(malloyType: AtomicTypeDef): string;
-    sqlTypeToMalloyType(sqlType: string): LeafAtomicTypeDef;
+    sqlTypeToMalloyType(sqlType: string): BasicAtomicTypeDef;
     castToString(expression: string): string;
     concat(...values: string[]): string;
     sqlMakeUnnestKey(key: string, rowKey: string): string;

package/dist/dialect/trino/trino.js

@@ -26,7 +26,6 @@ exports.PrestoDialect = exports.TrinoDialect = void 0;
 const utils_1 = require("../../model/utils");
 const malloy_types_1 = require("../../model/malloy_types");
 const functions_1 = require("../functions");
-const dialect_1 = require("../dialect");
 const pg_impl_1 = require("../pg_impl");
 const dialect_functions_1 = require("./dialect_functions");
 const function_overrides_1 = require("./function_overrides");
@@ -50,10 +49,6 @@ function qtz(qi) {
         return tz;
     }
 }
-const trinoTypeMap = {
-    'string': 'VARCHAR',
-    'number': 'DOUBLE',
-};
 const trinoToMalloyTypes = {
     'varchar': { type: 'string' },
     'integer': { type: 'number', numberType: 'integer' },
@@ -227,20 +222,9 @@ class TrinoDialect extends pg_impl_1.PostgresBase {
         return `ANY_VALUE(CASE WHEN group_set=${groupSet} THEN ${fieldName} END)`;
     }
     buildTypeExpression(fieldList) {
-        const fields = [];
-        for (const f of fieldList) {
-            if ((0, dialect_1.isDialectFieldStruct)(f)) {
-                let s = `ROW(${this.buildTypeExpression(f.nestedStruct)})`;
-                if (f.isArray) {
-                    s = `array(${s})`;
-                }
-                fields.push(`${f.sqlOutputName} ${s}`);
-            }
-            else {
-                fields.push(`${f.sqlOutputName} ${trinoTypeMap[f.type] || f.type}`);
-            }
-        }
-        return fields.join(', \n');
+        return fieldList
+            .map(dlf => `${dlf.sqlOutputName} ${this.malloyTypeToSQLType(dlf.typeDef)}`)
+            .join(', \n');
     }
     // can array agg or any_value a struct...
     sqlAggregateTurtle(groupSet, fieldList, orderBy, limit) {
@@ -253,10 +237,9 @@ class TrinoDialect extends pg_impl_1.PostgresBase {
         return ret;
     }
     sqlAnyValueTurtle(groupSet, fieldList) {
-        const fields = fieldList
-            .map(f => `\n '${f.sqlOutputName}' VALUE ${f.sqlExpression}`)
-            .join(', ');
-        return `ANY_VALUE(CASE WHEN group_set=${groupSet} THEN JSON_OBJECT(${fields}))`;
+        const expressions = fieldList.map(f => f.sqlExpression).join(',\n ');
+        const definitions = this.buildTypeExpression(fieldList);
+        return `ANY_VALUE(CASE WHEN group_set=${groupSet} THEN CAST(ROW(${expressions}) AS ROW(${definitions})) END)`;
     }
     sqlAnyValueLastTurtle(name, groupSet, sqlName) {
         return `ANY_VALUE(CASE WHEN group_set=${groupSet} THEN ${name} END) as ${sqlName}`;
@@ -465,10 +448,16 @@ ${(0, utils_1.indent)(sql)}
             case 'sql native':
                 return malloyType.rawType || 'UNKNOWN-NATIVE';
             case 'array': {
-                if (malloyType.elementTypeDef.type !== 'record_element') {
-                    return `ARRAY<${this.malloyTypeToSQLType(malloyType.elementTypeDef)}>`;
+                if ((0, malloy_types_1.isRepeatedRecord)(malloyType)) {
+                    const typeSpec = [];
+                    for (const f of malloyType.fields) {
+                        if ((0, malloy_types_1.isAtomic)(f)) {
+                            typeSpec.push(`${f.name} ${this.malloyTypeToSQLType(f)}`);
+                        }
+                    }
+                    return `ARRAY<ROW(${typeSpec.join(',')})>`;
                 }
-                return malloyType.type.toUpperCase();
+                return `ARRAY<${this.malloyTypeToSQLType(malloyType.elementTypeDef)}>`;
             }
             default:
                 return malloyType.type.toUpperCase();

package/dist/index.d.ts

@@ -1,7 +1,7 @@
 export { DuckDBDialect, StandardSQLDialect, TrinoDialect, PostgresDialect, SnowflakeDialect, MySQLDialect, registerDialect, arg, qtz, overload, minScalar, anyExprType, minAggregate, maxScalar, sql, makeParam, param, variadicParam, literal, spread, Dialect, TinyParser, } from './dialect';
 export type { DialectFieldList, DialectFunctionOverloadDef, QueryInfo, MalloyStandardFunctionImplementations, DefinitionBlueprint, DefinitionBlueprintMap, OverloadedDefinitionBlueprint, TinyToken, } from './dialect';
-export type { QueryDataRow, 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, QueryRunStats, NamedQuery, NamedModelObject, ExpressionType, FunctionDef, FunctionOverloadDef, FunctionParameterDef, ExpressionValueType, TypeDesc, FunctionParamTypeDesc, DocumentLocation, DocumentRange, DocumentPosition, Sampling, Annotation, LeafAtomicTypeDef, LeafAtomicDef, AtomicTypeDef, AtomicFieldDef, ArrayDef, ArrayTypeDef, RecordTypeDef, RepeatedRecordTypeDef, RecordDef, RepeatedRecordDef, RecordLiteralNode, ArrayLiteralNode, } from './model';
-export { isSourceDef, Segment, isLeafAtomic, isJoined, isJoinedSource, isSamplingEnable, isSamplingPercent, isSamplingRows, isRepeatedRecord, isScalarArray, mkArrayDef, mkFieldDef, expressionIsAggregate, expressionIsAnalytic, expressionIsCalculation, expressionIsScalar, expressionIsUngroupedAggregate, indent, composeSQLExpr, } from './model';
+export type { QueryDataRow, 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, QueryRunStats, NamedQuery, NamedModelObject, ExpressionType, FunctionDef, FunctionOverloadDef, FunctionParameterDef, ExpressionValueType, TypeDesc, FunctionParamTypeDesc, DocumentLocation, DocumentRange, DocumentPosition, Sampling, Annotation, BasicAtomicTypeDef, BasicAtomicDef, AtomicTypeDef, AtomicFieldDef, ArrayDef, ArrayTypeDef, RecordTypeDef, RepeatedRecordTypeDef, RecordDef, RepeatedRecordDef, RecordLiteralNode, ArrayLiteralNode, } from './model';
+export { isSourceDef, Segment, isBasicAtomic, isJoined, isJoinedSource, isSamplingEnable, isSamplingPercent, isSamplingRows, isRepeatedRecord, isBasicArray, mkArrayDef, mkFieldDef, expressionIsAggregate, expressionIsAnalytic, expressionIsCalculation, expressionIsScalar, expressionIsUngroupedAggregate, indent, composeSQLExpr, } from './model';
 export { malloyToQuery, MalloyTranslator, } from './lang';
 export type { LogMessage, TranslateResponse } from './lang';
 export { Model, Malloy, Runtime, AtomicFieldType, ConnectionRuntime, SingleConnectionRuntime, EmptyURLReader, InMemoryURLReader, FixedConnectionMap, MalloyError, JoinRelationship, SourceRelationship, DateTimeframe, TimestampTimeframe, PreparedResult, Result, QueryMaterializer, CSVWriter, JSONWriter, Parse, DataWriter, Explore, InMemoryModelCache, CacheManager, } from './malloy';

package/dist/index.js

@@ -23,7 +23,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.EmptyURLReader = exports.SingleConnectionRuntime = exports.ConnectionRuntime = exports.AtomicFieldType = exports.Runtime = exports.Malloy = exports.Model = exports.MalloyTranslator = exports.malloyToQuery = exports.composeSQLExpr = exports.indent = exports.expressionIsUngroupedAggregate = exports.expressionIsScalar = exports.expressionIsCalculation = exports.expressionIsAnalytic = exports.expressionIsAggregate = exports.mkFieldDef = exports.mkArrayDef = exports.isScalarArray = exports.isRepeatedRecord = exports.isSamplingRows = exports.isSamplingPercent = exports.isSamplingEnable = exports.isJoinedSource = exports.isJoined = exports.isLeafAtomic = exports.Segment = exports.isSourceDef = exports.TinyParser = 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.registerDialect = exports.MySQLDialect = exports.SnowflakeDialect = exports.PostgresDialect = exports.TrinoDialect = exports.StandardSQLDialect = exports.DuckDBDialect = void 0;
+exports.EmptyURLReader = exports.SingleConnectionRuntime = exports.ConnectionRuntime = exports.AtomicFieldType = exports.Runtime = exports.Malloy = exports.Model = exports.MalloyTranslator = exports.malloyToQuery = 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.isBasicAtomic = exports.Segment = exports.isSourceDef = exports.TinyParser = 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.registerDialect = exports.MySQLDialect = exports.SnowflakeDialect = exports.PostgresDialect = exports.TrinoDialect = exports.StandardSQLDialect = exports.DuckDBDialect = void 0;
 exports.annotationToTaglines = exports.annotationToTag = exports.sqlKey = exports.API = exports.modelDefToModelInfo = exports.toAsyncGenerator = 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 = void 0;
 /*
  * Copyright 2023 Google LLC
@@ -74,14 +74,14 @@ var model_1 = require("./model");
 Object.defineProperty(exports, "isSourceDef", { enumerable: true, get: function () { return model_1.isSourceDef; } });
 // Used in Composer Demo
 Object.defineProperty(exports, "Segment", { enumerable: true, get: function () { return model_1.Segment; } });
-Object.defineProperty(exports, "isLeafAtomic", { enumerable: true, get: function () { return model_1.isLeafAtomic; } });
+Object.defineProperty(exports, "isBasicAtomic", { enumerable: true, get: function () { return model_1.isBasicAtomic; } });
 Object.defineProperty(exports, "isJoined", { enumerable: true, get: function () { return model_1.isJoined; } });
 Object.defineProperty(exports, "isJoinedSource", { enumerable: true, get: function () { return model_1.isJoinedSource; } });
 Object.defineProperty(exports, "isSamplingEnable", { enumerable: true, get: function () { return model_1.isSamplingEnable; } });
 Object.defineProperty(exports, "isSamplingPercent", { enumerable: true, get: function () { return model_1.isSamplingPercent; } });
 Object.defineProperty(exports, "isSamplingRows", { enumerable: true, get: function () { return model_1.isSamplingRows; } });
 Object.defineProperty(exports, "isRepeatedRecord", { enumerable: true, get: function () { return model_1.isRepeatedRecord; } });
-Object.defineProperty(exports, "isScalarArray", { enumerable: true, get: function () { return model_1.isScalarArray; } });
+Object.defineProperty(exports, "isBasicArray", { enumerable: true, get: function () { return model_1.isBasicArray; } });
 Object.defineProperty(exports, "mkArrayDef", { enumerable: true, get: function () { return model_1.mkArrayDef; } });
 Object.defineProperty(exports, "mkFieldDef", { enumerable: true, get: function () { return model_1.mkFieldDef; } });
 Object.defineProperty(exports, "expressionIsAggregate", { enumerable: true, get: function () { return model_1.expressionIsAggregate; } });

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

@@ -480,7 +480,7 @@ function isDataTypeMatch(genericsAlreadySelected, genericTypes, arg, paramT) {
         return { dataTypeMatch: true, genericsSet: [] };
     }
     if (paramT.type === 'array' && arg.type === 'array') {
-        if ((0, malloy_types_1.isScalarArray)(arg)) {
+        if ((0, malloy_types_1.isBasicArray)(arg)) {
             if (!(0, malloy_types_1.isRepeatedRecordFunctionParam)(paramT)) {
                 return isDataTypeMatch(genericsAlreadySelected, genericTypes, arg.elementTypeDef, paramT.elementTypeDef);
             }

package/dist/lang/ast/field-space/index-field-space.js

@@ -135,7 +135,7 @@ class IndexFieldSpace extends query_spaces_1.QueryOperationSpace {
             else {
                 const eTypeDesc = entry.typeDesc();
                 // Don't index arrays and records
-                if (malloy_types_1.TD.isLeafAtomic(eTypeDesc) &&
+                if (malloy_types_1.TD.isBasicAtomic(eTypeDesc) &&
                     (0, malloy_types_1.expressionIsScalar)(eTypeDesc.expressionType) &&
                     (dialect === undefined || !dialect.ignoreInProject(name))) {
                     expandEntries.push({ name: indexName, entry });

package/dist/lang/ast/field-space/view-field.d.ts

@@ -55,7 +55,7 @@ export declare abstract class ViewField extends SpaceField {
     } | {
         compositeFieldUsage: import("../../../model/malloy_types").CompositeFieldUsage;
         type: "array";
-        elementTypeDef: import("../../../model/malloy_types").LeafAtomicTypeDef | import("../../../model/malloy_types").ScalarArrayTypeDef | import("../../../model/malloy_types").RepeatedRecordTypeDef;
+        elementTypeDef: import("../../../model/malloy_types").BasicAtomicTypeDef | import("../../../model/malloy_types").BasicArrayTypeDef | import("../../../model/malloy_types").RepeatedRecordTypeDef;
         expressionType: import("../../../model/malloy_types").ExpressionType;
         evalSpace: import("../../../model/malloy_types").EvalSpace;
     } | {

package/dist/model/malloy_query.d.ts

@@ -1,8 +1,7 @@
-import type { Dialect, DialectFieldList } from '../dialect';
-import type { AggregateFunctionType, Annotation, CompiledQuery, Expr, FieldDef, Filtered, FunctionOverloadDef, FunctionParameterDef, JoinRelationship, ModelDef, OrderBy, OutputFieldNode, ParameterNode, PipeSegment, Query, QueryFieldDef, QuerySegment, ResultMetadataDef, ResultStructMetadataDef, SearchIndexResult, SegmentFieldDef, StructDef, StructRef, TurtleDef, FunctionOrderBy, Argument, AggregateExpr, FilterCondition, GenericSQLExpr, FieldnameNode, FunctionCallNode, UngroupNode, SourceReferenceNode, SpreadExpr, FilteredExpr, SourceDef, BooleanFieldDef, QueryResultDef, QueryToMaterialize, PrepareResultOptions, CaseExpr, LeafAtomicDef } from './malloy_types';
+import type { QueryInfo, Dialect, DialectFieldList } from '../dialect';
+import type { AggregateFunctionType, Annotation, CompiledQuery, Expr, FieldDef, Filtered, FunctionOverloadDef, FunctionParameterDef, JoinRelationship, ModelDef, OrderBy, OutputFieldNode, ParameterNode, PipeSegment, Query, QueryFieldDef, QuerySegment, ResultMetadataDef, ResultStructMetadataDef, SearchIndexResult, SegmentFieldDef, StructDef, StructRef, TurtleDef, FunctionOrderBy, Argument, AggregateExpr, FilterCondition, GenericSQLExpr, FieldnameNode, FunctionCallNode, UngroupNode, SourceReferenceNode, SpreadExpr, FilteredExpr, SourceDef, BooleanFieldDef, QueryResultDef, QueryToMaterialize, PrepareResultOptions, CaseExpr, BasicAtomicDef, AtomicFieldDef } from './malloy_types';
 import type { Connection } from '../connection/types';
 import { AndChain } from './utils';
-import type { QueryInfo } from '../dialect/dialect';
 import type { EventStream } from '../runtime_types';
 import type { Tag } from '@malloydata/malloy-tag';
 interface TurtleDefPlus extends TurtleDef, Filtered {
@@ -98,19 +97,16 @@ declare class QueryField extends QueryNode {
     isNestedInParent(parentDef: FieldDef): boolean;
     isArrayElement(parentDef: FieldDef): boolean;
     generateExpression(resultSet: FieldInstanceResult): string;
+    includeInWildcard(): boolean;
 }
-type QueryFieldAtomic = AbstractQueryAtomic<LeafAtomicDef>;
-declare class AbstractQueryAtomic<T extends LeafAtomicDef> extends QueryField {
+type QueryBasicField = QueryAtomicField<BasicAtomicDef>;
+declare abstract class QueryAtomicField<T extends AtomicFieldDef> extends QueryField {
     fieldDef: T;
     constructor(fieldDef: T, parent: QueryStruct, refId?: string);
     includeInWildcard(): boolean;
-    isCalculated(): boolean;
-    isAggregate(): boolean;
     getFilterList(): FilterCondition[];
-    hasExpression(): boolean;
-    isAtomic(): boolean;
 }
-declare class QueryFieldBoolean extends AbstractQueryAtomic<BooleanFieldDef> {
+declare class QueryFieldBoolean extends QueryAtomicField<BooleanFieldDef> {
 }
 type FieldUsage = {
     type: 'result';
@@ -333,7 +329,7 @@ declare class QueryStruct {
     getJoinableParent(): QueryStruct;
     addFieldToNameMap(as: string, n: QueryField): void;
     /** the the primary key or throw an error. */
-    getPrimaryKeyField(fieldDef: FieldDef): QueryFieldAtomic;
+    getPrimaryKeyField(fieldDef: FieldDef): QueryBasicField;
     /**
      * called after all structure has been loaded.  Examine this structure to see
      * if if it is based on a query and if it is, add the output fields (unless
@@ -347,7 +343,7 @@ declare class QueryStruct {
     makeQueryField(field: FieldDef, referenceId?: string): QueryField;
     structSourceSQL(stageWriter: StageWriter): string;
     root(): QueryStruct;
-    primaryKey(): QueryFieldAtomic | undefined;
+    primaryKey(): QueryBasicField | undefined;
     getChildByName(name: string): QueryField | undefined;
     /** convert a path into a field reference */
     getFieldByName(path: string[]): QueryField;
@@ -355,10 +351,10 @@ declare class QueryStruct {
     getQueryFieldReference(path: string[], annotation: Annotation | undefined): QueryField;
     getDimensionOrMeasureByName(name: string[]): QueryField;
     /** returns a query object for the given name */
-    getDimensionByName(name: string[]): QueryFieldAtomic;
+    getDimensionByName(name: string[]): QueryBasicField;
     /** returns a query object for the given name */
     getStructByName(name: string[]): QueryStruct;
-    getDistinctKey(): QueryFieldAtomic;
+    getDistinctKey(): QueryBasicField;
     applyStructFiltersToTurtleDef(turtleDef: TurtleDef | TurtleDefPlus): TurtleDef;
 }
 /** the resulting SQL and the shape of the data at each stage of the pipeline */

package/dist/model/malloy_query.js

@@ -46,7 +46,7 @@ function getDialectFieldList(structDef) {
     const dialectFieldList = [];
     for (const f of structDef.fields.filter(malloy_types_1.fieldIsIntrinsic)) {
         dialectFieldList.push({
-            type: f.type,
+            typeDef: f,
             sqlExpression: (0, malloy_types_1.getIdentifier)(f),
             rawName: (0, malloy_types_1.getIdentifier)(f),
             sqlOutputName: (0, malloy_types_1.getIdentifier)(f),
@@ -54,6 +54,12 @@ function getDialectFieldList(structDef) {
     }
     return dialectFieldList;
 }
+function pushDialectField(dl, f) {
+    const { sqlExpression, sqlOutputName, rawName } = f;
+    if ((0, malloy_types_1.isAtomic)(f.fieldDef)) {
+        dl.push({ typeDef: f.fieldDef, sqlExpression, sqlOutputName, rawName });
+    }
+}
 class UniqueKeyUse extends Set {
     add_use(k) {
         if (k !== undefined) {
@@ -622,7 +628,7 @@ class QueryField extends QueryNode {
         const ret = [];
         let p = resultStruct.parent;
         while (p !== undefined) {
-            const scalars = p.fields(fi => isScalarField(fi.f) && fi.fieldUsage.type === 'result');
+            const scalars = p.fields(fi => isBasicScalar(fi.f) && fi.fieldUsage.type === 'result');
             const partitionSQLs = scalars.map(fi => fi.getAnalyticalSQL(true));
             ret.push(...partitionSQLs);
             p = p.parent;
@@ -942,17 +948,44 @@ class QueryField extends QueryNode {
             }
             : undefined);
     }
+    includeInWildcard() {
+        return false;
+    }
 }
-function isCalculatedField(f) {
-    return f instanceof AbstractQueryAtomic && f.isCalculated();
+function isBasicCalculation(f) {
+    return f instanceof QueryAtomicField && isCalculatedField(f);
 }
-function isAggregateField(f) {
-    return f instanceof AbstractQueryAtomic && f.isAggregate();
+function isBasicAggregate(f) {
+    return f instanceof QueryAtomicField && isAggregateField(f);
+}
+function isBasicScalar(f) {
+    return f instanceof QueryAtomicField && isScalarField(f);
 }
 function isScalarField(f) {
-    return (f instanceof AbstractQueryAtomic && !f.isCalculated() && !f.isAggregate());
+    if (f.isAtomic()) {
+        if ((0, malloy_types_1.hasExpression)(f.fieldDef)) {
+            const et = f.fieldDef.expressionType;
+            if ((0, malloy_types_1.expressionIsCalculation)(et) || (0, malloy_types_1.expressionIsAggregate)(et)) {
+                return false;
+            }
+        }
+        return true;
+    }
+    return false;
 }
-class AbstractQueryAtomic extends QueryField {
+function isCalculatedField(f) {
+    if (f.isAtomic() && (0, malloy_types_1.hasExpression)(f.fieldDef)) {
+        return (0, malloy_types_1.expressionIsCalculation)(f.fieldDef.expressionType);
+    }
+    return false;
+}
+function isAggregateField(f) {
+    if (f.isAtomic() && (0, malloy_types_1.hasExpression)(f.fieldDef)) {
+        return (0, malloy_types_1.expressionIsAggregate)(f.fieldDef.expressionType);
+    }
+    return false;
+}
+class QueryAtomicField extends QueryField {
     constructor(fieldDef, parent, refId) {
         super(fieldDef, parent, refId);
         this.fieldDef = fieldDef; // wish I didn't have to do this
@@ -960,36 +993,22 @@ class AbstractQueryAtomic extends QueryField {
     includeInWildcard() {
         return true;
     }
-    isCalculated() {
-        return ((0, malloy_types_1.hasExpression)(this.fieldDef) &&
-            (0, malloy_types_1.expressionIsCalculation)(this.fieldDef.expressionType));
-    }
-    isAggregate() {
-        return ((0, malloy_types_1.hasExpression)(this.fieldDef) &&
-            (0, malloy_types_1.expressionIsAggregate)(this.fieldDef.expressionType));
-    }
     getFilterList() {
         return [];
     }
-    hasExpression() {
-        return (0, malloy_types_1.hasExpression)(this.fieldDef);
-    }
-    isAtomic() {
-        return true;
-    }
 }
 // class QueryMeasure extends QueryField {}
-class QueryFieldString extends AbstractQueryAtomic {
+class QueryFieldString extends QueryAtomicField {
 }
-class QueryFieldNumber extends AbstractQueryAtomic {
+class QueryFieldNumber extends QueryAtomicField {
 }
-class QueryFieldBoolean extends AbstractQueryAtomic {
+class QueryFieldBoolean extends QueryAtomicField {
 }
-class QueryFieldJSON extends AbstractQueryAtomic {
+class QueryFieldJSON extends QueryAtomicField {
 }
-class QueryFieldUnsupported extends AbstractQueryAtomic {
+class QueryFieldUnsupported extends QueryAtomicField {
 }
-class QueryFieldDate extends AbstractQueryAtomic {
+class QueryFieldDate extends QueryAtomicField {
     generateExpression(resultSet) {
         const fd = this.fieldDef;
         const superExpr = super.generateExpression(resultSet);
@@ -1015,7 +1034,7 @@ class QueryFieldDate extends AbstractQueryAtomic {
         return new QueryFieldDate(fieldDef, this.parent);
     }
 }
-class QueryFieldTimestamp extends AbstractQueryAtomic {
+class QueryFieldTimestamp extends QueryAtomicField {
     // clone ourselves on demand as a timeframe.
     getChildByName(name) {
         const fieldDef = {
@@ -1026,7 +1045,7 @@ class QueryFieldTimestamp extends AbstractQueryAtomic {
         return new QueryFieldTimestamp(fieldDef, this.parent);
     }
 }
-class QueryFieldDistinctKey extends AbstractQueryAtomic {
+class QueryFieldDistinctKey extends QueryAtomicField {
     generateExpression(resultSet) {
         var _a;
         if (this.parent.primaryKey()) {
@@ -1246,7 +1265,7 @@ class FieldInstanceResult {
         let ret = 'inline_all_numbers';
         for (const f of this.fields()) {
             if (f.fieldUsage.type === 'result') {
-                if (isScalarField(f.f)) {
+                if (isBasicScalar(f.f)) {
                     return 'nested';
                 }
                 if (f.f instanceof QueryFieldStruct) {
@@ -1293,7 +1312,7 @@ class FieldInstanceResult {
                     if (['date', 'timestamp'].indexOf(fi.f.fieldDef.type) > -1) {
                         return [{ dir: 'desc', field: fi.fieldUsage.resultIndex }];
                     }
-                    else if (isAggregateField(fi.f)) {
+                    else if (isBasicAggregate(fi.f)) {
                         return [{ dir: 'desc', field: fi.fieldUsage.resultIndex }];
                     }
                 }
@@ -1367,7 +1386,7 @@ class FieldInstanceResult {
             // fields specified an an all, convert it to an exclude set.
             const allFields = (ungroupSet === null || ungroupSet === void 0 ? void 0 : ungroupSet.fields) || [];
             // convert an All into the equivalent exclude
-            excludeFields = this.fields(fi => isScalarField(fi.f) &&
+            excludeFields = this.fields(fi => isBasicScalar(fi.f) &&
                 fi.fieldUsage.type === 'result' &&
                 allFields.indexOf(fi.f.getIdentifier()) === -1).map(fi => fi.f.getIdentifier());
         }
@@ -1783,13 +1802,13 @@ class QueryQuery extends QueryField {
                 this.expandFields(fir);
                 resultStruct.add(as, fir);
             }
-            else if (field instanceof AbstractQueryAtomic) {
+            else if (field instanceof QueryAtomicField) {
                 resultStruct.addField(as, field, {
                     resultIndex,
                     type: 'result',
                 });
                 this.addDependancies(resultStruct, field);
-                if (isAggregateField(field)) {
+                if (isBasicAggregate(field)) {
                     if (this.firstSegment.type === 'project') {
                         throw new Error(`Aggregate Fields cannot be used in select - '${field.fieldDef.name}'`);
                     }
@@ -1896,7 +1915,7 @@ class QueryQuery extends QueryField {
                     sourceClasses,
                     referenceId,
                 };
-                if (isCalculatedField(fi.f)) {
+                if (isBasicCalculation(fi.f)) {
                     filterList = fi.f.getFilterList();
                     return {
                         ...base,
@@ -1904,7 +1923,7 @@ class QueryQuery extends QueryField {
                         fieldKind: 'measure',
                     };
                 }
-                if (isScalarField(fi.f)) {
+                if (isBasicScalar(fi.f)) {
                     return {
                         ...base,
                         filterList,
@@ -1976,7 +1995,7 @@ class QueryQuery extends QueryField {
                 if (fi.fieldUsage.type === 'result') {
                     // if there is only one dimension, it is the primaryKey
                     //  if there are more, primaryKey is undefined.
-                    if (isScalarField(fi.f)) {
+                    if (isBasicScalar(fi.f)) {
                         if (dimCount === 0 && isRoot) {
                             primaryKey = name;
                         }
@@ -2155,7 +2174,7 @@ class QueryQuery extends QueryField {
             }
             // we need to generate primary key.  If parent has a primary key combine
             // console.log(ji.alias, fieldExpression, this.inNestedPipeline());
-            s += `${this.parent.dialect.sqlUnnestAlias(arrayExpression, ji.alias, ji.getDialectFieldList(), ji.makeUniqueKey, (0, malloy_types_1.isScalarArray)(qsDef), this.inNestedPipeline())}\n`;
+            s += `${this.parent.dialect.sqlUnnestAlias(arrayExpression, ji.alias, ji.getDialectFieldList(), ji.makeUniqueKey, (0, malloy_types_1.isBasicArray)(qsDef), this.inNestedPipeline())}\n`;
         }
         else if (qsDef.type === 'record') {
             throw new Error('Internal Error: records should never appear in join trees');
@@ -2382,7 +2401,7 @@ class QueryQuery extends QueryField {
                         }
                         output.dimensionIndexes.push(output.fieldIndex++);
                     }
-                    else if (isCalculatedField(fi.f)) {
+                    else if (isBasicCalculation(fi.f)) {
                         output.sql.push(`${exp} as ${outputName}`);
                         output.fieldIndex++;
                     }
@@ -2519,7 +2538,7 @@ class QueryQuery extends QueryField {
                         output.sql.push(`${exp} as ${sqlFieldName}`);
                         output.dimensionIndexes.push(output.fieldIndex++);
                     }
-                    else if (isCalculatedField(fi.f)) {
+                    else if (isBasicCalculation(fi.f)) {
                         const exp = this.parent.dialect.sqlAnyValue(resultSet.groupSet, sqlFieldName);
                         output.sql.push(`${exp} as ${sqlFieldName}`);
                         output.fieldIndex++;
@@ -2591,7 +2610,7 @@ class QueryQuery extends QueryField {
                         fieldsSQL.push(this.parent.dialect.sqlMaybeQuoteIdentifier(`${name}__${this.rootResult.groupSet}`) + ` as ${sqlName}`);
                         dimensionIndexes.push(fieldIndex++);
                     }
-                    else if (isCalculatedField(fi.f)) {
+                    else if (isBasicCalculation(fi.f)) {
                         fieldsSQL.push(this.parent.dialect.sqlAnyValueLastTurtle(this.parent.dialect.sqlMaybeQuoteIdentifier(`${name}__${this.rootResult.groupSet}`), this.rootResult.groupSet, sqlName));
                         fieldIndex++;
                     }
@@ -2634,21 +2653,42 @@ class QueryQuery extends QueryField {
             //
             if (resultStruct.firstSegment.type === 'reduce' &&
                 field instanceof FieldInstanceResult) {
-                const d = {
-                    type: 'struct',
-                    sqlExpression: this.parent.dialect.sqlMaybeQuoteIdentifier(`${name}__${resultStruct.groupSet}`),
-                    rawName: name,
-                    sqlOutputName: sqlName,
-                    isArray: field.getRepeatedResultType() === 'nested',
-                    nestedStruct: this.buildDialectFieldList(field),
-                };
-                dialectFieldList.push(d);
+                const { structDef, repeatedResultType } = this.generateTurtlePipelineSQL(field, new StageWriter(true, undefined), '<nosource>');
+                if (repeatedResultType === 'nested') {
+                    const multiLineNest = {
+                        ...structDef,
+                        type: 'array',
+                        elementTypeDef: { type: 'record_element' },
+                        join: 'many',
+                        name,
+                    };
+                    dialectFieldList.push({
+                        typeDef: multiLineNest,
+                        sqlExpression: this.parent.dialect.sqlMaybeQuoteIdentifier(`${name}__${resultStruct.groupSet}`),
+                        rawName: name,
+                        sqlOutputName: sqlName,
+                    });
+                }
+                else {
+                    const oneLineNest = {
+                        ...structDef,
+                        type: 'record',
+                        join: 'one',
+                        name,
+                    };
+                    dialectFieldList.push({
+                        typeDef: oneLineNest,
+                        sqlExpression: this.parent.dialect.sqlMaybeQuoteIdentifier(`${name}__${resultStruct.groupSet}`),
+                        rawName: name,
+                        sqlOutputName: sqlName,
+                    });
+                }
             }
             else if (resultStruct.firstSegment.type === 'reduce' &&
                 field instanceof FieldInstanceField &&
                 field.fieldUsage.type === 'result') {
-                dialectFieldList.push({
-                    type: field.f.fieldDef.type,
+                pushDialectField(dialectFieldList, {
+                    fieldDef: field.f.fieldDef,
                     sqlExpression: this.parent.dialect.sqlMaybeQuoteIdentifier(`${name}__${resultStruct.groupSet}`),
                     rawName: name,
                     sqlOutputName: sqlName,
@@ -2657,8 +2697,8 @@ class QueryQuery extends QueryField {
             else if (resultStruct.firstSegment.type === 'project' &&
                 field instanceof FieldInstanceField &&
                 field.fieldUsage.type === 'result') {
-                dialectFieldList.push({
-                    type: field.f.fieldDef.type,
+                pushDialectField(dialectFieldList, {
+                    fieldDef: field.f.fieldDef,
                     sqlExpression: field.f.generateExpression(resultStruct),
                     rawName: name,
                     sqlOutputName: sqlName,
@@ -2857,7 +2897,7 @@ class QueryQueryIndexStage extends QueryQuery {
                 resultIndex,
                 type: 'result',
             });
-            if (field instanceof AbstractQueryAtomic) {
+            if (field instanceof QueryAtomicField) {
                 this.addDependancies(resultStruct, field);
             }
             resultIndex++;
@@ -3091,17 +3131,15 @@ class QueryFieldStruct extends QueryField {
      * those probably should be in here ... I thought this would be important
      * but maybe it isn't, it doesn't fix the problem I am working on ...
      */
-    // mtoy todo review with lloyd if any of these are needed, had to NOT
-    // do getIdentifier to pass a test, didn't stop to think why.
-    // getIdentifier() {
-    //   return this.queryStruct.getIdentifier();
-    // }
     getJoinableParent() {
         return this.queryStruct.getJoinableParent();
     }
     getFullOutputName() {
         return this.queryStruct.getFullOutputName();
     }
+    includeInWildcard() {
+        return this.isAtomic();
+    }
 }
 /** Structure object as it is used to build a query */
 class QueryStruct {
@@ -3551,7 +3589,7 @@ class QueryStruct {
     /** returns a query object for the given name */
     getDimensionByName(name) {
         const field = this.getFieldByName(name);
-        if (field.isAtomic() && isScalarField(field)) {
+        if (isBasicScalar(field)) {
             return field;
         }
         throw new Error(`${name} is not an atomic scalar field? Inconceivable!`);
@@ -3744,10 +3782,8 @@ class QueryModel {
         const struct = this.getStructByName(explore);
         let indexStar = [];
         for (const [fn, fv] of struct.nameMap) {
-            if (!(fv instanceof QueryFieldStruct)) {
-                if (isScalarField(fv) && fv.includeInWildcard()) {
-                    indexStar.push({ type: 'fieldref', path: [fn] });
-                }
+            if (isScalarField(fv) && fv.includeInWildcard()) {
+                indexStar.push({ type: 'fieldref', path: [fn] });
             }
         }
         indexStar = indexStar.sort((a, b) => a.path[0].localeCompare(b.path[0]));

package/dist/model/malloy_types.d.ts

@@ -154,15 +154,15 @@ export interface MalloyTypecastExpr extends ExprE {
     node: 'cast';
     safe: boolean;
     e: Expr;
-    dstType: LeafAtomicTypeDef;
-    srcType?: LeafAtomicTypeDef;
+    dstType: BasicAtomicTypeDef;
+    srcType?: BasicAtomicTypeDef;
 }
 interface RawTypeCastExpr extends ExprE {
     node: 'cast';
     safe: boolean;
     e: Expr;
     dstSQLType: string;
-    srcType?: LeafAtomicTypeDef;
+    srcType?: BasicAtomicTypeDef;
 }
 export type TypecastExpr = MalloyTypecastExpr | RawTypeCastExpr;
 export declare function isRawCast(te: TypecastExpr): te is RawTypeCastExpr;
@@ -371,7 +371,7 @@ export interface FieldBase extends NamedObject, Expression, ResultMetadata {
     annotation?: Annotation;
     accessModifier?: NonDefaultAccessModifierLabel | undefined;
 }
-export declare function fieldIsIntrinsic(f: FieldDef): boolean;
+export declare function fieldIsIntrinsic(f: FieldDef): f is AtomicFieldDef;
 export interface StringTypeDef {
     type: 'string';
     bucketFilter?: string;
@@ -396,11 +396,11 @@ export interface NativeUnsupportedTypeDef {
     rawType?: string;
 }
 export type NativeUnsupportedFieldDef = NativeUnsupportedTypeDef & AtomicFieldDef;
-export interface ScalarArrayTypeDef {
+export interface BasicArrayTypeDef {
     type: 'array';
     elementTypeDef: Exclude<AtomicTypeDef, RecordTypeDef>;
 }
-export interface ScalarArrayDef extends ScalarArrayTypeDef, StructDefBase, JoinBase, FieldBase {
+export interface BasicArrayDef extends BasicArrayTypeDef, StructDefBase, JoinBase, FieldBase {
     type: 'array';
     join: 'many';
 }
@@ -426,11 +426,11 @@ export interface RepeatedRecordDef extends RepeatedRecordTypeDef, StructDefBase,
     type: 'array';
     join: 'many';
 }
-export type ArrayTypeDef = ScalarArrayTypeDef | RepeatedRecordTypeDef;
-export type ArrayDef = ScalarArrayDef | RepeatedRecordDef;
+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 isScalarArray(td: AtomicTypeDef | FieldDef | QueryFieldDef | StructDef): td is ScalarArrayTypeDef;
+export declare function isBasicArray(td: AtomicTypeDef | FieldDef | QueryFieldDef | StructDef): td is BasicArrayTypeDef;
 export interface ErrorTypeDef {
     type: 'error';
 }
@@ -646,7 +646,7 @@ export interface NonAtomicTypeDef {
 }
 export type ExpressionValueType = AtomicFieldType | NonAtomicType;
 export type ExpressionValueTypeDef = AtomicTypeDef | NonAtomicTypeDef;
-export type LeafExpressionType = Exclude<ExpressionValueType, JoinElementType | 'turtle'>;
+export type BasicExpressionType = Exclude<ExpressionValueType, JoinElementType | 'turtle'>;
 export type TypeInfo = {
     expressionType: ExpressionType;
     evalSpace: EvalSpace;
@@ -658,11 +658,11 @@ export type FunctionParamTypeDesc = FunctionParameterTypeDef & {
     expressionType: ExpressionType | undefined;
     evalSpace: EvalSpace;
 };
-interface ScalarArrayExtTypeDef<TypeExtensions> {
+interface BasicArrayExtTypeDef<TypeExtensions> {
     type: 'array';
     elementTypeDef: Exclude<ExpressionValueExtTypeDef<TypeExtensions>, RecordExtTypeDef<TypeExtensions>>;
 }
-type ExpressionValueExtTypeDef<TypeExtensions> = AtomicTypeDef | NonAtomicTypeDef | ScalarArrayExtTypeDef<TypeExtensions> | RecordExtTypeDef<TypeExtensions> | RepeatedRecordExtTypeDef<TypeExtensions> | TypeExtensions;
+type ExpressionValueExtTypeDef<TypeExtensions> = AtomicTypeDef | NonAtomicTypeDef | BasicArrayExtTypeDef<TypeExtensions> | RecordExtTypeDef<TypeExtensions> | RepeatedRecordExtTypeDef<TypeExtensions> | TypeExtensions;
 interface RecordExtTypeDef<TypeExtensions> {
     type: 'record';
     fields: ExtFieldDef<TypeExtensions>[];
@@ -674,17 +674,17 @@ interface RepeatedRecordExtTypeDef<TypeExtensions> {
     fields: ExtFieldDef<TypeExtensions>[];
 }
 type FunctionReturnTypeExtensions = GenericTypeDef;
-export type ScalarArrayFunctionReturnTypeDef = ScalarArrayExtTypeDef<FunctionReturnTypeExtensions>;
+export type BasicArrayFunctionReturnTypeDef = BasicArrayExtTypeDef<FunctionReturnTypeExtensions>;
 export type FunctionReturnFieldDef = ExtFieldDef<FunctionReturnTypeExtensions>;
 export type RecordFunctionReturnTypeDef = RecordExtTypeDef<FunctionReturnTypeExtensions>;
 export type RepeatedRecordFunctionReturnTypeDef = RepeatedRecordExtTypeDef<FunctionReturnTypeExtensions>;
 type FunctionParameterTypeExtensions = GenericTypeDef | AnyTypeDef;
-export type ScalarArrayFunctionParameterTypeDef = ScalarArrayExtTypeDef<FunctionParameterTypeExtensions>;
+export type BasicArrayFunctionParameterTypeDef = BasicArrayExtTypeDef<FunctionParameterTypeExtensions>;
 export type FunctionParameterFieldDef = ExtFieldDef<FunctionParameterTypeExtensions>;
 export type RecordFunctionParameterTypeDef = RecordExtTypeDef<FunctionParameterTypeExtensions>;
 export type RepeatedRecordFunctionParameterTypeDef = RepeatedRecordExtTypeDef<FunctionParameterTypeExtensions>;
 type FunctionGenericTypeExtensions = AnyTypeDef;
-export type ScalarArrayFunctionGenericTypeDef = ScalarArrayExtTypeDef<FunctionGenericTypeExtensions>;
+export type BasicArrayFunctionGenericTypeDef = BasicArrayExtTypeDef<FunctionGenericTypeExtensions>;
 export type FunctionGenericFieldDef = ExtFieldDef<FunctionGenericTypeExtensions>;
 export type RecordFunctionGenericTypeDef = RecordExtTypeDef<FunctionGenericTypeExtensions>;
 export type RepeatedRecordFunctionGenericTypeDef = RepeatedRecordExtTypeDef<FunctionGenericTypeExtensions>;
@@ -740,12 +740,12 @@ export interface ConnectionDef extends NamedObject {
     type: 'connection';
 }
 export type TemporalTypeDef = DateTypeDef | TimestampTypeDef;
-export type LeafAtomicTypeDef = StringTypeDef | TemporalTypeDef | NumberTypeDef | BooleanTypeDef | JSONTypeDef | NativeUnsupportedTypeDef | ErrorTypeDef;
-export type LeafAtomicDef = LeafAtomicTypeDef & FieldBase;
-export type AtomicTypeDef = LeafAtomicTypeDef | ScalarArrayTypeDef | RecordTypeDef | RepeatedRecordTypeDef;
-export type AtomicFieldDef = LeafAtomicDef | ScalarArrayDef | RecordDef | RepeatedRecordDef;
-export declare function isLeafAtomic(fd: FieldDef | QueryFieldDef | AtomicTypeDef): fd is LeafAtomicDef;
-export type FieldDef = LeafAtomicDef | JoinFieldDef | TurtleDef;
+export type BasicAtomicTypeDef = StringTypeDef | TemporalTypeDef | NumberTypeDef | BooleanTypeDef | JSONTypeDef | NativeUnsupportedTypeDef | ErrorTypeDef;
+export type BasicAtomicDef = BasicAtomicTypeDef & FieldBase;
+export type AtomicTypeDef = BasicAtomicTypeDef | BasicArrayTypeDef | RecordTypeDef | RepeatedRecordTypeDef;
+export type AtomicFieldDef = BasicAtomicDef | BasicArrayDef | RecordDef | RepeatedRecordDef;
+export declare function isBasicAtomic(fd: FieldDef | QueryFieldDef | AtomicTypeDef): fd is BasicAtomicDef;
+export type FieldDef = BasicAtomicDef | JoinFieldDef | TurtleDef;
 export type FieldDefType = AtomicFieldType | 'turtle' | JoinElementType;
 export interface RefToField {
     type: 'fieldref';
@@ -879,7 +879,7 @@ type UTD = AtomicTypeDef | TypedDef | FunctionParameterTypeDef | FunctionReturnT
  */
 export declare const TD: {
     isAtomic(td: UTD): td is AtomicTypeDef;
-    isLeafAtomic(td: UTD): td is LeafAtomicTypeDef;
+    isBasicAtomic(td: UTD): td is BasicAtomicTypeDef;
     isString: (td: UTD) => td is StringTypeDef;
     isNumber: (td: UTD) => td is NumberTypeDef;
     isBoolean: (td: UTD) => td is BooleanTypeDef;

package/dist/model/malloy_types.js

@@ -23,8 +23,8 @@
  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.sourceBase = exports.isSegmentSQL = exports.isIndexSegment = exports.isRawSegment = exports.isSamplingEnable = exports.isSamplingPercent = exports.isSamplingRows = exports.isQuerySegment = exports.isProjectSegment = exports.isPartialSegment = exports.isReduceSegment = exports.structHasErrors = exports.segmentHasErrors = exports.refIsStructDef = exports.ValueType = exports.isExtractUnit = exports.isTimestampUnit = exports.isDateUnit = exports.isJoinedSource = exports.isJoined = exports.isJoinable = exports.isMatrixOperation = exports.isScalarArray = exports.isRepeatedRecord = exports.isRepeatedRecordFunctionParam = exports.mkArrayDef = exports.mkFieldDef = exports.fieldIsIntrinsic = exports.isCastType = exports.canOrderBy = exports.isAtomicFieldType = exports.isTemporalType = exports.hasExpression = exports.maxOfExpressionTypes = exports.maxExpressionType = exports.isExpressionTypeLEQ = exports.expressionIsAnalytic = exports.expressionIsCalculation = exports.expressionInvolvesAggregate = exports.expressionIsUngroupedAggregate = exports.expressionIsAggregate = exports.expressionIsScalar = exports.paramHasValue = exports.isFilterExprType = exports.isRawCast = exports.mkTemporal = exports.isAsymmetricExpr = exports.exprIsLeaf = exports.exprHasE = exports.exprHasKids = void 0;
-exports.TD = exports.isValueDate = exports.isValueTimestamp = exports.isValueBoolean = exports.isValueNumber = exports.isValueString = exports.isAtomic = exports.isTurtle = exports.getIdentifier = exports.isLeafAtomic = exports.mergeEvalSpaces = exports.isLiteral = exports.isBaseTable = exports.isSourceDef = void 0;
+exports.sourceBase = exports.isSegmentSQL = exports.isIndexSegment = exports.isRawSegment = exports.isSamplingEnable = exports.isSamplingPercent = exports.isSamplingRows = exports.isQuerySegment = exports.isProjectSegment = exports.isPartialSegment = exports.isReduceSegment = exports.structHasErrors = exports.segmentHasErrors = exports.refIsStructDef = exports.ValueType = exports.isExtractUnit = exports.isTimestampUnit = exports.isDateUnit = exports.isJoinedSource = exports.isJoined = exports.isJoinable = exports.isMatrixOperation = exports.isBasicArray = exports.isRepeatedRecord = exports.isRepeatedRecordFunctionParam = exports.mkArrayDef = exports.mkFieldDef = exports.fieldIsIntrinsic = exports.isCastType = exports.canOrderBy = exports.isAtomicFieldType = exports.isTemporalType = exports.hasExpression = exports.maxOfExpressionTypes = exports.maxExpressionType = exports.isExpressionTypeLEQ = exports.expressionIsAnalytic = exports.expressionIsCalculation = exports.expressionInvolvesAggregate = exports.expressionIsUngroupedAggregate = exports.expressionIsAggregate = exports.expressionIsScalar = exports.paramHasValue = exports.isFilterExprType = exports.isRawCast = exports.mkTemporal = exports.isAsymmetricExpr = exports.exprIsLeaf = exports.exprHasE = exports.exprHasKids = void 0;
+exports.TD = exports.isValueDate = exports.isValueTimestamp = exports.isValueBoolean = exports.isValueNumber = exports.isValueString = exports.isAtomic = exports.isTurtle = exports.getIdentifier = exports.isBasicAtomic = exports.mergeEvalSpaces = exports.isLiteral = exports.isBaseTable = exports.isSourceDef = void 0;
 function exprHasKids(e) {
     return 'kids' in e;
 }
@@ -187,7 +187,7 @@ function fieldIsIntrinsic(f) {
 }
 exports.fieldIsIntrinsic = fieldIsIntrinsic;
 function mkFieldDef(atd, name) {
-    if (isScalarArray(atd)) {
+    if (isBasicArray(atd)) {
         return mkArrayDef(atd.elementTypeDef, name);
     }
     if (isRepeatedRecord(atd)) {
@@ -232,10 +232,10 @@ function isRepeatedRecord(fd) {
     return fd.type === 'array' && fd.elementTypeDef.type === 'record_element';
 }
 exports.isRepeatedRecord = isRepeatedRecord;
-function isScalarArray(td) {
+function isBasicArray(td) {
     return td.type === 'array' && td.elementTypeDef.type !== 'record_element';
 }
-exports.isScalarArray = isScalarArray;
+exports.isBasicArray = isBasicArray;
 function isMatrixOperation(x) {
     return ['left', 'right', 'full', 'inner'].includes(x);
 }
@@ -388,7 +388,7 @@ function mergeEvalSpaces(...evalSpaces) {
     return 'input';
 }
 exports.mergeEvalSpaces = mergeEvalSpaces;
-function isLeafAtomic(fd) {
+function isBasicAtomic(fd) {
     return (fd.type === 'string' ||
         isTemporalType(fd.type) ||
         fd.type === 'number' ||
@@ -397,7 +397,7 @@ function isLeafAtomic(fd) {
         fd.type === 'sql native' ||
         fd.type === 'error');
 }
-exports.isLeafAtomic = isLeafAtomic;
+exports.isBasicAtomic = isBasicAtomic;
 /** Get the output name for a NamedObject */
 function getIdentifier(n) {
     if (n.as !== undefined) {
@@ -442,8 +442,8 @@ exports.TD = {
     isAtomic(td) {
         return td !== undefined && isAtomicFieldType(td.type);
     },
-    isLeafAtomic(td) {
-        return td !== undefined && isLeafAtomic({ type: td.type });
+    isBasicAtomic(td) {
+        return td !== undefined && isBasicAtomic({ type: td.type });
     },
     isString: (td) => (td === null || td === void 0 ? void 0 : td.type) === 'string',
     isNumber: (td) => (td === null || td === void 0 ? void 0 : td.type) === 'number',

package/dist/to_stable.js

@@ -220,7 +220,7 @@ function getResultStructMetadataAnnotation(field, resultMetadata) {
 }
 exports.getResultStructMetadataAnnotation = getResultStructMetadataAnnotation;
 function typeDefToType(field) {
-    if ((0, model_1.isLeafAtomic)(field)) {
+    if ((0, model_1.isBasicAtomic)(field)) {
         switch (field.type) {
             case 'string':
                 return { kind: 'string_type' };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@malloydata/malloy",
-  "version": "0.0.253-dev250330190957",
+  "version": "0.0.253-dev250401001016",
   "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.253-dev250330190957",
-    "@malloydata/malloy-interfaces": "^0.0.253-dev250330190957",
-    "@malloydata/malloy-tag": "^0.0.253-dev250330190957",
+    "@malloydata/malloy-filter": "^0.0.253-dev250401001016",
+    "@malloydata/malloy-interfaces": "^0.0.253-dev250401001016",
+    "@malloydata/malloy-tag": "^0.0.253-dev250401001016",
     "antlr4ts": "^0.5.0-alpha.4",
     "assert": "^2.0.0",
     "jest-diff": "^29.6.2",