@malloydata/malloy 0.0.22-dev230207144036 → 0.0.22-dev230207180844

package/dist/model/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./malloy_types";
+export { Segment, QueryModel, flattenQuery } from "./malloy_query";

package/dist/model/index.js

@@ -0,0 +1,45 @@
+"use strict";
+/*
+ * Copyright 2023 Google LLC
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files
+ * (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.flattenQuery = exports.QueryModel = exports.Segment = void 0;
+__exportStar(require("./malloy_types"), exports);
+var malloy_query_1 = require("./malloy_query");
+Object.defineProperty(exports, "Segment", { enumerable: true, get: function () { return malloy_query_1.Segment; } });
+Object.defineProperty(exports, "QueryModel", { enumerable: true, get: function () { return malloy_query_1.QueryModel; } });
+Object.defineProperty(exports, "flattenQuery", { enumerable: true, get: function () { return malloy_query_1.flattenQuery; } });
+//# sourceMappingURL=index.js.map

package/dist/model/malloy_query.d.ts

@@ -0,0 +1,351 @@
+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, NamedQuery, AnalyticFragment, ResultStructMetadataDef, SearchIndexResult } from "./malloy_types";
+import { AndChain } from "./utils";
+import { Connection } from "../runtime_types";
+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;
+    generateAnalyticFragment(resultStruct: FieldInstanceResult, context: QueryStruct, expr: AnalyticFragment, 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;
+    isCalculated(): 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;
+    queryUsesPartitioning: 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: any;
+        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: any;
+    };
+    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): any;
+    /**
+     * 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 declare function flattenQuery(model: ModelDef, query: NamedQuery): TurtleDef;
+export {};