@malloydata/malloy 0.0.80-dev230907183434 → 0.0.80

package/dist/lang/ast/expressions/expr-aggregate-function.d.ts

@@ -1,4 +1,4 @@
-import { FieldValueType } from '../../../model/malloy_types';
+import { FieldValueType, StructRelationship } from '../../../model/malloy_types';
 import { FieldReference } from '../query-items/field-references';
 import { ExprValue } from '../types/expr-value';
 import { ExpressionDef } from '../types/expression-def';
@@ -8,8 +8,14 @@ export declare abstract class ExprAggregateFunction extends ExpressionDef {
     elementType: string;
     source?: FieldReference;
     expr?: ExpressionDef;
+    explicitSource?: boolean;
     legalChildTypes: import("../../../model/malloy_types").TypeDesc[];
-    constructor(func: string, expr?: ExpressionDef);
+    constructor(func: string, expr?: ExpressionDef, explicitSource?: boolean);
     returns(_forExpression: ExprValue): FieldValueType;
     getExpression(fs: FieldSpace): ExprValue;
+    isSymmetricFunction(): boolean;
+    getJoinUsage(fs: FieldSpace): {
+        name: string;
+        structRelationship: StructRelationship;
+    }[][];
 }

package/dist/lang/ast/expressions/expr-aggregate-function.js

@@ -24,17 +24,22 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ExprAggregateFunction = void 0;
 const malloy_types_1 = require("../../../model/malloy_types");
+const utils_1 = require("../../../model/utils");
 const ast_utils_1 = require("../ast-utils");
-const reference_field_1 = require("../field-space/reference-field");
+const static_space_1 = require("../field-space/static-space");
 const struct_space_field_base_1 = require("../field-space/struct-space-field-base");
 const fragtype_utils_1 = require("../fragtype-utils");
+const field_references_1 = require("../query-items/field-references");
 const expression_def_1 = require("../types/expression-def");
