@malloydata/malloy 0.0.393 → 0.0.395

package/dist/model/inline_expr.js

@@ -0,0 +1,184 @@
+"use strict";
+/*
+ * Copyright Contributors to the Malloy project
+ * SPDX-License-Identifier: MIT
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.INLINE_LEAVES = exports.INLINE_OPS = void 0;
+exports.inlineExpr = inlineExpr;
+/**
+ * Operator node types allowed inside an `inline` given's default. Single
+ * source of truth — both the translator-side validator
+ * (`GivenDeclaration.execute`) and the bind-time evaluator below read
+ * this set when deciding whether an expression is reducible to a
+ * literal at bind time.
+ *
+ * Add a new operator here AND a corresponding `case` to `inlineExpr`'s
+ * switch in the same commit; the two are intentionally co-located so
+ * they can't drift apart.
+ */
+exports.INLINE_OPS = new Set([
+    'and',
+    'or',
+    'not',
+    '=',
+    '!=',
+    '>',
+    '<',
+    '>=',
+    '<=',
+    'inGiven',
+    '()',
+]);
+/**
+ * Leaf-shaped node types that are valid inside an inline expression but
+ * aren't "operators." Literals are returned as-is by the evaluator;
+ * `given` nodes resolve through the bound values map.
+ */
+exports.INLINE_LEAVES = new Set([
+    'stringLiteral',
+    'numberLiteral',
+    'true',
+    'false',
+    'null',
+    'arrayLiteral',
+    'given',
+]);
+/**
+ * Bind-time evaluator for `inline` given defaults. Walks the Expr tree,
+ * recursing on bound values for given-refs, and returns a literal Expr
+ * (string/number/boolean/null/arrayLiteral).
+ *
+ * Throws on any node outside `INLINE_OPS ∪ INLINE_LEAVES`. The
+ * translator's pre-flight check should have rejected such defaults
+ * already, so a throw here flags a compiler bug rather than a caller
+ * error.
+ */
+function inlineExpr(e, bound) {
+    switch (e.node) {
+        case 'stringLiteral':
+        case 'numberLiteral':
+        case 'true':
+        case 'false':
+        case 'null':
+        case 'arrayLiteral':
+            return e;
+        case 'given': {
+            const v = bound.get(e.id);
+            if (v === undefined) {
+                throw new Error(`inlineExpr: given '${e.refName}' has no bound value and no default — translator should have caught this earlier`);
+            }
+            return inlineExpr(v, bound);
+        }
+        case '()':
+            return inlineExpr(e.e, bound);
+        case 'not': {
+            const inner = inlineExpr(e.e, bound);
+            return toBoolLiteral(!exprAsBool(inner));
+        }
+        case 'and':
+        case 'or': {
+            const left = exprAsBool(inlineExpr(e.kids.left, bound));
+            const right = exprAsBool(inlineExpr(e.kids.right, bound));
+            return toBoolLiteral(e.node === 'and' ? left && right : left || right);
+        }
+        case '=':
+        case '!=':
+        case '>':
+        case '<':
+        case '>=':
+        case '<=': {
+            const left = inlineExpr(e.kids.left, bound);
+            const right = inlineExpr(e.kids.right, bound);
+            return toBoolLiteral(compareLiterals(e.node, left, right));
+        }
+        case 'inGiven': {
+            const lhs = inlineExpr(e.e, bound);
+            const arrBound = bound.get(e.givenRef.id);
+            if (arrBound === undefined) {
+                throw new Error(`inlineExpr: given '${e.givenRef.refName}' has no bound value and no default — translator should have caught this earlier`);
+            }
+            if (arrBound.node === 'null') {
+                return toBoolLiteral(e.not);
+            }
+            if (arrBound.node !== 'arrayLiteral') {
+                throw new Error(`inlineExpr: 'inGiven' bound to '${arrBound.node}', expected 'arrayLiteral'`);
+            }
+            const found = arrBound.kids.values.some(v => compareLiterals('=', lhs, inlineExpr(v, bound)));
+            return toBoolLiteral(e.not ? !found : found);
+        }
+        default:
+            throw new Error(`inlineExpr: unexpected node '${e.node}' — translator should have rejected this`);
+    }
+}
+function toBoolLiteral(b) {
+    return { node: b ? 'true' : 'false' };
+}
+/**
+ * Read a literal Expr as a JS boolean. The evaluator only ever produces
+ * 'true' / 'false' / 'null' / scalar literals here; anything else means
+ * we tried to use a non-boolean where a boolean was expected, which is a
+ * translator type-check bug.
+ */
+function exprAsBool(e) {
+    if (e.node === 'true')
+        return true;
+    if (e.node === 'false')
+        return false;
+    // `null` in boolean position is treated as false — matches the
+    // implicit SQL coalesce that Malloy does for filter expressions.
+    if (e.node === 'null')
+        return false;
+    throw new Error(`inlineExpr: expected boolean literal, got '${e.node}' — translator should have type-checked this`);
+}
+/**
+ * JS-side comparison of two literal Exprs. Only the literal nodes
+ * produced by the evaluator are supported.
+ *
+ * SQL nullability: any operand being null produces false (matching
+ * Malloy's COALESCE-to-true / COALESCE-to-false behavior elsewhere).
+ */
+function compareLiterals(op, left, right) {
+    if (left.node === 'null' || right.node === 'null') {
+        // Mirror SQL: comparisons with NULL are unknown; treat as false for
+        // = / > / < / >= / <=, true for !=.
+        return op === '!=';
+    }
+    const l = literalToJS(left);
+    const r = literalToJS(right);
+    switch (op) {
+        case '=':
+            return l === r;
+        case '!=':
+            return l !== r;
+        case '>':
+            return l > r;
+        case '<':
+            return l < r;
+        case '>=':
+            return l >= r;
+        case '<=':
+            return l <= r;
+    }
+}
+/**
+ * Convert a literal Expr to a comparable JS value. Numbers come through
+ * `numberLiteral` as a string (full precision preserved); we parse to a
+ * JS number for ordering — bind-time precision loss here is fine
+ * because the result of an inline expression is a boolean for SQL.
+ */
+function literalToJS(e) {
+    switch (e.node) {
+        case 'stringLiteral':
+            return e.literal;
+        case 'numberLiteral':
+            return Number(e.literal);
+        case 'true':
+            return true;
+        case 'false':
+            return false;
+        default:
+            throw new Error(`inlineExpr: cannot compare non-literal node '${e.node}'`);
+    }
+}
+//# sourceMappingURL=inline_expr.js.map

