@malloydata/malloy 0.0.219 → 0.0.220-dev241204170603

package/dist/dialect/snowflake/snowflake.js

@@ -142,12 +142,13 @@ class SnowflakeDialect extends dialect_1.Dialect {
         return `COALESCE(ARRAY_AGG(CASE WHEN group_set=${groupSet} THEN OBJECT_CONSTRUCT_KEEP_NULL(${fields}) END)[0], OBJECT_CONSTRUCT_KEEP_NULL(${nullValues}))`;
     }
     sqlUnnestAlias(source, alias, _fieldList, _needDistinctKey, isArray, _isInNestedPipeline) {
+        const as = this.sqlMaybeQuoteIdentifier(alias);
         if (isArray) {
-            return `,LATERAL FLATTEN(INPUT => ${source}) AS ${alias}_1, LATERAL (SELECT ${alias}_1.INDEX, object_construct('value', ${alias}_1.value) as value ) as ${alias}`;
+            return `,LATERAL FLATTEN(INPUT => ${source}) AS ${alias}_1, LATERAL (SELECT ${alias}_1.INDEX, object_construct('value', ${alias}_1.value) as value ) as ${as}`;
         }
         else {
             // have to have a non empty row or it treats it like an inner join :barf-emoji:
-            return `LEFT JOIN LATERAL FLATTEN(INPUT => ifnull(${source},[1])) AS ${alias}`;
+            return `LEFT JOIN LATERAL FLATTEN(INPUT => ifnull(${source},[1])) AS ${as}`;
         }
     }
     /*
@@ -190,23 +191,35 @@ class SnowflakeDialect extends dialect_1.Dialect {
     sqlGenerateUUID() {
         return 'UUID_STRING()';
     }
-    sqlFieldReference(alias, fieldName, fieldType, isNested, _isArray) {
-        if (fieldName === '__row_id') {
-            return `${alias}.INDEX::varchar`;
+    sqlFieldReference(parentAlias, parentType, childName, childType) {
+        const sqlName = this.sqlMaybeQuoteIdentifier(childName);
+        if (childName === '__row_id') {
+            return `"${parentAlias}".INDEX::varchar`;
         }
-        else if (!isNested) {
-            return `${alias}."${fieldName}"`;
-        }
-        else {
-            let snowflakeType = fieldType;
-            if (fieldType === 'string') {
-                snowflakeType = 'varchar';
-            }
-            else if (fieldType === 'struct') {
-                snowflakeType = 'variant';
+        else if (parentType === 'array[scalar]' ||
+            parentType === 'array[record]') {
+            const arrayRef = `"${parentAlias}".value:${sqlName}`;
+            switch (childType) {
+                case 'record':
+                case 'array':
+                    childType = 'VARIANT';
+                    break;
+                case 'string':
+                    childType = 'VARCHAR';
+                    break;
+                case 'number':
+                    childType = 'DOUBLE';
+                    break;
+                case 'struct':
+                    throw new Error('NOT STRUCT PLEASE');
+                // boolean and timestamp and date are all ok
             }
-            return `${alias}.value:"${fieldName}"::${snowflakeType}`;
+            return `${arrayRef}::${childType}`;
         }
+        else if (parentType === 'record') {
+            return `${parentAlias}:${sqlName}`;
+        }
+        return `${parentAlias}.${sqlName}`;
     }
     sqlUnnestPipelineHead(isSingleton, sourceSQLExpression) {
         let p = sourceSQLExpression;
@@ -226,7 +239,7 @@ class SnowflakeDialect extends dialect_1.Dialect {
         return `OBJECT_CONSTRUCT_KEEP_NULL(${alias}.*)`;
     }
     sqlMaybeQuoteIdentifier(identifier) {
-        return `"${identifier}"`;
+        return '"' + identifier.replace(/"/g, '""') + '"';
     }
     sqlCreateTableAsSelect(tableName, sql) {
         return `
@@ -368,14 +381,38 @@ ${(0, utils_1.indent)(sql)}
         return (0, functions_1.expandBlueprintMap)(dialect_functions_1.SNOWFLAKE_DIALECT_FUNCTIONS);
     }
     malloyTypeToSQLType(malloyType) {
-        if (malloyType.type === 'number') {
+        if (malloyType.type === 'string') {
+            return 'VARCHAR';
+        }
+        else if (malloyType.type === 'number') {
             if (malloyType.numberType === 'integer') {
-                return 'integer';
+                return 'INTEGER';
             }
             else {
-                return 'double';
+                return 'DOUBLE';
             }
         }
+        else if (malloyType.type === 'record' ||
+            (malloyType.type === 'array' &&
+                malloyType.elementTypeDef.type === 'record_element')) {
+            const sqlFields = malloyType.fields.reduce((ret, f) => {
+                var _a;
+                if ((0, malloy_types_1.isAtomic)(f)) {
+                    const name = (_a = f.as) !== null && _a !== void 0 ? _a : f.name;
+                    const oneSchema = `${this.sqlMaybeQuoteIdentifier(name)} ${this.malloyTypeToSQLType(f)}`;
+                    ret.push(oneSchema);
+                }
+                return ret;
+            }, []);
+            const recordScehma = `OBJECT(${sqlFields.join(',')})`;
+            return malloyType.type === 'record'
+                ? recordScehma
+                : `ARRAY(${recordScehma})`;
+        }
+        else if (malloyType.type === 'array' &&
+            malloyType.elementTypeDef.type !== 'record_element') {
+            return `ARRAY(${this.malloyTypeToSQLType(malloyType.elementTypeDef)})`;
+        }
         return malloyType.type;
     }
     sqlTypeToMalloyType(sqlType) {
@@ -401,6 +438,25 @@ ${(0, utils_1.indent)(sql)}
         // Square Brackets:      INT64[]
         return sqlType.match(/^[A-Za-z\s(),[\]0-9]*$/) !== null;
     }
+    sqlLiteralRecord(lit) {
+        var _a, _b;
+        const rowVals = [];
+        for (const f of lit.typeDef.fields) {
+            const name = (_a = f.as) !== null && _a !== void 0 ? _a : f.name;
+            const propName = `'${name}'`;
+            const propVal = (_b = lit.kids[name].sql) !== null && _b !== void 0 ? _b : 'internal-error-record-literal';
+            rowVals.push(`${propName},${propVal}`);
+        }
+        return `OBJECT_CONSTRUCT_KEEP_NULL(${rowVals.join(',')})`;
+    }
+    sqlLiteralArray(lit) {
+        const array = lit.kids.values.map(val => val.sql);
+        const arraySchema = `[${array.join(',')}]`;
+        return arraySchema;
+        // return lit.typeDef.elementTypeDef.type === 'record_element'
+        //   ? `${arraySchema}::${this.malloyTypeToSQLType(lit.typeDef)}`
+        //   : arraySchema;
+    }
 }
 exports.SnowflakeDialect = SnowflakeDialect;
 //# sourceMappingURL=snowflake.js.map

package/dist/dialect/standardsql/dialect_functions.js

@@ -3,7 +3,7 @@
  * Copyright (c) Meta Platforms, Inc. and affiliates.
  *
  * This source code is licensed under the MIT license found in the
- *  LICENSE file in the root directory of this source tree.
+ * LICENSE file in the root directory of this source tree.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.STANDARDSQL_DIALECT_FUNCTIONS = void 0;

package/dist/dialect/standardsql/function_overrides.js

@@ -3,7 +3,7 @@
  * Copyright (c) Meta Platforms, Inc. and affiliates.
  *
  * This source code is licensed under the MIT license found in the
- *  LICENSE file in the root directory of this source tree.
+ * LICENSE file in the root directory of this source tree.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.STANDARDSQL_MALLOY_STANDARD_OVERLOADS = void 0;

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

@@ -1,4 +1,4 @@
-import { Sampling, AtomicTypeDef, TimeTruncExpr, TimeExtractExpr, TimeDeltaExpr, TypecastExpr, RegexMatchExpr, TimeLiteralNode, MeasureTimeExpr, LeafAtomicTypeDef } from '../../model/malloy_types';
+import { Sampling, AtomicTypeDef, TimeTruncExpr, TimeExtractExpr, TimeDeltaExpr, TypecastExpr, RegexMatchExpr, TimeLiteralNode, MeasureTimeExpr, LeafAtomicTypeDef, RecordLiteralNode, ArrayLiteralNode } from '../../model/malloy_types';
 import { DialectFunctionOverloadDef } from '../functions';
 import { Dialect, DialectFieldList, QueryInfo } from '../dialect';
 export declare class StandardSQLDialect extends Dialect {
@@ -23,6 +23,7 @@ export declare class StandardSQLDialect extends Dialect {
     supportsNesting: boolean;
     cantPartitionWindowFunctionsOnExpressions: boolean;
     hasModOperator: boolean;
+    nestedArrays: boolean;
     quoteTablePath(tablePath: string): string;
     sqlGroupSetTable(groupSetCount: number): string;
     sqlAnyValue(groupSet: number, fieldName: string): string;
@@ -33,13 +34,12 @@ export declare class StandardSQLDialect extends Dialect {
     sqlUnnestAlias(source: string, alias: string, fieldList: DialectFieldList, needDistinctKey: boolean, isArray: boolean, _isInNestedPipeline: boolean): string;
     sqlSumDistinctHashedKey(sqlDistinctKey: string): string;
     sqlGenerateUUID(): string;
-    sqlFieldReference(alias: string, fieldName: string, _fieldType: string, _isNested: boolean, _isArray: boolean): string;
+    sqlFieldReference(parentAlias: string, _parentType: unknown, childName: string, _childType: string): string;
     sqlUnnestPipelineHead(isSingleton: boolean, sourceSQLExpression: string): string;
     sqlCreateFunction(id: string, funcText: string): string;
     sqlCreateTableAsSelect(tableName: string, sql: string): string;
     sqlCreateFunctionCombineLastStage(lastStageName: string): string;
     sqlSelectAliasAsStruct(alias: string): string;
-    keywords: string[];
     sqlMaybeQuoteIdentifier(identifier: string): string;
     sqlNowExpr(): string;
     sqlTruncExpr(qi: QueryInfo, trunc: TimeTruncExpr): string;
@@ -64,4 +64,6 @@ export declare class StandardSQLDialect extends Dialect {
     castToString(expression: string): string;
     concat(...values: string[]): string;
     validateTypeName(sqlType: string): boolean;
+    sqlLiteralRecord(lit: RecordLiteralNode): string;
+    sqlLiteralArray(lit: ArrayLiteralNode): string;
 }

package/dist/dialect/standardsql/standardsql.js

@@ -97,102 +97,7 @@ class StandardSQLDialect extends dialect_1.Dialect {
         this.supportsNesting = true;
         this.cantPartitionWindowFunctionsOnExpressions = true;
         this.hasModOperator = false;
-        this.keywords = `
-  ALL
-  AND
-  ANY
-  ARRAY
-  AS
-  ASC
-  ASSERT_ROWS_MODIFIED
-  AT
-  BETWEEN
-  BY
-  CASE
-  CAST
-  COLLATE
-  CONTAINS
-  CREATE
-  CROSS
-  CUBE
-  CURRENT
-  DEFAULT
-  DEFINE
-  DESC
-  DISTINCT
-  ELSE
-  END
-  ENUM
-  ESCAPE
-  EXCEPT
-  EXCLUDE
-  EXISTS
-  EXTRACT
-  FALSE
-  FETCH
-  FOLLOWING
-  FOR
-  FROM
-  FULL
-  GROUP
-  GROUPING
-  GROUPS
-  HASH
-  HAVING
-  IF
-  IGNORE
-  IN
-  INNER
-  INTERSECT
-  INTERVAL
-  INTO
-  IS
-  JOIN
-  LATERAL
-  LEFT
-  LIKE
-  LIMIT
-  LOOKUP
-  MERGE
-  NATURAL
-  NEW
-  NO
-  NOT
-  NULL
-  NULLS
-  OF
-  ON
-  OR
-  ORDER
-  OUTER
-  OVER
-  PARTITION
-  PRECEDING
-  PROTO
-  RANGE
-  RECURSIVE
-  RESPECT
-  RIGHT
-  ROLLUP
-  ROWS
-  SELECT
-  SET
-  SOME
-  STRUCT
-  TABLESAMPLE
-  THEN
-  TO
-  TREAT
-  TRUE
-  UNBOUNDED
-  UNION
-  UNNEST
-  USING
-  WHEN
-  WHERE
-  WINDOW
-  WITH
-  WITHIN`.split(/\s/);
+        this.nestedArrays = false; // Can't have an array of arrays for some reason
     }
     quoteTablePath(tablePath) {
         return `\`${tablePath}\``;
@@ -266,8 +171,9 @@ class StandardSQLDialect extends dialect_1.Dialect {
     sqlGenerateUUID() {
         return 'GENERATE_UUID()';
     }
-    sqlFieldReference(alias, fieldName, _fieldType, _isNested, _isArray) {
-        return `${alias}.${fieldName}`;
+    sqlFieldReference(parentAlias, _parentType, childName, _childType) {
+        const child = this.sqlMaybeQuoteIdentifier(childName);
+        return `${parentAlias}.${child}`;
     }
     sqlUnnestPipelineHead(isSingleton, sourceSQLExpression) {
         let p = sourceSQLExpression;
@@ -297,9 +203,6 @@ ${(0, utils_1.indent)(sql)}
         return `(SELECT AS STRUCT ${alias}.*)`;
     }
     sqlMaybeQuoteIdentifier(identifier) {
-        // return this.keywords.indexOf(identifier.toUpperCase()) > 0
-        //   ? '`' + identifier + '`'
-        //   : identifier;
         return '`' + identifier + '`';
     }
     sqlNowExpr() {
@@ -479,6 +382,18 @@ ${(0, utils_1.indent)(sql)}
         // Angle Brackets:       ARRAY<INT64>
         return sqlType.match(/^[A-Za-z\s(),<>0-9]*$/) !== null;
     }
+    sqlLiteralRecord(lit) {
+        const ents = [];
+        for (const [name, val] of Object.entries(lit.kids)) {
+            const expr = val.sql || 'internal-error-literal-record';
+            ents.push(`${expr} AS ${this.sqlMaybeQuoteIdentifier(name)}`);
+        }
+        return `STRUCT(${ents.join(',')})`;
+    }
+    sqlLiteralArray(lit) {
+        const array = lit.kids.values.map(val => val.sql);
+        return '[' + array.join(',') + ']';
+    }
 }
 exports.StandardSQLDialect = StandardSQLDialect;
 //# sourceMappingURL=standardsql.js.map

package/dist/dialect/tiny_parser.d.ts

@@ -0,0 +1,41 @@
+export interface TinyToken {
+    type: string;
+    text: string;
+}
+/**
+ * Simple framework for writing schema parsers. The parsers using this felt
+ * better than the more ad-hoc code they replaced, and are smaller than
+ * using a parser generator.
+ *
+ * NOTE: All parse errors are exceptions.
+ */
+export declare class TinyParser {
+    readonly input: string;
+    private tokens;
+    private parseCursor;
+    private lookAhead?;
+    private tokenMap;
+    /**
+     * The token map is tested in order. Return TinyToken
+     * is {type: tokenMapKey, text: matchingText }, except
+     * for the special tokenMapKeys:
+     * * space: skipped and never returned
+     * * char: matched string return in both .type and .text
+     * * q*: any token name starting with 'q' is assumed to be
+     *   a quoted string and the text will have the first and
+     *   last characters stripped
+     */
+    constructor(input: string, tokenMap?: Record<string, RegExp>);
+    parseError(str: string): Error;
+    peek(): TinyToken;
+    private getNext;
+    /**
+     * Return next token, if any token types are passed, read and require those
+     * tokens, then return the last one.
+     * @param types list of token types
+     * @returns The last token read
+     */
+    next(...types: string[]): TinyToken;
+    skipTo(type: string): void;
+    private tokenize;
+}

