@malloydata/malloy 0.0.177-dev240828173040 → 0.0.177-dev240829030921

package/dist/model/malloy_types.d.ts

@@ -1,4 +1,218 @@
 /// <reference types="node" />
+/**
+ * Field computations are compiled into an expression tree of "Expr"
+ * type nodes. Each node is one of these three interfaces. The
+ * final type "Expr" is a union type of all known nodes, so
+ * that you can use "if (expr.node === 'nodeType')" instead of
+ * having to write discriminator functions for every node type.
+ */
+export interface ExprLeaf {
+    node: string;
+    dataType?: AtomicFieldType;
+    sql?: string;
+}
+export interface ExprE extends ExprLeaf {
+    e: Expr;
+}
+export interface ExprOptionalE extends ExprLeaf {
+    e?: Expr;
+}
+export interface ExprWithKids extends ExprLeaf {
+    kids: Record<string, Expr | Expr[]>;
+}
+export type AnyExpr = ExprE | ExprOptionalE | ExprWithKids | ExprLeaf;
+export declare function exprHasKids(e: AnyExpr): e is ExprWithKids;
+export declare function exprHasE(e: AnyExpr): e is ExprE;
+export declare function exprIsLeaf(e: AnyExpr): boolean;
+export type Expr = BinaryExpr | UnaryExpr | FunctionCallNode | OutputFieldNode | FilterCondition | FilteredExpr | AggregateExpr | EmptyExpr | UngroupNode | FunctionParameterNode | SpreadExpr | AggregateOrderByNode | AggregateLimitNode | FieldnameNode | SourceReferenceNode | ParameterNode | NowNode | MeasureTimeExpr | TimeDeltaExpr | TimeTruncExpr | TimeExtractExpr | TypecastExpr | RegexMatchExpr | RegexLiteralNode | TimeLiteralNode | StringLiteralNode | NumberLiteralNode | BooleanLiteralNode | FunctionOrderBy | GenericSQLExpr | NullNode | PickExpr | ErrorNode;
+interface HasDataType {
+    dataType: AtomicFieldType;
+}
+export type TypedExpr = Expr & HasDataType;
+export type BinaryOperator = '+' | '-' | '*' | '%' | '/' | 'and' | 'or' | '=' | '!=' | '>' | '<' | '>=' | '<=' | 'coalesce' | 'like' | '!like';
+export interface BinaryExpr extends ExprWithKids {
+    node: BinaryOperator;
+    kids: {
+        left: Expr;
+        right: Expr;
+    };
+}
+export type UnaryOperator = '()' | 'not' | 'unary-' | 'is-null' | 'is-not-null';
+export interface UnaryExpr extends ExprE {
+    node: UnaryOperator;
+    e: Expr;
+}
+export interface FunctionCallNode extends ExprWithKids {
+    node: 'function_call';
+    name: string;
+    overload: FunctionOverloadDef;
+    expressionType: ExpressionType;
+    kids: {
+        args: Expr[];
+        orderBy?: FunctionOrderBy[];
+    };
+    limit?: number;
+    partitionBy?: string[];
+    structPath?: string[];
+}
+export interface OutputFieldNode extends ExprLeaf {
+    node: 'outputField';
+    name: string;
+}
+export interface FilterCondition extends ExprE {
+    node: 'filterCondition';
+    code: string;
+    expressionType: ExpressionType;
+}
+export interface FilteredExpr extends ExprWithKids {
+    node: 'filteredExpr';
+    kids: {
+        e: Expr;
+        filterList: FilterCondition[];
+    };
+}
+export type AggregateFunctionType = 'sum' | 'avg' | 'count' | 'distinct' | 'max' | 'min';
+export interface AggregateExpr extends ExprE {
+    node: 'aggregate';
+    function: AggregateFunctionType;
+    structPath?: string[];
+}
+export declare function isAsymmetricExpr(f: Expr): f is AggregateExpr;
+export interface EmptyExpr extends ExprLeaf {
+    node: '';
+}
+export interface UngroupNode extends ExprE {
+    node: 'all' | 'exclude';
+    fields?: string[];
+}
+export interface FunctionParameterNode extends ExprLeaf {
+    node: 'function_parameter';
+    name: string;
+}
+export interface AggregateOrderByNode extends ExprLeaf {
+    node: 'aggregate_order_by';
+    prefix?: string;
+    suffix?: string;
+}
+export interface AggregateLimitNode extends ExprLeaf {
+    node: 'aggregate_limit';
+}
+export interface SpreadExpr extends ExprE {
+    node: 'spread';
+    prefix: string | undefined;
+    suffix: string | undefined;
+}
+export interface FieldnameNode extends ExprLeaf {
+    node: 'field';
+    path: string[];
+}
+export interface SourceReferenceNode extends ExprLeaf {
+    node: 'source-reference';
+    path?: string[];
+}
+export interface ParameterNode extends ExprLeaf {
+    node: 'parameter';
+    path: string[];
+}
+export interface NowNode extends ExprLeaf {
+    node: 'now';
+}
+interface HasTimeValue {
+    dataType: TimeFieldType;
+}
+type TimeExpr = Expr & HasTimeValue;
+export interface MeasureTimeExpr extends ExprWithKids {
+    node: 'timeDiff';
+    units: TimestampUnit;
+    kids: {
+        left: TimeExpr;
+        right: TimeExpr;
+    };
+}
+export interface TimeDeltaExpr extends ExprWithKids {
+    node: 'delta';
+    kids: {
+        base: TimeExpr;
+        delta: Expr;
+    };
+    op: '+' | '-';
+    units: TimestampUnit;
+}
+export interface TimeTruncExpr extends ExprE {
+    node: 'trunc';
+    e: TimeExpr;
+    units: TimestampUnit;
+}
+export interface TimeExtractExpr extends ExprE {
+    node: 'extract';
+    e: TimeExpr;
+    units: ExtractUnit;
+}
+export interface TypecastExpr extends ExprE {
+    node: 'cast';
+    safe: boolean;
+    e: Expr;
+    dstType: CastType | {
+        raw: string;
+    };
+    srcType?: AtomicFieldType;
+}
+export interface RegexMatchExpr extends ExprWithKids {
+    node: 'regexpMatch';
+    kids: {
+        expr: Expr;
+        regex: Expr;
+    };
+}
+export interface TimeLiteralNode extends ExprLeaf {
+    node: 'timeLiteral';
+    literal: string;
+    dataType: TimeFieldType;
+    timezone?: string;
+}
+export interface StringLiteralNode extends ExprLeaf {
+    node: 'stringLiteral';
+    literal: string;
+}
+export interface RegexLiteralNode extends ExprLeaf {
+    node: 'regexpLiteral';
+    literal: string;
+}
+export interface NumberLiteralNode extends ExprLeaf {
+    node: 'numberLiteral';
+    literal: string;
+}
+export interface BooleanLiteralNode extends ExprLeaf {
+    node: 'true' | 'false';
+}
+export interface ErrorNode extends ExprLeaf {
+    node: 'error';
+    message?: string;
+}
+export interface GenericSQLExpr extends ExprWithKids {
+    node: 'genericSQLExpr';
+    kids: {
+        args: Expr[];
+    };
+    src: string[];
+}
+export interface NullNode extends ExprLeaf {
+    node: 'null';
+}
+export interface PickExpr extends ExprWithKids {
+    node: 'pick';
+    kids: {
+        pickWhen: Expr[];
+        pickThen: Expr[];
+        pickElse: Expr;
+    };
+}
+export type ExpressionType = 'scalar' | 'aggregate' | 'scalar_analytic' | 'aggregate_analytic' | 'ungrouped_aggregate';
+export interface Expression {
+    e?: Expr;
+    expressionType?: ExpressionType;
+    code?: string;
+}
 type ConstantExpr = Expr;
 export interface Parameter {
     value: ConstantExpr | null;
@@ -69,7 +283,7 @@ export interface ResultMetadataDef {
     sourceField: string;
     sourceExpression?: string;
     sourceClasses: string[];
-    filterList?: FilterExpression[];
+    filterList?: FilterCondition[];
     fieldKind: 'measure' | 'dimension' | 'struct';
 }
 export interface ResultStructMetadataDef extends ResultMetadataDef {
@@ -82,195 +296,6 @@ export interface ResultMetadata {
 export interface ResultStructMetadata {
     resultMetadata?: ResultStructMetadataDef;
 }
-export interface OutputFieldFragment {
-    type: 'outputField';
-    name: string;
-}
-export declare function isOutputFieldFragment(f: Fragment): f is OutputFieldFragment;
-export interface FilterFragment {
-    type: 'filterExpression';
-    filterList: FilterExpression[];
-    e: Expr;
-}
-export declare function isFilterFragment(f: Fragment): f is FilterFragment;
-export declare function isDialectFragment(f: Fragment): f is DialectFragment;
-export type AggregateFunctionType = 'sum' | 'avg' | 'count' | 'count_distinct' | 'max' | 'min';
-export interface AggregateFragment {
-    type: 'aggregate';
-    function: AggregateFunctionType;
-    e: Expr;
-    structPath?: string[];
-}
-export declare function isAggregateFragment(f: Fragment): f is AggregateFragment;
-export declare function isAsymmetricFragment(f: Fragment): f is AggregateFragment;
-export interface UngroupFragment {
-    type: 'all' | 'exclude';
-    e: Expr;
-    fields?: string[];
-}
-export declare function isUngroupFragment(f: Fragment): f is UngroupFragment;
-export interface FunctionParameterFragment {
-    type: 'function_parameter';
-    name: string;
-}
-export declare function isFunctionParameterFragment(f: Fragment): f is FunctionParameterFragment;
-export interface AggregateOrderByFragment {
-    type: 'aggregate_order_by';
-    prefix?: string;
-    suffix?: string;
-}
-export interface AggregateLimitFragment {
-    type: 'aggregate_limit';
-}
-export interface FunctionCallFragment {
-    type: 'function_call';
-    name: string;
-    overload: FunctionOverloadDef;
-    expressionType: ExpressionType;
-    args: Expr[];
-    orderBy?: FunctionOrderBy[];
-    limit?: number;
-    partitionBy?: string[];
-    structPath?: string[];
-}
-export declare function isFunctionCallFragment(f: Fragment): f is FunctionCallFragment;
-export interface SQLExpressionFragment {
-    type: 'sql_expression';
-    e: Expr;
-}
-export declare function isSQLExpressionFragment(f: Fragment): f is SQLExpressionFragment;
-export interface SpreadFragment {
-    type: 'spread';
-    e: Expr;
-    prefix: string | undefined;
-    suffix: string | undefined;
-}
-export declare function isSpreadFragment(f: Fragment): f is SpreadFragment;
-export interface FieldFragment {
-    type: 'field';
-    path: string[];
-}
-export declare function isFieldFragment(f: Fragment): f is FieldFragment;
-export interface SqlStringFragment {
-    type: 'sql-string';
-    e: Expr;
-}
-export declare function isSqlStringFragment(f: Fragment): f is SqlStringFragment;
-export interface SourceReferenceFragment {
-    type: 'source-reference';
-    path?: string[];
-}
-export declare function isSourceReferenceFragment(f: Fragment): f is SourceReferenceFragment;
-export interface ParameterFragment {
-    type: 'parameter';
-    path: string[];
-}
-export declare function isParameterFragment(f: Fragment): f is ParameterFragment;
-export interface ApplyValueFragment {
-    type: 'applyVal';
-}
-export declare function isApplyValue(f: Fragment): f is ApplyValueFragment;
-export interface ApplyFragment {
-    type: 'apply';
-    value: Expr;
-    to: Expr;
-}
-export declare function isApplyFragment(f: Fragment): f is ApplyFragment;
-interface DialectFragmentBase {
-    type: 'dialect';
-    function: string;
-}
-export interface NowFragment extends DialectFragmentBase {
-    function: 'now';
-}
-export interface TimeDiffFragment extends DialectFragmentBase {
-    function: 'timeDiff';
-    units: TimestampUnit;
-    left: TimeValue;
-    right: TimeValue;
-}
-export interface TimeDeltaFragment extends DialectFragmentBase {
-    function: 'delta';
-    base: TimeValue;
-    op: '+' | '-';
-    delta: Expr;
-    units: TimestampUnit;
-}
-export interface TimeTruncFragment extends DialectFragmentBase {
-    function: 'trunc';
-    expr: TimeValue;
-    units: TimestampUnit;
-}
-export interface TimeExtractFragment extends DialectFragmentBase {
-    function: 'extract';
-    expr: TimeValue;
-    units: ExtractUnit;
-}
-export interface TypecastFragment extends DialectFragmentBase {
-    function: 'cast';
-    safe: boolean;
-    expr: Expr;
-    dstType: CastType | {
-        raw: string;
-    };
-    srcType?: AtomicFieldType;
-}
-export interface RegexpMatchFragment extends DialectFragmentBase {
-    function: 'regexpMatch';
-    expr: Expr;
-    regexp: Expr;
-}
-export interface DivModFragment extends DialectFragmentBase {
-    function: 'div' | 'mod';
-    numerator: Expr;
-    denominator: Expr;
-}
-export interface TimeLiteralFragment extends DialectFragmentBase {
-    function: 'timeLiteral';
-    literal: string;
-    literalType: TimeFieldType;
-    timezone?: string;
-}
-export interface StringLiteralFragment extends DialectFragmentBase {
-    function: 'stringLiteral';
-    literal: string;
-}
-export interface RegexpLiteralFragment extends DialectFragmentBase {
-    function: 'regexpLiteral';
-    literal: string;
-}
-export interface NumberLiteralFragment extends DialectFragmentBase {
-    function: 'numberLiteral';
-    literal: string;
-}
-export type DialectFragment = DivModFragment | TimeLiteralFragment | NowFragment | TimeDeltaFragment | TimeDiffFragment | TimeTruncFragment | TypecastFragment | TimeExtractFragment | StringLiteralFragment | RegexpLiteralFragment | NumberLiteralFragment | RegexpMatchFragment;
-export type Fragment = string | ApplyFragment | ApplyValueFragment | FieldFragment | SourceReferenceFragment | SqlStringFragment | ParameterFragment | FilterFragment | OutputFieldFragment | AggregateFragment | UngroupFragment | DialectFragment | FunctionParameterFragment | AggregateOrderByFragment | AggregateLimitFragment | FunctionCallFragment | SQLExpressionFragment | SpreadFragment;
-export type Expr = Fragment[];
-export interface TypedValue {
-    value: Expr;
-    valueType: AtomicFieldType;
-}
-export interface TimeValue extends TypedValue {
-    valueType: TimeFieldType;
-}
-type TagElement = Expr | string;
-/**
- * Return an Expr based on the string template, subsittutions can be
- * either strings, or other Exprs.
-
- * ```
- * units = "inches"
- * len: Expr = [ "something", "returning", "a length "]
- * computeExpr = mkExpr`MEASURE(${len} in ${units})`;
- * ```
- */
-export declare function mkExpr(src: TemplateStringsArray, ...exprs: TagElement[]): Expr;
-export type ExpressionType = 'scalar' | 'aggregate' | 'scalar_analytic' | 'aggregate_analytic' | 'ungrouped_aggregate';
-export interface Expression {
-    e?: Expr;
-    expressionType?: ExpressionType;
-    code?: string;
-}
 export declare function expressionIsScalar(e: ExpressionType | undefined): boolean;
 export declare function expressionIsAggregate(e: ExpressionType | undefined): boolean;
 export declare function expressionIsUngroupedAggregate(e: ExpressionType | undefined): boolean;
@@ -381,12 +406,12 @@ export interface OrderBy {
     field: string | number;
     dir?: 'asc' | 'desc';
 }
-export interface FunctionOrderByExpression {
-    e: Expr;
+export interface FunctionOrderByExpression extends ExprE {
+    node: 'functionOrderBy';
     dir?: 'asc' | 'desc';
 }
-export interface FunctionOrderByDefaultExpression {
-    e: undefined;
+export interface FunctionOrderByDefaultExpression extends ExprLeaf {
+    node: 'functionDefaultOrderBy';
     dir: 'asc' | 'desc';
 }
 export type FunctionOrderBy = FunctionOrderByExpression | FunctionOrderByDefaultExpression;
@@ -415,7 +440,7 @@ export interface JoinedStruct {
     as: string;
 }
 export interface Filtered {
-    filterList?: FilterExpression[];
+    filterList?: FilterCondition[];
 }
 /**
  * First element in a pipeline might be a reference to a turtle
@@ -512,11 +537,11 @@ export type StructRelationship = {
     fieldName: string;
     isArray: boolean;
 };
-export interface SQLFragment {
+export interface SQLStringSegment {
     sql: string;
 }
-export type SQLPhrase = Query | SQLFragment;
-export declare function isSQLFragment(f: SQLPhrase): f is SQLFragment;
+export type SQLPhrase = Query | SQLStringSegment;
+export declare function isSQLFragment(f: SQLPhrase): f is SQLStringSegment;
 /**
  * A source reference to an SQL block. The compiler uses these to request
  * an SQLBlock with it's schema and structdef defined. Use the factory
@@ -643,12 +668,6 @@ export interface RefToField {
 export type FieldRefOrDef = FieldDef | RefToField;
 /** which field is the primary key in this struct */
 export type PrimaryKeyRef = string;
-/** filters */
-export interface FilterExpression {
-    expression: Expr;
-    code: string;
-    expressionType: ExpressionType;
-}
 /** Get the output name for a NamedObject */
 export declare function getIdentifier(n: AliasedName): string;
 export type NamedModelObject = StructDef | NamedQuery | FunctionDef | ConnectionDef;
@@ -698,7 +717,7 @@ export type MalloyQueryData = {
 };
 export interface DrillSource {
     sourceExplore: string;
-    sourceFilters?: FilterExpression[];
+    sourceFilters?: FilterCondition[];
 }
 export interface CompiledQuery extends DrillSource {
     structs: StructDef[];

package/dist/model/malloy_types.js

@@ -22,108 +22,29 @@
  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isIndexSegment = exports.isRawSegment = exports.isSamplingEnable = exports.isSamplingPercent = exports.isSamplingRows = exports.isQuerySegment = exports.isProjectSegment = exports.isPartialSegment = exports.isReduceSegment = exports.structHasErrors = exports.segmentHasErrors = exports.refIsStructDef = exports.isByExpression = exports.isByName = exports.ValueType = exports.isExtractUnit = exports.isTimestampUnit = exports.isDateUnit = exports.FieldIsIntrinsic = exports.isCastType = exports.isAtomicFieldType = exports.isTimeFieldType = exports.hasExpression = exports.maxOfExpressionTypes = exports.maxExpressionType = exports.isExpressionTypeLEQ = exports.expressionIsAnalytic = exports.expressionIsCalculation = exports.expressionInvolvesAggregate = exports.expressionIsUngroupedAggregate = exports.expressionIsAggregate = exports.expressionIsScalar = exports.mkExpr = exports.isApplyFragment = exports.isApplyValue = exports.isParameterFragment = exports.isSourceReferenceFragment = exports.isSqlStringFragment = exports.isFieldFragment = exports.isSpreadFragment = exports.isSQLExpressionFragment = exports.isFunctionCallFragment = exports.isFunctionParameterFragment = exports.isUngroupFragment = exports.isAsymmetricFragment = exports.isAggregateFragment = exports.isDialectFragment = exports.isFilterFragment = exports.isOutputFieldFragment = exports.paramHasValue = void 0;
-exports.isValueDate = exports.isValueTimestamp = exports.isValueBoolean = exports.isValueNumber = exports.isValueString = exports.isMeasureLike = exports.getPhysicalFields = exports.getDimensions = exports.isPhysical = exports.isDimensional = exports.isAtomicField = exports.isTurtleDef = exports.getIdentifier = exports.isFieldStructDef = exports.isFieldTimeBased = exports.isFieldTypeDef = exports.isSQLBlockStruct = exports.mergeEvalSpaces = exports.isLiteral = exports.isSQLFragment = exports.isJoinOn = exports.isMatrixOperation = void 0;
+exports.isDimensional = exports.isAtomicField = exports.isTurtleDef = exports.getIdentifier = exports.isFieldStructDef = exports.isFieldTimeBased = exports.isFieldTypeDef = exports.isSQLBlockStruct = exports.mergeEvalSpaces = exports.isLiteral = exports.isSQLFragment = exports.isJoinOn = exports.isMatrixOperation = exports.isIndexSegment = exports.isRawSegment = exports.isSamplingEnable = exports.isSamplingPercent = exports.isSamplingRows = exports.isQuerySegment = exports.isProjectSegment = exports.isPartialSegment = exports.isReduceSegment = exports.structHasErrors = exports.segmentHasErrors = exports.refIsStructDef = exports.isByExpression = exports.isByName = exports.ValueType = exports.isExtractUnit = exports.isTimestampUnit = exports.isDateUnit = exports.FieldIsIntrinsic = exports.isCastType = exports.isAtomicFieldType = exports.isTimeFieldType = exports.hasExpression = exports.maxOfExpressionTypes = exports.maxExpressionType = exports.isExpressionTypeLEQ = exports.expressionIsAnalytic = exports.expressionIsCalculation = exports.expressionInvolvesAggregate = exports.expressionIsUngroupedAggregate = exports.expressionIsAggregate = exports.expressionIsScalar = exports.paramHasValue = exports.isAsymmetricExpr = exports.exprIsLeaf = exports.exprHasE = exports.exprHasKids = void 0;
+exports.isValueDate = exports.isValueTimestamp = exports.isValueBoolean = exports.isValueNumber = exports.isValueString = exports.isMeasureLike = exports.getPhysicalFields = exports.getDimensions = exports.isPhysical = void 0;
+function exprHasKids(e) {
+    return 'kids' in e;
+}
+exports.exprHasKids = exprHasKids;
+function exprHasE(e) {
+    return 'e' in e;
+}
+exports.exprHasE = exprHasE;
+function exprIsLeaf(e) {
+    return !(exprHasKids(e) || exprHasE(e));
+}
+exports.exprIsLeaf = exprIsLeaf;
+function isAsymmetricExpr(f) {
+    return (f.node === 'aggregate' &&
+        ['sum', 'avg', 'count', 'distinct'].includes(f.function));
+}
+exports.isAsymmetricExpr = isAsymmetricExpr;
 function paramHasValue(p) {
     return p.value !== null;
 }
 exports.paramHasValue = paramHasValue;
-function isOutputFieldFragment(f) {
-    return (f === null || f === void 0 ? void 0 : f.type) === 'outputField';
-}
-exports.isOutputFieldFragment = isOutputFieldFragment;
-function isFilterFragment(f) {
-    return (f === null || f === void 0 ? void 0 : f.type) === 'filterExpression';
-}
-exports.isFilterFragment = isFilterFragment;
-function isDialectFragment(f) {
-    return (f === null || f === void 0 ? void 0 : f.type) === 'dialect';
-}
-exports.isDialectFragment = isDialectFragment;
-function isAggregateFragment(f) {
-    return (f === null || f === void 0 ? void 0 : f.type) === 'aggregate';
-}
-exports.isAggregateFragment = isAggregateFragment;
-function isAsymmetricFragment(f) {
-    return isAggregateFragment(f) && ['sum', 'avg', 'count'].includes(f.function);
-}
-exports.isAsymmetricFragment = isAsymmetricFragment;
-function isUngroupFragment(f) {
-    const ftype = f === null || f === void 0 ? void 0 : f.type;
-    return ftype === 'all' || ftype === 'exclude';
-}
-exports.isUngroupFragment = isUngroupFragment;
-function isFunctionParameterFragment(f) {
-    return (f === null || f === void 0 ? void 0 : f.type) === 'function_parameter';
-}
-exports.isFunctionParameterFragment = isFunctionParameterFragment;
-function isFunctionCallFragment(f) {
-    return (f === null || f === void 0 ? void 0 : f.type) === 'function_call';
-}
-exports.isFunctionCallFragment = isFunctionCallFragment;
-function isSQLExpressionFragment(f) {
-    return (f === null || f === void 0 ? void 0 : f.type) === 'sql_expression';
-}
-exports.isSQLExpressionFragment = isSQLExpressionFragment;
-function isSpreadFragment(f) {
-    return (f === null || f === void 0 ? void 0 : f.type) === 'spread';
-}
-exports.isSpreadFragment = isSpreadFragment;
-function isFieldFragment(f) {
-    return (f === null || f === void 0 ? void 0 : f.type) === 'field';
-}
-exports.isFieldFragment = isFieldFragment;
-function isSqlStringFragment(f) {
-    return (f === null || f === void 0 ? void 0 : f.type) === 'sql-string';
-}
-exports.isSqlStringFragment = isSqlStringFragment;
-function isSourceReferenceFragment(f) {
-    return (f === null || f === void 0 ? void 0 : f.type) === 'source-reference';
-}
-exports.isSourceReferenceFragment = isSourceReferenceFragment;
-function isParameterFragment(f) {
-    return (f === null || f === void 0 ? void 0 : f.type) === 'parameter';
-}
-exports.isParameterFragment = isParameterFragment;
-function isApplyValue(f) {
-    return (f === null || f === void 0 ? void 0 : f.type) === 'applyVal';
-}
-exports.isApplyValue = isApplyValue;
-function isApplyFragment(f) {
-    return (f === null || f === void 0 ? void 0 : f.type) === 'apply';
-}
-exports.isApplyFragment = isApplyFragment;
-/**
- * Return an Expr based on the string template, subsittutions can be
- * either strings, or other Exprs.
-
- * ```
- * units = "inches"
- * len: Expr = [ "something", "returning", "a length "]
- * computeExpr = mkExpr`MEASURE(${len} in ${units})`;
- * ```
- */
-function mkExpr(src, ...exprs) {
-    const ret = [];
-    let index;
-    for (index = 0; index < exprs.length; index++) {
-        const el = exprs[index];
-        if (src[index].length > 0) {
-            ret.push(src[index]);
-        }
-        if (typeof el === 'string') {
-            ret.push(el);
-        }
-        else {
-            ret.push(...el);
-        }
-    }
-    if (src[index].length > 0) {
-        ret.push(src[index]);
-    }
-    return ret;
-}
-exports.mkExpr = mkExpr;
 function expressionIsScalar(e) {
     return e === undefined || e === 'scalar';
 }

package/dist/model/utils.d.ts

@@ -1,4 +1,4 @@
-import { Expr, Fragment } from './malloy_types';
+import { Expr, GenericSQLExpr } from './malloy_types';
 /** simple indent function */
 export declare function indent(s: string): string;
 /**
@@ -21,7 +21,14 @@ export declare class AndChain {
     sql(whereOrHaving?: 'where' | 'having'): string;
 }
 export declare function generateHash(input: string): string;
-export declare function exprMap(expr: Expr, func: (fragment: Fragment) => Expr): Expr;
-export declare function exprWalk(expr: Expr, func: (fragment: Fragment) => void): void;
 export declare function joinWith<T>(els: T[][], sep: T): T[];
 export declare function range(start: number, end: number): number[];
+export declare function exprKids(eNode: Expr): IterableIterator<Expr>;
+export declare function exprWalk(eNode: Expr, order?: 'pre' | 'post'): IterableIterator<Expr>;
+export declare function exprMap(eNode: Expr, mapFunc: (e: Expr) => Expr): Expr;
+export type SQLExprElement = string | Expr;
+/**
+ * Take a mixed array of strings and Expr and turn it into an SQLExpr
+ * expression node.
+ */
+export declare function composeSQLExpr(from: SQLExprElement[]): GenericSQLExpr;