package/dist/model/malloy_types.d.ts

@@ -36,7 +36,7 @@ export type AnyExpr = ExprE | ExprOptionalE | ExprWithKids | ExprLeaf;
 export declare function exprHasKids(e: AnyExpr): e is ExprWithKids;
 export declare function exprHasE(e: AnyExpr): e is ExprE;
 export declare function exprIsLeaf(e: AnyExpr): boolean;
-export type Expr = BinaryExpr | UnaryExpr | FunctionCallNode | OutputFieldNode | FilterCondition | FilteredExpr | AggregateExpr | EmptyExpr | UngroupNode | FunctionParameterNode | SpreadExpr | AggregateOrderByNode | AggregateLimitNode | FieldnameNode | SourceReferenceNode | ParameterNode | GivenRefNode | NowNode | MeasureTimeExpr | TimeExtractExpr | TimeDeltaExpr | TimeTruncExpr | DateLiteralNode | TimestampLiteralNode | TimestamptzLiteralNode | TypecastExpr | RegexMatchExpr | RegexLiteralNode | FilterMatchExpr | FilterLiteralExpr | StringLiteralNode | NumberLiteralNode | BooleanLiteralNode | RecordLiteralNode | ArrayLiteralNode | FunctionOrderBy | GenericSQLExpr | NullNode | CaseExpr | InCompareExpr | CompositeFieldExpr | ErrorNode;
+export type Expr = BinaryExpr | UnaryExpr | FunctionCallNode | OutputFieldNode | FilterCondition | FilteredExpr | AggregateExpr | EmptyExpr | UngroupNode | FunctionParameterNode | SpreadExpr | AggregateOrderByNode | AggregateLimitNode | FieldnameNode | SourceReferenceNode | ParameterNode | GivenRefNode | NowNode | MeasureTimeExpr | TimeExtractExpr | TimeDeltaExpr | TimeTruncExpr | DateLiteralNode | TimestampLiteralNode | TimestamptzLiteralNode | TypecastExpr | RegexMatchExpr | RegexLiteralNode | FilterMatchExpr | FilterLiteralExpr | StringLiteralNode | NumberLiteralNode | BooleanLiteralNode | RecordLiteralNode | ArrayLiteralNode | FunctionOrderBy | GenericSQLExpr | NullNode | CaseExpr | InCompareExpr | InGivenExpr | CompositeFieldExpr | ErrorNode;
 export type BinaryOperator = '+' | '-' | '*' | '%' | '/' | 'and' | 'or' | '=' | '!=' | '>' | '<' | '>=' | '<=' | 'coalesce' | 'like' | '!like';
 export interface BinaryExpr extends ExprWithKids {
     node: BinaryOperator;
@@ -289,6 +289,19 @@ export interface InCompareExpr extends ExprWithKids {
         oneOf: Expr[];
     };
 }
