@malloydata/malloy 0.0.239-dev250226010331 → 0.0.239-dev250227145856

package/dist/api/stateless.spec.js

@@ -0,0 +1,394 @@
+"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 });
+const stateless_1 = require("./stateless");
+describe('api', () => {
+    describe('compile model', () => {
+        test('compile model with table dependency', () => {
+            const result = (0, stateless_1.compileModel)({
+                model_url: 'file://test.malloy',
+                compiler_needs: {
+                    table_schemas: [
+                        {
+                            connection_name: 'connection',
+                            name: 'flights',
+                            schema: {
+                                fields: [
+                                    {
+                                        kind: 'dimension',
+                                        name: 'carrier',
+                                        type: { kind: 'string_type' },
+                                    },
+                                ],
+                            },
+                        },
+                    ],
+                    files: [
+                        {
+                            url: 'file://test.malloy',
+                            contents: "source: flights is connection.table('flights')",
+                        },
+                    ],
+                    connections: [{ name: 'connection', dialect: 'duckdb' }],
+                },
+            });
+            const expected = {
+                model: {
+                    entries: [
+                        {
+                            kind: 'source',
+                            name: 'flights',
+                            schema: {
+                                fields: [
+                                    {
+                                        kind: 'dimension',
+                                        name: 'carrier',
+                                        type: { kind: 'string_type' },
+                                    },
+                                ],
+                            },
+                        },
+                    ],
+                    anonymous_queries: [],
+                },
+            };
+            expect(result).toMatchObject(expected);
+        });
+        test('compile model with model extension', () => {
+            const result = (0, stateless_1.compileModel)({
+                model_url: 'file://test.malloy',
+                extend_model_url: 'file://base.malloy',
+                compiler_needs: {
+                    table_schemas: [
+                        {
+                            connection_name: 'connection',
+                            name: 'flights',
+                            schema: {
+                                fields: [
+                                    {
+                                        kind: 'dimension',
+                                        name: 'carrier',
+                                        type: { kind: 'string_type' },
+                                    },
+                                ],
+                            },
+                        },
+                    ],
+                    files: [
+                        {
+                            url: 'file://base.malloy',
+                            contents: "source: flights_base is connection.table('flights')",
+                        },
+                        {
+                            url: 'file://test.malloy',
+                            contents: 'source: flights is flights_base',
+                        },
+                    ],
+                    connections: [{ name: 'connection', dialect: 'duckdb' }],
+                },
+            });
+            const expected = {
+                model: {
+                    entries: [
+                        {
+                            kind: 'source',
+                            name: 'flights_base',
+                            schema: {
+                                fields: [
+                                    {
+                                        kind: 'dimension',
+                                        name: 'carrier',
+                                        type: { kind: 'string_type' },
+                                    },
+                                ],
+                            },
+                        },
+                        {
+                            kind: 'source',
+                            name: 'flights',
+                            schema: {
+                                fields: [
+                                    {
+                                        kind: 'dimension',
+                                        name: 'carrier',
+                                        type: { kind: 'string_type' },
+                                    },
+                                ],
+                            },
+                        },
+                    ],
+                    anonymous_queries: [],
+                },
+            };
+            expect(result).toMatchObject(expected);
+        });
+        test('compile model with sql dependency', () => {
+            const result = (0, stateless_1.compileModel)({
+                model_url: 'file://test.malloy',
+                compiler_needs: {
+                    sql_schemas: [
+                        {
+                            connection_name: 'connection',
+                            sql: 'SELECT 1 as one',
+                            schema: {
+                                fields: [
+                                    {
+                                        kind: 'dimension',
+                                        name: 'one',
+                                        type: { kind: 'number_type' },
+                                    },
+                                ],
+                            },
+                        },
+                    ],
+                    files: [
+                        {
+                            url: 'file://test.malloy',
+                            contents: "source: flights is connection.sql('SELECT 1 as one')",
+                        },
+                    ],
+                    connections: [{ name: 'connection', dialect: 'duckdb' }],
+                },
+            });
+            const expected = {
+                model: {
+                    entries: [
+                        {
+                            kind: 'source',
+                            name: 'flights',
+                            schema: {
+                                fields: [
+                                    {
+                                        kind: 'dimension',
+                                        name: 'one',
+                                        type: { kind: 'number_type' },
+                                    },
+                                ],
+                            },
+                        },
+                    ],
+                    anonymous_queries: [],
+                },
+            };
+            expect(result).toMatchObject(expected);
+        });
+    });
+    test('compile model with turducken sql dependency', () => {
+        const sql = '\n                SELECT carrier FROM (SELECT \n   base."carrier" as "carrier"\nFROM flights as base\nGROUP BY 1\nORDER BY 1 asc NULLS LAST\n)\n              ';
+        const result = (0, stateless_1.compileModel)({
+            model_url: 'file://test.malloy',
+            compiler_needs: {
+                table_schemas: [
+                    {
+                        connection_name: 'connection',
+                        name: 'flights',
+                        schema: {
+                            fields: [
+                                {
+                                    kind: 'dimension',
+                                    name: 'carrier',
+                                    type: { kind: 'string_type' },
+                                },
+                            ],
+                        },
+                    },
+                ],
+                sql_schemas: [
+                    {
+                        connection_name: 'connection',
+                        sql,
+                        schema: {
+                            fields: [
+                                {
+                                    kind: 'dimension',
+                                    name: 'carrier',
+                                    type: { kind: 'string_type' },
+                                },
+                            ],
+                        },
+                    },
+                ],
+                files: [
+                    {
+                        url: 'file://test.malloy',
+                        contents: `
+              source: flights is connection.table('flights')
+              source: sql_source is connection.sql("""
+                SELECT carrier FROM (%{
+                  flights -> { group_by: carrier }
+                })
+              """)
+            `,
+                    },
+                ],
+                connections: [{ name: 'connection', dialect: 'duckdb' }],
+            },
+        });
+        const expected = {
+            model: {
+                entries: [
+                    {
+                        kind: 'source',
+                        name: 'flights',
+                        schema: {
+                            fields: [
+                                {
+                                    kind: 'dimension',
+                                    name: 'carrier',
+                                    type: { kind: 'string_type' },
+                                },
+                            ],
+                        },
+                    },
+                    {
+                        kind: 'source',
+                        name: 'sql_source',
+                        schema: {
+                            fields: [
+                                {
+                                    kind: 'dimension',
+                                    name: 'carrier',
+                                    type: { kind: 'string_type' },
+                                },
+                            ],
+                        },
+                    },
+                ],
+                anonymous_queries: [],
+            },
+        };
+        expect(result).toMatchObject(expected);
+    });
+    describe('compile query', () => {
+        test('compile query with table dependency', () => {
+            const result = (0, stateless_1.compileQuery)({
+                model_url: 'file://test.malloy',
+                query: {
+                    definition: {
+                        kind: 'arrow',
+                        source_reference: { name: 'flights' },
+                        view: {
+                            kind: 'segment',
+                            operations: [
+                                {
+                                    kind: 'group_by',
+                                    field: {
+                                        expression: { kind: 'field_reference', name: 'carrier' },
+                                    },
+                                },
+                            ],
+                        },
+                    },
+                },
+                compiler_needs: {
+                    table_schemas: [
+                        {
+                            connection_name: 'connection',
+                            name: 'flights',
+                            schema: {
+                                fields: [
+                                    {
+                                        kind: 'dimension',
+                                        name: 'carrier',
+                                        type: { kind: 'string_type' },
+                                    },
+                                ],
+                            },
+                        },
+                    ],
+                    files: [
+                        {
+                            url: 'file://test.malloy',
+                            contents: "source: flights is connection.table('flights')",
+                        },
+                    ],
+                    connections: [{ name: 'connection', dialect: 'duckdb' }],
+                },
+            });
+            const expected = {
+                result: {
+                    connection_name: 'connection',
+                    sql: `SELECT \n\
+   base."carrier" as "carrier"
+FROM flights as base
+GROUP BY 1
+ORDER BY 1 asc NULLS LAST
+`,
+                    schema: {
+                        fields: [
+                            {
+                                kind: 'dimension',
+                                name: 'carrier',
+                                type: { kind: 'string_type' },
+                            },
+                        ],
+                    },
+                },
+            };
+            expect(result).toMatchObject(expected);
+        });
+    });
+    describe('compiler errors', () => {
+        test('parse error should come back as a log', () => {
+            const result = (0, stateless_1.compileModel)({
+                model_url: 'file://test.malloy',
+                compiler_needs: {
+                    files: [
+                        {
+                            url: 'file://test.malloy',
+                            contents: 'run: flights -> { group_by: carrier }',
+                        },
+                    ],
+                },
+            });
+            const expected = {
+                logs: [
+                    {
+                        url: 'file://test.malloy',
+                        severity: 'error',
+                        message: "Reference to undefined object 'flights'",
+                        range: {
+                            start: { line: 0, character: 5 },
+                            end: { line: 0, character: 12 },
+                        },
+                    },
+                ],
+            };
+            expect(result).toMatchObject(expected);
+        });
+        test('missing source should come back as a log', () => {
+            const result = (0, stateless_1.compileSource)({
+                model_url: 'file://test.malloy',
+                name: 'flights',
+                compiler_needs: {
+                    files: [
+                        {
+                            url: 'file://test.malloy',
+                            contents: '// nothing to see here',
+                        },
+                    ],
+                },
+            });
+            const expected = {
+                logs: [
+                    {
+                        url: 'file://test.malloy',
+                        severity: 'error',
+                        message: 'Model does not contain a source named flights',
+                        range: {
+                            start: { line: 0, character: 0 },
+                            end: { line: 0, character: 0 },
+                        },
+                    },
+                ],
+            };
+            expect(result).toMatchObject(expected);
+        });
+    });
+});
+//# sourceMappingURL=stateless.spec.js.map

