:hedgehog: PostHog is the leading platform for building self-driving products. Our developer tools – AI observability, analytics, session replay, flags, experiments, error tracking, logs, and more – capture all the context agents need to diagnose problems, uncover opportunities, and ship fixes. Steer it all from Slack, web, desktop, or the MCP.
Python ab-testingai-analyticsanalyticscdpdata-warehouseexperimentsfeature-flagsjavascriptproduct-analyticspythonreactsession-replaysurveystypescriptweb-analytics
// Generated from HogQLParser.g4 by ANTLR 4.13.2
#pragma once
#include "antlr4-runtime.h"
class HogQLParser : public antlr4::Parser {
public:
enum {
ALL = 1, AND = 2, ANTI = 3, ANY = 4, ARRAY = 5, AS = 6, ASCENDING = 7,
ASOF = 8, BETWEEN = 9, BOTH = 10, BY = 11, CASE = 12, CAST = 13, CATCH = 14,
COHORT = 15, COLLATE = 16, COLUMNS = 17, CROSS = 18, CUBE = 19, CURRENT = 20,
DATE = 21, DAY = 22, DESC = 23, DESCENDING = 24, DISTINCT = 25, ELSE = 26,
END = 27, EXCEPT = 28, EXCLUDE = 29, EXTRACT = 30, FINAL = 31, FILL = 32,
FILTER = 33, FINALLY = 34, FIRST = 35, FN = 36, FOLLOWING = 37, FOR = 38,
FROM = 39, FULL = 40, FUN = 41, GROUP = 42, GROUPING = 43, HAVING = 44,
HOUR = 45, ID = 46, IF = 47, ILIKE = 48, IGNORE = 49, INCLUDE = 50,
IN = 51, INF = 52, INNER = 53, INTERSECT = 54, INTERPOLATE = 55, INTERVAL = 56,
IS = 57, JOIN = 58, KEY = 59, LAMBDA = 60, LAST = 61, LEADING = 62,
LEFT = 63, LET = 64, LIKE = 65, LIMIT = 66, MATERIALIZED = 67, MINUTE = 68,
MONTH = 69, NAME = 70, NATURAL = 71, NAN_SQL = 72, NOT = 73, NULL_SQL = 74,
NULLS = 75, OFFSET = 76, ON = 77, OR = 78, ORDER = 79, OUTER = 80, OVER = 81,
PARTITION = 82, PIVOT = 83, POSITIONAL = 84, PRECEDING = 85, PREWHERE = 86,
QUALIFY = 87, QUARTER = 88, RANGE = 89, RECURSIVE = 90, REPLACE = 91,
RETURN = 92, RIGHT = 93, ROLLUP = 94, ROW = 95, ROWS = 96, SAMPLE = 97,
SECOND = 98, SELECT = 99, SEMI = 100, SETS = 101, SETTINGS = 102, STEP = 103,
SUBSTRING = 104, THEN = 105, THROW = 106, TIES = 107, TIMESTAMP = 108,
TIME = 109, LOCAL = 110, ZONE = 111, TO = 112, TOP = 113, TOTALS = 114,
TRAILING = 115, TRIM = 116, TRUNCATE = 117, TRY = 118, TRY_CAST = 119,
UNBOUNDED = 120, UNION = 121, UNPIVOT = 122, USING = 123, VALUES = 124,
WEEK = 125, WHEN = 126, WHERE = 127, WHILE = 128, WINDOW = 129, WITH = 130,
WITHIN = 131, YEAR = 132, ESCAPE_CHAR_COMMON = 133, IDENTIFIER = 134,
QUOTED_IDENTIFIER = 135, FLOATING_LITERAL = 136, BINARY_LITERAL = 137,
OCTAL_LITERAL = 138, DECIMAL_LITERAL = 139, HEXADECIMAL_LITERAL = 140,
OCTAL_PREFIX_LITERAL = 141, MALFORMED_BINARY_LITERAL = 142, STRING_LITERAL = 143,
ARROW = 144, ASTERISK = 145, BACKQUOTE = 146, BACKSLASH = 147, DOUBLECOLON = 148,
COLONEQUALS = 149, COLON = 150, COMMA = 151, CONCAT = 152, DASH = 153,
DOLLAR = 154, DOT = 155, EQ_DOUBLE = 156, EQ_SINGLE = 157, GT_EQ = 158,
GT = 159, HASH = 160, IREGEX_SINGLE = 161, IREGEX_DOUBLE = 162, LBRACE = 163,
LBRACKET = 164, LPAREN = 165, NULL_SAFE_EQ = 166, LT_EQ = 167, LT = 168,
LT_SLASH = 169, NOT_EQ = 170, NOT_IREGEX = 171, NOT_REGEX = 172, NULL_PROPERTY = 173,
NULLISH = 174, PERCENT = 175, PLUS = 176, QUERY = 177, QUOTE_DOUBLE = 178,
QUOTE_SINGLE_TEMPLATE = 179, QUOTE_SINGLE_TEMPLATE_FULL = 180, QUOTE_SINGLE = 181,
REGEX_SINGLE = 182, REGEX_DOUBLE = 183, RBRACE = 184, RBRACKET = 185,
RPAREN = 186, SEMICOLON = 187, SLASH = 188, SLASH_GT = 189, UNDERSCORE = 190,
MULTI_LINE_COMMENT = 191, SINGLE_LINE_COMMENT = 192, HASH_COMMENT = 193,
WHITESPACE = 194, UNEXPECTED_CHARACTER = 195, STRING_TEXT = 196, STRING_ESCAPE_TRIGGER = 197,
FULL_STRING_TEXT = 198, FULL_STRING_ESCAPE_TRIGGER = 199, TAG_MULTI_LINE_COMMENT = 200,
TAG_SINGLE_LINE_COMMENT = 201, TAG_WS = 202, TAGC_MULTI_LINE_COMMENT = 203,
TAGC_SINGLE_LINE_COMMENT = 204, TAGC_WS = 205, HOGQLX_TEXT_TEXT = 206,
HOGQLX_TEXT_WS = 207
};
enum {
RuleProgram = 0, RuleDeclaration = 1, RuleExpression = 2, RuleVarDecl = 3,
RuleIdentifierList = 4, RuleStatement = 5, RuleReturnStmt = 6, RuleThrowStmt = 7,
RuleCatchBlock = 8, RuleTryCatchStmt = 9, RuleIfStmt = 10, RuleWhileStmt = 11,
RuleForStmt = 12, RuleForInStmt = 13, RuleFuncStmt = 14, RuleVarAssignment = 15,
RuleExprStmt = 16, RuleEmptyStmt = 17, RuleBlock = 18, RuleKvPair = 19,
RuleKvPairList = 20, RuleSelect = 21, RuleSelectStmtWithParens = 22,
RuleSubsequentSelectSetClause = 23, RuleSelectSetStmt = 24, RuleLimitAndOffsetClauseOptional = 25,
RuleSelectStmt = 26, RuleWithClause = 27, RuleTopClause = 28, RuleFromClause = 29,
RuleArrayJoinClause = 30, RuleWindowClause = 31, RulePrewhereClause = 32,
RuleWhereClause = 33, RuleGroupByClause = 34, RuleGroupingSetList = 35,
RuleGroupingSet = 36, RuleHavingClause = 37, RuleQualifyClause = 38,
RuleOrderByClause = 39, RuleInterpolateClause = 40, RuleProjectionOrderByClause = 41,
RuleLimitByClause = 42, RuleLimitAndOffsetClause = 43, RuleOffsetOnlyClause = 44,
RuleSettingsClause = 45, RuleValuesClause = 46, RuleValuesRow = 47,
RuleJoinExpr = 48, RuleJoinOp = 49, RuleJoinOpCross = 50, RuleJoinConstraintClause = 51,
RuleSampleClause = 52, RuleLimitExpr = 53, RuleOrderExprList = 54, RuleOrderExpr = 55,
RuleWithFillClause = 56, RuleInterpolateExpr = 57, RuleRatioExpr = 58,
RuleSettingExprList = 59, RuleSettingExpr = 60, RuleWindowExpr = 61,
RuleWinPartitionByClause = 62, RuleWinOrderByClause = 63, RuleWithinGroupClause = 64,
RuleWinFrameClause = 65, RuleWinFrameExtend = 66, RuleWinFrameBound = 67,
RuleExpr = 68, RuleColumnTypeExpr = 69, RuleColumnTypeCastExpr = 70,
RuleColumnTypeCastIdentifier = 71, RuleKeywordForTypeCast = 72, RuleColumnExprList = 73,
RuleSelectColumnExprListBeforeFrom = 74, RuleSelectColumnExprList = 75,
RuleSelectColumnExpr = 76, RuleColumnExpr = 77, RuleColumnExprValue = 78,
RuleColumnLambdaExpr = 79, RuleColumnsReplaceList = 80, RuleColumnsReplaceItem = 81,
RuleHogqlxChildElement = 82, RuleHogqlxText = 83, RuleHogqlxTagElement = 84,
RuleHogqlxTagAttribute = 85, RuleWithExprList = 86, RuleWithExpr = 87,
RuleWithExprColumnNameList = 88, RuleColumnIdentifier = 89, RuleNestedIdentifier = 90,
RuleTableExpr = 91, RulePivotColumnList = 92, RulePivotColumn = 93,
RuleUnpivotColumnList = 94, RuleUnpivotColumn = 95, RuleColumnExprTupleOrSingle = 96,
RuleColumnAliases = 97, RuleTableFunctionExpr = 98, RuleTableIdentifier = 99,
RuleTableArgList = 100, RuleDatabaseIdentifier = 101, RuleFloatingLiteral = 102,
RuleNumberLiteral = 103, RuleLiteral = 104, RuleInterval = 105, RuleKeyword = 106,
RuleKeywordForAlias = 107, RuleKeywordForImplicitAlias = 108, RuleAlias = 109,
RuleImplicitAlias = 110, RuleIdentifier = 111, RuleEnumValue = 112,
RulePlaceholder = 113, RuleString = 114, RuleTemplateString = 115, RuleStringContents = 116,
RuleFullTemplateString = 117, RuleStringContentsFull = 118
};
explicit HogQLParser(antlr4::TokenStream *input);
HogQLParser(antlr4::TokenStream *input, const antlr4::atn::ParserATNSimulatorOptions &options);
~HogQLParser() override;
std::string getGrammarFileName() const override;
const antlr4::atn::ATN& getATN() const override;
const std::vector<std::string>& getRuleNames() const override;
const antlr4::dfa::Vocabulary& getVocabulary() const override;
antlr4::atn::SerializedATNView getSerializedATN() const override;
class ProgramContext;
class DeclarationContext;
class ExpressionContext;
class VarDeclContext;
class IdentifierListContext;
class StatementContext;
class ReturnStmtContext;
class ThrowStmtContext;
class CatchBlockContext;
class TryCatchStmtContext;
class IfStmtContext;
class WhileStmtContext;
class ForStmtContext;
class ForInStmtContext;
class FuncStmtContext;
class VarAssignmentContext;
class ExprStmtContext;
class EmptyStmtContext;
class BlockContext;
class KvPairContext;
class KvPairListContext;
class SelectContext;
class SelectStmtWithParensContext;
class SubsequentSelectSetClauseContext;
class SelectSetStmtContext;
class LimitAndOffsetClauseOptionalContext;
class SelectStmtContext;
class WithClauseContext;
class TopClauseContext;
class FromClauseContext;
class ArrayJoinClauseContext;
class WindowClauseContext;
class PrewhereClauseContext;
class WhereClauseContext;
class GroupByClauseContext;
class GroupingSetListContext;
class GroupingSetContext;
class HavingClauseContext;
class QualifyClauseContext;
class OrderByClauseContext;
class InterpolateClauseContext;
class ProjectionOrderByClauseContext;
class LimitByClauseContext;
class LimitAndOffsetClauseContext;
class OffsetOnlyClauseContext;
class SettingsClauseContext;
class ValuesClauseContext;
class ValuesRowContext;
class JoinExprContext;
class JoinOpContext;
class JoinOpCrossContext;
class JoinConstraintClauseContext;
class SampleClauseContext;
class LimitExprContext;
class OrderExprListContext;
class OrderExprContext;
class WithFillClauseContext;
class InterpolateExprContext;
class RatioExprContext;
class SettingExprListContext;
class SettingExprContext;
class WindowExprContext;
class WinPartitionByClauseContext;
class WinOrderByClauseContext;
class WithinGroupClauseContext;
class WinFrameClauseContext;
class WinFrameExtendContext;
class WinFrameBoundContext;
class ExprContext;
class ColumnTypeExprContext;
class ColumnTypeCastExprContext;
class ColumnTypeCastIdentifierContext;
class KeywordForTypeCastContext;
class ColumnExprListContext;
class SelectColumnExprListBeforeFromContext;
class SelectColumnExprListContext;
class SelectColumnExprContext;
class ColumnExprContext;
class ColumnExprValueContext;
class ColumnLambdaExprContext;
class ColumnsReplaceListContext;
class ColumnsReplaceItemContext;
class HogqlxChildElementContext;
class HogqlxTextContext;
class HogqlxTagElementContext;
class HogqlxTagAttributeContext;
class WithExprListContext;
class WithExprContext;
class WithExprColumnNameListContext;
class ColumnIdentifierContext;
class NestedIdentifierContext;
class TableExprContext;
class PivotColumnListContext;
class PivotColumnContext;
class UnpivotColumnListContext;
class UnpivotColumnContext;
class ColumnExprTupleOrSingleContext;
class ColumnAliasesContext;
class TableFunctionExprContext;
class TableIdentifierContext;
class TableArgListContext;
class DatabaseIdentifierContext;
class FloatingLiteralContext;
class NumberLiteralContext;
class LiteralContext;
class IntervalContext;
class KeywordContext;
class KeywordForAliasContext;
class KeywordForImplicitAliasContext;
class AliasContext;
class ImplicitAliasContext;
class IdentifierContext;
class EnumValueContext;
class PlaceholderContext;
class StringContext;
class TemplateStringContext;
class StringContentsContext;
class FullTemplateStringContext;
class StringContentsFullContext;
class ProgramContext : public antlr4::ParserRuleContext {
public:
ProgramContext(antlr4::ParserRuleContext *parent, size_t invokingState);
virtual size_t getRuleIndex() const override;
antlr4::tree::TerminalNode *EOF();
std::vector<DeclarationContext *> declaration();
DeclarationContext* declaration(size_t i);
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
ProgramContext* program();
class DeclarationContext : public antlr4::ParserRuleContext {
public:
DeclarationContext(antlr4::ParserRuleContext *parent, size_t invokingState);
virtual size_t getRuleIndex() const override;
VarDeclContext *varDecl();
StatementContext *statement();
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
DeclarationContext* declaration();
class ExpressionContext : public antlr4::ParserRuleContext {
public:
ExpressionContext(antlr4::ParserRuleContext *parent, size_t invokingState);
virtual size_t getRuleIndex() const override;
ColumnExprContext *columnExpr();
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
ExpressionContext* expression();
class VarDeclContext : public antlr4::ParserRuleContext {
public:
VarDeclContext(antlr4::ParserRuleContext *parent, size_t invokingState);
virtual size_t getRuleIndex() const override;
antlr4::tree::TerminalNode *LET();
IdentifierContext *identifier();
antlr4::tree::TerminalNode *COLONEQUALS();
ExpressionContext *expression();
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
VarDeclContext* varDecl();
class IdentifierListContext : public antlr4::ParserRuleContext {
public:
IdentifierListContext(antlr4::ParserRuleContext *parent, size_t invokingState);
virtual size_t getRuleIndex() const override;
std::vector<NestedIdentifierContext *> nestedIdentifier();
NestedIdentifierContext* nestedIdentifier(size_t i);
std::vector<antlr4::tree::TerminalNode *> COMMA();
antlr4::tree::TerminalNode* COMMA(size_t i);
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
IdentifierListContext* identifierList();
class StatementContext : public antlr4::ParserRuleContext {
public:
StatementContext(antlr4::ParserRuleContext *parent, size_t invokingState);
virtual size_t getRuleIndex() const override;
ReturnStmtContext *returnStmt();
ThrowStmtContext *throwStmt();
TryCatchStmtContext *tryCatchStmt();
IfStmtContext *ifStmt();
WhileStmtContext *whileStmt();
ForInStmtContext *forInStmt();
ForStmtContext *forStmt();
FuncStmtContext *funcStmt();
BlockContext *block();
ExprStmtContext *exprStmt();
EmptyStmtContext *emptyStmt();
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
StatementContext* statement();
class ReturnStmtContext : public antlr4::ParserRuleContext {
public:
ReturnStmtContext(antlr4::ParserRuleContext *parent, size_t invokingState);
virtual size_t getRuleIndex() const override;
antlr4::tree::TerminalNode *RETURN();
ExpressionContext *expression();
antlr4::tree::TerminalNode *SEMICOLON();
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
ReturnStmtContext* returnStmt();
class ThrowStmtContext : public antlr4::ParserRuleContext {
public:
ThrowStmtContext(antlr4::ParserRuleContext *parent, size_t invokingState);
virtual size_t getRuleIndex() const override;
antlr4::tree::TerminalNode *THROW();
ExpressionContext *expression();
antlr4::tree::TerminalNode *SEMICOLON();
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
ThrowStmtContext* throwStmt();
class CatchBlockContext : public antlr4::ParserRuleContext {
public:
HogQLParser::IdentifierContext *catchVar = nullptr;
HogQLParser::IdentifierContext *catchType = nullptr;
HogQLParser::BlockContext *catchStmt = nullptr;
CatchBlockContext(antlr4::ParserRuleContext *parent, size_t invokingState);
virtual size_t getRuleIndex() const override;
antlr4::tree::TerminalNode *CATCH();
BlockContext *block();
antlr4::tree::TerminalNode *LPAREN();
antlr4::tree::TerminalNode *RPAREN();
std::vector<IdentifierContext *> identifier();
IdentifierContext* identifier(size_t i);
antlr4::tree::TerminalNode *COLON();
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
CatchBlockContext* catchBlock();
class TryCatchStmtContext : public antlr4::ParserRuleContext {
public:
HogQLParser::BlockContext *tryStmt = nullptr;
HogQLParser::BlockContext *finallyStmt = nullptr;
TryCatchStmtContext(antlr4::ParserRuleContext *parent, size_t invokingState);
virtual size_t getRuleIndex() const override;
antlr4::tree::TerminalNode *TRY();
std::vector<BlockContext *> block();
BlockContext* block(size_t i);
std::vector<CatchBlockContext *> catchBlock();
CatchBlockContext* catchBlock(size_t i);
antlr4::tree::TerminalNode *FINALLY();
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
TryCatchStmtContext* tryCatchStmt();
class IfStmtContext : public antlr4::ParserRuleContext {
public:
IfStmtContext(antlr4::ParserRuleContext *parent, size_t invokingState);
virtual size_t getRuleIndex() const override;
antlr4::tree::TerminalNode *IF();
antlr4::tree::TerminalNode *LPAREN();
ExpressionContext *expression();
antlr4::tree::TerminalNode *RPAREN();
std::vector<StatementContext *> statement();
StatementContext* statement(size_t i);
antlr4::tree::TerminalNode *ELSE();
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
IfStmtContext* ifStmt();
class WhileStmtContext : public antlr4::ParserRuleContext {
public:
WhileStmtContext(antlr4::ParserRuleContext *parent, size_t invokingState);
virtual size_t getRuleIndex() const override;
antlr4::tree::TerminalNode *WHILE();
antlr4::tree::TerminalNode *LPAREN();
ExpressionContext *expression();
antlr4::tree::TerminalNode *RPAREN();
StatementContext *statement();
antlr4::tree::TerminalNode *SEMICOLON();
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
WhileStmtContext* whileStmt();
class ForStmtContext : public antlr4::ParserRuleContext {
public:
HogQLParser::VarDeclContext *initializerVarDeclr = nullptr;
HogQLParser::VarAssignmentContext *initializerVarAssignment = nullptr;
HogQLParser::ExpressionContext *initializerExpression = nullptr;
HogQLParser::ExpressionContext *condition = nullptr;
HogQLParser::VarDeclContext *incrementVarDeclr = nullptr;
HogQLParser::VarAssignmentContext *incrementVarAssignment = nullptr;
HogQLParser::ExpressionContext *incrementExpression = nullptr;
ForStmtContext(antlr4::ParserRuleContext *parent, size_t invokingState);
virtual size_t getRuleIndex() const override;
antlr4::tree::TerminalNode *FOR();
antlr4::tree::TerminalNode *LPAREN();
std::vector<antlr4::tree::TerminalNode *> SEMICOLON();
antlr4::tree::TerminalNode* SEMICOLON(size_t i);
antlr4::tree::TerminalNode *RPAREN();
StatementContext *statement();
std::vector<VarDeclContext *> varDecl();
VarDeclContext* varDecl(size_t i);
std::vector<VarAssignmentContext *> varAssignment();
VarAssignmentContext* varAssignment(size_t i);
std::vector<ExpressionContext *> expression();
ExpressionContext* expression(size_t i);
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
ForStmtContext* forStmt();
class ForInStmtContext : public antlr4::ParserRuleContext {
public:
ForInStmtContext(antlr4::ParserRuleContext *parent, size_t invokingState);
virtual size_t getRuleIndex() const override;
antlr4::tree::TerminalNode *FOR();
antlr4::tree::TerminalNode *LPAREN();
antlr4::tree::TerminalNode *LET();
std::vector<IdentifierContext *> identifier();
IdentifierContext* identifier(size_t i);
antlr4::tree::TerminalNode *IN();
ExpressionContext *expression();
antlr4::tree::TerminalNode *RPAREN();
StatementContext *statement();
antlr4::tree::TerminalNode *COMMA();
antlr4::tree::TerminalNode *SEMICOLON();
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
ForInStmtContext* forInStmt();
class FuncStmtContext : public antlr4::ParserRuleContext {
public:
FuncStmtContext(antlr4::ParserRuleContext *parent, size_t invokingState);
virtual size_t getRuleIndex() const override;
IdentifierContext *identifier();
antlr4::tree::TerminalNode *LPAREN();
antlr4::tree::TerminalNode *RPAREN();
BlockContext *block();
antlr4::tree::TerminalNode *FN();
antlr4::tree::TerminalNode *FUN();
IdentifierListContext *identifierList();
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
FuncStmtContext* funcStmt();
class VarAssignmentContext : public antlr4::ParserRuleContext {
public:
VarAssignmentContext(antlr4::ParserRuleContext *parent, size_t invokingState);
virtual size_t getRuleIndex() const override;
std::vector<ExpressionContext *> expression();
ExpressionContext* expression(size_t i);
antlr4::tree::TerminalNode *COLONEQUALS();
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
VarAssignmentContext* varAssignment();
class ExprStmtContext : public antlr4::ParserRuleContext {
public:
ExprStmtContext(antlr4::ParserRuleContext *parent, size_t invokingState);
virtual size_t getRuleIndex() const override;
std::vector<ExpressionContext *> expression();
ExpressionContext* expression(size_t i);
antlr4::tree::TerminalNode *COLONEQUALS();
antlr4::tree::TerminalNode *SEMICOLON();
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
ExprStmtContext* exprStmt();
class EmptyStmtContext : public antlr4::ParserRuleContext {
public:
EmptyStmtContext(antlr4::ParserRuleContext *parent, size_t invokingState);
virtual size_t getRuleIndex() const override;
antlr4::tree::TerminalNode *SEMICOLON();
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
EmptyStmtContext* emptyStmt();
class BlockContext : public antlr4::ParserRuleContext {
public:
BlockContext(antlr4::ParserRuleContext *parent, size_t invokingState);
virtual size_t getRuleIndex() const override;
antlr4::tree::TerminalNode *LBRACE();
antlr4::tree::TerminalNode *RBRACE();
std::vector<DeclarationContext *> declaration();
DeclarationContext* declaration(size_t i);
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
BlockContext* block();
class KvPairContext : public antlr4::ParserRuleContext {
public:
KvPairContext(antlr4::ParserRuleContext *parent, size_t invokingState);
virtual size_t getRuleIndex() const override;
std::vector<ExpressionContext *> expression();
ExpressionContext* expression(size_t i);
antlr4::tree::TerminalNode *COLON();
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
KvPairContext* kvPair();
class KvPairListContext : public antlr4::ParserRuleContext {
public:
KvPairListContext(antlr4::ParserRuleContext *parent, size_t invokingState);
virtual size_t getRuleIndex() const override;
std::vector<KvPairContext *> kvPair();
KvPairContext* kvPair(size_t i);
std::vector<antlr4::tree::TerminalNode *> COMMA();
antlr4::tree::TerminalNode* COMMA(size_t i);
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
KvPairListContext* kvPairList();
class SelectContext : public antlr4::ParserRuleContext {
public:
SelectContext(antlr4::ParserRuleContext *parent, size_t invokingState);
virtual size_t getRuleIndex() const override;
antlr4::tree::TerminalNode *EOF();
SelectSetStmtContext *selectSetStmt();
SelectStmtContext *selectStmt();
HogqlxTagElementContext *hogqlxTagElement();
antlr4::tree::TerminalNode *SEMICOLON();
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
SelectContext* select();
class SelectStmtWithParensContext : public antlr4::ParserRuleContext {
public:
SelectStmtWithParensContext(antlr4::ParserRuleContext *parent, size_t invokingState);
virtual size_t getRuleIndex() const override;
SelectStmtContext *selectStmt();
WithClauseContext *withClause();
antlr4::tree::TerminalNode *LPAREN();
SelectSetStmtContext *selectSetStmt();
antlr4::tree::TerminalNode *RPAREN();
PlaceholderContext *placeholder();
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
SelectStmtWithParensContext* selectStmtWithParens();
class SubsequentSelectSetClauseContext : public antlr4::ParserRuleContext {
public:
SubsequentSelectSetClauseContext(antlr4::ParserRuleContext *parent, size_t invokingState);
virtual size_t getRuleIndex() const override;
SelectStmtWithParensContext *selectStmtWithParens();
antlr4::tree::TerminalNode *EXCEPT();
antlr4::tree::TerminalNode *ALL();
antlr4::tree::TerminalNode *UNION();
antlr4::tree::TerminalNode *DISTINCT();
antlr4::tree::TerminalNode *INTERSECT();
antlr4::tree::TerminalNode *BY();
antlr4::tree::TerminalNode *NAME();
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
SubsequentSelectSetClauseContext* subsequentSelectSetClause();
class SelectSetStmtContext : public antlr4::ParserRuleContext {
public:
SelectSetStmtContext(antlr4::ParserRuleContext *parent, size_t invokingState);
virtual size_t getRuleIndex() const override;
SelectStmtWithParensContext *selectStmtWithParens();
std::vector<SubsequentSelectSetClauseContext *> subsequentSelectSetClause();
SubsequentSelectSetClauseContext* subsequentSelectSetClause(size_t i);
OrderByClauseContext *orderByClause();
LimitAndOffsetClauseOptionalContext *limitAndOffsetClauseOptional();
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
SelectSetStmtContext* selectSetStmt();
class LimitAndOffsetClauseOptionalContext : public antlr4::ParserRuleContext {
public:
LimitAndOffsetClauseOptionalContext(antlr4::ParserRuleContext *parent, size_t invokingState);
virtual size_t getRuleIndex() const override;
antlr4::tree::TerminalNode *LIMIT();
std::vector<ColumnExprContext *> columnExpr();
ColumnExprContext* columnExpr(size_t i);
antlr4::tree::TerminalNode *PERCENT();
antlr4::tree::TerminalNode *COMMA();
antlr4::tree::TerminalNode *WITH();
antlr4::tree::TerminalNode *TIES();
antlr4::tree::TerminalNode *OFFSET();
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
LimitAndOffsetClauseOptionalContext* limitAndOffsetClauseOptional();
class SelectStmtContext : public antlr4::ParserRuleContext {
public:
HogQLParser::WithClauseContext *with = nullptr;
HogQLParser::SelectColumnExprListBeforeFromContext *columns = nullptr;
HogQLParser::FromClauseContext *from = nullptr;
HogQLParser::WhereClauseContext *where = nullptr;
SelectStmtContext(antlr4::ParserRuleContext *parent, size_t invokingState);
virtual size_t getRuleIndex() const override;
antlr4::tree::TerminalNode *SELECT();
SelectColumnExprListBeforeFromContext *selectColumnExprListBeforeFrom();
antlr4::tree::TerminalNode *DISTINCT();
TopClauseContext *topClause();
ArrayJoinClauseContext *arrayJoinClause();
PrewhereClauseContext *prewhereClause();
std::vector<SampleClauseContext *> sampleClause();
SampleClauseContext* sampleClause(size_t i);
GroupByClauseContext *groupByClause();
std::vector<antlr4::tree::TerminalNode *> WITH();
antlr4::tree::TerminalNode* WITH(size_t i);
antlr4::tree::TerminalNode *TOTALS();
HavingClauseContext *havingClause();
QualifyClauseContext *qualifyClause();
std::vector<antlr4::tree::TerminalNode *> USING();
antlr4::tree::TerminalNode* USING(size_t i);
WindowClauseContext *windowClause();
OrderByClauseContext *orderByClause();
LimitByClauseContext *limitByClause();
LimitAndOffsetClauseContext *limitAndOffsetClause();
OffsetOnlyClauseContext *offsetOnlyClause();
SettingsClauseContext *settingsClause();
WithClauseContext *withClause();
FromClauseContext *fromClause();
WhereClauseContext *whereClause();
antlr4::tree::TerminalNode *CUBE();
antlr4::tree::TerminalNode *ROLLUP();
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
SelectStmtContext* selectStmt();
class WithClauseContext : public antlr4::ParserRuleContext {
public:
WithClauseContext(antlr4::ParserRuleContext *parent, size_t invokingState);
virtual size_t getRuleIndex() const override;
antlr4::tree::TerminalNode *WITH();
WithExprListContext *withExprList();
antlr4::tree::TerminalNode *RECURSIVE();
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
WithClauseContext* withClause();
class TopClauseContext : public antlr4::ParserRuleContext {
public:
TopClauseContext(antlr4::ParserRuleContext *parent, size_t invokingState);
virtual size_t getRuleIndex() const override;
antlr4::tree::TerminalNode *TOP();
antlr4::tree::TerminalNode *DECIMAL_LITERAL();
antlr4::tree::TerminalNode *WITH();
antlr4::tree::TerminalNode *TIES();
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
TopClauseContext* topClause();
class FromClauseContext : public antlr4::ParserRuleContext {
public:
FromClauseContext(antlr4::ParserRuleContext *parent, size_t invokingState);
virtual size_t getRuleIndex() const override;
antlr4::tree::TerminalNode *FROM();
JoinExprContext *joinExpr();
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
FromClauseContext* fromClause();
class ArrayJoinClauseContext : public antlr4::ParserRuleContext {
public:
ArrayJoinClauseContext(antlr4::ParserRuleContext *parent, size_t invokingState);
virtual size_t getRuleIndex() const override;
antlr4::tree::TerminalNode *ARRAY();
antlr4::tree::TerminalNode *JOIN();
ColumnExprListContext *columnExprList();
antlr4::tree::TerminalNode *LEFT();
antlr4::tree::TerminalNode *INNER();
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
ArrayJoinClauseContext* arrayJoinClause();
class WindowClauseContext : public antlr4::ParserRuleContext {
public:
WindowClauseContext(antlr4::ParserRuleContext *parent, size_t invokingState);
virtual size_t getRuleIndex() const override;
antlr4::tree::TerminalNode *WINDOW();
std::vector<IdentifierContext *> identifier();
IdentifierContext* identifier(size_t i);
std::vector<antlr4::tree::TerminalNode *> AS();
antlr4::tree::TerminalNode* AS(size_t i);
std::vector<antlr4::tree::TerminalNode *> LPAREN();
antlr4::tree::TerminalNode* LPAREN(size_t i);
std::vector<WindowExprContext *> windowExpr();
WindowExprContext* windowExpr(size_t i);
std::vector<antlr4::tree::TerminalNode *> RPAREN();
antlr4::tree::TerminalNode* RPAREN(size_t i);
std::vector<antlr4::tree::TerminalNode *> COMMA();
antlr4::tree::TerminalNode* COMMA(size_t i);
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
WindowClauseContext* windowClause();
class PrewhereClauseContext : public antlr4::ParserRuleContext {
public:
PrewhereClauseContext(antlr4::ParserRuleContext *parent, size_t invokingState);
virtual size_t getRuleIndex() const override;
antlr4::tree::TerminalNode *PREWHERE();
ColumnExprContext *columnExpr();
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
PrewhereClauseContext* prewhereClause();
class WhereClauseContext : public antlr4::ParserRuleContext {
public:
WhereClauseContext(antlr4::ParserRuleContext *parent, size_t invokingState);
virtual size_t getRuleIndex() const override;
antlr4::tree::TerminalNode *WHERE();
ColumnExprContext *columnExpr();
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
WhereClauseContext* whereClause();
class GroupByClauseContext : public antlr4::ParserRuleContext {
public:
GroupByClauseContext(antlr4::ParserRuleContext *parent, size_t invokingState);
virtual size_t getRuleIndex() const override;
antlr4::tree::TerminalNode *GROUP();
antlr4::tree::TerminalNode *BY();
antlr4::tree::TerminalNode *ALL();
antlr4::tree::TerminalNode *LPAREN();
ColumnExprListContext *columnExprList();
antlr4::tree::TerminalNode *RPAREN();
antlr4::tree::TerminalNode *GROUPING();
antlr4::tree::TerminalNode *SETS();
GroupingSetListContext *groupingSetList();
antlr4::tree::TerminalNode *CUBE();
antlr4::tree::TerminalNode *ROLLUP();
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
GroupByClauseContext* groupByClause();
class GroupingSetListContext : public antlr4::ParserRuleContext {
public:
GroupingSetListContext(antlr4::ParserRuleContext *parent, size_t invokingState);
virtual size_t getRuleIndex() const override;
std::vector<GroupingSetContext *> groupingSet();
GroupingSetContext* groupingSet(size_t i);
std::vector<antlr4::tree::TerminalNode *> COMMA();
antlr4::tree::TerminalNode* COMMA(size_t i);
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
GroupingSetListContext* groupingSetList();
class GroupingSetContext : public antlr4::ParserRuleContext {
public:
GroupingSetContext(antlr4::ParserRuleContext *parent, size_t invokingState);
virtual size_t getRuleIndex() const override;
antlr4::tree::TerminalNode *LPAREN();
antlr4::tree::TerminalNode *RPAREN();
ColumnExprListContext *columnExprList();
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
GroupingSetContext* groupingSet();
class HavingClauseContext : public antlr4::ParserRuleContext {
public:
HavingClauseContext(antlr4::ParserRuleContext *parent, size_t invokingState);
virtual size_t getRuleIndex() const override;
antlr4::tree::TerminalNode *HAVING();
ColumnExprContext *columnExpr();
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
HavingClauseContext* havingClause();
class QualifyClauseContext : public antlr4::ParserRuleContext {
public:
QualifyClauseContext(antlr4::ParserRuleContext *parent, size_t invokingState);
virtual size_t getRuleIndex() const override;
antlr4::tree::TerminalNode *QUALIFY();
ColumnExprContext *columnExpr();
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
QualifyClauseContext* qualifyClause();
class OrderByClauseContext : public antlr4::ParserRuleContext {
public:
OrderByClauseContext(antlr4::ParserRuleContext *parent, size_t invokingState);
virtual size_t getRuleIndex() const override;
antlr4::tree::TerminalNode *ORDER();
antlr4::tree::TerminalNode *BY();
OrderExprListContext *orderExprList();
InterpolateClauseContext *interpolateClause();
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
OrderByClauseContext* orderByClause();
class InterpolateClauseContext : public antlr4::ParserRuleContext {
public:
InterpolateClauseContext(antlr4::ParserRuleContext *parent, size_t invokingState);
virtual size_t getRuleIndex() const override;
antlr4::tree::TerminalNode *INTERPOLATE();
antlr4::tree::TerminalNode *LPAREN();
std::vector<InterpolateExprContext *> interpolateExpr();
InterpolateExprContext* interpolateExpr(size_t i);
antlr4::tree::TerminalNode *RPAREN();
std::vector<antlr4::tree::TerminalNode *> COMMA();
antlr4::tree::TerminalNode* COMMA(size_t i);
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
InterpolateClauseContext* interpolateClause();
class ProjectionOrderByClauseContext : public antlr4::ParserRuleContext {
public:
ProjectionOrderByClauseContext(antlr4::ParserRuleContext *parent, size_t invokingState);
virtual size_t getRuleIndex() const override;
antlr4::tree::TerminalNode *ORDER();
antlr4::tree::TerminalNode *BY();
ColumnExprListContext *columnExprList();
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
ProjectionOrderByClauseContext* projectionOrderByClause();
class LimitByClauseContext : public antlr4::ParserRuleContext {
public:
LimitByClauseContext(antlr4::ParserRuleContext *parent, size_t invokingState);
virtual size_t getRuleIndex() const override;
antlr4::tree::TerminalNode *LIMIT();
LimitExprContext *limitExpr();
antlr4::tree::TerminalNode *BY();
ColumnExprListContext *columnExprList();
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
LimitByClauseContext* limitByClause();
class LimitAndOffsetClauseContext : public antlr4::ParserRuleContext {
public:
LimitAndOffsetClauseContext(antlr4::ParserRuleContext *parent, size_t invokingState);
virtual size_t getRuleIndex() const override;
antlr4::tree::TerminalNode *LIMIT();
std::vector<ColumnExprContext *> columnExpr();
ColumnExprContext* columnExpr(size_t i);
antlr4::tree::TerminalNode *PERCENT();
antlr4::tree::TerminalNode *COMMA();
antlr4::tree::TerminalNode *WITH();
antlr4::tree::TerminalNode *TIES();
antlr4::tree::TerminalNode *OFFSET();
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
LimitAndOffsetClauseContext* limitAndOffsetClause();
class OffsetOnlyClauseContext : public antlr4::ParserRuleContext {
public:
OffsetOnlyClauseContext(antlr4::ParserRuleContext *parent, size_t invokingState);
virtual size_t getRuleIndex() const override;
antlr4::tree::TerminalNode *OFFSET();
ColumnExprContext *columnExpr();
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
OffsetOnlyClauseContext* offsetOnlyClause();
class SettingsClauseContext : public antlr4::ParserRuleContext {
public:
SettingsClauseContext(antlr4::ParserRuleContext *parent, size_t invokingState);
virtual size_t getRuleIndex() const override;
antlr4::tree::TerminalNode *SETTINGS();
SettingExprListContext *settingExprList();
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
SettingsClauseContext* settingsClause();
class ValuesClauseContext : public antlr4::ParserRuleContext {
public:
ValuesClauseContext(antlr4::ParserRuleContext *parent, size_t invokingState);
virtual size_t getRuleIndex() const override;
antlr4::tree::TerminalNode *VALUES();
std::vector<ValuesRowContext *> valuesRow();
ValuesRowContext* valuesRow(size_t i);
std::vector<antlr4::tree::TerminalNode *> COMMA();
antlr4::tree::TerminalNode* COMMA(size_t i);
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
ValuesClauseContext* valuesClause();
class ValuesRowContext : public antlr4::ParserRuleContext {
public:
ValuesRowContext(antlr4::ParserRuleContext *parent, size_t invokingState);
virtual size_t getRuleIndex() const override;
antlr4::tree::TerminalNode *LPAREN();
std::vector<ColumnExprContext *> columnExpr();
ColumnExprContext* columnExpr(size_t i);
antlr4::tree::TerminalNode *RPAREN();
std::vector<antlr4::tree::TerminalNode *> COMMA();
antlr4::tree::TerminalNode* COMMA(size_t i);
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
ValuesRowContext* valuesRow();
class JoinExprContext : public antlr4::ParserRuleContext {
public:
JoinExprContext(antlr4::ParserRuleContext *parent, size_t invokingState);
JoinExprContext() = default;
void copyFrom(JoinExprContext *context);
using antlr4::ParserRuleContext::copyFrom;
virtual size_t getRuleIndex() const override;
};
class JoinExprPositionalContext : public JoinExprContext {
public:
JoinExprPositionalContext(JoinExprContext *ctx);
std::vector<JoinExprContext *> joinExpr();
JoinExprContext* joinExpr(size_t i);
antlr4::tree::TerminalNode *POSITIONAL();
antlr4::tree::TerminalNode *JOIN();
JoinConstraintClauseContext *joinConstraintClause();
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
class JoinExprOpContext : public JoinExprContext {
public:
JoinExprOpContext(JoinExprContext *ctx);
std::vector<JoinExprContext *> joinExpr();
JoinExprContext* joinExpr(size_t i);
antlr4::tree::TerminalNode *JOIN();
antlr4::tree::TerminalNode *NATURAL();
JoinOpContext *joinOp();
JoinConstraintClauseContext *joinConstraintClause();
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
class JoinExprTableContext : public JoinExprContext {
public:
JoinExprTableContext(JoinExprContext *ctx);
TableExprContext *tableExpr();
antlr4::tree::TerminalNode *FINAL();
SampleClauseContext *sampleClause();
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
class JoinExprUnpivotContext : public JoinExprContext {
public:
JoinExprUnpivotContext(JoinExprContext *ctx);
JoinExprContext *joinExpr();
antlr4::tree::TerminalNode *UNPIVOT();
antlr4::tree::TerminalNode *LPAREN();
UnpivotColumnListContext *unpivotColumnList();
antlr4::tree::TerminalNode *RPAREN();
antlr4::tree::TerminalNode *INCLUDE();
antlr4::tree::TerminalNode *NULLS();
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
class JoinExprParensContext : public JoinExprContext {
public:
JoinExprParensContext(JoinExprContext *ctx);
antlr4::tree::TerminalNode *LPAREN();
JoinExprContext *joinExpr();
antlr4::tree::TerminalNode *RPAREN();
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
class JoinExprCrossOpContext : public JoinExprContext {
public:
JoinExprCrossOpContext(JoinExprContext *ctx);
std::vector<JoinExprContext *> joinExpr();
JoinExprContext* joinExpr(size_t i);
JoinOpCrossContext *joinOpCross();
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
class JoinExprPivotContext : public JoinExprContext {
public:
JoinExprPivotContext(JoinExprContext *ctx);
JoinExprContext *joinExpr();
antlr4::tree::TerminalNode *PIVOT();
antlr4::tree::TerminalNode *LPAREN();
std::vector<ColumnExprListContext *> columnExprList();
ColumnExprListContext* columnExprList(size_t i);
PivotColumnListContext *pivotColumnList();
antlr4::tree::TerminalNode *RPAREN();
antlr4::tree::TerminalNode *GROUP();
antlr4::tree::TerminalNode *BY();
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
JoinExprContext* joinExpr();
JoinExprContext* joinExpr(int precedence);
class JoinOpContext : public antlr4::ParserRuleContext {
public:
JoinOpContext(antlr4::ParserRuleContext *parent, size_t invokingState);
JoinOpContext() = default;
void copyFrom(JoinOpContext *context);
using antlr4::ParserRuleContext::copyFrom;
virtual size_t getRuleIndex() const override;
};
class JoinOpFullContext : public JoinOpContext {
public:
JoinOpFullContext(JoinOpContext *ctx);
antlr4::tree::TerminalNode *FULL();
antlr4::tree::TerminalNode *OUTER();
antlr4::tree::TerminalNode *ALL();
antlr4::tree::TerminalNode *ANY();
antlr4::tree::TerminalNode *ASOF();
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
class JoinOpInnerContext : public JoinOpContext {
public:
JoinOpInnerContext(JoinOpContext *ctx);
antlr4::tree::TerminalNode *INNER();
antlr4::tree::TerminalNode *ANTI();
antlr4::tree::TerminalNode *SEMI();
antlr4::tree::TerminalNode *ASOF();
antlr4::tree::TerminalNode *ALL();
antlr4::tree::TerminalNode *ANY();
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
class JoinOpLeftRightContext : public JoinOpContext {
public:
JoinOpLeftRightContext(JoinOpContext *ctx);
antlr4::tree::TerminalNode *ASOF();
antlr4::tree::TerminalNode *LEFT();
antlr4::tree::TerminalNode *RIGHT();
antlr4::tree::TerminalNode *ANTI();
antlr4::tree::TerminalNode *SEMI();
antlr4::tree::TerminalNode *OUTER();
antlr4::tree::TerminalNode *ALL();
antlr4::tree::TerminalNode *ANY();
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
JoinOpContext* joinOp();
class JoinOpCrossContext : public antlr4::ParserRuleContext {
public:
JoinOpCrossContext(antlr4::ParserRuleContext *parent, size_t invokingState);
virtual size_t getRuleIndex() const override;
antlr4::tree::TerminalNode *CROSS();
antlr4::tree::TerminalNode *JOIN();
antlr4::tree::TerminalNode *COMMA();
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
JoinOpCrossContext* joinOpCross();
class JoinConstraintClauseContext : public antlr4::ParserRuleContext {
public:
JoinConstraintClauseContext(antlr4::ParserRuleContext *parent, size_t invokingState);
virtual size_t getRuleIndex() const override;
antlr4::tree::TerminalNode *ON();
ColumnExprListContext *columnExprList();
antlr4::tree::TerminalNode *USING();
antlr4::tree::TerminalNode *LPAREN();
antlr4::tree::TerminalNode *RPAREN();
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
JoinConstraintClauseContext* joinConstraintClause();
class SampleClauseContext : public antlr4::ParserRuleContext {
public:
SampleClauseContext(antlr4::ParserRuleContext *parent, size_t invokingState);
virtual size_t getRuleIndex() const override;
antlr4::tree::TerminalNode *SAMPLE();
std::vector<RatioExprContext *> ratioExpr();
RatioExprContext* ratioExpr(size_t i);
antlr4::tree::TerminalNode *PERCENT();
antlr4::tree::TerminalNode *OFFSET();
antlr4::tree::TerminalNode *LPAREN();
IdentifierContext *identifier();
antlr4::tree::TerminalNode *RPAREN();
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
SampleClauseContext* sampleClause();
class LimitExprContext : public antlr4::ParserRuleContext {
public:
LimitExprContext(antlr4::ParserRuleContext *parent, size_t invokingState);
virtual size_t getRuleIndex() const override;
std::vector<ColumnExprContext *> columnExpr();
ColumnExprContext* columnExpr(size_t i);
antlr4::tree::TerminalNode *COMMA();
antlr4::tree::TerminalNode *OFFSET();
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
LimitExprContext* limitExpr();
class OrderExprListContext : public antlr4::ParserRuleContext {
public:
OrderExprListContext(antlr4::ParserRuleContext *parent, size_t invokingState);
virtual size_t getRuleIndex() const override;
std::vector<OrderExprContext *> orderExpr();
OrderExprContext* orderExpr(size_t i);
std::vector<antlr4::tree::TerminalNode *> COMMA();
antlr4::tree::TerminalNode* COMMA(size_t i);
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
OrderExprListContext* orderExprList();
class OrderExprContext : public antlr4::ParserRuleContext {
public:
OrderExprContext(antlr4::ParserRuleContext *parent, size_t invokingState);
virtual size_t getRuleIndex() const override;
ColumnExprContext *columnExpr();
antlr4::tree::TerminalNode *NULLS();
antlr4::tree::TerminalNode *COLLATE();
antlr4::tree::TerminalNode *STRING_LITERAL();
WithFillClauseContext *withFillClause();
antlr4::tree::TerminalNode *ASCENDING();
antlr4::tree::TerminalNode *DESCENDING();
antlr4::tree::TerminalNode *DESC();
antlr4::tree::TerminalNode *FIRST();
antlr4::tree::TerminalNode *LAST();
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
OrderExprContext* orderExpr();
class WithFillClauseContext : public antlr4::ParserRuleContext {
public:
WithFillClauseContext(antlr4::ParserRuleContext *parent, size_t invokingState);
virtual size_t getRuleIndex() const override;
antlr4::tree::TerminalNode *WITH();
antlr4::tree::TerminalNode *FILL();
antlr4::tree::TerminalNode *FROM();
std::vector<ColumnExprContext *> columnExpr();
ColumnExprContext* columnExpr(size_t i);
antlr4::tree::TerminalNode *TO();
antlr4::tree::TerminalNode *STEP();
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
WithFillClauseContext* withFillClause();
class InterpolateExprContext : public antlr4::ParserRuleContext {
public:
InterpolateExprContext(antlr4::ParserRuleContext *parent, size_t invokingState);
virtual size_t getRuleIndex() const override;
std::vector<ColumnExprContext *> columnExpr();
ColumnExprContext* columnExpr(size_t i);
antlr4::tree::TerminalNode *AS();
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
InterpolateExprContext* interpolateExpr();
class RatioExprContext : public antlr4::ParserRuleContext {
public:
RatioExprContext(antlr4::ParserRuleContext *parent, size_t invokingState);
virtual size_t getRuleIndex() const override;
PlaceholderContext *placeholder();
std::vector<NumberLiteralContext *> numberLiteral();
NumberLiteralContext* numberLiteral(size_t i);
antlr4::tree::TerminalNode *SLASH();
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
RatioExprContext* ratioExpr();
class SettingExprListContext : public antlr4::ParserRuleContext {
public:
SettingExprListContext(antlr4::ParserRuleContext *parent, size_t invokingState);
virtual size_t getRuleIndex() const override;
std::vector<SettingExprContext *> settingExpr();
SettingExprContext* settingExpr(size_t i);
std::vector<antlr4::tree::TerminalNode *> COMMA();
antlr4::tree::TerminalNode* COMMA(size_t i);
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
SettingExprListContext* settingExprList();
class SettingExprContext : public antlr4::ParserRuleContext {
public:
SettingExprContext(antlr4::ParserRuleContext *parent, size_t invokingState);
virtual size_t getRuleIndex() const override;
IdentifierContext *identifier();
antlr4::tree::TerminalNode *EQ_SINGLE();
LiteralContext *literal();
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
SettingExprContext* settingExpr();
class WindowExprContext : public antlr4::ParserRuleContext {
public:
WindowExprContext(antlr4::ParserRuleContext *parent, size_t invokingState);
virtual size_t getRuleIndex() const override;
WinPartitionByClauseContext *winPartitionByClause();
WinOrderByClauseContext *winOrderByClause();
WinFrameClauseContext *winFrameClause();
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
WindowExprContext* windowExpr();
class WinPartitionByClauseContext : public antlr4::ParserRuleContext {
public:
WinPartitionByClauseContext(antlr4::ParserRuleContext *parent, size_t invokingState);
virtual size_t getRuleIndex() const override;
antlr4::tree::TerminalNode *PARTITION();
antlr4::tree::TerminalNode *BY();
ColumnExprListContext *columnExprList();
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
WinPartitionByClauseContext* winPartitionByClause();
class WinOrderByClauseContext : public antlr4::ParserRuleContext {
public:
WinOrderByClauseContext(antlr4::ParserRuleContext *parent, size_t invokingState);
virtual size_t getRuleIndex() const override;
antlr4::tree::TerminalNode *ORDER();
antlr4::tree::TerminalNode *BY();
OrderExprListContext *orderExprList();
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
WinOrderByClauseContext* winOrderByClause();
class WithinGroupClauseContext : public antlr4::ParserRuleContext {
public:
WithinGroupClauseContext(antlr4::ParserRuleContext *parent, size_t invokingState);
virtual size_t getRuleIndex() const override;
antlr4::tree::TerminalNode *WITHIN();
antlr4::tree::TerminalNode *GROUP();
antlr4::tree::TerminalNode *LPAREN();
OrderByClauseContext *orderByClause();
antlr4::tree::TerminalNode *RPAREN();
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
WithinGroupClauseContext* withinGroupClause();
class WinFrameClauseContext : public antlr4::ParserRuleContext {
public:
WinFrameClauseContext(antlr4::ParserRuleContext *parent, size_t invokingState);
virtual size_t getRuleIndex() const override;
WinFrameExtendContext *winFrameExtend();
antlr4::tree::TerminalNode *ROWS();
antlr4::tree::TerminalNode *RANGE();
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
WinFrameClauseContext* winFrameClause();
class WinFrameExtendContext : public antlr4::ParserRuleContext {
public:
WinFrameExtendContext(antlr4::ParserRuleContext *parent, size_t invokingState);
WinFrameExtendContext() = default;
void copyFrom(WinFrameExtendContext *context);
using antlr4::ParserRuleContext::copyFrom;
virtual size_t getRuleIndex() const override;
};
class FrameStartContext : public WinFrameExtendContext {
public:
FrameStartContext(WinFrameExtendContext *ctx);
WinFrameBoundContext *winFrameBound();
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
class FrameBetweenContext : public WinFrameExtendContext {
public:
FrameBetweenContext(WinFrameExtendContext *ctx);
antlr4::tree::TerminalNode *BETWEEN();
std::vector<WinFrameBoundContext *> winFrameBound();
WinFrameBoundContext* winFrameBound(size_t i);
antlr4::tree::TerminalNode *AND();
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
WinFrameExtendContext* winFrameExtend();
class WinFrameBoundContext : public antlr4::ParserRuleContext {
public:
WinFrameBoundContext(antlr4::ParserRuleContext *parent, size_t invokingState);
virtual size_t getRuleIndex() const override;
antlr4::tree::TerminalNode *CURRENT();
antlr4::tree::TerminalNode *ROW();
antlr4::tree::TerminalNode *UNBOUNDED();
antlr4::tree::TerminalNode *PRECEDING();
antlr4::tree::TerminalNode *FOLLOWING();
ColumnExprContext *columnExpr();
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
WinFrameBoundContext* winFrameBound();
class ExprContext : public antlr4::ParserRuleContext {
public:
ExprContext(antlr4::ParserRuleContext *parent, size_t invokingState);
virtual size_t getRuleIndex() const override;
ColumnExprContext *columnExpr();
antlr4::tree::TerminalNode *EOF();
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
ExprContext* expr();
class ColumnTypeExprContext : public antlr4::ParserRuleContext {
public:
ColumnTypeExprContext(antlr4::ParserRuleContext *parent, size_t invokingState);
ColumnTypeExprContext() = default;
void copyFrom(ColumnTypeExprContext *context);
using antlr4::ParserRuleContext::copyFrom;
virtual size_t getRuleIndex() const override;
};
class ColumnTypeExprNestedContext : public ColumnTypeExprContext {
public:
ColumnTypeExprNestedContext(ColumnTypeExprContext *ctx);
std::vector<IdentifierContext *> identifier();
IdentifierContext* identifier(size_t i);
antlr4::tree::TerminalNode *LPAREN();
std::vector<ColumnTypeExprContext *> columnTypeExpr();
ColumnTypeExprContext* columnTypeExpr(size_t i);
antlr4::tree::TerminalNode *RPAREN();
std::vector<antlr4::tree::TerminalNode *> COMMA();
antlr4::tree::TerminalNode* COMMA(size_t i);
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
class ColumnTypeExprParamContext : public ColumnTypeExprContext {
public:
ColumnTypeExprParamContext(ColumnTypeExprContext *ctx);
IdentifierContext *identifier();
antlr4::tree::TerminalNode *LPAREN();
antlr4::tree::TerminalNode *RPAREN();
ColumnExprListContext *columnExprList();
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
class ColumnTypeExprArrayContext : public ColumnTypeExprContext {
public:
ColumnTypeExprArrayContext(ColumnTypeExprContext *ctx);
ColumnTypeExprContext *columnTypeExpr();
antlr4::tree::TerminalNode *LBRACKET();
antlr4::tree::TerminalNode *RBRACKET();
antlr4::tree::TerminalNode *DECIMAL_LITERAL();
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
class ColumnTypeExprComplexContext : public ColumnTypeExprContext {
public:
ColumnTypeExprComplexContext(ColumnTypeExprContext *ctx);
IdentifierContext *identifier();
antlr4::tree::TerminalNode *LPAREN();
std::vector<ColumnTypeExprContext *> columnTypeExpr();
ColumnTypeExprContext* columnTypeExpr(size_t i);
antlr4::tree::TerminalNode *RPAREN();
std::vector<antlr4::tree::TerminalNode *> COMMA();
antlr4::tree::TerminalNode* COMMA(size_t i);
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
class ColumnTypeExprSimpleContext : public ColumnTypeExprContext {
public:
ColumnTypeExprSimpleContext(ColumnTypeExprContext *ctx);
IdentifierContext *identifier();
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
class ColumnTypeExprEnumContext : public ColumnTypeExprContext {
public:
ColumnTypeExprEnumContext(ColumnTypeExprContext *ctx);
IdentifierContext *identifier();
antlr4::tree::TerminalNode *LPAREN();
std::vector<EnumValueContext *> enumValue();
EnumValueContext* enumValue(size_t i);
antlr4::tree::TerminalNode *RPAREN();
std::vector<antlr4::tree::TerminalNode *> COMMA();
antlr4::tree::TerminalNode* COMMA(size_t i);
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
class ColumnTypeExprCompoundContext : public ColumnTypeExprContext {
public:
ColumnTypeExprCompoundContext(ColumnTypeExprContext *ctx);
std::vector<IdentifierContext *> identifier();
IdentifierContext* identifier(size_t i);
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
ColumnTypeExprContext* columnTypeExpr();
ColumnTypeExprContext* columnTypeExpr(int precedence);
class ColumnTypeCastExprContext : public antlr4::ParserRuleContext {
public:
ColumnTypeCastExprContext(antlr4::ParserRuleContext *parent, size_t invokingState);
ColumnTypeCastExprContext() = default;
void copyFrom(ColumnTypeCastExprContext *context);
using antlr4::ParserRuleContext::copyFrom;
virtual size_t getRuleIndex() const override;
};
class ColumnTypeCastExprSimpleContext : public ColumnTypeCastExprContext {
public:
ColumnTypeCastExprSimpleContext(ColumnTypeCastExprContext *ctx);
ColumnTypeCastIdentifierContext *columnTypeCastIdentifier();
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
class ColumnTypeCastExprWithTimeZoneContext : public ColumnTypeCastExprContext {
public:
ColumnTypeCastExprWithTimeZoneContext(ColumnTypeCastExprContext *ctx);
ColumnTypeCastIdentifierContext *columnTypeCastIdentifier();
antlr4::tree::TerminalNode *WITH();
antlr4::tree::TerminalNode *TIME();
antlr4::tree::TerminalNode *ZONE();
antlr4::tree::TerminalNode *LOCAL();
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
ColumnTypeCastExprContext* columnTypeCastExpr();
class ColumnTypeCastIdentifierContext : public antlr4::ParserRuleContext {
public:
ColumnTypeCastIdentifierContext(antlr4::ParserRuleContext *parent, size_t invokingState);
virtual size_t getRuleIndex() const override;
antlr4::tree::TerminalNode *IDENTIFIER();
antlr4::tree::TerminalNode *QUOTED_IDENTIFIER();
IntervalContext *interval();
KeywordForTypeCastContext *keywordForTypeCast();
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
ColumnTypeCastIdentifierContext* columnTypeCastIdentifier();
class KeywordForTypeCastContext : public antlr4::ParserRuleContext {
public:
KeywordForTypeCastContext(antlr4::ParserRuleContext *parent, size_t invokingState);
virtual size_t getRuleIndex() const override;
antlr4::tree::TerminalNode *DATE();
antlr4::tree::TerminalNode *TIME();
antlr4::tree::TerminalNode *TIMESTAMP();
antlr4::tree::TerminalNode *INTERVAL();
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
KeywordForTypeCastContext* keywordForTypeCast();
class ColumnExprListContext : public antlr4::ParserRuleContext {
public:
ColumnExprListContext(antlr4::ParserRuleContext *parent, size_t invokingState);
virtual size_t getRuleIndex() const override;
std::vector<ColumnExprContext *> columnExpr();
ColumnExprContext* columnExpr(size_t i);
std::vector<antlr4::tree::TerminalNode *> COMMA();
antlr4::tree::TerminalNode* COMMA(size_t i);
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
ColumnExprListContext* columnExprList();
class SelectColumnExprListBeforeFromContext : public antlr4::ParserRuleContext {
public:
SelectColumnExprListBeforeFromContext(antlr4::ParserRuleContext *parent, size_t invokingState);
SelectColumnExprListBeforeFromContext() = default;
void copyFrom(SelectColumnExprListBeforeFromContext *context);
using antlr4::ParserRuleContext::copyFrom;
virtual size_t getRuleIndex() const override;
};
class SelectColumnExprListBeforeFromTrailingCommaContext : public SelectColumnExprListBeforeFromContext {
public:
SelectColumnExprListBeforeFromTrailingCommaContext(SelectColumnExprListBeforeFromContext *ctx);
std::vector<SelectColumnExprContext *> selectColumnExpr();
SelectColumnExprContext* selectColumnExpr(size_t i);
std::vector<antlr4::tree::TerminalNode *> COMMA();
antlr4::tree::TerminalNode* COMMA(size_t i);
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
class SelectColumnExprListBeforeFromPlainContext : public SelectColumnExprListBeforeFromContext {
public:
SelectColumnExprListBeforeFromPlainContext(SelectColumnExprListBeforeFromContext *ctx);
SelectColumnExprListContext *selectColumnExprList();
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
SelectColumnExprListBeforeFromContext* selectColumnExprListBeforeFrom();
class SelectColumnExprListContext : public antlr4::ParserRuleContext {
public:
SelectColumnExprListContext(antlr4::ParserRuleContext *parent, size_t invokingState);
virtual size_t getRuleIndex() const override;
std::vector<SelectColumnExprContext *> selectColumnExpr();
SelectColumnExprContext* selectColumnExpr(size_t i);
std::vector<antlr4::tree::TerminalNode *> COMMA();
antlr4::tree::TerminalNode* COMMA(size_t i);
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
SelectColumnExprListContext* selectColumnExprList();
class SelectColumnExprContext : public antlr4::ParserRuleContext {
public:
SelectColumnExprContext(antlr4::ParserRuleContext *parent, size_t invokingState);
SelectColumnExprContext() = default;
void copyFrom(SelectColumnExprContext *context);
using antlr4::ParserRuleContext::copyFrom;
virtual size_t getRuleIndex() const override;
};
class ColumnExprAliasBeforeContext : public SelectColumnExprContext {
public:
ColumnExprAliasBeforeContext(SelectColumnExprContext *ctx);
IdentifierContext *identifier();
antlr4::tree::TerminalNode *COLON();
ColumnExprContext *columnExpr();
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
class ColumnExprInvalidFromImplicitAliasContext : public SelectColumnExprContext {
public:
ColumnExprInvalidFromImplicitAliasContext(SelectColumnExprContext *ctx);
antlr4::tree::TerminalNode *FROM();
ImplicitAliasContext *implicitAlias();
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
class ColumnExprAliasImplicitContext : public SelectColumnExprContext {
public:
ColumnExprAliasImplicitContext(SelectColumnExprContext *ctx);
ColumnExprContext *columnExpr();
ImplicitAliasContext *implicitAlias();
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
class ColumnExprSelectValueContext : public SelectColumnExprContext {
public:
ColumnExprSelectValueContext(SelectColumnExprContext *ctx);
ColumnExprContext *columnExpr();
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
SelectColumnExprContext* selectColumnExpr();
class ColumnExprContext : public antlr4::ParserRuleContext {
public:
ColumnExprContext(antlr4::ParserRuleContext *parent, size_t invokingState);
ColumnExprContext() = default;
void copyFrom(ColumnExprContext *context);
using antlr4::ParserRuleContext::copyFrom;
virtual size_t getRuleIndex() const override;
};
class ColumnExprTernaryOpContext : public ColumnExprContext {
public:
ColumnExprTernaryOpContext(ColumnExprContext *ctx);
std::vector<ColumnExprContext *> columnExpr();
ColumnExprContext* columnExpr(size_t i);
antlr4::tree::TerminalNode *QUERY();
antlr4::tree::TerminalNode *COLON();
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
class ColumnExprAliasContext : public ColumnExprContext {
public:
ColumnExprAliasContext(ColumnExprContext *ctx);
ColumnExprContext *columnExpr();
antlr4::tree::TerminalNode *AS();
IdentifierContext *identifier();
antlr4::tree::TerminalNode *STRING_LITERAL();
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
class ColumnExprAndContext : public ColumnExprContext {
public:
ColumnExprAndContext(ColumnExprContext *ctx);
std::vector<ColumnExprContext *> columnExpr();
ColumnExprContext* columnExpr(size_t i);
antlr4::tree::TerminalNode *AND();
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
class ColumnExprValuePassthroughContext : public ColumnExprContext {
public:
ColumnExprValuePassthroughContext(ColumnExprContext *ctx);
ColumnExprValueContext *columnExprValue();
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
class ColumnExprOrContext : public ColumnExprContext {
public:
ColumnExprOrContext(ColumnExprContext *ctx);
std::vector<ColumnExprContext *> columnExpr();
ColumnExprContext* columnExpr(size_t i);
antlr4::tree::TerminalNode *OR();
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
ColumnExprContext* columnExpr();
ColumnExprContext* columnExpr(int precedence);
class ColumnExprValueContext : public antlr4::ParserRuleContext {
public:
ColumnExprValueContext(antlr4::ParserRuleContext *parent, size_t invokingState);
ColumnExprValueContext() = default;
void copyFrom(ColumnExprValueContext *context);
using antlr4::ParserRuleContext::copyFrom;
virtual size_t getRuleIndex() const override;
};
class ColumnExprColumnsAllContext : public ColumnExprValueContext {
public:
ColumnExprColumnsAllContext(ColumnExprValueContext *ctx);
antlr4::tree::TerminalNode *COLUMNS();
antlr4::tree::TerminalNode *LPAREN();
antlr4::tree::TerminalNode *ASTERISK();
antlr4::tree::TerminalNode *RPAREN();
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
class ColumnExprNegateContext : public ColumnExprValueContext {
public:
ColumnExprNegateContext(ColumnExprValueContext *ctx);
antlr4::tree::TerminalNode *DASH();
ColumnExprValueContext *columnExprValue();
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
class ColumnExprLiteralContext : public ColumnExprValueContext {
public:
ColumnExprLiteralContext(ColumnExprValueContext *ctx);
LiteralContext *literal();
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
class ColumnExprArrayContext : public ColumnExprValueContext {
public:
ColumnExprArrayContext(ColumnExprValueContext *ctx);
antlr4::tree::TerminalNode *LBRACKET();
antlr4::tree::TerminalNode *RBRACKET();
antlr4::tree::TerminalNode *ARRAY();
ColumnExprListContext *columnExprList();
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
class ColumnExprPrecedence1Context : public ColumnExprValueContext {
public:
ColumnExprPrecedence1Context(ColumnExprValueContext *ctx);
HogQLParser::ColumnExprValueContext *left = nullptr;
antlr4::Token *operator_ = nullptr;
HogQLParser::ColumnExprValueContext *right = nullptr;
std::vector<ColumnExprValueContext *> columnExprValue();
ColumnExprValueContext* columnExprValue(size_t i);
antlr4::tree::TerminalNode *ASTERISK();
antlr4::tree::TerminalNode *SLASH();
antlr4::tree::TerminalNode *PERCENT();
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
class ColumnExprPrecedence2Context : public ColumnExprValueContext {
public:
ColumnExprPrecedence2Context(ColumnExprValueContext *ctx);
HogQLParser::ColumnExprValueContext *left = nullptr;
antlr4::Token *operator_ = nullptr;
HogQLParser::ColumnExprValueContext *right = nullptr;
std::vector<ColumnExprValueContext *> columnExprValue();
ColumnExprValueContext* columnExprValue(size_t i);
antlr4::tree::TerminalNode *PLUS();
antlr4::tree::TerminalNode *DASH();
antlr4::tree::TerminalNode *CONCAT();
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
class ColumnExprNullSafeEqContext : public ColumnExprValueContext {
public:
ColumnExprNullSafeEqContext(ColumnExprValueContext *ctx);
std::vector<ColumnExprValueContext *> columnExprValue();
ColumnExprValueContext* columnExprValue(size_t i);
antlr4::tree::TerminalNode *NULL_SAFE_EQ();
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
class ColumnExprPrecedence3Context : public ColumnExprValueContext {
public:
ColumnExprPrecedence3Context(ColumnExprValueContext *ctx);
HogQLParser::ColumnExprValueContext *left = nullptr;
antlr4::Token *operator_ = nullptr;
HogQLParser::ColumnExprValueContext *right = nullptr;
std::vector<ColumnExprValueContext *> columnExprValue();
ColumnExprValueContext* columnExprValue(size_t i);
antlr4::tree::TerminalNode *IN();
antlr4::tree::TerminalNode *EQ_DOUBLE();
antlr4::tree::TerminalNode *EQ_SINGLE();
antlr4::tree::TerminalNode *NOT_EQ();
antlr4::tree::TerminalNode *LT_EQ();
antlr4::tree::TerminalNode *LT();
antlr4::tree::TerminalNode *GT_EQ();
antlr4::tree::TerminalNode *GT();
antlr4::tree::TerminalNode *LIKE();
antlr4::tree::TerminalNode *ILIKE();
antlr4::tree::TerminalNode *REGEX_SINGLE();
antlr4::tree::TerminalNode *REGEX_DOUBLE();
antlr4::tree::TerminalNode *NOT_REGEX();
antlr4::tree::TerminalNode *IREGEX_SINGLE();
antlr4::tree::TerminalNode *IREGEX_DOUBLE();
antlr4::tree::TerminalNode *NOT_IREGEX();
antlr4::tree::TerminalNode *COHORT();
antlr4::tree::TerminalNode *NOT();
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
class ColumnExprIntervalContext : public ColumnExprValueContext {
public:
ColumnExprIntervalContext(ColumnExprValueContext *ctx);
antlr4::tree::TerminalNode *INTERVAL();
ColumnExprContext *columnExpr();
IntervalContext *interval();
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
class ColumnExprIsNullContext : public ColumnExprValueContext {
public:
ColumnExprIsNullContext(ColumnExprValueContext *ctx);
ColumnExprValueContext *columnExprValue();
antlr4::tree::TerminalNode *IS();
antlr4::tree::TerminalNode *NULL_SQL();
antlr4::tree::TerminalNode *NOT();
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
class ColumnExprWinFunctionTargetContext : public ColumnExprValueContext {
public:
ColumnExprWinFunctionTargetContext(ColumnExprValueContext *ctx);
HogQLParser::ColumnExprListContext *columnExprs = nullptr;
HogQLParser::ColumnExprListContext *columnArgList = nullptr;
HogQLParser::ColumnExprContext *filterExpr = nullptr;
std::vector<IdentifierContext *> identifier();
IdentifierContext* identifier(size_t i);
antlr4::tree::TerminalNode *OVER();
std::vector<antlr4::tree::TerminalNode *> LPAREN();
antlr4::tree::TerminalNode* LPAREN(size_t i);
std::vector<antlr4::tree::TerminalNode *> RPAREN();
antlr4::tree::TerminalNode* RPAREN(size_t i);
antlr4::tree::TerminalNode *FILTER();
antlr4::tree::TerminalNode *WHERE();
ColumnExprContext *columnExpr();
std::vector<ColumnExprListContext *> columnExprList();
ColumnExprListContext* columnExprList(size_t i);
antlr4::tree::TerminalNode *DISTINCT();
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
class ColumnExprNamedArgContext : public ColumnExprValueContext {
public:
ColumnExprNamedArgContext(ColumnExprValueContext *ctx);
IdentifierContext *identifier();
antlr4::tree::TerminalNode *COLONEQUALS();
ColumnExprContext *columnExpr();
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
class ColumnExprNullPropertyAccessContext : public ColumnExprValueContext {
public:
ColumnExprNullPropertyAccessContext(ColumnExprValueContext *ctx);
ColumnExprValueContext *columnExprValue();
antlr4::tree::TerminalNode *NULL_PROPERTY();
IdentifierContext *identifier();
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
class ColumnExprIntervalStringContext : public ColumnExprValueContext {
public:
ColumnExprIntervalStringContext(ColumnExprValueContext *ctx);
antlr4::tree::TerminalNode *INTERVAL();
antlr4::tree::TerminalNode *STRING_LITERAL();
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
class ColumnExprTagElementContext : public ColumnExprValueContext {
public:
ColumnExprTagElementContext(ColumnExprValueContext *ctx);
HogqlxTagElementContext *hogqlxTagElement();
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
class ColumnExprCallContext : public ColumnExprValueContext {
public:
ColumnExprCallContext(ColumnExprValueContext *ctx);
ColumnExprValueContext *columnExprValue();
antlr4::tree::TerminalNode *LPAREN();
antlr4::tree::TerminalNode *RPAREN();
ColumnExprListContext *columnExprList();
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
class ColumnExprArrayAccessContext : public ColumnExprValueContext {
public:
ColumnExprArrayAccessContext(ColumnExprValueContext *ctx);
ColumnExprValueContext *columnExprValue();
antlr4::tree::TerminalNode *LBRACKET();
ColumnExprContext *columnExpr();
antlr4::tree::TerminalNode *RBRACKET();
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
class ColumnExprBetweenContext : public ColumnExprValueContext {
public:
ColumnExprBetweenContext(ColumnExprValueContext *ctx);
std::vector<ColumnExprValueContext *> columnExprValue();
ColumnExprValueContext* columnExprValue(size_t i);
antlr4::tree::TerminalNode *BETWEEN();
antlr4::tree::TerminalNode *AND();
antlr4::tree::TerminalNode *NOT();
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
class ColumnExprParensContext : public ColumnExprValueContext {
public:
ColumnExprParensContext(ColumnExprValueContext *ctx);
antlr4::tree::TerminalNode *LPAREN();
ColumnExprContext *columnExpr();
antlr4::tree::TerminalNode *RPAREN();
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
class ColumnExprTimestampContext : public ColumnExprValueContext {
public:
ColumnExprTimestampContext(ColumnExprValueContext *ctx);
antlr4::tree::TerminalNode *TIMESTAMP();
antlr4::tree::TerminalNode *STRING_LITERAL();
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
class ColumnExprColumnsQualifiedExcludeContext : public ColumnExprValueContext {
public:
ColumnExprColumnsQualifiedExcludeContext(ColumnExprValueContext *ctx);
antlr4::tree::TerminalNode *COLUMNS();
std::vector<antlr4::tree::TerminalNode *> LPAREN();
antlr4::tree::TerminalNode* LPAREN(size_t i);
IdentifierContext *identifier();
antlr4::tree::TerminalNode *DOT();
antlr4::tree::TerminalNode *ASTERISK();
antlr4::tree::TerminalNode *EXCLUDE();
IdentifierListContext *identifierList();
std::vector<antlr4::tree::TerminalNode *> RPAREN();
antlr4::tree::TerminalNode* RPAREN(size_t i);
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
class ColumnExprNotContext : public ColumnExprValueContext {
public:
ColumnExprNotContext(ColumnExprValueContext *ctx);
antlr4::tree::TerminalNode *NOT();
ColumnExprValueContext *columnExprValue();
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
class ColumnExprFunctionContext : public ColumnExprValueContext {
public:
ColumnExprFunctionContext(ColumnExprValueContext *ctx);
HogQLParser::ColumnExprListContext *columnExprs = nullptr;
HogQLParser::ColumnExprListContext *columnArgList = nullptr;
HogQLParser::ColumnExprContext *filterExpr = nullptr;
IdentifierContext *identifier();
std::vector<antlr4::tree::TerminalNode *> LPAREN();
antlr4::tree::TerminalNode* LPAREN(size_t i);
std::vector<antlr4::tree::TerminalNode *> RPAREN();
antlr4::tree::TerminalNode* RPAREN(size_t i);
antlr4::tree::TerminalNode *DISTINCT();
antlr4::tree::TerminalNode *ORDER();
antlr4::tree::TerminalNode *BY();
OrderExprListContext *orderExprList();
antlr4::tree::TerminalNode *FILTER();
antlr4::tree::TerminalNode *WHERE();
std::vector<ColumnExprListContext *> columnExprList();
ColumnExprListContext* columnExprList(size_t i);
ColumnExprContext *columnExpr();
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
class ColumnExprDictContext : public ColumnExprValueContext {
public:
ColumnExprDictContext(ColumnExprValueContext *ctx);
antlr4::tree::TerminalNode *LBRACE();
antlr4::tree::TerminalNode *RBRACE();
KvPairListContext *kvPairList();
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
class ColumnExprSubqueryContext : public ColumnExprValueContext {
public:
ColumnExprSubqueryContext(ColumnExprValueContext *ctx);
antlr4::tree::TerminalNode *LPAREN();
SelectSetStmtContext *selectSetStmt();
antlr4::tree::TerminalNode *RPAREN();
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
class ColumnExprSubstringContext : public ColumnExprValueContext {
public:
ColumnExprSubstringContext(ColumnExprValueContext *ctx);
antlr4::tree::TerminalNode *SUBSTRING();
antlr4::tree::TerminalNode *LPAREN();
std::vector<ColumnExprContext *> columnExpr();
ColumnExprContext* columnExpr(size_t i);
antlr4::tree::TerminalNode *FROM();
antlr4::tree::TerminalNode *RPAREN();
antlr4::tree::TerminalNode *FOR();
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
class ColumnExprCastContext : public ColumnExprValueContext {
public:
ColumnExprCastContext(ColumnExprValueContext *ctx);
antlr4::tree::TerminalNode *CAST();
antlr4::tree::TerminalNode *LPAREN();
ColumnExprContext *columnExpr();
antlr4::tree::TerminalNode *AS();
ColumnTypeExprContext *columnTypeExpr();
antlr4::tree::TerminalNode *RPAREN();
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
class ColumnExprArraySliceContext : public ColumnExprValueContext {
public:
ColumnExprArraySliceContext(ColumnExprValueContext *ctx);
ColumnExprValueContext *columnExprValue();
antlr4::tree::TerminalNode *LBRACKET();
antlr4::tree::TerminalNode *COLON();
antlr4::tree::TerminalNode *RBRACKET();
std::vector<ColumnExprContext *> columnExpr();
ColumnExprContext* columnExpr(size_t i);
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
class ColumnExprColumnsQualifiedReplaceContext : public ColumnExprValueContext {
public:
ColumnExprColumnsQualifiedReplaceContext(ColumnExprValueContext *ctx);
antlr4::tree::TerminalNode *COLUMNS();
std::vector<antlr4::tree::TerminalNode *> LPAREN();
antlr4::tree::TerminalNode* LPAREN(size_t i);
IdentifierContext *identifier();
antlr4::tree::TerminalNode *DOT();
antlr4::tree::TerminalNode *ASTERISK();
antlr4::tree::TerminalNode *REPLACE();
ColumnsReplaceListContext *columnsReplaceList();
std::vector<antlr4::tree::TerminalNode *> RPAREN();
antlr4::tree::TerminalNode* RPAREN(size_t i);
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
class ColumnExprNullTupleAccessContext : public ColumnExprValueContext {
public:
ColumnExprNullTupleAccessContext(ColumnExprValueContext *ctx);
ColumnExprValueContext *columnExprValue();
antlr4::tree::TerminalNode *NULL_PROPERTY();
antlr4::tree::TerminalNode *DECIMAL_LITERAL();
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
class ColumnExprFunctionWithinGroupContext : public ColumnExprValueContext {
public:
ColumnExprFunctionWithinGroupContext(ColumnExprValueContext *ctx);
HogQLParser::ColumnExprListContext *columnExprs = nullptr;
IdentifierContext *identifier();
antlr4::tree::TerminalNode *LPAREN();
antlr4::tree::TerminalNode *RPAREN();
WithinGroupClauseContext *withinGroupClause();
ColumnExprListContext *columnExprList();
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
class ColumnExprPositionalContext : public ColumnExprValueContext {
public:
ColumnExprPositionalContext(ColumnExprValueContext *ctx);
antlr4::tree::TerminalNode *HASH();
antlr4::tree::TerminalNode *DECIMAL_LITERAL();
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
class ColumnExprColumnsRegexContext : public ColumnExprValueContext {
public:
ColumnExprColumnsRegexContext(ColumnExprValueContext *ctx);
antlr4::tree::TerminalNode *COLUMNS();
antlr4::tree::TerminalNode *LPAREN();
antlr4::tree::TerminalNode *STRING_LITERAL();
antlr4::tree::TerminalNode *RPAREN();
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
class ColumnExprTypeCastContext : public ColumnExprValueContext {
public:
ColumnExprTypeCastContext(ColumnExprValueContext *ctx);
ColumnExprValueContext *columnExprValue();
antlr4::tree::TerminalNode *DOUBLECOLON();
ColumnTypeCastExprContext *columnTypeCastExpr();
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
class ColumnExprIsDistinctFromContext : public ColumnExprValueContext {
public:
ColumnExprIsDistinctFromContext(ColumnExprValueContext *ctx);
std::vector<ColumnExprValueContext *> columnExprValue();
ColumnExprValueContext* columnExprValue(size_t i);
antlr4::tree::TerminalNode *IS();
antlr4::tree::TerminalNode *DISTINCT();
antlr4::tree::TerminalNode *FROM();
antlr4::tree::TerminalNode *NOT();
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
class ColumnExprSpreadColumnsListContext : public ColumnExprValueContext {
public:
ColumnExprSpreadColumnsListContext(ColumnExprValueContext *ctx);
antlr4::tree::TerminalNode *ASTERISK();
antlr4::tree::TerminalNode *COLUMNS();
antlr4::tree::TerminalNode *LPAREN();
ColumnExprListContext *columnExprList();
antlr4::tree::TerminalNode *RPAREN();
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
class ColumnExprColumnsExcludeReplaceContext : public ColumnExprValueContext {
public:
ColumnExprColumnsExcludeReplaceContext(ColumnExprValueContext *ctx);
antlr4::tree::TerminalNode *COLUMNS();
std::vector<antlr4::tree::TerminalNode *> LPAREN();
antlr4::tree::TerminalNode* LPAREN(size_t i);
antlr4::tree::TerminalNode *ASTERISK();
antlr4::tree::TerminalNode *EXCLUDE();
IdentifierListContext *identifierList();
std::vector<antlr4::tree::TerminalNode *> RPAREN();
antlr4::tree::TerminalNode* RPAREN(size_t i);
antlr4::tree::TerminalNode *REPLACE();
ColumnsReplaceListContext *columnsReplaceList();
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
class ColumnExprColumnsQualifiedExcludeReplaceContext : public ColumnExprValueContext {
public:
ColumnExprColumnsQualifiedExcludeReplaceContext(ColumnExprValueContext *ctx);
antlr4::tree::TerminalNode *COLUMNS();
std::vector<antlr4::tree::TerminalNode *> LPAREN();
antlr4::tree::TerminalNode* LPAREN(size_t i);
IdentifierContext *identifier();
antlr4::tree::TerminalNode *DOT();
antlr4::tree::TerminalNode *ASTERISK();
antlr4::tree::TerminalNode *EXCLUDE();
IdentifierListContext *identifierList();
std::vector<antlr4::tree::TerminalNode *> RPAREN();
antlr4::tree::TerminalNode* RPAREN(size_t i);
antlr4::tree::TerminalNode *REPLACE();
ColumnsReplaceListContext *columnsReplaceList();
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
class ColumnExprColumnsExcludeContext : public ColumnExprValueContext {
public:
ColumnExprColumnsExcludeContext(ColumnExprValueContext *ctx);
antlr4::tree::TerminalNode *COLUMNS();
std::vector<antlr4::tree::TerminalNode *> LPAREN();
antlr4::tree::TerminalNode* LPAREN(size_t i);
antlr4::tree::TerminalNode *ASTERISK();
antlr4::tree::TerminalNode *EXCLUDE();
IdentifierListContext *identifierList();
std::vector<antlr4::tree::TerminalNode *> RPAREN();
antlr4::tree::TerminalNode* RPAREN(size_t i);
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
class ColumnExprColonLambdaContext : public ColumnExprValueContext {
public:
ColumnExprColonLambdaContext(ColumnExprValueContext *ctx);
antlr4::tree::TerminalNode *LAMBDA();
std::vector<IdentifierContext *> identifier();
IdentifierContext* identifier(size_t i);
antlr4::tree::TerminalNode *COLON();
ColumnExprContext *columnExpr();
std::vector<antlr4::tree::TerminalNode *> COMMA();
antlr4::tree::TerminalNode* COMMA(size_t i);
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
class ColumnExprCallSelectContext : public ColumnExprValueContext {
public:
ColumnExprCallSelectContext(ColumnExprValueContext *ctx);
ColumnExprValueContext *columnExprValue();
antlr4::tree::TerminalNode *LPAREN();
SelectSetStmtContext *selectSetStmt();
antlr4::tree::TerminalNode *RPAREN();
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
class ColumnExprColumnsQualifiedAllContext : public ColumnExprValueContext {
public:
ColumnExprColumnsQualifiedAllContext(ColumnExprValueContext *ctx);
antlr4::tree::TerminalNode *COLUMNS();
antlr4::tree::TerminalNode *LPAREN();
IdentifierContext *identifier();
antlr4::tree::TerminalNode *DOT();
antlr4::tree::TerminalNode *ASTERISK();
antlr4::tree::TerminalNode *RPAREN();
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
class ColumnExprTrimContext : public ColumnExprValueContext {
public:
ColumnExprTrimContext(ColumnExprValueContext *ctx);
antlr4::tree::TerminalNode *TRIM();
antlr4::tree::TerminalNode *LPAREN();
StringContext *string();
antlr4::tree::TerminalNode *FROM();
ColumnExprContext *columnExpr();
antlr4::tree::TerminalNode *RPAREN();
antlr4::tree::TerminalNode *BOTH();
antlr4::tree::TerminalNode *LEADING();
antlr4::tree::TerminalNode *TRAILING();
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
class ColumnExprTemplateStringContext : public ColumnExprValueContext {
public:
ColumnExprTemplateStringContext(ColumnExprValueContext *ctx);
TemplateStringContext *templateString();
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
class ColumnExprTupleContext : public ColumnExprValueContext {
public:
ColumnExprTupleContext(ColumnExprValueContext *ctx);
antlr4::tree::TerminalNode *LPAREN();
ColumnExprListContext *columnExprList();
antlr4::tree::TerminalNode *RPAREN();
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
class ColumnExprTryCastContext : public ColumnExprValueContext {
public:
ColumnExprTryCastContext(ColumnExprValueContext *ctx);
antlr4::tree::TerminalNode *TRY_CAST();
antlr4::tree::TerminalNode *LPAREN();
ColumnExprContext *columnExpr();
antlr4::tree::TerminalNode *AS();
ColumnTypeExprContext *columnTypeExpr();
antlr4::tree::TerminalNode *RPAREN();
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
class ColumnExprColumnsListContext : public ColumnExprValueContext {
public:
ColumnExprColumnsListContext(ColumnExprValueContext *ctx);
antlr4::tree::TerminalNode *COLUMNS();
antlr4::tree::TerminalNode *LPAREN();
ColumnExprListContext *columnExprList();
antlr4::tree::TerminalNode *RPAREN();
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
class ColumnExprColumnsReplaceContext : public ColumnExprValueContext {
public:
ColumnExprColumnsReplaceContext(ColumnExprValueContext *ctx);
antlr4::tree::TerminalNode *COLUMNS();
std::vector<antlr4::tree::TerminalNode *> LPAREN();
antlr4::tree::TerminalNode* LPAREN(size_t i);
antlr4::tree::TerminalNode *ASTERISK();
antlr4::tree::TerminalNode *REPLACE();
ColumnsReplaceListContext *columnsReplaceList();
std::vector<antlr4::tree::TerminalNode *> RPAREN();
antlr4::tree::TerminalNode* RPAREN(size_t i);
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
class ColumnExprSpreadColumnsRegexContext : public ColumnExprValueContext {
public:
ColumnExprSpreadColumnsRegexContext(ColumnExprValueContext *ctx);
antlr4::tree::TerminalNode *ASTERISK();
antlr4::tree::TerminalNode *COLUMNS();
antlr4::tree::TerminalNode *LPAREN();
antlr4::tree::TerminalNode *STRING_LITERAL();
antlr4::tree::TerminalNode *RPAREN();
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
class ColumnExprPropertyAccessContext : public ColumnExprValueContext {
public:
ColumnExprPropertyAccessContext(ColumnExprValueContext *ctx);
ColumnExprValueContext *columnExprValue();
antlr4::tree::TerminalNode *DOT();
IdentifierContext *identifier();
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
class ColumnExprNullArrayAccessContext : public ColumnExprValueContext {
public:
ColumnExprNullArrayAccessContext(ColumnExprValueContext *ctx);
ColumnExprValueContext *columnExprValue();
antlr4::tree::TerminalNode *NULL_PROPERTY();
antlr4::tree::TerminalNode *LBRACKET();
ColumnExprContext *columnExpr();
antlr4::tree::TerminalNode *RBRACKET();
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
class ColumnExprIgnoreNullsContext : public ColumnExprValueContext {
public:
ColumnExprIgnoreNullsContext(ColumnExprValueContext *ctx);
ColumnExprValueContext *columnExprValue();
antlr4::tree::TerminalNode *IGNORE();
antlr4::tree::TerminalNode *NULLS();
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
class ColumnExprNullishContext : public ColumnExprValueContext {
public:
ColumnExprNullishContext(ColumnExprValueContext *ctx);
std::vector<ColumnExprValueContext *> columnExprValue();
ColumnExprValueContext* columnExprValue(size_t i);
antlr4::tree::TerminalNode *NULLISH();
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
class ColumnExprTupleAccessContext : public ColumnExprValueContext {
public:
ColumnExprTupleAccessContext(ColumnExprValueContext *ctx);
ColumnExprValueContext *columnExprValue();
antlr4::tree::TerminalNode *DOT();
antlr4::tree::TerminalNode *DECIMAL_LITERAL();
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
class ColumnExprCaseContext : public ColumnExprValueContext {
public:
ColumnExprCaseContext(ColumnExprValueContext *ctx);
HogQLParser::ColumnExprContext *caseExpr = nullptr;
HogQLParser::ColumnExprContext *whenExpr = nullptr;
HogQLParser::ColumnExprContext *thenExpr = nullptr;
HogQLParser::ColumnExprContext *elseExpr = nullptr;
antlr4::tree::TerminalNode *CASE();
antlr4::tree::TerminalNode *END();
std::vector<antlr4::tree::TerminalNode *> WHEN();
antlr4::tree::TerminalNode* WHEN(size_t i);
std::vector<antlr4::tree::TerminalNode *> THEN();
antlr4::tree::TerminalNode* THEN(size_t i);
antlr4::tree::TerminalNode *ELSE();
std::vector<ColumnExprContext *> columnExpr();
ColumnExprContext* columnExpr(size_t i);
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
class ColumnExprDateContext : public ColumnExprValueContext {
public:
ColumnExprDateContext(ColumnExprValueContext *ctx);
antlr4::tree::TerminalNode *DATE();
antlr4::tree::TerminalNode *STRING_LITERAL();
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
class ColumnExprWinFunctionContext : public ColumnExprValueContext {
public:
ColumnExprWinFunctionContext(ColumnExprValueContext *ctx);
HogQLParser::ColumnExprListContext *columnExprs = nullptr;
HogQLParser::ColumnExprListContext *columnArgList = nullptr;
HogQLParser::ColumnExprContext *filterExpr = nullptr;
IdentifierContext *identifier();
antlr4::tree::TerminalNode *OVER();
std::vector<antlr4::tree::TerminalNode *> LPAREN();
antlr4::tree::TerminalNode* LPAREN(size_t i);
WindowExprContext *windowExpr();
std::vector<antlr4::tree::TerminalNode *> RPAREN();
antlr4::tree::TerminalNode* RPAREN(size_t i);
antlr4::tree::TerminalNode *FILTER();
antlr4::tree::TerminalNode *WHERE();
ColumnExprContext *columnExpr();
std::vector<ColumnExprListContext *> columnExprList();
ColumnExprListContext* columnExprList(size_t i);
antlr4::tree::TerminalNode *DISTINCT();
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
class ColumnExprLambdaContext : public ColumnExprValueContext {
public:
ColumnExprLambdaContext(ColumnExprValueContext *ctx);
ColumnLambdaExprContext *columnLambdaExpr();
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
class ColumnExprIdentifierContext : public ColumnExprValueContext {
public:
ColumnExprIdentifierContext(ColumnExprValueContext *ctx);
ColumnIdentifierContext *columnIdentifier();
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
class ColumnExprAsteriskContext : public ColumnExprValueContext {
public:
ColumnExprAsteriskContext(ColumnExprValueContext *ctx);
antlr4::tree::TerminalNode *ASTERISK();
TableIdentifierContext *tableIdentifier();
antlr4::tree::TerminalNode *DOT();
antlr4::tree::TerminalNode *EXCLUDE();
antlr4::tree::TerminalNode *LPAREN();
IdentifierListContext *identifierList();
antlr4::tree::TerminalNode *RPAREN();
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
ColumnExprValueContext* columnExprValue();
ColumnExprValueContext* columnExprValue(int precedence);
class ColumnLambdaExprContext : public antlr4::ParserRuleContext {
public:
ColumnLambdaExprContext(antlr4::ParserRuleContext *parent, size_t invokingState);
ColumnLambdaExprContext() = default;
void copyFrom(ColumnLambdaExprContext *context);
using antlr4::ParserRuleContext::copyFrom;
virtual size_t getRuleIndex() const override;
};
class ArrowLambdaContext : public ColumnLambdaExprContext {
public:
ArrowLambdaContext(ColumnLambdaExprContext *ctx);
antlr4::tree::TerminalNode *ARROW();
antlr4::tree::TerminalNode *LPAREN();
std::vector<IdentifierContext *> identifier();
IdentifierContext* identifier(size_t i);
antlr4::tree::TerminalNode *RPAREN();
ColumnExprContext *columnExpr();
BlockContext *block();
std::vector<antlr4::tree::TerminalNode *> COMMA();
antlr4::tree::TerminalNode* COMMA(size_t i);
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
class ColonLambdaContext : public ColumnLambdaExprContext {
public:
ColonLambdaContext(ColumnLambdaExprContext *ctx);
antlr4::tree::TerminalNode *LAMBDA();
std::vector<IdentifierContext *> identifier();
IdentifierContext* identifier(size_t i);
antlr4::tree::TerminalNode *COLON();
ColumnExprContext *columnExpr();
std::vector<antlr4::tree::TerminalNode *> COMMA();
antlr4::tree::TerminalNode* COMMA(size_t i);
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
ColumnLambdaExprContext* columnLambdaExpr();
class ColumnsReplaceListContext : public antlr4::ParserRuleContext {
public:
ColumnsReplaceListContext(antlr4::ParserRuleContext *parent, size_t invokingState);
virtual size_t getRuleIndex() const override;
std::vector<ColumnsReplaceItemContext *> columnsReplaceItem();
ColumnsReplaceItemContext* columnsReplaceItem(size_t i);
std::vector<antlr4::tree::TerminalNode *> COMMA();
antlr4::tree::TerminalNode* COMMA(size_t i);
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
ColumnsReplaceListContext* columnsReplaceList();
class ColumnsReplaceItemContext : public antlr4::ParserRuleContext {
public:
ColumnsReplaceItemContext(antlr4::ParserRuleContext *parent, size_t invokingState);
virtual size_t getRuleIndex() const override;
ColumnExprContext *columnExpr();
antlr4::tree::TerminalNode *AS();
IdentifierContext *identifier();
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
ColumnsReplaceItemContext* columnsReplaceItem();
class HogqlxChildElementContext : public antlr4::ParserRuleContext {
public:
HogqlxChildElementContext(antlr4::ParserRuleContext *parent, size_t invokingState);
virtual size_t getRuleIndex() const override;
HogqlxTagElementContext *hogqlxTagElement();
HogqlxTextContext *hogqlxText();
antlr4::tree::TerminalNode *LBRACE();
ColumnExprContext *columnExpr();
antlr4::tree::TerminalNode *RBRACE();
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
HogqlxChildElementContext* hogqlxChildElement();
class HogqlxTextContext : public antlr4::ParserRuleContext {
public:
HogqlxTextContext(antlr4::ParserRuleContext *parent, size_t invokingState);
virtual size_t getRuleIndex() const override;
antlr4::tree::TerminalNode *HOGQLX_TEXT_TEXT();
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
HogqlxTextContext* hogqlxText();
class HogqlxTagElementContext : public antlr4::ParserRuleContext {
public:
HogqlxTagElementContext(antlr4::ParserRuleContext *parent, size_t invokingState);
HogqlxTagElementContext() = default;
void copyFrom(HogqlxTagElementContext *context);
using antlr4::ParserRuleContext::copyFrom;
virtual size_t getRuleIndex() const override;
};
class HogqlxTagElementClosedContext : public HogqlxTagElementContext {
public:
HogqlxTagElementClosedContext(HogqlxTagElementContext *ctx);
antlr4::tree::TerminalNode *LT();
IdentifierContext *identifier();
antlr4::tree::TerminalNode *SLASH_GT();
std::vector<HogqlxTagAttributeContext *> hogqlxTagAttribute();
HogqlxTagAttributeContext* hogqlxTagAttribute(size_t i);
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
class HogqlxTagElementNestedContext : public HogqlxTagElementContext {
public:
HogqlxTagElementNestedContext(HogqlxTagElementContext *ctx);
antlr4::tree::TerminalNode *LT();
std::vector<IdentifierContext *> identifier();
IdentifierContext* identifier(size_t i);
std::vector<antlr4::tree::TerminalNode *> GT();
antlr4::tree::TerminalNode* GT(size_t i);
antlr4::tree::TerminalNode *LT_SLASH();
std::vector<HogqlxTagAttributeContext *> hogqlxTagAttribute();
HogqlxTagAttributeContext* hogqlxTagAttribute(size_t i);
std::vector<HogqlxChildElementContext *> hogqlxChildElement();
HogqlxChildElementContext* hogqlxChildElement(size_t i);
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
HogqlxTagElementContext* hogqlxTagElement();
class HogqlxTagAttributeContext : public antlr4::ParserRuleContext {
public:
HogqlxTagAttributeContext(antlr4::ParserRuleContext *parent, size_t invokingState);
virtual size_t getRuleIndex() const override;
IdentifierContext *identifier();
antlr4::tree::TerminalNode *EQ_SINGLE();
StringContext *string();
antlr4::tree::TerminalNode *LBRACE();
ColumnExprContext *columnExpr();
antlr4::tree::TerminalNode *RBRACE();
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
HogqlxTagAttributeContext* hogqlxTagAttribute();
class WithExprListContext : public antlr4::ParserRuleContext {
public:
WithExprListContext(antlr4::ParserRuleContext *parent, size_t invokingState);
virtual size_t getRuleIndex() const override;
std::vector<WithExprContext *> withExpr();
WithExprContext* withExpr(size_t i);
std::vector<antlr4::tree::TerminalNode *> COMMA();
antlr4::tree::TerminalNode* COMMA(size_t i);
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
WithExprListContext* withExprList();
class WithExprContext : public antlr4::ParserRuleContext {
public:
WithExprContext(antlr4::ParserRuleContext *parent, size_t invokingState);
WithExprContext() = default;
void copyFrom(WithExprContext *context);
using antlr4::ParserRuleContext::copyFrom;
virtual size_t getRuleIndex() const override;
};
class WithExprColumnContext : public WithExprContext {
public:
WithExprColumnContext(WithExprContext *ctx);
ColumnExprContext *columnExpr();
antlr4::tree::TerminalNode *AS();
IdentifierContext *identifier();
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
class WithExprSubqueryContext : public WithExprContext {
public:
WithExprSubqueryContext(WithExprContext *ctx);
IdentifierContext *identifier();
antlr4::tree::TerminalNode *AS();
antlr4::tree::TerminalNode *LPAREN();
SelectSetStmtContext *selectSetStmt();
antlr4::tree::TerminalNode *RPAREN();
std::vector<WithExprColumnNameListContext *> withExprColumnNameList();
WithExprColumnNameListContext* withExprColumnNameList(size_t i);
antlr4::tree::TerminalNode *USING();
antlr4::tree::TerminalNode *KEY();
antlr4::tree::TerminalNode *MATERIALIZED();
antlr4::tree::TerminalNode *NOT();
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
WithExprContext* withExpr();
class WithExprColumnNameListContext : public antlr4::ParserRuleContext {
public:
WithExprColumnNameListContext(antlr4::ParserRuleContext *parent, size_t invokingState);
virtual size_t getRuleIndex() const override;
antlr4::tree::TerminalNode *LPAREN();
std::vector<IdentifierContext *> identifier();
IdentifierContext* identifier(size_t i);
antlr4::tree::TerminalNode *RPAREN();
std::vector<antlr4::tree::TerminalNode *> COMMA();
antlr4::tree::TerminalNode* COMMA(size_t i);
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
WithExprColumnNameListContext* withExprColumnNameList();
class ColumnIdentifierContext : public antlr4::ParserRuleContext {
public:
ColumnIdentifierContext(antlr4::ParserRuleContext *parent, size_t invokingState);
virtual size_t getRuleIndex() const override;
PlaceholderContext *placeholder();
NestedIdentifierContext *nestedIdentifier();
TableIdentifierContext *tableIdentifier();
antlr4::tree::TerminalNode *DOT();
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
ColumnIdentifierContext* columnIdentifier();
class NestedIdentifierContext : public antlr4::ParserRuleContext {
public:
NestedIdentifierContext(antlr4::ParserRuleContext *parent, size_t invokingState);
virtual size_t getRuleIndex() const override;
std::vector<IdentifierContext *> identifier();
IdentifierContext* identifier(size_t i);
std::vector<antlr4::tree::TerminalNode *> DOT();
antlr4::tree::TerminalNode* DOT(size_t i);
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
NestedIdentifierContext* nestedIdentifier();
class TableExprContext : public antlr4::ParserRuleContext {
public:
TableExprContext(antlr4::ParserRuleContext *parent, size_t invokingState);
TableExprContext() = default;
void copyFrom(TableExprContext *context);
using antlr4::ParserRuleContext::copyFrom;
virtual size_t getRuleIndex() const override;
};
class TableExprTagContext : public TableExprContext {
public:
TableExprTagContext(TableExprContext *ctx);
HogqlxTagElementContext *hogqlxTagElement();
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
class TableExprIdentifierContext : public TableExprContext {
public:
TableExprIdentifierContext(TableExprContext *ctx);
TableIdentifierContext *tableIdentifier();
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
class TableExprPlaceholderContext : public TableExprContext {
public:
TableExprPlaceholderContext(TableExprContext *ctx);
PlaceholderContext *placeholder();
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
class TableExprSubqueryContext : public TableExprContext {
public:
TableExprSubqueryContext(TableExprContext *ctx);
antlr4::tree::TerminalNode *LPAREN();
SelectSetStmtContext *selectSetStmt();
antlr4::tree::TerminalNode *RPAREN();
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
class TableExprPivotContext : public TableExprContext {
public:
TableExprPivotContext(TableExprContext *ctx);
TableExprContext *tableExpr();
antlr4::tree::TerminalNode *PIVOT();
antlr4::tree::TerminalNode *LPAREN();
std::vector<ColumnExprListContext *> columnExprList();
ColumnExprListContext* columnExprList(size_t i);
PivotColumnListContext *pivotColumnList();
antlr4::tree::TerminalNode *RPAREN();
antlr4::tree::TerminalNode *GROUP();
antlr4::tree::TerminalNode *BY();
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
class TableExprValuesContext : public TableExprContext {
public:
TableExprValuesContext(TableExprContext *ctx);
antlr4::tree::TerminalNode *LPAREN();
ValuesClauseContext *valuesClause();
antlr4::tree::TerminalNode *RPAREN();
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
class TableExprAliasContext : public TableExprContext {
public:
TableExprAliasContext(TableExprContext *ctx);
TableExprContext *tableExpr();
AliasContext *alias();
antlr4::tree::TerminalNode *AS();
IdentifierContext *identifier();
ColumnAliasesContext *columnAliases();
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
class TableExprFunctionContext : public TableExprContext {
public:
TableExprFunctionContext(TableExprContext *ctx);
TableFunctionExprContext *tableFunctionExpr();
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
class TableExprUnpivotContext : public TableExprContext {
public:
TableExprUnpivotContext(TableExprContext *ctx);
TableExprContext *tableExpr();
antlr4::tree::TerminalNode *UNPIVOT();
antlr4::tree::TerminalNode *LPAREN();
UnpivotColumnListContext *unpivotColumnList();
antlr4::tree::TerminalNode *RPAREN();
antlr4::tree::TerminalNode *INCLUDE();
antlr4::tree::TerminalNode *NULLS();
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
TableExprContext* tableExpr();
TableExprContext* tableExpr(int precedence);
class PivotColumnListContext : public antlr4::ParserRuleContext {
public:
PivotColumnListContext(antlr4::ParserRuleContext *parent, size_t invokingState);
virtual size_t getRuleIndex() const override;
antlr4::tree::TerminalNode *FOR();
std::vector<PivotColumnContext *> pivotColumn();
PivotColumnContext* pivotColumn(size_t i);
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
PivotColumnListContext* pivotColumnList();
class PivotColumnContext : public antlr4::ParserRuleContext {
public:
PivotColumnContext(antlr4::ParserRuleContext *parent, size_t invokingState);
virtual size_t getRuleIndex() const override;
ColumnExprTupleOrSingleContext *columnExprTupleOrSingle();
antlr4::tree::TerminalNode *IN();
antlr4::tree::TerminalNode *LPAREN();
ColumnExprListContext *columnExprList();
antlr4::tree::TerminalNode *RPAREN();
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
PivotColumnContext* pivotColumn();
class UnpivotColumnListContext : public antlr4::ParserRuleContext {
public:
UnpivotColumnListContext(antlr4::ParserRuleContext *parent, size_t invokingState);
virtual size_t getRuleIndex() const override;
std::vector<UnpivotColumnContext *> unpivotColumn();
UnpivotColumnContext* unpivotColumn(size_t i);
std::vector<antlr4::tree::TerminalNode *> COMMA();
antlr4::tree::TerminalNode* COMMA(size_t i);
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
UnpivotColumnListContext* unpivotColumnList();
class UnpivotColumnContext : public antlr4::ParserRuleContext {
public:
UnpivotColumnContext(antlr4::ParserRuleContext *parent, size_t invokingState);
virtual size_t getRuleIndex() const override;
std::vector<ColumnExprTupleOrSingleContext *> columnExprTupleOrSingle();
ColumnExprTupleOrSingleContext* columnExprTupleOrSingle(size_t i);
antlr4::tree::TerminalNode *FOR();
std::vector<antlr4::tree::TerminalNode *> IN();
antlr4::tree::TerminalNode* IN(size_t i);
std::vector<antlr4::tree::TerminalNode *> LPAREN();
antlr4::tree::TerminalNode* LPAREN(size_t i);
std::vector<ColumnExprListContext *> columnExprList();
ColumnExprListContext* columnExprList(size_t i);
std::vector<antlr4::tree::TerminalNode *> RPAREN();
antlr4::tree::TerminalNode* RPAREN(size_t i);
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
UnpivotColumnContext* unpivotColumn();
class ColumnExprTupleOrSingleContext : public antlr4::ParserRuleContext {
public:
ColumnExprTupleOrSingleContext(antlr4::ParserRuleContext *parent, size_t invokingState);
virtual size_t getRuleIndex() const override;
antlr4::tree::TerminalNode *LPAREN();
ColumnExprListContext *columnExprList();
antlr4::tree::TerminalNode *RPAREN();
ColumnExprContext *columnExpr();
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
ColumnExprTupleOrSingleContext* columnExprTupleOrSingle();
class ColumnAliasesContext : public antlr4::ParserRuleContext {
public:
ColumnAliasesContext(antlr4::ParserRuleContext *parent, size_t invokingState);
virtual size_t getRuleIndex() const override;
antlr4::tree::TerminalNode *LPAREN();
std::vector<IdentifierContext *> identifier();
IdentifierContext* identifier(size_t i);
antlr4::tree::TerminalNode *RPAREN();
std::vector<antlr4::tree::TerminalNode *> COMMA();
antlr4::tree::TerminalNode* COMMA(size_t i);
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
ColumnAliasesContext* columnAliases();
class TableFunctionExprContext : public antlr4::ParserRuleContext {
public:
TableFunctionExprContext(antlr4::ParserRuleContext *parent, size_t invokingState);
virtual size_t getRuleIndex() const override;
IdentifierContext *identifier();
antlr4::tree::TerminalNode *LPAREN();
antlr4::tree::TerminalNode *RPAREN();
TableArgListContext *tableArgList();
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
TableFunctionExprContext* tableFunctionExpr();
class TableIdentifierContext : public antlr4::ParserRuleContext {
public:
TableIdentifierContext(antlr4::ParserRuleContext *parent, size_t invokingState);
virtual size_t getRuleIndex() const override;
NestedIdentifierContext *nestedIdentifier();
DatabaseIdentifierContext *databaseIdentifier();
antlr4::tree::TerminalNode *DOT();
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
TableIdentifierContext* tableIdentifier();
class TableArgListContext : public antlr4::ParserRuleContext {
public:
TableArgListContext(antlr4::ParserRuleContext *parent, size_t invokingState);
virtual size_t getRuleIndex() const override;
std::vector<ColumnExprContext *> columnExpr();
ColumnExprContext* columnExpr(size_t i);
std::vector<antlr4::tree::TerminalNode *> COMMA();
antlr4::tree::TerminalNode* COMMA(size_t i);
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
TableArgListContext* tableArgList();
class DatabaseIdentifierContext : public antlr4::ParserRuleContext {
public:
DatabaseIdentifierContext(antlr4::ParserRuleContext *parent, size_t invokingState);
virtual size_t getRuleIndex() const override;
IdentifierContext *identifier();
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
DatabaseIdentifierContext* databaseIdentifier();
class FloatingLiteralContext : public antlr4::ParserRuleContext {
public:
FloatingLiteralContext(antlr4::ParserRuleContext *parent, size_t invokingState);
virtual size_t getRuleIndex() const override;
antlr4::tree::TerminalNode *FLOATING_LITERAL();
antlr4::tree::TerminalNode *DOT();
std::vector<antlr4::tree::TerminalNode *> DECIMAL_LITERAL();
antlr4::tree::TerminalNode* DECIMAL_LITERAL(size_t i);
antlr4::tree::TerminalNode *OCTAL_LITERAL();
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
FloatingLiteralContext* floatingLiteral();
class NumberLiteralContext : public antlr4::ParserRuleContext {
public:
NumberLiteralContext(antlr4::ParserRuleContext *parent, size_t invokingState);
virtual size_t getRuleIndex() const override;
FloatingLiteralContext *floatingLiteral();
antlr4::tree::TerminalNode *BINARY_LITERAL();
antlr4::tree::TerminalNode *OCTAL_LITERAL();
antlr4::tree::TerminalNode *OCTAL_PREFIX_LITERAL();
antlr4::tree::TerminalNode *DECIMAL_LITERAL();
antlr4::tree::TerminalNode *HEXADECIMAL_LITERAL();
antlr4::tree::TerminalNode *INF();
antlr4::tree::TerminalNode *NAN_SQL();
antlr4::tree::TerminalNode *PLUS();
antlr4::tree::TerminalNode *DASH();
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
NumberLiteralContext* numberLiteral();
class LiteralContext : public antlr4::ParserRuleContext {
public:
LiteralContext(antlr4::ParserRuleContext *parent, size_t invokingState);
virtual size_t getRuleIndex() const override;
NumberLiteralContext *numberLiteral();
antlr4::tree::TerminalNode *STRING_LITERAL();
antlr4::tree::TerminalNode *NULL_SQL();
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
LiteralContext* literal();
class IntervalContext : public antlr4::ParserRuleContext {
public:
IntervalContext(antlr4::ParserRuleContext *parent, size_t invokingState);
virtual size_t getRuleIndex() const override;
antlr4::tree::TerminalNode *SECOND();
antlr4::tree::TerminalNode *MINUTE();
antlr4::tree::TerminalNode *HOUR();
antlr4::tree::TerminalNode *DAY();
antlr4::tree::TerminalNode *WEEK();
antlr4::tree::TerminalNode *MONTH();
antlr4::tree::TerminalNode *QUARTER();
antlr4::tree::TerminalNode *YEAR();
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
IntervalContext* interval();
class KeywordContext : public antlr4::ParserRuleContext {
public:
KeywordContext(antlr4::ParserRuleContext *parent, size_t invokingState);
virtual size_t getRuleIndex() const override;
antlr4::tree::TerminalNode *ALL();
antlr4::tree::TerminalNode *AND();
antlr4::tree::TerminalNode *ANTI();
antlr4::tree::TerminalNode *ANY();
antlr4::tree::TerminalNode *ARRAY();
antlr4::tree::TerminalNode *AS();
antlr4::tree::TerminalNode *ASCENDING();
antlr4::tree::TerminalNode *ASOF();
antlr4::tree::TerminalNode *BETWEEN();
antlr4::tree::TerminalNode *BOTH();
antlr4::tree::TerminalNode *BY();
antlr4::tree::TerminalNode *CASE();
antlr4::tree::TerminalNode *CAST();
antlr4::tree::TerminalNode *COHORT();
antlr4::tree::TerminalNode *COLLATE();
antlr4::tree::TerminalNode *COLUMNS();
antlr4::tree::TerminalNode *CROSS();
antlr4::tree::TerminalNode *CUBE();
antlr4::tree::TerminalNode *CURRENT();
antlr4::tree::TerminalNode *DATE();
antlr4::tree::TerminalNode *DESC();
antlr4::tree::TerminalNode *DESCENDING();
antlr4::tree::TerminalNode *DISTINCT();
antlr4::tree::TerminalNode *ELSE();
antlr4::tree::TerminalNode *END();
antlr4::tree::TerminalNode *EXCLUDE();
antlr4::tree::TerminalNode *EXTRACT();
antlr4::tree::TerminalNode *FILL();
antlr4::tree::TerminalNode *FILTER();
antlr4::tree::TerminalNode *FINAL();
antlr4::tree::TerminalNode *FIRST();
antlr4::tree::TerminalNode *FOR();
antlr4::tree::TerminalNode *FOLLOWING();
antlr4::tree::TerminalNode *FROM();
antlr4::tree::TerminalNode *FULL();
antlr4::tree::TerminalNode *GROUP();
antlr4::tree::TerminalNode *HAVING();
antlr4::tree::TerminalNode *ID();
antlr4::tree::TerminalNode *INTERPOLATE();
antlr4::tree::TerminalNode *IS();
antlr4::tree::TerminalNode *GROUPING();
antlr4::tree::TerminalNode *IF();
antlr4::tree::TerminalNode *IGNORE();
antlr4::tree::TerminalNode *ILIKE();
antlr4::tree::TerminalNode *INCLUDE();
antlr4::tree::TerminalNode *IN();
antlr4::tree::TerminalNode *INNER();
antlr4::tree::TerminalNode *INTERVAL();
antlr4::tree::TerminalNode *JOIN();
antlr4::tree::TerminalNode *KEY();
antlr4::tree::TerminalNode *LAMBDA();
antlr4::tree::TerminalNode *LAST();
antlr4::tree::TerminalNode *LEADING();
antlr4::tree::TerminalNode *LEFT();
antlr4::tree::TerminalNode *LIKE();
antlr4::tree::TerminalNode *LIMIT();
antlr4::tree::TerminalNode *LOCAL();
antlr4::tree::TerminalNode *NAME();
antlr4::tree::TerminalNode *NATURAL();
antlr4::tree::TerminalNode *NOT();
antlr4::tree::TerminalNode *NULLS();
antlr4::tree::TerminalNode *OFFSET();
antlr4::tree::TerminalNode *ON();
antlr4::tree::TerminalNode *OR();
antlr4::tree::TerminalNode *ORDER();
antlr4::tree::TerminalNode *OUTER();
antlr4::tree::TerminalNode *OVER();
antlr4::tree::TerminalNode *PARTITION();
antlr4::tree::TerminalNode *PIVOT();
antlr4::tree::TerminalNode *POSITIONAL();
antlr4::tree::TerminalNode *PRECEDING();
antlr4::tree::TerminalNode *PREWHERE();
antlr4::tree::TerminalNode *QUALIFY();
antlr4::tree::TerminalNode *RANGE();
antlr4::tree::TerminalNode *RECURSIVE();
antlr4::tree::TerminalNode *REPLACE();
antlr4::tree::TerminalNode *RETURN();
antlr4::tree::TerminalNode *RIGHT();
antlr4::tree::TerminalNode *ROLLUP();
antlr4::tree::TerminalNode *ROW();
antlr4::tree::TerminalNode *ROWS();
antlr4::tree::TerminalNode *SAMPLE();
antlr4::tree::TerminalNode *SELECT();
antlr4::tree::TerminalNode *SEMI();
antlr4::tree::TerminalNode *SETS();
antlr4::tree::TerminalNode *SETTINGS();
antlr4::tree::TerminalNode *STEP();
antlr4::tree::TerminalNode *SUBSTRING();
antlr4::tree::TerminalNode *THEN();
antlr4::tree::TerminalNode *TIES();
antlr4::tree::TerminalNode *TIME();
antlr4::tree::TerminalNode *TIMESTAMP();
antlr4::tree::TerminalNode *TOTALS();
antlr4::tree::TerminalNode *TRAILING();
antlr4::tree::TerminalNode *TRIM();
antlr4::tree::TerminalNode *TRUNCATE();
antlr4::tree::TerminalNode *TRY_CAST();
antlr4::tree::TerminalNode *TO();
antlr4::tree::TerminalNode *TOP();
antlr4::tree::TerminalNode *UNBOUNDED();
antlr4::tree::TerminalNode *UNION();
antlr4::tree::TerminalNode *UNPIVOT();
antlr4::tree::TerminalNode *USING();
antlr4::tree::TerminalNode *VALUES();
antlr4::tree::TerminalNode *WHEN();
antlr4::tree::TerminalNode *WHERE();
antlr4::tree::TerminalNode *WINDOW();
antlr4::tree::TerminalNode *WITH();
antlr4::tree::TerminalNode *ZONE();
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
KeywordContext* keyword();
class KeywordForAliasContext : public antlr4::ParserRuleContext {
public:
KeywordForAliasContext(antlr4::ParserRuleContext *parent, size_t invokingState);
virtual size_t getRuleIndex() const override;
antlr4::tree::TerminalNode *DATE();
antlr4::tree::TerminalNode *FIRST();
antlr4::tree::TerminalNode *ID();
antlr4::tree::TerminalNode *KEY();
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
KeywordForAliasContext* keywordForAlias();
class KeywordForImplicitAliasContext : public antlr4::ParserRuleContext {
public:
KeywordForImplicitAliasContext(antlr4::ParserRuleContext *parent, size_t invokingState);
virtual size_t getRuleIndex() const override;
antlr4::tree::TerminalNode *ASCENDING();
antlr4::tree::TerminalNode *COHORT();
antlr4::tree::TerminalNode *DATE();
antlr4::tree::TerminalNode *DESCENDING();
antlr4::tree::TerminalNode *FINAL();
antlr4::tree::TerminalNode *ID();
antlr4::tree::TerminalNode *RETURN();
antlr4::tree::TerminalNode *TOP();
antlr4::tree::TerminalNode *TOTALS();
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
KeywordForImplicitAliasContext* keywordForImplicitAlias();
class AliasContext : public antlr4::ParserRuleContext {
public:
AliasContext(antlr4::ParserRuleContext *parent, size_t invokingState);
virtual size_t getRuleIndex() const override;
antlr4::tree::TerminalNode *IDENTIFIER();
antlr4::tree::TerminalNode *QUOTED_IDENTIFIER();
KeywordForAliasContext *keywordForAlias();
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
AliasContext* alias();
class ImplicitAliasContext : public antlr4::ParserRuleContext {
public:
ImplicitAliasContext(antlr4::ParserRuleContext *parent, size_t invokingState);
virtual size_t getRuleIndex() const override;
antlr4::tree::TerminalNode *IDENTIFIER();
antlr4::tree::TerminalNode *QUOTED_IDENTIFIER();
KeywordForImplicitAliasContext *keywordForImplicitAlias();
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
ImplicitAliasContext* implicitAlias();
class IdentifierContext : public antlr4::ParserRuleContext {
public:
IdentifierContext(antlr4::ParserRuleContext *parent, size_t invokingState);
virtual size_t getRuleIndex() const override;
antlr4::tree::TerminalNode *IDENTIFIER();
antlr4::tree::TerminalNode *QUOTED_IDENTIFIER();
IntervalContext *interval();
KeywordContext *keyword();
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
IdentifierContext* identifier();
class EnumValueContext : public antlr4::ParserRuleContext {
public:
EnumValueContext(antlr4::ParserRuleContext *parent, size_t invokingState);
virtual size_t getRuleIndex() const override;
StringContext *string();
antlr4::tree::TerminalNode *EQ_SINGLE();
NumberLiteralContext *numberLiteral();
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
EnumValueContext* enumValue();
class PlaceholderContext : public antlr4::ParserRuleContext {
public:
PlaceholderContext(antlr4::ParserRuleContext *parent, size_t invokingState);
virtual size_t getRuleIndex() const override;
antlr4::tree::TerminalNode *LBRACE();
ColumnExprContext *columnExpr();
antlr4::tree::TerminalNode *RBRACE();
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
PlaceholderContext* placeholder();
class StringContext : public antlr4::ParserRuleContext {
public:
StringContext(antlr4::ParserRuleContext *parent, size_t invokingState);
virtual size_t getRuleIndex() const override;
antlr4::tree::TerminalNode *STRING_LITERAL();
TemplateStringContext *templateString();
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
StringContext* string();
class TemplateStringContext : public antlr4::ParserRuleContext {
public:
TemplateStringContext(antlr4::ParserRuleContext *parent, size_t invokingState);
virtual size_t getRuleIndex() const override;
antlr4::tree::TerminalNode *QUOTE_SINGLE_TEMPLATE();
antlr4::tree::TerminalNode *QUOTE_SINGLE();
std::vector<StringContentsContext *> stringContents();
StringContentsContext* stringContents(size_t i);
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
TemplateStringContext* templateString();
class StringContentsContext : public antlr4::ParserRuleContext {
public:
StringContentsContext(antlr4::ParserRuleContext *parent, size_t invokingState);
virtual size_t getRuleIndex() const override;
antlr4::tree::TerminalNode *STRING_ESCAPE_TRIGGER();
ColumnExprContext *columnExpr();
antlr4::tree::TerminalNode *RBRACE();
antlr4::tree::TerminalNode *STRING_TEXT();
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
StringContentsContext* stringContents();
class FullTemplateStringContext : public antlr4::ParserRuleContext {
public:
FullTemplateStringContext(antlr4::ParserRuleContext *parent, size_t invokingState);
virtual size_t getRuleIndex() const override;
antlr4::tree::TerminalNode *QUOTE_SINGLE_TEMPLATE_FULL();
antlr4::tree::TerminalNode *EOF();
std::vector<StringContentsFullContext *> stringContentsFull();
StringContentsFullContext* stringContentsFull(size_t i);
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
FullTemplateStringContext* fullTemplateString();
class StringContentsFullContext : public antlr4::ParserRuleContext {
public:
StringContentsFullContext(antlr4::ParserRuleContext *parent, size_t invokingState);
virtual size_t getRuleIndex() const override;
antlr4::tree::TerminalNode *FULL_STRING_ESCAPE_TRIGGER();
ColumnExprContext *columnExpr();
antlr4::tree::TerminalNode *RBRACE();
antlr4::tree::TerminalNode *FULL_STRING_TEXT();
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
StringContentsFullContext* stringContentsFull();
bool sempred(antlr4::RuleContext *_localctx, size_t ruleIndex, size_t predicateIndex) override;
bool joinExprSempred(JoinExprContext *_localctx, size_t predicateIndex);
bool columnTypeExprSempred(ColumnTypeExprContext *_localctx, size_t predicateIndex);
bool columnExprSempred(ColumnExprContext *_localctx, size_t predicateIndex);
bool columnExprValueSempred(ColumnExprValueContext *_localctx, size_t predicateIndex);
bool tableExprSempred(TableExprContext *_localctx, size_t predicateIndex);
// By default the static state used to implement the parser is lazily initialized during the first
// call to the constructor. You can call this function if you wish to initialize the static state
// ahead of time.
static void initialize();
private:
};