@malloydata/malloy 0.0.394 → 0.0.395

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

@@ -40,9 +40,7 @@ export declare class Manifest {
      */
     get strict(): boolean;
     set strict(value: boolean);
-    /**
-     * Add or replace a manifest entry. Also marks it as touched.
-     */
+    /** Add or replace a manifest entry. Also marks it as touched. */
     update(buildId: BuildID, entry: BuildManifestEntry): void;
     /**
      * Mark an existing entry as active without changing it.
@@ -257,3 +255,4 @@ export declare class MalloyConfig {
      */
     readOverlay(overlayName: string, ...path: string[]): Promise<unknown>;
 }
+export declare function isBuildManifestEntry(value: unknown): value is BuildManifestEntry;

package/dist/api/foundation/config.js

@@ -5,10 +5,12 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MalloyConfig = exports.Manifest = void 0;
+exports.isBuildManifestEntry = isBuildManifestEntry;
 const config_compile_1 = require("./config_compile");
 const config_resolve_1 = require("./config_resolve");
 const config_lookup_1 = require("./config_lookup");
 const config_overlays_1 = require("./config_overlays");
+const validate_table_path_1 = require("../../connection/validate_table_path");
 /**
  * In-memory manifest store. Reads, updates, and serializes manifest data.
  *
@@ -61,10 +63,9 @@ class Manifest {
     set strict(value) {
         this._manifest.strict = value;
     }
-    /**
-     * Add or replace a manifest entry. Also marks it as touched.
-     */
+    /** Add or replace a manifest entry. Also marks it as touched. */
     update(buildId, entry) {
+        (0, validate_table_path_1.requireCanonicalTablePathAnyDialect)(entry.tableName, `Manifest entry '${buildId}'`);
         this._manifest.entries[buildId] = entry;
         this._touched.add(buildId);
     }
@@ -102,9 +103,10 @@ class Manifest {
         // Old format: {buildId: {tableName}, ...} (flat record, no "entries" key)
         const rawEntries = isRecord(parsed['entries']) ? parsed['entries'] : parsed;
         for (const [key, val] of Object.entries(rawEntries)) {
-            if (key !== 'strict' && isBuildManifestEntry(val)) {
-                this._manifest.entries[key] = val;
-            }
+            if (key === 'strict' || !isBuildManifestEntry(val))
+                continue;
+            (0, validate_table_path_1.requireCanonicalTablePathAnyDialect)(val.tableName, `Manifest entry '${key}'`);
+            this._manifest.entries[key] = val;
         }
     }
 }