package/dist/connection/base_connection.d.ts

@@ -1,3 +1,4 @@
+import { SQLSourceRequest } from '../lang/translate-response';
 import { MalloyQueryData, QueryRunStats, SQLSourceDef, StructDef, TableSourceDef } from '../model/malloy_types';
 import { RunSQLOptions } from '../run_sql_options';
 import { Connection, FetchSchemaOptions, PersistSQLResults, PooledConnection, StreamingConnection } from './types';
@@ -16,14 +17,14 @@ export declare abstract class BaseConnection implements Connection {
     abstract get name(): string;
     abstract get dialectName(): string;
     abstract fetchTableSchema(tableName: string, tablePath: string): Promise<TableSourceDef | string>;
-    abstract fetchSelectSchema(sqlSource: SQLSourceDef): Promise<SQLSourceDef | string>;
+    abstract fetchSelectSchema(sqlSource: SQLSourceRequest): Promise<SQLSourceDef | string>;
     protected schemaCache: Record<string, CachedSchema<StructDef>>;
     protected checkSchemaCache<T extends StructDef>(schemaKey: string, schemaType: 'table' | 'sql_select', fillCache: () => Promise<T | string>, refreshTimestamp: number | undefined): Promise<CachedSchema<T>>;
     fetchSchemaForTables(missing: Record<string, string>, { refreshTimestamp }: FetchSchemaOptions): Promise<{
         schemas: Record<string, TableSourceDef>;
         errors: Record<string, string>;
     }>;
-    fetchSchemaForSQLStruct(sqlRef: SQLSourceDef, { refreshTimestamp }: FetchSchemaOptions): Promise<{
+    fetchSchemaForSQLStruct(sqlRef: SQLSourceRequest, { refreshTimestamp }: FetchSchemaOptions): Promise<{
         structDef: SQLSourceDef;
         error?: undefined;
     } | {

package/dist/connection/base_connection.js

@@ -7,6 +7,7 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BaseConnection = void 0;
+const sql_block_1 = require("../model/sql_block");
 class BaseConnection {
     constructor() {
         this.schemaCache = {};
@@ -55,7 +56,8 @@ class BaseConnection {
         return { schemas, errors };
     }
     async fetchSchemaForSQLStruct(sqlRef, { refreshTimestamp }) {
-        const inCache = await this.checkSchemaCache(sqlRef.name, 'sql_select', async () => await this.fetchSelectSchema(sqlRef), refreshTimestamp);
+        const key = (0, sql_block_1.sqlKey)(sqlRef.connection, sqlRef.selectStr);
+        const inCache = await this.checkSchemaCache(key, 'sql_select', async () => await this.fetchSelectSchema(sqlRef), refreshTimestamp);
         if (inCache.schema) {
             return { structDef: inCache.schema };
         }

package/dist/connection/types.d.ts

@@ -1,6 +1,7 @@
 import { RunSQLOptions } from '../run_sql_options';
 import { Annotation, MalloyQueryData, QueryDataRow, QueryRunStats, SQLSourceDef, TableSourceDef } from '../model/malloy_types';
 import { Dialect } from '../dialect';
+import { SQLSourceRequest } from '../lang/translate-response';
 /**
  * Options passed to fetchSchema methods.
  */
@@ -29,7 +30,7 @@ export interface InfoConnection {
      * @param block The SQL blocks to fetch schemas for.
      * @return A mapping of SQL block names to schemas.
      */
-    fetchSchemaForSQLStruct(sentence: SQLSourceDef, options: FetchSchemaOptions): Promise<{
+    fetchSchemaForSQLStruct(sentence: SQLSourceRequest, options: FetchSchemaOptions): Promise<{
         structDef: SQLSourceDef;
         error?: undefined;
     } | {

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 export { DuckDBDialect, StandardSQLDialect, TrinoDialect, PostgresDialect, SnowflakeDialect, MySQLDialect, registerDialect, arg, qtz, overload, minScalar, anyExprType, minAggregate, maxScalar, sql, makeParam, param, variadicParam, literal, spread, Dialect, TinyParser, } from './dialect';
 export type { DialectFieldList, DialectFunctionOverloadDef, QueryInfo, MalloyStandardFunctionImplementations, DefinitionBlueprint, DefinitionBlueprintMap, OverloadedDefinitionBlueprint, TinyToken, } from './dialect';
-export type { QueryDataRow, StructDef, TableSourceDef, SQLSourceDef, SourceDef, JoinFieldDef, NamedSourceDefs, MalloyQueryData, DateUnit, ExtractUnit, TimestampUnit, TemporalFieldType, QueryData, QueryValue, Expr, FilterCondition, SQLSentence, Argument, Parameter, FieldDef, PipeSegment, QueryFieldDef, IndexFieldDef, TurtleDef, SearchValueMapResult, SearchIndexResult, ModelDef, Query, QueryResult, QueryRunStats, NamedQuery, NamedModelObject, ExpressionType, FunctionDef, FunctionOverloadDef, FunctionParameterDef, ExpressionValueType, TypeDesc, FunctionParamTypeDesc, DocumentLocation, DocumentRange, DocumentPosition, Sampling, Annotation, LeafAtomicTypeDef, LeafAtomicDef, AtomicTypeDef, AtomicFieldDef, ArrayDef, ArrayTypeDef, RecordTypeDef, RepeatedRecordTypeDef, RecordDef, RepeatedRecordDef, RecordLiteralNode, ArrayLiteralNode, } from './model';
+export type { QueryDataRow, StructDef, TableSourceDef, SQLSourceDef, SourceDef, JoinFieldDef, NamedSourceDefs, MalloyQueryData, DateUnit, ExtractUnit, TimestampUnit, TemporalFieldType, QueryData, QueryValue, Expr, FilterCondition, Argument, Parameter, FieldDef, PipeSegment, QueryFieldDef, IndexFieldDef, TurtleDef, SearchValueMapResult, SearchIndexResult, ModelDef, Query, QueryResult, QueryRunStats, NamedQuery, NamedModelObject, ExpressionType, FunctionDef, FunctionOverloadDef, FunctionParameterDef, ExpressionValueType, TypeDesc, FunctionParamTypeDesc, DocumentLocation, DocumentRange, DocumentPosition, Sampling, Annotation, LeafAtomicTypeDef, LeafAtomicDef, AtomicTypeDef, AtomicFieldDef, ArrayDef, ArrayTypeDef, RecordTypeDef, RepeatedRecordTypeDef, RecordDef, RepeatedRecordDef, RecordLiteralNode, ArrayLiteralNode, } from './model';
 export { isSourceDef, Segment, isLeafAtomic, isJoined, isJoinedSource, isSamplingEnable, isSamplingPercent, isSamplingRows, isRepeatedRecord, isScalarArray, mkArrayDef, mkFieldDef, expressionIsAggregate, expressionIsAnalytic, expressionIsCalculation, expressionIsScalar, expressionIsUngroupedAggregate, indent, composeSQLExpr, } from './model';
 export { MalloyTranslator, } from './lang';
 export type { LogMessage, TranslateResponse } from './lang';
@@ -11,4 +11,7 @@ export type { EventStream, ModelString, ModelURL, QueryString, QueryURL, URLRead
 export type { Connection, ConnectionConfig, ConnectionFactory, ConnectionParameter, ConnectionParameterValue, ConnectionConfigSchema, FetchSchemaOptions, InfoConnection, LookupConnection, PersistSQLResults, PooledConnection, TestableConnection, StreamingConnection, } from './connection/types';
 export { toAsyncGenerator } from './connection_utils';
 export { modelDefToModelInfo } from './to_stable';
-export { annotationToTag } from './annotation';
+export * as API from './api';
+export type { SQLSourceRequest } from './lang/translate-response';
+export { sqlKey } from './model/sql_block';
+export { annotationToTag, annotationToTaglines } from './annotation';

package/dist/index.js

@@ -1,7 +1,30 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.InMemoryURLReader = exports.EmptyURLReader = exports.SingleConnectionRuntime = exports.ConnectionRuntime = exports.AtomicFieldType = exports.Runtime = exports.Malloy = exports.Model = exports.MalloyTranslator = exports.composeSQLExpr = exports.indent = exports.expressionIsUngroupedAggregate = exports.expressionIsScalar = exports.expressionIsCalculation = exports.expressionIsAnalytic = exports.expressionIsAggregate = exports.mkFieldDef = exports.mkArrayDef = exports.isScalarArray = exports.isRepeatedRecord = exports.isSamplingRows = exports.isSamplingPercent = exports.isSamplingEnable = exports.isJoinedSource = exports.isJoined = exports.isLeafAtomic = exports.Segment = exports.isSourceDef = exports.TinyParser = exports.Dialect = exports.spread = exports.literal = exports.variadicParam = exports.param = exports.makeParam = exports.sql = exports.maxScalar = exports.minAggregate = exports.anyExprType = exports.minScalar = exports.overload = exports.qtz = exports.arg = exports.registerDialect = exports.MySQLDialect = exports.SnowflakeDialect = exports.PostgresDialect = exports.TrinoDialect = exports.StandardSQLDialect = exports.DuckDBDialect = void 0;
-exports.annotationToTag = exports.modelDefToModelInfo = exports.toAsyncGenerator = exports.CacheManager = exports.InMemoryModelCache = exports.Explore = exports.DataWriter = exports.Parse = exports.JSONWriter = exports.CSVWriter = exports.QueryMaterializer = exports.Result = exports.PreparedResult = exports.TimestampTimeframe = exports.DateTimeframe = exports.SourceRelationship = exports.JoinRelationship = exports.MalloyError = exports.FixedConnectionMap = void 0;
+exports.annotationToTaglines = exports.annotationToTag = exports.sqlKey = exports.API = exports.modelDefToModelInfo = exports.toAsyncGenerator = exports.CacheManager = exports.InMemoryModelCache = exports.Explore = exports.DataWriter = exports.Parse = exports.JSONWriter = exports.CSVWriter = exports.QueryMaterializer = exports.Result = exports.PreparedResult = exports.TimestampTimeframe = exports.DateTimeframe = exports.SourceRelationship = exports.JoinRelationship = exports.MalloyError = exports.FixedConnectionMap = void 0;
 /*
  * Copyright 2023 Google LLC
  *
@@ -100,6 +123,10 @@ var connection_utils_1 = require("./connection_utils");
 Object.defineProperty(exports, "toAsyncGenerator", { enumerable: true, get: function () { return connection_utils_1.toAsyncGenerator; } });
 var to_stable_1 = require("./to_stable");
 Object.defineProperty(exports, "modelDefToModelInfo", { enumerable: true, get: function () { return to_stable_1.modelDefToModelInfo; } });
+exports.API = __importStar(require("./api"));
+var sql_block_1 = require("./model/sql_block");
+Object.defineProperty(exports, "sqlKey", { enumerable: true, get: function () { return sql_block_1.sqlKey; } });
 var annotation_1 = require("./annotation");
 Object.defineProperty(exports, "annotationToTag", { enumerable: true, get: function () { return annotation_1.annotationToTag; } });
+Object.defineProperty(exports, "annotationToTaglines", { enumerable: true, get: function () { return annotation_1.annotationToTaglines; } });
 //# sourceMappingURL=index.js.map

package/dist/lang/ast/source-elements/sql-source.d.ts

@@ -1,5 +1,5 @@
-import { SQLSentence, InvokedStructRef, SourceDef } from '../../../model/malloy_types';
-import { NeedCompileSQL } from '../../translate-response';
+import { InvokedStructRef, SourceDef } from '../../../model/malloy_types';
+import { NeedCompileSQL, SQLSourceRequest } from '../../translate-response';
 import { Source } from './source';
 import { SQLString } from '../sql-elements/sql-string';
 import { ModelEntryReference, Document } from '../types/malloy-element';
@@ -7,10 +7,10 @@ export declare class SQLSource extends Source {
     readonly connectionName: ModelEntryReference;
     readonly select: SQLString;
     elementType: string;
-    requestBlock?: SQLSentence;
+    requestBlock?: SQLSourceRequest;
     private connectionNameInvalid;
     constructor(connectionName: ModelEntryReference, select: SQLString);
-    sqlSentence(): SQLSentence;
+    sqlSourceRequest(doc: Document): SQLSourceRequest;
     structRef(): InvokedStructRef;
     validateConnectionName(): boolean;
     needs(doc: Document): NeedCompileSQL | undefined;

package/dist/lang/ast/source-elements/sql-source.js

@@ -34,11 +34,11 @@ class SQLSource extends source_1.Source {
         this.elementType = 'sqlSource';
         this.connectionNameInvalid = false;
     }
-    sqlSentence() {
-        if (!this.requestBlock) {
-            this.requestBlock = (0, sql_block_1.makeSQLSentence)(this.select.sqlPhrases(), this.connectionName.refString);
-        }
-        return this.requestBlock;
+    sqlSourceRequest(doc) {
+        const partialModel = this.select.containsQueries
+            ? doc.modelDef()
+            : undefined;
+        return (0, sql_block_1.compileSQLInterpolation)(this.select.sqlPhrases(), this.connectionName.refString, partialModel);
     }
     structRef() {
         return {
@@ -69,18 +69,21 @@ class SQLSource extends source_1.Source {
         const childNeeds = super.needs(doc);
         if (childNeeds)
             return childNeeds;
-        const sql = this.sqlSentence();
+        if (this.requestBlock === undefined) {
+            this.requestBlock = this.sqlSourceRequest(doc);
+        }
+        const sql = this.requestBlock;
         const sqlDefEntry = (_a = this.translator()) === null || _a === void 0 ? void 0 : _a.root.sqlQueryZone;
         if (!sqlDefEntry) {
             this.logError('failed-to-fetch-sql-source-schema', "Cant't look up schema for sql block");
             return;
         }
-        sqlDefEntry.reference(sql.name, this.location);
-        const lookup = sqlDefEntry.getEntry(sql.name);
+        const key = (0, sql_block_1.sqlKey)(sql.connection, sql.selectStr);
+        sqlDefEntry.reference(key, this.location);
+        const lookup = sqlDefEntry.getEntry(key);
         if (lookup.status === 'reference') {
             return {
                 compileSQL: sql,
-                partialModel: this.select.containsQueries ? doc.modelDef() : undefined,
             };
         }
         else if (lookup.status === 'present') {
@@ -97,9 +100,14 @@ class SQLSource extends source_1.Source {
             this.logError('failed-to-fetch-sql-source-schema', "Cant't look up schema for sql block");
             return error_factory_1.ErrorFactory.structDef;
         }
-        const sql = this.sqlSentence();
-        sqlDefEntry.reference(sql.name, this.location);
-        const lookup = sqlDefEntry.getEntry(sql.name);
+        if (this.requestBlock === undefined) {
+            this.logError('failed-to-fetch-sql-source-schema', 'Expected to have already compiled the sql block');
+            return error_factory_1.ErrorFactory.structDef;
+        }
+        const sql = this.requestBlock;
+        const key = (0, sql_block_1.sqlKey)(sql.connection, sql.selectStr);
+        sqlDefEntry.reference(key, this.location);
+        const lookup = sqlDefEntry.getEntry(key);
         if (lookup.status === 'error') {
             const msgLines = lookup.message.split(/\r?\n/);
             this.select.logError('invalid-sql-source', 'Invalid SQL, ' + msgLines.join('\n    '));

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

@@ -231,7 +231,7 @@ export declare class MalloyToAST extends AbstractParseTreeVisitor<ast.MalloyElem
     visitSegRefine(pcx: parse.SegRefineContext): ast.ViewRefine;
     visitVArrow(pcx: parse.VArrowContext): ast.ViewArrow;
     visitSQRefinedQuery(pcx: parse.SQRefinedQueryContext): ast.SQRefine;
-    visitSQTable(pcx: parse.SQTableContext): ast.SQSource | ErrorNode;
+    visitSQTable(pcx: parse.SQTableContext): ErrorNode | ast.SQSource;
     visitSQSQL(pcx: parse.SQSQLContext): ast.SQSource;
     visitExperimentalStatementForTesting(pcx: parse.ExperimentalStatementForTestingContext): ast.ExperimentalExperiment;
     visitRecordRef(pcx: parse.RecordRefContext): ast.RecordElement;

package/dist/lang/parse-malloy.js

@@ -716,7 +716,6 @@ class MalloyTranslation {
         if (ret === null || ret === void 0 ? void 0 : ret.compileSQL) {
             return {
                 compileSQL: ret.compileSQL,
-                partialModel: ret.partialModel,
             };
         }
     }

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

@@ -116,7 +116,7 @@ describe('source locations', () => {
         expect(compileSql).toBeDefined();
         if (compileSql) {
             m.update({
-                compileSQL: { [compileSql.name]: (0, test_translator_1.getSelectOneStruct)(compileSql) },
+                compileSQL: (0, test_translator_1.getSelectOneStruct)(compileSql),
             });
             expect(m).toTranslate();
             const na = (0, test_translator_1.getExplore)(m.modelDef, 'na');

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

@@ -57,7 +57,7 @@ function prettyNeeds(response) {
         }
     }
     if (response.compileSQL) {
-        needString += `Compile SQL: ${response.compileSQL.name}`;
+        needString += `Compile SQL: ${response.compileSQL.selectStr}`;
     }
     if (response.urls) {
         needString += 'URLs:\n';