@malloydata/malloy 0.0.219 → 0.0.220-dev241204170603

package/dist/lang/parse-log.d.ts

@@ -344,6 +344,7 @@ type MessageParameterTypes = {
     'or-choices-only': string;
     'sql-in': string;
     'dialect-cast-unsafe-only': string;
+    'array-values-incompatible': string;
 };
 export declare const MESSAGE_FORMATTERS: PartialErrorCodeMessageMap;
 export type MessageCode = keyof MessageParameterTypes;

package/dist/lang/test/query.spec.js

@@ -684,6 +684,12 @@ describe('query:', () => {
             const fields = getFirstSegmentFieldNames(selstar.translator.getQuery(0));
             expect(fields).toEqual(filterdFields);
         });
+        test('array in query is passed into fields', () => {
+            const selArray = (0, test_translator_1.model) `run: a -> { select: ais }`;
+            expect(selArray).toTranslate();
+            const fields = getFirstSegmentFieldNames(selArray.translator.getQuery(0));
+            expect(fields).toEqual(['ais']);
+        });
         test('star error checking', () => {
             expect((0, test_translator_1.markSource) `run: a->{select: ${'zzz'}.*}`).toLog((0, test_translator_1.errorMessage)("No such field as 'zzz'"));
             expect((0, test_translator_1.markSource) `run: ab->{select: b.${'zzz'}.*}`).toLog((0, test_translator_1.errorMessage)("No such field as 'zzz'"));

package/dist/lang/test/test-translator.js

@@ -35,6 +35,7 @@ function pretty(thing) {
     return (0, util_1.inspect)(thing, { breakLength: 72, depth: Infinity });
 }
 exports.pretty = pretty;
+const intType = { type: 'number', numberType: 'integer' };
 const mockSchema = {
     'aTable': {
         type: 'table',
@@ -45,7 +46,7 @@ const mockSchema = {
         fields: [
             { type: 'string', name: 'astr' },
             { type: 'number', name: 'af', numberType: 'float' },
-            { type: 'number', name: 'ai', numberType: 'integer' },
+            { ...intType, name: 'ai' },
             { type: 'date', name: 'ad' },
             { type: 'boolean', name: 'abool' },
             { type: 'timestamp', name: 'ats' },
@@ -68,11 +69,19 @@ const mockSchema = {
             {
                 type: 'record',
                 name: 'aninline',
-                fields: [{ type: 'number', name: 'column', numberType: 'integer' }],
+                fields: [{ ...intType, name: 'column' }],
                 join: 'one',
                 matrixOperation: 'left',
                 dialect: 'standardsql',
             },
+            {
+                type: 'array',
+                name: 'ais',
+                elementTypeDef: intType,
+                join: 'many',
+                fields: (0, malloy_types_1.arrayEachFields)(intType),
+                dialect: 'standardsql',
+            },
         ],
     },
     'malloytest.carriers': {

package/dist/model/malloy_query.d.ts

@@ -1,5 +1,5 @@
 import { Dialect, DialectFieldList } from '../dialect';
-import { AggregateFunctionType, Annotation, CompiledQuery, Expr, FieldDef, Filtered, FunctionOverloadDef, FunctionParameterDef, JoinRelationship, ModelDef, OrderBy, OutputFieldNode, ParameterNode, PipeSegment, Query, QueryFieldDef, QuerySegment, ResultMetadataDef, ResultStructMetadataDef, SearchIndexResult, SegmentFieldDef, StructDef, StructRef, TurtleDef, FunctionOrderBy, Argument, AggregateExpr, FilterCondition, GenericSQLExpr, FieldnameNode, FunctionCallNode, UngroupNode, SourceReferenceNode, SpreadExpr, FilteredExpr, SourceDef, AtomicFieldDef, BooleanFieldDef, QueryResultDef, QueryToMaterialize, PrepareResultOptions, CaseExpr } from './malloy_types';
+import { AggregateFunctionType, Annotation, CompiledQuery, Expr, FieldDef, Filtered, FunctionOverloadDef, FunctionParameterDef, JoinRelationship, ModelDef, OrderBy, OutputFieldNode, ParameterNode, PipeSegment, Query, QueryFieldDef, QuerySegment, ResultMetadataDef, ResultStructMetadataDef, SearchIndexResult, SegmentFieldDef, StructDef, StructRef, TurtleDef, FunctionOrderBy, Argument, AggregateExpr, FilterCondition, GenericSQLExpr, FieldnameNode, FunctionCallNode, UngroupNode, SourceReferenceNode, SpreadExpr, FilteredExpr, SourceDef, BooleanFieldDef, QueryResultDef, QueryToMaterialize, PrepareResultOptions, CaseExpr, LeafAtomicDef } from './malloy_types';
 import { Connection } from '../connection/types';
 import { AndChain } from './utils';
 import { QueryInfo } from '../dialect/dialect';
@@ -46,7 +46,6 @@ declare class StageWriter {
     generateSQLStages(): string;
     generateCoorelatedSubQuery(dialect: Dialect, structDef: StructDef): string;
 }
-type QuerySomething = QueryField | QueryStruct | QueryTurtle;
 declare class GenerateState {
     whereSQL?: string;
     applyValue?: string;
@@ -59,7 +58,7 @@ declare abstract class QueryNode {
     readonly referenceId: string;
     constructor(referenceId?: string);
     abstract getIdentifier(): string;
-    getChildByName(_name: string): QuerySomething | undefined;
+    getChildByName(_name: string): QueryField | undefined;
 }
 declare class QueryField extends QueryNode {
     fieldDef: FieldDef;
@@ -68,6 +67,7 @@ declare class QueryField extends QueryNode {
     getIdentifier(): string;
     uniqueKeyPossibleUse(): UniqueKeyPossibleUse | undefined;
     getJoinableParent(): QueryStruct;
+    isAtomic(): boolean;
     caseGroup(groupSets: number[], s: string): string;
     getFullOutputName(): string;
     generateFieldFragment(resultSet: FieldInstanceResult, context: QueryStruct, expr: FieldnameNode, state: GenerateState): string;
@@ -96,10 +96,10 @@ declare class QueryField extends QueryNode {
     exprToSQL(resultSet: FieldInstanceResult, context: QueryStruct, exprToTranslate: Expr, state?: GenerateState): string;
     isNestedInParent(parentDef: FieldDef): boolean;
     isArrayElement(parentDef: FieldDef): boolean;
-    getExpr(): Expr;
     generateExpression(resultSet: FieldInstanceResult): string;
 }
-declare class QueryAtomicField<T extends AtomicFieldDef> extends QueryField {
+type QueryFieldAtomic = AbstractQueryAtomic<LeafAtomicDef>;
+declare class AbstractQueryAtomic<T extends LeafAtomicDef> extends QueryField {
     fieldDef: T;
     constructor(fieldDef: T, parent: QueryStruct, refId?: string);
     includeInWildcard(): boolean;
@@ -107,8 +107,9 @@ declare class QueryAtomicField<T extends AtomicFieldDef> extends QueryField {
     isAggregate(): boolean;
     getFilterList(): FilterCondition[];
     hasExpression(): boolean;
+    isAtomic(): boolean;
 }
-declare class QueryFieldBoolean extends QueryAtomicField<BooleanFieldDef> {
+declare class QueryFieldBoolean extends AbstractQueryAtomic<BooleanFieldDef> {
 }
 type FieldUsage = {
     type: 'result';
@@ -215,9 +216,6 @@ declare class JoinInstance {
     forceAllSymmetricCalculations(): boolean;
     getDialectFieldList(): DialectFieldList;
 }
-/** nested query */
-declare class QueryTurtle extends QueryField {
-}
 /**
  * Used by the translator to get the output StructDef of a pipe segment
  *
@@ -254,9 +252,10 @@ declare class QueryQuery extends QueryField {
     inNestedPipeline(): boolean;
     expandField(f: QueryFieldDef): {
         as: string;
-        field: QuerySomething;
+        field: QueryField;
     };
     addDependantPath(resultStruct: FieldInstanceResult, context: QueryStruct, path: string[], uniqueKeyPossibleUse: UniqueKeyPossibleUse | undefined, joinStack: string[]): void;
+    findRecordAliases(context: QueryStruct, path: string[]): void;
     addDependantExpr(resultStruct: FieldInstanceResult, context: QueryStruct, e: Expr, joinStack: string[]): void;
     addDependancies(resultStruct: FieldInstanceResult, field: QueryField): void;
     getSegmentFields(resultStruct: FieldInstanceResult): SegmentFieldDef[];
@@ -268,7 +267,7 @@ declare class QueryQuery extends QueryField {
     getResultMetadata(fi: FieldInstance): ResultStructMetadataDef | ResultMetadataDef | undefined;
     /**  returns a fields and primary key of a struct for this query */
     getResultStructDef(resultStruct?: FieldInstanceResult, isRoot?: boolean): QueryResultDef;
-    generateSQLJoinBlock(stageWriter: StageWriter, ji: JoinInstance): string;
+    generateSQLJoinBlock(stageWriter: StageWriter, ji: JoinInstance, depth: number): string;
     generateSQLPassthroughKeys(qs: QueryStruct): string;
     generateSQLJoins(stageWriter: StageWriter): string;
     genereateSQLOrderBy(queryDef: QuerySegment, resultStruct: FieldInstanceResult): string;
@@ -296,17 +295,19 @@ declare class QueryQuery extends QueryField {
     };
 }
 /** Structure object as it is used to build a query */
-declare class QueryStruct extends QueryNode {
+declare class QueryStruct {
     structDef: StructDef;
     readonly sourceArguments: Record<string, Argument> | undefined;
     readonly prepareResultOptions: PrepareResultOptions;
     parent: QueryStruct | undefined;
     model: QueryModel;
-    nameMap: Map<string, QuerySomething>;
+    nameMap: Map<string, QueryField>;
     pathAliasMap: Map<string, string>;
     dialect: Dialect;
     connectionName: string;
-    constructor(structDef: StructDef, sourceArguments: Record<string, Argument> | undefined, parent: ParentQueryStruct | ParentQueryModel, prepareResultOptions: PrepareResultOptions, referenceId?: string);
+    recordAlias?: string;
+    constructor(structDef: StructDef, sourceArguments: Record<string, Argument> | undefined, parent: ParentQueryStruct | ParentQueryModel, prepareResultOptions: PrepareResultOptions);
+    informOfAliasValue(av: string): void;
     maybeEmitParameterizedSourceUsage(): void;
     private resolveParentParameterReferences;
     private _arguments;
@@ -314,14 +315,18 @@ declare class QueryStruct extends QueryNode {
     private addFieldsFromFieldList;
     getAliasIdentifier(): string;
     getSQLIdentifier(): string;
+    sqlChildReference(name: string, expand: {
+        result: FieldInstanceResult;
+        field: QueryField;
+    } | undefined): string;
     getIdentifier(): string;
     getFullOutputName(): string;
     needsSymetricCalculation(resultSet: FieldInstanceResult): boolean;
     unnestWithNumbers(): boolean;
     getJoinableParent(): QueryStruct;
-    addFieldToNameMap(as: string, n: QuerySomething): void;
+    addFieldToNameMap(as: string, n: QueryField): void;
     /** the the primary key or throw an error. */
-    getPrimaryKeyField(fieldDef: FieldDef): QueryAtomicField<AtomicFieldDef>;
+    getPrimaryKeyField(fieldDef: FieldDef): QueryFieldAtomic;
     /**
      * 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
@@ -335,18 +340,18 @@ declare class QueryStruct extends QueryNode {
     makeQueryField(field: FieldDef, referenceId?: string): QueryField;
     structSourceSQL(stageWriter: StageWriter): string;
     root(): QueryStruct;
-    primaryKey(): QueryAtomicField<AtomicFieldDef> | undefined;
-    getChildByName(name: string): QuerySomething | undefined;
+    primaryKey(): QueryFieldAtomic | undefined;
+    getChildByName(name: string): QueryField | undefined;
     /** convert a path into a field reference */
-    getFieldByName(path: string[]): QuerySomething;
-    getQueryFieldByName(name: string[]): QuerySomething;
-    getQueryFieldReference(name: string[], annotation: Annotation | undefined): QuerySomething;
-    getDimensionOrMeasureByName(name: string[]): QueryAtomicField<AtomicFieldDef>;
+    getFieldByName(path: string[]): QueryField;
+    getQueryFieldByName(name: string[]): QueryField;
+    getQueryFieldReference(path: string[], annotation: Annotation | undefined): QueryField;
+    getDimensionOrMeasureByName(name: string[]): QueryField;
     /** returns a query object for the given name */
-    getDimensionByName(name: string[]): QueryAtomicField<AtomicFieldDef>;
+    getDimensionByName(name: string[]): QueryFieldAtomic;
     /** returns a query object for the given name */
     getStructByName(name: string[]): QueryStruct;
-    getDistinctKey(): QueryAtomicField<AtomicFieldDef>;
+    getDistinctKey(): QueryFieldAtomic;
     applyStructFiltersToTurtleDef(turtleDef: TurtleDef | TurtleDefPlus): TurtleDef;
 }
 /** the resulting SQL and the shape of the data at each stage of the pipeline */