+const space_field_1 = require("../types/space-field");
+const expr_id_reference_1 = require("./expr-id-reference");
 class ExprAggregateFunction extends expression_def_1.ExpressionDef {
-    constructor(func, expr) {
+    constructor(func, expr, explicitSource) {
         super();
         this.func = func;
         this.legalChildTypes = [fragtype_utils_1.FT.numberT];
         this.elementType = func;
+        this.explicitSource = explicitSource;
         if (expr) {
             this.expr = expr;
             this.has({ expr: expr });
@@ -45,13 +50,21 @@ class ExprAggregateFunction extends expression_def_1.ExpressionDef {
     }
     getExpression(fs) {
         var _a, _b;
-        let exprVal = (_a = this.expr) === null || _a === void 0 ? void 0 : _a.getExpression(fs);
+        // It is never useful to use output fields in an aggregate expression
+        // so we don't even allow them to be referenced at all
+        const inputFS = fs.isQueryFieldSpace() ? fs.inputSpace() : fs;
+        let expr = this.expr;
+        let exprVal = (_a = this.expr) === null || _a === void 0 ? void 0 : _a.getExpression(inputFS);
         let structPath = (_b = this.source) === null || _b === void 0 ? void 0 : _b.refString;
+        let sourceRelationship = [];
         if (this.source) {
-            const sourceFoot = this.source.getField(fs).found;
-            if (sourceFoot) {
+            const result = this.source.getField(inputFS);
+            if (result.found) {
+                sourceRelationship = result.relationship;
+                const sourceFoot = result.found;
                 const footType = sourceFoot.typeDesc();
                 if ((0, malloy_types_1.isAtomicFieldType)(footType.dataType)) {
+                    expr = this.source;
                     exprVal = {
                         dataType: footType.dataType,
                         expressionType: footType.expressionType,
@@ -68,13 +81,17 @@ class ExprAggregateFunction extends expression_def_1.ExpressionDef {
                         ],
                         evalSpace: footType.evalSpace,
                     };
-                    // If you reference an output field as the foot, then we need to get the
-                    // source from that field, rather than using the default source.
-                    if (sourceFoot.outputField && sourceFoot instanceof reference_field_1.ReferenceField) {
-                        structPath = sourceFoot.fieldRef.sourceString;
-                    }
-                    else {
-                        structPath = this.source.sourceString;
+                    structPath = this.source.sourceString;
+                    // Here we handle a special case where you write `foo.agg()` and `foo` is a
+                    // dimension which uses only one distinct join path; in this case, we set the
+                    // locality to be that join path
+                    const joinUsage = this.getJoinUsage(inputFS);
+                    const allUsagePaths = joinUsage.map(x => x.map(y => y.name).join('.'));
+                    const allUsagesSame = allUsagePaths.length > 0 &&
+                        allUsagePaths.slice(1).every(x => x === allUsagePaths[0]);
+                    if (allUsagesSame) {
+                        structPath = allUsagePaths[0];
+                        sourceRelationship = joinUsage[0];
                     }
                 }
                 else {
@@ -97,6 +114,27 @@ class ExprAggregateFunction extends expression_def_1.ExpressionDef {
             this.log('Aggregate expression cannot be aggregate');
             return (0, ast_utils_1.errorFor)('reagggregate');
         }
+        const isAnError = exprVal.dataType === 'error';
+        if (!isAnError) {
+            const joinUsage = this.getJoinUsage(inputFS);
+            // Did the user spceify a source, either as `source.agg()` or `path.to.join.agg()` or `path.to.field.agg()`
+            const sourceSpecified = this.source !== undefined || this.explicitSource;
+            if (expr) {
+                // Is this an `agg(field)`, where field uses no joins (or nested fields)
+                const noJoinField = !this.source && joinUsage.every(usage => usage.length === 0);
+                if (!noJoinField && !this.isSymmetricFunction()) {
+                    const usagePaths = getJoinUsagePaths(sourceRelationship, joinUsage);
+                    const joinError = validateUsagePaths(usagePaths);
+                    const message = sourceSpecified
+                        ? joinError
+                        : 'Join path is required for this calculation';
+                    if (message) {
+                        const errorWithSuggestion = suggestNewVersion(message, joinUsage, expr, this.elementType);
+                        this.log(errorWithSuggestion, joinError ? 'error' : 'warn');
+                    }
+                }
+            }
+        }
         if (this.typeCheck(this.expr || this, {
             ...exprVal,
             expressionType: 'scalar',
@@ -118,6 +156,167 @@ class ExprAggregateFunction extends expression_def_1.ExpressionDef {
         }
         return (0, ast_utils_1.errorFor)('aggregate type check');
     }
+    isSymmetricFunction() {
+        return true;
+    }
+    getJoinUsage(fs) {
+        const result = [];
+        if (this.source) {
+            const lookup = this.source.getField(fs);
+            if (lookup.found) {
+                const sfd = [{ type: 'field', path: this.source.refString }];
+                result.push(...getJoinUsage(fs, sfd));
+            }
+        }
+        if (this.expr) {
+            const efd = this.expr.getExpression(fs).value;
+            result.push(...getJoinUsage(fs, efd));
+        }
+        return result;
+    }
 }
 exports.ExprAggregateFunction = ExprAggregateFunction;
+function getJoinUsage(fs, expr) {
+    const result = [];
+    const lookup = (fs, path) => {
+        const parts = path.split('.');
+        const head = parts[0];
+        const rest = parts.slice(1);
+        const def = fs.entry(head);
+        if (def === undefined) {
+            throw new Error(`Invalid field lookup ${head}`);
+        }
+        if (def instanceof static_space_1.StructSpaceField && rest.length > 0) {
+            const restDef = lookup(def.fieldSpace, rest.join('.'));
+            return {
+                ...restDef,
+                relationship: [
+                    { name: head, structRelationship: def.structRelationship },
+                    ...restDef.relationship,
+                ],
+            };
+        }
+        else if (def instanceof space_field_1.SpaceField) {
+            if (rest.length !== 0) {
+                throw new Error(`${head} cannot contain a ${rest.join('.')}`);
+            }
+            const fieldDef = def.fieldDef();
+            if (fieldDef) {
+                return {
+                    fs,
+                    def: fieldDef,
+                    relationship: [],
+                };
+            }
+            throw new Error('No field def');
+        }
+        else {
+            throw new Error('expected a field def or struct');
+        }
+    };
+    (0, utils_1.exprWalk)(expr, frag => {
+        if (typeof frag !== 'string') {
+            if (frag.type === 'field') {
+                const def = lookup(fs, frag.path);
+                if (def.def.type !== 'struct' && def.def.type !== 'turtle') {
+                    if (def.def.e) {
+                        const defUsage = getJoinUsage(def.fs, def.def.e);
+                        result.push(...defUsage.map(r => [...def.relationship, ...r]));
+                    }
+                    else {
+                        result.push(def.relationship);
+                    }
+                }
+            }
+        }
+    });
+    return result;
+}
+function getJoinUsagePaths(sourceRelationship, joinUsage) {
+    const sourceToUsagePaths = [];
+    for (const usage of joinUsage) {
+        let overlap = 0;
+        for (let i = 0; i < sourceRelationship.length && i < usage.length; i++) {
+            if (sourceRelationship[i].name === usage[i].name) {
+                overlap = i + 1;
+            }
+            else {
+                break;
+            }
+        }
+        const nonOverlapSource = sourceRelationship.slice(overlap);
+        const nonOverlapUsage = usage.slice(overlap);
+        const sourceToUsagePath = [
+            ...nonOverlapSource.map(r => ({ ...r, reverse: true })),
+            ...nonOverlapUsage.map(r => ({ ...r, reverse: false })),
+        ];
+        sourceToUsagePaths.push(sourceToUsagePath);
+    }
+    return sourceToUsagePaths;
+}
+function validateUsagePaths(usagePaths) {
+    for (const path of usagePaths) {
+        for (const step of path) {
+            if (step.structRelationship.type === 'cross') {
+                return `Cannot compute asymmetric aggregate across \`join_cross\` relationship \`${step.name}\``;
+            }
+            else if (step.structRelationship.type === 'many' && !step.reverse) {
+                return `Cannot compute asymmetric aggregate across forward \`join_many\` relationship \`${step.name}\``;
+            }
+        }
+    }
+}
+function suggestNewVersion(joinError, joinUsage, expr, func) {
+    if (joinUsage.length === 0) {
+        return joinError;
+    }
+    // Get longest shared prefix
+    let longestOverlap = joinUsage[0];
+    for (const usage of joinUsage.slice(1)) {
+        for (let i = 0; i < longestOverlap.length; i++) {
+            const a = longestOverlap[i];
+            const b = usage[i];
+            if (a.name !== b.name) {
+                longestOverlap = longestOverlap.slice(0, i);
+                break;
+            }
+        }
+    }
+    const usagePaths = getJoinUsagePaths(longestOverlap, joinUsage);
+    const usageError = validateUsagePaths(usagePaths);
+    // get rid of everything after the last many/cross
+    const indexFromEndOfLastMany = longestOverlap
+        .slice()
+        .reverse()
+        .findIndex(x => x.structRelationship.type === 'many' ||
+        x.structRelationship.type === 'cross');
+    const numJoinsToLastMany = indexFromEndOfLastMany === -1
+        ? 0
+        : longestOverlap.length - indexFromEndOfLastMany;
+    const shortestOverlapWithMany = longestOverlap.slice(0, numJoinsToLastMany);
+    const shortUsagePaths = getJoinUsagePaths(shortestOverlapWithMany, joinUsage);
+    const shortUsageError = validateUsagePaths(shortUsagePaths);
+    const longLocality = longestOverlap.length > 0
+        ? longestOverlap.map(r => r.name).join('.')
+        : 'source';
+    const shortLocality = shortestOverlapWithMany.length > 0
+        ? shortestOverlapWithMany.map(r => r.name).join('.')
+        : 'source';
+    if (usageError) {
+        return 'Aggregated dimensional expression contains multiple join paths; rewrite, for example `sum(first_join.field + second_join.field)` as `first_join.field.sum() + second_join.field.sum()`';
+    }
+    else {
+        const longSuggestion = expr instanceof field_references_1.FieldReference
+            ? `${expr.refString}.${func}()`
+            : expr instanceof expr_id_reference_1.ExprIdReference
+                ? `${expr.fieldReference.refString}.${func}()`
+                : `${longLocality}.${func}(${expr.code})`;
+        const shortSuggestion = `${shortLocality}.${func}(${expr.code})`;
+        let result = `${joinError}; use \`${longSuggestion}\``;
+        if (shortUsageError === undefined && shortLocality !== longLocality) {
+            result += ` or \`${shortSuggestion}\` to get a result weighted with respect to \`${shortLocality}\``;
+        }
+        return result;
+    }
+}
 //# sourceMappingURL=expr-aggregate-function.js.map

package/dist/lang/ast/expressions/expr-asymmetric.d.ts

@@ -5,6 +5,7 @@ export declare abstract class ExprAsymmetric extends ExprAggregateFunction {
     readonly func: 'sum' | 'avg';
     readonly expr: ExpressionDef | undefined;
     readonly source?: FieldReference | undefined;
-    constructor(func: 'sum' | 'avg', expr: ExpressionDef | undefined, source?: FieldReference | undefined);
+    constructor(func: 'sum' | 'avg', expr: ExpressionDef | undefined, source?: FieldReference | undefined, explicitSource?: boolean);
+    isSymmetricFunction(): boolean;
     defaultFieldName(): undefined | string;
 }

package/dist/lang/ast/expressions/expr-asymmetric.js

@@ -25,13 +25,16 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ExprAsymmetric = void 0;
 const expr_aggregate_function_1 = require("./expr-aggregate-function");
 class ExprAsymmetric extends expr_aggregate_function_1.ExprAggregateFunction {
-    constructor(func, expr, source) {
-        super(func, expr);
+    constructor(func, expr, source, explicitSource) {
+        super(func, expr, explicitSource);
         this.func = func;
         this.expr = expr;
         this.source = source;
         this.has({ source: source });
     }
+    isSymmetricFunction() {
+        return false;
+    }
     defaultFieldName() {
         if (this.source && this.expr === undefined) {
             const tag = this.source.nameString;

package/dist/lang/ast/expressions/expr-avg.d.ts

@@ -2,5 +2,5 @@ import { FieldReference } from '../query-items/field-references';
 import { ExpressionDef } from '../types/expression-def';
 import { ExprAsymmetric } from './expr-asymmetric';
 export declare class ExprAvg extends ExprAsymmetric {
-    constructor(expr: ExpressionDef | undefined, source?: FieldReference);
+    constructor(expr: ExpressionDef | undefined, source?: FieldReference, explicitSource?: boolean);
 }

package/dist/lang/ast/expressions/expr-avg.js

@@ -25,8 +25,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ExprAvg = void 0;
 const expr_asymmetric_1 = require("./expr-asymmetric");
 class ExprAvg extends expr_asymmetric_1.ExprAsymmetric {
-    constructor(expr, source) {
-        super('avg', expr, source);
+    constructor(expr, source, explicitSource) {
+        super('avg', expr, source, explicitSource);
         this.has({ source: source });
     }
 }

package/dist/lang/ast/expressions/expr-sum.d.ts

@@ -2,5 +2,5 @@ import { FieldReference } from '../query-items/field-references';
 import { ExpressionDef } from '../types/expression-def';
 import { ExprAsymmetric } from './expr-asymmetric';
 export declare class ExprSum extends ExprAsymmetric {
-    constructor(expr: ExpressionDef | undefined, source?: FieldReference);
+    constructor(expr: ExpressionDef | undefined, source?: FieldReference, explicitSource?: boolean);
 }

package/dist/lang/ast/expressions/expr-sum.js

@@ -25,8 +25,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ExprSum = void 0;
 const expr_asymmetric_1 = require("./expr-asymmetric");
 class ExprSum extends expr_asymmetric_1.ExprAsymmetric {
-    constructor(expr, source) {
-        super('sum', expr, source);
+    constructor(expr, source, explicitSource) {
+        super('sum', expr, source, explicitSource);
         this.has({ source: source });
     }
 }

package/dist/lang/ast/field-space/static-space.js

@@ -132,16 +132,33 @@ class StaticSpace {
                 });
             }
         }
+        const relationship = found instanceof struct_space_field_base_1.StructSpaceFieldBase
+            ? [
+                {
+                    name: head.refString,
+                    structRelationship: found.structRelationship,
+                },
+            ]
+            : [];
         if (rest.length) {
             if (found instanceof struct_space_field_base_1.StructSpaceFieldBase) {
-                return found.fieldSpace.lookup(rest);
+                const restResult = found.fieldSpace.lookup(rest);
+                if (restResult.found) {
+                    return {
+                        ...restResult,
+                        relationship: [...relationship, ...restResult.relationship],
+                    };
+                }
+                else {
+                    return restResult;
+                }
             }
             return {
                 error: `'${head}' cannot contain a '${rest[0]}'`,
                 found: undefined,
             };
         }
-        return { found, error: undefined };
+        return { found, error: undefined, relationship };
     }
     isQueryFieldSpace() {
         return false;

package/dist/lang/ast/field-space/struct-space-field-base.d.ts

@@ -1,10 +1,11 @@
-import { FieldDef, StructDef, TypeDesc } from '../../../model/malloy_types';
+import { FieldDef, StructDef, StructRelationship, TypeDesc } from '../../../model/malloy_types';
 import { FieldSpace } from '../types/field-space';
 import { SpaceField } from '../types/space-field';
 export declare abstract class StructSpaceFieldBase extends SpaceField {
     protected sourceDef: StructDef;
     constructor(sourceDef: StructDef);
     abstract get fieldSpace(): FieldSpace;
+    get structRelationship(): StructRelationship;
     fieldDef(): FieldDef;
     describeType(): TypeDesc;
 }

package/dist/lang/ast/field-space/struct-space-field-base.js

@@ -29,6 +29,9 @@ class StructSpaceFieldBase extends space_field_1.SpaceField {
         super();
         this.sourceDef = sourceDef;
     }
+    get structRelationship() {
+        return this.sourceDef.structRelationship;
+    }
     fieldDef() {
         return this.sourceDef;
     }

package/dist/lang/ast/types/lookup-result.d.ts

@@ -1,6 +1,11 @@
+import { StructRelationship } from '../../../model';
 import { SpaceEntry } from './space-entry';
 export interface LookupFound {
     found: SpaceEntry;
+    relationship: {
+        name: string;
+        structRelationship: StructRelationship;
+    }[];
     error: undefined;
 }
 export interface LookupError {

package/dist/lang/ast/types/malloy-element.d.ts

@@ -23,6 +23,7 @@ export declare abstract class MalloyElement {
     has(kids: Record<string, ChildBody | undefined>): void;
     get location(): DocumentLocation;
     set location(loc: DocumentLocation | undefined);
+    get code(): string;
     protected document(): Document | undefined;
     protected namespace(): NameSpace | undefined;
     modelEntry(reference: string | ModelEntryReference): ModelEntry | undefined;

package/dist/lang/ast/types/malloy-element.js

@@ -82,6 +82,10 @@ class MalloyElement {
     set location(loc) {
         this.codeLocation = loc;
     }
+    get code() {
+        var _a, _b;
+        return (_b = (_a = this.translator()) === null || _a === void 0 ? void 0 : _a.codeAtLocation(this.location)) !== null && _b !== void 0 ? _b : '';
+    }
     document() {
         var _a;
         if (this instanceof Document) {

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

@@ -78,80 +78,81 @@ export declare class MalloyLexer extends Lexer {
     static readonly REFINE = 73;
     static readonly SECOND = 74;
     static readonly STRING = 75;
-    static readonly SUM = 76;
-    static readonly SQL = 77;
-    static readonly TABLE = 78;
-    static readonly THEN = 79;
-    static readonly THIS = 80;
-    static readonly TIMESTAMP = 81;
-    static readonly TO = 82;
-    static readonly TRUE = 83;
-    static readonly TURTLE = 84;
-    static readonly WEEK = 85;
-    static readonly WHEN = 86;
-    static readonly WITH = 87;
-    static readonly YEAR = 88;
-    static readonly UNGROUPED = 89;
-    static readonly STRING_ESCAPE = 90;
-    static readonly HACKY_REGEX = 91;
-    static readonly SQ_STRING = 92;
-    static readonly DQ_STRING = 93;
-    static readonly BQ_STRING = 94;
-    static readonly DOC_ANNOTATION = 95;
-    static readonly ANNOTATION = 96;
-    static readonly AMPER = 97;
-    static readonly ARROW = 98;
-    static readonly FAT_ARROW = 99;
-    static readonly OPAREN = 100;
-    static readonly CPAREN = 101;
-    static readonly OBRACK = 102;
-    static readonly CBRACK = 103;
-    static readonly OCURLY = 104;
-    static readonly CCURLY = 105;
-    static readonly DOUBLECOLON = 106;
-    static readonly TRIPLECOLON = 107;
-    static readonly EXCLAM = 108;
-    static readonly COLON = 109;
-    static readonly COMMA = 110;
-    static readonly DOT = 111;
-    static readonly LT = 112;
-    static readonly GT = 113;
-    static readonly EQ = 114;
-    static readonly NE = 115;
-    static readonly LTE = 116;
-    static readonly GTE = 117;
-    static readonly PLUS = 118;
-    static readonly MINUS = 119;
-    static readonly STAR = 120;
-    static readonly STARSTAR = 121;
-    static readonly SLASH = 122;
-    static readonly BAR = 123;
-    static readonly SEMI = 124;
-    static readonly NOT_MATCH = 125;
-    static readonly MATCH = 126;
-    static readonly PERCENT = 127;
-    static readonly DOUBLE_QMARK = 128;
-    static readonly QMARK = 129;
-    static readonly LITERAL_TIMESTAMP = 130;
-    static readonly LITERAL_HOUR = 131;
-    static readonly LITERAL_DAY = 132;
-    static readonly LITERAL_QUARTER = 133;
-    static readonly LITERAL_MONTH = 134;
-    static readonly LITERAL_WEEK = 135;
-    static readonly LITERAL_YEAR = 136;
-    static readonly IDENTIFIER = 137;
-    static readonly PERCENT_LITERAL = 138;
-    static readonly NUMERIC_LITERAL = 139;
-    static readonly INTEGER_LITERAL = 140;
-    static readonly BLOCK_COMMENT = 141;
-    static readonly COMMENT_TO_EOL = 142;
-    static readonly WHITE_SPACE = 143;
-    static readonly SQL_BEGIN = 144;
-    static readonly CLOSE_CODE = 145;
-    static readonly UNWATED_CHARS_TRAILING_NUMBERS = 146;
-    static readonly UNEXPECTED_CHAR = 147;
-    static readonly OPEN_CODE = 148;
-    static readonly SQL_END = 149;
+    static readonly SOURCE_KW = 76;
+    static readonly SUM = 77;
+    static readonly SQL = 78;
+    static readonly TABLE = 79;
+    static readonly THEN = 80;
+    static readonly THIS = 81;
+    static readonly TIMESTAMP = 82;
+    static readonly TO = 83;
+    static readonly TRUE = 84;
+    static readonly TURTLE = 85;
+    static readonly WEEK = 86;
+    static readonly WHEN = 87;
+    static readonly WITH = 88;
+    static readonly YEAR = 89;
+    static readonly UNGROUPED = 90;
+    static readonly STRING_ESCAPE = 91;
+    static readonly HACKY_REGEX = 92;
+    static readonly SQ_STRING = 93;
+    static readonly DQ_STRING = 94;
+    static readonly BQ_STRING = 95;
+    static readonly DOC_ANNOTATION = 96;
+    static readonly ANNOTATION = 97;
+    static readonly AMPER = 98;
+    static readonly ARROW = 99;
+    static readonly FAT_ARROW = 100;
+    static readonly OPAREN = 101;
+    static readonly CPAREN = 102;
+    static readonly OBRACK = 103;
+    static readonly CBRACK = 104;
+    static readonly OCURLY = 105;
+    static readonly CCURLY = 106;
+    static readonly DOUBLECOLON = 107;
+    static readonly TRIPLECOLON = 108;
+    static readonly EXCLAM = 109;
+    static readonly COLON = 110;
+    static readonly COMMA = 111;
+    static readonly DOT = 112;
+    static readonly LT = 113;
+    static readonly GT = 114;
+    static readonly EQ = 115;
+    static readonly NE = 116;
+    static readonly LTE = 117;
+    static readonly GTE = 118;
+    static readonly PLUS = 119;
+    static readonly MINUS = 120;
+    static readonly STAR = 121;
+    static readonly STARSTAR = 122;
+    static readonly SLASH = 123;
+    static readonly BAR = 124;
+    static readonly SEMI = 125;
+    static readonly NOT_MATCH = 126;
+    static readonly MATCH = 127;
+    static readonly PERCENT = 128;
+    static readonly DOUBLE_QMARK = 129;
+    static readonly QMARK = 130;
+    static readonly LITERAL_TIMESTAMP = 131;
+    static readonly LITERAL_HOUR = 132;
+    static readonly LITERAL_DAY = 133;
+    static readonly LITERAL_QUARTER = 134;
+    static readonly LITERAL_MONTH = 135;
+    static readonly LITERAL_WEEK = 136;
+    static readonly LITERAL_YEAR = 137;
+    static readonly IDENTIFIER = 138;
+    static readonly PERCENT_LITERAL = 139;
+    static readonly NUMERIC_LITERAL = 140;
+    static readonly INTEGER_LITERAL = 141;
+    static readonly BLOCK_COMMENT = 142;
+    static readonly COMMENT_TO_EOL = 143;
+    static readonly WHITE_SPACE = 144;
+    static readonly SQL_BEGIN = 145;
+    static readonly CLOSE_CODE = 146;
+    static readonly UNWATED_CHARS_TRAILING_NUMBERS = 147;
+    static readonly UNEXPECTED_CHAR = 148;
+    static readonly OPEN_CODE = 149;
+    static readonly SQL_END = 150;
     static readonly SQL_MODE = 1;
     static readonly channelNames: string[];
     static readonly modeNames: string[];