@malloydata/malloy 0.0.48 → 0.0.49-dev230626192330

package/dist/lang/lib/Malloy/MalloyParserListener.d.ts

@@ -19,6 +19,8 @@ import { ExprNULLContext } from "./MalloyParser";
 import { ExprBoolContext } from "./MalloyParser";
 import { ExprRegexContext } from "./MalloyParser";
 import { ExprNowContext } from "./MalloyParser";
+import { TableFunctionContext } from "./MalloyParser";
+import { TableMethodContext } from "./MalloyParser";
 import { NestExistingContext } from "./MalloyParser";
 import { NestDefContext } from "./MalloyParser";
 import { ExprFieldPathContext } from "./MalloyParser";
@@ -97,6 +99,7 @@ import { PipelineFromNameContext } from "./MalloyParser";
 import { FirstSegmentContext } from "./MalloyParser";
 import { PipeElementContext } from "./MalloyParser";
 import { ExploreTableContext } from "./MalloyParser";
+import { ConnectionIdContext } from "./MalloyParser";
 import { QueryPropertiesContext } from "./MalloyParser";
 import { FilterShortcutContext } from "./MalloyParser";
 import { ExploreQueryNameContext } from "./MalloyParser";
@@ -164,7 +167,8 @@ import { MalloyTypeContext } from "./MalloyParser";
 import { CompareOpContext } from "./MalloyParser";
 import { LiteralContext } from "./MalloyParser";
 import { DateLiteralContext } from "./MalloyParser";
-import { TableNameContext } from "./MalloyParser";
+import { TablePathContext } from "./MalloyParser";
+import { TableURIContext } from "./MalloyParser";
 import { IdContext } from "./MalloyParser";
 import { TimeframeContext } from "./MalloyParser";
 import { UngroupContext } from "./MalloyParser";