@@ -166,7 +168,7 @@ class MalloyConfig {
         this._managedLookup = (0, config_lookup_1.buildManagedLookup)(prepared.compiledConnections, mergedOverlays, log);
         this._connections = this._managedLookup;
         this._overlays = mergedOverlays;
-        this.virtualMap = toVirtualMap(prepared.virtualMap);
+        this.virtualMap = toVirtualMap(prepared.virtualMap, log);
         this.configURL = configURL;
         this.rootDirectory = rootDirectory;
         this.manifestPath = prepared.manifestPath;
@@ -441,9 +443,10 @@ function validateURLString(value, fieldName, log) {
 }
 /**
  * Convert the raw virtualMap POJO shape (a dict of dicts of strings) into
- * the runtime Map-of-Maps representation that Runtime consumes.
+ * the runtime Map-of-Maps representation. Invalid entries are dropped and
+ * logged — they'd be pasted into FROM clauses downstream otherwise.
  */
-function toVirtualMap(raw) {
+function toVirtualMap(raw, log) {
     if (!isRecord(raw))
         return undefined;
     const outer = new Map();
@@ -452,9 +455,18 @@ function toVirtualMap(raw) {
             continue;
         const innerMap = new Map();
         for (const [virtualName, tablePath] of Object.entries(inner)) {
-            if (typeof tablePath === 'string') {
-                innerMap.set(virtualName, tablePath);
+            if (typeof tablePath !== 'string')
+                continue;
+            const invalid = (0, validate_table_path_1.validateCanonicalTablePathAnyDialect)(tablePath);
+            if (invalid !== undefined) {
+                log.push({
+                    message: `virtualMap entry '${connName}.${virtualName}': ${invalid}`,
+                    severity: 'error',
+                    code: 'config-validation',
+                });
+                continue;
             }
+            innerMap.set(virtualName, tablePath);
         }
         if (innerMap.size > 0)
             outer.set(connName, innerMap);

package/dist/api/foundation/core.js

@@ -1101,7 +1101,7 @@ class PersistSource {
         const sd = this.persistableDef;
         const queryModel = this.model.queryModel;
         if (sd.type === 'sql_select') {
-            return (0, model_1.getCompiledSQL)(sd, options !== null && options !== void 0 ? options : {}, path => this.dialect.quoteTablePath(path), (query, opts) => queryModel.compileQuery(query, opts).sql);
+            return (0, model_1.getCompiledSQL)(sd, options !== null && options !== void 0 ? options : {}, (query, opts) => queryModel.compileQuery(query, opts).sql);
         }
         else {
             const compiled = queryModel.compileQuery(sd.query, options);

package/dist/api/foundation/runtime.js

@@ -7,6 +7,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ExploreMaterializer = exports.PreparedResultMaterializer = exports.QueryMaterializer = exports.ModelMaterializer = exports.SingleConnectionRuntime = exports.ConnectionRuntime = exports.Runtime = void 0;
 const model_1 = require("../../model");
 const dialect_1 = require("../../dialect");
+const validate_table_path_1 = require("../../connection/validate_table_path");
+const config_1 = require("./config");
 const row_data_utils_1 = require("../../api/row_data_utils");
 const readers_1 = require("./readers");
 const core_1 = require("./core");
@@ -221,6 +223,12 @@ class Runtime {
                     if (!isBuildManifestShape(parsed)) {
                         throw new Error('manifest is not an object with an "entries" map');
                     }
+                    for (const [buildId, entry] of Object.entries(parsed.entries)) {
+                        if (!(0, config_1.isBuildManifestEntry)(entry)) {
+                            throw new Error(`Manifest entry '${buildId}' is missing a string tableName`);
+                        }
+                        (0, validate_table_path_1.requireCanonicalTablePathAnyDialect)(entry.tableName, `Manifest entry '${buildId}'`);
+                    }
                     return parsed;
                 }
                 catch (e) {
@@ -502,7 +510,7 @@ class SingleConnectionRuntime extends Runtime {
     }
     // quote a column name
     quote(column) {
-        return (0, dialect_1.getDialect)(this.connection.dialectName).sqlMaybeQuoteIdentifier(column);
+        return (0, dialect_1.getDialect)(this.connection.dialectName).sqlQuoteIdentifier(column);
     }
     get dialect() {
         return (0, dialect_1.getDialect)(this.connection.dialectName);
@@ -834,6 +842,11 @@ class QueryMaterializer extends FluentState {
             // Pass EMPTY_BUILD_MANIFEST in options to explicitly suppress manifest substitution.
             const explicitManifest = mergedOptions.buildManifest !== undefined;
             let buildManifest = (_a = mergedOptions.buildManifest) !== null && _a !== void 0 ? _a : (await this.runtime._resolveBuildManifest());
+            if (buildManifest) {
+                for (const [buildId, entry] of Object.entries(buildManifest.entries)) {
+                    (0, validate_table_path_1.requireCanonicalTablePathAnyDialect)(entry.tableName, `Manifest entry '${buildId}'`);
+                }
+            }
             // If we have a manifest with entries, compute connectionDigests for lookups.
             // TODO: This is inefficient - we call getBuildPlan just to find connection names.
             // Consider adding a listConnections() method to LookupConnection, or caching this.
@@ -866,6 +879,13 @@ class QueryMaterializer extends FluentState {
             }
             // Use virtualMap from options if provided, otherwise fall back to Runtime's.
             const virtualMap = (_b = mergedOptions.virtualMap) !== null && _b !== void 0 ? _b : this.runtime.virtualMap;
+            if (virtualMap) {
+                for (const [connName, inner] of virtualMap) {
+                    for (const [virtualName, tablePath] of inner) {
+                        (0, validate_table_path_1.requireCanonicalTablePathAnyDialect)(tablePath, `virtualMap entry '${connName}.${virtualName}'`);
+                    }
+                }
+            }
             // Per-query supply for a finalized given is rejected at API entry
             // — the finalized-givens set is the runtime's "this can't be
             // overridden by the caller" guarantee. Fail before any IO so misuse

package/dist/api/util.js

@@ -13,6 +13,7 @@ exports.mapData = mapData;
 exports.wrapResult = wrapResult;
 exports.nodeToLiteralValue = nodeToLiteralValue;
 exports.mapLogs = mapLogs;
+const validate_table_path_1 = require("../connection/validate_table_path");
 const to_stable_1 = require("../to_stable");
 const row_data_utils_1 = require("./row_data_utils");
 function wrapLegacyInfoConnection(connection) {
@@ -31,6 +32,9 @@ function wrapLegacyInfoConnection(connection) {
             };
         },
         async fetchSchemaForTable(tableName) {
+            const invalid = (0, validate_table_path_1.validateCanonicalTablePath)(connection.dialectName, tableName);
+            if (invalid !== undefined)
+                throw new Error(invalid);
             const key = `${connection.name}:${tableName}`;
             const result = await connection.fetchSchemaForTables({ [key]: tableName }, {});
             const table = result.schemas[key];

package/dist/connection/base_connection.js

@@ -8,6 +8,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BaseConnection = void 0;
 const sql_block_1 = require("../model/sql_block");
+const validate_table_path_1 = require("./validate_table_path");
 class BaseConnection {
     constructor() {
         this.schemaCache = {};
@@ -47,6 +48,11 @@ class BaseConnection {
         const schemas = {};
         const errors = {};
         for (const [tableName, tablePath] of Object.entries(missing)) {
+            const invalid = (0, validate_table_path_1.validateCanonicalTablePath)(this.dialectName, tablePath);
+            if (invalid !== undefined) {
+                errors[tableName] = invalid;
+                continue;
+            }
             const inCache = await this.checkSchemaCache(tablePath, 'table', async () => await this.fetchTableSchema(tableName, tablePath), refreshTimestamp);
             if (inCache.schema) {
                 schemas[tableName] = inCache.schema;

package/dist/connection/validate_table_path.d.ts

@@ -0,0 +1,10 @@
+/** Validate against a known dialect. Returns an error string or undefined. */
+export declare function validateCanonicalTablePath(dialectName: string, tablePath: string): string | undefined;
+/**
+ * Validate against any registered dialect. Used at boundaries where the
+ * destination dialect isn't synchronously known (virtualMap, manifest
+ * entries).
+ */
+export declare function validateCanonicalTablePathAnyDialect(tablePath: string): string | undefined;
+/** Throw if `tablePath` isn't canonical SQL in any registered dialect. */
+export declare function requireCanonicalTablePathAnyDialect(tablePath: string, prefix: string): void;

package/dist/connection/validate_table_path.js

@@ -0,0 +1,56 @@
+"use strict";
+/*
+ * Copyright Contributors to the Malloy project
+ * SPDX-License-Identifier: MIT
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateCanonicalTablePath = validateCanonicalTablePath;
+exports.validateCanonicalTablePathAnyDialect = validateCanonicalTablePathAnyDialect;
+exports.requireCanonicalTablePathAnyDialect = requireCanonicalTablePathAnyDialect;
+const dialect_map_1 = require("../dialect/dialect_map");
+/** Validate against a known dialect. Returns an error string or undefined. */
+function validateCanonicalTablePath(dialectName, tablePath) {
+    let dialect;
+    try {
+        dialect = (0, dialect_map_1.getDialect)(dialectName);
+    }
+    catch {
+        return `tablePath '${tablePath}' cannot be validated: unknown dialect '${dialectName}'`;
+    }
+    const result = dialect.sqlValidateTableName(tablePath);
+    if (!result.ok) {
+        return `tablePath '${tablePath}' is not canonical SQL for the ${dialectName} dialect; the translator must validate before passing it here. (${result.error})`;
+    }
+    if (result.canonical !== tablePath) {
+        return `tablePath '${tablePath}' is not canonical SQL for the ${dialectName} dialect; the translator must validate before passing it here.`;
+    }
+    return undefined;
+}
+/**
+ * Validate against any registered dialect. Used at boundaries where the
+ * destination dialect isn't synchronously known (virtualMap, manifest
+ * entries).
+ */
+function validateCanonicalTablePathAnyDialect(tablePath) {
+    let suggestion;
+    for (const dialect of (0, dialect_map_1.getDialects)()) {
+        const result = dialect.sqlValidateTableName(tablePath);
+        if (result.ok) {
+            if (result.canonical === tablePath)
+                return undefined;
+            if (suggestion === undefined)
+                suggestion = result.canonical;
+        }
+    }
+    if (suggestion !== undefined) {
+        return `value '${tablePath}' is not canonical SQL; did you mean '${suggestion}'?`;
+    }
+    return `value '${tablePath}' is not a valid canonical table path in any registered dialect`;
+}
+/** Throw if `tablePath` isn't canonical SQL in any registered dialect. */
+function requireCanonicalTablePathAnyDialect(tablePath, prefix) {
+    const err = validateCanonicalTablePathAnyDialect(tablePath);
+    if (err !== undefined)
+        throw new Error(`${prefix}: ${err}`);
+}
+//# sourceMappingURL=validate_table_path.js.map

package/dist/dialect/databricks/databricks.d.ts

@@ -4,6 +4,9 @@ import { Dialect } from '../dialect';
 import type { DialectFunctionOverloadDef } from '../functions';
 export declare class DatabricksDialect extends Dialect {
     name: string;
+    stringLiteralStyle: "backslash";
+    identifierEscapeStyle: "doubled";
+    identifierQuoteChar: string;
     defaultNumberType: string;
     defaultDecimalType: string;
     udfPrefix: string;
@@ -37,9 +40,9 @@ export declare class DatabricksDialect extends Dialect {
     hasTimestamptz: boolean;
     supportsBigIntPrecision: boolean;
     maxIdentifierLength: number;
+    tablePathBareIdentRegex: RegExp;
     malloyTypeToSQLType(malloyType: AtomicTypeDef): string;
     sqlTypeToMalloyType(sqlType: string): BasicAtomicTypeDef;
-    quoteTablePath(tablePath: string): string;
     sqlGroupSetTable(groupSetCount: number): string;
     sqlLateralJoinBag(expressions: LateralJoinExpression[]): string;
     sqlOrderBy(orderTerms: string[], obr?: OrderByRequest): string;
@@ -60,7 +63,6 @@ export declare class DatabricksDialect extends Dialect {
     sqlCreateFunction(id: string, funcText: string): string;
     sqlCreateFunctionCombineLastStage(lastStageName: string, fieldList: DialectFieldList): string;
     sqlSelectAliasAsStruct(alias: string, fieldList: DialectFieldList): string;
-    sqlMaybeQuoteIdentifier(identifier: string): string;
     sqlCreateTableAsSelect(tableName: string, sql: string): string;
     sqlNowExpr(): string;
     sqlConvertToCivilTime(expr: string, timezone: string, _typeDef: AtomicTypeDef): {
@@ -78,8 +80,6 @@ export declare class DatabricksDialect extends Dialect {
     sqlTimestamptzLiteral(_qi: QueryInfo, _literal: string, _timezone: string): string;
     sqlMeasureTimeExpr(df: MeasureTimeExpr): string;
     sqlSampleTable(tableSQL: string, sample: Sampling | undefined): string;
-    sqlLiteralString(literal: string): string;
-    sqlLiteralRegexp(literal: string): string;
     getDialectFunctionOverrides(): {
         [name: string]: DialectFunctionOverloadDef[];
     };

package/dist/dialect/databricks/databricks.js

@@ -43,6 +43,9 @@ class DatabricksDialect extends dialect_1.Dialect {
     constructor() {
         super(...arguments);
         this.name = 'databricks';
+        this.stringLiteralStyle = dialect_1.EscapeStyle.Backslash;
+        this.identifierEscapeStyle = dialect_1.EscapeStyle.Doubled;
+        this.identifierQuoteChar = '`';
         this.defaultNumberType = 'DOUBLE';
         this.defaultDecimalType = 'DECIMAL';
         this.udfPrefix = '__udf';
@@ -74,6 +77,10 @@ class DatabricksDialect extends dialect_1.Dialect {
         this.hasTimestamptz = false;
         this.supportsBigIntPrecision = false;
         this.maxIdentifierLength = 255;
+        // Databricks bare identifiers may start with a digit, but cannot be
+        // entirely digits (or they lex as number literals). Verified against
+        // the live engine: `1foo` resolves; `$` is rejected.
+        this.tablePathBareIdentRegex = /^[A-Za-z0-9_]*[A-Za-z_][A-Za-z0-9_]*/;
     }
     malloyTypeToSQLType(malloyType) {
         switch (malloyType.type) {
@@ -95,7 +102,7 @@ class DatabricksDialect extends dialect_1.Dialect {
                 const fields = [];
                 for (const f of malloyType.fields) {
                     if ((0, malloy_types_1.isAtomic)(f)) {
-                        fields.push(`${this.sqlMaybeQuoteIdentifier(f.name)}: ${this.malloyTypeToSQLType(f)}`);
+                        fields.push(`${this.sqlQuoteIdentifier(f.name)}: ${this.malloyTypeToSQLType(f)}`);
                     }
                 }
                 return `STRUCT<${fields.join(', ')}>`;
@@ -105,7 +112,7 @@ class DatabricksDialect extends dialect_1.Dialect {
                     const fields = [];
                     for (const f of malloyType.fields) {
                         if ((0, malloy_types_1.isAtomic)(f)) {
-                            fields.push(`${this.sqlMaybeQuoteIdentifier(f.name)}: ${this.malloyTypeToSQLType(f)}`);
+                            fields.push(`${this.sqlQuoteIdentifier(f.name)}: ${this.malloyTypeToSQLType(f)}`);
                         }
                     }
                     return `ARRAY<STRUCT<${fields.join(', ')}>>`;
@@ -128,12 +135,6 @@ class DatabricksDialect extends dialect_1.Dialect {
             rawType: baseSqlType,
         });
     }
-    quoteTablePath(tablePath) {
-        return tablePath
-            .split('.')
-            .map(part => (/^[a-zA-Z_]\w*$/.test(part) ? part : `\`${part}\``))
-            .join('.');
-    }
     sqlGroupSetTable(groupSetCount) {
         return `LATERAL VIEW EXPLODE(SEQUENCE(0, ${groupSetCount})) group_set AS group_set`;
     }
@@ -163,7 +164,9 @@ class DatabricksDialect extends dialect_1.Dialect {
     // field names) in Databricks.
     buildNamedStructExpression(fieldList) {
         return ('named_struct(' +
-            fieldList.map(f => `'${f.rawName}', ${f.sqlExpression}`).join(', ') +
+            fieldList
+                .map(f => `${this.sqlLiteralString(f.rawName)}, ${f.sqlExpression}`)
+                .join(', ') +
             ')');
     }
     sqlAggregateTurtle(groupSet, fieldList, orderBy) {
@@ -207,7 +210,9 @@ class DatabricksDialect extends dialect_1.Dialect {
     sqlCoaleseMeasuresInline(groupSet, fieldList) {
         const namedStruct = this.buildNamedStructExpression(fieldList);
         const nullStruct = 'named_struct(' +
-            fieldList.map(f => `'${f.rawName}', NULL`).join(', ') +
+            fieldList
+                .map(f => `${this.sqlLiteralString(f.rawName)}, NULL`)
+                .join(', ') +
             ')';
         return `COALESCE(FIRST(CASE WHEN group_set=${groupSet} THEN ${namedStruct} END) IGNORE NULLS, ${nullStruct})`;
     }
@@ -268,7 +273,7 @@ class DatabricksDialect extends dialect_1.Dialect {
         if (childName === '__row_id') {
             return `__row_id_from_${parentAlias}`;
         }
-        return `${parentAlias}.${this.sqlMaybeQuoteIdentifier(childName)}`;
+        return `${parentAlias}.${this.sqlQuoteIdentifier(childName)}`;
     }
     sqlCreateFunction(id, funcText) {
         return `CREATE TEMPORARY FUNCTION ${id}(param STRING) RETURNS STRING RETURN (\n${(0, utils_1.indent)(funcText)}\n);\n`;
@@ -279,13 +284,10 @@ class DatabricksDialect extends dialect_1.Dialect {
     }
     sqlSelectAliasAsStruct(alias, fieldList) {
         const fields = fieldList
-            .map(f => `${alias}.${this.sqlMaybeQuoteIdentifier(f.rawName)}`)
+            .map(f => `${alias}.${this.sqlQuoteIdentifier(f.rawName)}`)
             .join(', ');
         return `STRUCT(${fields})`;
     }
-    sqlMaybeQuoteIdentifier(identifier) {
-        return '`' + identifier.replace(/`/g, '``') + '`';
-    }
     sqlCreateTableAsSelect(tableName, sql) {
         return `CREATE TABLE ${tableName} AS ${sql}`;
     }
@@ -406,13 +408,6 @@ class DatabricksDialect extends dialect_1.Dialect {
         }
         return tableSQL;
     }
-    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.DATABRICKS_MALLOY_STANDARD_OVERLOADS);
     }

package/dist/dialect/dialect.d.ts

@@ -1,5 +1,6 @@
 import type { Expr, Sampling, AtomicTypeDef, MeasureTimeExpr, TimeExtractExpr, TypecastExpr, RegexMatchExpr, TimeLiteralExpr, RecordLiteralNode, ArrayLiteralNode, BasicAtomicTypeDef, OrderBy, TimestampUnit, ATimestampTypeDef, TimeExpr, TemporalFieldType } from '../model/malloy_types';
 import type { DialectFunctionOverloadDef } from './functions';
+import type { ValidateTablePathResult } from './table-path';
 interface DialectField {
     typeDef: AtomicTypeDef;
     sqlExpression: string;
@@ -35,6 +36,18 @@ export declare const MIN_INT128: bigint;
 export declare const MAX_INT128: bigint;
 export declare const MIN_DECIMAL38: bigint;
 export declare const MAX_DECIMAL38: bigint;
+/**
+ * Allowed values for `Dialect.stringLiteralStyle` and
+ * `Dialect.identifierEscapeStyle`. Subclasses set their style with
+ * e.g. `stringLiteralStyle = EscapeStyle.Backslash`; the `as const`
+ * is centralized here so dialect files stay free of it.
+ */
+export declare const EscapeStyle: {
+    readonly Doubled: "doubled";
+    readonly Backslash: "backslash";
+    readonly Unset: "unset";
+};
+export type EscapeStyleValue = (typeof EscapeStyle)[keyof typeof EscapeStyle];
 /**
  * Data which dialect methods need in order to correctly generate SQL.
  * Initially this is just timezone related, but I made this an interface
@@ -132,7 +145,34 @@ export declare abstract class Dialect {
     abstract getDialectFunctions(): {
         [name: string]: DialectFunctionOverloadDef[];
     };
-    abstract quoteTablePath(tablePath: string): string;
+    /**
+     * Regex matching one bare (unquoted) table-path segment for this
+     * dialect, anchored at the start of the input. Drives the default
+     * `sqlValidateTableName` along with `identifierQuoteChar` and
+     * `identifierEscapeStyle`.
+     *
+     * The default is strict ANSI: `[A-Za-z_][A-Za-z0-9_]*`. Override to
+     * widen the char set (Postgres allows `$`, MySQL allows digit-start
+     * with caveats, BigQuery allows dashes, …). The per-dialect regexes
+     * were verified by probing live engines.
+     */
+    tablePathBareIdentRegex: RegExp;
+    /**
+     * Validate a user-supplied table-path string for this dialect. On
+     * success, the canonical form is the SQL fragment that gets pasted
+     * into `FROM` clauses and stored in `StructDef.tablePath`. Canonical
+     * equals input verbatim except where a Malloy convenience needs
+     * translating into dialect SQL (today: DuckDB's file-path branch
+     * wraps the input in single quotes).
+     *
+     * The default implementation handles every dialect whose table-path
+     * grammar is a dotted sequence of `bare | quoted` segments — every
+     * dialect we ship except DuckDB. New dialects of that shape need
+     * only override `tablePathBareIdentRegex`; override
+     * `sqlValidateTableName` itself only if your grammar is structurally
+     * different.
+     */
+    sqlValidateTableName(input: string): ValidateTablePathResult;
     abstract sqlGroupSetTable(groupSetCount: number): string;
     abstract sqlAnyValue(groupSet: number, fieldName: string): string;
     abstract sqlAggregateTurtle(groupSet: number, fieldList: DialectFieldList, orderBy: CompiledOrderBy[] | undefined): string;
@@ -151,7 +191,52 @@ export declare abstract class Dialect {
     abstract sqlSelectAliasAsStruct(alias: string, fieldList: DialectFieldList): string;
     sqlFinalStage(_lastStageName: string, _fields: string[]): string;
     sqlDateToString(sqlDateExp: string): string;
-    abstract sqlMaybeQuoteIdentifier(identifier: string): string;
+    /**
+     * The character the dialect uses to quote identifiers. Most dialects
+     * use ANSI double-quote `"`; MySQL, BigQuery and Databricks use the
+     * backtick `` ` ``. The dialect must escape this character by doubling
+     * inside a quoted identifier.
+     *
+     * Defaults to the empty string sentinel — concrete dialects must set
+     * a real value (or override `sqlQuoteIdentifier`), otherwise the
+     * base method throws to surface the omission immediately.
+     */
+    identifierQuoteChar: string;
+    /**
+     * How the dialect escapes the closing quote inside a string literal.
+     * Set via `EscapeStyle` from this module:
+     *
+     * - `EscapeStyle.Doubled`: `''` escapes `'`. Backslash is a literal
+     *   character. (ANSI standard; Postgres, DuckDB, Trino, Presto.)
+     * - `EscapeStyle.Backslash`: `\'` escapes `'`, `\\` escapes `\`.
+     *   (BigQuery, Snowflake, MySQL default mode, Databricks.)
+     * - `EscapeStyle.Unset` (default): base methods throw if reached. A
+     *   new dialect must set this (or override the literal methods).
+     *
+     * `sqlLiteralString` and `sqlLiteralRegexp` share this style — the
+     * regex engine receives whatever the SQL parser decodes, and the two
+     * must agree or regex patterns containing backslashes silently break.
+     */
+    stringLiteralStyle: EscapeStyleValue;
+    /**
+     * How the dialect escapes the quote character inside a quoted
+     * identifier. Mirrors `stringLiteralStyle`:
+     *
+     * - `EscapeStyle.Doubled`: doubling the quote char escapes it (ANSI
+     *   standard; most dialects).
+     * - `EscapeStyle.Backslash`: backslash-style escape, with `\\` for
+     *   backslash and `\<quote>` for the quote char. (BigQuery — quoted
+     *   identifiers use string-literal escape sequences.)
+     * - `EscapeStyle.Unset` (default): base method throws if reached.
+     */
+    identifierEscapeStyle: EscapeStyleValue;
+    /**
+     * Wrap an identifier in the dialect's quote character, escaping any
+     * embedded quote characters per the dialect's `identifierEscapeStyle`.
+     * This is the only safe way to render a user-controlled identifier
+     * in SQL.
+     */
+    sqlQuoteIdentifier(identifier: string): string;
     abstract castToString(expression: string): string;
     abstract concat(...values: string[]): string;
     sqlLiteralNumber(literal: string): string;
@@ -354,8 +439,19 @@ export declare abstract class Dialect {
      *   the civil time in the specified timezone
      */
     abstract sqlTimestamptzLiteral(qi: QueryInfo, literal: string, timezone: string): string;
-    abstract sqlLiteralString(literal: string): string;
-    abstract sqlLiteralRegexp(literal: string): string;
+    /**
+     * Render a Malloy string as a SQL string literal. The escape style is
+     * driven by `stringLiteralStyle`; dialects normally do not override
+     * this method.
+     */
+    sqlLiteralString(literal: string): string;
+    /**
+     * Render a Malloy regex literal as a SQL string literal. Defaults to
+     * `sqlLiteralString` — the regex engine receives whatever bytes the
+     * SQL parser decodes, and `sqlLiteralString` already produces a
+     * correctly decoding literal for both escape styles.
+     */
+    sqlLiteralRegexp(literal: string): string;
     abstract sqlLiteralArray(lit: ArrayLiteralNode): string;
     abstract sqlLiteralRecord(lit: RecordLiteralNode): string;
     /**