@malloydata/malloy 0.0.195-dev241003204905 → 0.0.195-dev241007154000

package/dist/model/malloy_types.d.ts

@@ -24,7 +24,7 @@ export type AnyExpr = ExprE | ExprOptionalE | ExprWithKids | ExprLeaf;
 export declare function exprHasKids(e: AnyExpr): e is ExprWithKids;
 export declare function exprHasE(e: AnyExpr): e is ExprE;
 export declare function exprIsLeaf(e: AnyExpr): boolean;
-export type Expr = BinaryExpr | UnaryExpr | FunctionCallNode | OutputFieldNode | FilterCondition | FilteredExpr | AggregateExpr | EmptyExpr | UngroupNode | FunctionParameterNode | SpreadExpr | AggregateOrderByNode | AggregateLimitNode | FieldnameNode | SourceReferenceNode | ParameterNode | NowNode | MeasureTimeExpr | TimeDeltaExpr | TimeTruncExpr | TimeExtractExpr | TypecastExpr | RegexMatchExpr | RegexLiteralNode | TimeLiteralNode | StringLiteralNode | NumberLiteralNode | BooleanLiteralNode | FunctionOrderBy | GenericSQLExpr | NullNode | PickExpr | ErrorNode;
+export type Expr = BinaryExpr | UnaryExpr | FunctionCallNode | OutputFieldNode | FilterCondition | FilteredExpr | AggregateExpr | EmptyExpr | UngroupNode | FunctionParameterNode | SpreadExpr | AggregateOrderByNode | AggregateLimitNode | FieldnameNode | SourceReferenceNode | ParameterNode | NowNode | MeasureTimeExpr | TimeDeltaExpr | TimeTruncExpr | TimeExtractExpr | TypecastExpr | RegexMatchExpr | RegexLiteralNode | TimeLiteralNode | StringLiteralNode | NumberLiteralNode | BooleanLiteralNode | RecordLiteralNode | ArrayLiteralNode | FunctionOrderBy | GenericSQLExpr | NullNode | PickExpr | ArrayEachExpr | ErrorNode;
 interface HasDataType {
     dataType: AtomicFieldType;
 }
