@malloydata/malloy 0.0.195-dev241003204819 → 0.0.195-dev241007154000

package/dist/connection/base_connection.d.ts

@@ -1,21 +1,35 @@
-import { MalloyQueryData, QueryRunStats, SQLBlock, StructDef } from '../model/malloy_types';
+import { MalloyQueryData, QueryRunStats, SQLSourceDef, StructDef, TableSourceDef } from '../model/malloy_types';
 import { RunSQLOptions } from '../run_sql_options';
 import { Connection, FetchSchemaOptions, PersistSQLResults, PooledConnection, StreamingConnection } from './types';
+export interface SchemaFound<T extends StructDef> {
+    schema: T;
+    error?: undefined;
+    timestamp: number;
+}
+export interface SchemaNotFound {
+    schema?: undefined;
+    error: string;
+}
+export type CachedSchema<T extends StructDef> = SchemaFound<T> | SchemaNotFound;
 export declare abstract class BaseConnection implements Connection {
     abstract runSQL(sql: string, options?: RunSQLOptions | undefined): Promise<MalloyQueryData>;
     abstract get name(): string;
     abstract get dialectName(): string;
-    abstract fetchSchemaForSQLBlock(block: SQLBlock, options: FetchSchemaOptions): Promise<{
-        structDef: StructDef;
+    abstract fetchTableSchema(tableName: string, tablePath: string): Promise<TableSourceDef | string>;
+    abstract fetchSelectSchema(sqlSource: SQLSourceDef): Promise<SQLSourceDef | string>;
+    protected schemaCache: Record<string, CachedSchema<StructDef>>;
+    protected checkSchemaCache<T extends StructDef>(schemaKey: string, schemaType: 'table' | 'sql_select', fillCache: () => Promise<T | string>, refreshTimestamp: number | undefined): Promise<CachedSchema<T>>;
+    fetchSchemaForTables(missing: Record<string, string>, { refreshTimestamp }: FetchSchemaOptions): Promise<{
+        schemas: Record<string, TableSourceDef>;
+        errors: Record<string, string>;
+    }>;
+    fetchSchemaForSQLStruct(sqlRef: SQLSourceDef, { refreshTimestamp }: FetchSchemaOptions): Promise<{
+        structDef: SQLSourceDef;
         error?: undefined;
     } | {
         error: string;
         structDef?: undefined;
     }>;
-    abstract fetchSchemaForTables(tables: Record<string, string>, options: FetchSchemaOptions): Promise<{
-        schemas: Record<string, StructDef>;
-        errors: Record<string, string>;
-    }>;
     isPool(): this is PooledConnection;
     canPersist(): this is PersistSQLResults;
     canStream(): this is StreamingConnection;

package/dist/connection/base_connection.js

@@ -1,7 +1,69 @@
 "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.BaseConnection = void 0;
 class BaseConnection {
+    constructor() {
+        this.schemaCache = {};
+    }
+    async checkSchemaCache(schemaKey, schemaType, fillCache, refreshTimestamp) {
+        let cached = this.schemaCache[schemaKey];
+        if (!cached ||
+            (cached.schema && refreshTimestamp && refreshTimestamp > cached.timestamp)) {
+            try {
+                const cacheResponse = await fillCache();
+                if (typeof cacheResponse === 'string') {
+                    cached = { error: cacheResponse };
+                }
+                else {
+                    cached = {
+                        schema: cacheResponse,
+                        timestamp: refreshTimestamp !== null && refreshTimestamp !== void 0 ? refreshTimestamp : Date.now(),
+                    };
+                }
+            }
+            catch (uncaught) {
+                cached = { error: uncaught.message };
+            }
+            this.schemaCache[schemaKey] = cached;
+        }
+        if (cached.error) {
+            return cached;
+        }
+        if (cached.schema && cached.schema.type === schemaType) {
+            return { ...cached, schema: cached.schema };
+        }
+        return { error: 'Wrong type found in schema cache' };
+    }
+    async fetchSchemaForTables(missing, { refreshTimestamp }) {
+        const schemas = {};
+        const errors = {};
+        for (const [tableName, tablePath] of Object.entries(missing)) {
+            const inCache = await this.checkSchemaCache(tablePath, 'table', async () => await this.fetchTableSchema(tableName, tablePath), refreshTimestamp);
+            if (inCache.schema) {
+                schemas[tableName] = inCache.schema;
+            }
+            if (inCache.error) {
+                errors[tableName] = inCache.error;
+            }
+        }
+        return { schemas, errors };
+    }
+    async fetchSchemaForSQLStruct(sqlRef, { refreshTimestamp }) {
+        const inCache = await this.checkSchemaCache(sqlRef.name, 'sql_select', async () => await this.fetchSelectSchema(sqlRef), refreshTimestamp);
+        if (inCache.schema) {
+            return { structDef: inCache.schema };
+        }
+        if (inCache.error) {
+            return { error: inCache.error };
+        }
+        return { error: 'Unknown schema fetch error' };
+    }
     isPool() {
         return false;
     }

package/dist/connection/types.d.ts

@@ -1,5 +1,5 @@
 import { RunSQLOptions } from '../run_sql_options';
-import { Annotation, MalloyQueryData, QueryDataRow, QueryRunStats, SQLBlock, StructDef } from '../model/malloy_types';
+import { Annotation, MalloyQueryData, QueryDataRow, QueryRunStats, SQLSourceDef, TableSourceDef } from '../model/malloy_types';
 import { Dialect } from '../dialect';
 /**
  * Options passed to fetchSchema methods.
@@ -20,7 +20,7 @@ export interface InfoConnection {
      * @return A mapping of table keys to schemas.
      */
     fetchSchemaForTables(tables: Record<string, string>, options: FetchSchemaOptions): Promise<{
-        schemas: Record<string, StructDef>;
+        schemas: Record<string, TableSourceDef>;
         errors: Record<string, string>;
     }>;
     /**
@@ -29,8 +29,8 @@ export interface InfoConnection {
      * @param block The SQL blocks to fetch schemas for.
      * @return A mapping of SQL block names to schemas.
      */
-    fetchSchemaForSQLBlock(block: SQLBlock, options: FetchSchemaOptions): Promise<{
-        structDef: StructDef;
+    fetchSchemaForSQLStruct(sentence: SQLSourceDef, options: FetchSchemaOptions): Promise<{
+        structDef: SQLSourceDef;
         error?: undefined;
     } | {
         error: string;
@@ -40,6 +40,7 @@ export interface InfoConnection {
      * The name of the connection.
      */
     get name(): string;
+    get dialectName(): string;
 }
 export type ConnectionParameterValue = string | number | boolean | Array<ConnectionParameterValue>;
 export interface ConnectionParameter {
@@ -84,7 +85,6 @@ export interface Connection extends InfoConnection {
     canStream(): this is StreamingConnection;
     close(): Promise<void>;
     estimateQueryCost(sqlCommand: string): Promise<QueryRunStats>;
-    get dialectName(): string;
     fetchMetadata: () => Promise<ConnectionMetadata>;
     fetchTableMetadata: (tablePath: string) => Promise<TableMetadata>;
 }

package/dist/dialect/dialect.d.ts

@@ -1,4 +1,4 @@
-import { Expr, Sampling, FieldAtomicTypeDef, MeasureTimeExpr, TimeTruncExpr, TimeExtractExpr, TimeDeltaExpr, TypecastExpr, RegexMatchExpr, TimeLiteralNode } from '../model/malloy_types';
+import { Expr, Sampling, AtomicTypeDef, MeasureTimeExpr, TimeTruncExpr, TimeExtractExpr, TimeDeltaExpr, TypecastExpr, RegexMatchExpr, TimeLiteralNode, RecordLiteralNode, ArrayLiteralNode, LeafAtomicDef } from '../model/malloy_types';
 import { DialectFunctionOverloadDef } from './functions';
 type DialectFieldTypes = string | 'struct';
 interface DialectField {
@@ -98,6 +98,8 @@ export declare abstract class Dialect {
     abstract sqlLiteralString(literal: string): string;
     abstract sqlLiteralRegexp(literal: string): string;
     abstract sqlRegexpMatch(df: RegexMatchExpr): string;
+    sqlLiteralArray(lit: ArrayLiteralNode): string;
+    sqlLiteralRecord(lit: RecordLiteralNode): string;
     /**
      * The dialect has a chance to over-ride how expressions are translated. If
      * "undefined" is returned then the translation is left to the query translator.
@@ -116,8 +118,8 @@ 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): FieldAtomicTypeDef | undefined;
-    abstract malloyTypeToSQLType(malloyType: FieldAtomicTypeDef): string;
+    abstract sqlTypeToMalloyType(sqlType: string): LeafAtomicDef;
+    abstract malloyTypeToSQLType(malloyType: AtomicTypeDef): string;
     abstract validateTypeName(sqlType: string): boolean;
 }
 export {};

package/dist/dialect/dialect.js

@@ -97,6 +97,17 @@ class Dialect {
     ignoreInProject(_fieldName) {
         return false;
     }
+    // abstract sqlLiteralRecord(lit: RecordLiteralNode): string;
+    // abstract sqlLiteralArray(lit: ArrayLiteralNode): string;
+    // SHOULD BE ABSTRACT BUT A PLACEHOLDER FOR NOW
+    sqlLiteralArray(lit) {
+        const array = lit.kids.values.map(val => val.sql);
+        return '[' + array.join(',') + ']';
+    }
+    sqlLiteralRecord(lit) {
+        const pairs = Object.entries(lit.kids).map(([propName, propVal]) => `${this.sqlMaybeQuoteIdentifier(propName)}:${propVal.sql}`);
+        return '{' + pairs.join(',') + '}';
+    }
     /**
      * The dialect has a chance to over-ride how expressions are translated. If
      * "undefined" is returned then the translation is left to the query translator.
@@ -143,6 +154,10 @@ class Dialect {
                 return this.sqlLiteralNumber(df.literal);
             case 'regexpLiteral':
                 return this.sqlLiteralRegexp(df.literal);
+            case 'recordLiteral':
+                return this.sqlLiteralRecord(df);
+            case 'arrayLiteral':
+                return this.sqlLiteralArray(df);
         }
     }
     sqlSumDistinct(_key, _value, _funcName) {

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

@@ -1,4 +1,4 @@
-import { Sampling, FieldAtomicTypeDef, TimeDeltaExpr, RegexMatchExpr, MeasureTimeExpr } from '../../model/malloy_types';
+import { Sampling, AtomicTypeDef, TimeDeltaExpr, RegexMatchExpr, MeasureTimeExpr, LeafAtomicDef } from '../../model/malloy_types';
 import { DialectFunctionOverloadDef } from '../functions';
 import { DialectFieldList } from '../dialect';
 import { PostgresBase } from '../pg_impl';
@@ -55,8 +55,8 @@ export declare class DuckDBDialect extends PostgresBase {
     getDialectFunctions(): {
         [name: string]: DialectFunctionOverloadDef[];
     };
-    malloyTypeToSQLType(malloyType: FieldAtomicTypeDef): string;
-    sqlTypeToMalloyType(sqlType: string): FieldAtomicTypeDef | undefined;
+    malloyTypeToSQLType(malloyType: AtomicTypeDef): string;
+    sqlTypeToMalloyType(sqlType: string): LeafAtomicDef;
     castToString(expression: string): string;
     concat(...values: string[]): string;
     validateTypeName(sqlType: string): boolean;

package/dist/dialect/duckdb/duckdb.js

@@ -283,10 +283,15 @@ class DuckDBDialect extends pg_impl_1.PostgresBase {
         return malloyType.type;
     }
     sqlTypeToMalloyType(sqlType) {
-        var _a, _b;
+        var _a, _b, _c;
+        // Remove decimal precision
+        const ddbType = sqlType.replace(/^DECIMAL\(\d+,\d+\)/g, 'DECIMAL');
         // Remove trailing params
-        const baseSqlType = (_b = (_a = sqlType.match(/^(\w+)/)) === null || _a === void 0 ? void 0 : _a.at(0)) !== null && _b !== void 0 ? _b : sqlType;
-        return duckDBToMalloyTypes[baseSqlType.toUpperCase()];
+        const baseSqlType = (_b = (_a = ddbType.match(/^(\w+)/)) === null || _a === void 0 ? void 0 : _a.at(0)) !== null && _b !== void 0 ? _b : ddbType;
+        return ((_c = duckDBToMalloyTypes[baseSqlType.toUpperCase()]) !== null && _c !== void 0 ? _c : {
+            type: 'sql native',
+            rawType: sqlType.toLowerCase(),
+        });
     }
     castToString(expression) {
         return `CAST(${expression} as VARCHAR)`;

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

@@ -1,4 +1,4 @@
-import { Sampling, FieldAtomicTypeDef, TimeDeltaExpr, TypecastExpr, MeasureTimeExpr } from '../../model/malloy_types';
+import { Sampling, AtomicTypeDef, TimeDeltaExpr, TypecastExpr, MeasureTimeExpr, LeafAtomicDef } from '../../model/malloy_types';
 import { DialectFunctionOverloadDef } from '../functions';
 import { DialectFieldList, QueryInfo } from '../dialect';
 import { PostgresBase } from '../pg_impl';
@@ -58,8 +58,8 @@ export declare class PostgresDialect extends PostgresBase {
     getDialectFunctions(): {
         [name: string]: DialectFunctionOverloadDef[];
     };
-    malloyTypeToSQLType(malloyType: FieldAtomicTypeDef): string;
-    sqlTypeToMalloyType(sqlType: string): FieldAtomicTypeDef | undefined;
+    malloyTypeToSQLType(malloyType: AtomicTypeDef): string;
+    sqlTypeToMalloyType(sqlType: string): LeafAtomicDef;
     castToString(expression: string): string;
     concat(...values: string[]): string;
     validateTypeName(sqlType: string): boolean;

package/dist/dialect/postgres/postgres.js

@@ -340,10 +340,13 @@ class PostgresDialect extends pg_impl_1.PostgresBase {
         return malloyType.type;
     }
     sqlTypeToMalloyType(sqlType) {
-        var _a, _b;
+        var _a, _b, _c;
         // Remove trailing params
         const baseSqlType = (_b = (_a = sqlType.match(/^([\w\s]+)/)) === null || _a === void 0 ? void 0 : _a.at(0)) !== null && _b !== void 0 ? _b : sqlType;
-        return postgresToMalloyTypes[baseSqlType.trim().toLowerCase()];
+        return ((_c = postgresToMalloyTypes[baseSqlType.trim().toLowerCase()]) !== null && _c !== void 0 ? _c : {
+            type: 'sql native',
+            rawType: sqlType,
+        });
     }
     castToString(expression) {
         return `CAST(${expression} as VARCHAR)`;

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

@@ -1,4 +1,4 @@
-import { Sampling, FieldAtomicTypeDef, TimeTruncExpr, TimeExtractExpr, TimeDeltaExpr, TypecastExpr, TimeLiteralNode, MeasureTimeExpr, RegexMatchExpr } from '../../model/malloy_types';
+import { Sampling, AtomicTypeDef, TimeTruncExpr, TimeExtractExpr, TimeDeltaExpr, TypecastExpr, TimeLiteralNode, MeasureTimeExpr, RegexMatchExpr, LeafAtomicDef } from '../../model/malloy_types';
 import { DialectFunctionOverloadDef } from '../functions';
 import { Dialect, DialectFieldList, QueryInfo } from '../dialect';
 export declare class SnowflakeDialect extends Dialect {
@@ -62,8 +62,8 @@ export declare class SnowflakeDialect extends Dialect {
     getDialectFunctions(): {
         [name: string]: DialectFunctionOverloadDef[];
     };
-    malloyTypeToSQLType(malloyType: FieldAtomicTypeDef): string;
-    sqlTypeToMalloyType(sqlType: string): FieldAtomicTypeDef | undefined;
+    malloyTypeToSQLType(malloyType: AtomicTypeDef): string;
+    sqlTypeToMalloyType(sqlType: string): LeafAtomicDef;
     castToString(expression: string): string;
     concat(...values: string[]): string;
     validateTypeName(sqlType: string): boolean;

package/dist/dialect/snowflake/snowflake.js

@@ -387,7 +387,10 @@ ${(0, utils_1.indent)(sql)}
         var _a, _b;
         // Remove trailing params
         const baseSqlType = (_b = (_a = sqlType.match(/^([\w\s]+)/)) === null || _a === void 0 ? void 0 : _a.at(0)) !== null && _b !== void 0 ? _b : sqlType;
-        return snowflakeToMalloyTypes[baseSqlType.trim().toLowerCase()];
+        return (snowflakeToMalloyTypes[baseSqlType.trim().toLowerCase()] || {
+            type: 'sql native',
+            rawType: sqlType,
+        });
     }
     castToString(expression) {
         return `TO_VARCHAR(${expression})`;

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

@@ -1,4 +1,4 @@
-import { Sampling, FieldAtomicTypeDef, TimeTruncExpr, TimeExtractExpr, TimeDeltaExpr, TypecastExpr, RegexMatchExpr, TimeLiteralNode, MeasureTimeExpr } from '../../model/malloy_types';
+import { Sampling, AtomicTypeDef, TimeTruncExpr, TimeExtractExpr, TimeDeltaExpr, TypecastExpr, RegexMatchExpr, TimeLiteralNode, MeasureTimeExpr, LeafAtomicDef } from '../../model/malloy_types';
 import { DialectFunctionOverloadDef } from '../functions';
 import { Dialect, DialectFieldList, QueryInfo } from '../dialect';
 export declare class StandardSQLDialect extends Dialect {
@@ -59,8 +59,8 @@ export declare class StandardSQLDialect extends Dialect {
     getDialectFunctions(): {
         [name: string]: DialectFunctionOverloadDef[];
     };
-    malloyTypeToSQLType(malloyType: FieldAtomicTypeDef): string;
-    sqlTypeToMalloyType(sqlType: string): FieldAtomicTypeDef | undefined;
+    malloyTypeToSQLType(malloyType: AtomicTypeDef): string;
+    sqlTypeToMalloyType(sqlType: string): LeafAtomicDef;
     castToString(expression: string): string;
     concat(...values: string[]): string;
     validateTypeName(sqlType: string): boolean;

package/dist/dialect/standardsql/standardsql.js

@@ -460,10 +460,13 @@ ${(0, utils_1.indent)(sql)}
         return malloyType.type;
     }
     sqlTypeToMalloyType(sqlType) {
-        var _a, _b;
+        var _a, _b, _c;
         // Remove trailing params
         const baseSqlType = (_b = (_a = sqlType.match(/^(\w+)/)) === null || _a === void 0 ? void 0 : _a.at(0)) !== null && _b !== void 0 ? _b : sqlType;
-        return bqToMalloyTypes[baseSqlType.toUpperCase()];
+        return ((_c = bqToMalloyTypes[baseSqlType.toUpperCase()]) !== null && _c !== void 0 ? _c : {
+            type: 'sql native',
+            rawType: sqlType.toLowerCase(),
+        });
     }
     castToString(expression) {
         return `CAST(${expression} as STRING)`;

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

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

package/dist/dialect/trino/trino.js

@@ -54,6 +54,34 @@ const trinoTypeMap = {
     'string': 'VARCHAR',
     'number': 'DOUBLE',
 };
+const trinoToMalloyTypes = {
+    'varchar': { type: 'string' },
+    'integer': { type: 'number', numberType: 'integer' },
+    'bigint': { type: 'number', numberType: 'integer' },
+    'smallint': { type: 'number', numberType: 'integer' },
+    'tinyint': { type: 'number', numberType: 'integer' },
+    'double': { type: 'number', numberType: 'float' },
+    'decimal': { type: 'number', numberType: 'float' },
+    'string': { type: 'string' },
+    'date': { type: 'date' },
+    'timestamp': { type: 'timestamp' },
+    'boolean': { type: 'boolean' },
+    // TODO(figutierrez0): cleanup.
+    /* 'INT64': {type: 'number', numberType: 'integer'},
+    'FLOAT': {type: 'number', numberType: 'float'},
+    'FLOAT64': {type: 'number', numberType: 'float'},
+    'NUMERIC': {type: 'number', numberType: 'float'},
+    'BIGNUMERIC': {type: 'number', numberType: 'float'},
+    'TIMESTAMP': {type: 'timestamp'},
+    'BOOLEAN': {type: 'boolean'},
+    'BOOL': {type: 'boolean'},
+    'JSON': {type: 'json'},*/
+    // TODO (https://cloud.google.com/bigquery/docs/reference/rest/v2/tables#tablefieldschema):
+    // BYTES
+    // DATETIME
+    // TIME
+    // GEOGRAPHY
+};
 class TrinoDialect extends pg_impl_1.PostgresBase {
     constructor() {
         super(...arguments);
@@ -438,9 +466,13 @@ ${(0, utils_1.indent)(sql)}
         }
         return malloyType.type;
     }
-    sqlTypeToMalloyType(_sqlType) {
-        // TODO(figutierrez): unimplemented.
-        return undefined;
+    sqlTypeToMalloyType(sqlType) {
+        var _a, _b, _c;
+        const baseSqlType = (_b = (_a = sqlType.match(/^(\w+)/)) === null || _a === void 0 ? void 0 : _a.at(0)) !== null && _b !== void 0 ? _b : sqlType;
+        return ((_c = trinoToMalloyTypes[baseSqlType]) !== null && _c !== void 0 ? _c : {
+            type: 'sql native',
+            rawType: sqlType,
+        });
     }
     castToString(expression) {
         return `CAST(${expression} as VARCHAR)`;

package/dist/index.d.ts

@@ -1,11 +1,11 @@
-export { DuckDBDialect, StandardSQLDialect, PostgresDialect, SnowflakeDialect, registerDialect, arg, qtz, overload, minScalar, anyExprType, minAggregate, maxScalar, sql, makeParam, param, variadicParam, literal, spread, Dialect, } from './dialect';
+export { DuckDBDialect, StandardSQLDialect, TrinoDialect, PostgresDialect, SnowflakeDialect, 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, StructRelationship, NamedStructDefs, MalloyQueryData, AtomicFieldType as AtomicFieldTypeInner, DateUnit, ExtractUnit, TimestampUnit, TimeFieldType, QueryData, QueryValue, FieldTypeDef, Expr, FilterCondition, SQLBlock, FieldAtomicDef, FieldDef, PipeSegment, QueryFieldDef, IndexFieldDef, TurtleDef, SearchValueMapResult, SearchIndexResult, ModelDef, Query, QueryResult, QueryRunStats, NamedQuery, NamedModelObject, ExpressionType, FunctionDef, FunctionOverloadDef, FunctionParameterDef, ExpressionValueType, TypeDesc, FieldValueType, ExpressionTypeDesc, FunctionParamTypeDesc, DocumentLocation, DocumentRange, DocumentPosition, Sampling, Annotation, FieldAtomicTypeDef, SQLBlockStructDef, } from './model';
-export { Segment, isSamplingEnable, isSamplingPercent, isSamplingRows, expressionIsCalculation, indent, composeSQLExpr, } from './model';
+export type { QueryDataRow, StructDef, TableSourceDef, SQLSourceDef, SourceDef, JoinFieldDef, NamedSourceDefs as NamedStructDefs, MalloyQueryData, DateUnit, ExtractUnit, TimestampUnit, TemporalFieldType as TimeFieldType, QueryData, QueryValue, Expr, FilterCondition, SQLSentence, FieldDef, PipeSegment, QueryFieldDef, IndexFieldDef, TurtleDef, SearchValueMapResult, SearchIndexResult, ModelDef, Query, QueryResult, QueryRunStats, NamedQuery, NamedModelObject, ExpressionType, FunctionDef, FunctionOverloadDef, FunctionParameterDef, ExpressionValueType, TypeDesc, FieldValueType, ExpressionTypeDesc, FunctionParamTypeDesc, DocumentLocation, DocumentRange, DocumentPosition, Sampling, Annotation, LeafAtomicDef, AtomicTypeDef, AtomicFieldDef, JoinedArrayDef, JoinedArrayTypeDef, RecordTypeDef, RepeatedRecordTypeDef, } from './model';
+export { arrayEachFields, isRepeatedRecord, isSourceDef, Segment, isSamplingEnable, isSamplingPercent, isSamplingRows, expressionIsCalculation, indent, composeSQLExpr, } from './model';
 export { 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, } from './malloy';
-export type { PreparedQuery, Field, AtomicField, ExploreField, QueryField, SortableField, DataArray, DataRecord, DataColumn, DataArrayOrRecord, Loggable, ModelMaterializer, DocumentTablePath, DocumentSymbol, ResultJSON, PreparedResultMaterializer, SQLBlockMaterializer, ExploreMaterializer, WriteStream, SerializedExplore, DateField, TimestampField, } from './malloy';
+export type { PreparedQuery, Field, AtomicField, ExploreField, QueryField, SortableField, DataArray, DataRecord, DataColumn, DataArrayOrRecord, Loggable, ModelMaterializer, DocumentTablePath, DocumentSymbol, ResultJSON, PreparedResultMaterializer, ExploreMaterializer, WriteStream, SerializedExplore, DateField, TimestampField, } from './malloy';
 export type { QueryOptionsReader, RunSQLOptions } from './run_sql_options';
 export type { EventStream, ModelString, ModelURL, QueryString, QueryURL, URLReader, } from './runtime_types';
 export type { Connection, ConnectionConfig, ConnectionFactory, ConnectionParameter, ConnectionParameterValue, ConnectionConfigSchema, FetchSchemaOptions, InfoConnection, LookupConnection, PersistSQLResults, PooledConnection, TestableConnection, StreamingConnection, } from './connection/types';

package/dist/index.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.toAsyncGenerator = exports.Explore = exports.DataWriter = exports.Parse = exports.JSONWriter = exports.CSVWriter = exports.QueryMaterializer = exports.Result = exports.PreparedResult = exports.TimestampTimeframe = exports.DateTimeframe = exports.SourceRelationship = exports.JoinRelationship = exports.MalloyError = exports.FixedConnectionMap = exports.InMemoryURLReader = exports.EmptyURLReader = exports.SingleConnectionRuntime = exports.ConnectionRuntime = exports.AtomicFieldType = exports.Runtime = exports.Malloy = exports.Model = exports.MalloyTranslator = exports.composeSQLExpr = exports.indent = exports.expressionIsCalculation = exports.isSamplingRows = exports.isSamplingPercent = exports.isSamplingEnable = exports.Segment = 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.SnowflakeDialect = exports.PostgresDialect = exports.StandardSQLDialect = exports.DuckDBDialect = void 0;
-exports.Tag = void 0;
+exports.JSONWriter = exports.CSVWriter = exports.QueryMaterializer = exports.Result = exports.PreparedResult = exports.TimestampTimeframe = exports.DateTimeframe = exports.SourceRelationship = exports.JoinRelationship = exports.MalloyError = exports.FixedConnectionMap = exports.InMemoryURLReader = exports.EmptyURLReader = exports.SingleConnectionRuntime = exports.ConnectionRuntime = exports.AtomicFieldType = exports.Runtime = exports.Malloy = exports.Model = exports.MalloyTranslator = exports.composeSQLExpr = exports.indent = exports.expressionIsCalculation = exports.isSamplingRows = exports.isSamplingPercent = exports.isSamplingEnable = exports.Segment = exports.isSourceDef = exports.isRepeatedRecord = exports.arrayEachFields = 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.SnowflakeDialect = exports.PostgresDialect = exports.TrinoDialect = exports.StandardSQLDialect = exports.DuckDBDialect = void 0;
+exports.Tag = exports.toAsyncGenerator = exports.Explore = exports.DataWriter = exports.Parse = void 0;
 /*
  * Copyright 2023 Google LLC
  *
@@ -27,6 +27,7 @@ exports.Tag = void 0;
 var dialect_1 = require("./dialect");
 Object.defineProperty(exports, "DuckDBDialect", { enumerable: true, get: function () { return dialect_1.DuckDBDialect; } });
 Object.defineProperty(exports, "StandardSQLDialect", { enumerable: true, get: function () { return dialect_1.StandardSQLDialect; } });
+Object.defineProperty(exports, "TrinoDialect", { enumerable: true, get: function () { return dialect_1.TrinoDialect; } });
 Object.defineProperty(exports, "PostgresDialect", { enumerable: true, get: function () { return dialect_1.PostgresDialect; } });
 Object.defineProperty(exports, "SnowflakeDialect", { enumerable: true, get: function () { return dialect_1.SnowflakeDialect; } });
 Object.defineProperty(exports, "registerDialect", { enumerable: true, get: function () { return dialect_1.registerDialect; } });
@@ -45,6 +46,9 @@ Object.defineProperty(exports, "literal", { enumerable: true, get: function () {
 Object.defineProperty(exports, "spread", { enumerable: true, get: function () { return dialect_1.spread; } });
 Object.defineProperty(exports, "Dialect", { enumerable: true, get: function () { return dialect_1.Dialect; } });
 var model_1 = require("./model");
+Object.defineProperty(exports, "arrayEachFields", { enumerable: true, get: function () { return model_1.arrayEachFields; } });
+Object.defineProperty(exports, "isRepeatedRecord", { enumerable: true, get: function () { return model_1.isRepeatedRecord; } });
+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, "isSamplingEnable", { enumerable: true, get: function () { return model_1.isSamplingEnable; } });

package/dist/lang/ast/error-factory.d.ts

@@ -1,7 +1,8 @@
-import { IndexSegment, ProjectSegment, Query, ReduceSegment, StructDef } from '../../model/malloy_types';
+import { TableSourceDef, IndexSegment, ProjectSegment, Query, ReduceSegment, StructDef, JoinFieldDef } from '../../model/malloy_types';
 export declare class ErrorFactory {
-    static get structDef(): StructDef;
-    static isErrorStructDef(s: StructDef): boolean;
+    static get structDef(): TableSourceDef;
+    static get joinDef(): JoinFieldDef;
+    static didCreate(s: StructDef | JoinFieldDef): boolean;
     static get query(): Query;
     static get reduceSegment(): ReduceSegment;
     static get projectSegment(): ProjectSegment;

package/dist/lang/ast/error-factory.js

@@ -23,26 +23,36 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ErrorFactory = void 0;
-const theErrorStruct = {
-    type: 'struct',
-    name: '~malformed~',
-    dialect: '~malformed~',
-    structSource: {
-        type: 'table',
-        tablePath: '//undefined_error_table_path',
-    },
-    structRelationship: {
-        type: 'basetable',
-        connectionName: '//undefined_error_connection',
-    },
-    fields: [],
-};
+const ERR_NAME = '~malformed~';
 class ErrorFactory {
     static get structDef() {
-        return { ...theErrorStruct };
+        const factoryStruct = {
+            type: 'table',
+            name: ERR_NAME,
+            dialect: '~malformed~',
+            connection: '~unknown~',
+            tablePath: '//undefined_error_table_path',
+            fields: [],
+            errorFactory: true,
+        };
+        return factoryStruct;
+    }
+    static get joinDef() {
+        const factoryJoin = {
+            type: 'table',
+            name: ERR_NAME,
+            dialect: '~malformed~',
+            connection: '~unknown~',
+            tablePath: '//undefined_error_table_path',
+            fields: [],
+            join: 'one',
+            matrixOperation: 'left',
+            errorFactory: true,
+        };
+        return factoryJoin;
     }
-    static isErrorStructDef(s) {
-        return s.name.includes(theErrorStruct.name);
+    static didCreate(s) {
+        return s.type === 'table' && 'errorFactory' in s;
     }
     static get query() {
         return {

package/dist/lang/ast/expressions/constant-expression.d.ts

@@ -12,6 +12,7 @@ export declare class ConstantFieldSpace implements FieldSpace {
     lookup(_name: unknown): LookupResult;
     entries(): [string, SpaceEntry][];
     entry(): undefined;
+    dialectName(): string;
     dialectObj(): undefined;
     isQueryFieldSpace(): this is QueryFieldSpace;
 }

package/dist/lang/ast/expressions/constant-expression.js

@@ -49,6 +49,9 @@ class ConstantFieldSpace {
     entry() {
         return undefined;
     }
+    dialectName() {
+        return '~constant-space-unknown-dialect~';
+    }
     dialectObj() {
         return undefined;
     }

package/dist/lang/ast/expressions/expr-aggregate-function.d.ts

@@ -1,12 +1,9 @@
-import { AggregateFunctionType, FieldValueType, StructRelationship } from '../../../model/malloy_types';
+import { AggregateFunctionType, FieldValueType } from '../../../model/malloy_types';
 import { FieldReference } from '../query-items/field-references';
 import { ExprValue } from '../types/expr-value';
 import { ExpressionDef } from '../types/expression-def';
 import { FieldSpace } from '../types/field-space';
-interface JoinPathElement {
-    name: string;
-    structRelationship: StructRelationship;
-}
+import { JoinPath } from '../types/lookup-result';
 export declare abstract class ExprAggregateFunction extends ExpressionDef {
     readonly func: AggregateFunctionType;
     elementType: string;
@@ -18,6 +15,5 @@ export declare abstract class ExprAggregateFunction extends ExpressionDef {
     returns(_forExpression: ExprValue): FieldValueType;
     getExpression(fs: FieldSpace): ExprValue;
     isSymmetricFunction(): boolean;
-    getJoinUsage(fs: FieldSpace): JoinPathElement[][];
+    getJoinUsage(fs: FieldSpace): JoinPath[];
 }
-export {};