@hamelin.sh/compiler 0.2.3-prerelease.20250910T133135 → 0.2.3

package/dist/main.d.ts

@@ -2927,6 +2927,8 @@ declare class HamelinListener implements ParseTreeListener {
     exitEveryRule(node: ParserRuleContext): void;
 }
 
+declare const hamelinGrammar = "grammar Hamelin;\n\nqueryEOF\n    : query EOF\n    ;\n\ncommandEOF\n    : command EOF\n    ;\n\nexpressionEOF\n    : expression EOF\n    ;\n\nidentifierEOF\n    : identifier EOF\n    ;\n\nsimpleIdentifierEOF\n    : simpleIdentifier EOF\n    ;\n\nquery\n    : (WITH simpleIdentifier ASSIGN pipeline)+ pipeline                                 #withQuery\n    | pipeline                                                                          #standaloneQuery\n    | expression                                                                        #expressionQuery\n    ;\n\npipeline\n    : command ( PIPE command )*                                                         #pipelineAlt\n    ;\n\ncommand\n    : LET_COMMAND assignment (COMMA assignment)* COMMA?                                 #letCommand\n    | WHERE_COMMAND expression                                                          #whereCommand\n    | SELECT_COMMAND assignmentClause (COMMA assignmentClause)* COMMA?                  #selectCommand\n    | DROP_COMMAND selection (COMMA selection)* COMMA?                                  #dropCommand\n    | FROM_COMMAND fromClause (COMMA fromClause)* COMMA?                                #fromCommand\n    | UNION_COMMAND fromClause (COMMA fromClause)* COMMA?                               #unionCommand\n    | LIMIT_COMMAND expression                                                          #limitCommand\n    | PARSE_COMMAND src=expression? string\n                    AS? identifier (COMMA identifier)* COMMA? NODROP?                   #parseCommand\n    | WITHIN_COMMAND expression                                                         #withinCommand\n    | AGG_COMMAND (assignmentClause (COMMA assignmentClause)*)? COMMA?\n                  (BY groupClause (COMMA groupClause)*)? COMMA?\n                  (SORT BY? sortExpression (COMMA sortExpression)*)? COMMA?             #aggCommand\n    | SORT BY? sortExpression (COMMA sortExpression)* COMMA?                            #sortCommand\n    | WINDOW_COMMAND assignmentClause (COMMA assignmentClause)* COMMA?\n                     (BY groupClause (COMMA groupClause)*)? COMMA?\n                     (SORT BY? sortExpression (COMMA sortExpression)*)? COMMA?\n                     (WITHIN_COMMAND within=expression)?                                #windowCommand\n    | APPEND_COMMAND tableReference (DISTINCT_BY selection (COMMA selection)*)? COMMA?  #appendCommand\n    | (JOIN_COMMAND | LOOKUP_COMMAND) fromClause (ON on=expression)?                    #joinCommand\n    | EXPLODE_COMMAND assignmentClause                                                  #explodeCommand\n    | (UNNEST_COMMAND | ROWS_COMMAND) expression                                        #unnestCommand\n    | NEST_COMMAND identifier                                                           #nestCommand\n    | MATCH_COMMAND pattern+\n                    (WHEN matchDefine (COMMA matchDefine)*)? COMMA?\n                    (BY groupClause (COMMA groupClause)*)? COMMA?\n                    (SORT BY? sortExpression (COMMA sortExpression)*)? COMMA?           #matchCommand\n    ;\n\nassignmentClause: assignment | expression;\ngroupClause: assignmentClause;\nassignment: identifier ASSIGN expression;\nmatchDefine: simpleIdentifier ASSIGN expression;\nselection: identifier;\nsortExpression: expression (ASC | DESC)?;\ntableAlias: simpleIdentifier ASSIGN tableReference;\nfromClause: tableAlias | tableReference;\n\nexpression\n    // Keep this list in precedence order (important!)\n    : operator=(MINUS | PLUS) expression                                                #unaryPrefixOperator\n    | expression (SECOND_TRUNC | MINUTE_TRUNC | HOUR_TRUNC | DAY_TRUNC | WEEK_TRUNC |\n                  MONTH_TRUNC | QUARTER_TRUNC | YEAR_TRUNC)                             #tsTrunc\n    | left=expression operator=DOT right=simpleIdentifier                               #deref\n    | value=expression LBRACKET index=expression RBRACKET                               #indexAccess\n    | left=expression operator=(ASTERISK | SLASH | PERCENT) right=expression            #binaryOperator\n    | left=expression operator=(PLUS | MINUS) right=expression                          #binaryOperator\n    | operator=RANGE expression                                                         #unaryPrefixOperator\n    | expression operator=RANGE                                                         #unaryPostfixOperator\n    | left=expression operator=RANGE right=expression                                   #binaryOperator\n    | left=expression operator=AS right=hamelintype                                     #cast\n    | left=expression\n        operator=(EQ | NEQ | LT | LTE | GT | GTE | IS | ISNOT | IN) right=expression    #binaryOperator\n    | operator=NOT expression                                                           #unaryPrefixOperator\n    | left=expression operator=AND right=expression                                     #binaryOperator\n    | left=expression operator=OR right=expression                                      #binaryOperator\n\n    // Complex Literals\n    | left=expression operator=COLON right=expression                                   #pairLiteral\n    | LCURLY simpleIdentifier COLON expression\n      (COMMA simpleIdentifier COLON expression)* COMMA? RCURLY                          #structLiteral\n    | LPARENS ((expression COMMA) |\n               (expression COMMA expression (COMMA expression)* COMMA?)) RPARENS        #tupleLiteral\n    | LBRACKET (expression (COMMA expression)* COMMA?)? RBRACKET                        #arrayLiteral\n\n    // Function Calls\n    | functionName=simpleIdentifier\n        LPARENS (namedArgument (COMMA namedArgument)* COMMA?)? RPARENS                  #functionCall\n    | functionName=simpleIdentifier LPARENS\n        positionalArgument (COMMA positionalArgument)*\n                           (COMMA namedArgument)* COMMA? RPARENS                        #functionCall\n\n    // Primitive Literals\n    | NULL                                                                              #nullLiteral\n    | number                                                                            #numericLiteral\n    | TRUE                                                                              #booleanLiteral\n    | FALSE                                                                             #booleanLiteral\n    | string                                                                            #stringLiteral\n    | BINARY_LITERAL                                                                    #binaryLiteral\n    | RANGE                                                                             #unboundRangeLiteral\n    | (NANOSECOND_INTERVAL | MICROSECOND_INTERVAL | MILLISECOND_INTERVAL |\n       SECOND_INTERVAL | MINUTE_INTERVAL | HOUR_INTERVAL | DAY_INTERVAL |\n       WEEK_INTERVAL | MONTH_INTERVAL | QUARTER_INTERVAL | YEAR_INTERVAL)               #intervalLiteral\n    | ROWS_LITERAL                                                                      #rowsLiteral\n    | (SECOND_TRUNC | MINUTE_TRUNC | HOUR_TRUNC | DAY_TRUNC | WEEK_TRUNC |\n       MONTH_TRUNC | QUARTER_TRUNC | YEAR_TRUNC)                                        #tsTruncTimestampLiteral\n\n    // Environment references\n    | columnReference                                                                   #columnReferenceAlt\n\n    // Keep this at the bottom to use it the mechanism that query authors have to specify precedence.\n    | LPARENS expression RPARENS                                                        #parenthesizedExpression\n    ;\n\nhamelintype\n    : simpleIdentifier LPARENS hamelintype (COMMA hamelintype)* COMMA? RPARENS          #parameterizedType\n    | simpleIdentifier LPARENS INTEGER_VALUE (COMMA INTEGER_VALUE)* COMMA? RPARENS      #typeWithArguments\n    | LCURLY simpleIdentifier COLON hamelintype\n             (COMMA simpleIdentifier COLON hamelintype)* COMMA? RCURLY                  #structType\n    | LPARENS hamelintype (COMMA hamelintype )* COMMA? RPARENS                          #tupleType\n    | simpleIdentifier                                                                  #simpleType\n    ;\n\npattern\n    : fromClause quantifier?                                                            #quantified\n    | LPARENS pattern+ RPARENS quantifier                                               #nested\n    ;\n\nquantifier\n    : ASTERISK                                                                          #AnyNumber\n    | PLUS                                                                              #AtLeastOne\n    | QUESTIONMARK                                                                      #ZeroOrOne\n    | LCURLY INTEGER_VALUE RCURLY                                                       #Exactly\n    ;\n\ncolumnReference\n    : simpleIdentifier\n    ;\n\ntableReference\n    : identifier\n    ;\n\nidentifier\n    : simpleIdentifier\n    | simpleIdentifier (DOT simpleIdentifier)+\n    ;\n\nsimpleIdentifier\n    : IDENTIFIER                                                                        #unquotedIdentifier\n    | BACKQUOTED_IDENTIFIER                                                             #backQuotedIdentifier\n    ;\n\nstring\n    : SINGLE_QUOTED_STRING                                                              #basicSingleQuotedStringLiteral\n    | DOUBLE_QUOTED_STRING                                                              #basicDoubleQuotedStringLiteral\n    | value=SINGLE_QUOTED_UNICODE_STRING (UESCAPE uesc=SINGLE_QUOTED_STRING)?           #unicodeSingleQuotedStringLiteral\n    | value=DOUBLE_QUOTED_UNICODE_STRING (UESCAPE uesc=DOUBLE_QUOTED_STRING)?           #unicodeDoubleQuotedStringLiteral\n    ;\n\nnumber\n    : value=DECIMAL_VALUE                                                               #decimalLiteral\n    | value=DOUBLE_VALUE                                                                #scientificLiteral\n    | value=INTEGER_VALUE                                                               #integerLiteral\n    ;\n\npositionalArgument\n    : expression\n    ;\n\nnamedArgument\n    : simpleIdentifier ASSIGN expression\n    ;\n\n//\n// COMMANDS\n//\n\nLET_COMMAND: 'LET' | 'let';\nWHERE_COMMAND: 'WHERE' | 'where';\nSELECT_COMMAND: 'SELECT' | 'select';\nDROP_COMMAND: 'DROP' | 'drop';\nFROM_COMMAND: 'FROM' | 'from';\nUNION_COMMAND: 'UNION' | 'union';\nLIMIT_COMMAND: 'LIMIT' | 'limit';\nPARSE_COMMAND: 'PARSE' | 'parse';\nWITHIN_COMMAND: 'WITHIN' | 'within';\nAGG_COMMAND: 'AGG' | 'agg';\nWINDOW_COMMAND: 'WINDOW' | 'window';\nAPPEND_COMMAND: 'APPEND' | 'append';\nJOIN_COMMAND: 'JOIN' | 'join';\nLOOKUP_COMMAND: 'LOOKUP' | 'lookup';\nEXPLODE_COMMAND: 'EXPLODE' | 'explode';\nUNNEST_COMMAND: 'UNNEST' | 'unnest';\nNEST_COMMAND: 'NEST' | 'nest';\nROWS_COMMAND: 'ROWS' | 'rows';\nMATCH_COMMAND: 'MATCH' | 'match';\n\nAS: 'AS' | 'as';\nNODROP: 'NODROP' | 'nodrop';\n\n//\n// Operators\n//\n\nPLUS: '+';\nMINUS: '-';\nASTERISK: '*';\nSLASH: '/';\nPERCENT: '%';\nLCURLY: '{';\nRCURLY: '}';\nCOLON: ':';\nQUESTIONMARK: '?';\n\nEQ: '==';\nNEQ: '!=';\nLT: '<';\nLTE: '<=';\nGT: '>';\nGTE: '>=';\nRANGE: '..';\n\nASSIGN: '=';\n\n//\n// Keywords\n//\n\nAND: 'AND' | 'and';\nFALSE: 'FALSE' | 'false';\nIS: 'IS' | 'is';\nNOT: 'NOT' | 'not';\nISNOT: 'IS NOT' | 'is not';\nIN: 'IN' | 'in';\nNULL: 'NULL' | 'null';\nOR: 'OR' | 'or';\nTRUE: 'TRUE' | 'true';\nUESCAPE: 'UESCAPE' | 'uescape';\nWITH: 'WITH' | 'with';\nBY: 'BY' | 'by';\nSORT: 'SORT' | 'sort';\nASC: 'ASC' | 'asc';\nDESC: 'DESC' | 'desc';\nDISTINCT_BY: 'DISTINCT BY' | 'distinct by';\nON: 'ON' | 'on';\nWHEN: 'WHEN' | 'when';\n\n//\n// Symbols\n//\n\nCOMMA: ',';\nPIPE: '|';\nLPARENS: '(';\nRPARENS: ')';\nDOT: '.';\nLBRACKET: '[';\nRBRACKET: ']';\n\n//\n// Literals\n//\n\nSINGLE_QUOTED_STRING\n        : '\\'' ( ~'\\'' | '\\'\\'')* '\\''\n        ;\nDOUBLE_QUOTED_STRING\n        : '\"' ( ~'\"' | '\"\"')* '\"'\n        ;\n\nSINGLE_QUOTED_UNICODE_STRING\n        : 'U&\\'' ( ~'\\'' | '\\'\\'')* '\\''    // Unicode string with default escape character: U&'Hello winter \\2603 !'\n        ;\n\nDOUBLE_QUOTED_UNICODE_STRING\n        : 'U&\"' ( ~'\"' | '\"\"')* '\"'         // Unicode string with custom escape character: U&'Hello winter #2603 !' UESCAPE '#'\n        ;\n\n// Note: we allow any character inside the binary literal and validate\n// its a correct literal when the AST is being constructed. This\n// allows us to provide more meaningful error messages to the user\nBINARY_LITERAL\n    : 'x\\'' (~'\\'')* '\\''\n    ;\n\nNANOSECOND_INTERVAL\n    : DECIMAL_INTEGER 'ns'\n    ;\n\nMICROSECOND_INTERVAL\n    : DECIMAL_INTEGER 'us'\n    ;\n\nMILLISECOND_INTERVAL\n    : DECIMAL_INTEGER 'ms'\n    ;\n\nSECOND_INTERVAL\n    : DECIMAL_INTEGER  ('s' | 'sec' | 'secs' | 'second' | 'seconds')\n    ;\n\nMINUTE_INTERVAL\n    : DECIMAL_INTEGER  ('m' | 'min' | 'mins' | 'minute' | 'minutes')\n    ;\n\nHOUR_INTERVAL\n    : DECIMAL_INTEGER ('h' | 'hr' | 'hrs' | 'hour' | 'hours')\n    ;\n\nDAY_INTERVAL\n    : DECIMAL_INTEGER ('d' | 'day' | 'days')\n    ;\n\nWEEK_INTERVAL\n    : DECIMAL_INTEGER ('w' | 'week' | 'weeks')\n    ;\n\nMONTH_INTERVAL\n    : DECIMAL_INTEGER ('mon' | 'month' | 'months')\n    ;\n\nQUARTER_INTERVAL\n    : DECIMAL_INTEGER ('q' | 'qtr' | 'qtrs' | 'quarter' | 'quarters')\n    ;\n\nYEAR_INTERVAL\n    : DECIMAL_INTEGER ('y' | 'yr' | 'yrs' | 'year' | 'years')\n    ;\n\nROWS_LITERAL\n    : DECIMAL_INTEGER ('r' | 'row' | 'rows')\n    ;\n\nSECOND_TRUNC\n    : '@'  ('s' | 'sec' | 'secs' | 'second' | 'seconds')\n    ;\n\nMINUTE_TRUNC\n    : '@'  ('m' | 'min' | 'mins' | 'minute' | 'minutes')\n    ;\n\nHOUR_TRUNC\n    : '@' ('h' | 'hr' | 'hrs' | 'hour' | 'hours')\n    ;\n\nDAY_TRUNC\n    : '@' ('d' | 'day' | 'days')\n    ;\n\nWEEK_TRUNC\n    : '@' ('w' | 'week' | 'weeks')\n    ;\n\nMONTH_TRUNC\n    : '@' ('mon' | 'month' | 'months')\n    ;\n\nQUARTER_TRUNC\n    : '@' ('q' | 'qtr' | 'qtrs' | 'quarter' | 'quarters')\n    ;\n\nYEAR_TRUNC\n    : '@' ('y' | 'yr' | 'yrs' | 'year' | 'years')\n    ;\n\nINTEGER_VALUE\n    : DECIMAL_INTEGER\n    | HEXADECIMAL_INTEGER\n    | OCTAL_INTEGER\n    | BINARY_INTEGER\n    ;\n\nDECIMAL_VALUE\n    : DECIMAL_INTEGER '.' DECIMAL_INTEGER\n    | '.' DECIMAL_INTEGER\n    ;\n\nDOUBLE_VALUE\n    : DIGIT+ ('.' DIGIT*)? EXPONENT\n    | '.' DIGIT+ EXPONENT\n    ;\n\nIDENTIFIER\n    : [a-zA-Z_][a-zA-Z_0-9]*\n    ;\n\nBACKQUOTED_IDENTIFIER\n    : '`' ( ~'`' | '``' )* '`'\n    ;\n\nfragment DECIMAL_INTEGER\n    : DIGIT ('_'? DIGIT)*\n    ;\n\nfragment HEXADECIMAL_INTEGER\n    : '0x' ('_'? (DIGIT | [A-F]))+\n    ;\n\nfragment OCTAL_INTEGER\n    : '0o' ('_'? [0-7])+\n    ;\n\nfragment BINARY_INTEGER\n    : '0b' ('_'? [01])+\n    ;\n\nfragment EXPONENT\n    : 'e' [+-]? DIGIT+\n    ;\n\nfragment DIGIT\n    : [0-9]\n    ;\n\n//\n// Comments and whitespace\n//\n\nSIMPLE_COMMENT\n    : '//' ~[\\r\\n]* '\\r'? '\\n'? -> channel(HIDDEN)\n    ;\n\nBRACKETED_COMMENT\n    : '/*' .*? '*/' -> channel(HIDDEN)\n    ;\n\nWS\n    : [ \\r\\n\\t]+ -> skip\n    ;\n";
+
 declare const getDatasetsFromQuery: (catalog: Catalog, hamelinInput: string) => Promise<QueryDatasetsResult>;
 
 declare const getFunctionDescriptions: () => Promise<FunctionDescription[]>;