+/**
+ * Test against a runtime-bound array given: `expr in $ARRAY_GIVEN`.
+ *
+ * Uses ExprE (one child `e`, the LHS). The given reference is embedded
+ * as a top-level field rather than a kid so the auto-visitor in
+ * `compileExpr` doesn't descend into it; resolution and per-element
+ * SQL emission happen in the `case 'inGiven':` handler.
+ */
+export interface InGivenExpr extends ExprE {
+    node: 'inGiven';
+    not: boolean;
+    givenRef: GivenRefNode;
+}
 export type ExpressionType = 'scalar' | 'aggregate' | 'scalar_analytic' | 'aggregate_analytic' | 'ungrouped_aggregate';
 export interface Expression {
     e?: Expr;
@@ -341,6 +354,11 @@ export interface Given extends HasLocation, HasAnnotation {
      *  its own default. Empty/undefined when the default is a closed
      *  literal. */
     givenUsage?: GivenUsage;
+    /** Marked with the `inline` modifier — the default is eager-evaluated
+     *  to a literal at bind time and substituted as that literal in SQL.
+     *  Translator validates the default is eager-evaluable; bind-time
+     *  evaluator (`model/inline_expr.ts`) performs the reduction. */
+    inline?: boolean;
 }
 export interface GivenEntry {
     type: 'given';

package/dist/model/query_model_impl.js

@@ -107,12 +107,12 @@ class QueryModelImpl {
             const fieldNames = [];
             for (const f of ret.outputStruct.fields) {
                 if ((0, malloy_types_1.isAtomic)(f)) {
-                    const quoted = q.parent.dialect.sqlMaybeQuoteIdentifier(f.name);
+                    const quoted = q.parent.dialect.sqlQuoteIdentifier(f.name);
                     fieldNames.push(quoted);
                 }
             }
             // const fieldNames = getAtomicFields(ret.outputStruct).map(fieldDef =>
-            //   q.parent.dialect.sqlMaybeQuoteIdentifier(fieldDef.name)
+            //   q.parent.dialect.sqlQuoteIdentifier(fieldDef.name)
             // );
             ret.lastStageName = stageWriter.addStage(q.parent.dialect.sqlFinalStage(ret.lastStageName, fieldNames));
         }
@@ -217,11 +217,11 @@ class QueryModelImpl {
                 },
             ],
         };
