@malloydata/malloy 0.0.22-dev230117223957 → 0.0.22-dev230119001546

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

@@ -1,7 +1,8 @@
 import * as model from "../../model/malloy_types";
+import { AtomicFieldType, ExpressionType, FieldTypeDef, Fragment, TimeFieldType, TimestampUnit } from "../../model/malloy_types";
 import { FieldSpace, QuerySpace, LookupResult } from "../field-space";
 import { MalloyTranslation, ModelDataRequest } from "../parse-malloy";
-import { ConstantSubExpression, ExpressionDef, FieldDeclaration } from "./index";
+import { Comparison, ExprValue } from "./ast-types";
 export declare class ErrorFactory {
     static get structDef(): model.StructDef;
     static isErrorStructDef(s: model.StructDef): boolean;
@@ -518,4 +519,143 @@ export declare class SampleProperty extends MalloyElement {
     constructor(sample: model.Sampling);
     sampling(): model.Sampling;
 }
+/**
+ * Root node for any element in an expression. These essentially
+ * create a sub-tree in the larger AST. Expression nodes know
+ * how to write themselves as SQL (or rather, generate the
+ * template for SQL required by the query writer)
+ */
+export declare abstract class ExpressionDef extends MalloyElement {
+    abstract elementType: string;
+    granular(): boolean;
+    /**
+     * Returns the "translation" or template for SQL generation. When asking
+     * for a tranlsation you may pass the types you can accept, allowing
+     * the translation code a chance to convert to match your expectations
+     * @param space Namespace for looking up field references
+     */
+    abstract getExpression(fs: FieldSpace): ExprValue;
+    legalChildTypes: import("./ast-types").FragType[];
+    /**
+     * Some operators want to give the right hand value a chance to
+     * rewrite itself. This requests a translation for a rewrite,
+     * or returns undefined if that request should be denied.
+     * @param fs FieldSpace
+     * @returns Translated expression or undefined
+     */
+    requestExpression(fs: FieldSpace): ExprValue | undefined;
+    defaultFieldName(): string | undefined;
+    /**
+     * Check an expression for type compatibility
+     * @param _eNode currently unused, will be used to get error location
+     * @param eVal ...list of expressions that must match legalChildTypes
+     */
+    typeCheck(eNode: ExpressionDef, eVal: ExprValue): boolean;
+    /**
+     * This is the operation which makes partial comparison and value trees work
+     * The default implemention merely constructs LEFT OP RIGHT, but specialized
+     * nodes like alternation trees or or partial comparison can control how
+     * the appplication gets generated
+     * @param fs The symbol table
+     * @param op The operator being applied
+     * @param expr The "other" (besdies 'this') value
+     * @returns The translated expression
+     */
+    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: FieldSpace): ExprValue;
+    private get constantFs();
+    constantValue(): ExprValue;
+    constantCondition(type: AtomicFieldType): ExprValue;
+    apply(fs: FieldSpace, op: string, expr: ExpressionDef): ExprValue;
+    requestExpression(fs: FieldSpace): ExprValue | undefined;
+}
+export declare class FieldDeclaration extends MalloyElement {
+    readonly expr: ExpressionDef;
+    readonly defineName: string;
+    readonly exprSrc?: string | undefined;
+    elementType: string;
+    isMeasure?: boolean;
+    constructor(expr: ExpressionDef, defineName: string, exprSrc?: string | undefined);
+    fieldDef(fs: FieldSpace, exprName: string): FieldTypeDef;
+    queryFieldDef(exprFS: FieldSpace, exprName: string): FieldTypeDef;
+}
+/**
+ * All of the magic of malloy expressions eventually flows to here,
+ * where an operator is applied to two values. Depending on the
+ * operator and value types this may involve transformations of
+ * the values or even the operator.
+ * @param fs FieldSpace for the symbols
+ * @param left Left value
+ * @param op The operator
+ * @param right Right Value
+ * @returns ExprValue of the expression
+ */
+export declare function applyBinary(fs: FieldSpace, left: ExpressionDef, op: string, right: ExpressionDef): ExprValue;
+export declare abstract class BinaryBoolean<opType extends string> extends ExpressionDef {
+    readonly left: ExpressionDef;
+    readonly op: opType;
+    readonly right: ExpressionDef;
+    elementType: string;
+    legalChildTypes: import("./ast-types").FragType[];
+    constructor(left: ExpressionDef, op: opType, right: ExpressionDef);
+    getExpression(fs: FieldSpace): ExprValue;
+}
+export declare class ExprCompare extends BinaryBoolean<Comparison> {
+    elementType: string;
+    constructor(left: ExpressionDef, op: Comparison, right: ExpressionDef);
+    getExpression(fs: FieldSpace): ExprValue;
+}
+/**
+ * GranularTime is a moment in time which ALSO has a "granularity"
+ * commonly this are created by applying ".datePart" to an expression
+ * 1) They have a value, which is the moment in time
+ * 2) When used in a comparison, they act like a range, for the
+ *    duration of 1 unit of granularity
+ */
+export declare class ExprGranularTime extends ExpressionDef {
+    readonly expr: ExpressionDef;
+    readonly units: TimestampUnit;
+    readonly truncate: boolean;
+    elementType: string;
+    legalChildTypes: import("./ast-types").FragType[];
+    constructor(expr: ExpressionDef, units: TimestampUnit, truncate: boolean);
+    granular(): boolean;
+    getExpression(fs: FieldSpace): ExprValue;
+    apply(fs: FieldSpace, op: string, left: ExpressionDef): ExprValue;
+    protected timestampRange(fs: FieldSpace, op: string, expr: ExpressionDef): ExprValue;
+    protected dateRange(fs: FieldSpace, op: string, expr: ExpressionDef): ExprValue;
+}
+export declare class TypeMistmatch extends Error {
+}
+export declare class ExprDuration extends ExpressionDef {
+    readonly n: ExpressionDef;
+    readonly timeframe: TimestampUnit;
+    elementType: string;
+    legalChildTypes: import("./ast-types").FragType[];
+    constructor(n: ExpressionDef, timeframe: TimestampUnit);
+    apply(fs: FieldSpace, op: string, left: ExpressionDef): ExprValue;
+    getExpression(_fs: FieldSpace): ExprValue;
+}
+export declare class ExprTime extends ExpressionDef {
+    elementType: string;
+    readonly translationValue: ExprValue;
+    constructor(timeType: TimeFieldType, value: Fragment[] | string, expressionType?: ExpressionType);
+    getExpression(_fs: FieldSpace): ExprValue;
+    static fromValue(timeType: TimeFieldType, expr: ExprValue): ExprTime;
+}
+export declare class Range extends ExpressionDef {
+    readonly first: ExpressionDef;
+    readonly last: ExpressionDef;
+    elementType: string;
+    constructor(first: ExpressionDef, last: ExpressionDef);
+    apply(fs: FieldSpace, op: string, expr: ExpressionDef): ExprValue;
+    requestExpression(_fs: FieldSpace): ExprValue | undefined;
+    getExpression(_fs: FieldSpace): ExprValue;
+}
 export {};