@malloydata/malloy 0.0.157 → 0.0.158-dev240805161224

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

@@ -0,0 +1,578 @@
+"use strict";
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const test_translator_1 = require("./test-translator");
+require("./parse-expects");
+describe('parameters', () => {
+    test('can declare parameter with no default value', () => {
+        expect(`
+      ##! experimental.parameters
+      source: ab_new(param::number) is ab
+    `).toTranslate();
+    });
+    test('can declare parameter with default value literal', () => {
+        expect(`
+      ##! experimental.parameters
+      source: ab_new(param::number is 7) is ab
+    `).toTranslate();
+    });
+    test('can declare parameter with default value constant', () => {
+        expect(`
+      ##! experimental.parameters
+      source: ab_new(param::number is 7 + 7) is ab
+    `).toTranslate();
+    });
+    test('cannot specify default value with incompatible type', () => {
+        expect((0, test_translator_1.markSource) `
+      ##! experimental.parameters
+      source: ab_new(param::number is ${'"hello"'}) is ab
+    `).translationToFailWith('Default value for parameter does not match declared type `number`');
+    });
+    test('error if paramter has no type or value', () => {
+        expect((0, test_translator_1.markSource) `
+      ##! experimental.parameters
+      source: ab_new(param) is ab
+    `).translationToFailWith('Parameter must have default value or declared type');
+    });
+    test('error if paramter type is null', () => {
+        expect((0, test_translator_1.markSource) `
+      ##! experimental.parameters
+      source: ab_new(param is null) is ab
+    `).translationToFailWith('Default value cannot have type `null`');
+    });
+    test('error if paramter type is range', () => {
+        expect((0, test_translator_1.markSource) `
+      ##! experimental.parameters
+      source: ab_new(param is 10 to 20) is ab
+    `).translationToFailWith('A Range is not a value');
+    });
+    test('no additional error if default value type is error', () => {
+        expect((0, test_translator_1.markSource) `
+      ##! experimental.parameters
+      source: ab_new(param::number is 1 + "foo") is ab
+    `).translationToFailWith("Non numeric('number,string') value with '+'");
+    });
+    test('can declare parameter with inferred type', () => {
+        expect(`
+      ##! experimental.parameters
+      source: ab_new(param is 7) is ab
+    `).toTranslate();
+    });
+    test('can pass parameter into extended base source', () => {
+        expect(`
+      ##! experimental.parameters
+      source: ab_new(param::number) is ab
+      source: ab_new_new(param::number) is ab_new(param) extend {}
+    `).toTranslate();
+    });
+    test.skip('can pass parameter into source of query', () => {
+        expect(`
+      ##! experimental.parameters
+      source: ab_new(param::number) is ab
+      source: ab_new_new(param::number) is ab_new(param) -> { select: * }
+    `).toTranslate();
+    });
+    test('can pass parameter to override default value with constant', () => {
+        expect(`
+      ##! experimental.parameters
+      source: ab_new(param::number is 10) is ab
+      source: ab_new_new is ab_new(param is 7) extend {}
+    `).toTranslate();
+    });
+    test('can pass parameter to override default value with param value', () => {
+        expect(`
+      ##! experimental.parameters
+      source: ab_new(param::number is 10) is ab
+      source: ab_new_new(param::number is 11) is ab_new(param) extend {}
+    `).toTranslate();
+    });
+    test('can pass parameter into named base source', () => {
+        expect(`
+      ##! experimental.parameters
+      source: ab_new(param::number) is ab
+      source: ab_new_new(param::number) is ab_new(param)
+    `).toTranslate();
+    });
+    test('can pass differently-named parameter into extended base source', () => {
+        expect(`
+      ##! experimental.parameters
+      source: ab_new(new_param::number) is ab
+      source: ab_new_new(new_new_param::number) is ab_new(new_param is new_new_param) extend {}
+    `).toTranslate();
+    });
+    test('can pass differently-named parameter into named base source', () => {
+        expect(`
+      ##! experimental.parameters
+      source: ab_new(new_param::number) is ab
+      source: ab_new_new(new_new_param::number) is ab_new(new_param is new_new_param)
+    `).toTranslate();
+    });
+    test('can pass parameter into base source longhand', () => {
+        expect(`
+      ##! experimental.parameters
+      source: ab_new(param::number) is ab
+      source: ab_new_new(param::number) is ab_new(param is param)
+    `).toTranslate();
+    });
+    test('can pass parameter into base source shorthand', () => {
+        expect(`
+      ##! experimental.parameters
+      source: ab_new(param::number) is ab
+      source: ab_new_new(param::number) is ab_new(param)
+    `).toTranslate();
+    });
+    test('can use declared parameter in dimension', () => {
+        expect(`
+      ##! experimental.parameters
+      source: ab_new(param::number) is ab extend {
+        dimension: param_plus_one is param + 1
+      }
+    `).toTranslate();
+    });
+    test('can use declared parameter in sql function', () => {
+        expect(`
+      ##! experimental { parameters sql_functions }
+      source: ab_new(param::number) is ab extend {
+        dimension: param_plus_one is sql_number("\${param} + 1")
+      }
+      run: ab_new(param is 1) -> param_plus_one
+    `).toTranslate();
+    });
+    test('can use declared parameter in nest extending other', () => {
+        expect(`
+      ##! experimental.parameters
+      source: ab_new(param::number is 10) is ab extend {
+        dimension: p1 is param
+        view: my_view is {
+          group_by: p2 is param
+          nest: nested is {
+            group_by: p3 is param
+          }
+        }
+      }
+      run: ab_new -> my_view
+    `).toTranslate();
+    });
+    test('can use declared parameter in source extension in view', () => {
+        expect(`
+      ##! experimental.parameters
+      source: ab_new(param::number is 10) is ab extend {
+        view: my_view is {
+          extend: {
+            dimension: p1 is param
+          }
+          group_by: p1
+        }
+      }
+    `).toTranslate();
+    });
+    test('can use declared parameter in nest with table', () => {
+        expect(`
+      ##! experimental.parameters
+      source: ab_new(param::number is 10) is _db_.table('aTable') extend {
+        dimension: p1 is param
+        view: my_view is {
+          group_by: p2 is param
+          nest: nested is {
+            group_by: p3 is param
+          }
+        }
+      }
+      run: ab_new -> my_view
+    `).toTranslate();
+    });
+    test('can pass argument for param', () => {
+        expect(`
+      ##! experimental.parameters
+      source: ab_new(param::number) is ab
+      run: ab_new(param is 1) -> { select: * }
+    `).toTranslate();
+    });
+    test('can not pass argument for default-valued param', () => {
+        expect(`
+      ##! experimental.parameters
+      source: ab_new(param is 1) is ab
+      run: ab_new -> { select: * }
+    `).toTranslate();
+    });
+    test('can pass zero args for source with default-valued param', () => {
+        expect(`
+      ##! experimental.parameters
+      source: ab_new(param is 1) is ab
+      run: ab_new() -> { select: * }
+    `).toTranslate();
+    });
+    test('can pass non-literal argument for param', () => {
+        expect(`
+      ##! experimental.parameters
+      source: ab_new(param::number) is ab
+      run: ab_new(param is 1 + 1) -> { select: * }
+    `).toTranslate();
+    });
+    test('parameter not included in wildcard', () => {
+        expect((0, test_translator_1.markSource) `
+      ##! experimental.parameters
+      source: ab_new(param::number) is ab extend {
+        view: all_fields is { select: * }
+      }
+      run: ab_new(param is 1) -> all_fields -> { select: ${'param'} }
+    `).translationToFailWith("'param' is not defined");
+    });
+    test('cannot reference renamed param in query against source', () => {
+        expect((0, test_translator_1.markSource) `
+      ##! experimental.parameters
+      source: ab_new(param::number) is ab
+      run: ab_new(param is 1) -> { select: p is ${'param'} }
+    `).translationToFailWith("'param' is not defined");
+    });
+    test('cannot reference param in query against source', () => {
+        expect((0, test_translator_1.markSource) `
+      ##! experimental.parameters
+      source: ab_new(param::number) is ab
+      run: ab_new(param is 1) -> { select: ${'param'} }
+    `).translationToFailWith("'param' is not defined");
+    });
+    test('cannot reference param in source extension', () => {
+        expect((0, test_translator_1.markSource) `
+      ##! experimental.parameters
+      source: ab_new(param::number) is ab
+      source: x is ab_new(param is 1) extend {
+        dimension: param_copy is ${'param'}
+      }
+    `).translationToFailWith("'param' is not defined");
+    });
+    test('cannot reference param in in-query source extension', () => {
+        expect((0, test_translator_1.markSource) `
+      ##! experimental.parameters
+      source: ab_new(param::number) is ab
+      run: ab_new(param is 1) -> {
+        extend: {
+          dimension: param_copy is ${'param'}
+        }
+        group_by: param_copy
+      }
+    `).translationToFailWith("'param' is not defined");
+    });
+    test('can reference field in source in argument', () => {
+        expect((0, test_translator_1.markSource) `
+      ##! experimental.parameters
+      source: ab_new(param::number) is ab
+      run: ab_new(param is ${'ai'}) -> { select: * }
+    `).translationToFailWith('`ai` is not defined');
+    });
+    test('can pass through parameter to joined source', () => {
+        expect(`
+      ##! experimental.parameters
+      source: ab_ext_1(a_1::string) is ab extend {
+        where: ai = a_1
+      }
+
+      source: ab_ext_2(a_2::string) is ab extend {
+        where: ai = a_2
+        join_many: ab_ext_1 is ab_ext_1(a_1 is a_2) on 1 = 1
+      }
+
+      run: ab_ext_2(a_2 is "CA") -> {
+        group_by:
+          a1 is ai,
+          a2 is ab_ext_1.ai
+        aggregate: c is count()
+      }
+    `).toTranslate();
+    });
+    test.skip('can pass through parameter to source in joined query', () => {
+        expect(`
+      ##! experimental.parameters
+      source: ab_ext_1(a_1::string) is ab extend {
+        where: ai = a_1
+      }
+
+      source: ab_ext_2(a_2::string) is ab extend {
+        where: ai = a_2
+        join_many: ab_ext_1 is ab_ext_1(a_1 is a_2) -> { select: * } on 1 = 1
+      }
+    `).toTranslate();
+    });
+    test.skip('can pass through parameter to view in joined query', () => {
+        expect(`
+      ##! experimental.parameters
+      source: ab_ext(param::string) is ab extend {
+        join_many: abq is ab -> { select: p is param } on 1 = 1
+      }
+    `).toTranslate();
+    });
+    test.skip('can pass through parameter to source in query in SQL source', () => {
+        expect(`
+      ##! experimental.parameters
+      source: ab_ext(param::string) is ab
+      source: sql_query(a_1::string) is duckdb.sql("""
+        SELECT * FROM (%{ ab_ext(param is a_1) -> { select: * } })
+      """)
+    `).toTranslate();
+    });
+    test.skip('can pass through parameter to view in query in SQL source', () => {
+        expect(`
+      ##! experimental.parameters
+      source: sql_query(a_1::string) is duckdb.sql("""
+        SELECT * FROM (%{ ab -> { select: p is param } })
+      """)
+    `).toTranslate();
+    });
+    test.skip('can pass through parameter to source in query in joined SQL source', () => {
+        expect(`
+      ##! experimental.parameters
+      source: ab_ext_1(a_1::string) is ab extend {
+        where: ai = a_1
+      }
+
+      source: ab_ext_2(a_2::string) is ab extend {
+        where: ai = a_2
+        join_many: ab_ext_1 is duckdb.sql("""
+          SELECT * FROM (%{ ab_ext_1(a_1 is a_2) -> { select: * } })
+        """) on 1 = 1
+      }
+    `).toTranslate();
+    });
+    test('can reference param in query against source', () => {
+        expect((0, test_translator_1.markSource) `
+      ##! experimental.parameters
+      source: ab_new(param::number) is ab
+      run: ab_new(param is 1) -> { select: ${'param'} }
+    `).translationToFailWith("'param' is not defined");
+    });
+    test('can reference param in view in source', () => {
+        expect(`
+      ##! experimental.parameters
+      source: ab_new(param::number) is ab extend {
+        view: x is { select: param }
+      }
+    `).toTranslate();
+    });
+    test('can declare dimension which is just the parameter', () => {
+        expect(`
+      ##! experimental.parameters
+      source: ab_new(param::number) is ab extend {
+        dimension: p is param
+      }
+    `).toTranslate();
+    });
+    test('cannot reference param in expression in query against source', () => {
+        expect(`
+      ##! experimental.parameters
+      source: ab_new(param::number) is ab
+      run: ab_new(param is 1) -> { select: p is ${'param'} }
+    `).translationToFailWith("'param' is not defined");
+    });
+    test('error when declaring parameter twice', () => {
+        expect((0, test_translator_1.markSource) `
+        ##! experimental.parameters
+        source: ab_new(param::number, ${'param::number'}) is ab
+      `).translationToFailWith('Cannot redefine parameter `param`');
+    });
+    // This behavior will likely change in the future; but in the meantime, this
+    // safeguards against some confusion about parameter scoping
+    test('error when declaring parameter with same name as field (extended)', () => {
+        expect(`
+        ##! experimental.parameters
+        source: ab_new(ai::string) is ab extend {
+          dimension: foo is upper(ai)
+        }
+      `).translationToFailWith('No matching overload for function upper(number)', 'Illegal shadowing of field `ai` by parameter with the same name');
+    });
+    test('can shadow field that is excepted', () => {
+        expect(`
+        ##! experimental.parameters
+        source: ab_new(ai::string) is ab extend {
+          except: ai
+          dimension: foo is upper(ai)
+        }
+      `).toTranslate();
+    });
+    test('error when declaring parameter with same name as field (not extended)', () => {
+        expect((0, test_translator_1.markSource) `
+        ##! experimental.parameters
+        source: ab_new(${'ai::string'}) is ab
+      `).translationToFailWith('Illegal shadowing of field `ai` by parameter with the same name');
+    });
+    test('do not inherit parameters from base source', () => {
+        expect((0, test_translator_1.markSource) `
+        ##! experimental.parameters
+        source: ab_new(param::number) is ab
+        source: ab_new_new is ab_new(param is 1)
+        run: ab_new_new(${'param'} is 2) -> { select: * }
+      `).translationToFailWith('`ab_new_new` has no declared parameter named `param`');
+    });
+    test('error when declaring field with same name as parameter', () => {
+        expect((0, test_translator_1.markSource) `
+        ##! experimental.parameters
+        source: ab_new(param::number) is ab extend {
+          dimension: param is 1
+        }
+      `).translationToFailWith("Cannot redefine 'param'");
+    });
+    test('error when declaring parameter without experiment enabled', () => {
+        expect((0, test_translator_1.markSource) `
+        source: ab_new(param::number) is ab
+      `).translationToFailWith("Experimental flag 'parameters' required to enable this feature");
+    });
+    test('cannot except parameter from extended source', () => {
+        expect((0, test_translator_1.markSource) `
+        ##! experimental.parameters
+        source: ab_new(param_a::number) is ab
+        source: ab_new_new(param_b::number) is ab_new(param_a is 1) extend {
+          except: param_a
+        }
+      `).translationToFailWith('`param_a` is not defined');
+    });
+    test('cannot except parameter in direct extend', () => {
+        expect((0, test_translator_1.markSource) `
+        ##! experimental.parameters
+        source: ab_new(param::number) is ab extend {
+          except: param
+        }
+      `).translationToFailWith('Illegal `except:` of parameter');
+    });
+    test('cannot accept parameter', () => {
+        expect((0, test_translator_1.markSource) `
+        ##! experimental.parameters
+        source: ab_new(param::number) is ab extend {
+          accept: param
+        }
+      `).translationToFailWith('Illegal `accept:` of parameter');
+    });
+    test('error when using parameter without experiment enabled', () => {
+        expect((0, test_translator_1.markSource) `
+        run: ab_new${'(param is param)'} -> { select: * }
+      `).translationToFailWith("Experimental flag 'parameters' required to enable this feature");
+    });
+    test('parameters cannot reference themselves', () => {
+        expect((0, test_translator_1.markSource) `
+        ##! experimental.parameters
+        source: ab_new(param::number) is ab
+        run: ab_new(param is ${'param'}) -> { select: * }
+      `).translationToFailWith('`param` is not defined');
+    });
+    // This just looks like circular referencing--in reality, you cannot reference other
+    // parameters in parameter arguments, hence just "xxx is not defined"
+    test('error when circularly referencing mutually recursive parameters in argument', () => {
+        expect((0, test_translator_1.markSource) `
+        ##! experimental.parameters
+        source: ab_new(p_a::number, p_b::number) is ab
+        run: ab_new(p_a is ${'p_b'}, p_b is ${'p_a'}) -> { select: * }
+      `).translationToFailWith('`p_b` is not defined', '`p_a` is not defined');
+    });
+    test('error when passing param with no name', () => {
+        expect((0, test_translator_1.markSource) `
+        ##! experimental.parameters
+        source: ab_new(param::number) is ab
+        run: ab_new(${'1'}) -> { select: * }
+      `).translationToFailWith('Parameterized source arguments must be named with `parameter_name is`', 'Argument not provided for required parameter `param`');
+    });
+    test('error when passing param with incorrect name', () => {
+        expect((0, test_translator_1.markSource) `
+        ##! experimental.parameters
+        source: ab_new(param::number) is ab
+        run: ab_new(${'wrong_name'} is 1, param is 2) -> { select: * }
+      `).translationToFailWith('`ab_new` has no declared parameter named `wrong_name`');
+    });
+    test('error when passing param multiple times', () => {
+        expect((0, test_translator_1.markSource) `
+        ##! experimental.parameters
+        source: ab_new(param::number) is ab
+        run: ab_new(param is 1, ${'param is 2'}) -> { select: * }
+      `).translationToFailWith('Cannot pass argument for `param` more than once');
+    });
+    test('error when not specifying argument for param with parentheses', () => {
+        expect((0, test_translator_1.markSource) `
+        ##! experimental.parameters
+        source: ab_new(param::number) is ab
+        run: ${'ab_new'}() -> { select: * }
+      `).translationToFailWith('Argument not provided for required parameter `param`');
+    });
+    test('error when not specifying argument for param without parentheses', () => {
+        expect((0, test_translator_1.markSource) `
+        ##! experimental.parameters
+        source: ab_new(param::number) is ab
+        run: ${'ab_new'} -> { select: * }
+      `).translationToFailWith('Argument not provided for required parameter `param`');
+    });
+    test('error when not specifying argument for param second time', () => {
+        expect((0, test_translator_1.markSource) `
+        ##! experimental.parameters
+        source: ab_new(param::number) is ab
+        run: ab_new(param is 1) -> { select: * }
+        run: ${'ab_new'} -> { select: * }
+      `).translationToFailWith('Argument not provided for required parameter `param`');
+    });
+    test('error when referencing parameter that does not exist in join definition', () => {
+        expect((0, test_translator_1.markSource) `
+        ##! experimental.parameters
+        source: ab_new_1(param_1::number) is ab
+        source: ab_new_2(param_2::number) is ab extend {
+          join_one: ab_join is ab_new_1(param_1 is ${'param_3'})
+        }
+      `).translationToFailWith('`param_3` is not defined');
+    });
+    test('error when referencing identifier in default param value', () => {
+        expect((0, test_translator_1.markSource) `
+        ##! experimental.parameters
+        source: ab_new_1(param_1 is ${'ident'}) is ab
+      `).translationToFailWith('Only constants allowed in parameter default values');
+    });
+    test.skip('can use param in multi-stage query', () => {
+        expect(`
+      ##! experimental.parameters
+      source: ab_new(param::number) is ab extend {
+        view: q is {
+          select: *
+        } -> {
+          group_by: x is param
+        }
+      }
+    `).toTranslate();
+    });
+    test('can not pass parameter into source of query yet', () => {
+        expect((0, test_translator_1.markSource) `
+      ##! experimental.parameters
+      source: ab_new(param::number) is ab
+      source: ab_new_new(param::number) is ab_new(${'param'}) -> { select: * }
+    `).translationToFailWith('`param` is not defined');
+    });
+    test.skip('can add an annotation to a param', () => {
+        expect(`
+      ##! experimental.parameters
+      source: ab_new(
+        # mytag=1
+        param::number
+      ) is ab
+    `).toTranslate();
+    });
+    test('source arguments from query propagate as arguments not parameters', () => {
+        expect(`
+      ##! experimental.parameters
+      source: ab_new(param::number) is ab extend {
+        dimension: param_value is param
+      }
+      query: foo is ab_new(param is 1) -> { select: param_value }
+      source: foo_ext is foo
+      run: foo_ext -> { select: param_value }
+    `).toTranslate();
+    });
+    test('source arguments carry over from previous invocation', () => {
+        expect(`
+      ##! experimental.parameters
+      source: ab_new(param::number) is ab extend {
+        dimension: param_value is param
+      }
+      source: foo is ab_new(param is 1)
+      source: foo_ext is foo
+      run: foo_ext -> { select: param_value }
+    `).toTranslate();
+    });
+});
+//# sourceMappingURL=parameters.spec.js.map