-        const fieldNameColumn = d.sqlMaybeQuoteIdentifier('fieldName');
-        const fieldPathColumn = d.sqlMaybeQuoteIdentifier('fieldPath');
-        const fieldValueColumn = d.sqlMaybeQuoteIdentifier('fieldValue');
-        const fieldTypeColumn = d.sqlMaybeQuoteIdentifier('fieldType');
-        const weightColumn = d.sqlMaybeQuoteIdentifier('weight');
+        const fieldNameColumn = d.sqlQuoteIdentifier('fieldName');
+        const fieldPathColumn = d.sqlQuoteIdentifier('fieldPath');
+        const fieldValueColumn = d.sqlQuoteIdentifier('fieldValue');
+        const fieldTypeColumn = d.sqlQuoteIdentifier('fieldType');
+        const weightColumn = d.sqlQuoteIdentifier('weight');
         // if we've compiled the SQL before use it otherwise
         let sqlPDT = this.exploreSearchSQLMap.get(explore);
         if (sqlPDT === undefined) {

package/dist/model/query_query.d.ts

@@ -103,7 +103,7 @@ export declare class QueryQuery extends QueryField {
     generateTurtlePipelineSQL(fi: FieldInstanceResult, stageWriter: StageWriter, sourceSQLExpression: string): {
         structDef: QueryResultDef;
         pipeOut: any;
-        repeatedResultType: "nested" | "inline_all_numbers" | "inline";
+        repeatedResultType: "inline" | "nested" | "inline_all_numbers";
     };
     generateComplexSQL(stageWriter: StageWriter): string;
     generateSQL(stageWriter: StageWriter): string;

package/dist/model/query_query.js

@@ -517,14 +517,17 @@ class QueryQuery extends query_node_1.QueryField {
         var _a, _b, _c, _d;
         switch (qs.structDef.type) {
             case 'table':
-                return this.parent.dialect.quoteTablePath(qs.structDef.tablePath);
+                // tablePath is canonical SQL — translator pre-validated.
+                return qs.structDef.tablePath;
             case 'virtual': {
                 const virtualMap = (_a = qs.prepareResultOptions) === null || _a === void 0 ? void 0 : _a.virtualMap;
                 const tablePath = (_b = virtualMap === null || virtualMap === void 0 ? void 0 : virtualMap.get(qs.structDef.connection)) === null || _b === void 0 ? void 0 : _b.get(qs.structDef.name);
                 if (!tablePath) {
                     throw new Error(`No virtual map entry for '${qs.structDef.name}' on connection '${qs.structDef.connection}'`);
                 }
-                return this.parent.dialect.quoteTablePath(tablePath);
+                // virtualMap entries are application-supplied — assumed already
+                // canonical SQL.
+                return tablePath;
             }
             case 'composite':
                 // TODO: throw an error here; not simple because we call into this
@@ -533,7 +536,7 @@ class QueryQuery extends query_node_1.QueryField {
             case 'finalize':
                 return qs.structDef.name;
             case 'sql_select':
-                return `(${(0, sql_compiled_1.getCompiledSQL)(qs.structDef, (_c = qs.prepareResultOptions) !== null && _c !== void 0 ? _c : {}, path => this.parent.dialect.quoteTablePath(path), (query, opts) => {
+                return `(${(0, sql_compiled_1.getCompiledSQL)(qs.structDef, (_c = qs.prepareResultOptions) !== null && _c !== void 0 ? _c : {}, (query, opts) => {
                     // Compile query to isolated SQL (not into parent's stageWriter)
                     const ret = this.compileQueryToStages(query, opts !== null && opts !== void 0 ? opts : {}, undefined, false);
                     return ret.sql;
@@ -551,8 +554,9 @@ class QueryQuery extends query_node_1.QueryField {
                         const buildId = (0, source_def_utils_1.mkBuildID)(connDigest, fullRet.sql);
                         const entry = buildManifest.entries[buildId];
                         if (entry) {
-                            // Found in manifest - use persisted table
-                            return this.parent.dialect.quoteTablePath(entry.tableName);
+                            // Found in manifest - use persisted table.
+                            // entry.tableName comes from the manifest, assumed canonical.
+                            return entry.tableName;
                         }
                         if (buildManifest.strict) {
                             const base = `Persist source '${qs.structDef.sourceID}' not found in manifest (buildId: ${buildId})`;
@@ -631,7 +635,7 @@ class QueryQuery extends query_node_1.QueryField {
             }
             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)`;
+                structSQL = `(SELECT ${qs.dialect.sqlGenerateUUID()} as ${qs.dialect.sqlQuoteIdentifier('__distinct_key')}, x.* ${passKeys} FROM ${structSQL} as x)`;
             }
             let onCondition = '';
             if (qs.parent === undefined) {
@@ -764,7 +768,7 @@ class QueryQuery extends query_node_1.QueryField {
         if ((0, malloy_types_1.isBaseTable)(qs.structDef)) {
             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)`;
+                structSQL = `(SELECT ${qs.dialect.sqlGenerateUUID()} as ${qs.dialect.sqlQuoteIdentifier('__distinct_key')}, x.* ${passKeys} FROM ${structSQL} as x)`;
             }
             s += `FROM ${structSQL} as ${ji.alias}\n`;
         }
@@ -846,7 +850,7 @@ class QueryQuery extends query_node_1.QueryField {
                         o.push(`${fi.fieldUsage.resultIndex} ${f.dir || 'ASC'}`);
                     }
                     else if (this.parent.dialect.orderByClause === 'output_name') {
-                        o.push(`${this.parent.dialect.sqlMaybeQuoteIdentifier(f.field)} ${f.dir || 'ASC'}`);
+                        o.push(`${this.parent.dialect.sqlQuoteIdentifier(f.field)} ${f.dir || 'ASC'}`);
                     }
                     else if (this.parent.dialect.orderByClause === 'expression') {
                         const fieldExpr = fi.getSQL();
@@ -863,7 +867,7 @@ class QueryQuery extends query_node_1.QueryField {
                 }
                 else if (this.parent.dialect.orderByClause === 'output_name') {
                     const orderingField = resultStruct.getFieldByNumber(f.field);
-                    o.push(`${this.parent.dialect.sqlMaybeQuoteIdentifier(orderingField.name)} ${f.dir || 'ASC'}`);
+                    o.push(`${this.parent.dialect.sqlQuoteIdentifier(orderingField.name)} ${f.dir || 'ASC'}`);
                 }
                 else if (this.parent.dialect.orderByClause === 'expression') {
                     const orderingField = resultStruct.getFieldByNumber(f.field);
@@ -887,7 +891,7 @@ class QueryQuery extends query_node_1.QueryField {
         const fields = [];
         for (const [name, field] of this.rootResult.allFields) {
             const fi = field;
-            const sqlName = this.parent.dialect.sqlMaybeQuoteIdentifier(name);
+            const sqlName = this.parent.dialect.sqlQuoteIdentifier(name);
             if (fi.fieldUsage.type === 'result') {
                 fields.push(` ${fi.generateExpression()} as ${sqlName}`);
             }
@@ -937,7 +941,7 @@ class QueryQuery extends query_node_1.QueryField {
                 .map(o => `${o.pipelineSQL} as ${o.sqlFieldName}`)
                 .join(',\n');
             const outputFields = outputPipelinedSQL.map(f => f.sqlFieldName);
-            const allFields = Array.from(this.rootResult.allFields.keys()).map(f => this.parent.dialect.sqlMaybeQuoteIdentifier(f));
+            const allFields = Array.from(this.rootResult.allFields.keys()).map(f => this.parent.dialect.sqlQuoteIdentifier(f));
             const fields = allFields.filter(f => outputFields.indexOf(f) === -1);
             retSQL = `SELECT ${fields.length > 0 ? fields.join(', ') + ',' : ''} ${pipelinesSQL} FROM ${lastStageName}`;
         }
@@ -956,7 +960,7 @@ class QueryQuery extends query_node_1.QueryField {
         }
         const orderedFields = [...scalarFields, ...otherFields];
         for (const [name, fi] of orderedFields) {
-            const outputName = this.parent.dialect.sqlMaybeQuoteIdentifier(`${name}__${resultSet.groupSet}`);
+            const outputName = this.parent.dialect.sqlQuoteIdentifier(`${name}__${resultSet.groupSet}`);
             if (fi instanceof field_instance_1.FieldInstanceField) {
                 if (fi.fieldUsage.type === 'result') {
                     const exp = fi.getSQL();
@@ -975,7 +979,7 @@ class QueryQuery extends query_node_1.QueryField {
                             });
                             output.sql.push(outputFieldName);
                             if (fi.f.fieldDef.type === 'number') {
-                                const outputNameString = this.parent.dialect.sqlMaybeQuoteIdentifier(`${name}__${resultSet.groupSet}_string`);
+                                const outputNameString = this.parent.dialect.sqlQuoteIdentifier(`${name}__${resultSet.groupSet}_string`);
                                 const outputFieldNameString = `__lateral_join_bag.${outputNameString}`;
                                 output.sql.push(outputFieldNameString);
                                 output.dimensionIndexes.push(output.fieldIndex++);
@@ -1086,7 +1090,7 @@ class QueryQuery extends query_node_1.QueryField {
                 let r = result;
                 while (r) {
                     for (const name of r.fieldNames(fi => (0, query_node_1.isScalarField)(fi.f))) {
-                        dimensions.push(this.parent.dialect.sqlMaybeQuoteIdentifier(`${name}__${r.groupSet}`));
+                        dimensions.push(this.parent.dialect.sqlQuoteIdentifier(`${name}__${r.groupSet}`));
                     }
                     r = r.parent;
                 }
@@ -1120,7 +1124,7 @@ class QueryQuery extends query_node_1.QueryField {
                             orderingField = result.getFieldByNumber(ordering.field);
                         }
                         obSQL.push(' ' +
-                            this.parent.dialect.sqlMaybeQuoteIdentifier(`${orderingField.name}__${result.groupSet}`) +
+                            this.parent.dialect.sqlQuoteIdentifier(`${orderingField.name}__${result.groupSet}`) +
                             ` ${ordering.dir || 'ASC'}`);
                     }
                     // partition for a row number is the parent if it exists.
@@ -1225,7 +1229,7 @@ class QueryQuery extends query_node_1.QueryField {
     generateDepthNFields(depth, resultSet, output, stageWriter) {
         const groupsToMap = [];
         for (const [name, fi] of resultSet.allFields) {
-            const sqlFieldName = this.parent.dialect.sqlMaybeQuoteIdentifier(`${name}__${resultSet.groupSet}`);
+            const sqlFieldName = this.parent.dialect.sqlQuoteIdentifier(`${name}__${resultSet.groupSet}`);
             if (fi instanceof field_instance_1.FieldInstanceField) {
                 if (fi.fieldUsage.type === 'result') {
                     if ((0, query_node_1.isScalarField)(fi.f)) {
@@ -1329,15 +1333,15 @@ class QueryQuery extends query_node_1.QueryField {
         const outputPipelinedSQL = [];
         const dimensionIndexes = [];
         for (const [name, fi] of this.rootResult.allFields) {
-            const sqlName = this.parent.dialect.sqlMaybeQuoteIdentifier(name);
+            const sqlName = this.parent.dialect.sqlQuoteIdentifier(name);
             if (fi instanceof field_instance_1.FieldInstanceField) {
                 if (fi.fieldUsage.type === 'result') {
                     if ((0, query_node_1.isScalarField)(fi.f)) {
-                        fieldsSQL.push(this.parent.dialect.sqlMaybeQuoteIdentifier(`${name}__${this.rootResult.groupSet}`) + ` as ${sqlName}`);
+                        fieldsSQL.push(this.parent.dialect.sqlQuoteIdentifier(`${name}__${this.rootResult.groupSet}`) + ` as ${sqlName}`);
                         dimensionIndexes.push(fieldIndex++);
                     }
                     else if ((0, query_node_1.isBasicCalculation)(fi.f)) {
-                        fieldsSQL.push(this.parent.dialect.sqlAnyValueLastTurtle(this.parent.dialect.sqlMaybeQuoteIdentifier(`${name}__${this.rootResult.groupSet}`), this.rootResult.groupSet, sqlName));
+                        fieldsSQL.push(this.parent.dialect.sqlAnyValueLastTurtle(this.parent.dialect.sqlQuoteIdentifier(`${name}__${this.rootResult.groupSet}`), this.rootResult.groupSet, sqlName));
                         fieldIndex++;
                     }
                 }
@@ -1348,7 +1352,7 @@ class QueryQuery extends query_node_1.QueryField {
                     fieldIndex++;
                 }
                 else if (fi.firstSegment.type === 'project') {
-                    fieldsSQL.push(this.parent.dialect.sqlAnyValueLastTurtle(this.parent.dialect.sqlMaybeQuoteIdentifier(`${name}__${this.rootResult.groupSet}`), this.rootResult.groupSet, sqlName));
+                    fieldsSQL.push(this.parent.dialect.sqlAnyValueLastTurtle(this.parent.dialect.sqlQuoteIdentifier(`${name}__${this.rootResult.groupSet}`), this.rootResult.groupSet, sqlName));
                     fieldIndex++;
                 }
             }
@@ -1375,7 +1379,7 @@ class QueryQuery extends query_node_1.QueryField {
     buildDialectFieldList(resultStruct) {
         const dialectFieldList = [];
         for (const [name, field] of resultStruct.allFields) {
-            const sqlName = this.parent.dialect.sqlMaybeQuoteIdentifier(name);
+            const sqlName = this.parent.dialect.sqlQuoteIdentifier(name);
             //
             if (resultStruct.firstSegment.type === 'reduce' &&
                 field instanceof field_instance_1.FieldInstanceResult) {
@@ -1390,7 +1394,7 @@ class QueryQuery extends query_node_1.QueryField {
                     };
                     dialectFieldList.push({
                         typeDef: multiLineNest,
-                        sqlExpression: this.parent.dialect.sqlMaybeQuoteIdentifier(`${name}__${resultStruct.groupSet}`),
+                        sqlExpression: this.parent.dialect.sqlQuoteIdentifier(`${name}__${resultStruct.groupSet}`),
                         rawName: name,
                         sqlOutputName: sqlName,
                     });
@@ -1404,7 +1408,7 @@ class QueryQuery extends query_node_1.QueryField {
                     };
                     dialectFieldList.push({
                         typeDef: oneLineNest,
-                        sqlExpression: this.parent.dialect.sqlMaybeQuoteIdentifier(`${name}__${resultStruct.groupSet}`),
+                        sqlExpression: this.parent.dialect.sqlQuoteIdentifier(`${name}__${resultStruct.groupSet}`),
                         rawName: name,
                         sqlOutputName: sqlName,
                     });
@@ -1415,7 +1419,7 @@ class QueryQuery extends query_node_1.QueryField {
                 field.fieldUsage.type === 'result') {
                 pushDialectField(dialectFieldList, {
                     fieldDef: field.f.fieldDef,
-                    sqlExpression: this.parent.dialect.sqlMaybeQuoteIdentifier(`${name}__${resultStruct.groupSet}`),
+                    sqlExpression: this.parent.dialect.sqlQuoteIdentifier(`${name}__${resultStruct.groupSet}`),
                     rawName: name,
                     sqlOutputName: sqlName,
                 });
@@ -1449,10 +1453,10 @@ class QueryQuery extends query_node_1.QueryField {
             else {
                 orderingField = resultStruct.getFieldByNumber(ordering.field);
             }
-            const structField = this.parent.dialect.sqlMaybeQuoteIdentifier(orderingField.name);
+            const structField = this.parent.dialect.sqlQuoteIdentifier(orderingField.name);
             if (resultStruct.firstSegment.type === 'reduce') {
                 compiledOrderBy.push({
-                    field: this.parent.dialect.sqlMaybeQuoteIdentifier(`${orderingField.name}__${resultStruct.groupSet}`),
+                    field: this.parent.dialect.sqlQuoteIdentifier(`${orderingField.name}__${resultStruct.groupSet}`),
                     structField,
                     dir: ordering.dir || 'asc',
                 });
@@ -1636,12 +1640,12 @@ class QueryQueryIndexStage extends QueryQuery {
     generateSQL(stageWriter) {
         let measureSQL = 'COUNT(*)';
         const dialect = this.parent.dialect;
-        const fieldNameColumn = dialect.sqlMaybeQuoteIdentifier('fieldName');
-        const fieldPathColumn = dialect.sqlMaybeQuoteIdentifier('fieldPath');
-        const fieldValueColumn = dialect.sqlMaybeQuoteIdentifier('fieldValue');
-        const fieldTypeColumn = dialect.sqlMaybeQuoteIdentifier('fieldType');
-        const fieldRangeColumn = dialect.sqlMaybeQuoteIdentifier('fieldRange');
-        const weightColumn = dialect.sqlMaybeQuoteIdentifier('weight');
+        const fieldNameColumn = dialect.sqlQuoteIdentifier('fieldName');
+        const fieldPathColumn = dialect.sqlQuoteIdentifier('fieldPath');
+        const fieldValueColumn = dialect.sqlQuoteIdentifier('fieldValue');
+        const fieldTypeColumn = dialect.sqlQuoteIdentifier('fieldType');
+        const fieldRangeColumn = dialect.sqlQuoteIdentifier('fieldRange');
+        const weightColumn = dialect.sqlQuoteIdentifier('weight');
         const measureName = this.firstSegment.weightMeasure;
         if (measureName) {
             measureSQL = this.rootResult.getField(measureName).generateExpression();
@@ -1819,7 +1823,7 @@ class QueryQueryRaw extends QueryQuery {
         if (this.parent.structDef.type !== 'sql_select') {
             throw new Error('Invalid struct for QueryQueryRaw, currently only supports SQL');
         }
-        return stageWriter.addStage((0, sql_compiled_1.getCompiledSQL)(this.parent.structDef, (_a = this.parent.prepareResultOptions) !== null && _a !== void 0 ? _a : {}, path => this.parent.dialect.quoteTablePath(path), (query, opts) => {
+        return stageWriter.addStage((0, sql_compiled_1.getCompiledSQL)(this.parent.structDef, (_a = this.parent.prepareResultOptions) !== null && _a !== void 0 ? _a : {}, (query, opts) => {
             // Compile query to isolated SQL (not into parent's stageWriter)
             const ret = this.compileQueryToStages(query, opts !== null && opts !== void 0 ? opts : {}, undefined, false);
             return ret.sql;

package/dist/model/sql_compiled.d.ts

@@ -13,17 +13,15 @@ export type CompileQueryCallback = (query: Query, opts?: PrepareResultOptions) =
  *
  * @param src The SQLSourceDef to compile
  * @param opts PrepareResultOptions with buildManifest and connectionDigests
- * @param quoteTablePath Dialect function to safely quote a table path
  * @param compileQuery Callback to compile a Query to SQL
  */
-export declare function getCompiledSQL(src: SQLSourceDef, opts: PrepareResultOptions, quoteTablePath: (path: string) => string, compileQuery: CompileQueryCallback): string;
+export declare function getCompiledSQL(src: SQLSourceDef, opts: PrepareResultOptions, compileQuery: CompileQueryCallback): string;
 /**
  * Get the SQL for a PersistableSourceDef.
  *
  * @param source The persistable source to compile
- * @param quoteTablePath Dialect function to quote table paths
  * @param compileQuery Callback to compile a Query to SQL
  * @param opts Optional - if provided with manifest, nested sources may be substituted.
  *             Omit for "full SQL" (e.g., when computing BuildID).
  */
-export declare function getSourceSQL(source: PersistableSourceDef, quoteTablePath: (path: string) => string, compileQuery: CompileQueryCallback, opts?: PrepareResultOptions): string;
+export declare function getSourceSQL(source: PersistableSourceDef, compileQuery: CompileQueryCallback, opts?: PrepareResultOptions): string;

package/dist/model/sql_compiled.js

@@ -16,10 +16,9 @@ const source_def_utils_1 = require("./source_def_utils");
  *
  * @param src The SQLSourceDef to compile
  * @param opts PrepareResultOptions with buildManifest and connectionDigests
- * @param quoteTablePath Dialect function to safely quote a table path
  * @param compileQuery Callback to compile a Query to SQL
  */
-function getCompiledSQL(src, opts, quoteTablePath, compileQuery) {
+function getCompiledSQL(src, opts, compileQuery) {
     // If no segments, just return the pre-computed selectStr
     if (!src.selectSegments || src.selectSegments.length === 0) {
         return src.selectStr;
@@ -27,42 +26,43 @@ function getCompiledSQL(src, opts, quoteTablePath, compileQuery) {
     // Expand each segment
     const parts = [];
     for (const segment of src.selectSegments) {
-        parts.push(expandSegment(segment, opts, quoteTablePath, compileQuery));
+        parts.push(expandSegment(segment, opts, compileQuery));
     }
     return parts.join('');
 }
 /**
  * Expand a single SQLPhraseSegment to SQL.
  */
-function expandSegment(segment, opts, quoteTablePath, compileQuery) {
+function expandSegment(segment, opts, compileQuery) {
     // Plain SQL string
     if ((0, malloy_types_1.isSegmentSQL)(segment)) {
         return segment.sql;
     }
     // PersistableSourceDef (sql_select or query_source)
     if ((0, malloy_types_1.isSegmentSource)(segment)) {
-        return expandPersistableSource(segment, opts, quoteTablePath, compileQuery);
+        return expandPersistableSource(segment, opts, compileQuery);
     }
     // Query segment
-    return expandQuery(segment, opts, quoteTablePath, compileQuery);
+    return expandQuery(segment, opts, compileQuery);
 }
 /**
  * Expand a PersistableSourceDef, checking manifest for pre-built table.
  * Always returns a subquery form: (SELECT * FROM table) or (inline SQL)
  */
-function expandPersistableSource(source, opts, quoteTablePath, compileQuery) {
+function expandPersistableSource(source, opts, compileQuery) {
     const { buildManifest, connectionDigests } = opts;
     // Try manifest lookup if we have the required info (only for persistent sources)
     if (buildManifest && connectionDigests && source.persistent) {
         const connDigest = (0, malloy_types_1.safeRecordGet)(connectionDigests, source.connection);
         if (connDigest) {
             // Get the SQL for this source to compute BuildID (no opts = full SQL)
-            const sql = getSourceSQL(source, quoteTablePath, compileQuery);
+            const sql = getSourceSQL(source, compileQuery);
             const buildId = (0, source_def_utils_1.mkBuildID)(connDigest, sql);
             const entry = buildManifest.entries[buildId];
             if (entry) {
-                // Found in manifest - substitute with subquery from persisted table
-                return `(SELECT * FROM ${quoteTablePath(entry.tableName)})`;
+                // Found in manifest - substitute with subquery from persisted table.
+                // entry.tableName is canonical SQL, supplied by the manifest builder.
+                return `(SELECT * FROM ${entry.tableName})`;
             }
             // Not in manifest
             if (buildManifest.strict) {
@@ -74,13 +74,13 @@ function expandPersistableSource(source, opts, quoteTablePath, compileQuery) {
         }
     }
     // No manifest or not found - expand inline as subquery
-    const sql = getSourceSQL(source, quoteTablePath, compileQuery, opts);
+    const sql = getSourceSQL(source, compileQuery, opts);
     return `(${sql})`;
 }
 /**
  * Expand a Query segment.
  */
-function expandQuery(query, opts, _quoteTablePath, compileQuery) {
+function expandQuery(query, opts, compileQuery) {
     // Set isPartialQuery so CTEs aren't used (they can't be nested in subqueries)
     const sql = compileQuery(query, { ...opts, isPartialQuery: true });
     return `(${sql})`;
@@ -89,15 +89,14 @@ function expandQuery(query, opts, _quoteTablePath, compileQuery) {
  * Get the SQL for a PersistableSourceDef.
  *
  * @param source The persistable source to compile
- * @param quoteTablePath Dialect function to quote table paths
  * @param compileQuery Callback to compile a Query to SQL
  * @param opts Optional - if provided with manifest, nested sources may be substituted.
  *             Omit for "full SQL" (e.g., when computing BuildID).
  */
-function getSourceSQL(source, quoteTablePath, compileQuery, opts) {
+function getSourceSQL(source, compileQuery, opts) {
     if (source.type === 'sql_select') {
         // Recursive call for nested sql_select
-        return getCompiledSQL(source, opts !== null && opts !== void 0 ? opts : {}, quoteTablePath, compileQuery);
+        return getCompiledSQL(source, opts !== null && opts !== void 0 ? opts : {}, compileQuery);
     }
     // query_source - compile the inner query
     return compileQuery(source.query, opts);

package/dist/test/test-models.js

@@ -194,7 +194,7 @@ function generateSQL(dialect, rows) {
             const sql = exprToSQL(typedValue.expr, dialect);
             if (idx === 0) {
                 // First row: include column aliases and explicit casts if needed
-                const quotedName = dialect.sqlMaybeQuoteIdentifier(colName);
+                const quotedName = dialect.sqlQuoteIdentifier(colName);
                 if (typedValue.needsCast) {
                     const sqlType = dialect.malloyTypeToSQLType(typedValue.malloyType);
                     fields.push(`CAST(${sql} AS ${sqlType}) AS ${quotedName}`);
@@ -225,7 +225,7 @@ function generateSQL(dialect, rows) {
     }
     // Multiple rows: wrap for sorting
     const quotedColumns = columnList
-        .map(col => dialect.sqlMaybeQuoteIdentifier(col))
+        .map(col => dialect.sqlQuoteIdentifier(col))
         .join(', ');
     const innerQuery = selects.join('\nUNION ALL ');
     // Generate ORDER BY based on dialect preference

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const MALLOY_VERSION = "0.0.393";
+export declare const MALLOY_VERSION = "0.0.395";