@@ -118,7 +118,7 @@ export interface NowNode extends ExprLeaf {
     node: 'now';
 }
 interface HasTimeValue {
-    dataType: TimeFieldType;
+    dataType: TemporalFieldType;
 }
 type TimeExpr = Expr & HasTimeValue;
 export interface MeasureTimeExpr extends ExprWithKids {
@@ -167,7 +167,7 @@ export interface RegexMatchExpr extends ExprWithKids {
 export interface TimeLiteralNode extends ExprLeaf {
     node: 'timeLiteral';
     literal: string;
-    dataType: TimeFieldType;
+    dataType: TemporalFieldType;
     timezone?: string;
 }
 export interface StringLiteralNode extends ExprLeaf {
@@ -185,6 +185,17 @@ export interface NumberLiteralNode extends ExprLeaf {
 export interface BooleanLiteralNode extends ExprLeaf {
     node: 'true' | 'false';
 }
+export interface RecordLiteralNode extends ExprWithKids {
+    node: 'recordLiteral';
+    kids: Record<string, TypedExpr>;
+}
+export interface ArrayLiteralNode extends ExprWithKids {
+    node: 'arrayLiteral';
+    kids: {
+        values: Expr[];
+    };
+    dataType: AtomicFieldType;
+}
 export interface ErrorNode extends ExprLeaf {
     node: 'error';
     message?: string;
@@ -207,6 +218,9 @@ export interface PickExpr extends ExprWithKids {
         pickElse: Expr;
     };
 }
+export interface ArrayEachExpr extends ExprLeaf {
+    node: 'arrayEach';
+}
 export type ExpressionType = 'scalar' | 'aggregate' | 'scalar_analytic' | 'aggregate_analytic' | 'ungrouped_aggregate';
 export interface Expression {
     e?: Expr;
@@ -252,7 +266,7 @@ export interface DocumentJoinReference extends DocumentReferenceBase {
 }
 export interface DocumentSQLBlockReference extends DocumentReferenceBase {
     type: 'sqlBlockReference';
-    definition: SQLBlockStructDef;
+    definition: SQLSourceDef;
 }
 export interface DocumentQueryReference extends DocumentReferenceBase {
     type: 'queryReference';
@@ -272,9 +286,6 @@ export interface AliasedName {
     name: string;
     as?: string;
 }
-export interface TypedObject {
-    type: string;
-}
 /** all named objects have a type an a name (optionally aliased) */
 export interface NamedObject extends AliasedName, HasLocation {
     type: string;
@@ -306,15 +317,14 @@ export declare function expressionIsAnalytic(e: ExpressionType | undefined): boo
 export declare function isExpressionTypeLEQ(e1: ExpressionType, e2: ExpressionType): boolean;
 export declare function maxExpressionType(e1: ExpressionType, e2: ExpressionType): ExpressionType;
 export declare function maxOfExpressionTypes(types: ExpressionType[]): ExpressionType;
-type HasExpression = FieldDef & Expression & {
+/**  Grants access to the expression properties of a FieldDef */
+export declare function hasExpression<T extends FieldDef>(f: T): f is T & Expression & {
     e: Expr;
 };
-/**  Grants access to the expression property of a FieldDef */
-export declare function hasExpression(f: FieldDef): f is HasExpression;
-export type TimeFieldType = 'date' | 'timestamp';
-export declare function isTimeFieldType(s: string): s is TimeFieldType;
-export type CastType = 'string' | 'number' | TimeFieldType | 'boolean' | 'json';
-export type AtomicFieldType = CastType | 'sql native' | 'error';
+export type TemporalFieldType = 'date' | 'timestamp';
+export declare function isTemporalField(s: string): s is TemporalFieldType;
+export type CastType = 'string' | 'number' | TemporalFieldType | 'boolean' | 'json';
+export type AtomicFieldType = CastType | 'sql native' | 'record' | 'array' | 'error';
 export declare function isAtomicFieldType(s: string): s is AtomicFieldType;
 export declare function isCastType(s: string): s is CastType;
 /**
@@ -322,56 +332,84 @@ export declare function isCastType(s: string): s is CastType;
  * value could be an expression, and this is one of the objects
  * which might have an annotation.
  */
-export interface FieldAtomicDef extends NamedObject, Expression, ResultMetadata {
-    type: AtomicFieldType;
+export interface FieldBase extends NamedObject, Expression, ResultMetadata {
     annotation?: Annotation;
 }
-export declare function FieldIsIntrinsic(f: FieldDef): boolean;
-export interface FieldStringTypeDef {
+interface FieldAtomicBase extends FieldBase {
+    type: AtomicFieldType;
+}
+export declare function fieldIsIntrinsic(f: FieldDef): boolean;
+export interface StringTypeDef {
     type: 'string';
     bucketFilter?: string;
     bucketOther?: string;
 }
-/** Scalar String Field */
-export interface FieldStringDef extends FieldAtomicDef, FieldStringTypeDef {
-    type: 'string';
-}
-export interface FieldNumberTypeDef {
+export type StringFieldDef = StringTypeDef & AtomicFieldDef;
+export interface NumberTypeDef {
     type: 'number';
     numberType?: 'integer' | 'float';
 }
-/** Scalar Numeric String Field */
-export interface FieldNumberDef extends FieldAtomicDef, FieldNumberTypeDef {
-    type: 'number';
-}
-export interface FieldBooleanTypeDef {
-    type: 'boolean';
-}
-/** Scalar Boolean Field */
-export interface FieldBooleanDef extends FieldAtomicDef, FieldBooleanTypeDef {
+export type NumberFieldDef = NumberTypeDef & AtomicFieldDef;
+export interface BooleanTypeDef {
     type: 'boolean';
 }
-export interface FieldJSONTypeDef {
-    type: 'json';
-}
-/** Scalar JSON Field */
-export interface FieldJSONDef extends FieldAtomicDef, FieldJSONTypeDef {
+export type BooleanFieldDef = BooleanTypeDef & AtomicFieldDef;
+export interface JSONTypeDef {
     type: 'json';
 }
-export interface FieldNativeUnsupportedTypeDef {
+export type JSONFieldDef = JSONTypeDef & AtomicFieldDef;
+export interface NativeUnsupportedTypeDef {
     type: 'sql native';
     rawType?: string;
 }
-/** Scalar unsupported Field */
-export interface FeldNativeUnsupportedDef extends FieldAtomicDef, FieldNativeUnsupportedTypeDef {
-    type: 'sql native';
-}
-export interface FieldErrorTypeDef {
+export type NativeUnsupportedFieldDef = NativeUnsupportedTypeDef & AtomicFieldDef;
+export interface ArrayTypeDef {
+    type: 'array';
+    elementTypeDef: Exclude<AtomicTypeDef, RecordTypeDef> | RecordElementTypeDef;
+}
+export type ArrayFieldDef = ArrayTypeDef & AtomicFieldDef;
+export interface JoinedArrayTypeDef extends ArrayTypeDef, JoinBase, StructDefBase {
+    type: 'array';
+    join: 'many';
+}
+export type JoinedArrayDef = JoinedArrayTypeDef & AtomicFieldDef;
+export declare function arrayEachFields(arrayOf: AtomicTypeDef): AtomicFieldDef[];
+export interface RecordTypeDef extends StructDefBase, JoinBase {
+    type: 'record';
+    join: 'one';
+}
+export interface RecordElementTypeDef {
+    type: 'record_element';
+}
+export interface RepeatedRecordTypeDef extends JoinedArrayTypeDef {
+    type: 'array';
+    elementTypeDef: RecordElementTypeDef;
+    join: 'many';
+}
+export type RecordFieldDef = RecordTypeDef & AtomicFieldDef;
+export type RepeatedRecordFieldDef = RepeatedRecordTypeDef & AtomicFieldDef;
+export declare function isRepeatedRecord(fd: FieldDef): fd is RepeatedRecordFieldDef;
+export interface ErrorTypeDef {
     type: 'error';
 }
-export interface FieldErrorDef extends FieldAtomicDef, FieldErrorTypeDef {
-    type: 'error';
+export type ErrorFieldDef = ErrorTypeDef & AtomicFieldDef;
+export type JoinType = 'one' | 'many' | 'cross';
+export type JoinRelationship = 'one_to_one' | 'one_to_many' | 'many_to_one' | 'many_to_many';
+export type MatrixOperation = 'left' | 'right' | 'full' | 'inner';
+export declare function isMatrixOperation(x: string): x is MatrixOperation;
+export type JoinElementType = 'table' | 'sql_select' | 'query_source' | 'array' | 'record';
+export interface JoinBase {
+    type: JoinElementType;
+    join: JoinType;
+    matrixOperation?: MatrixOperation;
+    onExpression?: Expr;
 }
+export type Joinable = TableSourceDef | SQLSourceDef | QuerySourceDef | RecordFieldDef | JoinedArrayDef;
+export type JoinFieldDef = JoinBase & Joinable;
+export type JoinFieldTypes = 'table' | 'sql_select' | 'query_source' | 'array' | 'record';
+export declare function isJoinable(sd: StructDef): sd is Joinable;
+export declare function isJoined<T extends FieldDef | StructDef>(fd: T): fd is T & Joinable & JoinBase;
+export declare function isJoinedSource(sd: StructDef): sd is SourceDef & JoinBase;
 export type DateUnit = 'day' | 'week' | 'month' | 'quarter' | 'year';
 export declare function isDateUnit(str: string): str is DateUnit;
 export type TimestampUnit = DateUnit | 'hour' | 'minute' | 'second';
@@ -386,22 +424,16 @@ export declare enum ValueType {
     String = "string"
 }
 export type TimeValueType = ValueType.Date | ValueType.Timestamp;
-export interface FieldDateTypeDef {
+export interface DateTypeDef {
     type: 'date';
     timeframe?: DateUnit;
 }
-/** Scalar Date Field. */
-export interface FieldDateDef extends FieldAtomicDef, FieldDateTypeDef {
-    type: 'date';
-}
-export interface FieldTimestampTypeDef {
+export type DateFieldDef = DateTypeDef & AtomicFieldDef;
+export interface TimestampTypeDef {
     type: 'timestamp';
     timeframe?: TimestampUnit;
 }
-/** Scalar Timestamp Field */
-export interface FieldTimestampDef extends FieldAtomicDef, FieldTimestampTypeDef {
-    type: 'timestamp';
-}
+export type TimestampFieldDef = TimestampTypeDef & AtomicFieldDef;
 /** parameter to order a query */
 export interface OrderBy {
     field: string | number;
@@ -428,18 +460,12 @@ export type By = ByName | ByExpression;
 export declare function isByName(by: By | undefined): by is ByName;
 export declare function isByExpression(by: By | undefined): by is ByExpression;
 /** reference to a data source */
-export type StructRef = string | StructDef;
-export declare function refIsStructDef(ref: StructRef): ref is StructDef;
+export type StructRef = string | SourceDef;
+export declare function refIsStructDef(ref: StructRef): ref is SourceDef;
 export type InvokedStructRef = {
     structRef: StructRef;
     sourceArguments?: Record<string, Argument>;
 };
-/** join pattern structs is a struct. */
-export interface JoinedStruct {
-    structRef: StructRef;
-    structRelationship: StructRelationship;
-    as: string;
-}
 export interface Filtered {
     filterList?: FilterCondition[];
 }
@@ -518,84 +544,63 @@ export interface TurtleDef extends NamedObject, Pipeline {
     type: 'turtle';
     annotation?: Annotation;
 }
-export type JoinRelationship = 'one_to_one' | 'one_to_many' | 'many_to_one' | 'many_to_many';
-export type MatrixOperation = 'left' | 'right' | 'full' | 'inner';
-export declare function isMatrixOperation(x: string): x is MatrixOperation;
-export interface JoinOn {
-    type: 'one' | 'many' | 'cross';
-    matrixOperation: MatrixOperation;
-    onExpression?: Expr;
+interface StructDefBase extends HasLocation, NamedObject {
+    type: string;
+    annotation?: Annotation;
+    modelAnnotation?: ModelAnnotation;
+    fields: FieldDef[];
+    dialect: string;
+}
+interface SourceDefBase extends StructDefBase, Filtered, ResultStructMetadata {
+    arguments?: Record<string, Argument>;
+    parameters?: Record<string, Parameter>;
+    queryTimezone?: string;
+    connection: string;
+    primaryKey?: PrimaryKeyRef;
+}
+/** which field is the primary key in this struct */
+export type PrimaryKeyRef = string;
+export interface TableSourceDef extends SourceDefBase {
+    type: 'table';
+    tablePath: string;
 }
-export declare function isJoinOn(sr: StructRelationship): sr is JoinOn;
-/** types of joins. */
-export type StructRelationship = {
-    type: 'basetable';
-    connectionName: string;
-} | JoinOn | {
-    type: 'inline';
-} | {
-    type: 'nested';
-    fieldName: string;
-    isArray: boolean;
-};
 export interface SQLStringSegment {
     sql: string;
 }
-export type SQLPhrase = Query | SQLStringSegment;
-export declare function isSQLFragment(f: SQLPhrase): f is SQLStringSegment;
-/**
- * A source reference to an SQL block. The compiler uses these to request
- * an SQLBlock with it's schema and structdef defined. Use the factory
- * makeSQLBlock to construct these.
- */
-export interface SQLBlockSource {
+export type SQLPhraseSegment = Query | SQLStringSegment;
+export declare function isSegmentSQL(f: SQLPhraseSegment): f is SQLStringSegment;
+export interface SQLSentence {
     name: string;
-    connection?: string;
-    select: SQLPhrase[];
+    connection: string;
+    select: SQLPhraseSegment[];
 }
-export interface SQLBlock extends NamedObject {
-    type: 'sqlBlock';
-    connection?: string;
+export interface SQLSourceDef extends SourceDefBase {
+    type: 'sql_select';
     selectStr: string;
 }
-interface SubquerySource {
-    type: 'sql';
-    method: 'subquery';
-    sqlBlock: SQLBlock;
-}
-/** where does the struct come from? */
-export type StructSource = {
-    type: 'table';
-    tablePath: string;
-} | {
-    type: 'nested';
-} | {
-    type: 'inline';
-} | {
-    type: 'query';
+export interface QuerySourceDef extends SourceDefBase {
+    type: 'query_source';
     query: Query;
-} | {
-    type: 'sql';
-    method: 'nested' | 'lastStage';
-} | {
+}
+export interface QueryResultDef extends SourceDefBase {
     type: 'query_result';
-} | SubquerySource;
-/** struct that is intrinsic to the table */
-export interface StructDef extends NamedObject, ResultStructMetadata, Filtered {
-    type: 'struct';
-    structSource: StructSource;
-    structRelationship: StructRelationship;
-    fields: FieldDef[];
-    primaryKey?: PrimaryKeyRef;
-    arguments?: Record<string, Argument>;
-    parameters?: Record<string, Parameter>;
-    queryTimezone?: string;
-    dialect: string;
-    annotation?: Annotation;
-    modelAnnotation?: ModelAnnotation;
 }
+export interface NestSourceDef extends SourceDefBase {
+    type: 'nest_source';
+    pipeSQL: string;
+}
+export interface FinalizeSourceDef extends SourceDefBase {
+    type: 'finalize';
+}
+export declare function sourceBase(sd: SourceDefBase): SourceDefBase;
+export declare function isSourceDef(sd: StructDef | FieldDef): sd is SourceDef;
+export type SourceDef = TableSourceDef | SQLSourceDef | QuerySourceDef | QueryResultDef | FinalizeSourceDef | NestSourceDef;
+/** Is this the "FROM" table of a query tree */
+export declare function isBaseTable(def: StructDef): def is SourceDef;
+export declare function isScalarArray(def: FieldDef | StructDef): boolean;
+export type StructDef = SourceDef | RecordFieldDef | JoinedArrayDef;
 export type ExpressionValueType = AtomicFieldType | 'null' | 'duration' | 'any' | 'regular expression';
-export type FieldValueType = ExpressionValueType | 'turtle' | 'struct';
+export type FieldValueType = ExpressionValueType | 'turtle' | JoinFieldTypes;
 export interface ExpressionTypeDesc {
     dataType: FieldValueType;
     expressionType: ExpressionType;
@@ -646,32 +651,21 @@ export interface FunctionDef extends NamedObject {
 export interface ConnectionDef extends NamedObject {
     type: 'connection';
 }
-export interface SQLBlockStructDef extends StructDef {
-    structSource: SubquerySource;
-    declaredSQLBlock?: boolean;
-}
-export declare function isSQLBlockStruct(sd: StructDef): sd is SQLBlockStructDef;
-/** any of the different field types */
-export type FieldTypeDef = FieldStringDef | FieldDateDef | FieldTimestampDef | FieldNumberDef | FieldBooleanDef | FieldJSONDef | FeldNativeUnsupportedDef | FieldErrorDef;
-export type FieldAtomicTypeDef = FieldStringTypeDef | FieldDateTypeDef | FieldTimestampTypeDef | FieldNumberTypeDef | FieldBooleanTypeDef | FieldJSONTypeDef | FieldNativeUnsupportedTypeDef | FieldErrorTypeDef;
-export declare function isFieldTypeDef(f: FieldDef): f is FieldTypeDef;
-export declare function isFieldTimeBased(f: FieldDef): f is FieldTimestampDef | FieldDateDef;
-export declare function isFieldStructDef(f: FieldDef): f is StructDef;
-export type QueryFieldDef = FieldTypeDef | TurtleDef | RefToField;
-/** basics statement */
-export type FieldDef = FieldTypeDef | StructDef | TurtleDef;
-/** reference to a field */
+export type TemporalTypeDef = DateTypeDef | TimestampTypeDef;
+export type LeafAtomicDef = StringTypeDef | TemporalTypeDef | NumberTypeDef | BooleanTypeDef | JSONTypeDef | NativeUnsupportedTypeDef | ErrorTypeDef;
+export type AtomicTypeDef = LeafAtomicDef | ArrayTypeDef | RecordTypeDef;
+export type AtomicFieldDef = AtomicTypeDef & FieldAtomicBase;
+export type FieldDef = AtomicFieldDef | JoinFieldDef | TurtleDef;
 export interface RefToField {
     type: 'fieldref';
     path: string[];
     annotation?: Annotation;
 }
-export type FieldRefOrDef = FieldDef | RefToField;
-/** which field is the primary key in this struct */
-export type PrimaryKeyRef = string;
+export type QueryFieldDef = AtomicFieldDef | TurtleDef | RefToField;
 /** Get the output name for a NamedObject */
 export declare function getIdentifier(n: AliasedName): string;
 export type NamedModelObject = StructDef | NamedQuery | FunctionDef | ConnectionDef;
+export declare function modelObjIsSource(nmo: NamedModelObject): nmo is SourceDef;
 /** Result of parsing a model file */
 export interface ModelDef {
     name: string;
@@ -680,7 +674,7 @@ export interface ModelDef {
     annotation?: ModelAnnotation;
 }
 /** Very common record type */
-export type NamedStructDefs = Record<string, StructDef>;
+export type NamedSourceDefs = Record<string, SourceDef>;
 export type NamedModelObjects = Record<string, NamedModelObject>;
 /** Malloy source annotations attached to objects */
 export interface Annotation {
@@ -727,7 +721,7 @@ export type QueryToMaterialize = {
     queryName: string;
 };
 export interface CompiledQuery extends DrillSource {
-    structs: StructDef[];
+    structs: SourceDef[];
     sql: string;
     lastStageName: string;
     malloy: string;
@@ -747,18 +741,14 @@ export interface QueryResult extends CompiledQuery {
     profilingUrl?: string;
 }
 export declare function isTurtleDef(def: FieldDef): def is TurtleDef;
-export declare function isAtomicField(def: FieldDef): def is FieldAtomicDef;
+export declare function isAtomic(def: FieldDef): def is AtomicFieldDef;
 export interface SearchResultRow {
     field_name: string;
     field_value: string;
     weight: number;
 }
 export type SearchResult = SearchResultRow[];
-export declare function isDimensional(field: FieldDef): boolean;
-export declare function isPhysical(field: FieldDef): boolean;
-export declare function getDimensions(structDef: StructDef): FieldAtomicDef[];
-export declare function getPhysicalFields(structDef: StructDef): FieldDef[];
-export declare function isMeasureLike(field: FieldDef): boolean;
+export declare function getAtomicFields(structDef: StructDef): AtomicFieldDef[];
 export declare function isValueString(value: QueryValue, field: FieldDef): value is string | null;
 export declare function isValueNumber(value: QueryValue, field: FieldDef): value is number | null;
 export declare function isValueBoolean(value: QueryValue, field: FieldDef): value is boolean | null;