package/dist/model/malloy_query.d.ts

@@ -1,5 +1,5 @@
 import { Dialect, DialectFieldList } from '../dialect';
-import { AggregateFragment, AggregateFunctionType, Annotation, CompiledQuery, DialectFragment, Expr, FieldDef, FieldFragment, Filtered, FilterExpression, FilterFragment, FunctionCallFragment, FunctionOverloadDef, FunctionParameterDef, JoinRelationship, ModelDef, OrderBy, OutputFieldFragment, Parameter, ParameterFragment, PipeSegment, Query, QueryFieldDef, QuerySegment, ResultMetadataDef, ResultStructMetadataDef, SearchIndexResult, SourceReferenceFragment, SegmentFieldDef, SpreadFragment, SQLExpressionFragment, SqlStringFragment, StructDef, StructRef, TurtleDef, UngroupFragment, FunctionOrderBy } from './malloy_types';
+import { AggregateFragment, AggregateFunctionType, Annotation, CompiledQuery, DialectFragment, Expr, FieldDef, FieldFragment, Filtered, FilterExpression, FilterFragment, FunctionCallFragment, FunctionOverloadDef, FunctionParameterDef, JoinRelationship, ModelDef, OrderBy, OutputFieldFragment, Parameter, ParameterFragment, PipeSegment, Query, QueryFieldDef, QuerySegment, ResultMetadataDef, ResultStructMetadataDef, SearchIndexResult, SourceReferenceFragment, SegmentFieldDef, SpreadFragment, SQLExpressionFragment, SqlStringFragment, StructDef, StructRef, TurtleDef, UngroupFragment, FunctionOrderBy, Argument } from './malloy_types';
 import { Connection } from '../runtime_types';
 import { AndChain } from './utils';
 import { QueryInfo } from '../dialect/dialect';
