@malloydata/malloy 0.0.336 → 0.0.338

package/dist/api/foundation/compile.d.ts

@@ -1,5 +1,6 @@
 import type { LogMessage } from '../../lang';
 import type { Connection, InfoConnection, LookupConnection, FetchSchemaOptions } from '../../connection/types';
+import type { ConnectionTypeDef, ConnectionPropertyDefinition, ConnectionsConfig } from '../../connection/registry';
 import type { URLReader, EventStream } from '../../runtime_types';
 import type { SQLSourceDef, QueryRunStats } from '../../model';
 import type { RunSQLOptions } from '../../run_sql_options';
@@ -55,6 +56,31 @@ export declare class MalloyError extends Error {
 }
 export declare class Malloy {
     static get version(): string;
+    /**
+     * Register a connection type with the global registry.
+     * Typically called by db-* packages on import as a side effect.
+     */
+    static registerConnectionType(typeName: string, def: ConnectionTypeDef): void;
+    /**
+     * Get the property definitions for a registered connection type.
+     */
+    static getConnectionProperties(typeName: string): ConnectionPropertyDefinition[] | undefined;
+    /**
+     * Get the names of all registered connection types.
+     */
+    static getRegisteredConnectionTypes(): string[];
+    /**
+     * Parse a JSON config string into an editable ConnectionsConfig.
+     */
+    static readConnectionsConfig(jsonText: string): ConnectionsConfig;
+    /**
+     * Serialize a ConnectionsConfig to a JSON string.
+     */
+    static writeConnectionsConfig(config: ConnectionsConfig): string;
+    /**
+     * Create a LookupConnection from a ConnectionsConfig using registered factories.
+     */
+    static createConnectionsFromConfig(config: ConnectionsConfig): LookupConnection<Connection>;
     private static _parse;
     /**
      * Parse a Malloy document by URL.

package/dist/api/foundation/compile.js

@@ -6,6 +6,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Malloy = exports.MalloyError = void 0;
 const lang_1 = require("../../lang");
+const registry_1 = require("../../connection/registry");
 const model_1 = require("../../model");
 const sql_block_1 = require("../../model/sql_block");
 const version_1 = require("../../version");
@@ -43,6 +44,43 @@ class Malloy {
     static get version() {
         return version_1.MALLOY_VERSION;
     }
+    /**
+     * Register a connection type with the global registry.
+     * Typically called by db-* packages on import as a side effect.
+     */
+    static registerConnectionType(typeName, def) {
+        (0, registry_1.registerConnectionType)(typeName, def);
+    }
+    /**
+     * Get the property definitions for a registered connection type.
+     */
+    static getConnectionProperties(typeName) {
+        return (0, registry_1.getConnectionProperties)(typeName);
+    }
+    /**
+     * Get the names of all registered connection types.
+     */
+    static getRegisteredConnectionTypes() {
+        return (0, registry_1.getRegisteredConnectionTypes)();
+    }
+    /**
+     * Parse a JSON config string into an editable ConnectionsConfig.
+     */
+    static readConnectionsConfig(jsonText) {
+        return (0, registry_1.readConnectionsConfig)(jsonText);
+    }
+    /**
+     * Serialize a ConnectionsConfig to a JSON string.
+     */
+    static writeConnectionsConfig(config) {
+        return (0, registry_1.writeConnectionsConfig)(config);
+    }
+    /**
+     * Create a LookupConnection from a ConnectionsConfig using registered factories.
+     */
+    static createConnectionsFromConfig(config) {
+        return (0, registry_1.createConnectionsFromConfig)(config);
+    }
     static _parse(source, url, eventStream, options, invalidationKey) {
         if (url === undefined) {
             url = new URL(MALLOY_INTERNAL_URL);

package/dist/api/foundation/result.d.ts

@@ -1,4 +1,4 @@
-import type { QueryData, QueryDataRow, QueryResult, QueryRunStats, ModelDef } from '../../model';
+import type { QueryData, QueryRecord, QueryResult, QueryRunStats, ModelDef } from '../../model';
 import type { Explore, Field, AtomicField, StringField, NumberField, BooleanField, DateField, TimestampField, JSONField, UnsupportedField } from './core';
 import { PreparedResult } from './core';
 export type ResultJSON = {
@@ -163,17 +163,17 @@ export declare class DataRecord extends Data<{
     protected _field: Explore;
     readonly index: number | undefined;
     private cellCache;
-    constructor(queryDataRow: QueryDataRow, index: number | undefined, field: Explore, parent: DataArrayOrRecord | undefined, parentRecord: DataRecord | undefined);
+    constructor(queryDataRow: QueryRecord, index: number | undefined, field: Explore, parent: DataArrayOrRecord | undefined, parentRecord: DataRecord | undefined);
     /**
      * @return Normalized data with JS native types (number | bigint, Date).
      * Use this for CSV output, tests, and general programmatic access.
      */
-    toObject(): QueryDataRow;
+    toObject(): QueryRecord;
     /**
      * @return Normalized data with JSON-safe types (numbers as number | string, dates as ISO strings).
      * Use this for JSON serialization.
      */
-    toJSON(): QueryDataRow;
+    toJSON(): QueryRecord;
     path(...path: (number | string)[]): DataColumn;
     cell(fieldOrName: string | Field): DataColumn;
     get value(): {

package/dist/api/foundation/result.js

@@ -406,12 +406,12 @@ const JSON_NORMALIZERS = {
  * Walk a QueryData array and normalize values according to the given normalizers.
  */
 function walkQueryData(data, structDef, normalizers) {
-    return data.map(row => walkQueryDataRow(row, structDef, normalizers));
+    return data.map(row => walkQueryRecord(row, structDef, normalizers));
 }
 /**
- * Walk a QueryDataRow and normalize values according to the given normalizers.
+ * Walk a QueryRecord and normalize values according to the given normalizers.
  */
-function walkQueryDataRow(row, structDef, normalizers) {
+function walkQueryRecord(row, structDef, normalizers) {
     var _a;
     const result = {};
     for (const fieldDef of structDef.fields) {
@@ -458,7 +458,7 @@ function walkValue(value, fieldDef, normalizers) {
         }
         if ((0, model_1.isRepeatedRecord)(fieldDef)) {
             // Array of records - recurse into each record
-            return value.map(item => walkQueryDataRow(item, fieldDef, normalizers));
+            return value.map(item => walkQueryRecord(item, fieldDef, normalizers));
         }
         else if ((0, model_1.isBasicArray)(fieldDef)) {
             // Scalar array - normalize each element based on elementTypeDef
@@ -470,7 +470,7 @@ function walkValue(value, fieldDef, normalizers) {
     // Handle records (non-array)
     if (fieldDef.type === 'record') {
         if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
-            return walkQueryDataRow(value, fieldDef, normalizers);
+            return walkQueryRecord(value, fieldDef, normalizers);
         }
     }
     // Fallback - pass through
@@ -505,7 +505,7 @@ function walkScalarValue(value, typeDef, normalizers) {
             return value.map(item => walkScalarValue(item, elementType, normalizers));
         }
         else if ((0, model_1.isRepeatedRecord)(typeDef)) {
-            return value.map(item => walkQueryDataRow(item, typeDef, normalizers));
+            return value.map(item => walkQueryRecord(item, typeDef, normalizers));
         }
     }
     // Pass through other types
@@ -612,14 +612,14 @@ class DataRecord extends Data {
      * Use this for CSV output, tests, and general programmatic access.
      */
     toObject() {
-        return walkQueryDataRow(this.queryDataRow, this._field.structDef, OBJECT_NORMALIZERS);
+        return walkQueryRecord(this.queryDataRow, this._field.structDef, OBJECT_NORMALIZERS);
     }
     /**
      * @return Normalized data with JSON-safe types (numbers as number | string, dates as ISO strings).
      * Use this for JSON serialization.
      */
     toJSON() {
-        return walkQueryDataRow(this.queryDataRow, this._field.structDef, JSON_NORMALIZERS);
+        return walkQueryRecord(this.queryDataRow, this._field.structDef, JSON_NORMALIZERS);
     }
     path(...path) {
         return getPath(this, path);
@@ -657,7 +657,7 @@ class DataRecord extends Data {
                 }
             }
             else if (field.isExploreField()) {
-                if (Array.isArray(value)) {
+                if ((0, model_1.isCompoundArrayData)(value)) {
                     column = new DataArray(value, field, this, this);
                 }
                 else {

package/dist/api/foundation/writers.d.ts

@@ -15,7 +15,7 @@ export declare class JSONWriter extends DataWriter {
  * CSV writer class that handles nested data.
  * This writer creates CSV using a DFS traversal of the result dataset.
  * Each trivial column value is converted to a CSV of 1x1 matrix and all the
- * columns are merged together to create a CSV that represents 1 QueryDataRow.
+ * columns are merged together to create a CSV that represents 1 QueryRecord.
  * Since this follows DFS, each non trivial data is rendered into a NxM matrix
  * where N is the number of rows in the nested data and M is the number of
  * columns it has.

package/dist/api/foundation/writers.js

@@ -5,6 +5,7 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CSVWriter = exports.JSONWriter = exports.DataWriter = void 0;
+const model_1 = require("../../model");
 // =============================================================================
 // DataWriter Base Class
 // =============================================================================
@@ -47,7 +48,7 @@ exports.JSONWriter = JSONWriter;
  * CSV writer class that handles nested data.
  * This writer creates CSV using a DFS traversal of the result dataset.
  * Each trivial column value is converted to a CSV of 1x1 matrix and all the
- * columns are merged together to create a CSV that represents 1 QueryDataRow.
+ * columns are merged together to create a CSV that represents 1 QueryRecord.
  * Since this follows DFS, each non trivial data is rendered into a NxM matrix
  * where N is the number of rows in the nested data and M is the number of
  * columns it has.
@@ -108,7 +109,7 @@ class CSVWriter extends DataWriter {
         for (const key in firstVal) {
             numKeys = numKeys + 1;
             const val = firstVal[key];
-            if (Array.isArray(val)) {
+            if ((0, model_1.isCompoundArrayData)(val)) {
                 const weight = this.getColWeight(val) - 1;
                 numKeys = numKeys + weight;
             }
@@ -123,7 +124,7 @@ class CSVWriter extends DataWriter {
             csv.push(this.escape(key));
             const val = row[key];
             width++;
-            if (Array.isArray(val)) {
+            if ((0, model_1.isCompoundArrayData)(val)) {
                 const numKeys = this.getColWeight(val) - 1;
                 width = width + numKeys;
                 for (let i = 0; i < numKeys; i++) {
@@ -193,7 +194,11 @@ class CSVWriter extends DataWriter {
         const matrices = [];
         for (const key in row) {
             const val = row[key];
-            if (!Array.isArray(val)) {
+            if ((0, model_1.isCompoundArrayData)(val)) {
+                const cell = this.getChildMatrix(val);
+                matrices.push(cell);
+            }
+            else {
                 const cell = {
                     rows: [this.stringify(val)],
                     length: 1,
@@ -201,10 +206,6 @@ class CSVWriter extends DataWriter {
                 };
                 matrices.push(cell);
             }
-            else {
-                const cell = this.getChildMatrix(val);
-                matrices.push(cell);
-            }
         }
         return this.mergeMatrices(matrices);
     }

package/dist/connection/index.d.ts

@@ -1,2 +1,3 @@
 export * from './types';
 export * from './base_connection';
+export * from './registry';

package/dist/connection/index.js

@@ -16,4 +16,5 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./types"), exports);
 __exportStar(require("./base_connection"), exports);
+__exportStar(require("./registry"), exports);
 //# sourceMappingURL=index.js.map

package/dist/connection/registry.d.ts

@@ -0,0 +1,73 @@
+import type { Connection, ConnectionConfig, LookupConnection } from './types';
+/**
+ * A factory function that creates a Connection from a config object.
+ */
+export type ConnectionTypeFactory = (config: ConnectionConfig) => Connection;
+/**
+ * The type of a connection property value.
+ */
+export type ConnectionPropertyType = 'string' | 'number' | 'boolean' | 'password' | 'file' | 'text';
+/**
+ * Describes a single configuration property for a connection type.
+ */
+export interface ConnectionPropertyDefinition {
+    name: string;
+    displayName: string;
+    type: ConnectionPropertyType;
+    optional?: true;
+    default?: string;
+    description?: string;
+    /** For type 'file': extension filters for picker dialogs. */
+    fileFilters?: Record<string, string[]>;
+}
+/**
+ * A connection type definition: factory plus property metadata.
+ */
+export interface ConnectionTypeDef {
+    factory: ConnectionTypeFactory;
+    properties: ConnectionPropertyDefinition[];
+}
+/**
+ * A single connection entry in a JSON config.
+ */
+export interface ConnectionConfigEntry {
+    is: string;
+    [key: string]: string | number | boolean | undefined;
+}
+/**
+ * The editable intermediate representation of a connections config file.
+ */
+export interface ConnectionsConfig {
+    connections: Record<string, ConnectionConfigEntry>;
+}
+/**
+ * Register a connection type with its factory and property definitions.
+ *
+ * @param typeName The connection type name (e.g. "duckdb", "bigquery").
+ * @param def The connection type definition (factory + properties).
+ */
+export declare function registerConnectionType(typeName: string, def: ConnectionTypeDef): void;
+/**
+ * Get the property definitions for a registered connection type.
+ *
+ * @param typeName The connection type name.
+ * @returns The property definitions, or undefined if the type is not registered.
+ */
+export declare function getConnectionProperties(typeName: string): ConnectionPropertyDefinition[] | undefined;
+/**
+ * Get the names of all registered connection types.
+ */
+export declare function getRegisteredConnectionTypes(): string[];
+/**
+ * Parse a JSON config string into a ConnectionsConfig.
+ * Validates that each connection entry has an `is` field.
+ */
+export declare function readConnectionsConfig(jsonText: string): ConnectionsConfig;
+/**
+ * Serialize a ConnectionsConfig to a JSON string with 2-space indent.
+ */
+export declare function writeConnectionsConfig(config: ConnectionsConfig): string;
+/**
+ * Create a LookupConnection from a ConnectionsConfig using registered factories.
+ */
+export declare function createConnectionsFromConfig(config: ConnectionsConfig): LookupConnection<Connection>;

package/dist/connection/registry.js

@@ -0,0 +1,106 @@
+"use strict";
+/*
+ * Copyright Contributors to the Malloy project
+ * SPDX-License-Identifier: MIT
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerConnectionType = registerConnectionType;
+exports.getConnectionProperties = getConnectionProperties;
+exports.getRegisteredConnectionTypes = getRegisteredConnectionTypes;
+exports.readConnectionsConfig = readConnectionsConfig;
+exports.writeConnectionsConfig = writeConnectionsConfig;
+exports.createConnectionsFromConfig = createConnectionsFromConfig;
+// Module-level registry
+const registry = new Map();
+/**
+ * Register a connection type with its factory and property definitions.
+ *
+ * @param typeName The connection type name (e.g. "duckdb", "bigquery").
+ * @param def The connection type definition (factory + properties).
+ */
+function registerConnectionType(typeName, def) {
+    registry.set(typeName, def);
+}
+/**
+ * Get the property definitions for a registered connection type.
+ *
+ * @param typeName The connection type name.
+ * @returns The property definitions, or undefined if the type is not registered.
+ */
+function getConnectionProperties(typeName) {
+    var _a;
+    return (_a = registry.get(typeName)) === null || _a === void 0 ? void 0 : _a.properties;
+}
+/**
+ * Get the names of all registered connection types.
+ */
+function getRegisteredConnectionTypes() {
+    return [...registry.keys()];
+}
+/**
+ * Parse a JSON config string into a ConnectionsConfig.
+ * Validates that each connection entry has an `is` field.
+ */
+function readConnectionsConfig(jsonText) {
+    const parsed = JSON.parse(jsonText);
+    const connections = parsed.connections;
+    if (connections === undefined || typeof connections !== 'object') {
+        throw new Error('Invalid connections config: missing "connections" object');
+    }
+    for (const [name, entry] of Object.entries(connections)) {
+        if (typeof entry !== 'object' ||
+            entry === null ||
+            !entry.is) {
+            throw new Error(`Connection "${name}" is missing required "is" property`);
+        }
+    }
+    return parsed;
+}
+/**
+ * Serialize a ConnectionsConfig to a JSON string with 2-space indent.
+ */
+function writeConnectionsConfig(config) {
+    return JSON.stringify(config, null, 2);
+}
+/**
+ * Create a LookupConnection from a ConnectionsConfig using registered factories.
+ */
+function createConnectionsFromConfig(config) {
+    const entries = Object.entries(config.connections);
+    const firstConnectionName = entries.length > 0 ? entries[0][0] : undefined;
+    const cache = new Map();
+    return {
+        async lookupConnection(connectionName) {
+            if (connectionName === undefined) {
+                connectionName = firstConnectionName;
+            }
+            if (connectionName === undefined) {
+                throw new Error('No connections defined in config');
+            }
+            const cached = cache.get(connectionName);
+            if (cached)
+                return cached;
+            const entry = config.connections[connectionName];
+            if (!entry) {
+                throw new Error(`No connection named "${connectionName}" found in config`);
+            }
+            const typeDef = registry.get(entry.is);
+            if (!typeDef) {
+                throw new Error(`No registered connection type "${entry.is}" for connection "${connectionName}". ` +
+                    'Did you forget to import the connection package?');
+            }
+            const connConfig = { name: connectionName };
+            for (const [key, value] of Object.entries(entry)) {
+                if (key === 'is')
+                    continue;
+                if (value !== undefined) {
+                    connConfig[key] = value;
+                }
+            }
+            const connection = typeDef.factory(connConfig);
+            cache.set(connectionName, connection);
+            return connection;
+        },
+    };
+}
+//# sourceMappingURL=registry.js.map

package/dist/connection/types.d.ts

@@ -1,6 +1,5 @@
 import type { RunSQLOptions } from '../run_sql_options';
-import type { Annotation, MalloyQueryData, QueryDataRow, QueryRunStats, SQLSourceDef, TableSourceDef } from '../model/malloy_types';
-import type { Dialect } from '../dialect';
+import type { Annotation, MalloyQueryData, QueryRecord, QueryRunStats, SQLSourceDef, TableSourceDef } from '../model/malloy_types';
 import type { SQLSourceRequest } from '../lang/translate-response';
 /**
  * Options passed to fetchSchema methods.
@@ -49,24 +48,10 @@ export interface InfoConnection {
     getDigest(): string;
 }
 export type ConnectionParameterValue = string | number | boolean | Array<ConnectionParameterValue>;
-export interface ConnectionParameter {
-    name: string;
-    label: string;
-    type: 'string' | 'number' | 'boolean';
-    isOptional?: boolean;
-    isSecret?: boolean;
-    defaultValue?: ConnectionParameterValue;
-}
-export type ConnectionConfigSchema = ConnectionParameter[];
 export interface ConnectionConfig {
     name: string;
     [key: string]: ConnectionParameterValue | undefined;
 }
-export interface ConnectionFactory {
-    connectionName: string;
-    configSchema: ConnectionConfigSchema;
-    createConnection(connectionConfig: ConnectionConfig, dialectRegistrar?: (dialect: Dialect) => void): Connection & TestableConnection;
-}
 export interface ConnectionMetadata {
     url?: string;
 }
@@ -105,7 +90,7 @@ export interface PersistSQLResults extends Connection {
     manifestTemporaryTable(sqlCommand: string): Promise<string>;
 }
 export interface StreamingConnection extends Connection {
-    runSQLStream(sqlCommand: string, options?: RunSQLOptions): AsyncIterableIterator<QueryDataRow>;
+    runSQLStream(sqlCommand: string, options?: RunSQLOptions): AsyncIterableIterator<QueryRecord>;
 }
 /**
  * A mapping of connection names to connections.

package/dist/dialect/dialect.d.ts

@@ -74,6 +74,7 @@ export declare abstract class Dialect {
     supportsBigIntPrecision: boolean;
     supportsComplexFilteredSources: boolean;
     supportsTempTables: boolean;
+    maxIdentifierLength: number;
     hasModOperator: boolean;
     supportsLeftJoinUnnest: boolean;
     requiresExplicitUnnestOrdering: boolean;
@@ -368,7 +369,7 @@ export declare abstract class Dialect {
     sqlCastPrep(cast: TypecastExpr): {
         op: string;
         srcTypeDef: BasicAtomicTypeDef | undefined;
-        dstTypeDef: BasicAtomicTypeDef | undefined;
+        dstTypeDef: AtomicTypeDef | undefined;
         dstSQLType: string;
     };
     /**

package/dist/dialect/dialect.js

@@ -95,6 +95,9 @@ class Dialect {
         this.supportsComplexFilteredSources = true;
         // can create temp tables
         this.supportsTempTables = true;
+        // Maximum length of a table/view identifier. Used to truncate
+        // generated temp table names. 128 is a safe default for most databases.
+        this.maxIdentifierLength = 128;
         this.hasModOperator = true;
         // can LEFT JOIN UNNEST
         this.supportsLeftJoinUnnest = true;

package/dist/dialect/duckdb/duckdb.js

@@ -289,9 +289,30 @@ class DuckDBDialect extends pg_impl_1.PostgresBase {
         else if (malloyType.type === 'string') {
             return 'varchar';
         }
-        if (malloyType.type === 'timestamptz') {
+        else if (malloyType.type === 'timestamptz') {
             return 'timestamp with time zone';
         }
+        else if (malloyType.type === 'record') {
+            const typeSpec = [];
+            for (const f of malloyType.fields) {
+                if ((0, malloy_types_1.isAtomic)(f)) {
+                    typeSpec.push(`${this.sqlMaybeQuoteIdentifier(f.name)} ${this.malloyTypeToSQLType(f)}`);
+                }
+            }
+            return `STRUCT(${typeSpec.join(', ')})`;
+        }
+        else if (malloyType.type === 'array') {
+            if ((0, malloy_types_1.isRepeatedRecord)(malloyType)) {
+                const typeSpec = [];
+                for (const f of malloyType.fields) {
+                    if ((0, malloy_types_1.isAtomic)(f)) {
+                        typeSpec.push(`${this.sqlMaybeQuoteIdentifier(f.name)} ${this.malloyTypeToSQLType(f)}`);
+                    }
+                }
+                return `STRUCT(${typeSpec.join(', ')})[]`;
+            }
+            return `${this.malloyTypeToSQLType(malloyType.elementTypeDef)}[]`;
+        }
         return malloyType.type;
     }
     parseDuckDBType(sqlType) {

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

@@ -31,6 +31,7 @@ export declare class MySQLDialect extends Dialect {
     compoundObjectInSchema: boolean;
     booleanType: BooleanTypeSupport;
     orderByClause: OrderByClauseType;
+    maxIdentifierLength: number;
     malloyTypeToSQLType(malloyType: AtomicTypeDef): string;
     sqlTypeToMalloyType(sqlType: string): BasicAtomicTypeDef;
     quoteTablePath(tablePath: string): string;

package/dist/dialect/mysql/mysql.js

@@ -120,6 +120,7 @@ class MySQLDialect extends dialect_1.Dialect {
         this.compoundObjectInSchema = false;
         this.booleanType = 'simulated';
         this.orderByClause = 'ordinal';
+        this.maxIdentifierLength = 64;
     }
     malloyTypeToSQLType(malloyType) {
         switch (malloyType.type) {

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

@@ -26,6 +26,7 @@ export declare class PostgresDialect extends PostgresBase {
     supportsComplexFilteredSources: boolean;
     compoundObjectInSchema: boolean;
     likeEscape: boolean;
+    maxIdentifierLength: number;
     quoteTablePath(tablePath: string): string;
     sqlGroupSetTable(groupSetCount: number): string;
     sqlAnyValue(groupSet: number, fieldName: string): string;

package/dist/dialect/postgres/postgres.js

@@ -97,6 +97,7 @@ class PostgresDialect extends pg_impl_1.PostgresBase {
         this.supportsComplexFilteredSources = false;
         this.compoundObjectInSchema = false;
         this.likeEscape = false;
+        this.maxIdentifierLength = 63;
     }
     quoteTablePath(tablePath) {
         return tablePath
@@ -331,6 +332,15 @@ class PostgresDialect extends pg_impl_1.PostgresBase {
         else if (malloyType.type === 'string') {
             return 'varchar';
         }
+        else if (malloyType.type === 'record') {
+            throw new Error('PostgreSQL does not support CAST to record type');
+        }
+        else if (malloyType.type === 'array') {
+            if ((0, malloy_types_1.isRepeatedRecord)(malloyType)) {
+                throw new Error('PostgreSQL does not support CAST to array of records');
+            }
+            return `${this.malloyTypeToSQLType(malloyType.elementTypeDef)}[]`;
+        }
         return malloyType.type;
     }
     sqlTypeToMalloyType(rawSqlType) {

package/dist/dialect/standardsql/standardsql.js

@@ -377,6 +377,27 @@ ${(0, utils_1.indent)(sql)}
                 return 'FLOAT64';
             }
         }
+        else if (malloyType.type === 'record') {
+            const typeSpec = [];
+            for (const f of malloyType.fields) {
+                if ((0, malloy_types_1.isAtomic)(f)) {
+                    typeSpec.push(`${f.name} ${this.malloyTypeToSQLType(f)}`);
+                }
+            }
+            return `STRUCT<${typeSpec.join(', ')}>`;
+        }
+        else if (malloyType.type === 'array') {
+            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<STRUCT<${typeSpec.join(', ')}>>`;
+            }
+            return `ARRAY<${this.malloyTypeToSQLType(malloyType.elementTypeDef)}>`;
+        }
         return malloyType.type;
     }
     sqlTypeToMalloyType(sqlType) {

package/dist/index.d.ts

@@ -1,14 +1,16 @@
 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, QueryResultDef, QueryRunStats, QueryScalar, NamedQueryDef, NamedModelObject, ExpressionType, FunctionDef, FunctionOverloadDef, FunctionParameterDef, ExpressionValueType, TypeDesc, FunctionParamTypeDesc, DocumentLocation, DocumentRange, DocumentPosition, Sampling, Annotation, BasicAtomicTypeDef, BasicAtomicDef, AtomicTypeDef, AtomicFieldDef, ArrayDef, ArrayTypeDef, RecordTypeDef, RepeatedRecordTypeDef, RecordDef, RepeatedRecordDef, RecordLiteralNode, StringLiteralNode, ArrayLiteralNode, SourceComponentInfo, DateLiteralNode, TimestampLiteralNode, TimestamptzLiteralNode, TimeLiteralExpr, TypecastExpr, BuildManifest, BuildManifestEntry, } from './model';
-export { isSourceDef, isBasicAtomic, isJoined, isJoinedSource, isSamplingEnable, isSamplingPercent, isSamplingRows, isRepeatedRecord, isBasicArray, mkArrayDef, mkFieldDef, expressionIsAggregate, expressionIsAnalytic, expressionIsCalculation, expressionIsScalar, expressionIsUngroupedAggregate, indent, composeSQLExpr, isTimestampUnit, isDateUnit, constantExprToSQL, } from './model';
+export type { QueryRecord, 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, QueryResultDef, QueryRunStats, QueryScalar, NamedQueryDef, NamedModelObject, ExpressionType, FunctionDef, FunctionOverloadDef, FunctionParameterDef, ExpressionValueType, TypeDesc, FunctionParamTypeDesc, DocumentLocation, DocumentRange, DocumentPosition, Sampling, Annotation, BasicAtomicTypeDef, BasicAtomicDef, AtomicTypeDef, AtomicFieldDef, ArrayDef, ArrayTypeDef, RecordTypeDef, RepeatedRecordTypeDef, RecordDef, RepeatedRecordDef, RecordLiteralNode, StringLiteralNode, ArrayLiteralNode, SourceComponentInfo, DateLiteralNode, TimestampLiteralNode, TimestamptzLiteralNode, TimeLiteralExpr, TypecastExpr, BuildManifest, BuildManifestEntry, } from './model';
+export { isSourceDef, isAtomic, isBasicAtomic, isCompoundArrayData, isJoined, isJoinedSource, isSamplingEnable, isSamplingPercent, isSamplingRows, isRepeatedRecord, isBasicArray, mkArrayDef, mkFieldDef, expressionIsAggregate, expressionIsAnalytic, expressionIsCalculation, expressionIsScalar, expressionIsUngroupedAggregate, indent, composeSQLExpr, isTimestampUnit, isDateUnit, constantExprToSQL, } 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 './api/foundation';
 export type { PreparedQuery, Field, AtomicField, ExploreField, QueryField, SortableField, DataArray, DataRecord, DataColumn, DataArrayOrRecord, Loggable, ModelMaterializer, DocumentTablePath, DocumentSymbol, ResultJSON, PreparedResultJSON, PreparedResultMaterializer, ExploreMaterializer, WriteStream, SerializedExplore, ModelCache, CachedModel, DateField, TimestampField, } from './api/foundation';
 export type { QueryOptionsReader, RunSQLOptions } from './run_sql_options';
 export type { EventStream, ModelString, ModelURL, QueryString, QueryURL, URLReader, InvalidationKey, } from './runtime_types';
-export type { Connection, ConnectionConfig, ConnectionFactory, ConnectionParameter, ConnectionParameterValue, ConnectionConfigSchema, FetchSchemaOptions, InfoConnection, LookupConnection, PersistSQLResults, PooledConnection, TestableConnection, StreamingConnection, } from './connection/types';
+export type { Connection, ConnectionConfig, ConnectionParameterValue, FetchSchemaOptions, InfoConnection, LookupConnection, PersistSQLResults, PooledConnection, TestableConnection, StreamingConnection, } from './connection/types';
+export { registerConnectionType, getConnectionProperties, getRegisteredConnectionTypes, readConnectionsConfig, writeConnectionsConfig, createConnectionsFromConfig, } from './connection/registry';
+export type { ConnectionTypeFactory, ConnectionPropertyType, ConnectionPropertyDefinition, ConnectionTypeDef, ConnectionConfigEntry, ConnectionsConfig, } from './connection/registry';
 export { toAsyncGenerator } from './connection_utils';
 export { modelDefToModelInfo, sourceDefToSourceInfo, writeMalloyObjectToTag, extractMalloyObjectFromTag, } from './to_stable';
 export * as API from './api';