@malloydata/malloy 0.0.1

package/dist/model/malloy_query.d.ts

@@ -0,0 +1,353 @@
+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 } from "./malloy_types";
+import { AndChain } from "./utils";
+import { ResultStructMetadataDef, SearchIndexResult } from ".";
+import { Connection } from "..";
+interface TurtleDefPlus extends TurtleDef, Filtered {
+}
+interface OutputPipelinedSQL {
+    sqlFieldName: string;
+    pipelineSQL: string;
+}
+declare class StageWriter {
+    withs: string[];
+    udfs: string[];
+    pdts: string[];
+    stagePrefix: string;
+    parent: StageWriter | undefined;
+    useCTE: boolean;
+    constructor(useCTE: boolean | undefined, parent: StageWriter | undefined);
+    getName(id: number): string;
+    root(): StageWriter;
+    addStage(sql: string): string;
+    addUDF(stageWriter: StageWriter, dialect: Dialect, structDef: StructDef): string;
+    addPDT(baseName: string, dialect: Dialect): string;
+    combineStages(includeLastStage: boolean): {
+        sql: string;
+        lastStageName: string | undefined;
+    };
+    /** emit the SQL for all the stages.  */
+    generateSQLStages(): string;
+    generateCoorelatedSubQuery(dialect: Dialect, structDef: StructDef): string;
+}
+declare type QuerySomething = QueryField | QueryStruct | QueryTurtle;
+declare class GenerateState {
+    whereSQL?: string;
+    applyValue?: string;
+    totalGroupSet: number;
+    withWhere(s?: string): GenerateState;
+    withApply(s: string): GenerateState;
+    withTotal(groupSet: number): GenerateState;
+}
+declare abstract class QueryNode {
+    fieldDef: FieldDef;
+    constructor(fieldDef: FieldDef);
+    getIdentifier(): string;
+    getChildByName(_name: string): QuerySomething | undefined;
+}
+declare class QueryField extends QueryNode {
+    fieldDef: FieldDef;
+    parent: QueryStruct;
+    constructor(fieldDef: FieldDef, parent: QueryStruct);
+    mayNeedUniqueKey(): boolean;
+    getJoinableParent(): QueryStruct;
+    caseGroup(groupSets: number[], s: string): string;
+    getFullOutputName(): string;
+    generateFieldFragment(resultSet: FieldInstanceResult, context: QueryStruct, expr: FieldFragment, state: GenerateState): string;
+    generateParameterFragment(resultSet: FieldInstanceResult, context: QueryStruct, expr: ParameterFragment, state: GenerateState): string;
+    generateFilterFragment(resultSet: FieldInstanceResult, context: QueryStruct, expr: FilterFragment, state: GenerateState): string;
+    generateDimFragment(resultSet: FieldInstanceResult, context: QueryStruct, expr: AggregateFragment, state: GenerateState): string;
+    generateUngroupedFragment(resultSet: FieldInstanceResult, context: QueryStruct, expr: UngroupFragment, state: GenerateState): string;
+    generateDistinctKeyIfNecessary(resultSet: FieldInstanceResult, context: QueryStruct, structPath: string | undefined): string | undefined;
+    generateSumFragment(resultSet: FieldInstanceResult, context: QueryStruct, expr: AggregateFragment, state: GenerateState): string;
+    generateSymmetricFragment(resultSet: FieldInstanceResult, context: QueryStruct, expr: AggregateFragment, state: GenerateState): string;
+    generateAvgFragment(resultSet: FieldInstanceResult, context: QueryStruct, expr: AggregateFragment, state: GenerateState): string;
+    generateCountFragment(resultSet: FieldInstanceResult, context: QueryStruct, expr: AggregateFragment, state: GenerateState): string;
+    generateDialect(resultSet: FieldInstanceResult, context: QueryStruct, expr: DialectFragment, state: GenerateState): string;
+    generateExpressionFromExpr(resultSet: FieldInstanceResult, context: QueryStruct, e: Expr, state?: GenerateState): string;
+    getExpr(): Expr;
+    generateExpression(resultSet: FieldInstanceResult): string;
+}
+declare class QueryAtomicField extends QueryField {
+    includeInWildcard(): boolean;
+    isAggregate(): boolean;
+    getFilterList(): FilterExpression[];
+    hasExpression(): boolean;
+}
+declare class QueryFieldBoolean extends QueryAtomicField {
+}
+declare class QueryFieldStruct extends QueryAtomicField {
+    primaryKey: string;
+    constructor(fieldDef: FieldDef, parent: QueryStruct, primaryKey: string);
+    getName(): string;
+    getAsJoinedStructDef(foreignKeyName: string): StructDef;
+}
+declare type FieldUsage = {
+    type: "result";
+    resultIndex: number;
+} | {
+    type: "where";
+} | {
+    type: "dependant";
+};
+declare type FieldInstanceType = "field" | "query";
+interface FieldInstance {
+    type: FieldInstanceType;
+    root(): FieldInstanceResultRoot;
+}
+declare class FieldInstanceField implements FieldInstance {
+    type: FieldInstanceType;
+    f: QueryField;
+    fieldUsage: FieldUsage;
+    additionalGroupSets: number[];
+    parent: FieldInstanceResult;
+    partitionSQL: string | undefined;
+    constructor(f: QueryField, fieldUsage: FieldUsage, parent: FieldInstanceResult);
+    root(): FieldInstanceResultRoot;
+    getSQL(): string;
+    getPartitionSQL(): string;
+}
+declare type RepeatedResultType = "nested" | "inline_all_numbers" | "inline";
+declare type UngroupSet = {
+    type: "all" | "exclude";
+    fields: string[];
+    groupSet: number;
+};
+declare class FieldInstanceResult implements FieldInstance {
+    type: FieldInstanceType;
+    allFields: Map<string, FieldInstance>;
+    groupSet: number;
+    depth: number;
+    parent: FieldInstanceResult | undefined;
+    childGroups: number[];
+    turtleDef: TurtleDef;
+    firstSegment: PipeSegment;
+    hasHaving: boolean;
+    ungroupedSets: Map<string, UngroupSet>;
+    resultUsesUngrouped: boolean;
+    constructor(turtleDef: TurtleDef, parent: FieldInstanceResult | undefined);
+    addField(as: string, field: QueryField, usage: FieldUsage): void;
+    parentGroupSet(): number;
+    add(name: string, f: FieldInstance): void;
+    hasField(name: string): boolean;
+    getField(name: string): FieldInstanceField;
+    getFieldByNumber(index: number): {
+        name: string;
+        fif: FieldInstanceField;
+    };
+    computeGroups(nextGroupSetNumber: number, depth: number): {
+        nextGroupSetNumber: number;
+        maxDepth: number;
+        children: number[];
+        isComplex: boolean;
+    };
+    fields(fn?: undefined | ((field: FieldInstanceField) => boolean)): FieldInstanceField[];
+    fieldNames(fn: undefined | ((field: FieldInstanceField) => boolean)): string[];
+    getRepeatedResultType(): RepeatedResultType;
+    structs(): FieldInstanceResult[];
+    selectStructs(result: FieldInstanceResult[], fn: (result: FieldInstanceResult) => boolean): FieldInstanceResult[];
+    calculateDefaultOrderBy(): OrderBy[];
+    addStructToJoin(qs: QueryStruct, query: QueryQuery, mayNeedUniqueKey: boolean, joinStack: string[]): void;
+    findJoins(query: QueryQuery): void;
+    root(): FieldInstanceResultRoot;
+    getUngroupPartitions(ungroupSet: UngroupSet | undefined): FieldInstanceField[];
+    assignFieldsToGroups(): void;
+}
+declare class FieldInstanceResultRoot extends FieldInstanceResult {
+    joins: Map<string, JoinInstance>;
+    havings: AndChain;
+    isComplexQuery: boolean;
+    queryUsesUngrouped: boolean;
+    computeOnlyGroups: number[];
+    elimatedComputeGroups: boolean;
+    constructor(turtleDef: TurtleDef);
+    root(): FieldInstanceResultRoot;
+    eliminateComputeGroupsSQL(): string;
+    calculateSymmetricAggregates(): void;
+}
+declare class JoinInstance {
+    mayNeedUniqueKey: boolean;
+    makeUniqueKey: boolean;
+    leafiest: boolean;
+    parent: JoinInstance | undefined;
+    queryStruct: QueryStruct;
+    joinFilterConditions?: QueryFieldBoolean[];
+    alias: string;
+    children: JoinInstance[];
+    constructor(queryStruct: QueryStruct, alias: string, parent: JoinInstance | undefined);
+    parentRelationship(): "root" | JoinRelationship;
+    getDialectFieldList(): DialectFieldList;
+}
+/** nested query */
+declare class QueryTurtle extends QueryField {
+}
+/**
+ * Used by the translator to get the output StructDef of a pipe segment
+ *
+ * half translated to the new world of types ..
+ */
+export declare class Segment {
+    static nextStructDef(structDef: StructDef, segment: PipeSegment): StructDef;
+}
+declare type StageGroupMaping = {
+    fromGroup: number;
+    toGroup: number;
+};
+declare type StageOutputContext = {
+    sql: string[];
+    lateralJoinSQLExpressions: string[];
+    dimensionIndexes: number[];
+    fieldIndex: number;
+    groupsAggregated: StageGroupMaping[];
+    outputPipelinedSQL: OutputPipelinedSQL[];
+};
+/** Query builder object. */
+declare class QueryQuery extends QueryField {
+    fieldDef: TurtleDef;
+    firstSegment: PipeSegment;
+    prepared: boolean;
+    maxDepth: number;
+    maxGroupSet: number;
+    rootResult: FieldInstanceResultRoot;
+    resultStage: string | undefined;
+    stageWriter: StageWriter | undefined;
+    constructor(fieldDef: TurtleDef, parent: QueryStruct, stageWriter: StageWriter | undefined);
+    static makeQuery(fieldDef: TurtleDef, parentStruct: QueryStruct, stageWriter?: StageWriter | undefined): QueryQuery;
+    getFieldList(): QueryFieldDef[];
+    expandField(f: QueryFieldDef): {
+        as: string;
+        field: QuerySomething;
+    };
+    expandDependantField(resultStruct: FieldInstanceResult, fieldRef: FieldRef): void;
+    expandWildCardStruct(struct: QueryStruct, expandChildren: boolean, filter?: ((qf: QueryNode) => boolean) | undefined): string[];
+    expandWildCards(fields: QueryFieldDef[], filter?: ((qf: QueryNode) => boolean) | undefined): QueryFieldDef[];
+    addDependantPath(resultStruct: FieldInstanceResult, context: QueryStruct, path: string, mayNeedUniqueKey: boolean, joinStack: string[]): void;
+    addDependantExpr(resultStruct: FieldInstanceResult, context: QueryStruct, e: Expr, joinStack: string[]): void;
+    addDependancies(resultStruct: FieldInstanceResult, field: QueryField): void;
+    expandFields(resultStruct: FieldInstanceResult): void;
+    expandFilters(resultStruct: FieldInstanceResult): void;
+    generateSQLFilters(resultStruct: FieldInstanceResult, which: "where" | "having", filterList?: FilterExpression[] | undefined): AndChain;
+    prepare(_stageWriter: StageWriter | undefined): void;
+    getResultMetadata(fi: FieldInstance): ResultStructMetadataDef | ResultMetadataDef | undefined;
+    /**  returns a fields and primary key of a struct for this query */
+    getResultStructDef(resultStruct?: FieldInstanceResult, isRoot?: boolean): StructDef;
+    generateSQLJoinBlock(stageWriter: StageWriter, ji: JoinInstance): string;
+    generateSQLJoins(stageWriter: StageWriter): string;
+    genereateSQLOrderBy(queryDef: QuerySegment, resultStruct: FieldInstanceResult): string;
+    generateSimpleSQL(stageWriter: StageWriter): string;
+    generatePipelinedStages(outputPipelinedSQL: OutputPipelinedSQL[], lastStageName: string, stageWriter: StageWriter): string;
+    generateStage0Fields(resultSet: FieldInstanceResult, output: StageOutputContext, stageWriter: StageWriter): void;
+    generateSQLWhereChildren(resultStruct: FieldInstanceResult): AndChain;
+    generateSQLWhereTurtled(): string;
+    generateSQLHavingLimit(stageWriter: StageWriter, lastStageName: string): string;
+    generateSQLStage0(stageWriter: StageWriter): string;
+    generateDepthNFields(depth: number, resultSet: FieldInstanceResult, output: StageOutputContext, stageWriter: StageWriter): void;
+    generateSQLDepthN(depth: number, stageWriter: StageWriter, stageName: string): string;
+    genereateSQLCombineTurtles(stageWriter: StageWriter, stage0Name: string): string;
+    generateTurtleSQL(resultStruct: FieldInstanceResult, stageWriter: StageWriter, sqlFieldName: string, outputPipelinedSQL: OutputPipelinedSQL[]): string;
+    generateTurtlePipelineSQL(fi: FieldInstanceResult, stageWriter: StageWriter, sourceSQLExpression: string): {
+        structDef: StructDef;
+        pipeOut: {
+            lastStageName: string;
+            outputStruct: StructDef;
+        } | undefined;
+    };
+    generateComplexSQL(stageWriter: StageWriter): string;
+    generateSQL(stageWriter: StageWriter): string;
+    toMalloy(): string;
+    generateSQLFromPipeline(stageWriter: StageWriter): {
+        lastStageName: string;
+        outputStruct: StructDef;
+    };
+}
+/** Structure object as it is used to build a query */
+declare class QueryStruct extends QueryNode {
+    fieldDef: StructDef;
+    parent: QueryStruct | undefined;
+    model: QueryModel;
+    nameMap: Map<string, QuerySomething>;
+    pathAliasMap: Map<string, string>;
+    dialect: Dialect;
+    connectionName: string;
+    constructor(fieldDef: StructDef, parent: {
+        struct: QueryStruct;
+    } | {
+        model: QueryModel;
+    });
+    parameters(): Record<string, Parameter>;
+    addFieldsFromFieldList(fields: FieldDef[]): void;
+    getAliasIdentifier(): string;
+    getAsQueryField(): QueryFieldStruct;
+    getSQLIdentifier(): string;
+    getIdentifier(): string;
+    getFullOutputName(): string;
+    needsSymetricCalculation(resultSet: FieldInstanceResult): boolean;
+    unnestWithNumbers(): boolean;
+    getJoinableParent(): QueryStruct;
+    addFieldToNameMap(as: string, n: QuerySomething): void;
+    /** the the primary key or throw an error. */
+    getPrimaryKeyField(fieldDef: FieldDef): QueryAtomicField;
+    /**
+     * called after all structure has been loaded.  Examine this structure to see
+     * if if it is based on a query and if it is, add the output fields (unless
+     * they exist) to the structure.
+     */
+    resolveQueryFields(): void;
+    getModel(): QueryModel;
+    setParent(parent: {
+        struct: QueryStruct;
+    } | {
+        model: QueryModel;
+    }): void;
+    /** makes a new queryable field object from a fieldDef */
+    makeQueryField(field: FieldDef): QueryField;
+    /**
+     * return a field if it exists, make one if we are passed a field definition.
+     */
+    getOrMakeField(fieldRef: FieldRef): QuerySomething;
+    /** returns a dimension for the given name  or make one. */
+    getOrMakeDimension(fieldRef: FieldRef): QueryAtomicField;
+    structSourceSQL(stageWriter: StageWriter): string;
+    root(): QueryStruct;
+    primaryKey(): QueryAtomicField | undefined;
+    /** get the componennts of a field path */
+    static resolvePath(name: string): string[];
+    getChildByName(name: string): QuerySomething | undefined;
+    /** convert a name into a field reference */
+    getFieldByName(name: string): QuerySomething;
+    getQueryFieldByName(name: string): QuerySomething;
+    getDimensionOrMeasureByName(name: string): QueryAtomicField;
+    /** returns a query object for the given name */
+    getDimensionByName(name: string): QueryAtomicField;
+    /** returns a query object for the given name */
+    getStructByName(name: string): QueryStruct;
+    getDistinctKey(): QueryAtomicField;
+    flattenTurtleDef(turtleDef: TurtleDef | TurtleDefPlus): TurtleDef;
+}
+/** the resulting SQL and the shape of the data at each stage of the pipeline */
+interface QueryResults {
+    lastStageName: string;
+    stageWriter: StageWriter;
+    structs: StructDef[];
+    malloy: string;
+    connectionName: string;
+}
+/** start here */
+export declare class QueryModel {
+    dialect: Dialect;
+    modelDef: ModelDef | undefined;
+    structs: Map<string, QueryStruct>;
+    constructor(modelDef: ModelDef | undefined);
+    loadModelFromDef(modelDef: ModelDef): void;
+    parseQueryPath(name: string): {
+        struct: QueryStruct;
+        queryName: string;
+    };
+    getStructByName(name: string): QueryStruct;
+    getStructFromRef(structRef: StructRef): QueryStruct;
+    loadQuery(query: Query, stageWriter: StageWriter | undefined, emitFinalStage?: boolean): QueryResults;
+    compileQuery(query: Query, finalize?: boolean): CompiledQuery;
+    exploreSearchSQLMap: Map<any, any>;
+    searchIndex(connection: Connection, explore: string, searchValue: string, limit?: number, searchField?: string | undefined): Promise<SearchIndexResult[] | undefined>;
+}
+export {};