package/dist/dialect/tiny_parser.js

@@ -0,0 +1,126 @@
+"use strict";
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TinyParser = void 0;
+/**
+ * Simple framework for writing schema parsers. The parsers using this felt
+ * better than the more ad-hoc code they replaced, and are smaller than
+ * using a parser generator.
+ *
+ * NOTE: All parse errors are exceptions.
+ */
+class TinyParser {
+    /**
+     * The token map is tested in order. Return TinyToken
+     * is {type: tokenMapKey, text: matchingText }, except
+     * for the special tokenMapKeys:
+     * * space: skipped and never returned
+     * * char: matched string return in both .type and .text
+     * * q*: any token name starting with 'q' is assumed to be
+     *   a quoted string and the text will have the first and
+     *   last characters stripped
+     */
+    constructor(input, tokenMap) {
+        this.input = input;
+        this.parseCursor = 0;
+        this.tokens = this.tokenize(input);
+        this.tokenMap = tokenMap !== null && tokenMap !== void 0 ? tokenMap : {
+            space: /^\s+/,
+            char: /^[,:[\]()-]/,
+            id: /^\w+/,
+            qstr: /^"\w+"/,
+        };
+    }
+    parseError(str) {
+        const errText = `INTERNAL ERROR parsing schema: ${str}\n` +
+            `${this.input}\n` +
+            `${' '.repeat(this.parseCursor)}^`;
+        return new Error(errText);
+    }
+    peek() {
+        if (this.lookAhead) {
+            return this.lookAhead;
+        }
+        else {
+            const { value } = this.tokens.next();
+            const peekVal = value !== null && value !== void 0 ? value : { type: 'eof', text: '' };
+            this.lookAhead = peekVal;
+            return peekVal;
+        }
+    }
+    getNext() {
+        var _a;
+        const next = (_a = this.lookAhead) !== null && _a !== void 0 ? _a : this.peek();
+        this.lookAhead = undefined;
+        return next;
+    }
+    /**
+     * Return next token, if any token types are passed, read and require those
+     * tokens, then return the last one.
+     * @param types list of token types
+     * @returns The last token read
+     */
+    next(...types) {
+        if (types.length === 0)
+            return this.getNext();
+        let next = undefined;
+        let expected = types[0];
+        for (const typ of types) {
+            next = this.getNext();
+            expected = typ;
+            if (next.type !== typ) {
+                next = undefined;
+                break;
+            }
+        }
+        if (next)
+            return next;
+        throw this.parseError(`Expected ${expected}`);
+    }
+    skipTo(type) {
+        for (;;) {
+            const next = this.next();
+            if (next.type === 'eof') {
+                throw this.parseError(`Expected token '${type}`);
+            }
+            if (next.type === type) {
+                return;
+            }
+        }
+    }
+    *tokenize(src) {
+        const tokenList = this.tokenMap;
+        while (this.parseCursor < src.length) {
+            let notFound = true;
+            for (const tokenType in tokenList) {
+                const srcAtCursor = src.slice(this.parseCursor);
+                const foundToken = srcAtCursor.match(tokenList[tokenType]);
+                if (foundToken) {
+                    notFound = false;
+                    let tokenText = foundToken[0];
+                    this.parseCursor += tokenText.length;
+                    if (tokenType !== 'space') {
+                        if (tokenType[0] === 'q') {
+                            tokenText = tokenText.slice(1, -1); // strip quotes
+                        }
+                        yield {
+                            type: tokenType === 'char' ? tokenText : tokenType,
+                            text: tokenText,
+                        };
+                    }
+                }
+            }
+            if (notFound) {
+                yield { type: 'unexpected token', text: src };
+                return;
+            }
+        }
+    }
+}
+exports.TinyParser = TinyParser;
+//# sourceMappingURL=tiny_parser.js.map

