@malloydata/malloy 0.0.303 → 0.0.305

package/dist/model/query_node.d.ts

@@ -0,0 +1,132 @@
+import type { FieldDef, BooleanFieldDef, DateFieldDef, StringFieldDef, JSONFieldDef, NumberFieldDef, TimestampFieldDef, NativeUnsupportedFieldDef, JoinFieldDef, Argument, PrepareResultOptions, AtomicFieldDef, BasicAtomicDef, FilterCondition, RefToField, StructDef, TurtleDef, TurtleDefPlusFilters, SourceDef, Query } from './malloy_types';
+import type { EventStream } from '../runtime_types';
+import type { Tag } from '@malloydata/malloy-tag';
+import type { Dialect } from '../dialect';
+declare abstract class QueryNode {
+    readonly referenceId: string;
+    constructor(referenceId?: string);
+    abstract getIdentifier(): string;
+    getChildByName(_name: string): QueryField | undefined;
+}
+export declare class QueryField extends QueryNode {
+    fieldDef: FieldDef;
+    parent: QueryStruct;
+    constructor(fieldDef: FieldDef, parent: QueryStruct, referenceId?: string);
+    getIdentifier(): string;
+    getJoinableParent(): QueryStruct;
+    isAtomic(): boolean;
+    getFullOutputName(): string;
+    isNestedInParent(parentDef: FieldDef): boolean;
+    isArrayElement(parentDef: FieldDef): boolean;
+    includeInWildcard(): boolean;
+}
+export declare abstract class QueryAtomicField<T extends AtomicFieldDef> extends QueryField {
+    fieldDef: T;
+    constructor(fieldDef: T, parent: QueryStruct, refId?: string);
+    includeInWildcard(): boolean;
+    getFilterList(): FilterCondition[];
+}
+export declare class QueryFieldBoolean extends QueryAtomicField<BooleanFieldDef> {
+}
+export declare class QueryFieldDate extends QueryAtomicField<DateFieldDef> {
+}
+export declare class QueryFieldDistinctKey extends QueryAtomicField<StringFieldDef> {
+}
+export declare class QueryFieldJSON extends QueryAtomicField<JSONFieldDef> {
+}
+export declare class QueryFieldNumber extends QueryAtomicField<NumberFieldDef> {
+}
+export declare class QueryFieldString extends QueryAtomicField<StringFieldDef> {
+}
+export declare class QueryFieldStruct extends QueryField {
+    queryStruct: QueryStruct;
+    fieldDef: JoinFieldDef;
+    constructor(jfd: JoinFieldDef, sourceArguments: Record<string, Argument> | undefined, parent: QueryStruct, prepareResultOptions: PrepareResultOptions, referenceId?: string);
+    getJoinableParent(): QueryStruct;
+    getFullOutputName(): string;
+    includeInWildcard(): boolean;
+}
+export declare class QueryFieldTimestamp extends QueryAtomicField<TimestampFieldDef> {
+}
+export declare class QueryFieldUnsupported extends QueryAtomicField<NativeUnsupportedFieldDef> {
+}
+export type QueryBasicField = QueryAtomicField<BasicAtomicDef>;
+export declare function isAggregateField(f: QueryField): boolean;
+export declare function isCalculatedField(f: QueryField): boolean;
+export declare function isScalarField(f: QueryField): boolean;
+export declare function isBasicAggregate(f: QueryField): f is QueryBasicField;
+export declare function isBasicCalculation(f: QueryField): f is QueryBasicField;
+export declare function isBasicScalar(f: QueryField): f is QueryBasicField;
+export interface ParentQueryStruct {
+    struct: QueryStruct;
+}
+export interface ModelRootInterface {
+    eventStream?: EventStream;
+}
+export interface ParentQueryModel {
+    model: ModelRootInterface;
+}
+/** Structure object as it is used to build a query */
+export declare class QueryStruct {
+    structDef: StructDef;
+    readonly sourceArguments: Record<string, Argument> | undefined;
+    readonly prepareResultOptions: PrepareResultOptions;
+    parent: QueryStruct | undefined;
+    model: ModelRootInterface;
+    nameMap: Map<string, QueryField>;
+    pathAliasMap: Map<string, string>;
+    dialect: Dialect;
+    connectionName: string;
+    recordAlias?: string;
+    constructor(structDef: StructDef, sourceArguments: Record<string, Argument> | undefined, parent: ParentQueryStruct | ParentQueryModel, prepareResultOptions: PrepareResultOptions);
+    private static turtleFieldMaker;
+    static registerTurtleFieldMaker(maker: (field: TurtleDef, parent: QueryStruct) => QueryField): void;
+    private _modelTag;
+    modelCompilerFlags(): Tag;
+    protected findFirstDialect(): string;
+    informOfAliasValue(av: string): void;
+    maybeEmitParameterizedSourceUsage(): void;
+    private resolveParentParameterReferences;
+    private _arguments;
+    arguments(): Record<string, Argument>;
+    private addFieldsFromFieldList;
+    getAliasIdentifier(): string;
+    getSQLIdentifier(): string;
+    sqlSimpleChildReference(name: string): string;
+    getIdentifier(): string;
+    getFullOutputName(): string;
+    unnestWithNumbers(): boolean;
+    getJoinableParent(): QueryStruct;
+    addFieldToNameMap(as: string, n: QueryField): void;
+    /** the the primary key or throw an error. */
+    getPrimaryKeyField(fieldDef: FieldDef): QueryBasicField;
+    /**
+     * 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.
+     *
+     * finalOutputStruct exists so that query_node doesn't need to
+     * to import query_query
+     */
+    resolveQueryFields(finalOutputStruct: (query: Query, options: PrepareResultOptions | undefined) => SourceDef | undefined): void;
+    getModel(): ModelRootInterface;
+    get eventStream(): EventStream | undefined;
+    setParent(parent: ParentQueryStruct | ParentQueryModel): void;
+    /** makes a new queryable field object from a fieldDef */
+    makeQueryField(field: FieldDef, referenceId?: string): QueryField;
+    root(): QueryStruct;
+    primaryKey(): QueryBasicField | undefined;
+    getChildByName(name: string): QueryField | undefined;
+    /** convert a path into a field reference */
+    getFieldByName(path: string[]): QueryField;
+    getQueryFieldByName(name: string[]): QueryField;
+    getQueryFieldReference(f: RefToField): QueryField;
+    getDimensionOrMeasureByName(name: string[]): QueryField;
+    /** returns a query object for the given name */
+    getDimensionByName(name: string[]): QueryBasicField;
+    /** returns a query object for the given name */
+    getStructByName(name: string[]): QueryStruct;
+    getDistinctKey(): QueryBasicField;
+    applyStructFiltersToTurtleDef(turtleDef: TurtleDef | TurtleDefPlusFilters): TurtleDef;
+}
+export {};