@malloydata/malloy 0.0.177-dev240828173040 → 0.0.177-dev240829030921

package/dist/lang/lib/Malloy/MalloyParserListener.d.ts

@@ -40,7 +40,6 @@ import { ExprNotContext } from "./MalloyParser";
 import { ExprLogicalAndContext } from "./MalloyParser";
 import { ExprLogicalOrContext } from "./MalloyParser";
 import { ExprCoalesceContext } from "./MalloyParser";
-import { ExprCountDisinctContext } from "./MalloyParser";
 import { ExprPathlessAggregateContext } from "./MalloyParser";
 import { ExprAggregateContext } from "./MalloyParser";
 import { ExprExprContext } from "./MalloyParser";
@@ -707,18 +706,6 @@ export interface MalloyParserListener extends ParseTreeListener {
      * @param ctx the parse tree
      */
     exitExprCoalesce?: (ctx: ExprCoalesceContext) => void;
-    /**
-     * Enter a parse tree produced by the `exprCountDisinct`
-     * labeled alternative in `MalloyParser.fieldExpr`.
-     * @param ctx the parse tree
-     */
-    enterExprCountDisinct?: (ctx: ExprCountDisinctContext) => void;
-    /**
-     * Exit a parse tree produced by the `exprCountDisinct`
-     * labeled alternative in `MalloyParser.fieldExpr`.
-     * @param ctx the parse tree
-     */
-    exitExprCountDisinct?: (ctx: ExprCountDisinctContext) => void;
     /**
      * Enter a parse tree produced by the `exprPathlessAggregate`
      * labeled alternative in `MalloyParser.fieldExpr`.

package/dist/lang/lib/Malloy/MalloyParserVisitor.d.ts

@@ -40,7 +40,6 @@ import { ExprNotContext } from "./MalloyParser";
 import { ExprLogicalAndContext } from "./MalloyParser";
 import { ExprLogicalOrContext } from "./MalloyParser";
 import { ExprCoalesceContext } from "./MalloyParser";
-import { ExprCountDisinctContext } from "./MalloyParser";
 import { ExprPathlessAggregateContext } from "./MalloyParser";
 import { ExprAggregateContext } from "./MalloyParser";
 import { ExprExprContext } from "./MalloyParser";
@@ -505,13 +504,6 @@ export interface MalloyParserVisitor<Result> extends ParseTreeVisitor<Result> {
      * @return the visitor result
      */
     visitExprCoalesce?: (ctx: ExprCoalesceContext) => Result;
-    /**
-     * Visit a parse tree produced by the `exprCountDisinct`
-     * labeled alternative in `MalloyParser.fieldExpr`.
-     * @param ctx the parse tree
-     * @return the visitor result
-     */
-    visitExprCountDisinct?: (ctx: ExprCountDisinctContext) => Result;
     /**
      * Visit a parse tree produced by the `exprPathlessAggregate`
      * labeled alternative in `MalloyParser.fieldExpr`.

package/dist/lang/malloy-to-ast.d.ts

@@ -167,7 +167,6 @@ export declare class MalloyToAST extends AbstractParseTreeVisitor<ast.MalloyElem
     visitExprAddSub(pcx: parse.ExprAddSubContext): ast.ExprAddSub;
     visitExprMulDiv(pcx: parse.ExprMulDivContext): ast.ExprMulDiv;
     visitExprCompare(pcx: parse.ExprCompareContext): ast.ExprCompare;
-    visitExprCountDisinct(pcx: parse.ExprCountDisinctContext): ast.ExprCountDistinct;
     visitExprUngroup(pcx: parse.ExprUngroupContext): ast.ExprUngroup;
     symmetricAggregateUsageError(aggFunc: string): string;
     asymmetricAggregateUsageError(aggFunc: string): string;

package/dist/lang/malloy-to-ast.js

@@ -919,10 +919,6 @@ class MalloyToAST extends AbstractParseTreeVisitor_1.AbstractParseTreeVisitor {
         }
         throw this.internalError(pcx, `untranslatable comparison operator '${op}'`);
     }
-    visitExprCountDisinct(pcx) {
-        this.m4advisory(pcx, '`count(distinct expression)` deprecated, use `count(expression)` instead');
-        return this.astAt(new ast.ExprCountDistinct(this.getFieldExpr(pcx.fieldExpr())), pcx);
-    }
     visitExprUngroup(pcx) {
         const flist = pcx.fieldName().map(fcx => this.getFieldName(fcx));
         const kw = pcx.ungroup().text.toLowerCase();

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

@@ -22,31 +22,42 @@
  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-const model_1 = require("../../model");
 const test_translator_1 = require("./test-translator");
 require("./parse-expects");
 /**
- * Convert an expression to a string, any fragment which is not a string turns into a variable,
- * useful for maybe checking simple code generation, but it sort of hints at an interesting matcher
- * @param expr Compiled expression
- * @returns A string with variables A,B,... substituded for non string elements
+ * Try and write a generic version of the expression, might some day be the basis for
+ * a much better expression matcher.
  */
-function exprToString(expr) {
-    let varCode = 'A'.charCodeAt(0);
-    const vars = {};
-    return expr
-        .map(f => {
-        if (typeof f === 'string') {
-            return f;
-        }
-        const key = JSON.stringify(f);
-        if (!vars[key]) {
-            vars[key] = String.fromCharCode(varCode);
-            varCode += 1;
-        }
-        return vars[key];
-    })
-        .join('');
+function exprToString(e, symbols = {}) {
+    switch (e.node) {
+        case '=':
+        case '>':
+        case '>=':
+        case '<':
+        case '<=':
+        case '+':
+        case '-':
+        case '*':
+        case '/':
+        case '%':
+            return `${exprToString(e.kids.left, symbols)}${e.node}${exprToString(e.kids.right, symbols)}`;
+        case 'and':
+        case 'or':
+            return `(${exprToString(e.kids.left, symbols)})${e.node}(${exprToString(e.kids.right, symbols)})`;
+        case 'field': {
+            const ref = e.path.join('.');
+            if (symbols[ref] === undefined) {
+                const nSyms = Object.keys(symbols).length;
+                symbols[ref] = String.fromCharCode('A'.charCodeAt(0) + nSyms);
+            }
+            return symbols[ref];
+        }
+        case '()':
+            return `(${exprToString(e.e, symbols)})`;
+        case 'not':
+            return `not(${exprToString(e.e, symbols)})`;
+    }
+    return `{${e.node}}`;
 }
 describe('expressions', () => {
     describe('timeframes', () => {
@@ -160,25 +171,25 @@ describe('expressions', () => {
             const compare = (0, test_translator_1.expr) `ad = ad.quarter`;
             expect(compare).toTranslate();
             const compare_expr = compare.translator.generated().value;
-            expect(exprToString(compare_expr)).toEqual('A=B');
+            expect(exprToString(compare_expr)).toEqual('A={trunc}');
         });
         test('compare to granular result expression uses straight comparison', () => {
             const compare = (0, test_translator_1.expr) `ad = ad.quarter + 1`;
             expect(compare).toTranslate();
             const compare_expr = compare.translator.generated().value;
-            expect(exprToString(compare_expr)).toEqual('A=B');
+            expect(exprToString(compare_expr)).toEqual('A={delta}');
         });
         test('apply granular-truncation uses range', () => {
             const compare = (0, test_translator_1.expr) `ad ? ad.quarter`;
             expect(compare).toTranslate();
             const compare_expr = compare.translator.generated().value;
-            expect(exprToString(compare_expr)).toEqual('(A>=B)and(A<C)');
+            expect(exprToString(compare_expr)).toEqual('(A>={trunc})and(A<{delta})');
         });
-        test('apply granular-literal alternation uses range', () => {
+        test('apply granular-literal alternation uses all literals for range', () => {
             const compare = (0, test_translator_1.expr) `ad ? @2020 | @2022`;
             expect(compare).toTranslate();
             const compare_expr = compare.translator.generated().value;
-            expect(exprToString(compare_expr)).toEqual('((A>=B)and(A<C))or((A>=D)and(A<E))');
+            expect(exprToString(compare_expr)).toEqual('((A>={timeLiteral})and(A<{timeLiteral}))or((A>={timeLiteral})and(A<{timeLiteral}))');
         });
         // this should use range, but it uses = and alternations are
         // kind of needing help so this is a placeholder for
@@ -700,13 +711,6 @@ describe('expressions', () => {
         calculate: bar is lag(sum(output))
       }`).translationToFailWith("'output' is not defined");
         });
-        test('count(distinct column)', () => {
-            expect((0, test_translator_1.model) `
-      ##! m4warnings=warn
-      run: a -> {
-        aggregate: x is count(distinct astr)
-      }`).toTranslateWithWarnings('`count(distinct expression)` deprecated, use `count(expression)` instead');
-        });
     });
     describe('pick statements', () => {
         test('full', () => {
@@ -807,59 +811,11 @@ describe('expressions', () => {
         });
     });
     test('paren and applied div', () => {
-        var _a, _b;
-        const modelSrc = 'query: z is a -> { group_by: x is 1+(3/4) }';
-        const m = new test_translator_1.TestTranslator(modelSrc);
-        expect(m).toTranslate();
-        const queryDef = (_b = (_a = m.translate()) === null || _a === void 0 ? void 0 : _a.translated) === null || _b === void 0 ? void 0 : _b.modelDef.contents['z'];
-        expect(queryDef).toBeDefined();
-        expect(queryDef === null || queryDef === void 0 ? void 0 : queryDef.type).toBe('query');
-        if (queryDef && queryDef.type === 'query') {
-            const qSeg = queryDef.pipeline[0];
-            expect(qSeg.type).toEqual('reduce');
-            if (qSeg.type === 'reduce') {
-                const x = qSeg.queryFields[0];
-                if (x.type !== 'fieldref' &&
-                    (0, model_1.isFieldTypeDef)(x) &&
-                    x.type === 'number' &&
-                    x.e) {
-                    expect(x).toMatchObject({
-                        'e': [
-                            {
-                                'function': 'numberLiteral',
-                                'literal': '1',
-                                'type': 'dialect',
-                            },
-                            // TODO not sure why there are TWO sets of parentheses... A previous version of this test
-                            // just checked that there were ANY parens, so that went under the radar. Not fixing now.
-                            '+((',
-                            {
-                                'denominator': [
-                                    {
-                                        'function': 'numberLiteral',
-                                        'literal': '4',
-                                        'type': 'dialect',
-                                    },
-                                ],
-                                'function': 'div',
-                                'numerator': [
-                                    {
-                                        'function': 'numberLiteral',
-                                        'literal': '3',
-                                        'type': 'dialect',
-                                    },
-                                ],
-                                'type': 'dialect',
-                            },
-                            '))',
-                        ],
-                    });
-                }
-                else {
-                    fail('expression with parens compiled oddly');
-                }
-            }
-        }
+        const one34 = (0, test_translator_1.expr) `1+(3/4)`;
+        expect(one34).toTranslate();
+        const exprVal = one34.translator.generated();
+        const exprE = exprVal.value;
+        expect(exprToString(exprE)).toEqual('{numberLiteral}+({numberLiteral}/{numberLiteral})');
     });
     test.each([
         ['ats', 'timestamp'],

package/dist/lang/test/field-symbols.spec.js

@@ -144,11 +144,13 @@ describe('structdef comprehension', () => {
             structRelationship: {
                 type: 'one',
                 matrixOperation: 'left',
-                onExpression: [
-                    { type: 'field', path: ['aKey'] },
-                    '=',
-                    { type: 'field', path: ['t', 'a'] },
-                ],
+                onExpression: {
+                    node: '=',
+                    kids: {
+                        left: { node: 'field', path: ['aKey'] },
+                        right: { node: 'field', path: ['t', 'a'] },
+                    },
+                },
             },
             structSource: { type: 'table', tablePath: 't' },
             fields: [{ type: 'string', name: 'a' }],
@@ -187,7 +189,7 @@ describe('structdef comprehension', () => {
             cOptStr: {
                 name: 'cOptStr',
                 type: 'string',
-                value: ['value'],
+                value: { node: 'stringLiteral', literal: 'value' },
             },
         };
         const space = new static_space_1.StaticSpace(struct);

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

@@ -33,7 +33,7 @@ describe('literals', () => {
     test('string', () => {
         const m = new test_translator_1.BetaExpression("'forty two'");
         expect(m).toTranslate();
-        const m42 = m.generated().value[0];
+        const m42 = m.generated().value;
         expect(m42).toMatchObject({ literal: 'forty two' });
     });
     test('string with quoted quote', () => {
@@ -99,7 +99,7 @@ describe('literals', () => {
         else {
             expect((0, granular_result_1.isGranularResult)(ir)).toBeFalsy();
         }
-        expect(ir.value[0]).toEqual(expect.objectContaining(result));
+        expect(ir.value).toEqual(expect.objectContaining(result));
     });
     const morphicLiterals = [
         ['@1960', '1960-01-01 00:00:00'],
@@ -117,7 +117,7 @@ describe('literals', () => {
         if (morphic) {
             expect(morphTo).toBeDefined();
             if (morphTo) {
-                expect(morphTo[0]).toEqual(expect.objectContaining({ literal: morphic }));
+                expect(morphTo).toEqual(expect.objectContaining({ literal: morphic }));
             }
         }
         else {
@@ -187,7 +187,7 @@ describe('literals', () => {
               right
         """`);
             expect(checking).toTranslate();
-            const v = checking.generated().value[0];
+            const v = checking.generated().value;
             expect(v).toMatchObject({ literal: '\nleft\n  mid\n    right\n' });
         });
         test('multi-line indent decreasing', () => {
@@ -197,13 +197,13 @@ describe('literals', () => {
           left
         """`);
             expect(checking).toTranslate();
-            const v = checking.generated().value[0];
+            const v = checking.generated().value;
             expect(v).toMatchObject({ literal: '\n    right\n  mid\nleft\n' });
         });
         test('multi-line indent keep', () => {
             const checking = new test_translator_1.BetaExpression('"""right\n  mid\nleft"""');
             expect(checking).toTranslate();
-            const v = checking.generated().value[0];
+            const v = checking.generated().value;
             expect(v).toMatchObject({ literal: 'right\n  mid\nleft' });
         });
         test('timezone single quote', () => {

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

@@ -41,7 +41,7 @@ exports.CHILD_EXPLORE = {
             type: 'number',
             name: 'flight_count',
             expressionType: 'aggregate',
-            e: [{ type: 'aggregate', function: 'count', e: [] }],
+            e: { node: 'aggregate', function: 'count', e: { node: '' } },
         },
     ],
 };
@@ -62,7 +62,7 @@ exports.PARENT_EXPLORE = {
             type: 'number',
             name: 'some_parent_count',
             expressionType: 'aggregate',
-            e: [{ type: 'aggregate', function: 'count', e: [] }],
+            e: { node: 'aggregate', function: 'count', e: { node: '' } },
         },
     ],
 };
@@ -83,7 +83,7 @@ exports.GRADPARENT_EXPLORE = {
             type: 'number',
             name: 'some_gradparent_count',
             expressionType: 'aggregate',
-            e: [{ type: 'aggregate', function: 'count', e: [] }],
+            e: { node: 'aggregate', function: 'count', e: { node: '' } },
         },
     ],
 };
@@ -104,14 +104,14 @@ exports.SOURCE_EXPLORE = {
             type: 'number',
             name: 'some_child_count',
             expressionType: 'aggregate',
-            e: [{ type: 'aggregate', function: 'count', e: [] }],
+            e: { node: 'aggregate', function: 'count', e: { node: '' } },
         },
     ],
 };
 describe('serializeModel', () => {
     test('Stringify on an `explore` with no parent nor source explore', async () => {
         const parent_explore = new malloy_1.Explore(exports.PARENT_EXPLORE);
-        expect(JSON.stringify(parent_explore)).toStrictEqual('{"_structDef":{"type":"struct","name":"some_ns.parent","as":"parent","dialect":"standardsql","structSource":{"type":"table","tablePath":"some_ns.parent"},"structRelationship":{"type":"basetable","connectionName":"bigquery"},"primaryKey":"id2","fields":[{"type":"string","name":"name"},{"type":"number","name":"some_parent_count","expressionType":"aggregate","e":[{"type":"aggregate","function":"count","e":[]}]}]}}');
+        expect(JSON.stringify(parent_explore)).toStrictEqual('{"_structDef":{"type":"struct","name":"some_ns.parent","as":"parent","dialect":"standardsql","structSource":{"type":"table","tablePath":"some_ns.parent"},"structRelationship":{"type":"basetable","connectionName":"bigquery"},"primaryKey":"id2","fields":[{"type":"string","name":"name"},{"type":"number","name":"some_parent_count","expressionType":"aggregate","e":{"node":"aggregate","function":"count","e":{"node":""}}}]}}');
     });
     test('No parent nor source explore', async () => {
         const parent_explore = new malloy_1.Explore(exports.PARENT_EXPLORE);

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

@@ -210,7 +210,7 @@ class TestTranslator extends parse_malloy_1.MalloyTranslator {
         this.allDialectsEnabled = true;
         /*
          * All test source files can assume that an import of this
-         * model has already happened.
+      
          *
          * Also the following tables will be available on _db_
          *   aTable, malloytest.carriers, malloytest.flights, malloytest.airports
@@ -242,11 +242,13 @@ class TestTranslator extends parse_malloy_1.MalloyTranslator {
                             structRelationship: {
                                 type: 'one',
                                 matrixOperation: 'left',
-                                onExpression: [
-                                    { type: 'field', path: ['astr'] },
-                                    '=',
-                                    { type: 'field', path: ['b', 'astr'] },
-                                ],
+                                onExpression: {
+                                    node: '=',
+                                    kids: {
+                                        left: { node: 'field', path: ['astr'] },
+                                        right: { node: 'field', path: ['b', 'astr'] },
+                                    },
+                                },
                             },
                         },
                         {
@@ -254,7 +256,7 @@ class TestTranslator extends parse_malloy_1.MalloyTranslator {
                             name: 'acount',
                             numberType: 'integer',
                             expressionType: 'aggregate',
-                            e: ['COUNT()'],
+                            e: { node: 'aggregate', function: 'count', e: { node: '' } },
                             code: 'count()',
                         },
                         {

package/dist/malloy.d.ts

@@ -2,7 +2,7 @@
 import { RunSQLOptions } from './run_sql_options';
 import { DocumentCompletion as DocumentCompletionDefinition, DocumentSymbol as DocumentSymbolDefinition, LogMessage, MalloyTranslator } from './lang';
 import { DocumentHelpContext } from './lang/parse-tree-walkers/document-help-context-walker';
-import { CompiledQuery, DocumentLocation, DocumentReference, FieldBooleanDef, FieldDateDef, FieldJSONDef, FieldNumberDef, FieldStringDef, FieldTimestampDef, FieldTypeDef, FilterExpression, Query as InternalQuery, ModelDef, DocumentPosition as ModelDocumentPosition, NamedQuery, QueryData, QueryDataRow, QueryResult, SQLBlock, SQLBlockSource, SQLBlockStructDef, SearchIndexResult, SearchValueMapResult, StructDef, TurtleDef, FeldNativeUnsupportedDef, QueryRunStats, ImportLocation, Annotation } from './model';
+import { CompiledQuery, DocumentLocation, DocumentReference, FieldBooleanDef, FieldDateDef, FieldJSONDef, FieldNumberDef, FieldStringDef, FieldTimestampDef, FieldTypeDef, FilterCondition, Query as InternalQuery, ModelDef, DocumentPosition as ModelDocumentPosition, NamedQuery, QueryData, QueryDataRow, QueryResult, SQLBlock, SQLBlockSource, SQLBlockStructDef, SearchIndexResult, SearchValueMapResult, StructDef, TurtleDef, FeldNativeUnsupportedDef, QueryRunStats, ImportLocation, Annotation } from './model';
 import { ModelString, ModelURL, QueryString, QueryURL, URLReader } from './runtime_types';
 import { Connection, InfoConnection, LookupConnection } from './connection/types';
 import { Tag, TagParse, TagParseSpec, Taggable } from './tags';
@@ -459,7 +459,7 @@ export declare class PreparedResult implements Taggable {
     get resultExplore(): Explore;
     get sourceExplore(): Explore;
     get _sourceExploreName(): string;
-    get _sourceFilters(): FilterExpression[];
+    get _sourceFilters(): FilterCondition[];
 }
 /**
  * A URL reader which always throws an error when a URL's contents is requested.
@@ -578,7 +578,7 @@ export declare class Explore extends Entity implements Taggable {
     get parentExplore(): Explore | undefined;
     get sourceRelationship(): SourceRelationship;
     hasParentExplore(): this is ExploreField;
-    get filters(): FilterExpression[];
+    get filters(): FilterCondition[];
     get limit(): number | undefined;
     get structDef(): StructDef;
     get queryTimezone(): string | undefined;

package/dist/malloy.js

@@ -1146,7 +1146,7 @@ class Explore extends Entity {
     hasParentExplore() {
         return this instanceof ExploreField;
     }
-    // TODO wrapper type for FilterExpression
+    // TODO wrapper type for FilterCondition
     get filters() {
         var _a;
         return ((_a = this.structDef.resultMetadata) === null || _a === void 0 ? void 0 : _a.filterList) || [];

package/dist/model/index.d.ts

@@ -1,3 +1,3 @@
 export * from './malloy_types';
 export { Segment, QueryModel } from './malloy_query';
-export { indent } from './utils';
+export { indent, composeSQLExpr } from './utils';

package/dist/model/index.js

@@ -36,11 +36,12 @@ 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.indent = exports.QueryModel = exports.Segment = void 0;
+exports.composeSQLExpr = exports.indent = 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; } });
 var utils_1 = require("./utils");
 Object.defineProperty(exports, "indent", { enumerable: true, get: function () { return utils_1.indent; } });
+Object.defineProperty(exports, "composeSQLExpr", { enumerable: true, get: function () { return utils_1.composeSQLExpr; } });
 //# sourceMappingURL=index.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, Argument } from './malloy_types';
+import { AggregateFunctionType, Annotation, CompiledQuery, Expr, FieldDef, Filtered, FunctionOverloadDef, FunctionParameterDef, JoinRelationship, ModelDef, OrderBy, OutputFieldNode, Parameter, ParameterNode, PipeSegment, Query, QueryFieldDef, QuerySegment, ResultMetadataDef, ResultStructMetadataDef, SearchIndexResult, SegmentFieldDef, StructDef, StructRef, TurtleDef, FunctionOrderBy, Argument, AggregateExpr, FilterCondition, GenericSQLExpr, FieldnameNode, FunctionCallNode, UngroupNode, SourceReferenceNode, PickExpr, SpreadExpr, FilteredExpr } from './malloy_types';
 import { Connection } from '../connection/types';
 import { AndChain } from './utils';
 import { QueryInfo } from '../dialect/dialect';
@@ -66,31 +66,30 @@ declare class QueryField extends QueryNode {
     getJoinableParent(): QueryStruct;
     caseGroup(groupSets: number[], s: string): string;
     getFullOutputName(): string;
-    generateFieldFragment(resultSet: FieldInstanceResult, context: QueryStruct, expr: FieldFragment, state: GenerateState): string;
-    generateOutputFieldFragment(resultSet: FieldInstanceResult, _context: QueryStruct, frag: OutputFieldFragment, _state: GenerateState): string;
-    generateSQLExpression(resultSet: FieldInstanceResult, context: QueryStruct, frag: SQLExpressionFragment, state: GenerateState): string;
+    generateFieldFragment(resultSet: FieldInstanceResult, context: QueryStruct, expr: FieldnameNode, state: GenerateState): string;
+    generateOutputFieldFragment(resultSet: FieldInstanceResult, _context: QueryStruct, frag: OutputFieldNode, _state: GenerateState): string;
+    stringsFromSQLExpression(resultSet: FieldInstanceResult, context: QueryStruct, e: GenericSQLExpr, state: GenerateState): Generator<string, void, unknown>;
     private getParameterMap;
     private expandFunctionCall;
     getFunctionOrderBy(resultSet: FieldInstanceResult, context: QueryStruct, state: GenerateState, orderBy: FunctionOrderBy[], args: Expr[], overload: FunctionOverloadDef): string | undefined;
     generateAsymmetricStringAggExpression(resultSet: FieldInstanceResult, context: QueryStruct, value: Expr, separator: Expr | undefined, distinctKey: string, orderBy: FunctionOrderBy[] | undefined, dialectName: string, state: GenerateState): string;
     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;
-    generateFilterFragment(resultSet: FieldInstanceResult, context: QueryStruct, expr: FilterFragment, state: GenerateState): string;
+    generateFunctionCallExpression(resultSet: FieldInstanceResult, context: QueryStruct, frag: FunctionCallNode, state: GenerateState): string;
+    generateSpread(_resultSet: FieldInstanceResult, _context: QueryStruct, _frag: SpreadExpr, _state: GenerateState): string;
+    generateParameterFragment(resultSet: FieldInstanceResult, context: QueryStruct, expr: ParameterNode, state: GenerateState): string;
+    generateFilterFragment(resultSet: FieldInstanceResult, context: QueryStruct, expr: FilteredExpr, state: GenerateState): string;
     generateDimFragment(resultSet: FieldInstanceResult, context: QueryStruct, expr: Expr, state: GenerateState): string;
-    generateUngroupedFragment(resultSet: FieldInstanceResult, context: QueryStruct, expr: UngroupFragment, state: GenerateState): string;
+    generateUngroupedFragment(resultSet: FieldInstanceResult, context: QueryStruct, expr: UngroupNode, 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;
-    generateSqlString(resultSet: FieldInstanceResult, context: QueryStruct, expr: SqlStringFragment, state: GenerateState): string;
-    generateSourceReference(resultSet: FieldInstanceResult, context: QueryStruct, expr: SourceReferenceFragment): string;
+    generateSumFragment(resultSet: FieldInstanceResult, context: QueryStruct, expr: AggregateExpr, state: GenerateState): string;
+    generateSymmetricFragment(resultSet: FieldInstanceResult, context: QueryStruct, expr: AggregateExpr, state: GenerateState): string;
+    generateAvgFragment(resultSet: FieldInstanceResult, context: QueryStruct, expr: AggregateExpr, state: GenerateState): string;
+    generateCountFragment(resultSet: FieldInstanceResult, context: QueryStruct, expr: AggregateExpr, state: GenerateState): string;
+    generateSourceReference(resultSet: FieldInstanceResult, context: QueryStruct, expr: SourceReferenceNode): string;
     getAnalyticPartitions(resultStruct: FieldInstanceResult, extraPartitionFields?: string[]): string[];
     generateAnalyticFragment(resultStruct: FieldInstanceResult, context: QueryStruct, expr: Expr, overload: FunctionOverloadDef, state: GenerateState, args: Expr[], partitionByFields?: string[], funcOrdering?: string): string;
-    generateExpressionFromExpr(resultSet: FieldInstanceResult, context: QueryStruct, e: Expr, state?: GenerateState): string;
+    generatePickSQL(pf: PickExpr): string;
+    exprToSQL(resultSet: FieldInstanceResult, context: QueryStruct, exprToTranslate: Expr, state?: GenerateState): string;
     getExpr(): Expr;
     generateExpression(resultSet: FieldInstanceResult): string;
 }
@@ -98,7 +97,7 @@ declare class QueryAtomicField extends QueryField {
     includeInWildcard(): boolean;
     isCalculated(): boolean;
     isAggregate(): boolean;
-    getFilterList(): FilterExpression[];
+    getFilterList(): FilterCondition[];
     hasExpression(): boolean;
 }
 declare class QueryFieldBoolean extends QueryAtomicField {
@@ -148,6 +147,12 @@ declare class FieldInstanceResult implements FieldInstance {
     ungroupedSets: Map<string, UngroupSet>;
     resultUsesUngrouped: boolean;
     constructor(turtleDef: TurtleDef, parent: FieldInstanceResult | undefined);
+    /**
+     * Information about the query containing this result set. Invented
+     * to pass on timezone information, but maybe more things will
+     * eventually go in here.
+     * @returns QueryInfo
+     */
     getQueryInfo(): QueryInfo;
     addField(as: string, field: QueryField, usage: FieldUsage): void;
     parentGroupSet(): number;
@@ -249,7 +254,7 @@ declare class QueryQuery extends QueryField {
     getSegmentFields(resultStruct: FieldInstanceResult): SegmentFieldDef[];
     expandFields(resultStruct: FieldInstanceResult): void;
     expandFilters(resultStruct: FieldInstanceResult): void;
-    generateSQLFilters(resultStruct: FieldInstanceResult, which: 'where' | 'having', filterList?: FilterExpression[] | undefined): AndChain;
+    generateSQLFilters(resultStruct: FieldInstanceResult, which: 'where' | 'having'): AndChain;
     prepare(_stageWriter: StageWriter | undefined): void;
     getResultMetadata(fi: FieldInstance): ResultStructMetadataDef | ResultMetadataDef | undefined;
     /**  returns a fields and primary key of a struct for this query */