@malloydata/malloy 0.0.434 → 0.0.435

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

@@ -35,7 +35,6 @@ export interface MalloyCompileOptions {
     noThrowOnError?: boolean;
     eventStream?: EventStream;
     importBaseURL?: URL;
-    testEnvironment?: boolean;
     virtualMap?: VirtualMap;
 }
 export interface MalloyRunOptions {

package/dist/api/foundation/compile.js

@@ -88,9 +88,6 @@ class Malloy {
         const translator = new lang_1.MalloyTranslator(url.toString(), importBaseURL.toString(), {
             urls: { [url.toString()]: source },
         }, eventStream, (_a = options === null || options === void 0 ? void 0 : options.restrictedMode) !== null && _a !== void 0 ? _a : false);
-        if (options === null || options === void 0 ? void 0 : options.testEnvironment) {
-            translator.allDialectsEnabled = true;
-        }
         return new document_1.Parse(translator, invalidationKey);
     }
     static parse({ url, urlReader, source, eventStream, options, }) {

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

@@ -42,7 +42,6 @@ declare class FluentState<T> {
  * An environment for compiling and running Malloy queries.
  */
 export declare class Runtime {
-    isTestRuntime: boolean;
     private _urlReader;
     private _connections;
     private _eventStream;

package/dist/api/foundation/runtime.js

@@ -51,7 +51,6 @@ class FluentState {
 class Runtime {
     constructor({ urlReader, connections, connection, config, buildManifest, eventStream, cacheManager, givens, }) {
         var _a, _b;
-        this.isTestRuntime = false;
         if (config !== undefined) {
             this._config = config;
             connections = connections !== null && connections !== void 0 ? connections : config.connections;
@@ -350,14 +349,6 @@ class Runtime {
      */
     loadModel(source, options) {
         const { refreshSchemaCache, noThrowOnError } = options || {};
-        if (this.isTestRuntime) {
-            if (options === undefined) {
-                options = { testEnvironment: true };
-            }
-            else {
-                options = { ...options, testEnvironment: true };
-            }
-        }
         const compilable = source instanceof URL ? { url: source } : { source };
         return new ModelMaterializer(this, async () => {
             var _a;
@@ -369,7 +360,6 @@ class Runtime {
                 noThrowOnError,
                 eventStream: this.eventStream,
                 importBaseURL: options === null || options === void 0 ? void 0 : options.importBaseURL,
-                testEnvironment: options === null || options === void 0 ? void 0 : options.testEnvironment,
                 cacheManager: this.cacheManager,
                 virtualMap: (_a = options === null || options === void 0 ? void 0 : options.virtualMap) !== null && _a !== void 0 ? _a : this.virtualMap,
             });
@@ -631,7 +621,7 @@ class ModelMaterializer extends FluentState {
         // `restrictedMode` and `method` are named to hold them back: this entry
         // point has never honored them, and `loadRestrictedQuery` is how a caller
         // asks for restricted compilation.
-        const { importBaseURL, testEnvironment, refreshSchemaCache, noThrowOnError, restrictedMode: _restrictedMode, method: _method, ...callQueryOptions } = options !== null && options !== void 0 ? options : {};
+        const { importBaseURL, refreshSchemaCache, noThrowOnError, restrictedMode: _restrictedMode, method: _method, ...callQueryOptions } = options !== null && options !== void 0 ? options : {};
         const compileQueryOptions = {
             ...this.compileQueryOptions,
             ...callQueryOptions,
@@ -647,7 +637,6 @@ class ModelMaterializer extends FluentState {
                 refreshSchemaCache,
                 noThrowOnError,
                 importBaseURL,
-                testEnvironment: testEnvironment || this.runtime.isTestRuntime,
                 ...compileQueryOptions,
                 virtualMap: (_a = compileQueryOptions.virtualMap) !== null && _a !== void 0 ? _a : this.runtime.virtualMap,
             });
@@ -701,7 +690,6 @@ class ModelMaterializer extends FluentState {
         return this.makeQueryMaterializer(async () => {
             const urlReader = this.runtime.urlReader;
             const connections = this.runtime.connections;
-            const testEnvironment = this.runtime.isTestRuntime ? true : undefined;
             const model = await this.getModel();
             const queryModel = await compile_1.Malloy.compile({
                 source: text,
@@ -710,7 +698,6 @@ class ModelMaterializer extends FluentState {
                 urlReader,
                 connections,
                 model,
-                testEnvironment,
                 ...this.compileQueryOptions,
             });
             return queryModel.preparedQuery;
@@ -726,14 +713,6 @@ class ModelMaterializer extends FluentState {
     extendModel(query, options) {
         var _a, _b;
         const virtualMap = (_a = options === null || options === void 0 ? void 0 : options.virtualMap) !== null && _a !== void 0 ? _a : (_b = this.compileQueryOptions) === null || _b === void 0 ? void 0 : _b.virtualMap;
-        if (this.runtime.isTestRuntime) {
-            if (options === undefined) {
-                options = { testEnvironment: true };
-            }
-            else {
-                options = { ...options, testEnvironment: true };
-            }
-        }
         return new ModelMaterializer(this.runtime, async () => {
             const urlReader = this.runtime.urlReader;
             const connections = this.runtime.connections;
@@ -748,7 +727,6 @@ class ModelMaterializer extends FluentState {
                 refreshSchemaCache: options === null || options === void 0 ? void 0 : options.refreshSchemaCache,
                 noThrowOnError: options === null || options === void 0 ? void 0 : options.noThrowOnError,
                 importBaseURL: options === null || options === void 0 ? void 0 : options.importBaseURL,
-                testEnvironment: options === null || options === void 0 ? void 0 : options.testEnvironment,
                 ...this.compileQueryOptions,
                 virtualMap: virtualMap !== null && virtualMap !== void 0 ? virtualMap : this.runtime.virtualMap,
             });

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

@@ -20,7 +20,6 @@ export interface Loggable {
 }
 export interface ParseOptions {
     importBaseURL?: URL;
-    testEnvironment?: boolean;
     /** Reject language constructs that reach outside the trusted model. */
     restrictedMode?: boolean;
     /**

package/dist/dialect/dialect.d.ts

@@ -83,6 +83,7 @@ export declare function qtz(qi: QueryInfo): string | undefined;
  */
 export declare function turtleGroupSetCondition(groupSet: number | undefined, filterSQL: string | undefined): string | undefined;
 export type OrderByClauseType = 'output_name' | 'ordinal' | 'expression';
+export type GroupByClauseType = 'ordinal' | 'expression';
 export type OrderByRequest = 'query' | 'turtle' | 'analytical';
 export type BooleanTypeSupport = 'supported' | 'simulated' | 'none';
 /**
@@ -115,6 +116,14 @@ export declare abstract class Dialect {
     abstract supportsSafeCast: boolean;
     abstract supportsNesting: boolean;
     abstract experimental: boolean;
+    /**
+     * What the compiler consults, not `experimental` itself. The test harness
+     * calls `acceptExperimental()` on the dialect under test so the shared
+     * suites can run on an experimental dialect without every test enabling it.
+     */
+    private experimentalAccepted;
+    isExperimental(): boolean;
+    acceptExperimental(): void;
     cantPartitionWindowFunctionsOnExpressions: boolean;
     sqlLateralJoinBag(_expressions: LateralJoinExpression[]): string;
     supportsPipelinesInViews: boolean;
@@ -123,6 +132,9 @@ export declare abstract class Dialect {
     hasTimestamptz: boolean;
     readsNestedData: boolean;
     orderByClause: OrderByClauseType;
+    groupByClause: GroupByClauseType;
+    /** The ordering and row limit which end a SELECT stage */
+    sqlOrderByLimit(orderTerms: string[], limit: number | undefined): string;
     nullMatchesFunctionSignature: boolean;
     supportsSelectReplace: boolean;
     supportsBigIntPrecision: boolean;
@@ -140,6 +152,7 @@ export declare abstract class Dialect {
     compoundObjectInSchema: boolean;
     booleanType: BooleanTypeSupport;
     likeEscape: boolean;
+    likeExtraWildcards: string[];
     /**
      * Mappings from integer value ranges to Malloy number types.
      *
@@ -503,7 +516,7 @@ export declare abstract class Dialect {
     exprToSQL(qi: QueryInfo, df: Expr): string | undefined;
     sqlSumDistinct(_key: string, _value: string, _funcName: string): string;
     sqlAggDistinct(_key: string, _values: string[], _func: (valNames: string[]) => string): string;
-    sqlSampleTable(tableSQL: string, sample: Sampling | undefined): string;
+    sqlSampleTable(tableSQL: string, sample: Sampling | undefined, _onBaseTable?: boolean): string;
     /**
      * MySQL is NULLs first, all other dialects have a way to make NULLs last.
      * isBaseOrdering is a hack to allow the MySQL dialect to partially implement

package/dist/dialect/dialect.js

@@ -81,6 +81,12 @@ function turtleGroupSetCondition(groupSet, filterSQL) {
 }
 class Dialect {
     constructor() {
+        /**
+         * What the compiler consults, not `experimental` itself. The test harness
+         * calls `acceptExperimental()` on the dialect under test so the shared
+         * suites can run on an experimental dialect without every test enabling it.
+         */
+        this.experimentalAccepted = false;
         // -- we should add flags with default values from now on so as to not break
         // dialects outside our repository
         //
@@ -106,6 +112,9 @@ class Dialect {
         this.readsNestedData = true;
         // ORDER BY 1 DESC
         this.orderByClause = 'ordinal';
+        // GROUP BY 1, or GROUP BY the dimension expressions for an engine whose
+        // GROUP BY takes no ordinals
+        this.groupByClause = 'ordinal';
         // null will match in a function signature
         this.nullMatchesFunctionSignature = true;
         // support select * replace(...)
@@ -147,6 +156,8 @@ class Dialect {
         this.booleanType = 'supported';
         // Like characters are escaped with ESCAPE clause
         this.likeEscape = true;
+        // Characters LIKE reads as wildcards beyond % and _, escaped like them
+        this.likeExtraWildcards = [];
         /**
          * Mappings from integer value ranges to Malloy number types.
          *
@@ -209,6 +220,12 @@ class Dialect {
          */
         this.identifierEscapeStyle = exports.EscapeStyle.Unset;
     }
+    isExperimental() {
+        return this.experimental && !this.experimentalAccepted;
+    }
+    acceptExperimental() {
+        this.experimentalAccepted = true;
+    }
     // Generate the lateral join bag clause for window function partitioning.
     // The expressions are dimension fields that need to be referenced by name
     // in PARTITION BY clauses. Must be overridden by any dialect that sets
@@ -219,6 +236,14 @@ class Dialect {
         }
         throw new Error('Internal error: sqlLateralJoinBag called but cantPartitionWindowFunctionsOnExpressions is false');
     }
+    /** The ordering and row limit which end a SELECT stage */
+    sqlOrderByLimit(orderTerms, limit) {
+        let s = orderTerms.length > 0 ? this.sqlOrderBy(orderTerms, 'query') + '\n' : '';
+        if (limit !== undefined) {
+            s += `LIMIT ${limit}\n`;
+        }
+        return s;
+    }
     /**
      * Determine the Malloy number type for a numeric literal.
      */
@@ -623,7 +648,9 @@ class Dialect {
     _func) {
         return 'sqlAggDistinct called but not implemented';
     }
-    sqlSampleTable(tableSQL, sample) {
+    // onBaseTable: the source is a table the engine can sample in place; a
+    // dialect whose sampling reads the table itself ignores a sample elsewhere
+    sqlSampleTable(tableSQL, sample, _onBaseTable = true) {
         if (sample !== undefined) {
             throw new Error(`Sampling is not supported on dialect ${this.name}.`);
         }
@@ -694,6 +721,11 @@ class Dialect {
                 escapeActive = false;
                 escapeClause = true;
             }
+            else if (this.likeEscape && this.likeExtraWildcards.includes(c)) {
+                escaped += '^' + c;
+                escapeActive = false;
+                escapeClause = true;
+            }
             else {
                 if (escapeActive) {
                     if (this.likeEscape) {
@@ -720,7 +752,7 @@ class Dialect {
      */
     sqlBoolean(bv) {
         if (this.booleanType === 'none') {
-            return bv ? '(1=1)' : '(1-0)';
+            return bv ? '(1=1)' : '(1=0)';
         }
         return bv ? 'true' : 'false';
     }

package/dist/dialect/dialect_map.js

@@ -14,6 +14,7 @@ const standardsql_1 = require("./standardsql");
 const trino_1 = require("./trino");
 const mysql_1 = require("./mysql");
 const databricks_1 = require("./databricks");
+const sqlserver_1 = require("./sqlserver");
 const dialectMap = new Map();
 function getDialect(name) {
     const d = dialectMap.get(name);
@@ -36,4 +37,5 @@ registerDialect(new trino_1.TrinoDialect());
 registerDialect(new trino_1.PrestoDialect());
 registerDialect(new mysql_1.MySQLDialect());
 registerDialect(new databricks_1.DatabricksDialect());
+registerDialect(new sqlserver_1.SQLServerDialect());
 //# sourceMappingURL=dialect_map.js.map

package/dist/dialect/index.d.ts

@@ -1,7 +1,7 @@
 export type { DialectFunctionOverloadDef, DefinitionBlueprint, DefinitionBlueprintMap, OverloadedDefinitionBlueprint, } from './functions/util';
 export { arg, anyExprType, makeParam, overload, minScalar, minAggregate, maxScalar, spread, param, variadicParam, literal, sql, } from './functions/util';
 export { Dialect, qtz } from './dialect';
-export type { DialectFieldList, CompiledOrderBy, LateralJoinExpression, QueryInfo, FieldReferenceType, } from './dialect';
+export type { DialectFieldList, CompiledOrderBy, LateralJoinExpression, QueryInfo, FieldReferenceType, GroupByClauseType, OrderByClauseType, } from './dialect';
 export { StandardSQLDialect } from './standardsql';
 export { PostgresDialect } from './postgres';
 export { DuckDBDialect } from './duckdb';
@@ -9,6 +9,7 @@ export { SnowflakeDialect } from './snowflake';
 export { TrinoDialect } from './trino';
 export { MySQLDialect } from './mysql';
 export { DatabricksDialect } from './databricks';
+export { SQLServerDialect } from './sqlserver';
 export { getDialect, registerDialect } from './dialect_map';
 export { getMalloyStandardFunctions } from './functions';
 export type { MalloyStandardFunctionImplementations } from './functions';

package/dist/dialect/index.js

@@ -4,7 +4,7 @@
  * SPDX-License-Identifier: MIT
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.validateDottedTablePath = exports.decodeDottedTablePath = exports.TinyParser = exports.getMalloyStandardFunctions = exports.registerDialect = exports.getDialect = exports.DatabricksDialect = 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;
+exports.validateDottedTablePath = exports.decodeDottedTablePath = exports.TinyParser = exports.getMalloyStandardFunctions = exports.registerDialect = exports.getDialect = exports.SQLServerDialect = exports.DatabricksDialect = 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; } });
@@ -35,6 +35,8 @@ var mysql_1 = require("./mysql");
 Object.defineProperty(exports, "MySQLDialect", { enumerable: true, get: function () { return mysql_1.MySQLDialect; } });
 var databricks_1 = require("./databricks");
 Object.defineProperty(exports, "DatabricksDialect", { enumerable: true, get: function () { return databricks_1.DatabricksDialect; } });
+var sqlserver_1 = require("./sqlserver");
+Object.defineProperty(exports, "SQLServerDialect", { enumerable: true, get: function () { return sqlserver_1.SQLServerDialect; } });
 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/sqlserver/dialect_functions.d.ts

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

package/dist/dialect/sqlserver/dialect_functions.js

@@ -0,0 +1,42 @@
+"use strict";
+/*
+ * Copyright Contributors to the Malloy project
+ * SPDX-License-Identifier: MIT
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SQLSERVER_DIALECT_FUNCTIONS = void 0;
+const util_1 = require("../functions/util");
+const order_by = {
+    node: 'aggregate_order_by',
+    prefix: ' WITHIN GROUP (',
+    suffix: ')',
+};
+// STRING_AGG's result is limited to 8000 bytes unless its input is a MAX type.
+const string_agg = {
+    default_separator: {
+        takes: { 'value': { dimension: 'string' } },
+        returns: { measure: 'string' },
+        supportsOrderBy: true,
+        impl: {
+            expr: (0, util_1.sql) `STRING_AGG(CAST(${(0, util_1.arg)('value')} AS NVARCHAR(MAX)), ',')${order_by}`,
+        },
+    },
+    with_separator: {
+        takes: {
+            'value': { dimension: 'string' },
+            'separator': { literal: 'string' },
+        },
+        returns: { measure: 'string' },
+        supportsOrderBy: true,
+        impl: {
+            expr: (0, util_1.sql) `STRING_AGG(CAST(${(0, util_1.arg)('value')} AS NVARCHAR(MAX)), ${(0, util_1.arg)('separator')})${order_by}`,
+        },
+    },
+};
+// No string_agg_distinct: STRING_AGG accepts no DISTINCT, so the translator
+// reports the function as unknown for this dialect.
+exports.SQLSERVER_DIALECT_FUNCTIONS = {
+    string_agg,
+    ...(0, util_1.def)('reverse', { 'str': 'string' }, 'string'),
+};
+//# sourceMappingURL=dialect_functions.js.map

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

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

package/dist/dialect/sqlserver/function_overrides.js

@@ -0,0 +1,55 @@
+"use strict";
+/*
+ * Copyright Contributors to the Malloy project
+ * SPDX-License-Identifier: MIT
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SQLSERVER_MALLOY_STANDARD_OVERLOADS = void 0;
+// LEN ignores trailing spaces: append one character, count, subtract one
+const len = (arg) => `(LEN(${arg} + N'x') - 1)`;
+exports.SQLSERVER_MALLOY_STANDARD_OVERLOADS = {
+    ceil: { function: 'CEILING' },
+    chr: { sql: "CASE WHEN ${value} = 0 THEN '' ELSE NCHAR(${value}) END" },
+    div: { sql: 'FLOOR(${dividend} / ${divisor})' },
+    // starts_with and ends_with are written as comparisons because SQL Server
+    // has no boolean values: legal as a condition (where:, having:), a server
+    // error as a value. A NULL input matches nothing, where the standard's
+    // COALESCE(..., false) returns false.
+    ends_with: {
+        sql: `RIGHT(\${value}, ${len('${suffix}')}) = \${suffix}`,
+    },
+    ifnull: { function: 'ISNULL' },
+    // A FLOAT holds neither infinity nor NaN, so neither condition is ever true
+    is_inf: { sql: '(1=0)' },
+    is_nan: { sql: '(1=0)' },
+    length: { sql: len('${value}') },
+    ln: { sql: 'LOG(${value})' },
+    log: { sql: 'LOG(${value}, ${base})' },
+    // POWER answers in the type of its base, so an integer base truncates
+    pow: { sql: 'POWER(CAST(${base} AS FLOAT(53)), ${exponent})' },
+    round: {
+        to_integer: { sql: 'ROUND(${value}, 0)' },
+        to_precision: { sql: 'ROUND(${value}, ${precision})' },
+    },
+    atan2: { function: 'ATN2' },
+    trim: { characters: { sql: 'TRIM(${trim_characters} FROM ${value})' } },
+    starts_with: {
+        sql: `LEFT(\${value}, ${len('${prefix}')}) = \${prefix}`,
+    },
+    stddev: { function: 'STDEV' },
+    string_repeat: { function: 'REPLICATE' },
+    strpos: { sql: 'CHARINDEX(${search_string}, ${test_string})' },
+    substr: {
+        position_only: {
+            sql: `SUBSTRING(\${value}, CASE WHEN \${position} < 0 THEN ${len('${value}')} + \${position} + 1 ELSE \${position} END, ${len('${value}')})`,
+        },
+        with_length: {
+            sql: `SUBSTRING(\${value}, CASE WHEN \${position} < 0 THEN ${len('${value}')} + \${position} + 1 ELSE \${position} END, \${length})`,
+        },
+    },
+    trunc: {
+        to_integer: { sql: 'ROUND(${value}, 0, 1)' },
+        to_precision: { sql: 'ROUND(${value}, ${precision}, 1)' },
+    },
+};
+//# sourceMappingURL=function_overrides.js.map

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

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

package/dist/dialect/sqlserver/index.js

@@ -0,0 +1,22 @@
+"use strict";
+/*
+ * Copyright Contributors to the Malloy project
+ * SPDX-License-Identifier: MIT
+ */
+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("./sqlserver"), exports);
+//# sourceMappingURL=index.js.map

package/dist/dialect/sqlserver/sqlserver.d.ts

@@ -0,0 +1,102 @@
+import type { Sampling, AtomicTypeDef, ATimestampTypeDef, TypecastExpr, MeasureTimeExpr, BasicAtomicTypeDef, RegexMatchExpr, TimeExtractExpr, TimestampUnit, OrderBy } from '../../model/malloy_types';
+import type { DialectFunctionOverloadDef } from '../functions';
+import type { BooleanTypeSupport, DialectFieldList, FieldReferenceType, GroupByClauseType, QueryInfo } from '../dialect';
+import { Dialect } from '../dialect';
+import type { ValidateTablePathResult } from '../table-path';
+/** T-SQL for SQL Server 2017 and later, and Azure SQL Database. */
+export declare class SQLServerDialect extends Dialect {
+    name: string;
+    experimental: boolean;
+    stringLiteralStyle: "doubled";
+    identifierEscapeStyle: "doubled";
+    identifierQuoteChar: string;
+    defaultNumberType: string;
+    defaultDecimalType: string;
+    udfPrefix: string;
+    hasFinalStage: boolean;
+    divisionIsInteger: boolean;
+    supportsSumDistinctFunction: boolean;
+    unnestWithNumbers: boolean;
+    defaultSampling: {
+        rows: number;
+    };
+    supportUnnestArrayAgg: boolean;
+    supportsAggDistinct: boolean;
+    supportsCTEinCoorelatedSubQueries: boolean;
+    dontUnionIndex: boolean;
+    supportsQualify: boolean;
+    supportsSafeCast: boolean;
+    supportsNesting: boolean;
+    supportsPipelinesInViews: boolean;
+    supportsFullJoin: boolean;
+    readsNestedData: boolean;
+    supportsComplexFilteredSources: boolean;
+    supportsArraysInData: boolean;
+    compoundObjectInSchema: boolean;
+    supportsSelectReplace: boolean;
+    supportsTempTables: boolean;
+    booleanType: BooleanTypeSupport;
+    hasTimestamptz: boolean;
+    supportsBigIntPrecision: boolean;
+    maxIdentifierLength: number;
+    likeEscape: boolean;
+    likeExtraWildcards: string[];
+    groupByClause: GroupByClauseType;
+    tablePathBareIdentRegex: RegExp;
+    /**
+     * `[schema].[table]` is read as the ANSI-quoted path it stands for, and the
+     * canonical form is the ANSI spelling the base validates.
+     */
+    sqlValidateTableName(input: string): ValidateTablePathResult;
+    malloyTypeToSQLType(malloyType: AtomicTypeDef): string;
+    sqlTypeToMalloyType(sqlType: string): BasicAtomicTypeDef;
+    validateTypeName(sqlType: string): boolean;
+    sqlGroupSetTable(groupSetCount: number): string;
+    sqlAnyValue(_groupSet: number, fieldName: string): string;
+    sqlAggregateTurtle(): string;
+    sqlAnyValueTurtle(): string;
+    sqlAnyValueLastTurtle(): string;
+    sqlCoaleseMeasuresInline(): string;
+    sqlUnnestAlias(): string;
+    sqlSelectAliasAsStruct(): string;
+    sqlLiteralRecord(): string;
+    sqlLiteralArray(): string;
+    sqlFieldReference(parentAlias: string, _parentType: FieldReferenceType, childName: string, _childType: string): string;
+    private unsupported;
+    sqlUnnestPipelineHead(_isSingleton: boolean, _sourceSQLExpression: string, _fieldList?: DialectFieldList): string;
+    sqlCreateFunction(_id: string, _funcText: string): string;
+    sqlCreateFunctionCombineLastStage(_lastStageName: string, _fieldList: DialectFieldList, _orderBy: OrderBy[] | undefined): string;
+    sqlCreateTableAsSelect(tableName: string, sql: string): string;
+    sqlGenerateUUID(): string;
+    sqlLiteralString(literal: string): string;
+    sqlSumDistinctHashedKey(sqlDistinctKey: string): string;
+    sqlSumDistinct(key: string, value: string, funcName: string): string;
+    sqlAggDistinct(_key: string, _values: string[], _func: (valNames: string[]) => string): string;
+    sqlOrderByLimit(orderTerms: string[], limit: number | undefined): string;
+    sqlSampleTable(tableSQL: string, sample: Sampling | undefined, onBaseTable?: boolean): string;
+    castToString(expression: string): string;
+    concat(...values: string[]): string;
+    sqlDateToString(sqlDateExp: string): string;
+    sqlNowExpr(): string;
+    sqlTimeExtractExpr(qi: QueryInfo, from: TimeExtractExpr): string;
+    sqlCast(qi: QueryInfo, cast: TypecastExpr): string;
+    sqlRegexpMatch(_df: RegexMatchExpr): string;
+    sqlDateLiteral(_qi: QueryInfo, literal: string): string;
+    sqlTimestampLiteral(qi: QueryInfo, literal: string, timezone: string | undefined): string;
+    sqlTimestamptzLiteral(_qi: QueryInfo, _literal: string, _timezone: string): string;
+    sqlTimezoneLiteral(timezone: string): string;
+    sqlConvertToCivilTime(expr: string, timezone: string, _typeDef: AtomicTypeDef): {
+        sql: string;
+        typeDef: AtomicTypeDef;
+    };
+    sqlConvertFromCivilTime(expr: string, timezone: string, _destTypeDef: ATimestampTypeDef): string;
+    sqlTruncate(expr: string, unit: TimestampUnit, typeDef: AtomicTypeDef, _inCivilTime: boolean, _timezone?: string): string;
+    sqlOffsetTime(expr: string, op: '+' | '-', magnitude: string, unit: TimestampUnit, _typeDef: AtomicTypeDef, _inCivilTime: boolean, _timezone?: string): string;
+    sqlMeasureTimeExpr(df: MeasureTimeExpr): string;
+    getDialectFunctionOverrides(): {
+        [name: string]: DialectFunctionOverloadDef[];
+    };
+    getDialectFunctions(): {
+        [name: string]: DialectFunctionOverloadDef[];
+    };
+}