@malloydata/malloy 0.0.1

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

@@ -0,0 +1,291 @@
+import { By, AtomicFieldType, FieldTypeDef, Fragment, TimeFieldType } from "../../model/malloy_types";
+import { FSPair, FieldSpace } from "../field-space";
+import { Filter, MalloyElement, ExprValue, FieldValueType, FragType } from "./index";
+import { FieldName, FieldReference } from "./ast-main";
+/**
+ * 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: FSPair): ExprValue;
+    legalChildTypes: 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: FSPair): 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: FSPair, 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;
+    private get constantFs();
+    constantValue(): ExprValue;
+    constantCondition(type: AtomicFieldType): ExprValue;
+    apply(fs: FSPair, op: string, expr: ExpressionDef): ExprValue;
+    requestExpression(fs: FSPair): 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: FSPair, exprName: string): FieldTypeDef;
+}
+export declare class TypeMistmatch extends Error {
+}
+export declare class ExprString extends ExpressionDef {
+    readonly value: string;
+    elementType: string;
+    constructor(value: string);
+    getExpression(_fs: FSPair): ExprValue;
+}
+export declare class ExprNumber extends ExpressionDef {
+    readonly n: string;
+    elementType: string;
+    constructor(n: string);
+    getExpression(_fs: FSPair): ExprValue;
+    constantExpression(): ExprValue;
+}
+export declare class ExprRegEx extends ExpressionDef {
+    readonly regex: string;
+    elementType: string;
+    constructor(regex: string);
+    getExpression(): ExprValue;
+}
+export declare class ExprTime extends ExpressionDef {
+    elementType: string;
+    readonly translationValue: ExprValue;
+    constructor(timeType: TimeFieldType, value: Fragment[] | string, aggregate?: boolean);
+    getExpression(_fs: FSPair): ExprValue;
+    static fromValue(timeType: TimeFieldType, expr: ExprValue): ExprTime;
+}
+declare abstract class Unary extends ExpressionDef {
+    readonly expr: ExpressionDef;
+    constructor(expr: ExpressionDef);
+}
+export declare class ExprNot extends Unary {
+    elementType: string;
+    legalChildTypes: FragType[];
+    constructor(expr: ExpressionDef);
+    getExpression(fs: FSPair): ExprValue;
+}
+export declare class Boolean extends ExpressionDef {
+    readonly value: "true" | "false";
+    elementType: string;
+    constructor(value: "true" | "false");
+    getExpression(): ExprValue;
+}
+export declare abstract class BinaryBoolean<opType extends string> extends ExpressionDef {
+    readonly left: ExpressionDef;
+    readonly op: opType;
+    readonly right: ExpressionDef;
+    elementType: string;
+    legalChildTypes: FragType[];
+    constructor(left: ExpressionDef, op: opType, right: ExpressionDef);
+    getExpression(fs: FSPair): ExprValue;
+}
+export declare class ExprLogicalOp extends BinaryBoolean<"and" | "or"> {
+    elementType: string;
+    legalChildTypes: FragType[];
+}
+export declare class ExprIdReference extends ExpressionDef {
+    readonly fieldReference: FieldReference;
+    elementType: string;
+    constructor(fieldReference: FieldReference);
+    get refString(): string;
+    getExpression(fs: FSPair): ExprValue;
+    apply(fs: FSPair, op: string, expr: ExpressionDef): ExprValue;
+}
+export declare class ExprNULL extends ExpressionDef {
+    elementType: string;
+    getExpression(): ExprValue;
+}
+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;
+}
+export declare class ExprMinus extends ExpressionDef {
+    readonly expr: ExpressionDef;
+    elementType: string;
+    constructor(expr: ExpressionDef);
+    getExpression(fs: FSPair): ExprValue;
+}
+export declare abstract class BinaryNumeric<opType extends string> extends ExpressionDef {
+    readonly left: ExpressionDef;
+    readonly op: opType;
+    readonly right: ExpressionDef;
+    elementType: string;
+    constructor(left: ExpressionDef, op: opType, right: ExpressionDef);
+    getExpression(fs: FSPair): ExprValue;
+}
+export declare class ExprAddSub extends BinaryNumeric<"+" | "-"> {
+    elementType: string;
+}
+export declare class ExprMulDiv extends BinaryNumeric<"*" | "/"> {
+    elementType: string;
+}
+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;
+}
+declare abstract class ExprAggregateFunction extends ExpressionDef {
+    readonly func: string;
+    elementType: string;
+    source?: FieldReference;
+    expr?: ExpressionDef;
+    legalChildTypes: FragType[];
+    constructor(func: string, expr?: ExpressionDef);
+    returns(_forExpression: ExprValue): FieldValueType;
+    getExpression(fs: FSPair): ExprValue;
+}
+export declare class ExprMin extends ExprAggregateFunction {
+    legalChildTypes: FragType[];
+    constructor(expr: ExpressionDef);
+    returns(forExpression: ExprValue): FieldValueType;
+}
+export declare class ExprMax extends ExprAggregateFunction {
+    legalChildTypes: FragType[];
+    constructor(expr: ExpressionDef);
+    returns(forExpression: ExprValue): FieldValueType;
+}
+export declare class ExprCountDistinct extends ExprAggregateFunction {
+    legalChildTypes: FragType[];
+    constructor(expr: ExpressionDef);
+}
+declare abstract class ExprAsymmetric extends ExprAggregateFunction {
+    readonly func: "sum" | "avg";
+    readonly expr: ExpressionDef | undefined;
+    readonly source?: FieldReference | undefined;
+    constructor(func: "sum" | "avg", expr: ExpressionDef | undefined, source?: FieldReference | undefined);
+    defaultFieldName(): undefined | string;
+}
+export declare class ExprCount extends ExprAggregateFunction {
+    readonly source?: FieldReference | undefined;
+    elementType: string;
+    constructor(source?: FieldReference | undefined);
+    defaultFieldName(): string | undefined;
+    getExpression(_fs: FSPair): ExprValue;
+}
+export declare class ExprAvg extends ExprAsymmetric {
+    constructor(expr: ExpressionDef | undefined, source?: FieldReference);
+}
+export declare class ExprSum extends ExprAsymmetric {
+    constructor(expr: ExpressionDef | undefined, source?: FieldReference);
+}
+export declare class ExprUngroup extends ExpressionDef {
+    readonly control: "all" | "exclude";
+    readonly expr: ExpressionDef;
+    readonly fields: FieldName[];
+    legalChildTypes: FragType[];
+    elementType: string;
+    constructor(control: "all" | "exclude", expr: ExpressionDef, fields: FieldName[]);
+    returns(_forExpression: ExprValue): FieldValueType;
+    getExpression(fs: FSPair): ExprValue;
+}
+export declare class WhenClause extends ExpressionDef {
+    readonly whenThis: ExpressionDef;
+    readonly thenThis: ExpressionDef;
+    elementType: string;
+    constructor(whenThis: ExpressionDef, thenThis: ExpressionDef);
+    getExpression(_fs: FSPair): 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;
+}
+export declare class ExprFilter extends ExpressionDef {
+    readonly expr: ExpressionDef;
+    readonly filter: Filter;
+    elementType: string;
+    legalChildTypes: FragType[];
+    constructor(expr: ExpressionDef, filter: Filter);
+    getExpression(fs: FSPair): ExprValue;
+}
+declare type CastType = "string" | "number" | "boolean" | "date" | "timestamp";
+export declare function isCastType(t: string): t is CastType;
+export declare class ExprCast extends ExpressionDef {
+    readonly expr: ExpressionDef;
+    readonly castType: CastType;
+    readonly safe: boolean;
+    elementType: string;
+    constructor(expr: ExpressionDef, castType: CastType, safe?: boolean);
+    getExpression(fs: FSPair): ExprValue;
+}
+export declare class TopBy extends MalloyElement {
+    readonly by: string | ExpressionDef;
+    elementType: string;
+    constructor(by: string | ExpressionDef);
+    getBy(fs: FSPair): 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;
+}
+export declare class PickWhen extends MalloyElement {
+    readonly pick: ExpressionDef | undefined;
+    readonly when: ExpressionDef;
+    elementType: string;
+    constructor(pick: ExpressionDef | undefined, when: ExpressionDef);
+}
+export declare class Pick extends ExpressionDef {
+    readonly choices: PickWhen[];
+    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;
+}
+export {};