package/dist/dialect/trino/dialect_functions.js

@@ -3,7 +3,7 @@
  * Copyright (c) Meta Platforms, Inc. and affiliates.
  *
  * This source code is licensed under the MIT license found in the
- *  LICENSE file in the root directory of this source tree.
+ * LICENSE file in the root directory of this source tree.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TRINO_DIALECT_FUNCTIONS = void 0;

package/dist/dialect/trino/function_overrides.js

@@ -3,7 +3,7 @@
  * Copyright (c) Meta Platforms, Inc. and affiliates.
  *
  * This source code is licensed under the MIT license found in the
- *  LICENSE file in the root directory of this source tree.
+ * LICENSE file in the root directory of this source tree.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TRINO_MALLOY_STANDARD_OVERLOADS = void 0;

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

@@ -1,4 +1,4 @@
-import { Expr, Sampling, AtomicTypeDef, TimeDeltaExpr, TypecastExpr, RegexMatchExpr, MeasureTimeExpr, TimeLiteralNode, TimeExtractExpr, LeafAtomicTypeDef } from '../../model/malloy_types';
+import { Expr, Sampling, AtomicTypeDef, TimeDeltaExpr, TypecastExpr, RegexMatchExpr, MeasureTimeExpr, TimeLiteralNode, TimeExtractExpr, LeafAtomicTypeDef, RecordLiteralNode } from '../../model/malloy_types';
 import { DialectFunctionOverloadDef } from '../functions';
 import { DialectFieldList, OrderByClauseType, QueryInfo } from '../dialect';
 import { PostgresBase } from '../pg_impl';