@@ -2947,4 +2949,4 @@ declare const getSorts: (hamelinQuery: string) => QuerySort[];
 
 declare const sampleCatalog: Catalog;
 
-export { AggCommandContext, AnyNumberContext, AppendCommandContext, ArrayLiteralContext, AssignmentClauseContext, AssignmentContext, AtLeastOneContext, BackQuotedIdentifierContext, BasicDoubleQuotedStringLiteralContext, BasicSingleQuotedStringLiteralContext, BinaryLiteralContext, BinaryOperatorContext, BooleanLiteralContext, CastContext, type Catalog, CatalogProvider, type Column, ColumnReferenceAltContext, ColumnReferenceContext, CommandContext, CommandEOFContext, type CompileQueryResult, Compiler, type Completion, type CompletionItem, type CompletionItemKind, type Context, type ContextualCompletion, type ContextualResult, type ContextualTranslationError, type ContextualTranslationErrors, type DMLTranslation, DecimalLiteralContext, DerefContext, DropCommandContext, ExactlyContext, ExplodeCommandContext, ExpressionContext, ExpressionEOFContext, ExpressionQueryContext, FromClauseContext, FromCommandContext, FunctionCallContext, type FunctionDescription, GroupClauseContext, HamelinLexer, HamelinListener, HamelinParser, type HamelinType, HamelinVisitor, HamelintypeContext, IdentifierContext, IdentifierEOFContext, IndexAccessContext, type InitInput, type InitOutput, IntegerLiteralContext, IntervalLiteralContext, JoinCommandContext, type LanguageArea, LetCommandContext, type Level, LimitCommandContext, MatchCommandContext, MatchDefineContext, NamedArgumentContext, NestCommandContext, NestedContext, NullLiteralContext, NumberContext, NumericLiteralContext, PairLiteralContext, ParameterizedTypeContext, ParenthesizedExpressionContext, ParseCommandContext, PatternContext, PipelineAltContext, PipelineContext, PositionalArgumentContext, QuantifiedContext, QuantifierContext, QueryContext, type QueryDatasetsResult, QueryEOFContext, type QuerySort, type QueryTranslation, RowsLiteralContext, ScientificLiteralContext, SelectCommandContext, SelectionContext, SimpleIdentifierContext, SimpleIdentifierEOFContext, SimpleTypeContext, SortCommandContext, SortExpressionContext, type Stage, StandaloneQueryContext, type StatementTranslation, StringContext, StringLiteralContext, StructLiteralContext, StructTypeContext, type SyncInitInput, TableAliasContext, TableReferenceContext, type Translation, type TranslationError, type TranslationErrors, TsTruncContext, TsTruncTimestampLiteralContext, TupleLiteralContext, TupleTypeContext, TypeWithArgumentsContext, UnaryPostfixOperatorContext, UnaryPrefixOperatorContext, UnboundRangeLiteralContext, UnicodeDoubleQuotedStringLiteralContext, UnicodeSingleQuotedStringLiteralContext, UnionCommandContext, UnnestCommandContext, UnquotedIdentifierContext, WhereCommandContext, WindowCommandContext, WithQueryContext, WithinCommandContext, ZeroOrOneContext, compileHamelin, createCompiler, getDatasetsFromQuery, getFunctionDescriptions, getLimits, getSorts, initSync, sampleCatalog };
+export { AggCommandContext, AnyNumberContext, AppendCommandContext, ArrayLiteralContext, AssignmentClauseContext, AssignmentContext, AtLeastOneContext, BackQuotedIdentifierContext, BasicDoubleQuotedStringLiteralContext, BasicSingleQuotedStringLiteralContext, BinaryLiteralContext, BinaryOperatorContext, BooleanLiteralContext, CastContext, type Catalog, CatalogProvider, type Column, ColumnReferenceAltContext, ColumnReferenceContext, CommandContext, CommandEOFContext, type CompileQueryResult, Compiler, type Completion, type CompletionItem, type CompletionItemKind, type Context, type ContextualCompletion, type ContextualResult, type ContextualTranslationError, type ContextualTranslationErrors, type DMLTranslation, DecimalLiteralContext, DerefContext, DropCommandContext, ExactlyContext, ExplodeCommandContext, ExpressionContext, ExpressionEOFContext, ExpressionQueryContext, FromClauseContext, FromCommandContext, FunctionCallContext, type FunctionDescription, GroupClauseContext, HamelinLexer, HamelinListener, HamelinParser, type HamelinType, HamelinVisitor, HamelintypeContext, IdentifierContext, IdentifierEOFContext, IndexAccessContext, type InitInput, type InitOutput, IntegerLiteralContext, IntervalLiteralContext, JoinCommandContext, type LanguageArea, LetCommandContext, type Level, LimitCommandContext, MatchCommandContext, MatchDefineContext, NamedArgumentContext, NestCommandContext, NestedContext, NullLiteralContext, NumberContext, NumericLiteralContext, PairLiteralContext, ParameterizedTypeContext, ParenthesizedExpressionContext, ParseCommandContext, PatternContext, PipelineAltContext, PipelineContext, PositionalArgumentContext, QuantifiedContext, QuantifierContext, QueryContext, type QueryDatasetsResult, QueryEOFContext, type QuerySort, type QueryTranslation, RowsLiteralContext, ScientificLiteralContext, SelectCommandContext, SelectionContext, SimpleIdentifierContext, SimpleIdentifierEOFContext, SimpleTypeContext, SortCommandContext, SortExpressionContext, type Stage, StandaloneQueryContext, type StatementTranslation, StringContext, StringLiteralContext, StructLiteralContext, StructTypeContext, type SyncInitInput, TableAliasContext, TableReferenceContext, type Translation, type TranslationError, type TranslationErrors, TsTruncContext, TsTruncTimestampLiteralContext, TupleLiteralContext, TupleTypeContext, TypeWithArgumentsContext, UnaryPostfixOperatorContext, UnaryPrefixOperatorContext, UnboundRangeLiteralContext, UnicodeDoubleQuotedStringLiteralContext, UnicodeSingleQuotedStringLiteralContext, UnionCommandContext, UnnestCommandContext, UnquotedIdentifierContext, WhereCommandContext, WindowCommandContext, WithQueryContext, WithinCommandContext, ZeroOrOneContext, compileHamelin, createCompiler, getDatasetsFromQuery, getFunctionDescriptions, getLimits, getSorts, hamelinGrammar, initSync, sampleCatalog };