@@ -435,6 +439,30 @@ export interface MalloyParserListener extends ParseTreeListener {
      * @param ctx the parse tree
      */
     exitExprNow?: (ctx: ExprNowContext) => void;
+    /**
+     * Enter a parse tree produced by the `tableFunction`
+     * labeled alternative in `MalloyParser.exploreTable`.
+     * @param ctx the parse tree
+     */
+    enterTableFunction?: (ctx: TableFunctionContext) => void;
+    /**
+     * Exit a parse tree produced by the `tableFunction`
+     * labeled alternative in `MalloyParser.exploreTable`.
+     * @param ctx the parse tree
+     */
+    exitTableFunction?: (ctx: TableFunctionContext) => void;
+    /**
+     * Enter a parse tree produced by the `tableMethod`
+     * labeled alternative in `MalloyParser.exploreTable`.
+     * @param ctx the parse tree
+     */
+    enterTableMethod?: (ctx: TableMethodContext) => void;
+    /**
+     * Exit a parse tree produced by the `tableMethod`
+     * labeled alternative in `MalloyParser.exploreTable`.
+     * @param ctx the parse tree
+     */
+    exitTableMethod?: (ctx: TableMethodContext) => void;
     /**
      * Enter a parse tree produced by the `nestExisting`
      * labeled alternative in `MalloyParser.nestEntry`.
@@ -1319,6 +1347,16 @@ export interface MalloyParserListener extends ParseTreeListener {
      * @param ctx the parse tree
      */
     exitExploreTable?: (ctx: ExploreTableContext) => void;
+    /**
+     * Enter a parse tree produced by `MalloyParser.connectionId`.
+     * @param ctx the parse tree
+     */
+    enterConnectionId?: (ctx: ConnectionIdContext) => void;
+    /**
+     * Exit a parse tree produced by `MalloyParser.connectionId`.
+     * @param ctx the parse tree
+     */
+    exitConnectionId?: (ctx: ConnectionIdContext) => void;
     /**
      * Enter a parse tree produced by `MalloyParser.queryProperties`.
      * @param ctx the parse tree
@@ -1990,15 +2028,25 @@ export interface MalloyParserListener extends ParseTreeListener {
      */
     exitDateLiteral?: (ctx: DateLiteralContext) => void;
     /**
-     * Enter a parse tree produced by `MalloyParser.tableName`.
+     * Enter a parse tree produced by `MalloyParser.tablePath`.
+     * @param ctx the parse tree
+     */
+    enterTablePath?: (ctx: TablePathContext) => void;
+    /**
+     * Exit a parse tree produced by `MalloyParser.tablePath`.
+     * @param ctx the parse tree
+     */
+    exitTablePath?: (ctx: TablePathContext) => void;
+    /**
+     * Enter a parse tree produced by `MalloyParser.tableURI`.
      * @param ctx the parse tree
      */
-    enterTableName?: (ctx: TableNameContext) => void;
+    enterTableURI?: (ctx: TableURIContext) => void;
     /**
-     * Exit a parse tree produced by `MalloyParser.tableName`.
+     * Exit a parse tree produced by `MalloyParser.tableURI`.
      * @param ctx the parse tree
      */
-    exitTableName?: (ctx: TableNameContext) => void;
+    exitTableURI?: (ctx: TableURIContext) => void;
     /**
      * Enter a parse tree produced by `MalloyParser.id`.
      * @param ctx the parse tree

package/dist/lang/lib/Malloy/MalloyParserVisitor.d.ts

@@ -19,6 +19,8 @@ import { ExprNULLContext } from "./MalloyParser";
 import { ExprBoolContext } from "./MalloyParser";
 import { ExprRegexContext } from "./MalloyParser";
 import { ExprNowContext } from "./MalloyParser";
+import { TableFunctionContext } from "./MalloyParser";
+import { TableMethodContext } from "./MalloyParser";
 import { NestExistingContext } from "./MalloyParser";
 import { NestDefContext } from "./MalloyParser";
 import { ExprFieldPathContext } from "./MalloyParser";
@@ -97,6 +99,7 @@ import { PipelineFromNameContext } from "./MalloyParser";
 import { FirstSegmentContext } from "./MalloyParser";
 import { PipeElementContext } from "./MalloyParser";
 import { ExploreTableContext } from "./MalloyParser";
+import { ConnectionIdContext } from "./MalloyParser";
 import { QueryPropertiesContext } from "./MalloyParser";
 import { FilterShortcutContext } from "./MalloyParser";
 import { ExploreQueryNameContext } from "./MalloyParser";
@@ -164,7 +167,8 @@ import { MalloyTypeContext } from "./MalloyParser";
 import { CompareOpContext } from "./MalloyParser";
 import { LiteralContext } from "./MalloyParser";
 import { DateLiteralContext } from "./MalloyParser";
-import { TableNameContext } from "./MalloyParser";
+import { TablePathContext } from "./MalloyParser";
+import { TableURIContext } from "./MalloyParser";
 import { IdContext } from "./MalloyParser";
 import { TimeframeContext } from "./MalloyParser";
 import { UngroupContext } from "./MalloyParser";
@@ -338,6 +342,20 @@ export interface MalloyParserVisitor<Result> extends ParseTreeVisitor<Result> {
      * @return the visitor result
      */
     visitExprNow?: (ctx: ExprNowContext) => Result;
+    /**
+     * Visit a parse tree produced by the `tableFunction`
+     * labeled alternative in `MalloyParser.exploreTable`.
+     * @param ctx the parse tree
+     * @return the visitor result
+     */
+    visitTableFunction?: (ctx: TableFunctionContext) => Result;
+    /**
+     * Visit a parse tree produced by the `tableMethod`
+     * labeled alternative in `MalloyParser.exploreTable`.
+     * @param ctx the parse tree
+     * @return the visitor result
+     */
+    visitTableMethod?: (ctx: TableMethodContext) => Result;
     /**
      * Visit a parse tree produced by the `nestExisting`
      * labeled alternative in `MalloyParser.nestEntry`.
@@ -858,6 +876,12 @@ export interface MalloyParserVisitor<Result> extends ParseTreeVisitor<Result> {
      * @return the visitor result
      */
     visitExploreTable?: (ctx: ExploreTableContext) => Result;
+    /**
+     * Visit a parse tree produced by `MalloyParser.connectionId`.
+     * @param ctx the parse tree
+     * @return the visitor result
+     */
+    visitConnectionId?: (ctx: ConnectionIdContext) => Result;
     /**
      * Visit a parse tree produced by `MalloyParser.queryProperties`.
      * @param ctx the parse tree
@@ -1261,11 +1285,17 @@ export interface MalloyParserVisitor<Result> extends ParseTreeVisitor<Result> {
      */
     visitDateLiteral?: (ctx: DateLiteralContext) => Result;
     /**
-     * Visit a parse tree produced by `MalloyParser.tableName`.
+     * Visit a parse tree produced by `MalloyParser.tablePath`.
+     * @param ctx the parse tree
+     * @return the visitor result
+     */
+    visitTablePath?: (ctx: TablePathContext) => Result;
+    /**
+     * Visit a parse tree produced by `MalloyParser.tableURI`.
      * @param ctx the parse tree
      * @return the visitor result
      */
-    visitTableName?: (ctx: TableNameContext) => Result;
+    visitTableURI?: (ctx: TableURIContext) => Result;
     /**
      * Visit a parse tree produced by `MalloyParser.id`.
      * @param ctx the parse tree

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

@@ -65,7 +65,8 @@ export declare class MalloyToAST extends AbstractParseTreeVisitor<ast.MalloyElem
     visitSourceDefinition(pcx: parse.SourceDefinitionContext): ast.DefineSource;
     visitExplore(pcx: parse.ExploreContext): ast.Source;
     visitExploreProperties(pcx: parse.ExplorePropertiesContext): ast.SourceDesc;
-    visitExploreTable(pcx: parse.ExploreTableContext): ast.TableSource;
+    visitTableFunction(pcx: parse.TableFunctionContext): ast.TableSource;
+    visitTableMethod(pcx: parse.TableMethodContext): ast.TableSource;
     visitTableSource(pcx: parse.TableSourceContext): ast.TableSource;
     visitSQLSourceName(pcx: parse.SQLSourceNameContext): ast.SQLSource;
     visitQuerySource(pcx: parse.QuerySourceContext): ast.Source;

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

@@ -49,6 +49,7 @@ exports.MalloyToAST = void 0;
 const AbstractParseTreeVisitor_1 = require("antlr4ts/tree/AbstractParseTreeVisitor");
 const ast = __importStar(require("./ast"));
 const Interval_1 = require("antlr4ts/misc/Interval");
+const ast_1 = require("./ast");
 const ENABLE_M4_WARNINGS = false;
 class IgnoredElement extends ast.MalloyElement {
     constructor(src) {
@@ -262,12 +263,26 @@ class MalloyToAST extends AbstractParseTreeVisitor_1.AbstractParseTreeVisitor {
         }
         return propList;
     }
-    visitExploreTable(pcx) {
-        const tableName = this.stripQuotes(pcx.tableName().text);
-        return this.astAt(new ast.TableSource(tableName), pcx);
+    visitTableFunction(pcx) {
+        const tableURI = this.stripQuotes(pcx.tableURI().text);
+        const el = this.astAt(new ast.TableFunctionSource(tableURI), pcx);
+        if (ENABLE_M4_WARNINGS) {
+            this.astError(el, "`table('connection_name:table_path')` is deprecated; use `connection_name.table('table_path')`", 'warn');
+        }
+        return el;
+    }
+    visitTableMethod(pcx) {
+        const connId = pcx.connectionId();
+        const connectionName = this.astAt(this.getModelEntryName(connId), connId);
+        const tablePath = this.stripQuotes(pcx.tablePath().text);
+        return this.astAt(new ast.TableMethodSource(connectionName, tablePath), pcx);
     }
     visitTableSource(pcx) {
-        return this.visitExploreTable(pcx.exploreTable());
+        const result = this.visit(pcx.exploreTable());
+        if (result instanceof ast_1.TableSource) {
+            return result;
+        }
+        throw this.internalError(pcx, `Table source matched, but ${result.elementType} found`);
     }
     visitSQLSourceName(pcx) {
         const name = this.getModelEntryName(pcx.sqlExploreNameRef());

package/dist/lang/parse-malloy.d.ts

@@ -56,7 +56,7 @@ declare class ParseStep implements TranslationStep {
 }
 declare class ImportsAndTablesStep implements TranslationStep {
     readonly parseStep: ParseStep;
-    private alreadyLooked;
+    private parseReferences;
     constructor(parseStep: ParseStep);
     step(that: MalloyTranslation): DataRequestResponse | ParseResponse;
 }

package/dist/lang/parse-malloy.js

@@ -194,45 +194,40 @@ class ParseStep {
 class ImportsAndTablesStep {
     constructor(parseStep) {
         this.parseStep = parseStep;
-        this.alreadyLooked = false;
+        this.parseReferences = undefined;
     }
     step(that) {
         const parseReq = this.parseStep.step(that);
         if (parseReq.parse === undefined) {
             return parseReq;
         }
-        if (!this.alreadyLooked) {
-            this.alreadyLooked = true;
-            const parseRefs = (0, find_external_references_1.findReferences)(that, parseReq.parse.tokenStream, parseReq.parse.root);
-            if (parseRefs === null || parseRefs === void 0 ? void 0 : parseRefs.tables) {
-                for (const ref in parseRefs.tables) {
-                    that.root.schemaZone.reference(ref, {
+        if (!this.parseReferences) {
+            this.parseReferences = (0, find_external_references_1.findReferences)(that, parseReq.parse.tokenStream, parseReq.parse.root);
+            for (const ref in this.parseReferences.tables) {
+                that.root.schemaZone.reference(ref, {
+                    url: that.sourceURL,
+                    range: this.parseReferences.tables[ref].firstReference,
+                });
+            }
+            for (const relativeRef in this.parseReferences.urls) {
+                const firstRef = this.parseReferences.urls[relativeRef];
+                try {
+                    const ref = decodeURI(new URL(relativeRef, that.sourceURL).toString());
+                    that.addChild(ref);
+                    that.root.importZone.reference(ref, {
                         url: that.sourceURL,
-                        range: parseRefs.tables[ref],
+                        range: firstRef,
                     });
                 }
-            }
-            if (parseRefs === null || parseRefs === void 0 ? void 0 : parseRefs.urls) {
-                for (const relativeRef in parseRefs.urls) {
-                    const firstRef = parseRefs.urls[relativeRef];
-                    try {
-                        const ref = decodeURI(new URL(relativeRef, that.sourceURL).toString());
-                        that.addChild(ref);
-                        that.root.importZone.reference(ref, {
-                            url: that.sourceURL,
-                            range: firstRef,
-                        });
-                    }
-                    catch (err) {
-                        // This import spec is so bad the URL library threw up, this
-                        // may be impossible, because it will append any garbage
-                        // to the known good rootURL assuming it is relative
-                        that.root.logger.log({
-                            message: `Malformed URL '${relativeRef}'"`,
-                            at: { url: that.sourceURL, range: firstRef },
-                            severity: 'error',
-                        });
-                    }
+                catch (err) {
+                    // This import spec is so bad the URL library threw up, this
+                    // may be impossible, because it will append any garbage
+                    // to the known good rootURL assuming it is relative
+                    that.root.logger.log({
+                        message: `Malformed URL '${relativeRef}'"`,
+                        at: { url: that.sourceURL, range: firstRef },
+                        severity: 'error',
+                    });
                 }
             }
         }
@@ -244,7 +239,15 @@ class ImportsAndTablesStep {
         let allMissing = {};
         const missingTables = that.root.schemaZone.getUndefined();
         if (missingTables) {
-            allMissing = { tables: missingTables };
+            const tables = {};
+            for (const key of missingTables) {
+                const info = this.parseReferences.tables[key];
+                tables[key] = {
+                    connectionName: info.connectionName,
+                    tablePath: info.tablePath,
+                };
+            }
+            allMissing = { tables };
         }
         const missingImports = that.root.importZone.getUndefined();
         if (missingImports) {

package/dist/lang/parse-tree-walkers/find-external-references.d.ts

@@ -2,10 +2,29 @@ import { CommonTokenStream } from 'antlr4ts';
 import { ParseTree } from 'antlr4ts/tree';
 import { DocumentRange } from '../../model/malloy_types';
 import { MalloyTranslation } from '../parse-malloy';
-declare type References = Record<string, DocumentRange>;
-interface FinderFound {
-    tables?: References;
-    urls?: References;
+declare type NeedImports = Record<string, DocumentRange>;
+declare type NeedTables = Record<string, {
+    connectionName: string | undefined;
+    tablePath: string;
+    firstReference: DocumentRange;
+}>;
+export declare function constructTableKey(connectionName: string | undefined, tablePath: string): string;
+/**
+ * This function parses an old-style `tableURI` into a connection name and
+ * table path. The name includes `deprecated` because it should only be used
+ * in the (deprecated) old-style `table('conn:tab')` syntax. Any use of this
+ * anywhere else is bad.
+ * @param tableURI The sting that is passed into the `table('conn:tab')` syntax.
+ * @returns A connection name and table path.
+ * @deprecated
+ */
+export declare function deprecatedParseTableURI(tableURI: string): {
+    connectionName?: string;
+    tablePath: string;
+};
+export interface FindReferencesData {
+    tables: NeedTables;
+    urls: NeedImports;
 }
-export declare function findReferences(trans: MalloyTranslation, tokens: CommonTokenStream, parseTree: ParseTree): FinderFound | null;
+export declare function findReferences(trans: MalloyTranslation, tokens: CommonTokenStream, parseTree: ParseTree): FindReferencesData;
 export {};

package/dist/lang/parse-tree-walkers/find-external-references.js

@@ -22,7 +22,7 @@
  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.findReferences = void 0;
+exports.findReferences = exports.deprecatedParseTableURI = exports.constructTableKey = void 0;
 const ParseTreeWalker_1 = require("antlr4ts/tree/ParseTreeWalker");
 class FindExternalReferences {
     constructor(trans, tokens) {
@@ -31,31 +31,77 @@ class FindExternalReferences {
         this.needTables = {};
         this.needImports = {};
     }
-    enterTableName(pcx) {
-        const tableName = this.tokens.getText(pcx).slice(1, -1);
-        if (!this.needTables[tableName]) {
-            this.needTables[tableName] = this.trans.rangeFromContext(pcx);
+    registerTableReference(connectionName, tablePath, reference) {
+        const key = constructTableKey(connectionName, tablePath);
+        if (!this.needTables[key]) {
+            this.needTables[key] = {
+                connectionName,
+                tablePath,
+                firstReference: reference,
+            };
         }
     }
+    enterTableMethod(pcx) {
+        const connectionName = this.stripIdQuotes(pcx.connectionId().text);
+        const tablePath = this.tokens.getText(pcx.tablePath()).slice(1, -1);
+        const reference = this.trans.rangeFromContext(pcx);
+        this.registerTableReference(connectionName, tablePath, reference);
+    }
+    enterTableFunction(pcx) {
+        const tableURI = this.tokens.getText(pcx.tableURI()).slice(1, -1);
+        // This use of `deprecatedParseTableURI` is ok because it is for handling the
+        // old, soon-to-be-deprecated table syntax.
+        const { connectionName, tablePath } = deprecatedParseTableURI(tableURI);
+        const reference = this.trans.rangeFromContext(pcx);
+        this.registerTableReference(connectionName, tablePath, reference);
+    }
     enterImportURL(pcx) {
         const url = JSON.parse(pcx.JSON_STRING().text);
         if (!this.needImports[url]) {
             this.needImports[url] = this.trans.rangeFromContext(pcx);
         }
     }
+    stripIdQuotes(id) {
+        if (id[0] === '`' && id[id.length - 1] === '`') {
+            return id.slice(1, -1);
+        }
+        return id;
+    }
+}
+function constructTableKey(connectionName, tablePath) {
+    return connectionName === undefined
+        ? tablePath
+        : `${connectionName}:${tablePath}`;
 }
+exports.constructTableKey = constructTableKey;
+/**
+ * This function parses an old-style `tableURI` into a connection name and
+ * table path. The name includes `deprecated` because it should only be used
+ * in the (deprecated) old-style `table('conn:tab')` syntax. Any use of this
+ * anywhere else is bad.
+ * @param tableURI The sting that is passed into the `table('conn:tab')` syntax.
+ * @returns A connection name and table path.
+ * @deprecated
+ */
+function deprecatedParseTableURI(tableURI) {
+    const parts = tableURI.match(/^([^:]*):(.*)$/);
+    if (parts) {
+        const [, firstPart, secondPart] = parts;
+        return { connectionName: firstPart, tablePath: secondPart };
+    }
+    else {
+        return { tablePath: tableURI };
+    }
+}
+exports.deprecatedParseTableURI = deprecatedParseTableURI;
 function findReferences(trans, tokens, parseTree) {
     const finder = new FindExternalReferences(trans, tokens);
     const listener = finder;
     ParseTreeWalker_1.ParseTreeWalker.DEFAULT.walk(listener, parseTree);
-    let refs = {};
-    if (Object.keys(finder.needTables).length > 0) {
-        refs = { tables: finder.needTables };
-    }
-    if (Object.keys(finder.needImports).length > 0) {
-        refs = { ...refs, urls: finder.needImports };
-    }
-    return Object.keys(refs).length > 0 ? refs : null;
+    return {
+        tables: finder.needTables,
+        urls: finder.needImports,
+    };
 }
 exports.findReferences = findReferences;
 //# sourceMappingURL=find-external-references.js.map

package/dist/lang/test/parse-expects.js

@@ -44,7 +44,9 @@ function prettyNeeds(response) {
     let needString = '';
     if (response.tables) {
         needString += 'Tables:\n';
-        response.tables.forEach(table => (needString += `  - ${table}`));
+        for (const table in response.tables) {
+            needString += `  - ${table}`;
+        }
     }
     if (response.compileSQL) {
         needString += `Compile SQL: ${response.compileSQL.name}`;

package/dist/lang/test/parse.spec.js

@@ -28,6 +28,35 @@ const test_translator_1 = require("./test-translator");
 const granular_result_1 = require("../ast/types/granular-result");
 require("./parse-expects");
 describe('model statements', () => {
+    describe('table method', () => {
+        test('table method works', () => {
+            expect("source: testA is conn.table('aTable')").toTranslate();
+        });
+        test('table method works with quoted connection name', () => {
+            expect("source: testA is `conn`.table('aTable')").toTranslate();
+        });
+        test('table method fails when connection name is wrong', () => {
+            expect("source: testA is bad_conn.table('aTable')").not.toTranslate();
+        });
+        test('table method fails when connection is not a connection', () => {
+            const m = (0, test_translator_1.model) `source: a1 is a; source: testA is a1.table('aTable')`;
+            // This is a somewhat weird behavior from the translator. During the
+            // first phase of translation, we fetch "external references" (tables and
+            // imports). At that point we don't know that there will be an error
+            // "a1 is not a connection," so we attempt to fetch `aTable` from connection
+            // `a1` even though a1 is not a connection. The response from the application
+            // is basically ignored in the end, as we still eventually get the error
+            // that a1 is not a connection (it's a source).
+            m.translator.update({
+                errors: { tables: { 'a1:aTable': 'invalid connection' } },
+            });
+            expect(m).translationToFailWith('a1 is not a connection');
+        });
+        // TODO unskip this when ENABLE_M4_WARNINGS becomes a document annotation
+        test.skip('table function is deprecated', () => {
+            expect("testA is table('conn:aTable')").toTranslateWithWarnings("`table('connection_name:table_path')` is deprecated; use `connection_name.table('table_path')`");
+        });
+    });
     describe('source:', () => {
         test('table', () => {
             expect("source: testA is table('aTable')").toTranslate();
@@ -2409,7 +2438,7 @@ describe('translation need error locations', () => {
         const result = m.translate();
         m.update({
             errors: {
-                tables: { [(result.tables || [])[0]]: 'Bad table!' },
+                tables: { [Object.keys(result.tables || {})[0]]: 'Bad table!' },
             },
         });
         expect(m).translationToFailWith(/Bad table!/);

package/dist/lang/test/test-translator.js

@@ -254,6 +254,7 @@ class TestTranslator extends parse_malloy_1.MalloyTranslator {
         this.importZone.define(testURI, testSrc);
         for (const tableName in mockSchema) {
             this.schemaZone.define(tableName, mockSchema[tableName]);
+            this.schemaZone.define('conn:' + tableName, mockSchema[tableName]);
         }
     }
     translate() {

package/dist/lang/translate-response.d.ts

@@ -17,7 +17,10 @@ export interface ProblemResponse {
 }
 export declare type FatalResponse = FinalResponse & ProblemResponse;
 export interface NeedSchemaData {
-    tables: string[];
+    tables: Record<string, {
+        connectionName: string | undefined;
+        tablePath: string;
+    }>;
 }
 export interface NeedURLData {
     urls: string[];

package/dist/malloy.d.ts

@@ -231,10 +231,6 @@ export declare class PreparedQuery implements Taggable {
      */
     getFlattenedQuery(defaultName: string): PreparedQuery;
 }
-export declare function parseTableURI(tableURI: string): {
-    connectionName?: string;
-    tablePath: string;
-};
 /**
  * A parsed Malloy document.
  */

package/dist/malloy.js

@@ -22,7 +22,7 @@
  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CSVWriter = exports.JSONWriter = exports.DataWriter = exports.DataRecord = exports.DataArray = exports.Result = exports.ExploreMaterializer = exports.SQLBlockMaterializer = exports.PreparedResultMaterializer = exports.QueryMaterializer = exports.ModelMaterializer = exports.SingleConnectionRuntime = exports.ConnectionRuntime = exports.Runtime = exports.ExploreField = exports.JoinRelationship = exports.QueryField = exports.Query = exports.StringField = exports.UnsupportedField = exports.JSONField = exports.BooleanField = exports.NumberField = exports.TimestampField = exports.DateField = exports.TimestampTimeframe = exports.DateTimeframe = exports.AtomicField = exports.AtomicFieldType = exports.Explore = exports.SourceRelationship = exports.FixedConnectionMap = exports.InMemoryURLReader = exports.EmptyURLReader = exports.PreparedResult = exports.DocumentCompletion = exports.DocumentSymbol = exports.DocumentPosition = exports.DocumentRange = exports.DocumentHighlight = exports.Parse = exports.parseTableURI = exports.PreparedQuery = exports.Model = exports.MalloyError = exports.Malloy = void 0;
+exports.CSVWriter = exports.JSONWriter = exports.DataWriter = exports.DataRecord = exports.DataArray = exports.Result = exports.ExploreMaterializer = exports.SQLBlockMaterializer = exports.PreparedResultMaterializer = exports.QueryMaterializer = exports.ModelMaterializer = exports.SingleConnectionRuntime = exports.ConnectionRuntime = exports.Runtime = exports.ExploreField = exports.JoinRelationship = exports.QueryField = exports.Query = exports.StringField = exports.UnsupportedField = exports.JSONField = exports.BooleanField = exports.NumberField = exports.TimestampField = exports.DateField = exports.TimestampTimeframe = exports.DateTimeframe = exports.AtomicField = exports.AtomicFieldType = exports.Explore = exports.SourceRelationship = exports.FixedConnectionMap = exports.InMemoryURLReader = exports.EmptyURLReader = exports.PreparedResult = exports.DocumentCompletion = exports.DocumentSymbol = exports.DocumentPosition = exports.DocumentRange = exports.DocumentHighlight = exports.Parse = exports.PreparedQuery = exports.Model = exports.MalloyError = exports.Malloy = void 0;
 const lang_1 = require("./lang");
 const model_1 = require("./model");
 const luxon_1 = require("luxon");
@@ -110,25 +110,24 @@ class Malloy {
                 if (result.tables) {
                     // collect tables by connection name since there may be multiple connections
                     const tablesByConnection = new Map();
-                    for (const connectionTableString of result.tables) {
-                        const { connectionName } = parseTableURI(connectionTableString);
-                        let connectionToTablesMap = tablesByConnection.get(connectionName);
-                        if (!connectionToTablesMap) {
-                            connectionToTablesMap = [connectionTableString];
+                    for (const tableKey in result.tables) {
+                        const { connectionName, tablePath } = result.tables[tableKey];
+                        const connectionToTablesMap = tablesByConnection.get(connectionName);
+                        if (connectionToTablesMap === undefined) {
+                            tablesByConnection.set(connectionName, { [tableKey]: tablePath });
                         }
                         else {
-                            connectionToTablesMap.push(connectionTableString);
+                            connectionToTablesMap[tableKey] = tablePath;
                         }
-                        tablesByConnection.set(connectionName, connectionToTablesMap);
                     }
                     // iterate over connections, fetching schema for all missing tables
-                    for (const [connectionName, connectionTableString,] of tablesByConnection) {
+                    for (const [connectionName, tablePathByKey] of tablesByConnection) {
                         try {
                             const connection = await connections.lookupConnection(connectionName);
                             // TODO detect if the union of `Object.keys(tables)` and `Object.keys(errors)` is not the same
-                            //      as `Object.keys(connectionTableString)`, i.e. that all tables are accounted for. Otherwise
+                            //      as `Object.keys(tablePathByKey)`, i.e. that all tables are accounted for. Otherwise
                             //      the translator runs into an infinite loop fetching tables.
-                            const { schemas: tables, errors } = await connection.fetchSchemaForTables(connectionTableString);
+                            const { schemas: tables, errors } = await connection.fetchSchemaForTables(tablePathByKey);
                             translator.update({ tables, errors: { tables: errors } });
                         }
                         catch (error) {
@@ -136,8 +135,8 @@ class Malloy {
                             // with all its tables
                             const tables = {};
                             const errors = {};
-                            for (const table of connectionTableString) {
-                                errors[table] = error.toString();
+                            for (const tableKey in tablePathByKey) {
+                                errors[tableKey] = error.toString();
                             }
                             translator.update({ tables, errors: { tables: errors } });
                         }
@@ -491,17 +490,6 @@ class PreparedQuery {
     }
 }
 exports.PreparedQuery = PreparedQuery;
-function parseTableURI(tableURI) {
-    const parts = tableURI.match(/^([^:]*):(.*)$/);
-    if (parts) {
-        const [, firstPart, secondPart] = parts;
-        return { connectionName: firstPart, tablePath: secondPart };
-    }
-    else {
-        return { tablePath: tableURI };
-    }
-}
-exports.parseTableURI = parseTableURI;
 /**
  * A parsed Malloy document.
  */

package/dist/model/malloy_types.d.ts

@@ -533,6 +533,9 @@ export interface FunctionDef extends NamedObject {
     type: 'function';
     overloads: FunctionOverloadDef[];
 }
+export interface ConnectionDef extends NamedObject {
+    type: 'connection';
+}
 export interface SQLBlockStructDef extends StructDef {
     structSource: SubquerySource;
     declaredSQLBlock?: boolean;
@@ -561,7 +564,7 @@ export interface FilterExpression {
 }
 /** Get the output name for a NamedObject */
 export declare function getIdentifier(n: AliasedName): string;
-export declare type NamedModelObject = StructDef | NamedQuery | FunctionDef;
+export declare type NamedModelObject = StructDef | NamedQuery | FunctionDef | ConnectionDef;
 /** Result of parsing a model file */
 export interface ModelDef {
     name: string;