@@ -43,14 +43,13 @@ export declare class TrinoDialect extends PostgresBase {
     sqlSumDistinctHashedKey(sqlDistinctKey: string): string;
     sqlSumDistinct(key: string, value: string, funcName: string): string;
     sqlGenerateUUID(): string;
-    sqlFieldReference(alias: string, fieldName: string, _fieldType: string, _isNested: boolean, _isArray: boolean): string;
+    sqlFieldReference(parentAlias: string, _parentType: unknown, childName: string, _childType: string): string;
     sqlUnnestPipelineHead(isSingleton: boolean, sourceSQLExpression: string): string;
     sqlCreateFunction(id: string, funcText: string): string;
     sqlCreateTableAsSelect(tableName: string, sql: string): string;
     sqlCreateFunctionCombineLastStage(lastStageName: string, fieldList: DialectFieldList): string;
     sqlSelectAliasAsStruct(alias: string, fieldList: any): string;
     keywords: string[];
-    sqlMaybeQuoteIdentifier(identifier: string): string;
     sqlAlterTimeExpr(df: TimeDeltaExpr): string;
     sqlCast(qi: QueryInfo, cast: TypecastExpr): string;
     sqlRegexpMatch(reCmp: RegexMatchExpr): string;
@@ -73,6 +72,7 @@ export declare class TrinoDialect extends PostgresBase {
     validateTypeName(sqlType: string): boolean;
     sqlLiteralTime(qi: QueryInfo, lit: TimeLiteralNode): string;
     sqlTimeExtractExpr(qi: QueryInfo, from: TimeExtractExpr): string;
+    sqlLiteralRecord(lit: RecordLiteralNode): string;
 }
 export declare class PrestoDialect extends TrinoDialect {
     name: string;

package/dist/dialect/trino/trino.js

@@ -312,12 +312,12 @@ class TrinoDialect extends pg_impl_1.PostgresBase {
     sqlGenerateUUID() {
         return 'UUID()';
     }
-    sqlFieldReference(alias, fieldName, _fieldType, _isNested, _isArray) {
+    sqlFieldReference(parentAlias, _parentType, childName, _childType) {
         // LTNOTE: hack, in duckdb we can't have structs as tables so we kind of simulate it.
-        if (fieldName === '__row_id') {
-            return `__row_id_from_${alias}`;
+        if (childName === '__row_id') {
+            return `__row_id_from_${parentAlias}`;
         }
-        return `${alias}.${this.sqlMaybeQuoteIdentifier(fieldName)}`;
+        return `${parentAlias}.${this.sqlMaybeQuoteIdentifier(childName)}`;
     }
     sqlUnnestPipelineHead(isSingleton, sourceSQLExpression) {
         let p = sourceSQLExpression;
@@ -350,9 +350,6 @@ ${(0, utils_1.indent)(sql)}
         const definitions = this.buildTypeExpression(fieldList);
         return `CAST(ROW(${fields}) as ROW(${definitions})`;
     }
-    sqlMaybeQuoteIdentifier(identifier) {
-        return '"' + identifier + '"';
-    }
     sqlAlterTimeExpr(df) {
         let timeframe = df.units;
         let n = df.kids.delta.sql;
@@ -450,18 +447,31 @@ ${(0, utils_1.indent)(sql)}
         return (0, functions_1.expandBlueprintMap)(dialect_functions_1.TRINO_DIALECT_FUNCTIONS);
     }
     malloyTypeToSQLType(malloyType) {
-        if (malloyType.type === 'number') {
-            if (malloyType.numberType === 'integer') {
-                return 'BIGINT';
+        switch (malloyType.type) {
+            case 'number':
+                return malloyType.numberType === 'integer' ? 'BIGINT' : 'DOUBLE';
+            case 'string':
+                return 'VARCHAR';
+            case 'record': {
+                const typeSpec = [];
+                for (const f of malloyType.fields) {
+                    if ((0, malloy_types_1.isAtomic)(f)) {
+                        typeSpec.push(`${f.name} ${this.malloyTypeToSQLType(f)}`);
+                    }
+                }
+                return `ROW(${typeSpec.join(',')})`;
             }
-            else {
-                return 'DOUBLE';
+            case 'sql native':
+                return malloyType.rawType || 'UNKNOWN-NATIVE';
+            case 'array': {
+                if (malloyType.elementTypeDef.type !== 'record_element') {
+                    return `ARRAY<${this.malloyTypeToSQLType(malloyType.elementTypeDef)}>`;
+                }
+                return malloyType.type.toUpperCase();
             }
+            default:
+                return malloyType.type.toUpperCase();
         }
-        else if (malloyType.type === 'string') {
-            return 'VARCHAR';
-        }
-        return malloyType.type;
     }
     sqlTypeToMalloyType(sqlType) {
         var _a, _b, _c;
@@ -514,6 +524,20 @@ ${(0, utils_1.indent)(sql)}
         const extracted = `EXTRACT(${pgUnits} FROM ${extractFrom})`;
         return from.units === 'day_of_week' ? `mod(${extracted}+1,7)` : extracted;
     }
+    sqlLiteralRecord(lit) {
+        var _a, _b;
+        const rowVals = [];
+        const rowTypes = [];
+        for (const f of lit.typeDef.fields) {
+            if ((0, malloy_types_1.isAtomic)(f)) {
+                const name = (_a = f.as) !== null && _a !== void 0 ? _a : f.name;
+                rowVals.push((_b = lit.kids[name].sql) !== null && _b !== void 0 ? _b : 'internal-error-record-literal');
+                const elType = this.malloyTypeToSQLType(f);
+                rowTypes.push(`${name} ${elType}`);
+            }
+        }
+        return `CAST(ROW(${rowVals.join(',')}) AS ROW(${rowTypes.join(',')}))`;
+    }
 }
 exports.TrinoDialect = TrinoDialect;
 TrinoDialect.dtype = 'DECIMAL(38,0)';

package/dist/index.d.ts

@@ -1,6 +1,6 @@
-export { DuckDBDialect, StandardSQLDialect, TrinoDialect, PostgresDialect, SnowflakeDialect, MySQLDialect, registerDialect, arg, qtz, overload, minScalar, anyExprType, minAggregate, maxScalar, sql, makeParam, param, variadicParam, literal, spread, Dialect, } from './dialect';
-export type { DialectFieldList, DialectFunctionOverloadDef, QueryInfo, MalloyStandardFunctionImplementations, DefinitionBlueprint, DefinitionBlueprintMap, OverloadedDefinitionBlueprint, } from './dialect';
-export type { QueryDataRow, StructDef, TableSourceDef, SQLSourceDef, SourceDef, JoinFieldDef, NamedSourceDefs, MalloyQueryData, DateUnit, ExtractUnit, TimestampUnit, TemporalFieldType, QueryData, QueryValue, Expr, FilterCondition, SQLSentence, 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, } from './model';
+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, SQLSentence, 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 { arrayEachFields, isRepeatedRecord, isSourceDef, Segment, isLeafAtomic, isJoined, isJoinedSource, isSamplingEnable, isSamplingPercent, isSamplingRows, expressionIsAggregate, expressionIsAnalytic, expressionIsCalculation, expressionIsScalar, expressionIsUngroupedAggregate, indent, composeSQLExpr, } from './model';
 export { MalloyTranslator, } from './lang';
 export type { LogMessage, TranslateResponse } from './lang';