@malloydata/malloy 0.0.1 → 0.0.3

package/README.md

@@ -9,17 +9,16 @@ This package facilitates building the Malloy language - or the usage of data mod
 ## Show me an example!
 
 ```
-import { Runtime } from "@malloydata/malloy";
-import { DuckDBConnection } from "@malloydata/db-duckdb";
-
-const connection = new DuckDBConnection("duckdb-example");
-const runtime = new Runtime(files, connection);
-
-runtime.loadModel("source: flights is table('duckdb:data/flights.parquet')")
-
-const runner = runtime.loadQuery("query: flights->{group_by: flight_num}")
-runner.run() // <- executes query, returns JSON of results
-
+const malloy = require("@malloydata/malloy")
+const bigquery = require("@malloydata/db-bigquery")
+
+const connection = new bigquery.BigQueryConnection("bigquery");
+const runtime = new malloy.SingleConnectionRuntime(connection);
+const model = runtime.loadModel("source: airports is table('malloytest.airports')")
+const runner = model.loadQuery("query: airports->{aggregate: airport_count is count()}")
+runner.run().then((result) => {
+    console.log(result.data.value) // [ { airport_count: 19793 } ]
+})
 ```
 
 Note: These APIs are still in beta and subject to change.
@@ -37,3 +36,5 @@ In practice, much of this loop is handled by various database plugins:
 ## Do you have any examples?
 
 You can find a (very) simple example of writing a CLI for executing Malloy queries [here](https://github.com/looker-open-source/malloy/tree/main/demo/malloy-demo-bq-cli)
+
+A more realistic and complex use case - we use these libraries to power our VSCode Extension. Some examples can be found [here](https://github.com/looker-open-source/malloy/tree/main/vscode-extension/src/extension/commands)

package/dist/dialect/dialect.d.ts

@@ -1,5 +1,5 @@
 import { AtomicFieldTypeInner, TimeFieldType, TimestampUnit, ExtractUnit, DialectFragment, TimeValue } from "..";
-import { Expr, Sampling, StructDef, TypecastFragment } from "../model";
+import { Expr, Sampling, StructDef, TypecastFragment } from "../model/malloy_types";
 interface DialectField {
     type: string;
     sqlExpression: string;

package/dist/dialect/dialect.js

@@ -13,6 +13,11 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Dialect = void 0;
+// Can't get these from "../model" because model includes this file
+// and that can create a circular reference problem. This is a patch
+// and really indicates a problem in the relationship between
+// dialect and model, it's going to come up again some time.
+const malloy_types_1 = require("../model/malloy_types");
 class Dialect {
     sqlFinalStage(_lastStageName, _fields) {
         throw new Error("Dialect has no final Stage but called Anyway");
@@ -45,6 +50,14 @@ class Dialect {
                 return this.sqlCast(df);
             case "regexpMatch":
                 return this.sqlRegexpMatch(df.expr, df.regexp);
+            case "div": {
+                if (this.divisionIsInteger) {
+                    return (0, malloy_types_1.mkExpr) `${df.numerator}*1.0/${df.denominator}`;
+                }
+                return (0, malloy_types_1.mkExpr) `${df.numerator}/${df.denominator}`;
+            }
+            case "timeLiteral":
+                return [this.sqlLiteralTime(df.literal, df.literalType, df.timezone)];
         }
     }
     sqlSumDistinct(_key, _value) {

package/dist/dialect/duckdb.d.ts

@@ -34,7 +34,7 @@ export declare class DuckDBDialect extends Dialect {
     sqlSelectAliasAsStruct(alias: string, physicalFieldNames: string[]): string;
     sqlMaybeQuoteIdentifier(identifier: string): string;
     sqlCreateTableAsSelect(_tableName: string, _sql: string): string;
-    getFunctionInfo(_functionName: string): FunctionInfo | undefined;
+    getFunctionInfo(functionName: string): FunctionInfo | undefined;
     sqlMeasureTime(from: TimeValue, to: TimeValue, units: string): Expr;
     sqlNow(): Expr;
     sqlTrunc(sqlTime: TimeValue, units: TimestampUnit): Expr;

package/dist/dialect/duckdb.js

@@ -109,8 +109,6 @@ const inSeconds = {
     second: 1,
     minute: 60,
     hour: 3600,
-    day: 86400,
-    week: 604800,
 };
 class DuckDBDialect extends dialect_1.Dialect {
     constructor() {
@@ -125,7 +123,9 @@ class DuckDBDialect extends dialect_1.Dialect {
         this.defaultSampling = { rows: 50000 };
         this.supportUnnestArrayAgg = true;
         this.supportsCTEinCoorelatedSubQueries = true;
-        this.functionInfo = {};
+        this.functionInfo = {
+            concat: { returnType: "string" },
+        };
     }
     // hack until they support temporary macros.
     get udfPrefix() {
@@ -230,8 +230,8 @@ class DuckDBDialect extends dialect_1.Dialect {
     sqlCreateTableAsSelect(_tableName, _sql) {
         throw new Error("Not implemented Yet");
     }
-    getFunctionInfo(_functionName) {
-        return undefined;
+    getFunctionInfo(functionName) {
+        return this.functionInfo[functionName];
     }
     sqlMeasureTime(from, to, units) {
         let lVal = from.value;
@@ -242,21 +242,20 @@ class DuckDBDialect extends dialect_1.Dialect {
             const duration = (0, model_1.mkExpr) `(${rVal} - ${lVal})`;
             return units == "second"
                 ? duration
-                : (0, model_1.mkExpr) `TRUNC(${duration}/${inSeconds[units].toString()})`;
+                : (0, model_1.mkExpr) `FLOOR(${duration}/${inSeconds[units].toString()})`;
         }
-        const yearDiff = (0, model_1.mkExpr) `TRUNC(EXTRACT(YEAR FROM ${rVal}) - EXTRACT(YEAR FROM ${lVal}))`;
-        if (units == "year") {
-            return yearDiff;
+        if (from.valueType != "date") {
+            lVal = (0, model_1.mkExpr) `CAST((${lVal}) AS DATE)`;
         }
-        if (units == "month") {
-            const monthDiff = (0, model_1.mkExpr) `TRUNC(EXTRACT(MONTH FROM ${rVal}) - EXTRACT(MONTH FROM ${lVal}))`;
-            return (0, model_1.mkExpr) `${yearDiff} * 12 + ${monthDiff}`;
+        if (to.valueType != "date") {
+            rVal = (0, model_1.mkExpr) `CAST((${rVal}) AS DATE)`;
         }
-        if (units == "quarter") {
-            const qDiff = (0, model_1.mkExpr) `TRUNC(EXTRACT(QUARTER FROM ${rVal}) - EXTRACT(QUARTER FROM ${lVal}))`;
-            return (0, model_1.mkExpr) `${yearDiff} * 4 + ${qDiff}`;
+        if (units == "week") {
+            // DuckDB's weeks start on Monday, but Malloy's weeks start on Sunday
+            lVal = (0, model_1.mkExpr) `(${lVal} + INTERVAL 1 DAY)`;
+            rVal = (0, model_1.mkExpr) `(${rVal} + INTERVAL 1 DAY)`;
         }
-        throw new Error(`Unknown or unhandled postgres time unit: ${units}`);
+        return (0, model_1.mkExpr) `DATE_DIFF('${units}', ${lVal}, ${rVal})`;
     }
     sqlNow() {
         return (0, model_1.mkExpr) `CURRENT_TIMESTAMP`;
@@ -265,10 +264,10 @@ class DuckDBDialect extends dialect_1.Dialect {
         // adjusting for monday/sunday weeks
         const week = units == "week";
         const truncThis = week
-            ? (0, model_1.mkExpr) `${sqlTime.value}+interval'1'day`
+            ? (0, model_1.mkExpr) `${sqlTime.value} + INTERVAL 1 DAY`
             : sqlTime.value;
         const trunced = (0, model_1.mkExpr) `DATE_TRUNC('${units}', ${truncThis})`;
-        return week ? (0, model_1.mkExpr) `(${trunced}-interval'1'day)` : trunced;
+        return week ? (0, model_1.mkExpr) `(${trunced} - INTERVAL 1 DAY)` : trunced;
     }
     sqlExtract(from, units) {
         const pgUnits = pgExtractionMap[units] || units;
@@ -284,8 +283,8 @@ class DuckDBDialect extends dialect_1.Dialect {
             timeframe = "day";
             n = (0, model_1.mkExpr) `${n}*7`;
         }
-        const interval = (0, model_1.mkExpr) `INTERVAL ${n} ${timeframe}`;
-        return (0, model_1.mkExpr) `((${expr.value})${op}${interval})`;
+        const interval = (0, model_1.mkExpr) `INTERVAL (${n}) ${timeframe}`;
+        return (0, model_1.mkExpr) `((${expr.value})) ${op} ${interval}`;
     }
     sqlCast(cast) {
         if (cast.dstType !== cast.srcType) {
@@ -299,7 +298,7 @@ class DuckDBDialect extends dialect_1.Dialect {
     }
     sqlLiteralTime(timeString, type, _timezone) {
         if (type == "date") {
-            return `DATE('${timeString}')`;
+            return `DATE '${timeString}'`;
         }
         else if (type == "timestamp") {
             return `TIMESTAMP '${timeString}'`;
@@ -308,24 +307,23 @@ class DuckDBDialect extends dialect_1.Dialect {
             throw new Error(`Unknown Literal time format ${type}`);
         }
     }
-    // sqlSumDistinct(key: string, value: string): string {
-    //   // return `sum_distinct(list({key:${key}, val: ${value}}))`;
-    //   return `(
-    //     fail -- force the query for fail until the bug is fixed.
-    //     SELECT sum(a.val) as value
-    //     FROM (
-    //       SELECT UNNEST(list(distinct {key:${key}, val: ${value}})) a
-    //     )
-    //   )`;
-    // }
     sqlSumDistinct(key, value) {
-        const _factor = 32;
-        const precision = 0.000001;
-        const keySQL = `md5_number_lower(${key}::varchar)::int128`;
-        return `
-    (SUM(DISTINCT ${keySQL} + FLOOR(IFNULL(${value},0)/${precision})::int128) -  SUM(DISTINCT ${keySQL}))*${precision}
-    `;
+        // return `sum_distinct(list({key:${key}, val: ${value}}))`;
+        return `(
+      SELECT sum(a.val) as value
+      FROM (
+        SELECT UNNEST(list(distinct {key:${key}, val: ${value}})) a
+      )
+    )`;
     }
+    // sqlSumDistinct(key: string, value: string): string {
+    //   const _factor = 32;
+    //   const precision = 0.000001;
+    //   const keySQL = `md5_number_lower(${key}::varchar)::int128`;
+    //   return `
+    //   (SUM(DISTINCT ${keySQL} + FLOOR(IFNULL(${value},0)/${precision})::int128) -  SUM(DISTINCT ${keySQL}))*${precision}
+    //   `;
+    // }
     // default duckdb to sampling 50K rows.
     sqlSampleTable(tableSQL, sample) {
         if (sample !== undefined) {

package/dist/dialect/postgres.d.ts

@@ -41,7 +41,7 @@ export declare class PostgresDialect extends Dialect {
     sqlCast(cast: TypecastFragment): Expr;
     sqlRegexpMatch(expr: Expr, regexp: string): Expr;
     sqlLiteralTime(timeString: string, type: TimeFieldType, _timezone: string): string;
-    getFunctionInfo(_functionName: string): FunctionInfo | undefined;
+    getFunctionInfo(functionName: string): FunctionInfo | undefined;
     sqlMeasureTime(from: TimeValue, to: TimeValue, units: string): Expr;
     sqlSumDistinct(key: string, value: string): string;
     sqlSampleTable(tableSQL: string, sample: Sampling | undefined): string;

package/dist/dialect/postgres.js

@@ -37,8 +37,6 @@ const inSeconds = {
     second: 1,
     minute: 60,
     hour: 3600,
-    day: 86400,
-    week: 604800,
 };
 class PostgresDialect extends dialect_1.Dialect {
     constructor() {
@@ -54,7 +52,9 @@ class PostgresDialect extends dialect_1.Dialect {
         this.defaultSampling = { rows: 50000 };
         this.supportUnnestArrayAgg = true;
         this.supportsCTEinCoorelatedSubQueries = true;
-        this.functionInfo = {};
+        this.functionInfo = {
+            concat: { returnType: "string" },
+        };
     }
     quoteTablePath(tablePath) {
         return tablePath
@@ -249,8 +249,8 @@ class PostgresDialect extends dialect_1.Dialect {
             throw new Error(`Unknown Literal time format ${type}`);
         }
     }
-    getFunctionInfo(_functionName) {
-        return undefined;
+    getFunctionInfo(functionName) {
+        return this.functionInfo[functionName];
     }
     sqlMeasureTime(from, to, units) {
         let lVal = from.value;
@@ -263,16 +263,23 @@ class PostgresDialect extends dialect_1.Dialect {
                 ? duration
                 : (0, model_1.mkExpr) `TRUNC(${duration}/${inSeconds[units].toString()})`;
         }
-        const yearDiff = (0, model_1.mkExpr) `TRUNC(EXTRACT(YEAR FROM ${rVal}) - EXTRACT(YEAR FROM ${lVal}))`;
+        if (units === "day") {
+            return (0, model_1.mkExpr) `${rVal}::date - ${lVal}::date`;
+        }
+        const yearDiff = (0, model_1.mkExpr) `(DATE_PART('year', ${rVal}) - DATE_PART('year', ${lVal}))`;
         if (units == "year") {
             return yearDiff;
         }
+        if (units == "week") {
+            const dayDiffForWeekStart = (0, model_1.mkExpr) `(DATE_TRUNC('week', ${rVal} + '1 day'::interval)::date - DATE_TRUNC('week', ${lVal} + '1 day'::interval)::date)`;
+            return (0, model_1.mkExpr) `${dayDiffForWeekStart} / 7`;
+        }
         if (units == "month") {
-            const monthDiff = (0, model_1.mkExpr) `TRUNC(EXTRACT(MONTH FROM ${rVal}) - EXTRACT(MONTH FROM ${lVal}))`;
+            const monthDiff = (0, model_1.mkExpr) `DATE_PART('month', ${rVal}) - DATE_PART('month', ${lVal})`;
             return (0, model_1.mkExpr) `${yearDiff} * 12 + ${monthDiff}`;
         }
         if (units == "quarter") {
-            const qDiff = (0, model_1.mkExpr) `TRUNC(EXTRACT(QUARTER FROM ${rVal}) - EXTRACT(QUARTER FROM ${lVal}))`;
+            const qDiff = (0, model_1.mkExpr) `DATE_PART('quarter', ${rVal}) - DATE_PART('quarter', ${lVal})`;
             return (0, model_1.mkExpr) `${yearDiff} * 4 + ${qDiff}`;
         }
         throw new Error(`Unknown or unhandled postgres time unit: ${units}`);

package/dist/dialect/standardsql.js

@@ -48,6 +48,7 @@ class StandardSQLDialect extends dialect_1.Dialect {
         this.supportsCTEinCoorelatedSubQueries = false;
         this.functionInfo = {
             timestamp_seconds: { returnType: "timestamp" },
+            concat: { returnType: "string" },
         };
         this.keywords = `
   ALL

package/dist/index.d.ts

@@ -1,9 +1,9 @@
-export type { QueryDataRow, ModelDef, Fragment, Query, StructDef, NamedStructDefs, MalloyQueryData, AtomicFieldType as AtomicFieldTypeInner, DateUnit, ExtractUnit, TimestampUnit, TimeFieldType, QueryData, FieldTypeDef, Expr, DialectFragment, TimeValue, FilterExpression, SQLBlock, FieldDef, PipeSegment, QueryFieldDef, TurtleDef, SearchValueMapResult, SearchIndexResult, } from "./model";
+export type { QueryDataRow, ModelDef, Fragment, Query, StructDef, StructRelationship, NamedStructDefs, MalloyQueryData, AtomicFieldType as AtomicFieldTypeInner, DateUnit, ExtractUnit, TimestampUnit, TimeFieldType, QueryData, FieldTypeDef, Expr, DialectFragment, TimeValue, FilterExpression, SQLBlock, FieldDef, FilteredAliasedName, PipeSegment, QueryFieldDef, TurtleDef, SearchValueMapResult, SearchIndexResult, } from "./model";
 export { Segment, isFilteredAliasedName, } from "./model";
 export { HighlightType, MalloyTranslator, } from "./lang";
 export type { LogMessage, TranslateResponse } from "./lang";
-export { Malloy, Runtime, AtomicFieldType, ConnectionRuntime, SingleConnectionRuntime, EmptyURLReader, InMemoryURLReader, FixedConnectionMap, MalloyError, JoinRelationship, SourceRelationship, DateTimeframe, TimestampTimeframe, Result, parseTableURL, QueryMaterializer, CSVWriter, JSONWriter, DataWriter, } from "./malloy";
-export type { Explore, Model, PreparedQuery, PreparedResult, Field, AtomicField, ExploreField, QueryField, DataArray, DataRecord, DataColumn, DataArrayOrRecord, ModelMaterializer, DocumentSymbol, DocumentHighlight, ResultJSON, PreparedResultMaterializer, SQLBlockMaterializer, ExploreMaterializer, WriteStream, } from "./malloy";
-export type { URLReader, InfoConnection, LookupConnection, Connection, QueryString, ModelString, QueryURL, ModelURL, PooledConnection, TestableConnection, PersistSQLResults, } from "./runtime_types";
+export { Malloy, Runtime, AtomicFieldType, ConnectionRuntime, SingleConnectionRuntime, EmptyURLReader, InMemoryURLReader, FixedConnectionMap, MalloyError, JoinRelationship, SourceRelationship, DateTimeframe, TimestampTimeframe, Result, parseTableURI, QueryMaterializer, CSVWriter, JSONWriter, DataWriter, } from "./malloy";
+export type { Explore, Model, PreparedQuery, PreparedResult, Field, AtomicField, ExploreField, QueryField, DataArray, DataRecord, DataColumn, DataArrayOrRecord, ModelMaterializer, DocumentSymbol, DocumentHighlight, ResultJSON, RunSQLOptions, PreparedResultMaterializer, SQLBlockMaterializer, ExploreMaterializer, WriteStream, } from "./malloy";
+export type { URLReader, InfoConnection, LookupConnection, Connection, QueryString, ModelString, QueryURL, ModelURL, PooledConnection, TestableConnection, PersistSQLResults, FetchSchemaAndRunSimultaneously, StreamingConnection, FetchSchemaAndRunStreamSimultaneously, } from "./runtime_types";
 export type { Loggable } from "./malloy";
 export { toAsyncGenerator } from "./connection_utils";

package/dist/index.js

@@ -12,7 +12,7 @@
  * GNU General Public License for more details.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.toAsyncGenerator = exports.DataWriter = exports.JSONWriter = exports.CSVWriter = exports.QueryMaterializer = exports.parseTableURL = exports.Result = exports.TimestampTimeframe = exports.DateTimeframe = exports.SourceRelationship = exports.JoinRelationship = exports.MalloyError = exports.FixedConnectionMap = exports.InMemoryURLReader = exports.EmptyURLReader = exports.SingleConnectionRuntime = exports.ConnectionRuntime = exports.AtomicFieldType = exports.Runtime = exports.Malloy = exports.MalloyTranslator = exports.HighlightType = exports.isFilteredAliasedName = exports.Segment = void 0;
+exports.toAsyncGenerator = exports.DataWriter = exports.JSONWriter = exports.CSVWriter = exports.QueryMaterializer = exports.parseTableURI = exports.Result = exports.TimestampTimeframe = exports.DateTimeframe = exports.SourceRelationship = exports.JoinRelationship = exports.MalloyError = exports.FixedConnectionMap = exports.InMemoryURLReader = exports.EmptyURLReader = exports.SingleConnectionRuntime = exports.ConnectionRuntime = exports.AtomicFieldType = exports.Runtime = exports.Malloy = exports.MalloyTranslator = exports.HighlightType = exports.isFilteredAliasedName = exports.Segment = void 0;
 var model_1 = require("./model");
 // Used in Composer Demo
 Object.defineProperty(exports, "Segment", { enumerable: true, get: function () { return model_1.Segment; } });
@@ -37,7 +37,7 @@ Object.defineProperty(exports, "SourceRelationship", { enumerable: true, get: fu
 Object.defineProperty(exports, "DateTimeframe", { enumerable: true, get: function () { return malloy_1.DateTimeframe; } });
 Object.defineProperty(exports, "TimestampTimeframe", { enumerable: true, get: function () { return malloy_1.TimestampTimeframe; } });
 Object.defineProperty(exports, "Result", { enumerable: true, get: function () { return malloy_1.Result; } });
-Object.defineProperty(exports, "parseTableURL", { enumerable: true, get: function () { return malloy_1.parseTableURL; } });
+Object.defineProperty(exports, "parseTableURI", { enumerable: true, get: function () { return malloy_1.parseTableURI; } });
 Object.defineProperty(exports, "QueryMaterializer", { enumerable: true, get: function () { return malloy_1.QueryMaterializer; } });
 Object.defineProperty(exports, "CSVWriter", { enumerable: true, get: function () { return malloy_1.CSVWriter; } });
 Object.defineProperty(exports, "JSONWriter", { enumerable: true, get: function () { return malloy_1.JSONWriter; } });

package/dist/lang/ast/apply-expr.d.ts

@@ -1,5 +1,5 @@
 import { Expr } from "../../model/malloy_types";
-import { FSPair } from "../field-space";
+import { FieldSpace } from "../field-space";
 import { ExprValue, ExpressionDef, Equality } from "./index";
 /**
  * All of the magic of malloy expressions eventually flows to here,
@@ -12,5 +12,5 @@ import { ExprValue, ExpressionDef, Equality } from "./index";
  * @param right Right Value
  * @returns ExprValue of the expression
  */
-export declare function applyBinary(fs: FSPair, left: ExpressionDef, op: string, right: ExpressionDef): ExprValue;
+export declare function applyBinary(fs: FieldSpace, left: ExpressionDef, op: string, right: ExpressionDef): ExprValue;
 export declare function nullsafeNot(expr: Expr, op?: Equality): Expr;

package/dist/lang/ast/apply-expr.js

@@ -40,12 +40,28 @@ function applyBinary(fs, left, op, right) {
         return numeric(fs, left, op, right);
     }
     if (oneOf(op, "/")) {
-        if (fs.in.getDialect().divisionIsInteger) {
-            return numeric(fs, left, "*1.0/", right);
+        const num = left.getExpression(fs);
+        const denom = right.getExpression(fs);
+        if (num.dataType != "number") {
+            left.log("Numerator for division must be a number");
+        }
+        else if (denom.dataType != "number") {
+            right.log("Denominator for division must be a number");
         }
         else {
-            return numeric(fs, left, op, right);
+            const div = {
+                type: "dialect",
+                function: "div",
+                numerator: num.value,
+                denominator: denom.value,
+            };
+            return {
+                dataType: "number",
+                aggregate: num.aggregate || denom.aggregate,
+                value: [div],
+            };
         }
+        return (0, index_1.errorFor)("divide type mismatch");
     }
     left.log(`Canot use ${op} operator here`);
     return (0, index_1.errorFor)("applybinary bad operator");

package/dist/lang/ast/ast-expr.d.ts

@@ -1,5 +1,5 @@
 import { By, AtomicFieldType, FieldTypeDef, Fragment, TimeFieldType } from "../../model/malloy_types";
-import { FSPair, FieldSpace } from "../field-space";
+import { FieldSpace } from "../field-space";
 import { Filter, MalloyElement, ExprValue, FieldValueType, FragType } from "./index";
 import { FieldName, FieldReference } from "./ast-main";
 /**
@@ -17,7 +17,7 @@ export declare abstract class ExpressionDef extends MalloyElement {
      * the translation code a chance to convert to match your expectations
      * @param space Namespace for looking up field references
      */
-    abstract getExpression(fs: FSPair): ExprValue;
+    abstract getExpression(fs: FieldSpace): ExprValue;
     legalChildTypes: FragType[];
     /**
      * Some operators want to give the right hand value a chance to
@@ -26,7 +26,7 @@ export declare abstract class ExpressionDef extends MalloyElement {
      * @param fs FieldSpace
      * @returns Translated expression or undefined
      */
-    requestExpression(fs: FSPair): ExprValue | undefined;
+    requestExpression(fs: FieldSpace): ExprValue | undefined;
     defaultFieldName(): string | undefined;
     /**
      * Check an expression for type compatibility
@@ -44,19 +44,19 @@ export declare abstract class ExpressionDef extends MalloyElement {
      * @param expr The "other" (besdies 'this') value
      * @returns The translated expression
      */
-    apply(fs: FSPair, op: string, left: ExpressionDef): ExprValue;
+    apply(fs: FieldSpace, op: string, left: ExpressionDef): ExprValue;
 }
 export declare class ConstantSubExpression extends ExpressionDef {
     readonly expr: ExpressionDef;
     elementType: string;
     private cfs?;
     constructor(expr: ExpressionDef);
-    getExpression(_fs: FSPair): ExprValue;
+    getExpression(_fs: FieldSpace): ExprValue;
     private get constantFs();
     constantValue(): ExprValue;
     constantCondition(type: AtomicFieldType): ExprValue;
-    apply(fs: FSPair, op: string, expr: ExpressionDef): ExprValue;
-    requestExpression(fs: FSPair): ExprValue | undefined;
+    apply(fs: FieldSpace, op: string, expr: ExpressionDef): ExprValue;
+    requestExpression(fs: FieldSpace): ExprValue | undefined;
 }
 export declare class FieldDeclaration extends MalloyElement {
     readonly expr: ExpressionDef;
@@ -66,7 +66,7 @@ export declare class FieldDeclaration extends MalloyElement {
     isMeasure?: boolean;
     constructor(expr: ExpressionDef, defineName: string, exprSrc?: string | undefined);
     fieldDef(fs: FieldSpace, exprName: string): FieldTypeDef;
-    queryFieldDef(exprFS: FSPair, exprName: string): FieldTypeDef;
+    queryFieldDef(exprFS: FieldSpace, exprName: string): FieldTypeDef;
 }
 export declare class TypeMistmatch extends Error {
 }
@@ -74,13 +74,13 @@ export declare class ExprString extends ExpressionDef {
     readonly value: string;
     elementType: string;
     constructor(value: string);
-    getExpression(_fs: FSPair): ExprValue;
+    getExpression(_fs: FieldSpace): ExprValue;
 }
 export declare class ExprNumber extends ExpressionDef {
     readonly n: string;
     elementType: string;
     constructor(n: string);
-    getExpression(_fs: FSPair): ExprValue;
+    getExpression(_fs: FieldSpace): ExprValue;
     constantExpression(): ExprValue;
 }
 export declare class ExprRegEx extends ExpressionDef {
@@ -93,7 +93,7 @@ export declare class ExprTime extends ExpressionDef {
     elementType: string;
     readonly translationValue: ExprValue;
     constructor(timeType: TimeFieldType, value: Fragment[] | string, aggregate?: boolean);
-    getExpression(_fs: FSPair): ExprValue;
+    getExpression(_fs: FieldSpace): ExprValue;
     static fromValue(timeType: TimeFieldType, expr: ExprValue): ExprTime;
 }
 declare abstract class Unary extends ExpressionDef {
@@ -104,7 +104,7 @@ export declare class ExprNot extends Unary {
     elementType: string;
     legalChildTypes: FragType[];
     constructor(expr: ExpressionDef);
-    getExpression(fs: FSPair): ExprValue;
+    getExpression(fs: FieldSpace): ExprValue;
 }
 export declare class Boolean extends ExpressionDef {
     readonly value: "true" | "false";
@@ -119,7 +119,7 @@ export declare abstract class BinaryBoolean<opType extends string> extends Expre
     elementType: string;
     legalChildTypes: FragType[];
     constructor(left: ExpressionDef, op: opType, right: ExpressionDef);
-    getExpression(fs: FSPair): ExprValue;
+    getExpression(fs: FieldSpace): ExprValue;
 }
 export declare class ExprLogicalOp extends BinaryBoolean<"and" | "or"> {
     elementType: string;
@@ -130,8 +130,8 @@ export declare class ExprIdReference extends ExpressionDef {
     elementType: string;
     constructor(fieldReference: FieldReference);
     get refString(): string;
-    getExpression(fs: FSPair): ExprValue;
-    apply(fs: FSPair, op: string, expr: ExpressionDef): ExprValue;
+    getExpression(fs: FieldSpace): ExprValue;
+    apply(fs: FieldSpace, op: string, expr: ExpressionDef): ExprValue;
 }
 export declare class ExprNULL extends ExpressionDef {
     elementType: string;
@@ -141,15 +141,15 @@ export declare class ExprParens extends ExpressionDef {
     readonly expr: ExpressionDef;
     elementType: string;
     constructor(expr: ExpressionDef);
-    apply(fs: FSPair, op: string, expr: ExpressionDef): ExprValue;
-    requestExpression(fs: FSPair): ExprValue | undefined;
-    getExpression(fs: FSPair): ExprValue;
+    apply(fs: FieldSpace, op: string, expr: ExpressionDef): ExprValue;
+    requestExpression(fs: FieldSpace): ExprValue | undefined;
+    getExpression(fs: FieldSpace): ExprValue;
 }
 export declare class ExprMinus extends ExpressionDef {
     readonly expr: ExpressionDef;
     elementType: string;
     constructor(expr: ExpressionDef);
-    getExpression(fs: FSPair): ExprValue;
+    getExpression(fs: FieldSpace): ExprValue;
 }
 export declare abstract class BinaryNumeric<opType extends string> extends ExpressionDef {
     readonly left: ExpressionDef;
@@ -157,7 +157,7 @@ export declare abstract class BinaryNumeric<opType extends string> extends Expre
     readonly right: ExpressionDef;
     elementType: string;
     constructor(left: ExpressionDef, op: opType, right: ExpressionDef);
-    getExpression(fs: FSPair): ExprValue;
+    getExpression(fs: FieldSpace): ExprValue;
 }
 export declare class ExprAddSub extends BinaryNumeric<"+" | "-"> {
     elementType: string;
@@ -168,9 +168,9 @@ export declare class ExprMulDiv extends BinaryNumeric<"*" | "/"> {
 export declare class ExprAlternationTree extends BinaryBoolean<"|" | "&"> {
     elementType: string;
     constructor(left: ExpressionDef, op: "|" | "&", right: ExpressionDef);
-    apply(fs: FSPair, applyOp: string, expr: ExpressionDef): ExprValue;
-    requestExpression(_fs: FSPair): ExprValue | undefined;
-    getExpression(_fs: FSPair): ExprValue;
+    apply(fs: FieldSpace, applyOp: string, expr: ExpressionDef): ExprValue;
+    requestExpression(_fs: FieldSpace): ExprValue | undefined;
+    getExpression(_fs: FieldSpace): ExprValue;
 }
 declare abstract class ExprAggregateFunction extends ExpressionDef {
     readonly func: string;
@@ -180,7 +180,7 @@ declare abstract class ExprAggregateFunction extends ExpressionDef {
     legalChildTypes: FragType[];
     constructor(func: string, expr?: ExpressionDef);
     returns(_forExpression: ExprValue): FieldValueType;
-    getExpression(fs: FSPair): ExprValue;
+    getExpression(fs: FieldSpace): ExprValue;
 }
 export declare class ExprMin extends ExprAggregateFunction {
     legalChildTypes: FragType[];
@@ -208,7 +208,7 @@ export declare class ExprCount extends ExprAggregateFunction {
     elementType: string;
     constructor(source?: FieldReference | undefined);
     defaultFieldName(): string | undefined;
-    getExpression(_fs: FSPair): ExprValue;
+    getExpression(_fs: FieldSpace): ExprValue;
 }
 export declare class ExprAvg extends ExprAsymmetric {
     constructor(expr: ExpressionDef | undefined, source?: FieldReference);
@@ -224,21 +224,21 @@ export declare class ExprUngroup extends ExpressionDef {
     elementType: string;
     constructor(control: "all" | "exclude", expr: ExpressionDef, fields: FieldName[]);
     returns(_forExpression: ExprValue): FieldValueType;
-    getExpression(fs: FSPair): ExprValue;
+    getExpression(fs: FieldSpace): ExprValue;
 }
 export declare class WhenClause extends ExpressionDef {
     readonly whenThis: ExpressionDef;
     readonly thenThis: ExpressionDef;
     elementType: string;
     constructor(whenThis: ExpressionDef, thenThis: ExpressionDef);
-    getExpression(_fs: FSPair): ExprValue;
+    getExpression(_fs: FieldSpace): ExprValue;
 }
 export declare class ExprCase extends ExpressionDef {
     readonly when: WhenClause[];
     readonly elseClause?: ExpressionDef | undefined;
     elementType: string;
     constructor(when: WhenClause[], elseClause?: ExpressionDef | undefined);
-    getExpression(fs: FSPair): ExprValue;
+    getExpression(fs: FieldSpace): ExprValue;
 }
 export declare class ExprFilter extends ExpressionDef {
     readonly expr: ExpressionDef;
@@ -246,7 +246,7 @@ export declare class ExprFilter extends ExpressionDef {
     elementType: string;
     legalChildTypes: FragType[];
     constructor(expr: ExpressionDef, filter: Filter);
-    getExpression(fs: FSPair): ExprValue;
+    getExpression(fs: FieldSpace): ExprValue;
 }
 declare type CastType = "string" | "number" | "boolean" | "date" | "timestamp";
 export declare function isCastType(t: string): t is CastType;
@@ -256,22 +256,22 @@ export declare class ExprCast extends ExpressionDef {
     readonly safe: boolean;
     elementType: string;
     constructor(expr: ExpressionDef, castType: CastType, safe?: boolean);
-    getExpression(fs: FSPair): ExprValue;
+    getExpression(fs: FieldSpace): ExprValue;
 }
 export declare class TopBy extends MalloyElement {
     readonly by: string | ExpressionDef;
     elementType: string;
     constructor(by: string | ExpressionDef);
-    getBy(fs: FSPair): By;
+    getBy(fs: FieldSpace): By;
 }
 export declare class Range extends ExpressionDef {
     readonly first: ExpressionDef;
     readonly last: ExpressionDef;
     elementType: string;
     constructor(first: ExpressionDef, last: ExpressionDef);
-    apply(fs: FSPair, op: string, expr: ExpressionDef): ExprValue;
-    requestExpression(_fs: FSPair): ExprValue | undefined;
-    getExpression(_fs: FSPair): ExprValue;
+    apply(fs: FieldSpace, op: string, expr: ExpressionDef): ExprValue;
+    requestExpression(_fs: FieldSpace): ExprValue | undefined;
+    getExpression(_fs: FieldSpace): ExprValue;
 }
 export declare class PickWhen extends MalloyElement {
     readonly pick: ExpressionDef | undefined;
@@ -284,8 +284,8 @@ export declare class Pick extends ExpressionDef {
     readonly elsePick?: ExpressionDef | undefined;
     elementType: string;
     constructor(choices: PickWhen[], elsePick?: ExpressionDef | undefined);
-    requestExpression(fs: FSPair): ExprValue | undefined;
-    apply(fs: FSPair, op: string, expr: ExpressionDef): ExprValue;
-    getExpression(fs: FSPair): ExprValue;
+    requestExpression(fs: FieldSpace): ExprValue | undefined;
+    apply(fs: FieldSpace, op: string, expr: ExpressionDef): ExprValue;
+    getExpression(fs: FieldSpace): ExprValue;
 }
 export {};