@malloydata/malloy 0.0.196-dev241007221852 → 0.0.196-dev241007232826

package/dist/dialect/dialect.d.ts

@@ -59,6 +59,8 @@ export declare abstract class Dialect {
     hasModOperator: boolean;
     supportsLeftJoinUnnest: boolean;
     supportsCountApprox: boolean;
+    supportsFullJoin: boolean;
+    nativeBoolean: boolean;
     abstract getDialectFunctionOverrides(): {
         [name: string]: DialectFunctionOverloadDef[];
     };
@@ -76,7 +78,7 @@ export declare abstract class Dialect {
     abstract sqlSumDistinctHashedKey(sqlDistinctKey: string): string;
     abstract sqlGenerateUUID(): string;
     abstract sqlFieldReference(alias: string, fieldName: string, fieldType: string, isNested: boolean, isArray: boolean): string;
-    abstract sqlUnnestPipelineHead(isSingleton: boolean, sourceSQLExpression: string): string;
+    abstract sqlUnnestPipelineHead(isSingleton: boolean, sourceSQLExpression: string, fieldList?: DialectFieldList): string;
     abstract sqlCreateFunction(id: string, funcText: string): string;
     abstract sqlCreateFunctionCombineLastStage(lastStageName: string, fieldList: DialectFieldList): string;
     abstract sqlCreateTableAsSelect(tableName: string, sql: string): string;

package/dist/dialect/dialect.js

@@ -81,6 +81,9 @@ class Dialect {
         // can LEFT JOIN UNNEST
         this.supportsLeftJoinUnnest = true;
         this.supportsCountApprox = false;
+        // MYSQL doesn't have full join, maybe others.
+        this.supportsFullJoin = true;
+        this.nativeBoolean = true;
     }
     sqlFinalStage(_lastStageName, _fields) {
         throw new Error('Dialect has no final Stage but called Anyway');

package/dist/dialect/dialect_map.js

@@ -28,6 +28,7 @@ const postgres_1 = require("./postgres");
 const snowflake_1 = require("./snowflake");
 const standardsql_1 = require("./standardsql");
 const trino_1 = require("./trino");
+const mysql_1 = require("./mysql");
 const dialectMap = new Map();
 function getDialect(name) {
     const d = dialectMap.get(name);
@@ -51,4 +52,5 @@ registerDialect(new duckdb_1.DuckDBDialect());
 registerDialect(new snowflake_1.SnowflakeDialect());
 registerDialect(new trino_1.TrinoDialect());
 registerDialect(new trino_1.PrestoDialect());
+registerDialect(new mysql_1.MySQLDialect());
 //# sourceMappingURL=dialect_map.js.map

package/dist/dialect/index.d.ts

@@ -7,6 +7,7 @@ export { PostgresDialect } from './postgres';
 export { DuckDBDialect } from './duckdb';
 export { SnowflakeDialect } from './snowflake';
 export { TrinoDialect } from './trino';
+export { MySQLDialect } from './mysql';
 export { getDialect, registerDialect } from './dialect_map';
 export { getMalloyStandardFunctions } from './functions';
 export type { MalloyStandardFunctionImplementations } from './functions';

package/dist/dialect/index.js

@@ -22,7 +22,7 @@
  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getMalloyStandardFunctions = exports.registerDialect = exports.getDialect = exports.TrinoDialect = exports.SnowflakeDialect = exports.DuckDBDialect = exports.PostgresDialect = exports.StandardSQLDialect = exports.qtz = exports.Dialect = exports.sql = exports.literal = exports.variadicParam = exports.param = exports.spread = exports.maxScalar = exports.minAggregate = exports.minScalar = exports.overload = exports.makeParam = exports.anyExprType = exports.arg = void 0;
+exports.getMalloyStandardFunctions = exports.registerDialect = exports.getDialect = exports.MySQLDialect = exports.TrinoDialect = exports.SnowflakeDialect = exports.DuckDBDialect = exports.PostgresDialect = exports.StandardSQLDialect = exports.qtz = exports.Dialect = exports.sql = exports.literal = exports.variadicParam = exports.param = exports.spread = exports.maxScalar = exports.minAggregate = exports.minScalar = exports.overload = exports.makeParam = exports.anyExprType = exports.arg = void 0;
 var util_1 = require("./functions/util");
 Object.defineProperty(exports, "arg", { enumerable: true, get: function () { return util_1.arg; } });
 Object.defineProperty(exports, "anyExprType", { enumerable: true, get: function () { return util_1.anyExprType; } });
@@ -49,6 +49,8 @@ var snowflake_1 = require("./snowflake");
 Object.defineProperty(exports, "SnowflakeDialect", { enumerable: true, get: function () { return snowflake_1.SnowflakeDialect; } });
 var trino_1 = require("./trino");
 Object.defineProperty(exports, "TrinoDialect", { enumerable: true, get: function () { return trino_1.TrinoDialect; } });
+var mysql_1 = require("./mysql");
+Object.defineProperty(exports, "MySQLDialect", { enumerable: true, get: function () { return mysql_1.MySQLDialect; } });
 var dialect_map_1 = require("./dialect_map");
 Object.defineProperty(exports, "getDialect", { enumerable: true, get: function () { return dialect_map_1.getDialect; } });
 Object.defineProperty(exports, "registerDialect", { enumerable: true, get: function () { return dialect_map_1.registerDialect; } });

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

@@ -0,0 +1,2 @@
+import { DefinitionBlueprintMap } from '../functions/util';
+export declare const MYSQL_DIALECT_FUNCTIONS: DefinitionBlueprintMap;

package/dist/dialect/mysql/dialect_functions.js

@@ -0,0 +1,51 @@
+"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.MYSQL_DIALECT_FUNCTIONS = void 0;
+const string_agg = {
+    default_separator: {
+        takes: { 'value': { dimension: 'string' } },
+        returns: { measure: 'string' },
+        supportsOrderBy: true,
+        impl: { sql: 'GROUP_CONCAT(${value} ${order_by:})' },
+    },
+    with_separator: {
+        takes: {
+            'value': { dimension: 'string' },
+            'separator': { literal: 'string' },
+        },
+        returns: { measure: 'string' },
+        supportsOrderBy: true,
+        impl: { sql: 'GROUP_CONCAT(${value} ${order_by:} SEPARATOR ${separator})' },
+    },
+};
+const string_agg_distinct = {
+    default_separator: {
+        ...string_agg['default_separator'],
+        isSymmetric: true,
+        supportsOrderBy: 'only_default',
+        impl: {
+            sql: 'GROUP_CONCAT(DISTINCT ${value} ${order_by:})',
+            defaultOrderByArgIndex: 0,
+        },
+    },
+    with_separator: {
+        ...string_agg['with_separator'],
+        isSymmetric: true,
+        supportsOrderBy: 'only_default',
+        impl: {
+            sql: 'GROUP_CONCAT(DISTINCT ${value} ${order_by:} SEPARATOR ${separator})',
+            defaultOrderByArgIndex: 0,
+        },
+    },
+};
+exports.MYSQL_DIALECT_FUNCTIONS = {
+    string_agg,
+    string_agg_distinct,
+};
+//# sourceMappingURL=dialect_functions.js.map

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

@@ -0,0 +1,2 @@
+import { MalloyStandardFunctionImplementations as OverrideMap } from '../functions/malloy_standard_functions';
+export declare const MYSQL_MALLOY_STANDARD_OVERLOADS: OverrideMap;

package/dist/dialect/mysql/function_overrides.js

@@ -0,0 +1,51 @@
+"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.MYSQL_MALLOY_STANDARD_OVERLOADS = void 0;
+exports.MYSQL_MALLOY_STANDARD_OVERLOADS = {
+    regexp_extract: { function: 'REGEXP_SUBSTR' },
+    replace: {
+        // In Postgres we specifically need to say that the replacement should be global.
+        regular_expression: {
+            sql: 'REGEXP_REPLACE(${value}, ${pattern}, ${replacement}, 1,0)',
+        },
+    },
+    trunc: {
+        to_integer: {
+            sql: '(FLOOR(${value}) + IF(${value} < 0,1,0))',
+        },
+        to_precision: {
+            sql: '(ABS(FLOOR(${value} * POW(10,${precision}))/POW(10,${precision}))*IF(${value} < 0, -1, 1))',
+        },
+    },
+    log: {
+        sql: 'log(${base},${value})',
+    },
+    div: { sql: 'FLOOR(${dividend} / ${divisor})' },
+    strpos: { sql: 'LOCATE(${search_string},${test_string})' },
+    starts_with: { sql: "COALESCE(${value} LIKE CONCAT(${prefix}, '%'),0)" },
+    ends_with: { sql: "COALESCE(${value} LIKE CONCAT('%',${suffix}),0)" },
+    trim: {
+        characters: {
+            sql: 'TRIM(BOTH ${trim_characters} FROM ${value})',
+        },
+    },
+    ltrim: {
+        characters: {
+            sql: 'TRIM(LEADING ${trim_characters} FROM ${value})',
+        },
+    },
+    rtrim: {
+        characters: {
+            sql: 'TRIM(TRAILING ${trim_characters} FROM ${value})',
+        },
+    },
+    byte_length: { sql: '(LENGTH(CAST(${value} AS VARBINARY)))' },
+    chr: { sql: "CASE WHEN ${value} = 0 THEN '' ELSE CHR(${value}) END" },
+};
+//# sourceMappingURL=function_overrides.js.map

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

@@ -0,0 +1 @@
+export * from './mysql';

package/dist/dialect/mysql/index.js

@@ -0,0 +1,24 @@
+"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.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./mysql"), exports);
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,78 @@
+import { Sampling, MeasureTimeExpr, TimeLiteralNode, RegexMatchExpr, TimeDeltaExpr, TimeTruncExpr, TimeExtractExpr, TypecastExpr, LeafAtomicDef, AtomicTypeDef } from '../../model/malloy_types';
+import { Dialect, DialectFieldList, QueryInfo } from '../dialect';
+import { DialectFunctionOverloadDef } from '../functions';
+export declare class MySQLDialect extends Dialect {
+    name: string;
+    defaultNumberType: string;
+    defaultDecimalType: string;
+    udfPrefix: string;
+    hasFinalStage: boolean;
+    stringTypeName: string;
+    divisionIsInteger: boolean;
+    supportsSumDistinctFunction: boolean;
+    unnestWithNumbers: boolean;
+    defaultSampling: {
+        rows: number;
+    };
+    supportUnnestArrayAgg: boolean;
+    supportsAggDistinct: boolean;
+    supportsCTEinCoorelatedSubQueries: boolean;
+    supportsSafeCast: boolean;
+    dontUnionIndex: boolean;
+    supportsQualify: boolean;
+    supportsNesting: boolean;
+    experimental: boolean;
+    nativeBoolean: boolean;
+    supportsFullJoin: boolean;
+    supportsPipelinesInViews: boolean;
+    readsNestedData: boolean;
+    supportsComplexFilteredSources: boolean;
+    malloyTypeToSQLType(malloyType: AtomicTypeDef): string;
+    sqlTypeToMalloyType(sqlType: string): LeafAtomicDef;
+    quoteTablePath(tablePath: string): string;
+    sqlGroupSetTable(groupSetCount: number): string;
+    sqlAnyValue(_groupSet: number, fieldName: string): string;
+    private mapFields;
+    sqlAggregateTurtle(groupSet: number, fieldList: DialectFieldList, orderBy: string | undefined, limit: number | undefined): string;
+    sqlAnyValueTurtle(groupSet: number, fieldList: DialectFieldList): string;
+    sqlAnyValueLastTurtle(name: string, groupSet: number, sqlName: string): string;
+    sqlCoaleseMeasuresInline(groupSet: number, fieldList: DialectFieldList): string;
+    malloyToSQL(t: string): string;
+    unnestColumns(fieldList: DialectFieldList): string;
+    jsonTable(source: string, fieldList: DialectFieldList): string;
+    sqlUnnestAlias(source: string, alias: string, fieldList: DialectFieldList, _needDistinctKey: boolean, _isArray: boolean, _isInNestedPipeline: boolean): string;
+    sqlUnnestPipelineHead(_isSingleton: boolean, sourceSQLExpression: string, fieldList: DialectFieldList): string;
+    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;
+    sqlCreateFunction(id: string, funcText: string): string;
+    sqlCreateFunctionCombineLastStage(lastStageName: string): string;
+    sqlSelectAliasAsStruct(_alias: string, _fieldList: DialectFieldList): string;
+    sqlMaybeQuoteIdentifier(identifier: string): string;
+    sqlCreateTableAsSelect(_tableName: string, _sql: string): string;
+    sqlNowExpr(): string;
+    sqlTruncExpr(qi: QueryInfo, trunc: TimeTruncExpr): string;
+    truncToUnit(expr: string, units: string): string;
+    sqlTimeExtractExpr(qi: QueryInfo, te: TimeExtractExpr): string;
+    sqlAlterTimeExpr(df: TimeDeltaExpr): string;
+    sqlCast(qi: QueryInfo, cast: TypecastExpr): string;
+    sqlRegexpMatch(df: RegexMatchExpr): string;
+    sqlLiteralTime(qi: QueryInfo, lt: TimeLiteralNode): string;
+    sqlMeasureTimeExpr(df: MeasureTimeExpr): string;
+    sqlAggDistinct(_key: string, _values: string[], _func: (valNames: string[]) => string): string;
+    sqlSampleTable(tableSQL: string, sample: Sampling | undefined): string;
+    sqlOrderBy(orderTerms: string[]): string;
+    sqlLiteralString(literal: string): string;
+    sqlLiteralRegexp(literal: string): string;
+    getDialectFunctionOverrides(): {
+        [name: string]: DialectFunctionOverloadDef[];
+    };
+    getDialectFunctions(): {
+        [name: string]: DialectFunctionOverloadDef[];
+    };
+    mapFieldsForJsonObject(fieldList: DialectFieldList, nullValues?: boolean): string;
+    castToString(expression: string): string;
+    concat(...values: string[]): string;
+    validateTypeName(sqlType: string): boolean;
+}

package/dist/dialect/mysql/mysql.js

@@ -0,0 +1,450 @@
+"use strict";
+/*
+ * Copyright 2023 Google LLC
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files
+ * (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MySQLDialect = void 0;
+// import {
+//   Dialect,
+//   DialectFieldList,
+//   QueryInfo,
+//   qtz,
+//   DialectFunctionOverloadDef,
+// } from '..';
+const malloy_types_1 = require("../../model/malloy_types");
+const utils_1 = require("../../model/utils");
+const dialect_1 = require("../dialect");
+const functions_1 = require("../functions");
+const dialect_functions_1 = require("./dialect_functions");
+const function_overrides_1 = require("./function_overrides");
+const castMap = {
+    number: 'double precision',
+    string: 'varchar(255)',
+};
+const msExtractionMap = {
+    day_of_week: 'DAYOFWEEK',
+    day_of_year: 'DAYOFYEAR',
+};
+const inSeconds = {
+    second: 1,
+    minute: 60,
+    hour: 3600,
+    day: 24 * 3600,
+    week: 7 * 24 * 3600,
+};
+const mysqlToMalloyTypes = {
+    // TODO: This assumes tinyint is always going to be a boolean.
+    'tinyint': { type: 'boolean' },
+    'smallint': { type: 'number', numberType: 'integer' },
+    'mediumint': { type: 'number', numberType: 'integer' },
+    'int': { type: 'number', numberType: 'integer' },
+    'bigint': { type: 'number', numberType: 'integer' },
+    'tinyint unsigned': { type: 'number', numberType: 'integer' },
+    'smallint unsigned': { type: 'number', numberType: 'integer' },
+    'mediumint unsigned': { type: 'number', numberType: 'integer' },
+    'int unsigned': { type: 'number', numberType: 'integer' },
+    'bigint unsigned': { type: 'number', numberType: 'integer' },
+    'double': { type: 'number', numberType: 'float' },
+    'varchar': { type: 'string' },
+    'varbinary': { type: 'string' },
+    'char': { type: 'string' },
+    'text': { type: 'string' },
+    'date': { type: 'date' },
+    'datetime': { type: 'timestamp' },
+    'timestamp': { type: 'timestamp' },
+    'time': { type: 'string' },
+    'decimal': { type: 'number', numberType: 'float' },
+    // TODO: Check if we need special handling for boolean.
+    'tinyint(1)': { type: 'boolean' },
+};
+class MySQLDialect extends dialect_1.Dialect {
+    constructor() {
+        super(...arguments);
+        this.name = 'mysql';
+        this.defaultNumberType = 'DOUBLE PRECISION';
+        this.defaultDecimalType = 'DECIMAL';
+        this.udfPrefix = 'ms_temp.__udf';
+        this.hasFinalStage = false;
+        // TODO: this may not be enough for lager casts.
+        this.stringTypeName = 'VARCHAR(255)';
+        this.divisionIsInteger = true;
+        this.supportsSumDistinctFunction = true;
+        this.unnestWithNumbers = false;
+        this.defaultSampling = { rows: 50000 };
+        this.supportUnnestArrayAgg = true;
+        this.supportsAggDistinct = true;
+        this.supportsCTEinCoorelatedSubQueries = true;
+        this.supportsSafeCast = false;
+        this.dontUnionIndex = false;
+        this.supportsQualify = false;
+        this.supportsNesting = true;
+        this.experimental = true;
+        this.nativeBoolean = false;
+        this.supportsFullJoin = false;
+        this.supportsPipelinesInViews = false;
+        this.readsNestedData = false;
+        this.supportsComplexFilteredSources = false;
+    }
+    malloyTypeToSQLType(malloyType) {
+        if (malloyType.type === 'number') {
+            if (malloyType.numberType === 'integer') {
+                return 'BIGINT';
+            }
+            else {
+                return 'DOUBLE';
+            }
+        }
+        return malloyType.type;
+    }
+    sqlTypeToMalloyType(sqlType) {
+        var _a, _b;
+        // 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 (mysqlToMalloyTypes[baseSqlType.toLowerCase()] || {
+            type: 'sql native',
+            rawType: baseSqlType,
+        });
+    }
+    quoteTablePath(tablePath) {
+        return tablePath
+            .split('.')
+            .map(part => `\`${part}\``)
+            .join('.');
+    }
+    sqlGroupSetTable(groupSetCount) {
+        return `CROSS JOIN (select number - 1 as group_set from JSON_TABLE(cast(concat("[1", repeat(",1", ${groupSetCount}), "]") as JSON),"$[*]" COLUMNS(number FOR ORDINALITY)) group_set) as group_set`;
+    }
+    sqlAnyValue(_groupSet, fieldName) {
+        return `MAX(${fieldName})`;
+    }
+    mapFields(fieldList) {
+        return fieldList.map(f => `"${f.rawName}", ${f.sqlExpression}`).join(', ');
+    }
+    sqlAggregateTurtle(groupSet, fieldList, orderBy, limit) {
+        const separator = limit ? ',xrmmex' : ',';
+        let gc = `GROUP_CONCAT(
+      IF(group_set=${groupSet},
+        JSON_OBJECT(${this.mapFields(fieldList)})
+        , null
+        )
+      ${orderBy}
+      SEPARATOR '${separator}'
+    )`;
+        if (limit) {
+            gc = `SUBSTRING_INDEX(${gc}, '${separator}', ${limit})`;
+            gc = `REPLACE(${gc},'${separator}',',')`;
+        }
+        gc = `JSON_EXTRACT(CONCAT('[',${gc},']'),'$')`;
+        return gc;
+    }
+    sqlAnyValueTurtle(groupSet, fieldList) {
+        const fields = this.mapFieldsForJsonObject(fieldList);
+        return `MAX(CASE WHEN group_set=${groupSet} THEN JSON_OBJECT(${fields}) END)`;
+    }
+    sqlAnyValueLastTurtle(name, groupSet, sqlName) {
+        return `MAX(CASE WHEN group_set=${groupSet} AND ${name} IS NOT NULL THEN ${name} END) as ${sqlName}`;
+    }
+    sqlCoaleseMeasuresInline(groupSet, fieldList) {
+        const fields = this.mapFieldsForJsonObject(fieldList);
+        const nullValues = this.mapFieldsForJsonObject(fieldList, true);
+        return `COALESCE(MAX(CASE WHEN group_set=${groupSet} THEN JSON_OBJECT(${fields}) END),JSON_OBJECT(${nullValues}))`;
+    }
+    malloyToSQL(t) {
+        if (t === 'number') {
+            return 'DOUBLE';
+        }
+        else if (t === 'string') {
+            return 'TEXT';
+        }
+        else if (t === 'struct') {
+            return 'JSON';
+        }
+        else
+            return t;
+    }
+    unnestColumns(fieldList) {
+        const fields = [];
+        for (const f of fieldList) {
+            fields.push(`${this.sqlMaybeQuoteIdentifier(f.sqlOutputName)} ${this.malloyToSQL(f.type)} PATH "$.${f.rawName}"`);
+        }
+        return fields.join(',\n');
+    }
+    jsonTable(source, fieldList) {
+        return `JSON_TABLE(${source}, '$[*]'
+        COLUMNS (
+          __row_id FOR ORDINALITY,
+          ${this.unnestColumns(fieldList)}
+        )
+      )`;
+    }
+    // LTNOTE: We'll make this work with Arrays once MToy's changes land.
+    sqlUnnestAlias(source, alias, fieldList, _needDistinctKey, _isArray, _isInNestedPipeline) {
+        return `
+      LEFT JOIN ${this.jsonTable(source, fieldList)} as ${alias} ON 1=1`;
+    }
+    sqlUnnestPipelineHead(_isSingleton, sourceSQLExpression, fieldList) {
+        return this.jsonTable(sourceSQLExpression, fieldList);
+    }
+    sqlSumDistinctHashedKey(_sqlDistinctKey) {
+        return 'UNUSED';
+    }
+    sqlSumDistinct(key, value, funcName) {
+        const sqlDistinctKey = `CONCAT(${key}, '')`;
+        const upperPart = `CAST(CONV(SUBSTRING(MD5(${sqlDistinctKey}), 1, 16), 16, 10) AS DECIMAL(65, 0)) * 4294967296`;
+        const lowerPart = `CAST(CONV(SUBSTRING(MD5(${sqlDistinctKey}), 16, 8), 16, 10) AS DECIMAL(65, 0))`;
+        const hashkey = `(${upperPart} + ${lowerPart})`;
+        const v = `COALESCE(${value},0)`;
+        const sqlSum = `(SUM(DISTINCT ${hashkey} + ${v}) - SUM(DISTINCT ${hashkey}))`;
+        if (funcName === 'SUM') {
+            return sqlSum;
+        }
+        else if (funcName === 'AVG') {
+            return `(${sqlSum})/NULLIF(COUNT(DISTINCT CASE WHEN ${value} IS NOT NULL THEN ${key} END),0)`;
+        }
+        throw new Error(`Unknown Symmetric Aggregate function ${funcName}`);
+    }
+    sqlGenerateUUID() {
+        // TODO: This causes the query to become slow, figure out another way to make UUID deterministic.
+        return 'CONCAT(ROW_NUMBER() OVER(), UUID())';
+    }
+    sqlFieldReference(alias, fieldName, fieldType, isNested, _isArray) {
+        let ret = `${alias}.\`${fieldName}\``;
+        if (isNested) {
+            switch (fieldType) {
+                case 'string':
+                    ret = `CONCAT(${ret}, '')`;
+                    break;
+                // TODO: Fix this.
+                case 'number':
+                    ret = `CAST(${ret} as double)`;
+                    break;
+                case 'struct':
+                    ret = `CAST(${ret} as JSON)`;
+                    break;
+            }
+            return ret;
+        }
+        else {
+            return `${alias}.\`${fieldName}\``;
+        }
+    }
+    sqlCreateFunction(id, funcText) {
+        // TODO:
+        return `CREATE FUNCTION ${id}(JSONB) RETURNS JSONB AS $$\n${(0, utils_1.indent)(funcText)}\n$$ LANGUAGE SQL;\n`;
+    }
+    sqlCreateFunctionCombineLastStage(lastStageName) {
+        // TODO:
+        return `SELECT ARRAY((SELECT AS STRUCT * FROM ${lastStageName}))\n`;
+    }
+    sqlSelectAliasAsStruct(_alias, _fieldList) {
+        return 'MYSQL: Implement this';
+        // return `JSON_OBJECT(${physicalFieldNames
+        //   .map(name => `'${name.replace(/`/g, '')}', \`${alias}\`.${name}`)
+        //   .join(',')})`;
+    }
+    sqlMaybeQuoteIdentifier(identifier) {
+        return `\`${identifier}\``;
+    }
+    // TODO: Check what this is.
+    sqlCreateTableAsSelect(_tableName, _sql) {
+        throw new Error('Not implemented Yet');
+    }
+    sqlNowExpr() {
+        return 'LOCALTIMESTAMP';
+    }
+    // truncToUnit(sql, unit: string): string {
+    //   return `EXTRACT(${unit} FROM ${sql})`;
+    // }
+    sqlTruncExpr(qi, trunc) {
+        // LTNOTE: how come this can be undefined?
+        let truncThis = trunc.e.sql || 'why could this be undefined';
+        if (trunc.units === 'week') {
+            truncThis = `DATE_SUB(${truncThis}, INTERVAL DAYOFWEEK(${truncThis}) - 1 DAY)`;
+        }
+        if (trunc.e.dataType === 'timestamp') {
+            const tz = (0, dialect_1.qtz)(qi);
+            if (tz) {
+                const civilSource = `(CONVERT_TZ(${truncThis}, 'UTC','${tz}'))`;
+                const civilTrunc = `${this.truncToUnit(civilSource, trunc.units)}`;
+                const truncTsTz = `CONVERT_TZ(${civilTrunc}, '${tz}', 'UTC')`;
+                return `(${truncTsTz})`; // TODO: should it cast?
+            }
+        }
+        const result = `${this.truncToUnit(truncThis, trunc.units)}`;
+        return result;
+    }
+    truncToUnit(expr, units) {
+        let format = "'%Y-%m-%d %H:%i:%s'";
+        switch (units) {
+            case 'minute':
+                format = "'%Y-%m-%d %H:%i:00'";
+                break;
+            case 'hour':
+                format = "'%Y-%m-%d %H:00:00'";
+                break;
+            case 'day':
+            case 'week':
+                format = "'%Y-%m-%d 00:00:00'";
+                break;
+            case 'month':
+                format = "'%Y-%m-01 00:00:00'";
+                break;
+            case 'quarter':
+                format = `CASE WHEN MONTH(${expr}) > 9 THEN '%Y-10-01 00:00:00' WHEN MONTH(${expr}) > 6 THEN '%Y-07-01 00:00:00' WHEN MONTH(${expr}) > 3 THEN '%Y-04-01 00:00:00' ELSE '%Y-01-01 00:00:00' end`;
+                break;
+            case 'year':
+                format = "'%Y-01-01 00:00:00'";
+                break;
+        }
+        return `TIMESTAMP(DATE_FORMAT(${expr}, ${format}))`;
+    }
+    sqlTimeExtractExpr(qi, te) {
+        const msUnits = msExtractionMap[te.units] || te.units;
+        let extractFrom = te.e.sql;
+        if (te.e.dataType === 'timestamp') {
+            const tz = (0, dialect_1.qtz)(qi);
+            if (tz) {
+                extractFrom = `CONVERT_TZ(${extractFrom}, 'UTC', '${tz}')`;
+            }
+        }
+        return `${msUnits}(${extractFrom})`;
+    }
+    sqlAlterTimeExpr(df) {
+        let timeframe = df.units;
+        let n = df.kids.delta.sql;
+        if (timeframe === 'quarter') {
+            timeframe = 'month';
+            n = `${n}*3`;
+        }
+        else if (timeframe === 'week') {
+            timeframe = 'day';
+            n = `${n}*7`;
+        }
+        const interval = `INTERVAL ${n} ${timeframe} `;
+        return `(${df.kids.base.sql})${df.op}${interval}`;
+    }
+    sqlCast(qi, cast) {
+        const op = `${cast.srcType}::${cast.dstType}`;
+        const tz = (0, dialect_1.qtz)(qi);
+        if (op === 'timestamp::date' && tz) {
+            return `CAST(CONVERT_TZ(${cast.e.sql}, 'UTC', '${tz}') AS DATE) `;
+        }
+        else if (op === 'date::timestamp' && tz) {
+            return ` CONVERT_TZ(${cast.e.sql}, '${tz}', 'UTC')`;
+        }
+        if (cast.srcType !== cast.dstType) {
+            const dstType = typeof cast.dstType === 'string'
+                ? castMap[cast.dstType]
+                : cast.dstType.raw;
+            if (cast.safe) {
+                throw new Error("Mysql dialect doesn't support Safe Cast");
+            }
+            if (cast.dstType === 'string') {
+                return `CONCAT(${cast.e.sql}, '')`;
+            }
+            return `CAST(${cast.e.sql}  AS ${dstType})`;
+        }
+        // LTNOTE: I don't understand how this could be undefined.
+        return cast.e.sql || 'weirdly undefined';
+    }
+    sqlRegexpMatch(df) {
+        return `REGEXP_LIKE(${df.kids.expr.sql}, ${df.kids.regex.sql})`;
+    }
+    sqlLiteralTime(qi, lt) {
+        if (lt.dataType === 'date') {
+            return `DATE '${lt.literal}'`;
+        }
+        const tz = lt.timezone || (0, dialect_1.qtz)(qi);
+        if (tz) {
+            return ` CONVERT_TZ('${lt.literal}', '${tz}', 'UTC')`;
+        }
+        return `TIMESTAMP '${lt.literal}'`;
+    }
+    sqlMeasureTimeExpr(df) {
+        let lVal = df.kids.left.sql;
+        let rVal = df.kids.right.sql;
+        if (inSeconds[df.units]) {
+            lVal = `UNIX_TIMESTAMP(${lVal})`;
+            rVal = `UNIX_TIMESTAMP(${rVal})`;
+            const duration = `${rVal}-${lVal}`;
+            return df.units === 'second'
+                ? `FLOOR(${duration})`
+                : `FLOOR((${duration})/${inSeconds[df.units].toString()}.0)`;
+        }
+        throw new Error(`Unknown or unhandled MySQL time unit: ${df.units}`);
+    }
+    sqlAggDistinct(_key, _values, _func) {
+        throw new Error('MySQL dialect does not support nesting.');
+    }
+    sqlSampleTable(tableSQL, sample) {
+        if (sample !== undefined) {
+            if ((0, malloy_types_1.isSamplingEnable)(sample) && sample.enable) {
+                sample = this.defaultSampling;
+            }
+            if ((0, malloy_types_1.isSamplingRows)(sample)) {
+                return `(SELECT * FROM ${tableSQL} ORDER BY rand() LIMIT ${sample.rows} )`;
+            }
+            else if ((0, malloy_types_1.isSamplingPercent)(sample)) {
+                return `(SELECT * FROM (SELECT ROW_NUMBER() OVER (ORDER BY rand()) as __row_number, __source_tbl.* from ${tableSQL} as __source_tbl) as __rand_tbl where __row_number % FLOOR(100.0 / ${sample.percent}) = 1)`;
+            }
+        }
+        return tableSQL;
+    }
+    sqlOrderBy(orderTerms) {
+        return `ORDER BY ${orderTerms
+            .map(t => `${t.trim().slice(0, t.trim().lastIndexOf(' '))} IS NULL DESC, ${t}`)
+            .join(',')}`;
+    }
+    sqlLiteralString(literal) {
+        const noVirgule = literal.replace(/\\/g, '\\\\');
+        return "'" + noVirgule.replace(/'/g, "\\'") + "'";
+    }
+    sqlLiteralRegexp(literal) {
+        return "'" + literal.replace(/'/g, "''") + "'";
+    }
+    getDialectFunctionOverrides() {
+        return (0, functions_1.expandOverrideMap)(function_overrides_1.MYSQL_MALLOY_STANDARD_OVERLOADS);
+    }
+    getDialectFunctions() {
+        return (0, functions_1.expandBlueprintMap)(dialect_functions_1.MYSQL_DIALECT_FUNCTIONS);
+    }
+    mapFieldsForJsonObject(fieldList, nullValues) {
+        return fieldList
+            .map(f => `${f.sqlOutputName.replace(/`/g, "'")}, ${nullValues ? 'NULL' : f.sqlExpression}\n`)
+            .join(', ');
+    }
+    castToString(expression) {
+        return `CONCAT(${expression}, '')`;
+    }
+    concat(...values) {
+        return `CONCAT(${values.join(',')})`;
+    }
+    validateTypeName(sqlType) {
+        // Letters:              BIGINT
+        // Numbers:              INT8
+        // Spaces,
+        // Parentheses, Commas:  NUMERIC(5, 2)
+        return sqlType.match(/^[A-Za-z\s(),0-9]*$/) !== null;
+    }
+}
+exports.MySQLDialect = MySQLDialect;
+//# sourceMappingURL=mysql.js.map

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-export { DuckDBDialect, StandardSQLDialect, TrinoDialect, 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, 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 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';

package/dist/index.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-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;
+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.MySQLDialect = exports.SnowflakeDialect = exports.PostgresDialect = exports.TrinoDialect = exports.StandardSQLDialect = exports.DuckDBDialect = void 0;
+exports.Tag = exports.toAsyncGenerator = exports.Explore = exports.DataWriter = exports.Parse = exports.JSONWriter = void 0;
 /*
  * Copyright 2023 Google LLC
  *
@@ -30,6 +30,7 @@ Object.defineProperty(exports, "StandardSQLDialect", { enumerable: true, get: fu
 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, "MySQLDialect", { enumerable: true, get: function () { return dialect_1.MySQLDialect; } });
 Object.defineProperty(exports, "registerDialect", { enumerable: true, get: function () { return dialect_1.registerDialect; } });
 Object.defineProperty(exports, "arg", { enumerable: true, get: function () { return dialect_1.arg; } });
 Object.defineProperty(exports, "qtz", { enumerable: true, get: function () { return dialect_1.qtz; } });

package/dist/model/malloy_query.js

@@ -1990,6 +1990,9 @@ class QueryQuery extends QueryField {
         if ((0, malloy_types_1.isJoinedSource)(qsDef)) {
             let structSQL = qs.structSourceSQL(stageWriter);
             const matrixOperation = (qsDef.matrixOperation || 'left').toUpperCase();
+            if (!this.parent.dialect.supportsFullJoin && matrixOperation === 'FULL') {
+                throw new Error('FULL JOIN not supported');
+            }
             if (ji.makeUniqueKey) {
                 const passKeys = this.generateSQLPassthroughKeys(qs);
                 structSQL = `(SELECT ${qs.dialect.sqlGenerateUUID()} as ${qs.dialect.sqlMaybeQuoteIdentifier('__distinct_key')}, x.* ${passKeys} FROM ${structSQL} as x)`;
@@ -2634,7 +2637,7 @@ class QueryQuery extends QueryField {
             const inputStruct = {
                 type: 'nest_source',
                 name: '~pipe~',
-                pipeSQL: this.parent.dialect.sqlUnnestPipelineHead(repeatedResultType === 'inline_all_numbers', sourceSQLExpression),
+                pipeSQL: this.parent.dialect.sqlUnnestPipelineHead(repeatedResultType === 'inline_all_numbers', sourceSQLExpression, getDialectFieldList(structDef)),
                 fields: structDef.fields,
                 connection: structDef.connection,
                 dialect: structDef.dialect,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@malloydata/malloy",
-  "version": "0.0.196-dev241007221852",
+  "version": "0.0.196-dev241007232826",
   "license": "MIT",
   "exports": {
     ".": "./dist/index.js",