@malloydata/malloy 0.0.1

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

@@ -0,0 +1,480 @@
+import * as model from "../../model/malloy_types";
+import { FieldSpace, FSPair, QuerySpace, LookupResult } from "../field-space";
+import { MalloyTranslation } from "../parse-malloy";
+import { ConstantSubExpression, ExpressionDef, FieldDeclaration } from "./index";
+import { SQLBlockRequest } from "../../model/sql_block";
+export declare class ErrorFactory {
+    static get structDef(): model.StructDef;
+    static isErrorStructDef(s: model.StructDef): boolean;
+    static get query(): model.Query;
+    static get reduceSegment(): model.ReduceSegment;
+    static get projectSegment(): model.ProjectSegment;
+    static get indexSegment(): model.IndexSegment;
+}
+declare type ChildBody = MalloyElement | MalloyElement[];
+declare type ElementChildren = Record<string, ChildBody>;
+export declare abstract class MalloyElement {
+    abstract elementType: string;
+    codeLocation?: model.DocumentLocation;
+    children: ElementChildren;
+    parent: MalloyElement | null;
+    private logger?;
+    /**
+     * @param kids All children passed to the constructor are not optional
+     */
+    constructor(kids?: ElementChildren);
+    /**
+     * Record all elements as children of this element, and mark this
+     * element as their parent.
+     * @param kids Some of these might be undefined, in which case they are ignored
+     */
+    has(kids: Record<string, ChildBody | undefined>): void;
+    get location(): model.DocumentLocation;
+    set location(loc: model.DocumentLocation | undefined);
+    protected namespace(): NameSpace | undefined;
+    modelEntry(reference: string | ModelEntryReference): ModelEntry | undefined;
+    private xlate?;
+    translator(): MalloyTranslation | undefined;
+    setTranslator(x: MalloyTranslation): void;
+    addReference(reference: model.DocumentReference): void;
+    private get sourceURL();
+    errorsExist(): boolean;
+    private logged;
+    log(message: string): void;
+    /**
+     * Mostly for debugging / testing. A string-y version of this object which
+     * is used to ask "are these two AST segments equal". Formatted so that
+     * errors would be human readable.
+     * @param indent only used for recursion
+     */
+    toString(): string;
+    private stringify;
+    walk(callBack: (node: MalloyElement) => void): void;
+    private varInfo;
+    protected internalError(msg: string): Error;
+}
+export declare class ListOf<ET extends MalloyElement> extends MalloyElement {
+    elementType: string;
+    private elements;
+    constructor(listDesc: string, elements: ET[]);
+    private newContents;
+    get list(): ET[];
+    empty(): boolean;
+    notEmpty(): boolean;
+    push(...el: ET[]): ET[];
+}
+export declare class Unimplemented extends MalloyElement {
+    elementType: string;
+    reported: boolean;
+}
+declare type FieldDecl = FieldDeclaration | Join | TurtleDecl | Turtles;
+export declare type ExploreField = FieldDecl | RenameField;
+export declare function isExploreField(f: MalloyElement): f is ExploreField;
+/**
+ * A "Mallobj" is a thing which you can run queries against, it has been called
+ * an "exploreable", or a "space".
+ */
+export declare abstract class Mallobj extends MalloyElement {
+    abstract structDef(): model.StructDef;
+    structRef(): model.StructRef;
+    withParameters(pList: HasParameter[] | undefined): model.StructDef;
+}
+export interface DocStatement extends MalloyElement {
+    execute(doc: Document): void;
+}
+export declare function isDocStatement(e: MalloyElement): e is DocStatement;
+export declare class DefineExplore extends MalloyElement implements DocStatement {
+    readonly name: string;
+    readonly mallobj: Mallobj;
+    readonly exported: boolean;
+    elementType: string;
+    readonly parameters?: HasParameter[];
+    constructor(name: string, mallobj: Mallobj, exported: boolean, params?: MalloyElement[]);
+    execute(doc: Document): void;
+}
+export declare class DefineSourceList extends ListOf<DefineExplore> implements DocStatement {
+    constructor(sourceList: DefineExplore[]);
+    execute(doc: Document): void;
+}
+/**
+ * A Mallobj made from a source and a set of refinements
+ */
+export declare class RefinedExplore extends Mallobj {
+    readonly source: Mallobj;
+    readonly refinement: ExploreDesc;
+    elementType: string;
+    constructor(source: Mallobj, refinement: ExploreDesc);
+    structDef(): model.StructDef;
+    withParameters(pList: HasParameter[] | undefined): model.StructDef;
+}
+export declare class TableSource extends Mallobj {
+    readonly name: string;
+    elementType: string;
+    constructor(name: string);
+    structDef(): model.StructDef;
+}
+export declare class IsValueBlock extends MalloyElement {
+    readonly isMap: Record<string, ConstantSubExpression>;
+    elementType: string;
+    constructor(isMap: Record<string, ConstantSubExpression>);
+}
+export declare class ModelEntryReference extends MalloyElement {
+    readonly name: string;
+    elementType: string;
+    constructor(name: string);
+    get refString(): string;
+    toString(): string;
+}
+export declare class NamedSource extends Mallobj {
+    readonly ref: ModelEntryReference | string;
+    elementType: string;
+    protected isBlock?: IsValueBlock;
+    constructor(ref: ModelEntryReference | string, paramValues?: Record<string, ConstantSubExpression>);
+    get refName(): string;
+    structRef(): model.StructRef;
+    modelStruct(): model.StructDef | undefined;
+    structDef(): model.StructDef;
+}
+export declare class SQLSource extends NamedSource {
+    elementType: string;
+    structRef(): model.StructRef;
+    modelStruct(): model.StructDef | undefined;
+}
+export declare class QuerySource extends Mallobj {
+    readonly query: QueryElement;
+    elementType: string;
+    constructor(query: QueryElement);
+    structDef(): model.StructDef;
+}
+export declare abstract class Join extends MalloyElement {
+    abstract name: ModelEntryReference;
+    abstract structDef(): model.StructDef;
+    abstract fixupJoinOn(outer: FSPair, inStruct: model.StructDef): void;
+}
+export declare class KeyJoin extends Join {
+    readonly name: ModelEntryReference;
+    readonly source: Mallobj;
+    readonly keyExpr: ExpressionDef;
+    elementType: string;
+    constructor(name: ModelEntryReference, source: Mallobj, keyExpr: ExpressionDef);
+    structDef(): model.StructDef;
+    fixupJoinOn(outer: FSPair, inStruct: model.StructDef): void;
+}
+declare type ExpressionJoinType = "many" | "one" | "cross";
+export declare class ExpressionJoin extends Join {
+    readonly name: ModelEntryReference;
+    readonly source: Mallobj;
+    elementType: string;
+    joinType: ExpressionJoinType;
+    private expr?;
+    constructor(name: ModelEntryReference, source: Mallobj);
+    set joinOn(joinExpr: ExpressionDef | undefined);
+    get joinOn(): ExpressionDef | undefined;
+    fixupJoinOn(outer: FSPair, inStruct: model.StructDef): model.Expr | undefined;
+    structDef(): model.StructDef;
+}
+export declare class Joins extends ListOf<Join> {
+    constructor(joins: Join[]);
+}
+export declare type QueryProperty = Ordering | Top | Limit | Filter | Index | SampleProperty | Joins | DeclareFields | ProjectStatement | NestReference | NestDefinition | NestReference | Nests | Aggregate | GroupBy;
+export declare function isQueryProperty(q: MalloyElement): q is QueryProperty;
+export declare type ExploreProperty = Filter | Joins | DeclareFields | FieldListEdit | Renames | PrimaryKey | Turtles;
+export declare function isExploreProperty(p: MalloyElement): p is ExploreProperty;
+export declare class ExploreDesc extends ListOf<ExploreProperty> {
+    constructor(props: ExploreProperty[]);
+}
+export declare class FilterElement extends MalloyElement {
+    readonly expr: ExpressionDef;
+    readonly exprSrc: string;
+    elementType: string;
+    constructor(expr: ExpressionDef, exprSrc: string);
+    filterExpression(fs: FSPair): model.FilterExpression;
+}
+export declare class Filter extends ListOf<FilterElement> {
+    elementType: string;
+    private havingClause?;
+    constructor(elements?: FilterElement[]);
+    set having(isHaving: boolean);
+    getFilterList(fs: FSPair): model.FilterExpression[];
+}
+export declare class DeclareFields extends ListOf<FieldDeclaration> {
+    constructor(fields: FieldDeclaration[], fieldType?: string);
+}
+export declare class Measures extends DeclareFields {
+    constructor(measures: FieldDeclaration[]);
+}
+export declare class Dimensions extends DeclareFields {
+    constructor(dimensions: FieldDeclaration[]);
+}
+export declare class Renames extends ListOf<RenameField> {
+    constructor(renames: RenameField[]);
+}
+export declare class FieldName extends MalloyElement {
+    readonly name: string;
+    elementType: string;
+    constructor(name: string);
+    get refString(): string;
+    toString(): string;
+    getField(fs: FSPair): LookupResult;
+}
+export declare class FieldReference extends ListOf<FieldName> {
+    elementType: string;
+    constructor(names: FieldName[]);
+    get refString(): string;
+    get outputName(): string;
+    get sourceString(): string | undefined;
+    get nameString(): string;
+    getField(fs: FieldSpace): LookupResult;
+}
+export declare type FieldReferenceElement = FieldReference | WildcardFieldReference;
+export declare class FieldReferences extends ListOf<FieldReferenceElement> {
+    constructor(members: FieldReferenceElement[]);
+}
+export declare type FieldCollectionMember = FieldReferenceElement | FieldDeclaration;
+export declare function isFieldCollectionMember(el: MalloyElement): el is FieldCollectionMember;
+export declare class ProjectStatement extends ListOf<FieldCollectionMember> {
+    constructor(members: FieldCollectionMember[]);
+}
+export declare class FieldListEdit extends MalloyElement {
+    readonly edit: "accept" | "except";
+    readonly refs: FieldReferences;
+    elementType: string;
+    constructor(edit: "accept" | "except", refs: FieldReferences);
+}
+export declare type QueryItem = FieldDeclaration | FieldReference | NestDefinition | NestReference;
+export declare class GroupBy extends ListOf<QueryItem> {
+    constructor(members: QueryItem[]);
+}
+export declare class Aggregate extends ListOf<QueryItem> {
+    constructor(members: QueryItem[]);
+}
+interface OpDesc {
+    segment: model.PipeSegment;
+    outputSpace: () => FieldSpace;
+}
+declare type QOPType = "grouping" | "aggregate" | "project" | "index";
+export declare class QOPDesc extends ListOf<QueryProperty> {
+    opType: QOPType;
+    private refineThis?;
+    constructor(props: QueryProperty[]);
+    protected computeType(): QOPType;
+    refineFrom(existing: model.PipeSegment): void;
+    private getExecutor;
+    getOp(inputFS: FieldSpace, forPipeline: PipelineDesc | null): OpDesc;
+}
+export interface ModelEntry {
+    entry: model.NamedModelObject | model.SQLBlock;
+    exported?: boolean;
+}
+export interface NameSpace {
+    getEntry(name: string): ModelEntry | undefined;
+    setEntry(name: string, value: ModelEntry, exported: boolean): void;
+}
+export declare class Document extends MalloyElement implements NameSpace {
+    readonly statements: DocStatement[];
+    elementType: string;
+    documentModel: Record<string, ModelEntry>;
+    queryList: model.Query[];
+    sqlBlocks: model.SQLBlock[];
+    constructor(statements: DocStatement[]);
+    getModelDef(extendingModelDef: model.ModelDef | undefined): model.ModelDef;
+    defineSQL(sql: model.SQLBlock, name?: string): boolean;
+    getEntry(str: string): ModelEntry;
+    setEntry(str: string, ent: ModelEntry): void;
+}
+export declare class PrimaryKey extends MalloyElement {
+    readonly field: FieldName;
+    elementType: string;
+    constructor(field: FieldName);
+}
+export declare class RenameField extends MalloyElement {
+    readonly newName: string;
+    readonly oldName: FieldName;
+    elementType: string;
+    constructor(newName: string, oldName: FieldName);
+}
+export declare class WildcardFieldReference extends MalloyElement {
+    readonly joinPath: FieldReference | undefined;
+    readonly star: "*" | "**";
+    elementType: string;
+    constructor(joinPath: FieldReference | undefined, star: "*" | "**");
+    getFieldDef(): model.FieldDef;
+    get refString(): string;
+}
+export declare class OrderBy extends MalloyElement {
+    readonly field: number | FieldName;
+    readonly dir?: "asc" | "desc" | undefined;
+    elementType: string;
+    constructor(field: number | FieldName, dir?: "asc" | "desc" | undefined);
+    get modelField(): string | number;
+    getOrderBy(_fs: FSPair): model.OrderBy;
+}
+export declare class Ordering extends ListOf<OrderBy> {
+    constructor(list: OrderBy[]);
+    getOrderBy(fs: FSPair): model.OrderBy[];
+}
+export declare class Limit extends MalloyElement {
+    readonly limit: number;
+    elementType: string;
+    constructor(limit: number);
+}
+export declare class Turtles extends ListOf<TurtleDecl> {
+    constructor(turtles: TurtleDecl[]);
+}
+export declare class Index extends MalloyElement {
+    readonly fields: FieldReferences;
+    elementType: string;
+    weightBy?: FieldName;
+    constructor(fields: FieldReferences);
+    useWeight(fn: FieldName): void;
+}
+interface QueryComp {
+    outputStruct: model.StructDef;
+    query: model.Query;
+}
+/**
+ * Generic abstract for all pipelines, the first segment might be a reference
+ * to an existing pipeline (query or turtle), and if there is a refinement it
+ * is refers to the first segment of the composed pipeline.
+ */
+declare abstract class PipelineDesc extends MalloyElement {
+    elementType: string;
+    protected headRefinement?: QOPDesc;
+    protected qops: QOPDesc[];
+    nestedInQuerySpace?: QuerySpace;
+    refineHead(refinement: QOPDesc): void;
+    addSegments(...segDesc: QOPDesc[]): void;
+    protected appendOps(modelPipe: model.PipeSegment[], existingEndSpace: FieldSpace): {
+        opList: model.PipeSegment[];
+        structDef: model.StructDef;
+    };
+    protected refinePipeline(fs: FieldSpace, modelPipe: model.Pipeline): model.Pipeline;
+    protected expandTurtle(turtleName: string, fromStruct: model.StructDef): {
+        pipeline: model.PipeSegment[];
+        location: model.DocumentLocation | undefined;
+    };
+    protected getOutputStruct(walkStruct: model.StructDef, pipeline: model.PipeSegment[]): model.StructDef;
+}
+export declare class ExistingQuery extends PipelineDesc {
+    _head?: ModelEntryReference;
+    set head(head: ModelEntryReference | undefined);
+    get head(): ModelEntryReference | undefined;
+    queryComp(): QueryComp;
+    query(): model.Query;
+}
+export declare abstract class TurtleHeadedPipe extends PipelineDesc {
+    _turtleName?: FieldName;
+    set turtleName(turtleName: FieldName | undefined);
+    get turtleName(): FieldName | undefined;
+}
+export declare class FullQuery extends TurtleHeadedPipe {
+    readonly explore: Mallobj;
+    constructor(explore: Mallobj);
+    queryComp(): QueryComp;
+    query(): model.Query;
+}
+export declare class TurtleDecl extends TurtleHeadedPipe {
+    readonly name: string;
+    constructor(name: string);
+    getPipeline(fs: FSPair): model.Pipeline;
+    getFieldDef(inSpace: FieldSpace, nestParent: QuerySpace | undefined): model.TurtleDef;
+}
+export declare class NestReference extends FieldReference {
+    readonly name: FieldName;
+    elementType: string;
+    constructor(name: FieldName);
+}
+export declare class NestRefinement extends TurtleDecl {
+    elementType: string;
+    constructor(turtleName: FieldName);
+}
+export declare class NestDefinition extends TurtleDecl {
+    elementType: string;
+    constructor(name: string);
+}
+export declare type NestedQuery = NestReference | NestDefinition | NestRefinement;
+export declare function isNestedQuery(me: MalloyElement): me is NestedQuery;
+export declare class Nests extends ListOf<NestedQuery> {
+    constructor(nests: NestedQuery[]);
+}
+export declare type QueryElement = FullQuery | ExistingQuery;
+export declare function isQueryElement(e: MalloyElement): e is QueryElement;
+export declare class DefineQueryList extends ListOf<DefineQuery> implements DocStatement {
+    constructor(queryList: DefineQuery[]);
+    execute(doc: Document): void;
+}
+export declare class DefineQuery extends MalloyElement implements DocStatement {
+    readonly name: string;
+    readonly queryDetails: QueryElement;
+    elementType: string;
+    constructor(name: string, queryDetails: QueryElement);
+    execute(doc: Document): void;
+}
+export declare class AnonymousQuery extends MalloyElement implements DocStatement {
+    readonly theQuery: QueryElement;
+    elementType: string;
+    constructor(theQuery: QueryElement);
+    execute(doc: Document): void;
+}
+declare type TopInit = FieldName | ExpressionDef;
+export declare class Top extends MalloyElement {
+    readonly limit: number;
+    readonly by?: TopInit | undefined;
+    elementType: string;
+    constructor(limit: number, by?: TopInit | undefined);
+    getBy(fs: FSPair): model.By | undefined;
+}
+export declare class JSONElement extends MalloyElement {
+    elementType: string;
+    readonly value: any;
+    constructor(jsonSrc: string);
+}
+export declare class JSONStructDef extends Mallobj {
+    readonly struct: model.StructDef;
+    elementType: string;
+    constructor(struct: model.StructDef);
+    static fromJSON(jsonObj: JSONElement): JSONStructDef | undefined;
+    structDef(): model.StructDef;
+}
+export declare class ImportStatement extends MalloyElement implements DocStatement {
+    readonly url: string;
+    elementType: string;
+    fullURL?: string;
+    constructor(url: string, baseURL: string);
+    execute(doc: Document): void;
+}
+interface HasInit {
+    name: string;
+    isCondition: boolean;
+    type?: string;
+    default?: ConstantSubExpression;
+}
+export declare class HasParameter extends MalloyElement {
+    elementType: string;
+    readonly name: string;
+    readonly isCondition: boolean;
+    readonly type?: model.AtomicFieldType;
+    readonly default?: ConstantSubExpression;
+    constructor(init: HasInit);
+    parameter(): model.Parameter;
+}
+export declare class ConstantParameter extends HasParameter {
+    readonly value: ConstantSubExpression;
+    constructor(name: string, value: ConstantSubExpression);
+    parameter(): model.Parameter;
+}
+export declare class SQLStatement extends MalloyElement implements DocStatement {
+    readonly blockReq: SQLBlockRequest;
+    elementType: string;
+    is?: string;
+    constructor(blockReq: SQLBlockRequest);
+    sqlBlock(): model.SQLBlock;
+    execute(doc: Document): void;
+}
+export declare class SampleProperty extends MalloyElement {
+    readonly sample: model.Sampling;
+    elementType: string;
+    constructor(sample: model.Sampling);
+    sampling(): model.Sampling;
+}
+export {};