package/dist/main.js

@@ -26319,6 +26319,452 @@ var HamelinVisitor = class extends AbstractParseTreeVisitor {
   visitNamedArgument;
 };
 
+// src/generated/hamelin-grammar-string.ts
+var hamelinGrammar = `grammar Hamelin;
+
+queryEOF
+    : query EOF
+    ;
+
+commandEOF
+    : command EOF
+    ;
+
+expressionEOF
+    : expression EOF
+    ;
+
+identifierEOF
+    : identifier EOF
+    ;
+
+simpleIdentifierEOF
+    : simpleIdentifier EOF
+    ;
+
+query
+    : (WITH simpleIdentifier ASSIGN pipeline)+ pipeline                                 #withQuery
+    | pipeline                                                                          #standaloneQuery
+    | expression                                                                        #expressionQuery
+    ;
+
+pipeline
+    : command ( PIPE command )*                                                         #pipelineAlt
+    ;
+
+command
+    : LET_COMMAND assignment (COMMA assignment)* COMMA?                                 #letCommand
+    | WHERE_COMMAND expression                                                          #whereCommand
+    | SELECT_COMMAND assignmentClause (COMMA assignmentClause)* COMMA?                  #selectCommand
+    | DROP_COMMAND selection (COMMA selection)* COMMA?                                  #dropCommand
+    | FROM_COMMAND fromClause (COMMA fromClause)* COMMA?                                #fromCommand
+    | UNION_COMMAND fromClause (COMMA fromClause)* COMMA?                               #unionCommand
+    | LIMIT_COMMAND expression                                                          #limitCommand
+    | PARSE_COMMAND src=expression? string
+                    AS? identifier (COMMA identifier)* COMMA? NODROP?                   #parseCommand
+    | WITHIN_COMMAND expression                                                         #withinCommand
+    | AGG_COMMAND (assignmentClause (COMMA assignmentClause)*)? COMMA?
+                  (BY groupClause (COMMA groupClause)*)? COMMA?
+                  (SORT BY? sortExpression (COMMA sortExpression)*)? COMMA?             #aggCommand
+    | SORT BY? sortExpression (COMMA sortExpression)* COMMA?                            #sortCommand
+    | WINDOW_COMMAND assignmentClause (COMMA assignmentClause)* COMMA?
+                     (BY groupClause (COMMA groupClause)*)? COMMA?
+                     (SORT BY? sortExpression (COMMA sortExpression)*)? COMMA?
+                     (WITHIN_COMMAND within=expression)?                                #windowCommand
+    | APPEND_COMMAND tableReference (DISTINCT_BY selection (COMMA selection)*)? COMMA?  #appendCommand
+    | (JOIN_COMMAND | LOOKUP_COMMAND) fromClause (ON on=expression)?                    #joinCommand
+    | EXPLODE_COMMAND assignmentClause                                                  #explodeCommand
+    | (UNNEST_COMMAND | ROWS_COMMAND) expression                                        #unnestCommand
+    | NEST_COMMAND identifier                                                           #nestCommand
+    | MATCH_COMMAND pattern+
+                    (WHEN matchDefine (COMMA matchDefine)*)? COMMA?
+                    (BY groupClause (COMMA groupClause)*)? COMMA?
+                    (SORT BY? sortExpression (COMMA sortExpression)*)? COMMA?           #matchCommand
+    ;
+
+assignmentClause: assignment | expression;
+groupClause: assignmentClause;
+assignment: identifier ASSIGN expression;
+matchDefine: simpleIdentifier ASSIGN expression;
+selection: identifier;
+sortExpression: expression (ASC | DESC)?;
+tableAlias: simpleIdentifier ASSIGN tableReference;
+fromClause: tableAlias | tableReference;
+
+expression
+    // Keep this list in precedence order (important!)
+    : operator=(MINUS | PLUS) expression                                                #unaryPrefixOperator
+    | expression (SECOND_TRUNC | MINUTE_TRUNC | HOUR_TRUNC | DAY_TRUNC | WEEK_TRUNC |
+                  MONTH_TRUNC | QUARTER_TRUNC | YEAR_TRUNC)                             #tsTrunc
+    | left=expression operator=DOT right=simpleIdentifier                               #deref
+    | value=expression LBRACKET index=expression RBRACKET                               #indexAccess
+    | left=expression operator=(ASTERISK | SLASH | PERCENT) right=expression            #binaryOperator
+    | left=expression operator=(PLUS | MINUS) right=expression                          #binaryOperator
+    | operator=RANGE expression                                                         #unaryPrefixOperator
+    | expression operator=RANGE                                                         #unaryPostfixOperator
+    | left=expression operator=RANGE right=expression                                   #binaryOperator
+    | left=expression operator=AS right=hamelintype                                     #cast
+    | left=expression
+        operator=(EQ | NEQ | LT | LTE | GT | GTE | IS | ISNOT | IN) right=expression    #binaryOperator
+    | operator=NOT expression                                                           #unaryPrefixOperator
+    | left=expression operator=AND right=expression                                     #binaryOperator
+    | left=expression operator=OR right=expression                                      #binaryOperator
+
+    // Complex Literals
+    | left=expression operator=COLON right=expression                                   #pairLiteral
+    | LCURLY simpleIdentifier COLON expression
+      (COMMA simpleIdentifier COLON expression)* COMMA? RCURLY                          #structLiteral
+    | LPARENS ((expression COMMA) |
+               (expression COMMA expression (COMMA expression)* COMMA?)) RPARENS        #tupleLiteral
+    | LBRACKET (expression (COMMA expression)* COMMA?)? RBRACKET                        #arrayLiteral
+
+    // Function Calls
+    | functionName=simpleIdentifier
+        LPARENS (namedArgument (COMMA namedArgument)* COMMA?)? RPARENS                  #functionCall
+    | functionName=simpleIdentifier LPARENS
+        positionalArgument (COMMA positionalArgument)*
+                           (COMMA namedArgument)* COMMA? RPARENS                        #functionCall
+
+    // Primitive Literals
+    | NULL                                                                              #nullLiteral
+    | number                                                                            #numericLiteral
+    | TRUE                                                                              #booleanLiteral
+    | FALSE                                                                             #booleanLiteral
+    | string                                                                            #stringLiteral
+    | BINARY_LITERAL                                                                    #binaryLiteral
+    | RANGE                                                                             #unboundRangeLiteral
+    | (NANOSECOND_INTERVAL | MICROSECOND_INTERVAL | MILLISECOND_INTERVAL |
+       SECOND_INTERVAL | MINUTE_INTERVAL | HOUR_INTERVAL | DAY_INTERVAL |
+       WEEK_INTERVAL | MONTH_INTERVAL | QUARTER_INTERVAL | YEAR_INTERVAL)               #intervalLiteral
+    | ROWS_LITERAL                                                                      #rowsLiteral
+    | (SECOND_TRUNC | MINUTE_TRUNC | HOUR_TRUNC | DAY_TRUNC | WEEK_TRUNC |
+       MONTH_TRUNC | QUARTER_TRUNC | YEAR_TRUNC)                                        #tsTruncTimestampLiteral
+
+    // Environment references
+    | columnReference                                                                   #columnReferenceAlt
+
+    // Keep this at the bottom to use it the mechanism that query authors have to specify precedence.
+    | LPARENS expression RPARENS                                                        #parenthesizedExpression
+    ;
+
+hamelintype
+    : simpleIdentifier LPARENS hamelintype (COMMA hamelintype)* COMMA? RPARENS          #parameterizedType
+    | simpleIdentifier LPARENS INTEGER_VALUE (COMMA INTEGER_VALUE)* COMMA? RPARENS      #typeWithArguments
+    | LCURLY simpleIdentifier COLON hamelintype
+             (COMMA simpleIdentifier COLON hamelintype)* COMMA? RCURLY                  #structType
+    | LPARENS hamelintype (COMMA hamelintype )* COMMA? RPARENS                          #tupleType
+    | simpleIdentifier                                                                  #simpleType
+    ;
+
+pattern
+    : fromClause quantifier?                                                            #quantified
+    | LPARENS pattern+ RPARENS quantifier                                               #nested
+    ;
+
+quantifier
+    : ASTERISK                                                                          #AnyNumber
+    | PLUS                                                                              #AtLeastOne
+    | QUESTIONMARK                                                                      #ZeroOrOne
+    | LCURLY INTEGER_VALUE RCURLY                                                       #Exactly
+    ;
+
+columnReference
+    : simpleIdentifier
+    ;
+
+tableReference
+    : identifier
+    ;
+
+identifier
+    : simpleIdentifier
+    | simpleIdentifier (DOT simpleIdentifier)+
+    ;
+
+simpleIdentifier
+    : IDENTIFIER                                                                        #unquotedIdentifier
+    | BACKQUOTED_IDENTIFIER                                                             #backQuotedIdentifier
+    ;
+
+string
+    : SINGLE_QUOTED_STRING                                                              #basicSingleQuotedStringLiteral
+    | DOUBLE_QUOTED_STRING                                                              #basicDoubleQuotedStringLiteral
+    | value=SINGLE_QUOTED_UNICODE_STRING (UESCAPE uesc=SINGLE_QUOTED_STRING)?           #unicodeSingleQuotedStringLiteral
+    | value=DOUBLE_QUOTED_UNICODE_STRING (UESCAPE uesc=DOUBLE_QUOTED_STRING)?           #unicodeDoubleQuotedStringLiteral
+    ;
+
+number
+    : value=DECIMAL_VALUE                                                               #decimalLiteral
+    | value=DOUBLE_VALUE                                                                #scientificLiteral
+    | value=INTEGER_VALUE                                                               #integerLiteral
+    ;
+
+positionalArgument
+    : expression
+    ;
+
+namedArgument
+    : simpleIdentifier ASSIGN expression
+    ;
+
+//
+// COMMANDS
+//
+
+LET_COMMAND: 'LET' | 'let';
+WHERE_COMMAND: 'WHERE' | 'where';
+SELECT_COMMAND: 'SELECT' | 'select';
+DROP_COMMAND: 'DROP' | 'drop';
+FROM_COMMAND: 'FROM' | 'from';
+UNION_COMMAND: 'UNION' | 'union';
+LIMIT_COMMAND: 'LIMIT' | 'limit';
+PARSE_COMMAND: 'PARSE' | 'parse';
+WITHIN_COMMAND: 'WITHIN' | 'within';
+AGG_COMMAND: 'AGG' | 'agg';
+WINDOW_COMMAND: 'WINDOW' | 'window';
+APPEND_COMMAND: 'APPEND' | 'append';
+JOIN_COMMAND: 'JOIN' | 'join';
+LOOKUP_COMMAND: 'LOOKUP' | 'lookup';
+EXPLODE_COMMAND: 'EXPLODE' | 'explode';
+UNNEST_COMMAND: 'UNNEST' | 'unnest';
+NEST_COMMAND: 'NEST' | 'nest';
+ROWS_COMMAND: 'ROWS' | 'rows';
+MATCH_COMMAND: 'MATCH' | 'match';
+
+AS: 'AS' | 'as';
+NODROP: 'NODROP' | 'nodrop';
+
+//
+// Operators
+//
+
+PLUS: '+';
+MINUS: '-';
+ASTERISK: '*';
+SLASH: '/';
+PERCENT: '%';
+LCURLY: '{';
+RCURLY: '}';
+COLON: ':';
+QUESTIONMARK: '?';
+
+EQ: '==';
+NEQ: '!=';
+LT: '<';
+LTE: '<=';
+GT: '>';
+GTE: '>=';
+RANGE: '..';
+
+ASSIGN: '=';
+
+//
+// Keywords
+//
+
+AND: 'AND' | 'and';
+FALSE: 'FALSE' | 'false';
+IS: 'IS' | 'is';
+NOT: 'NOT' | 'not';
+ISNOT: 'IS NOT' | 'is not';
+IN: 'IN' | 'in';
+NULL: 'NULL' | 'null';
+OR: 'OR' | 'or';
+TRUE: 'TRUE' | 'true';
+UESCAPE: 'UESCAPE' | 'uescape';
+WITH: 'WITH' | 'with';
+BY: 'BY' | 'by';
+SORT: 'SORT' | 'sort';
+ASC: 'ASC' | 'asc';
+DESC: 'DESC' | 'desc';
+DISTINCT_BY: 'DISTINCT BY' | 'distinct by';
+ON: 'ON' | 'on';
+WHEN: 'WHEN' | 'when';
+
+//
+// Symbols
+//
+
+COMMA: ',';
+PIPE: '|';
+LPARENS: '(';
+RPARENS: ')';
+DOT: '.';
+LBRACKET: '[';
+RBRACKET: ']';
+
+//
+// Literals
+//
+
+SINGLE_QUOTED_STRING
+        : '\\'' ( ~'\\'' | '\\'\\'')* '\\''
+        ;
+DOUBLE_QUOTED_STRING
+        : '"' ( ~'"' | '""')* '"'
+        ;
+
+SINGLE_QUOTED_UNICODE_STRING
+        : 'U&\\'' ( ~'\\'' | '\\'\\'')* '\\''    // Unicode string with default escape character: U&'Hello winter \\2603 !'
+        ;
+
+DOUBLE_QUOTED_UNICODE_STRING
+        : 'U&"' ( ~'"' | '""')* '"'         // Unicode string with custom escape character: U&'Hello winter #2603 !' UESCAPE '#'
+        ;
+
+// Note: we allow any character inside the binary literal and validate
+// its a correct literal when the AST is being constructed. This
+// allows us to provide more meaningful error messages to the user
+BINARY_LITERAL
+    : 'x\\'' (~'\\'')* '\\''
+    ;
+
+NANOSECOND_INTERVAL
+    : DECIMAL_INTEGER 'ns'
+    ;
+
+MICROSECOND_INTERVAL
+    : DECIMAL_INTEGER 'us'
+    ;
+
+MILLISECOND_INTERVAL
+    : DECIMAL_INTEGER 'ms'
+    ;
+
+SECOND_INTERVAL
+    : DECIMAL_INTEGER  ('s' | 'sec' | 'secs' | 'second' | 'seconds')
+    ;
+
+MINUTE_INTERVAL
+    : DECIMAL_INTEGER  ('m' | 'min' | 'mins' | 'minute' | 'minutes')
+    ;
+
+HOUR_INTERVAL
+    : DECIMAL_INTEGER ('h' | 'hr' | 'hrs' | 'hour' | 'hours')
+    ;
+
+DAY_INTERVAL
+    : DECIMAL_INTEGER ('d' | 'day' | 'days')
+    ;
+
+WEEK_INTERVAL
+    : DECIMAL_INTEGER ('w' | 'week' | 'weeks')
+    ;
+
+MONTH_INTERVAL
+    : DECIMAL_INTEGER ('mon' | 'month' | 'months')
+    ;
+
+QUARTER_INTERVAL
+    : DECIMAL_INTEGER ('q' | 'qtr' | 'qtrs' | 'quarter' | 'quarters')
+    ;
+
+YEAR_INTERVAL
+    : DECIMAL_INTEGER ('y' | 'yr' | 'yrs' | 'year' | 'years')
+    ;
+
+ROWS_LITERAL
+    : DECIMAL_INTEGER ('r' | 'row' | 'rows')
+    ;
+
+SECOND_TRUNC
+    : '@'  ('s' | 'sec' | 'secs' | 'second' | 'seconds')
+    ;
+
+MINUTE_TRUNC
+    : '@'  ('m' | 'min' | 'mins' | 'minute' | 'minutes')
+    ;
+
+HOUR_TRUNC
+    : '@' ('h' | 'hr' | 'hrs' | 'hour' | 'hours')
+    ;
+
+DAY_TRUNC
+    : '@' ('d' | 'day' | 'days')
+    ;
+
+WEEK_TRUNC
+    : '@' ('w' | 'week' | 'weeks')
+    ;
+
+MONTH_TRUNC
+    : '@' ('mon' | 'month' | 'months')
+    ;
+
+QUARTER_TRUNC
+    : '@' ('q' | 'qtr' | 'qtrs' | 'quarter' | 'quarters')
+    ;
+
+YEAR_TRUNC
+    : '@' ('y' | 'yr' | 'yrs' | 'year' | 'years')
+    ;
+
+INTEGER_VALUE
+    : DECIMAL_INTEGER
+    | HEXADECIMAL_INTEGER
+    | OCTAL_INTEGER
+    | BINARY_INTEGER
+    ;
+
+DECIMAL_VALUE
+    : DECIMAL_INTEGER '.' DECIMAL_INTEGER
+    | '.' DECIMAL_INTEGER
+    ;
+
+DOUBLE_VALUE
+    : DIGIT+ ('.' DIGIT*)? EXPONENT
+    | '.' DIGIT+ EXPONENT
+    ;
+
+IDENTIFIER
+    : [a-zA-Z_][a-zA-Z_0-9]*
+    ;
+
+BACKQUOTED_IDENTIFIER
+    : '\`' ( ~'\`' | '\`\`' )* '\`'
+    ;
+
+fragment DECIMAL_INTEGER
+    : DIGIT ('_'? DIGIT)*
+    ;
+
+fragment HEXADECIMAL_INTEGER
+    : '0x' ('_'? (DIGIT | [A-F]))+
+    ;
+
+fragment OCTAL_INTEGER
+    : '0o' ('_'? [0-7])+
+    ;
+
+fragment BINARY_INTEGER
+    : '0b' ('_'? [01])+
+    ;
+
+fragment EXPONENT
+    : 'e' [+-]? DIGIT+
+    ;
+
+fragment DIGIT
+    : [0-9]
+    ;
+
+//
+// Comments and whitespace
+//
+
+SIMPLE_COMMENT
+    : '//' ~[\\r\\n]* '\\r'? '\\n'? -> channel(HIDDEN)
+    ;
+
+BRACKETED_COMMENT
+    : '/*' .*? '*/' -> channel(HIDDEN)
+    ;
+
+WS
+    : [ \\r\\n\\t]+ -> skip
+    ;
+`;
+
 // src/get-datasets-from-query.ts
 var getDatasetsFromQuery = async (catalog, hamelinInput) => {
   await initializeWasm();
@@ -26954,5 +27400,6 @@ export {
   getFunctionDescriptions,
   getLimits,
   getSorts,
+  hamelinGrammar,
   sampleCatalog
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hamelin.sh/compiler",
-  "version": "0.2.3-prerelease.20250910T133135",
+  "version": "0.2.3",
   "sideEffects": false,
   "license": "UNLICENSED",
   "type": "module",
@@ -33,12 +33,13 @@
     "check": "pnpm check:types",
     "check:types": "tsc --noEmit",
     "dev": "tsup --watch",
-    "generate": "pnpm generate:1 && pnpm generate:2 && pnpm generate:3 && pnpm generate:4 && pnpm generate:5",
+    "generate": "pnpm generate:1 && pnpm generate:2 && pnpm generate:3 && pnpm generate:4 && pnpm generate:5 && pnpm generate:6",
     "generate:1": "cd ../../hamelin_wasm && wasm-pack build --target web",
     "generate:2": "copyfiles -u 4 \"../../hamelin_wasm/pkg/hamelin_wasm*\" src/generated/",
     "generate:3": "node encode-wasm.js",
     "generate:4": "antlr4ng -Dlanguage=TypeScript -visitor -Xexact-output-dir ../../hamelin_lib/grammars/Hamelin.g4 -o src/generated",
-    "generate:5": "biome lint --write src/generated --only style/useImportType --config-path ./purposefully-empty.json",
+    "generate:5": "node generate-hamelin-grammar-string.js",
+    "generate:6": "biome lint --write src/generated --only style/useImportType --config-path ./purposefully-empty.json",
     "test": "vitest"
   }
 }