@malloydata/malloy 0.0.22-dev230117165007 → 0.0.22-dev230117200639

package/dist/dialect/dialect.d.ts

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

package/dist/dialect/dialect.js

@@ -23,10 +23,6 @@
  */
 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) {

package/dist/dialect/dialect_map.js

@@ -23,7 +23,7 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.registerDialect = exports.getDialect = void 0;
-const _1 = require(".");
+const duckdb_1 = require("./duckdb");
 const postgres_1 = require("./postgres");
 const standardsql_1 = require("./standardsql");
 const dialectMap = new Map();
@@ -41,5 +41,5 @@ function registerDialect(d) {
 exports.registerDialect = registerDialect;
 registerDialect(new postgres_1.PostgresDialect());
 registerDialect(new standardsql_1.StandardSQLDialect());
-registerDialect(new _1.DuckDBDialect());
+registerDialect(new duckdb_1.DuckDBDialect());
 //# sourceMappingURL=dialect_map.js.map

package/dist/dialect/duckdb.d.ts

@@ -1,4 +1,4 @@
-import { DateUnit, Expr, ExtractUnit, Sampling, StructDef, TimeFieldType, TimestampUnit, TimeValue, TypecastFragment } from "../model";
+import { DateUnit, Expr, ExtractUnit, Sampling, StructDef, TimeFieldType, TimestampUnit, TimeValue, TypecastFragment } from "../model/malloy_types";
 import { Dialect, DialectFieldList, FunctionInfo } from "./dialect";
 export declare class DuckDBDialect extends Dialect {
     name: string;

package/dist/dialect/duckdb.js

@@ -23,7 +23,7 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DuckDBDialect = void 0;
-const model_1 = require("../model");
+const malloy_types_1 = require("../model/malloy_types");
 const utils_1 = require("../model/utils");
 const dialect_1 = require("./dialect");
 // need to refactor runSQL to take a SQLBlock instead of just a sql string.
@@ -220,7 +220,7 @@ class DuckDBDialect extends dialect_1.Dialect {
     }
     sqlCreateFunctionCombineLastStage(lastStageName, structDef) {
         return `SELECT LIST(ROW(${structDef.fields
-            .map((fieldDef) => this.sqlMaybeQuoteIdentifier((0, model_1.getIdentifier)(fieldDef)))
+            .map((fieldDef) => this.sqlMaybeQuoteIdentifier((0, malloy_types_1.getIdentifier)(fieldDef)))
             .join(",")})) FROM ${lastStageName}\n`;
     }
     sqlSelectAliasAsStruct(alias, physicalFieldNames) {
@@ -251,64 +251,64 @@ class DuckDBDialect extends dialect_1.Dialect {
         let lVal = from.value;
         let rVal = to.value;
         if (inSeconds[units]) {
-            lVal = (0, model_1.mkExpr) `EXTRACT(EPOCH FROM ${lVal})`;
-            rVal = (0, model_1.mkExpr) `EXTRACT(EPOCH FROM ${rVal})`;
-            const duration = (0, model_1.mkExpr) `(${rVal} - ${lVal})`;
+            lVal = (0, malloy_types_1.mkExpr) `EXTRACT(EPOCH FROM ${lVal})`;
+            rVal = (0, malloy_types_1.mkExpr) `EXTRACT(EPOCH FROM ${rVal})`;
+            const duration = (0, malloy_types_1.mkExpr) `(${rVal} - ${lVal})`;
             return units == "second"
                 ? duration
-                : (0, model_1.mkExpr) `FLOOR(${duration}/${inSeconds[units].toString()})`;
+                : (0, malloy_types_1.mkExpr) `FLOOR(${duration}/${inSeconds[units].toString()})`;
         }
         if (from.valueType != "date") {
-            lVal = (0, model_1.mkExpr) `CAST((${lVal}) AS DATE)`;
+            lVal = (0, malloy_types_1.mkExpr) `CAST((${lVal}) AS DATE)`;
         }
         if (to.valueType != "date") {
-            rVal = (0, model_1.mkExpr) `CAST((${rVal}) AS DATE)`;
+            rVal = (0, malloy_types_1.mkExpr) `CAST((${rVal}) AS DATE)`;
         }
         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)`;
+            lVal = (0, malloy_types_1.mkExpr) `(${lVal} + INTERVAL 1 DAY)`;
+            rVal = (0, malloy_types_1.mkExpr) `(${rVal} + INTERVAL 1 DAY)`;
         }
-        return (0, model_1.mkExpr) `DATE_DIFF('${units}', ${lVal}, ${rVal})`;
+        return (0, malloy_types_1.mkExpr) `DATE_DIFF('${units}', ${lVal}, ${rVal})`;
     }
     sqlNow() {
-        return (0, model_1.mkExpr) `CURRENT_TIMESTAMP::TIMESTAMP`;
+        return (0, malloy_types_1.mkExpr) `CURRENT_TIMESTAMP::TIMESTAMP`;
     }
     sqlTrunc(sqlTime, units) {
         // adjusting for monday/sunday weeks
         const week = units == "week";
         const truncThis = week
-            ? (0, model_1.mkExpr) `${sqlTime.value} + INTERVAL 1 DAY`
+            ? (0, malloy_types_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;
+        const trunced = (0, malloy_types_1.mkExpr) `DATE_TRUNC('${units}', ${truncThis})`;
+        return week ? (0, malloy_types_1.mkExpr) `(${trunced} - INTERVAL 1 DAY)` : trunced;
     }
     sqlExtract(from, units) {
         const pgUnits = pgExtractionMap[units] || units;
-        const extracted = (0, model_1.mkExpr) `EXTRACT(${pgUnits} FROM ${from.value})`;
-        return units == "day_of_week" ? (0, model_1.mkExpr) `(${extracted}+1)` : extracted;
+        const extracted = (0, malloy_types_1.mkExpr) `EXTRACT(${pgUnits} FROM ${from.value})`;
+        return units == "day_of_week" ? (0, malloy_types_1.mkExpr) `(${extracted}+1)` : extracted;
     }
     sqlAlterTime(op, expr, n, timeframe) {
         if (timeframe == "quarter") {
             timeframe = "month";
-            n = (0, model_1.mkExpr) `${n}*3`;
+            n = (0, malloy_types_1.mkExpr) `${n}*3`;
         }
         if (timeframe == "week") {
             timeframe = "day";
-            n = (0, model_1.mkExpr) `${n}*7`;
+            n = (0, malloy_types_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, malloy_types_1.mkExpr) `INTERVAL (${n}) ${timeframe}`;
+        return (0, malloy_types_1.mkExpr) `((${expr.value})) ${op} ${interval}`;
     }
     sqlCast(cast) {
         if (cast.dstType !== cast.srcType) {
             const castTo = castMap[cast.dstType] || cast.dstType;
-            return (0, model_1.mkExpr) `cast(${cast.expr} as ${castTo})`;
+            return (0, malloy_types_1.mkExpr) `cast(${cast.expr} as ${castTo})`;
         }
         return cast.expr;
     }
     sqlRegexpMatch(expr, regexp) {
-        return (0, model_1.mkExpr) `REGEXP_MATCHES(${expr}, ${regexp})`;
+        return (0, malloy_types_1.mkExpr) `REGEXP_MATCHES(${expr}, ${regexp})`;
     }
     sqlLiteralTime(timeString, type, _timezone) {
         if (type == "date") {
@@ -341,13 +341,13 @@ class DuckDBDialect extends dialect_1.Dialect {
     // default duckdb to sampling 50K rows.
     sqlSampleTable(tableSQL, sample) {
         if (sample !== undefined) {
-            if ((0, model_1.isSamplingEnable)(sample) && sample.enable) {
+            if ((0, malloy_types_1.isSamplingEnable)(sample) && sample.enable) {
                 sample = this.defaultSampling;
             }
-            if ((0, model_1.isSamplingRows)(sample)) {
+            if ((0, malloy_types_1.isSamplingRows)(sample)) {
                 return `(SELECT * FROM ${tableSQL} USING SAMPLE ${sample.rows})`;
             }
-            else if ((0, model_1.isSamplingPercent)(sample)) {
+            else if ((0, malloy_types_1.isSamplingPercent)(sample)) {
                 return `(SELECT * FROM ${tableSQL} USING SAMPLE ${sample.percent} PERCENT (bernoulli))`;
             }
         }

package/dist/dialect/postgres.d.ts

@@ -1,4 +1,4 @@
-import { DateUnit, ExtractUnit, TimeFieldType, TimestampUnit, Expr, TimeValue, TypecastFragment, Sampling } from "../model";
+import { DateUnit, ExtractUnit, TimeFieldType, TimestampUnit, Expr, TimeValue, TypecastFragment, Sampling } from "../model/malloy_types";
 import { Dialect, DialectFieldList, FunctionInfo } from "./dialect";
 export declare class PostgresDialect extends Dialect {
     name: string;

package/dist/dialect/postgres.js

@@ -24,7 +24,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PostgresDialect = void 0;
 const utils_1 = require("../model/utils");
-const model_1 = require("../model");
+const malloy_types_1 = require("../model/malloy_types");
 const dialect_1 = require("./dialect");
 const castMap = {
     number: "double precision",
@@ -216,39 +216,39 @@ class PostgresDialect extends dialect_1.Dialect {
         throw new Error("Not implemented Yet");
     }
     sqlNow() {
-        return (0, model_1.mkExpr) `CURRENT_TIMESTAMP`;
+        return (0, malloy_types_1.mkExpr) `CURRENT_TIMESTAMP`;
     }
     sqlTrunc(sqlTime, units) {
         // adjusting for monday/sunday weeks
         const week = units == "week";
         const truncThis = week
-            ? (0, model_1.mkExpr) `${sqlTime.value}+interval'1'day`
+            ? (0, malloy_types_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;
+        const trunced = (0, malloy_types_1.mkExpr) `DATE_TRUNC('${units}', ${truncThis})`;
+        return week ? (0, malloy_types_1.mkExpr) `(${trunced}-interval'1'day)` : trunced;
     }
     sqlExtract(from, units) {
         const pgUnits = pgExtractionMap[units] || units;
-        const extracted = (0, model_1.mkExpr) `EXTRACT(${pgUnits} FROM ${from.value})`;
-        return units == "day_of_week" ? (0, model_1.mkExpr) `(${extracted}+1)` : extracted;
+        const extracted = (0, malloy_types_1.mkExpr) `EXTRACT(${pgUnits} FROM ${from.value})`;
+        return units == "day_of_week" ? (0, malloy_types_1.mkExpr) `(${extracted}+1)` : extracted;
     }
     sqlAlterTime(op, expr, n, timeframe) {
         if (timeframe == "quarter") {
             timeframe = "month";
-            n = (0, model_1.mkExpr) `${n}*3`;
+            n = (0, malloy_types_1.mkExpr) `${n}*3`;
         }
-        const interval = (0, model_1.mkExpr) `make_interval(${pgMakeIntervalMap[timeframe]}=>${n})`;
-        return (0, model_1.mkExpr) `((${expr.value})${op}${interval})`;
+        const interval = (0, malloy_types_1.mkExpr) `make_interval(${pgMakeIntervalMap[timeframe]}=>${n})`;
+        return (0, malloy_types_1.mkExpr) `((${expr.value})${op}${interval})`;
     }
     sqlCast(cast) {
         if (cast.dstType !== cast.srcType) {
             const castTo = castMap[cast.dstType] || cast.dstType;
-            return (0, model_1.mkExpr) `cast(${cast.expr} as ${castTo})`;
+            return (0, malloy_types_1.mkExpr) `cast(${cast.expr} as ${castTo})`;
         }
         return cast.expr;
     }
     sqlRegexpMatch(expr, regexp) {
-        return (0, model_1.mkExpr) `(${expr} ~ ${regexp})`;
+        return (0, malloy_types_1.mkExpr) `(${expr} ~ ${regexp})`;
     }
     sqlLiteralTime(timeString, type, _timezone) {
         if (type == "date") {
@@ -268,31 +268,31 @@ class PostgresDialect extends dialect_1.Dialect {
         let lVal = from.value;
         let rVal = to.value;
         if (inSeconds[units]) {
-            lVal = (0, model_1.mkExpr) `EXTRACT(EPOCH FROM ${lVal})`;
-            rVal = (0, model_1.mkExpr) `EXTRACT(EPOCH FROM ${rVal})`;
-            const duration = (0, model_1.mkExpr) `(${rVal} - ${lVal})`;
+            lVal = (0, malloy_types_1.mkExpr) `EXTRACT(EPOCH FROM ${lVal})`;
+            rVal = (0, malloy_types_1.mkExpr) `EXTRACT(EPOCH FROM ${rVal})`;
+            const duration = (0, malloy_types_1.mkExpr) `(${rVal} - ${lVal})`;
             return units == "second"
                 ? duration
-                : (0, model_1.mkExpr) `TRUNC(${duration}/${inSeconds[units].toString()})`;
+                : (0, malloy_types_1.mkExpr) `TRUNC(${duration}/${inSeconds[units].toString()})`;
         }
         if (units === "day") {
-            return (0, model_1.mkExpr) `${rVal}::date - ${lVal}::date`;
+            return (0, malloy_types_1.mkExpr) `${rVal}::date - ${lVal}::date`;
         }
-        const yearDiff = (0, model_1.mkExpr) `(DATE_PART('year', ${rVal}) - DATE_PART('year', ${lVal}))`;
+        const yearDiff = (0, malloy_types_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`;
+            const dayDiffForWeekStart = (0, malloy_types_1.mkExpr) `(DATE_TRUNC('week', ${rVal} + '1 day'::interval)::date - DATE_TRUNC('week', ${lVal} + '1 day'::interval)::date)`;
+            return (0, malloy_types_1.mkExpr) `${dayDiffForWeekStart} / 7`;
         }
         if (units == "month") {
-            const monthDiff = (0, model_1.mkExpr) `DATE_PART('month', ${rVal}) - DATE_PART('month', ${lVal})`;
-            return (0, model_1.mkExpr) `${yearDiff} * 12 + ${monthDiff}`;
+            const monthDiff = (0, malloy_types_1.mkExpr) `DATE_PART('month', ${rVal}) - DATE_PART('month', ${lVal})`;
+            return (0, malloy_types_1.mkExpr) `${yearDiff} * 12 + ${monthDiff}`;
         }
         if (units == "quarter") {
-            const qDiff = (0, model_1.mkExpr) `DATE_PART('quarter', ${rVal}) - DATE_PART('quarter', ${lVal})`;
-            return (0, model_1.mkExpr) `${yearDiff} * 4 + ${qDiff}`;
+            const qDiff = (0, malloy_types_1.mkExpr) `DATE_PART('quarter', ${rVal}) - DATE_PART('quarter', ${lVal})`;
+            return (0, malloy_types_1.mkExpr) `${yearDiff} * 4 + ${qDiff}`;
         }
         throw new Error(`Unknown or unhandled postgres time unit: ${units}`);
     }
@@ -307,13 +307,13 @@ class PostgresDialect extends dialect_1.Dialect {
     }
     sqlSampleTable(tableSQL, sample) {
         if (sample !== undefined) {
-            if ((0, model_1.isSamplingEnable)(sample) && sample.enable) {
+            if ((0, malloy_types_1.isSamplingEnable)(sample) && sample.enable) {
                 sample = this.defaultSampling;
             }
-            if ((0, model_1.isSamplingRows)(sample)) {
+            if ((0, malloy_types_1.isSamplingRows)(sample)) {
                 return `(SELECT * FROM ${tableSQL} TABLESAMPLE SYSTEM_ROWS(${sample.rows}))`;
             }
-            else if ((0, model_1.isSamplingPercent)(sample)) {
+            else if ((0, malloy_types_1.isSamplingPercent)(sample)) {
                 return `(SELECT * FROM ${tableSQL} TABLESAMPLE SYSTEM (${sample.percent}))`;
             }
         }

package/dist/dialect/standardsql.d.ts

@@ -1,4 +1,4 @@
-import { TimestampUnit, ExtractUnit, Expr, TimeValue, TypecastFragment, Sampling } from "../model";
+import { TimestampUnit, ExtractUnit, Expr, TimeValue, TypecastFragment, Sampling } from "../model/malloy_types";
 import { Dialect, DialectFieldList, FunctionInfo } from "./dialect";
 export declare class StandardSQLDialect extends Dialect {
     name: string;

package/dist/dialect/standardsql.js

@@ -24,7 +24,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.StandardSQLDialect = void 0;
 const utils_1 = require("../model/utils");
-const model_1 = require("../model");
+const malloy_types_1 = require("../model/malloy_types");
 const dialect_1 = require("./dialect");
 const castMap = {
     number: "float64",
@@ -270,20 +270,20 @@ ${(0, utils_1.indent)(sql)}
             : identifier;
     }
     sqlNow() {
-        return (0, model_1.mkExpr) `CURRENT_TIMESTAMP()`;
+        return (0, malloy_types_1.mkExpr) `CURRENT_TIMESTAMP()`;
     }
     sqlTrunc(sqlTime, units) {
         if (sqlTime.valueType == "date") {
-            if ((0, model_1.isDateUnit)(units)) {
-                return (0, model_1.mkExpr) `DATE_TRUNC(${sqlTime.value},${units})`;
+            if ((0, malloy_types_1.isDateUnit)(units)) {
+                return (0, malloy_types_1.mkExpr) `DATE_TRUNC(${sqlTime.value},${units})`;
             }
-            return (0, model_1.mkExpr) `TIMESTAMP(${sqlTime.value})`;
+            return (0, malloy_types_1.mkExpr) `TIMESTAMP(${sqlTime.value})`;
         }
-        return (0, model_1.mkExpr) `TIMESTAMP_TRUNC(${sqlTime.value},${units})`;
+        return (0, malloy_types_1.mkExpr) `TIMESTAMP_TRUNC(${sqlTime.value},${units})`;
     }
     sqlExtract(expr, units) {
         const extractTo = extractMap[units] || units;
-        return (0, model_1.mkExpr) `EXTRACT(${extractTo} FROM ${expr.value})`;
+        return (0, malloy_types_1.mkExpr) `EXTRACT(${extractTo} FROM ${expr.value})`;
     }
     sqlAlterTime(op, expr, n, timeframe) {
         let theTime = expr.value;
@@ -292,16 +292,16 @@ ${(0, utils_1.indent)(sql)}
             // The units must be done in timestamp, no matter the input type
             computeType = "timestamp";
             if (expr.valueType != "timestamp") {
-                theTime = (0, model_1.mkExpr) `TIMESTAMP(${theTime})`;
+                theTime = (0, malloy_types_1.mkExpr) `TIMESTAMP(${theTime})`;
             }
         }
         else if (expr.valueType == "timestamp") {
-            theTime = (0, model_1.mkExpr) `DATETIME(${theTime})`;
+            theTime = (0, malloy_types_1.mkExpr) `DATETIME(${theTime})`;
             computeType = "datetime";
         }
         const funcName = computeType.toUpperCase() + (op == "+" ? "_ADD" : "_SUB");
-        const newTime = (0, model_1.mkExpr) `${funcName}(${theTime}, INTERVAL ${n} ${timeframe})`;
-        return computeType == "datetime" ? (0, model_1.mkExpr) `TIMESTAMP(${newTime})` : newTime;
+        const newTime = (0, malloy_types_1.mkExpr) `${funcName}(${theTime}, INTERVAL ${n} ${timeframe})`;
+        return computeType == "datetime" ? (0, malloy_types_1.mkExpr) `TIMESTAMP(${newTime})` : newTime;
     }
     ignoreInProject(fieldName) {
         return fieldName === "_PARTITIONTIME";
@@ -310,19 +310,19 @@ ${(0, utils_1.indent)(sql)}
         if (cast.srcType !== cast.dstType) {
             const dstType = castMap[cast.dstType] || cast.dstType;
             // This just makes the code look a little prettier ...
-            if (!cast.safe && cast.srcType && (0, model_1.isTimeFieldType)(cast.srcType)) {
+            if (!cast.safe && cast.srcType && (0, malloy_types_1.isTimeFieldType)(cast.srcType)) {
                 if (dstType == "date") {
-                    return (0, model_1.mkExpr) `DATE(${cast.expr})`;
+                    return (0, malloy_types_1.mkExpr) `DATE(${cast.expr})`;
                 }
-                return (0, model_1.mkExpr) `TIMESTAMP(${cast.expr})`;
+                return (0, malloy_types_1.mkExpr) `TIMESTAMP(${cast.expr})`;
             }
             const castFunc = cast.safe ? "SAFE_CAST" : "CAST";
-            return (0, model_1.mkExpr) `${castFunc}(${cast.expr}  AS ${dstType})`;
+            return (0, malloy_types_1.mkExpr) `${castFunc}(${cast.expr}  AS ${dstType})`;
         }
         return cast.expr;
     }
     sqlRegexpMatch(expr, regexp) {
-        return (0, model_1.mkExpr) `REGEXP_CONTAINS(${expr}, r${regexp})`;
+        return (0, malloy_types_1.mkExpr) `REGEXP_CONTAINS(${expr}, r${regexp})`;
     }
     sqlLiteralTime(timeString, type, timezone) {
         if (type === "date") {
@@ -341,32 +341,32 @@ ${(0, utils_1.indent)(sql)}
         let diffUsing = "TIMESTAMP_DIFF";
         if (units == "second" || units == "minute" || units == "hour") {
             if (from.valueType != "timestamp") {
-                lVal = (0, model_1.mkExpr) `TIMESTAMP(${lVal})`;
+                lVal = (0, malloy_types_1.mkExpr) `TIMESTAMP(${lVal})`;
             }
             if (to.valueType != "timestamp") {
-                rVal = (0, model_1.mkExpr) `TIMESTAMP(${rVal})`;
+                rVal = (0, malloy_types_1.mkExpr) `TIMESTAMP(${rVal})`;
             }
         }
         else {
             diffUsing = "DATE_DIFF";
             if (from.valueType != "date") {
-                lVal = (0, model_1.mkExpr) `DATE(${lVal})`;
+                lVal = (0, malloy_types_1.mkExpr) `DATE(${lVal})`;
             }
             if (to.valueType != "date") {
-                rVal = (0, model_1.mkExpr) `DATE(${rVal})`;
+                rVal = (0, malloy_types_1.mkExpr) `DATE(${rVal})`;
             }
         }
-        return (0, model_1.mkExpr) `${diffUsing}(${rVal}, ${lVal}, ${units})`;
+        return (0, malloy_types_1.mkExpr) `${diffUsing}(${rVal}, ${lVal}, ${units})`;
     }
     sqlSampleTable(tableSQL, sample) {
         if (sample !== undefined) {
-            if ((0, model_1.isSamplingEnable)(sample) && sample.enable) {
+            if ((0, malloy_types_1.isSamplingEnable)(sample) && sample.enable) {
                 sample = this.defaultSampling;
             }
-            if ((0, model_1.isSamplingRows)(sample)) {
+            if ((0, malloy_types_1.isSamplingRows)(sample)) {
                 throw new Error(`StandardSQL doesn't support sampling by rows only percent`);
             }
-            else if ((0, model_1.isSamplingPercent)(sample)) {
+            else if ((0, malloy_types_1.isSamplingPercent)(sample)) {
                 return `(SELECT * FROM ${tableSQL}  TABLESAMPLE SYSTEM (${sample.percent} PERCENT))`;
             }
         }

package/dist/index.d.ts

@@ -3,7 +3,8 @@ export { Segment, isFilteredAliasedName, flattenQuery, expressionIsCalculation,
 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, 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 { Explore, Model, PreparedQuery, PreparedResult, Field, AtomicField, ExploreField, QueryField, DataArray, DataRecord, DataColumn, DataArrayOrRecord, ModelMaterializer, DocumentSymbol, DocumentHighlight, ResultJSON, PreparedResultMaterializer, SQLBlockMaterializer, ExploreMaterializer, WriteStream, } from "./malloy";
+export type { RunSQLOptions } from "./run_sql_options";
 export type { URLReader, InfoConnection, LookupConnection, Connection, QueryString, ModelString, QueryURL, ModelURL, PooledConnection, TestableConnection, PersistSQLResults, StreamingConnection, } from "./runtime_types";
 export type { Loggable } from "./malloy";
 export { toAsyncGenerator } from "./connection_utils";

package/dist/malloy.d.ts

@@ -1,18 +1,15 @@
 /// <reference types="node" />
-import { InfoConnection } from ".";
+import { RunSQLOptions } from "./run_sql_options";
 import { DocumentHighlight as DocumentHighlightDefinition, DocumentSymbol as DocumentSymbolDefinition, DocumentCompletion as DocumentCompletionDefinition, LogMessage, MalloyTranslator } from "./lang";
 import { DocumentHelpContext } from "./lang/parse-tree-walkers/document-help-context-walker";
 import { CompiledQuery, FieldBooleanDef, FieldDateDef, FieldNumberDef, FieldStringDef, FieldTimestampDef, FieldTypeDef, FilterExpression, ModelDef, Query as InternalQuery, QueryData, QueryDataRow, QueryResult, StructDef, TurtleDef, SQLBlock, DocumentReference, DocumentPosition as ModelDocumentPosition, SearchIndexResult, SearchValueMapResult, NamedQuery, SQLBlockStructDef, FieldJSONDef } from "./model";
-import { LookupConnection, ModelString, ModelURL, QueryString, QueryURL, URLReader, Connection } from "./runtime_types";
+import { LookupConnection, ModelString, ModelURL, QueryString, QueryURL, URLReader, Connection, InfoConnection } from "./runtime_types";
 export interface Loggable {
     debug: (message?: any, ...optionalParams: any[]) => void;
     info: (message?: any, ...optionalParams: any[]) => void;
     warn: (message?: any, ...optionalParams: any[]) => void;
     error: (message?: any, ...optionalParams: any[]) => void;
 }
-export interface RunSQLOptions {
-    rowLimit?: number;
-}
 export declare class Malloy {
     static get version(): string;
     private static _log;

package/dist/model/malloy_query.d.ts

@@ -1,8 +1,7 @@
 import { Dialect, DialectFieldList } from "../dialect";
-import { FieldDef, FieldRef, FilterExpression, ModelDef, Query, QueryFieldDef, StructDef, StructRef, OrderBy, ResultMetadataDef, Expr, FieldFragment, AggregateFragment, CompiledQuery, FilterFragment, PipeSegment, TurtleDef, QuerySegment, Filtered, ParameterFragment, Parameter, JoinRelationship, DialectFragment, UngroupFragment, NamedQuery, AnalyticFragment } from "./malloy_types";
+import { FieldDef, FieldRef, FilterExpression, ModelDef, Query, QueryFieldDef, StructDef, StructRef, OrderBy, ResultMetadataDef, Expr, FieldFragment, AggregateFragment, CompiledQuery, FilterFragment, PipeSegment, TurtleDef, QuerySegment, Filtered, ParameterFragment, Parameter, JoinRelationship, DialectFragment, UngroupFragment, NamedQuery, AnalyticFragment, ResultStructMetadataDef, SearchIndexResult } from "./malloy_types";
 import { AndChain } from "./utils";
-import { ResultStructMetadataDef, SearchIndexResult } from ".";
-import { Connection } from "..";
+import { Connection } from "../runtime_types";
 interface TurtleDefPlus extends TurtleDef, Filtered {
 }
 interface OutputPipelinedSQL {

package/dist/run_sql_options.d.ts

@@ -0,0 +1,3 @@
+export interface RunSQLOptions {
+    rowLimit?: number;
+}

package/dist/run_sql_options.js

@@ -0,0 +1,15 @@
+"use strict";
+/*
+ * Copyright 2022 Google LLC
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=run_sql_options.js.map

package/dist/runtime_types.d.ts

@@ -1,5 +1,5 @@
-import { RunSQLOptions } from "./malloy";
-import { MalloyQueryData, QueryDataRow, SQLBlock, StructDef } from "./model";
+import { RunSQLOptions } from "./run_sql_options";
+import { MalloyQueryData, QueryDataRow, SQLBlock, StructDef } from "./model/malloy_types";
 /**
  * The contents of a Malloy query document.
  */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@malloydata/malloy",
-  "version": "0.0.22-dev230117165007",
+  "version": "0.0.22-dev230117200639",
   "license": "MIT",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",