@@ -76,7 +76,7 @@ declare class QueryField extends QueryNode {
     getParamForArgIndex(params: FunctionParameterDef[], argIndex: number): FunctionParameterDef;
     generateFunctionCallExpression(resultSet: FieldInstanceResult, context: QueryStruct, frag: FunctionCallFragment, state: GenerateState): string;
     generateSpread(_resultSet: FieldInstanceResult, _context: QueryStruct, _frag: SpreadFragment, _state: GenerateState): string;
-    generateParameterFragment(resultSet: FieldInstanceResult, context: QueryStruct, expr: ParameterFragment, _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: Expr, state: GenerateState): string;
     generateUngroupedFragment(resultSet: FieldInstanceResult, context: QueryStruct, expr: UngroupFragment, state: GenerateState): string;
@@ -284,6 +284,7 @@ declare class QueryQuery extends QueryField {
 }
 /** Structure object as it is used to build a query */
 declare class QueryStruct extends QueryNode {
+    readonly sourceArguments: Record<string, Argument> | undefined;
     fieldDef: StructDef;
     parent: QueryStruct | undefined;
     model: QueryModel;
@@ -291,8 +292,10 @@ declare class QueryStruct extends QueryNode {
     pathAliasMap: Map<string, string>;
     dialect: Dialect;
     connectionName: string;
-    constructor(fieldDef: StructDef, parent: ParentQueryStruct | ParentQueryModel);
-    parameters(): Record<string, Parameter>;
+    constructor(fieldDef: StructDef, sourceArguments: Record<string, Argument> | undefined, parent: ParentQueryStruct | ParentQueryModel);
+    resolveParentParameterReferences(param: Parameter): Parameter;
+    private _arguments;
+    arguments(): Record<string, Argument>;
     addFieldsFromFieldList(fields: FieldDef[]): void;
     getAliasIdentifier(): string;
     getSQLIdentifier(): string;
@@ -346,7 +349,7 @@ export declare class QueryModel {
     constructor(modelDef: ModelDef | undefined);
     loadModelFromDef(modelDef: ModelDef): void;
     getStructByName(name: string): QueryStruct;
-    getStructFromRef(structRef: StructRef): QueryStruct;
+    getStructFromRef(structRef: StructRef, sourceArguments: Record<string, Argument> | undefined): QueryStruct;
     loadQuery(query: Query, stageWriter: StageWriter | undefined, emitFinalStage?: boolean, isJoinedSubquery?: boolean): QueryResults;
     compileQuery(query: Query, finalize?: boolean): CompiledQuery;
     exploreSearchSQLMap: Map<any, any>;