@malloydata/malloy 0.0.240-dev250311155207 → 0.0.240-dev250311213218

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

@@ -105,7 +105,7 @@ describe('api', () => {
                 query: {
                     definition: {
                         kind: 'arrow',
-                        source_reference: { name: 'flights' },
+                        source: { kind: 'source_reference', name: 'flights' },
                         view: {
                             kind: 'segment',
                             operations: [
@@ -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' }],
                     },
                 ],
             };
@@ -195,7 +197,7 @@ ORDER BY 1 asc NULLS LAST
                 query: {
                     definition: {
                         kind: 'arrow',
-                        source_reference: { name: 'flights' },
+                        source: { kind: 'source_reference', name: 'flights' },
                         view: {
                             kind: 'segment',
                             operations: [

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

@@ -31,7 +31,9 @@ export declare function statedCompileModel(state: CompileModelState): Malloy.Com
 export declare function statedCompileSource(state: CompileModelState, name: string): Malloy.CompileSourceResponse;
 export declare function _statedCompileModel(state: CompileModelState): CompileResponse;
 export declare const DEFAULT_LOG_RANGE: Malloy.DocumentRange;
+export declare function mapLogs(logs: LogMessage[], defaultURL: string): Malloy.LogMessage[];
 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.mapLogs = 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}`;
@@ -324,6 +326,7 @@ function mapLogs(logs, defaultURL) {
         });
     });
 }
+exports.mapLogs = mapLogs;
 function wrapResponse(response, defaultURL) {
     const logs = response.logs ? mapLogs(response.logs, defaultURL) : undefined;
     if (response.compilerNeeds) {
@@ -371,6 +374,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 +401,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 +424,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/sessioned.spec.js

@@ -161,7 +161,7 @@ describe('api', () => {
             const query = {
                 definition: {
                     kind: 'arrow',
-                    source_reference: { name: 'flights' },
+                    source: { kind: 'source_reference', name: 'flights' },
                     view: {
                         kind: 'segment',
                         operations: [

package/dist/api/stateless.spec.js

@@ -269,9 +269,10 @@ 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' },
+                        source: { kind: 'source_reference', name: 'flights' },
                         view: {
                             kind: 'segment',
                             operations: [
@@ -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/lang/malloy-parse-info.d.ts

@@ -1,12 +1,4 @@
-import { CodePointCharStream, CommonTokenStream, ParserRuleContext } from 'antlr4ts';
-import { ParseTree } from 'antlr4ts/tree';
-import { DocumentRange } from '../model/malloy_types';
-export interface MalloyParseInfo {
-    root: ParseTree;
-    tokenStream: CommonTokenStream;
-    sourceStream: CodePointCharStream;
-    sourceURL: string;
+import { ParseInfo } from './utils';
+export interface MalloyParseInfo extends ParseInfo {
     importBaseURL: string;
-    rangeFromContext: (pcx: ParserRuleContext) => DocumentRange;
-    malloyVersion: string;
 }

package/dist/lang/malloy-to-ast.d.ts

@@ -44,6 +44,7 @@ export declare class MalloyToAST extends AbstractParseTreeVisitor<ast.MalloyElem
      * Log an error message relative to an AST node
      */
     protected astError<T extends MessageCode>(el: ast.MalloyElement, code: T, data: MessageParameterType<T>, options?: LogMessageOptions): void;
+    protected rangeFromContext(cx: ParserRuleContext): DocumentRange;
     protected getLocation(cx: ParserRuleContext): DocumentLocation;
     protected getSourceString(cx: ParserRuleContext): string;
     /**

package/dist/lang/malloy-to-ast.js

@@ -105,10 +105,13 @@ class MalloyToAST extends AbstractParseTreeVisitor_1.AbstractParseTreeVisitor {
     astError(el, code, data, options) {
         this.msgLog.log((0, parse_log_1.makeLogMessage)(code, data, { at: el.location, ...options }));
     }
+    rangeFromContext(cx) {
+        return (0, utils_1.rangeFromContext)(this.parseInfo.sourceInfo, cx);
+    }
     getLocation(cx) {
         return {
             url: this.parseInfo.sourceURL,
-            range: this.parseInfo.rangeFromContext(cx),
+            range: this.rangeFromContext(cx),
         };
     }
     getSourceString(cx) {
@@ -180,7 +183,7 @@ class MalloyToAST extends AbstractParseTreeVisitor_1.AbstractParseTreeVisitor {
     astAt(el, cx) {
         el.location = {
             url: this.parseInfo.sourceURL,
-            range: this.parseInfo.rangeFromContext(cx),
+            range: this.rangeFromContext(cx),
         };
         return el;
     }
@@ -957,7 +960,7 @@ class MalloyToAST extends AbstractParseTreeVisitor_1.AbstractParseTreeVisitor {
         const left = this.getFieldExpr(pcx.fieldExpr(0));
         const right = this.getFieldExpr(pcx.fieldExpr(1));
         if (ast.isEquality(op)) {
-            const wholeRange = this.parseInfo.rangeFromContext(pcx);
+            const wholeRange = this.rangeFromContext(pcx);
             if (right instanceof ast.ExprNULL) {
                 if (op === '=') {
                     this.warnWithReplacement('sql-is-null', "Use 'is null' to check for NULL instead of '= null'", wholeRange, `${this.getSourceCode(pcx.fieldExpr(0))} is null`);
@@ -1170,7 +1173,7 @@ class MalloyToAST extends AbstractParseTreeVisitor_1.AbstractParseTreeVisitor {
         });
         const elseCx = pcx._caseElse;
         const theElse = elseCx ? this.getFieldExpr(elseCx) : undefined;
-        this.warnWithReplacement('sql-case', 'Use a `pick` statement instead of `case`', this.parseInfo.rangeFromContext(pcx), `${[
+        this.warnWithReplacement('sql-case', 'Use a `pick` statement instead of `case`', this.rangeFromContext(pcx), `${[
             ...(valueCx ? [`${this.getSourceCode(valueCx)} ?`] : []),
             ...whenCxs.map(whenCx => `pick ${this.getSourceCode(whenCx._result)} when ${this.getSourceCode(whenCx._condition)}`),
             elseCx ? `else ${elseCx.text}` : 'else null',
@@ -1486,7 +1489,7 @@ class MalloyToAST extends AbstractParseTreeVisitor_1.AbstractParseTreeVisitor {
         let op = '~';
         const left = pcx.fieldExpr(0);
         const right = pcx.fieldExpr(1);
-        const wholeRange = this.parseInfo.rangeFromContext(pcx);
+        const wholeRange = this.rangeFromContext(pcx);
         if (pcx.NOT()) {
             op = '!~';
             this.warnWithReplacement('sql-not-like', "Use Malloy operator '!~' instead of 'NOT LIKE'", wholeRange, `${this.getSourceCode(left)} !~ ${this.getSourceCode(right)}`);
@@ -1505,7 +1508,7 @@ class MalloyToAST extends AbstractParseTreeVisitor_1.AbstractParseTreeVisitor {
         const isNot = !!pcx.NOT();
         const from = pcx.fieldExprList().fieldExpr();
         const inStmt = this.astAt(new ast.ExprLegacyIn(expr, isNot, from.map(f => this.getFieldExpr(f))), pcx);
-        this.warnWithReplacement('sql-in', `Use = (a|b|c) instead of${isNot ? ' NOT' : ''} IN (a,b,c)`, this.parseInfo.rangeFromContext(pcx), `${this.getSourceCode(pcx.fieldExpr())} ${isNot ? '!=' : '='} (${from
+        this.warnWithReplacement('sql-in', `Use = (a|b|c) instead of${isNot ? ' NOT' : ''} IN (a,b,c)`, this.rangeFromContext(pcx), `${this.getSourceCode(pcx.fieldExpr())} ${isNot ? '!=' : '='} (${from
             .map(f => this.getSourceCode(f))
             .join(' | ')})`);
         return inStmt;

package/dist/lang/malloy-to-stable-query.d.ts

@@ -0,0 +1,76 @@
+import { ParserRuleContext } from 'antlr4ts';
+import { ParseTree, TerminalNode } from 'antlr4ts/tree';
+import { AbstractParseTreeVisitor } from 'antlr4ts/tree/AbstractParseTreeVisitor';
+import { MalloyParserVisitor } from './lib/Malloy/MalloyParserVisitor';
+import * as Malloy from '@malloydata/malloy-interfaces';
+import * as parse from './lib/Malloy/MalloyParser';
+import { LogMessageOptions, MessageCode, MessageLogger, MessageParameterType } from './parse-log';
+import { DocumentLocation } from '../model/malloy_types';
+import { ParseInfo } from './utils';
+type HasAnnotations = ParserRuleContext & {
+    ANNOTATION: () => TerminalNode[];
+};
+type Node = Malloy.Query | Malloy.QueryDefinitionWithArrow | Malloy.QueryDefinitionWithQueryReference | Malloy.QueryDefinitionWithRefinement | null;
+/**
+ * ANTLR visitor pattern parse tree traversal. Generates a Malloy
+ * AST from an ANTLR parse tree.
+ */
+export declare class MalloyToQuery extends AbstractParseTreeVisitor<Node> implements MalloyParserVisitor<Node> {
+    readonly parseInfo: ParseInfo;
+    readonly msgLog: MessageLogger;
+    constructor(parseInfo: ParseInfo, msgLog: MessageLogger);
+    /**
+     * Mostly used to flag a case where the grammar and the type system are
+     * no longer in sync. A visitor was written based on a grammar which
+     * apparently has changed and now an unexpected element type has appeared.
+     * This is a non recoverable error, since the parser and the grammar
+     * are not compatible.
+     * @return an error object to throw.
+     */
+    protected internalError(cx: ParserRuleContext, message: string): Error;
+    protected getLocation(cx: ParserRuleContext): DocumentLocation;
+    /**
+     * Log an error message relative to a parse node
+     */
+    protected contextError<T extends MessageCode>(cx: ParserRuleContext, code: T, data: MessageParameterType<T>, options?: LogMessageOptions): void;
+    protected getNumber(term: ParseTree): number;
+    protected defaultResult(): Node;
+    /**
+     * Get all the possibly missing annotations from this parse rule
+     * @param cx Any parse context which has an ANNOTATION* rules
+     * @returns Array of texts for the annotations
+     */
+    protected getAnnotations(cx: HasAnnotations): Malloy.Annotation[] | undefined;
+    protected getIsAnnotations(cx?: parse.IsDefineContext): Malloy.Annotation[] | undefined;
+    protected notAllowed(pcx: ParserRuleContext, what: string): void;
+    protected illegal(pcx: ParserRuleContext, what: string): void;
+    visitMalloyDocument(pcx: parse.MalloyDocumentContext): Malloy.Query | null;
+    visitRunStatement(pcx: parse.RunStatementContext): Malloy.Query | null;
+    protected getQueryReference(cx: parse.SQIDContext): Malloy.Reference | null;
+    protected getQueryDefinition(cx: parse.SqExprContext): Malloy.QueryDefinition | null;
+    protected getRefinementSegment(cx: parse.SegExprContext): Malloy.ViewDefinition | null;
+    protected getGroupByStatement(gbcx: parse.GroupByStatementContext): Malloy.ViewOperationWithGroupBy[] | null;
+    protected getAggregateStatement(agcx: parse.AggregateStatementContext): Malloy.ViewOperationWithAggregate[] | null;
+    protected getOrderByStatement(obcx: parse.OrderByStatementContext): Malloy.ViewOperationWithOrderBy[] | null;
+    protected getNestStatement(nstcx: parse.NestStatementContext): Malloy.ViewOperationWithNest[] | null;
+    protected getViewExpression(cx: parse.VExprContext): Malloy.ViewDefinition | null;
+    protected getLimitStatement(cx: parse.LimitStatementContext): Malloy.ViewOperationWithLimit | null;
+    protected getSegmentOperation(cx: parse.QueryStatementContext): Malloy.ViewOperation[] | null;
+    protected getFieldPath(pcx: parse.FieldPathContext): {
+        name: string;
+        path?: string[];
+    };
+    protected getTimeframe(cx: parse.TimeframeContext): Malloy.TimestampTimeframe | null;
+    protected getQueryField(cx: parse.QueryFieldEntryContext): {
+        name?: string;
+        field: Malloy.Field;
+    } | null;
+    getFieldExpression(cx: parse.FieldExprContext): Malloy.Expression | null;
+    getWhere(_whereCx: parse.WhereStatementContext): Malloy.Where[] | null;
+    protected combineAnnotations(...a: (Malloy.Annotation[] | undefined)[]): Malloy.Annotation[] | undefined;
+}
+export declare function malloyToQuery(code: string): {
+    query?: Malloy.Query;
+    logs: Malloy.LogMessage[];
+};
+export {};