@malloydata/malloy 0.0.240-dev250311155207 → 0.0.240-dev250311202829

package/dist/api/asynchronous.js

@@ -121,7 +121,7 @@ async function compileModel(request, fetchers) {
     // eslint-disable-next-line no-constant-condition
     while (true) {
         const result = Core.statedCompileModel(state);
-        if (result.model) {
+        if (result.model || Core.hasErrors(result.logs)) {
             return result;
         }
         const needs = await fetchNeeds(result.compiler_needs, fetchers);
@@ -134,7 +134,7 @@ async function compileSource(request, fetchers) {
     // eslint-disable-next-line no-constant-condition
     while (true) {
         const result = Core.statedCompileSource(state, request.name);
-        if (result.source) {
+        if (result.source || Core.hasErrors(result.logs)) {
             return result;
         }
         const needs = await fetchNeeds(result.compiler_needs, fetchers);
@@ -147,7 +147,7 @@ async function compileQuery(request, fetchers) {
     // eslint-disable-next-line no-constant-condition
     while (true) {
         const result = Core.statedCompileQuery(state);
-        if (result.result) {
+        if (result.result || Core.hasErrors(result.logs)) {
             return result;
         }
         const needs = await fetchNeeds(result.compiler_needs, fetchers);
@@ -177,7 +177,7 @@ async function runQuery(request, fetchers) {
     }
     try {
         const connection = await fetchers.connections.lookupConnection(compiled.result.connection_name);
-        const data = await connection.runSQL(compiled.result.sql);
+        const data = await connection.runSQL(compiled.result.sql, compiled.result.schema);
         return {
             ...compiled,
             result: {

package/dist/api/asynchronous.spec.js

@@ -146,13 +146,15 @@ ORDER BY 1 asc NULLS LAST
     describe('run query', () => {
         test('run query with table dependency', async () => {
             const data = {
-                kind: 'table',
-                rows: [
+                kind: 'array_cell',
+                array_value: [
                     {
-                        cells: [{ kind: 'string_cell', string_value: 'WN' }],
+                        kind: 'record_cell',
+                        record_value: [{ kind: 'string_cell', string_value: 'WN' }],
                     },
                     {
-                        cells: [{ kind: 'string_cell', string_value: 'AA' }],
+                        kind: 'record_cell',
+                        record_value: [{ kind: 'string_cell', string_value: 'AA' }],
                     },
                 ],
             };

package/dist/api/connection.d.ts

@@ -5,7 +5,7 @@ export interface InfoConnection {
     get dialectName(): string;
 }
 export interface Connection extends InfoConnection {
-    runSQL(sql: string): Promise<Malloy.Data>;
+    runSQL(sql: string, schema: Malloy.Schema): Promise<Malloy.Data>;
 }
 export interface LookupConnection<T extends InfoConnection> {
     lookupConnection(connectionName?: string): Promise<T>;

package/dist/api/core.d.ts

@@ -33,5 +33,6 @@ export declare function _statedCompileModel(state: CompileModelState): CompileRe
 export declare const DEFAULT_LOG_RANGE: Malloy.DocumentRange;
 export declare function compileModel(request: Malloy.CompileModelRequest, state?: CompileModelState): Malloy.CompileModelResponse;
 export declare function compileSource(request: Malloy.CompileSourceRequest): Malloy.CompileSourceResponse;
+export declare function hasErrors(log: Malloy.LogMessage[] | undefined): boolean;
 export declare function newCompileQueryState(request: Malloy.CompileQueryRequest): CompileModelState;
 export declare function statedCompileQuery(state: CompileModelState): Malloy.CompileQueryResponse;

package/dist/api/core.js

@@ -29,12 +29,14 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.statedCompileQuery = exports.newCompileQueryState = exports.compileSource = exports.compileModel = exports.DEFAULT_LOG_RANGE = exports._statedCompileModel = exports.statedCompileSource = exports.statedCompileModel = exports.newCompileSourceState = exports.newCompileModelState = exports.updateCompileModelState = exports.compileQuery = void 0;
+exports.statedCompileQuery = exports.newCompileQueryState = exports.hasErrors = exports.compileSource = exports.compileModel = exports.DEFAULT_LOG_RANGE = exports._statedCompileModel = exports.statedCompileSource = exports.statedCompileModel = exports.newCompileSourceState = exports.newCompileModelState = exports.updateCompileModelState = exports.compileQuery = void 0;
 const Malloy = __importStar(require("@malloydata/malloy-interfaces"));
 const lang_1 = require("../lang");
 const model_1 = require("../model");
 const to_stable_1 = require("../to_stable");
 const sql_block_1 = require("../model/sql_block");
+const annotation_1 = require("../annotation");
+const malloy_tag_1 = require("@malloydata/malloy-tag");
 // TODO find where this should go...
 function tableKey(connectionName, tablePath) {
     return `${connectionName}:${tablePath}`;
@@ -371,6 +373,11 @@ function extractSource(result, name, defaultURL) {
         return { compiler_needs: result.compilerNeeds, logs };
     }
 }
+function hasErrors(log) {
+    var _a;
+    return (_a = log === null || log === void 0 ? void 0 : log.some(m => m.severity === 'error')) !== null && _a !== void 0 ? _a : false;
+}
+exports.hasErrors = hasErrors;
 // Given a StableQueryDef and the URL to a model, run it and return a StableResult
 // Given a StableQueryDef and the URL to a model, compile it and return a StableResultDef
 // Given a StableQueryDef and the URL to a model, validate it and return a list of StableErrors
@@ -393,6 +400,7 @@ function newCompileQueryState(request) {
 }
 exports.newCompileQueryState = newCompileQueryState;
 function statedCompileQuery(state) {
+    var _a;
     const result = _statedCompileModel(state);
     // TODO this can expose the internal URL... is there a better way to handle URL-less errors from the compiler?
     const defaultURL = state.translator.sourceURL;
@@ -415,14 +423,33 @@ function statedCompileQuery(state) {
         const index = queries.length - 1;
         const query = result.modelDef.queryList[index];
         const schema = result.model.anonymous_queries[index].schema;
+        const annotations = (_a = result.model.anonymous_queries[index].annotations) !== null && _a !== void 0 ? _a : [];
         try {
             const queryModel = new model_1.QueryModel(result.modelDef);
             const translatedQuery = queryModel.compileQuery(query);
+            const modelAnnotations = (0, annotation_1.annotationToTaglines)(result.modelDef.annotation).map(l => ({
+                value: l,
+            }));
+            annotations.push({
+                value: malloy_tag_1.Tag.withPrefix('#(malloy) ')
+                    .set(['source_name'], translatedQuery.sourceExplore)
+                    .toString(),
+            });
+            if (translatedQuery.queryName) {
+                annotations.push({
+                    value: malloy_tag_1.Tag.withPrefix('#(malloy) ')
+                        .set(['query_name'], translatedQuery.queryName)
+                        .toString(),
+                });
+            }
             return {
                 result: {
                     sql: translatedQuery.sql,
                     schema,
                     connection_name: translatedQuery.connectionName,
+                    annotations: annotations.length > 0 ? annotations : undefined,
+                    model_annotations: modelAnnotations.length > 0 ? modelAnnotations : undefined,
+                    query_timezone: translatedQuery.queryTimezone,
                 },
             };
         }

package/dist/api/index.d.ts

@@ -1,3 +1,5 @@
 export * as sessioned from './sessioned';
 export * as stateless from './stateless';
 export * as asynchronous from './asynchronous';
+export * from './connection';
+export * as util from './util';

package/dist/api/index.js

@@ -22,8 +22,11 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __setModuleDefault(result, mod);
     return result;
 };
+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 });
-exports.asynchronous = exports.stateless = exports.sessioned = void 0;
+exports.util = exports.asynchronous = exports.stateless = exports.sessioned = void 0;
 /*
  * Copyright (c) Meta Platforms, Inc. and affiliates.
  *
@@ -33,4 +36,6 @@ exports.asynchronous = exports.stateless = exports.sessioned = void 0;
 exports.sessioned = __importStar(require("./sessioned"));
 exports.stateless = __importStar(require("./stateless"));
 exports.asynchronous = __importStar(require("./asynchronous"));
+__exportStar(require("./connection"), exports);
+exports.util = __importStar(require("./util"));
 //# sourceMappingURL=index.js.map

package/dist/api/sessioned.js

@@ -131,8 +131,7 @@ class SessionManager {
         this.sessions.delete(sessionId);
     }
     hasErrors(log) {
-        var _a;
-        return (_a = log === null || log === void 0 ? void 0 : log.some(m => m.severity === 'error')) !== null && _a !== void 0 ? _a : false;
+        return Core.hasErrors(log);
     }
     compileModel(request, options) {
         const sessionInfo = {

package/dist/api/stateless.spec.js

@@ -269,6 +269,7 @@ describe('api', () => {
             const result = (0, stateless_1.compileQuery)({
                 model_url: 'file://test.malloy',
                 query: {
+                    annotations: [{ value: '#(test) hello' }],
                     definition: {
                         kind: 'arrow',
                         source_reference: { name: 'flights' },
@@ -313,6 +314,11 @@ describe('api', () => {
             const expected = {
                 result: {
                     connection_name: 'connection',
+                    annotations: [
+                        { value: '#(test) hello\n' },
+                        { value: '#(malloy) ordered_by = [{ carrier = asc }]\n' },
+                        { value: '#(malloy) source_name = flights\n' },
+                    ],
                     sql: `SELECT \n\
    base."carrier" as "carrier"
 FROM flights as base

package/dist/api/util.d.ts

@@ -0,0 +1,9 @@
+import { InfoConnection as LegacyInfoConnection, Connection as LegacyConnection } from '../connection';
+import { Result } from '../malloy';
+import { QueryData } from '../model';
+import { Connection, InfoConnection } from './connection';
+import * as Malloy from '@malloydata/malloy-interfaces';
+export declare function wrapLegacyInfoConnection(connection: LegacyInfoConnection): InfoConnection;
+export declare function wrapLegacyConnection(connection: LegacyConnection): Connection;
+export declare function mapData(data: QueryData, schema: Malloy.Schema): Malloy.Data;
+export declare function wrapResult(result: Result): Malloy.Result;

package/dist/api/util.js

@@ -0,0 +1,215 @@
+"use strict";
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.wrapResult = exports.mapData = exports.wrapLegacyConnection = exports.wrapLegacyInfoConnection = void 0;
+const malloy_tag_1 = require("@malloydata/malloy-tag");
+const annotation_1 = require("../annotation");
+const to_stable_1 = require("../to_stable");
+const luxon_1 = require("luxon");
+function wrapLegacyInfoConnection(connection) {
+    return {
+        get dialectName() {
+            return connection.dialectName;
+        },
+        async fetchSchemaForSQLQuery(sql) {
+            const result = await connection.fetchSchemaForSQLStruct({ connection: connection.name, selectStr: sql }, {});
+            const table = result.structDef;
+            if (table === undefined) {
+                throw new Error(result.error);
+            }
+            return {
+                fields: (0, to_stable_1.convertFieldInfos)(table, table.fields),
+            };
+        },
+        async fetchSchemaForTable(tableName) {
+            const key = `${connection.name}:${tableName}`;
+            const result = await connection.fetchSchemaForTables({ [key]: tableName }, {});
+            const table = result.schemas[key];
+            if (table === undefined) {
+                throw new Error(result.errors[key]);
+            }
+            return {
+                fields: (0, to_stable_1.convertFieldInfos)(table, table.fields),
+            };
+        },
+    };
+}
+exports.wrapLegacyInfoConnection = wrapLegacyInfoConnection;
+function wrapLegacyConnection(connection) {
+    return {
+        ...wrapLegacyInfoConnection(connection),
+        runSQL: async (sql, schema) => {
+            const result = await connection.runSQL(sql);
+            return mapData(result.rows, schema);
+        },
+    };
+}
+exports.wrapLegacyConnection = wrapLegacyConnection;
+function valueToDate(value) {
+    // TODO properly map the data from BQ/Postgres types
+    if (value instanceof Date) {
+        return value;
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const valAsAny = value;
+    if (valAsAny.constructor.name === 'Date') {
+        // For some reason duckdb TSTZ values come back as objects which do not
+        // pass "instance of" but do seem date like.
+        return new Date(value);
+    }
+    else if (typeof value === 'number') {
+        return new Date(value);
+    }
+    else if (typeof value !== 'string') {
+        return new Date(value.value);
+    }
+    else {
+        // Postgres timestamps end up here, and ideally we would know the system
+        // timezone of the postgres instance to correctly create a Date() object
+        // which represents the same instant in time, but we don't have the data
+        // flow to implement that. This may be a problem at some future day,
+        // so here is a comment, for that day.
+        let parsed = luxon_1.DateTime.fromISO(value, { zone: 'UTC' });
+        if (!parsed.isValid) {
+            parsed = luxon_1.DateTime.fromSQL(value, { zone: 'UTC' });
+        }
+        return parsed.toJSDate();
+    }
+}
+function mapData(data, schema) {
+    function mapValue(value, field) {
+        if (value === null) {
+            return { kind: 'null_cell' };
+        }
+        else if (field.type.kind === 'date_type' ||
+            field.type.kind === 'timestamp_type') {
+            const time_value = valueToDate(value).toISOString();
+            if (field.type.kind === 'date_type') {
+                return { kind: 'date_cell', date_value: time_value };
+            }
+            else {
+                return { kind: 'timestamp_cell', timestamp_value: time_value };
+            }
+        }
+        else if (field.type.kind === 'boolean_type') {
+            if (typeof value === 'number') {
+                return { kind: 'boolean_cell', boolean_value: value !== 0 };
+            }
+            if (typeof value !== 'boolean') {
+                throw new Error(`Invalid boolean ${value}`);
+            }
+            return { kind: 'boolean_cell', boolean_value: value };
+        }
+        else if (field.type.kind === 'number_type') {
+            if (typeof value !== 'number') {
+                throw new Error(`Invalid number ${value}`);
+            }
+            return { kind: 'number_cell', number_value: value };
+        }
+        else if (field.type.kind === 'string_type') {
+            if (typeof value !== 'string') {
+                throw new Error(`Invalid string ${value}`);
+            }
+            return { kind: 'string_cell', string_value: value };
+        }
+        else if (field.type.kind === 'array_type') {
+            if (!Array.isArray(value)) {
+                throw new Error(`Invalid array ${value}`);
+            }
+            return {
+                kind: 'array_cell',
+                array_value: value.map(value => mapValue(value, {
+                    name: 'array_element',
+                    type: field.type.element_type,
+                })),
+            };
+        }
+        else if (field.type.kind === 'json_type') {
+            return { kind: 'json_cell', json_value: JSON.stringify(value) };
+        }
+        else if (field.type.kind === 'sql_native_type') {
+            return { kind: 'sql_native_cell', sql_native_value: JSON.stringify(value) };
+        }
+        else {
+            const type = field.type;
+            if (type.kind !== 'record_type') {
+                throw new Error(`Invalid record in result ${JSON.stringify(field)}, ${JSON.stringify(value)}`);
+            }
+            return mapRow(value, {
+                kind: 'join',
+                relationship: 'many',
+                name: 'array_element',
+                schema: {
+                    fields: type.fields.map(f => ({ kind: 'dimension', ...f })),
+                },
+            });
+        }
+    }
+    function mapRow(row, field) {
+        const cells = [];
+        for (const f of field.schema.fields) {
+            const value = row[f.name];
+            if (f.kind !== 'dimension') {
+                throw new Error('Invalid result -- expected all fields to be dimensions');
+            }
+            const cell = mapValue(value, f);
+            cells.push(cell);
+        }
+        return {
+            kind: 'record_cell',
+            record_value: cells,
+        };
+    }
+    const rootField = {
+        kind: 'join',
+        schema,
+        name: 'root',
+        relationship: 'one',
+    };
+    return {
+        kind: 'array_cell',
+        array_value: data.map(row => mapRow(row, rootField)),
+    };
+}
+exports.mapData = mapData;
+function wrapResult(result) {
+    const structs = result._queryResult.structs;
+    const struct = structs[structs.length - 1];
+    const schema = { fields: (0, to_stable_1.convertFieldInfos)(struct, struct.fields) };
+    const annotations = (0, annotation_1.annotationToTaglines)(result.annotation).map(l => ({
+        value: l,
+    }));
+    const metadataAnnot = struct.resultMetadata
+        ? (0, to_stable_1.getResultStructMetadataAnnotation)(struct, struct.resultMetadata)
+        : undefined;
+    if (metadataAnnot) {
+        annotations.push(metadataAnnot);
+    }
+    annotations.push(...(struct.resultMetadata ? [] : []));
+    if (result.sourceExplore) {
+        annotations.push({
+            value: malloy_tag_1.Tag.withPrefix('#(malloy) ')
+                .set(['source_name'], result.sourceExplore.name)
+                .toString(),
+        });
+    }
+    annotations.push({
+        value: malloy_tag_1.Tag.withPrefix('#(malloy) ')
+            .set(['query_name'], result.resultExplore.name)
+            .toString(),
+    });
+    return {
+        schema,
+        data: mapData(result.data.toObject(), schema),
+        connection_name: result.connectionName,
+        annotations: annotations.length > 0 ? annotations : undefined,
+        query_timezone: result.data.field.queryTimezone,
+    };
+}
+exports.wrapResult = wrapResult;
+//# sourceMappingURL=util.js.map

package/dist/index.d.ts

@@ -5,7 +5,7 @@ export { isSourceDef, Segment, isLeafAtomic, isJoined, isJoinedSource, isSamplin
 export { MalloyTranslator, } from './lang';
 export type { LogMessage, TranslateResponse } from './lang';
 export { Model, Malloy, Runtime, AtomicFieldType, ConnectionRuntime, SingleConnectionRuntime, EmptyURLReader, InMemoryURLReader, FixedConnectionMap, MalloyError, JoinRelationship, SourceRelationship, DateTimeframe, TimestampTimeframe, PreparedResult, Result, QueryMaterializer, CSVWriter, JSONWriter, Parse, DataWriter, Explore, InMemoryModelCache, CacheManager, } from './malloy';
-export type { PreparedQuery, Field, AtomicField, ExploreField, QueryField, SortableField, DataArray, DataRecord, DataColumn, DataArrayOrRecord, Loggable, ModelMaterializer, DocumentTablePath, DocumentSymbol, ResultJSON, PreparedResultMaterializer, ExploreMaterializer, WriteStream, SerializedExplore, ModelCache, CachedModel, DateField, TimestampField, } from './malloy';
+export type { PreparedQuery, Field, AtomicField, ExploreField, QueryField, SortableField, DataArray, DataRecord, DataColumn, DataArrayOrRecord, Loggable, ModelMaterializer, DocumentTablePath, DocumentSymbol, ResultJSON, PreparedResultJSON, PreparedResultMaterializer, ExploreMaterializer, WriteStream, SerializedExplore, ModelCache, CachedModel, DateField, TimestampField, } from './malloy';
 export type { QueryOptionsReader, RunSQLOptions } from './run_sql_options';
 export type { EventStream, ModelString, ModelURL, QueryString, QueryURL, URLReader, InvalidationKey, } from './runtime_types';
 export type { Connection, ConnectionConfig, ConnectionFactory, ConnectionParameter, ConnectionParameterValue, ConnectionConfigSchema, FetchSchemaOptions, InfoConnection, LookupConnection, PersistSQLResults, PooledConnection, TestableConnection, StreamingConnection, } from './connection/types';

package/dist/malloy.d.ts

@@ -482,7 +482,7 @@ export declare class PreparedResult implements Taggable {
      * @return The `Explore` representing the data that will be returned by running this query.
      */
     get resultExplore(): Explore;
-    get sourceExplore(): Explore;
+    get sourceExplore(): Explore | undefined;
     get _sourceExploreName(): string;
     get _sourceFilters(): FilterCondition[];
 }

package/dist/malloy.js

@@ -864,13 +864,9 @@ class PreparedResult {
     get sourceExplore() {
         const name = this.inner.sourceExplore;
         const explore = this.modelDef.contents[name];
-        if (explore === undefined) {
-            throw new Error('Malformed query result.');
-        }
-        if ((0, model_1.isSourceDef)(explore)) {
+        if (explore && (0, model_1.isSourceDef)(explore)) {
             return new Explore(explore);
         }
-        throw new Error(`'${name} is not an explore`);
     }
     get _sourceExploreName() {
         return this.inner.sourceExplore;

package/dist/model/malloy_query.d.ts

@@ -289,6 +289,7 @@ declare class QueryQuery extends QueryField {
     generateTurtlePipelineSQL(fi: FieldInstanceResult, stageWriter: StageWriter, sourceSQLExpression: string): {
         structDef: QueryResultDef;
         pipeOut: any;
+        repeatedResultType: RepeatedResultType;
     };
     generateComplexSQL(stageWriter: StageWriter): string;
     generateSQL(stageWriter: StageWriter): string;

package/dist/model/malloy_query.js

@@ -1934,8 +1934,8 @@ class QueryQuery extends QueryField {
         for (const [name, fi] of resultStruct.allFields) {
             const resultMetadata = this.getResultMetadata(fi);
             if (fi instanceof FieldInstanceResult) {
-                const { structDef } = this.generateTurtlePipelineSQL(fi, new StageWriter(true, undefined), '<nosource>');
-                if (fi.getRepeatedResultType() === 'nested') {
+                const { structDef, repeatedResultType } = this.generateTurtlePipelineSQL(fi, new StageWriter(true, undefined), '<nosource>');
+                if (repeatedResultType === 'nested') {
                     const multiLineNest = {
                         ...structDef,
                         type: 'array',
@@ -2716,6 +2716,7 @@ class QueryQuery extends QueryField {
         const repeatedResultType = fi.getRepeatedResultType();
         const hasPipeline = fi.turtleDef.pipeline.length > 1;
         let pipeOut;
+        let outputRepeatedResultType = repeatedResultType;
         if (hasPipeline) {
             const pipeline = [...fi.turtleDef.pipeline];
             pipeline.shift();
@@ -2735,6 +2736,7 @@ class QueryQuery extends QueryField {
             const qs = new QueryStruct(inputStruct, undefined, { model: this.parent.getModel() }, this.parent.prepareResultOptions);
             const q = QueryQuery.makeQuery(newTurtle, qs, stageWriter, this.isJoinedSubquery);
             pipeOut = q.generateSQLFromPipeline(stageWriter);
+            outputRepeatedResultType = q.rootResult.getRepeatedResultType();
             // console.log(stageWriter.generateSQLStages());
             structDef = pipeOut.outputStruct;
         }
@@ -2742,6 +2744,7 @@ class QueryQuery extends QueryField {
         return {
             structDef,
             pipeOut,
+            repeatedResultType: outputRepeatedResultType,
         };
     }
     generateComplexSQL(stageWriter) {
@@ -3706,6 +3709,7 @@ class QueryModel {
             queryName: query.name,
             connectionName: ret.connectionName,
             annotation: query.annotation,
+            queryTimezone: ret.structs[0].queryTimezone,
         };
     }
     async searchIndex(connection, explore, searchValue, limit = 1000, searchField = undefined) {

package/dist/to_stable.d.ts

@@ -1,4 +1,5 @@
 import * as Malloy from '@malloydata/malloy-interfaces';
-import { FieldDef, ModelDef, SourceDef } from './model';
+import { FieldDef, ModelDef, ResultStructMetadataDef, SourceDef } from './model';
 export declare function modelDefToModelInfo(modelDef: ModelDef): Malloy.ModelInfo;
 export declare function convertFieldInfos(source: SourceDef, fields: FieldDef[]): Malloy.FieldInfo[];
+export declare function getResultStructMetadataAnnotation(field: SourceDef, resultMetadata: ResultStructMetadataDef): Malloy.Annotation | undefined;

package/dist/to_stable.js

@@ -1,6 +1,12 @@
 "use strict";
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.convertFieldInfos = exports.modelDefToModelInfo = void 0;
+exports.getResultStructMetadataAnnotation = exports.convertFieldInfos = exports.modelDefToModelInfo = void 0;
 const model_1 = require("./model");
 const malloy_query_1 = require("./model/malloy_query");
 const annotation_1 = require("./annotation");
@@ -146,6 +152,13 @@ function getResultMetadataAnnotation(field, resultMetadata) {
         tag.set(['calculation']);
         hasAny = true;
     }
+    if (resultMetadata.filterList) {
+        const drillFilters = resultMetadata.filterList
+            .filter(f => f.expressionType === 'scalar')
+            .map(f => f.code);
+        tag.set(['drill_filters'], drillFilters);
+        hasAny = true;
+    }
     if (resultMetadata.fieldKind === 'dimension') {
         const dot = '.';
         // If field is joined-in from another table i.e. of type `tableName.columnName`,
@@ -153,7 +166,7 @@ function getResultMetadataAnnotation(field, resultMetadata) {
         const drillExpression = (resultMetadata === null || resultMetadata === void 0 ? void 0 : resultMetadata.sourceExpression) ||
             ((resultMetadata === null || resultMetadata === void 0 ? void 0 : resultMetadata.sourceField.includes(dot))
                 ? resultMetadata === null || resultMetadata === void 0 ? void 0 : resultMetadata.sourceField
-                : field.name);
+                : identifierCode(field.name));
         tag.set(['drill_expression'], drillExpression);
         hasAny = true;
     }
@@ -163,6 +176,14 @@ function getResultMetadataAnnotation(field, resultMetadata) {
         }
         : undefined;
 }
+function escapeIdentifier(str) {
+    return str.replace(/\\/g, '\\\\').replace(/`/g, '\\`');
+}
+function identifierCode(name) {
+    if (name.match(/^[A-Za-z_][0-9A-Za-z_]*$/))
+        return name;
+    return `\`${escapeIdentifier(name)}\``;
+}
 function getResultStructMetadataAnnotation(field, resultMetadata) {
     var _a, _b;
     const tag = malloy_tag_1.Tag.withPrefix('#(malloy) ');
@@ -171,11 +192,20 @@ function getResultStructMetadataAnnotation(field, resultMetadata) {
         tag.set(['limit'], resultMetadata.limit);
         hasAny = true;
     }
+    if (resultMetadata.filterList) {
+        const drillFilters = resultMetadata.filterList
+            .filter(f => f.expressionType === 'scalar')
+            .map(f => f.code);
+        if (drillFilters.length > 0) {
+            tag.set(['drill_filters'], drillFilters);
+            hasAny = true;
+        }
+    }
     if (resultMetadata.orderBy) {
         for (let i = 0; i < resultMetadata.orderBy.length; i++) {
             const orderBy = resultMetadata.orderBy[i];
             const orderByField = typeof orderBy.field === 'number'
-                ? (_a = field.fields[orderBy.field].as) !== null && _a !== void 0 ? _a : field.fields[orderBy.field].name
+                ? (_a = field.fields[orderBy.field - 1].as) !== null && _a !== void 0 ? _a : field.fields[orderBy.field - 1].name
                 : orderBy.field;
             const direction = (_b = orderBy.dir) !== null && _b !== void 0 ? _b : null;
             tag.set(['ordered_by', i, orderByField], direction);
@@ -188,6 +218,7 @@ function getResultStructMetadataAnnotation(field, resultMetadata) {
         }
         : undefined;
 }
+exports.getResultStructMetadataAnnotation = getResultStructMetadataAnnotation;
 function typeDefToType(field) {
     if ((0, model_1.isLeafAtomic)(field)) {
         switch (field.type) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@malloydata/malloy",
-  "version": "0.0.240-dev250311155207",
+  "version": "0.0.240-dev250311202829",
   "license": "MIT",
   "exports": {
     ".": "./dist/index.js",
@@ -41,8 +41,8 @@
     "generate-version-file": "VERSION=$(npm pkg get version --workspaces=false | tr -d \\\")\necho \"// generated with 'generate-version-file' script; do not edit manually\\nexport const MALLOY_VERSION = '$VERSION';\" > src/version.ts"
   },
   "dependencies": {
-    "@malloydata/malloy-interfaces": "^0.0.240-dev250311155207",
-    "@malloydata/malloy-tag": "^0.0.240-dev250311155207",
+    "@malloydata/malloy-interfaces": "^0.0.240-dev250311202829",
+    "@malloydata/malloy-tag": "^0.0.240-dev250311202829",
     "antlr4ts": "^0.5.0-alpha.4",
     "assert": "^2.0.0",
     "jest-diff": "^29.6.2",