parser

package

Go to main page

Versions in this module

v1

v1.15.10

Apr 21, 2022

v1.15.9

Apr 21, 2022

v1.15.8

Apr 21, 2022

v1.15.7

Apr 20, 2022

v1.15.6

Apr 20, 2022

v1.15.5

Apr 20, 2022

v1.15.4

Apr 20, 2022

v1.15.3

Apr 20, 2022

v1.15.2

Apr 20, 2022

v1.15.1

Apr 20, 2022

Changes in this version

+ const SQLiteLexerABORT_

+ const SQLiteLexerACTION_

+ const SQLiteLexerADD_

+ const SQLiteLexerAFTER_

+ const SQLiteLexerALL_

+ const SQLiteLexerALTER_

+ const SQLiteLexerALWAYS_

+ const SQLiteLexerANALYZE_

+ const SQLiteLexerAND_

+ const SQLiteLexerASC_

+ const SQLiteLexerAS_

+ const SQLiteLexerATTACH_

+ const SQLiteLexerAUTOINCREMENT_

+ const SQLiteLexerBEFORE_

+ const SQLiteLexerBEGIN_

+ const SQLiteLexerBETWEEN_

+ const SQLiteLexerBY_

+ const SQLiteLexerCASCADE_

+ const SQLiteLexerCASE_

+ const SQLiteLexerCAST_

+ const SQLiteLexerCHECK_

+ const SQLiteLexerCOLLATE_

+ const SQLiteLexerCOLUMN_

+ const SQLiteLexerCOMMIT_

+ const SQLiteLexerCONFLICT_

+ const SQLiteLexerCONSTRAINT_

+ const SQLiteLexerCREATE_

+ const SQLiteLexerCROSS_

+ const SQLiteLexerCUME_DIST_

+ const SQLiteLexerCURRENT_

+ const SQLiteLexerCURRENT_DATE_

+ const SQLiteLexerCURRENT_TIMESTAMP_

+ const SQLiteLexerCURRENT_TIME_

+ const SQLiteLexerDATABASE_

+ const SQLiteLexerDEFAULT_

+ const SQLiteLexerDEFERRABLE_

+ const SQLiteLexerDEFERRED_

+ const SQLiteLexerDELETE_

+ const SQLiteLexerDENSE_RANK_

+ const SQLiteLexerDESC_

+ const SQLiteLexerDETACH_

+ const SQLiteLexerDISTINCT_

+ const SQLiteLexerDO_

+ const SQLiteLexerDROP_

+ const SQLiteLexerEACH_

+ const SQLiteLexerELSE_

+ const SQLiteLexerEND_

+ const SQLiteLexerESCAPE_

+ const SQLiteLexerEXCEPT_

+ const SQLiteLexerEXCLUDE_

+ const SQLiteLexerEXCLUSIVE_

+ const SQLiteLexerEXISTS_

+ const SQLiteLexerEXPLAIN_

+ const SQLiteLexerFAIL_

+ const SQLiteLexerFALSE_

+ const SQLiteLexerFILTER_

+ const SQLiteLexerFIRST_

+ const SQLiteLexerFIRST_VALUE_

+ const SQLiteLexerFOLLOWING_

+ const SQLiteLexerFOREIGN_

+ const SQLiteLexerFOR_

+ const SQLiteLexerFROM_

+ const SQLiteLexerFULL_

+ const SQLiteLexerGENERATED_

+ const SQLiteLexerGLOB_

+ const SQLiteLexerGROUPS_

+ const SQLiteLexerGROUP_

+ const SQLiteLexerHAVING_

+ const SQLiteLexerIF_

+ const SQLiteLexerIGNORE_

+ const SQLiteLexerIMMEDIATE_

+ const SQLiteLexerINDEXED_

+ const SQLiteLexerINDEX_

+ const SQLiteLexerINITIALLY_

+ const SQLiteLexerINNER_

+ const SQLiteLexerINSERT_

+ const SQLiteLexerINSTEAD_

+ const SQLiteLexerINTERSECT_

+ const SQLiteLexerINTO_

+ const SQLiteLexerIN_

+ const SQLiteLexerISNULL_

+ const SQLiteLexerIS_

+ const SQLiteLexerJOIN_

+ const SQLiteLexerKEY_

+ const SQLiteLexerLAG_

+ const SQLiteLexerLAST_

+ const SQLiteLexerLAST_VALUE_

+ const SQLiteLexerLEAD_

+ const SQLiteLexerLEFT_

+ const SQLiteLexerLIKE_

+ const SQLiteLexerLIMIT_

+ const SQLiteLexerMATCH_

+ const SQLiteLexerNATURAL_

+ const SQLiteLexerNOTHING_

+ const SQLiteLexerNOTNULL_

+ const SQLiteLexerNOT_

+ const SQLiteLexerNO_

+ const SQLiteLexerNTH_VALUE_

+ const SQLiteLexerNTILE_

+ const SQLiteLexerNULLS_

+ const SQLiteLexerNULL_

+ const SQLiteLexerOFFSET_

+ const SQLiteLexerOF_

+ const SQLiteLexerON_

+ const SQLiteLexerORDER_

+ const SQLiteLexerOR_

+ const SQLiteLexerOTHERS_

+ const SQLiteLexerOUTER_

+ const SQLiteLexerOVER_

+ const SQLiteLexerPARTITION_

+ const SQLiteLexerPERCENT_RANK_

+ const SQLiteLexerPLAN_

+ const SQLiteLexerPRAGMA_

+ const SQLiteLexerPRECEDING_

+ const SQLiteLexerPRIMARY_

+ const SQLiteLexerQUERY_

+ const SQLiteLexerRAISE_

+ const SQLiteLexerRANGE_

+ const SQLiteLexerRANK_

+ const SQLiteLexerRECURSIVE_

+ const SQLiteLexerREFERENCES_

+ const SQLiteLexerREGEXP_

+ const SQLiteLexerREINDEX_

+ const SQLiteLexerRELEASE_

+ const SQLiteLexerRENAME_

+ const SQLiteLexerREPLACE_

+ const SQLiteLexerRESTRICT_

+ const SQLiteLexerRIGHT_

+ const SQLiteLexerROLLBACK_

+ const SQLiteLexerROWS_

+ const SQLiteLexerROW_

+ const SQLiteLexerROW_NUMBER_

+ const SQLiteLexerSAVEPOINT_

+ const SQLiteLexerSELECT_

+ const SQLiteLexerSET_

+ const SQLiteLexerSTORED_

+ const SQLiteLexerTABLE_

+ const SQLiteLexerTEMPORARY_

+ const SQLiteLexerTEMP_

+ const SQLiteLexerTHEN_

+ const SQLiteLexerTIES_

+ const SQLiteLexerTO_

+ const SQLiteLexerTRANSACTION_

+ const SQLiteLexerTRIGGER_

+ const SQLiteLexerTRUE_

+ const SQLiteLexerUNBOUNDED_

+ const SQLiteLexerUNION_

+ const SQLiteLexerUNIQUE_

+ const SQLiteLexerUPDATE_

+ const SQLiteLexerUSING_

+ const SQLiteLexerVACUUM_

+ const SQLiteLexerVALUES_

+ const SQLiteLexerVIEW_

+ const SQLiteLexerVIRTUAL_

+ const SQLiteLexerWHEN_

+ const SQLiteLexerWHERE_

+ const SQLiteLexerWINDOW_

+ const SQLiteLexerWITHOUT_

+ const SQLiteLexerWITH_

+ const SQLiteParserABORT_

+ const SQLiteParserACTION_

+ const SQLiteParserADD_

+ const SQLiteParserAFTER_

+ const SQLiteParserALL_

+ const SQLiteParserALTER_

+ const SQLiteParserALWAYS_

+ const SQLiteParserANALYZE_

+ const SQLiteParserAND_

+ const SQLiteParserASC_

+ const SQLiteParserAS_

+ const SQLiteParserATTACH_

+ const SQLiteParserAUTOINCREMENT_

+ const SQLiteParserBEFORE_

+ const SQLiteParserBEGIN_

+ const SQLiteParserBETWEEN_

+ const SQLiteParserBY_

+ const SQLiteParserCASCADE_

+ const SQLiteParserCASE_

+ const SQLiteParserCAST_

+ const SQLiteParserCHECK_

+ const SQLiteParserCOLLATE_

+ const SQLiteParserCOLUMN_

+ const SQLiteParserCOMMIT_

+ const SQLiteParserCONFLICT_

+ const SQLiteParserCONSTRAINT_

+ const SQLiteParserCREATE_

+ const SQLiteParserCROSS_

+ const SQLiteParserCUME_DIST_

+ const SQLiteParserCURRENT_

+ const SQLiteParserCURRENT_DATE_

+ const SQLiteParserCURRENT_TIMESTAMP_

+ const SQLiteParserCURRENT_TIME_

+ const SQLiteParserDATABASE_

+ const SQLiteParserDEFAULT_

+ const SQLiteParserDEFERRABLE_

+ const SQLiteParserDEFERRED_

+ const SQLiteParserDELETE_

+ const SQLiteParserDENSE_RANK_

+ const SQLiteParserDESC_

+ const SQLiteParserDETACH_

+ const SQLiteParserDISTINCT_

+ const SQLiteParserDO_

+ const SQLiteParserDROP_

+ const SQLiteParserEACH_

+ const SQLiteParserELSE_

+ const SQLiteParserEND_

+ const SQLiteParserESCAPE_

+ const SQLiteParserEXCEPT_

+ const SQLiteParserEXCLUDE_

+ const SQLiteParserEXCLUSIVE_

+ const SQLiteParserEXISTS_

+ const SQLiteParserEXPLAIN_

+ const SQLiteParserFAIL_

+ const SQLiteParserFALSE_

+ const SQLiteParserFILTER_

+ const SQLiteParserFIRST_

+ const SQLiteParserFIRST_VALUE_

+ const SQLiteParserFOLLOWING_

+ const SQLiteParserFOREIGN_

+ const SQLiteParserFOR_

+ const SQLiteParserFROM_

+ const SQLiteParserFULL_

+ const SQLiteParserGENERATED_

+ const SQLiteParserGLOB_

+ const SQLiteParserGROUPS_

+ const SQLiteParserGROUP_

+ const SQLiteParserHAVING_

+ const SQLiteParserIF_

+ const SQLiteParserIGNORE_

+ const SQLiteParserIMMEDIATE_

+ const SQLiteParserINDEXED_

+ const SQLiteParserINDEX_

+ const SQLiteParserINITIALLY_

+ const SQLiteParserINNER_

+ const SQLiteParserINSERT_

+ const SQLiteParserINSTEAD_

+ const SQLiteParserINTERSECT_

+ const SQLiteParserINTO_

+ const SQLiteParserIN_

+ const SQLiteParserISNULL_

+ const SQLiteParserIS_

+ const SQLiteParserJOIN_

+ const SQLiteParserKEY_

+ const SQLiteParserLAG_

+ const SQLiteParserLAST_

+ const SQLiteParserLAST_VALUE_

+ const SQLiteParserLEAD_

+ const SQLiteParserLEFT_

+ const SQLiteParserLIKE_

+ const SQLiteParserLIMIT_

+ const SQLiteParserMATCH_

+ const SQLiteParserNATURAL_

+ const SQLiteParserNOTHING_

+ const SQLiteParserNOTNULL_

+ const SQLiteParserNOT_

+ const SQLiteParserNO_

+ const SQLiteParserNTH_VALUE_

+ const SQLiteParserNTILE_

+ const SQLiteParserNULLS_

+ const SQLiteParserNULL_

+ const SQLiteParserOFFSET_

+ const SQLiteParserOF_

+ const SQLiteParserON_

+ const SQLiteParserORDER_

+ const SQLiteParserOR_

+ const SQLiteParserOTHERS_

+ const SQLiteParserOUTER_

+ const SQLiteParserOVER_

+ const SQLiteParserPARTITION_

+ const SQLiteParserPERCENT_RANK_

+ const SQLiteParserPLAN_

+ const SQLiteParserPRAGMA_

+ const SQLiteParserPRECEDING_

+ const SQLiteParserPRIMARY_

+ const SQLiteParserQUERY_

+ const SQLiteParserRAISE_

+ const SQLiteParserRANGE_

+ const SQLiteParserRANK_

+ const SQLiteParserRECURSIVE_

+ const SQLiteParserREFERENCES_

+ const SQLiteParserREGEXP_

+ const SQLiteParserREINDEX_

+ const SQLiteParserRELEASE_

+ const SQLiteParserRENAME_

+ const SQLiteParserREPLACE_

+ const SQLiteParserRESTRICT_

+ const SQLiteParserRIGHT_

+ const SQLiteParserROLLBACK_

+ const SQLiteParserROWS_

+ const SQLiteParserROW_

+ const SQLiteParserROW_NUMBER_

+ const SQLiteParserRULE_aggregate_func

+ const SQLiteParserRULE_aggregate_function_invocation

+ const SQLiteParserRULE_alias

+ const SQLiteParserRULE_asc_desc

+ const SQLiteParserRULE_base_window_name

+ const SQLiteParserRULE_column_name_list

+ const SQLiteParserRULE_common_table_stmt

+ const SQLiteParserRULE_cte_table_name

+ const SQLiteParserRULE_default_DEFAULT__value

+ const SQLiteParserRULE_drop_stmt

+ const SQLiteParserRULE_expr_asc_desc

+ const SQLiteParserRULE_filename

+ const SQLiteParserRULE_filter_clause

+ const SQLiteParserRULE_frame_clause

+ const SQLiteParserRULE_frame_left

+ const SQLiteParserRULE_frame_right

+ const SQLiteParserRULE_frame_single

+ const SQLiteParserRULE_frame_spec

+ const SQLiteParserRULE_initial_select

+ const SQLiteParserRULE_limit_stmt

+ const SQLiteParserRULE_of_OF_fset

+ const SQLiteParserRULE_order_by_expr

+ const SQLiteParserRULE_order_by_expr_asc_desc

+ const SQLiteParserRULE_order_by_stmt

+ const SQLiteParserRULE_over_clause

+ const SQLiteParserRULE_partition_by

+ const SQLiteParserRULE_recursive__select

+ const SQLiteParserRULE_recursive_cte

+ const SQLiteParserRULE_simple_func

+ const SQLiteParserRULE_simple_function_invocation

+ const SQLiteParserRULE_upsert_clause

+ const SQLiteParserRULE_window_defn

+ const SQLiteParserRULE_window_function

+ const SQLiteParserRULE_window_function_invocation

+ const SQLiteParserRULE_window_name

+ const SQLiteParserSAVEPOINT_

+ const SQLiteParserSELECT_

+ const SQLiteParserSET_

+ const SQLiteParserSTORED_

+ const SQLiteParserTABLE_

+ const SQLiteParserTEMPORARY_

+ const SQLiteParserTEMP_

+ const SQLiteParserTHEN_

+ const SQLiteParserTIES_

+ const SQLiteParserTO_

+ const SQLiteParserTRANSACTION_

+ const SQLiteParserTRIGGER_

+ const SQLiteParserTRUE_

+ const SQLiteParserUNBOUNDED_

+ const SQLiteParserUNION_

+ const SQLiteParserUNIQUE_

+ const SQLiteParserUPDATE_

+ const SQLiteParserUSING_

+ const SQLiteParserVACUUM_

+ const SQLiteParserVALUES_

+ const SQLiteParserVIEW_

+ const SQLiteParserVIRTUAL_

+ const SQLiteParserWHEN_

+ const SQLiteParserWHERE_

+ const SQLiteParserWINDOW_

+ const SQLiteParserWITHOUT_

+ const SQLiteParserWITH_

+ type Aggregate_funcContext struct

+ func NewAggregate_funcContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Aggregate_funcContext

+ func NewEmptyAggregate_funcContext() *Aggregate_funcContext

+ func (*Aggregate_funcContext) IsAggregate_funcContext()

+ func (s *Aggregate_funcContext) Any_name() IAny_nameContext

+ func (s *Aggregate_funcContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Aggregate_funcContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Aggregate_funcContext) GetParser() antlr.Parser

+ func (s *Aggregate_funcContext) GetRuleContext() antlr.RuleContext

+ func (s *Aggregate_funcContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type Aggregate_function_invocationContext struct

+ func NewAggregate_function_invocationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Aggregate_function_invocationContext

+ func NewEmptyAggregate_function_invocationContext() *Aggregate_function_invocationContext

+ func (*Aggregate_function_invocationContext) IsAggregate_function_invocationContext()

+ func (s *Aggregate_function_invocationContext) Aggregate_func() IAggregate_funcContext

+ func (s *Aggregate_function_invocationContext) AllCOMMA() []antlr.TerminalNode

+ func (s *Aggregate_function_invocationContext) AllExpr() []IExprContext

+ func (s *Aggregate_function_invocationContext) CLOSE_PAR() antlr.TerminalNode

+ func (s *Aggregate_function_invocationContext) COMMA(i int) antlr.TerminalNode

+ func (s *Aggregate_function_invocationContext) DISTINCT_() antlr.TerminalNode

+ func (s *Aggregate_function_invocationContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Aggregate_function_invocationContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Aggregate_function_invocationContext) Expr(i int) IExprContext

+ func (s *Aggregate_function_invocationContext) Filter_clause() IFilter_clauseContext

+ func (s *Aggregate_function_invocationContext) GetParser() antlr.Parser

+ func (s *Aggregate_function_invocationContext) GetRuleContext() antlr.RuleContext

+ func (s *Aggregate_function_invocationContext) OPEN_PAR() antlr.TerminalNode

+ func (s *Aggregate_function_invocationContext) STAR() antlr.TerminalNode

+ func (s *Aggregate_function_invocationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type AliasContext struct

+ func NewAliasContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AliasContext

+ func NewEmptyAliasContext() *AliasContext

+ func (*AliasContext) IsAliasContext()

+ func (s *AliasContext) Any_name() IAny_nameContext

+ func (s *AliasContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *AliasContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *AliasContext) GetParser() antlr.Parser

+ func (s *AliasContext) GetRuleContext() antlr.RuleContext

+ func (s *AliasContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Alter_table_stmtContext

+ func (s *Alter_table_stmtContext) ADD_() antlr.TerminalNode

+ func (s *Alter_table_stmtContext) ALTER_() antlr.TerminalNode

+ func (s *Alter_table_stmtContext) AllColumn_name() []IColumn_nameContext

+ func (s *Alter_table_stmtContext) COLUMN_() antlr.TerminalNode

+ func (s *Alter_table_stmtContext) DROP_() antlr.TerminalNode

+ func (s *Alter_table_stmtContext) GetNew_column_name() IColumn_nameContext

+ func (s *Alter_table_stmtContext) GetOld_column_name() IColumn_nameContext

+ func (s *Alter_table_stmtContext) RENAME_() antlr.TerminalNode

+ func (s *Alter_table_stmtContext) Schema_name() ISchema_nameContext

+ func (s *Alter_table_stmtContext) SetNew_column_name(v IColumn_nameContext)

+ func (s *Alter_table_stmtContext) SetOld_column_name(v IColumn_nameContext)

+ func (s *Alter_table_stmtContext) TABLE_() antlr.TerminalNode

+ func (s *Alter_table_stmtContext) TO_() antlr.TerminalNode

type Analyze_stmtContext

+ func (s *Analyze_stmtContext) ANALYZE_() antlr.TerminalNode

+ func (s *Analyze_stmtContext) Schema_name() ISchema_nameContext

+ type Asc_descContext struct

+ func NewAsc_descContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Asc_descContext

+ func NewEmptyAsc_descContext() *Asc_descContext

+ func (*Asc_descContext) IsAsc_descContext()

+ func (s *Asc_descContext) ASC_() antlr.TerminalNode

+ func (s *Asc_descContext) DESC_() antlr.TerminalNode

+ func (s *Asc_descContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Asc_descContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Asc_descContext) GetParser() antlr.Parser

+ func (s *Asc_descContext) GetRuleContext() antlr.RuleContext

+ func (s *Asc_descContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Attach_stmtContext

+ func (s *Attach_stmtContext) AS_() antlr.TerminalNode

+ func (s *Attach_stmtContext) ATTACH_() antlr.TerminalNode

+ func (s *Attach_stmtContext) DATABASE_() antlr.TerminalNode

+ func (s *Attach_stmtContext) Schema_name() ISchema_nameContext

+ type BaseSQLiteParserListener struct

+ func (s *BaseSQLiteParserListener) EnterAggregate_func(ctx *Aggregate_funcContext)

+ func (s *BaseSQLiteParserListener) EnterAggregate_function_invocation(ctx *Aggregate_function_invocationContext)

+ func (s *BaseSQLiteParserListener) EnterAlias(ctx *AliasContext)

+ func (s *BaseSQLiteParserListener) EnterAlter_table_stmt(ctx *Alter_table_stmtContext)

+ func (s *BaseSQLiteParserListener) EnterAnalyze_stmt(ctx *Analyze_stmtContext)

+ func (s *BaseSQLiteParserListener) EnterAny_name(ctx *Any_nameContext)

+ func (s *BaseSQLiteParserListener) EnterAsc_desc(ctx *Asc_descContext)

+ func (s *BaseSQLiteParserListener) EnterAttach_stmt(ctx *Attach_stmtContext)

+ func (s *BaseSQLiteParserListener) EnterBase_window_name(ctx *Base_window_nameContext)

+ func (s *BaseSQLiteParserListener) EnterBegin_stmt(ctx *Begin_stmtContext)

+ func (s *BaseSQLiteParserListener) EnterCollation_name(ctx *Collation_nameContext)

+ func (s *BaseSQLiteParserListener) EnterColumn_alias(ctx *Column_aliasContext)

+ func (s *BaseSQLiteParserListener) EnterColumn_constraint(ctx *Column_constraintContext)

+ func (s *BaseSQLiteParserListener) EnterColumn_def(ctx *Column_defContext)

+ func (s *BaseSQLiteParserListener) EnterColumn_name(ctx *Column_nameContext)

+ func (s *BaseSQLiteParserListener) EnterColumn_name_list(ctx *Column_name_listContext)

+ func (s *BaseSQLiteParserListener) EnterCommit_stmt(ctx *Commit_stmtContext)

+ func (s *BaseSQLiteParserListener) EnterCommon_table_expression(ctx *Common_table_expressionContext)

+ func (s *BaseSQLiteParserListener) EnterCommon_table_stmt(ctx *Common_table_stmtContext)

+ func (s *BaseSQLiteParserListener) EnterCompound_operator(ctx *Compound_operatorContext)

+ func (s *BaseSQLiteParserListener) EnterCompound_select_stmt(ctx *Compound_select_stmtContext)

+ func (s *BaseSQLiteParserListener) EnterConflict_clause(ctx *Conflict_clauseContext)

+ func (s *BaseSQLiteParserListener) EnterCreate_index_stmt(ctx *Create_index_stmtContext)

+ func (s *BaseSQLiteParserListener) EnterCreate_table_stmt(ctx *Create_table_stmtContext)

+ func (s *BaseSQLiteParserListener) EnterCreate_trigger_stmt(ctx *Create_trigger_stmtContext)

+ func (s *BaseSQLiteParserListener) EnterCreate_view_stmt(ctx *Create_view_stmtContext)

+ func (s *BaseSQLiteParserListener) EnterCreate_virtual_table_stmt(ctx *Create_virtual_table_stmtContext)

+ func (s *BaseSQLiteParserListener) EnterCte_table_name(ctx *Cte_table_nameContext)

+ func (s *BaseSQLiteParserListener) EnterDefault_DEFAULT__value(ctx *Default_DEFAULT__valueContext)

+ func (s *BaseSQLiteParserListener) EnterDelete_stmt(ctx *Delete_stmtContext)

+ func (s *BaseSQLiteParserListener) EnterDelete_stmt_limited(ctx *Delete_stmt_limitedContext)

+ func (s *BaseSQLiteParserListener) EnterDetach_stmt(ctx *Detach_stmtContext)

+ func (s *BaseSQLiteParserListener) EnterDrop_stmt(ctx *Drop_stmtContext)

+ func (s *BaseSQLiteParserListener) EnterError_message(ctx *Error_messageContext)

+ func (s *BaseSQLiteParserListener) EnterEveryRule(ctx antlr.ParserRuleContext)

+ func (s *BaseSQLiteParserListener) EnterExpr_asc_desc(ctx *Expr_asc_descContext)

+ func (s *BaseSQLiteParserListener) EnterExpr_between(ctx *Expr_betweenContext)

+ func (s *BaseSQLiteParserListener) EnterExpr_binary(ctx *Expr_binaryContext)

+ func (s *BaseSQLiteParserListener) EnterExpr_bind(ctx *Expr_bindContext)

+ func (s *BaseSQLiteParserListener) EnterExpr_case(ctx *Expr_caseContext)

+ func (s *BaseSQLiteParserListener) EnterExpr_cast(ctx *Expr_castContext)

+ func (s *BaseSQLiteParserListener) EnterExpr_collate(ctx *Expr_collateContext)

+ func (s *BaseSQLiteParserListener) EnterExpr_comparison(ctx *Expr_comparisonContext)

+ func (s *BaseSQLiteParserListener) EnterExpr_function(ctx *Expr_functionContext)

+ func (s *BaseSQLiteParserListener) EnterExpr_in_select(ctx *Expr_in_selectContext)

+ func (s *BaseSQLiteParserListener) EnterExpr_list(ctx *Expr_listContext)

+ func (s *BaseSQLiteParserListener) EnterExpr_literal(ctx *Expr_literalContext)

+ func (s *BaseSQLiteParserListener) EnterExpr_math_op(ctx *Expr_math_opContext)

+ func (s *BaseSQLiteParserListener) EnterExpr_null_comp(ctx *Expr_null_compContext)

+ func (s *BaseSQLiteParserListener) EnterExpr_qualified_column_name(ctx *Expr_qualified_column_nameContext)

+ func (s *BaseSQLiteParserListener) EnterExpr_raise(ctx *Expr_raiseContext)

+ func (s *BaseSQLiteParserListener) EnterExpr_unary(ctx *Expr_unaryContext)

+ func (s *BaseSQLiteParserListener) EnterFactored_select_stmt(ctx *Factored_select_stmtContext)

+ func (s *BaseSQLiteParserListener) EnterFilename(ctx *FilenameContext)

+ func (s *BaseSQLiteParserListener) EnterFilter_clause(ctx *Filter_clauseContext)

+ func (s *BaseSQLiteParserListener) EnterForeign_key_clause(ctx *Foreign_key_clauseContext)

+ func (s *BaseSQLiteParserListener) EnterForeign_table(ctx *Foreign_tableContext)

+ func (s *BaseSQLiteParserListener) EnterFrame_clause(ctx *Frame_clauseContext)

+ func (s *BaseSQLiteParserListener) EnterFrame_left(ctx *Frame_leftContext)

+ func (s *BaseSQLiteParserListener) EnterFrame_right(ctx *Frame_rightContext)

+ func (s *BaseSQLiteParserListener) EnterFrame_single(ctx *Frame_singleContext)

+ func (s *BaseSQLiteParserListener) EnterFrame_spec(ctx *Frame_specContext)

+ func (s *BaseSQLiteParserListener) EnterFunction_name(ctx *Function_nameContext)

+ func (s *BaseSQLiteParserListener) EnterIndex_name(ctx *Index_nameContext)

+ func (s *BaseSQLiteParserListener) EnterIndexed_column(ctx *Indexed_columnContext)

+ func (s *BaseSQLiteParserListener) EnterInitial_select(ctx *Initial_selectContext)

+ func (s *BaseSQLiteParserListener) EnterInsert_stmt(ctx *Insert_stmtContext)

+ func (s *BaseSQLiteParserListener) EnterJoin_clause(ctx *Join_clauseContext)

+ func (s *BaseSQLiteParserListener) EnterJoin_constraint(ctx *Join_constraintContext)

+ func (s *BaseSQLiteParserListener) EnterJoin_operator(ctx *Join_operatorContext)

+ func (s *BaseSQLiteParserListener) EnterKeyword(ctx *KeywordContext)

+ func (s *BaseSQLiteParserListener) EnterLimit_stmt(ctx *Limit_stmtContext)

+ func (s *BaseSQLiteParserListener) EnterLiteral_value(ctx *Literal_valueContext)

+ func (s *BaseSQLiteParserListener) EnterModule_argument(ctx *Module_argumentContext)

+ func (s *BaseSQLiteParserListener) EnterModule_name(ctx *Module_nameContext)

+ func (s *BaseSQLiteParserListener) EnterName(ctx *NameContext)

+ func (s *BaseSQLiteParserListener) EnterNew_table_name(ctx *New_table_nameContext)

+ func (s *BaseSQLiteParserListener) EnterOf_OF_fset(ctx *Of_OF_fsetContext)

+ func (s *BaseSQLiteParserListener) EnterOrder_by_expr(ctx *Order_by_exprContext)

+ func (s *BaseSQLiteParserListener) EnterOrder_by_expr_asc_desc(ctx *Order_by_expr_asc_descContext)

+ func (s *BaseSQLiteParserListener) EnterOrder_by_stmt(ctx *Order_by_stmtContext)

+ func (s *BaseSQLiteParserListener) EnterOrdering_term(ctx *Ordering_termContext)

+ func (s *BaseSQLiteParserListener) EnterOver_clause(ctx *Over_clauseContext)

+ func (s *BaseSQLiteParserListener) EnterParse(ctx *ParseContext)

+ func (s *BaseSQLiteParserListener) EnterPartition_by(ctx *Partition_byContext)

+ func (s *BaseSQLiteParserListener) EnterPragma_name(ctx *Pragma_nameContext)

+ func (s *BaseSQLiteParserListener) EnterPragma_stmt(ctx *Pragma_stmtContext)

+ func (s *BaseSQLiteParserListener) EnterPragma_value(ctx *Pragma_valueContext)

+ func (s *BaseSQLiteParserListener) EnterQualified_table_name(ctx *Qualified_table_nameContext)

+ func (s *BaseSQLiteParserListener) EnterRaise_function(ctx *Raise_functionContext)

+ func (s *BaseSQLiteParserListener) EnterRecursive__select(ctx *Recursive__selectContext)

+ func (s *BaseSQLiteParserListener) EnterRecursive_cte(ctx *Recursive_cteContext)

+ func (s *BaseSQLiteParserListener) EnterReindex_stmt(ctx *Reindex_stmtContext)

+ func (s *BaseSQLiteParserListener) EnterRelease_stmt(ctx *Release_stmtContext)

+ func (s *BaseSQLiteParserListener) EnterResult_column(ctx *Result_columnContext)

+ func (s *BaseSQLiteParserListener) EnterRollback_stmt(ctx *Rollback_stmtContext)

+ func (s *BaseSQLiteParserListener) EnterSavepoint_name(ctx *Savepoint_nameContext)

+ func (s *BaseSQLiteParserListener) EnterSavepoint_stmt(ctx *Savepoint_stmtContext)

+ func (s *BaseSQLiteParserListener) EnterSchema_name(ctx *Schema_nameContext)

+ func (s *BaseSQLiteParserListener) EnterSelect_core(ctx *Select_coreContext)

+ func (s *BaseSQLiteParserListener) EnterSelect_stmt(ctx *Select_stmtContext)

+ func (s *BaseSQLiteParserListener) EnterSigned_number(ctx *Signed_numberContext)

+ func (s *BaseSQLiteParserListener) EnterSimple_func(ctx *Simple_funcContext)

+ func (s *BaseSQLiteParserListener) EnterSimple_function_invocation(ctx *Simple_function_invocationContext)

+ func (s *BaseSQLiteParserListener) EnterSimple_select_stmt(ctx *Simple_select_stmtContext)

+ func (s *BaseSQLiteParserListener) EnterSql_stmt(ctx *Sql_stmtContext)

+ func (s *BaseSQLiteParserListener) EnterSql_stmt_list(ctx *Sql_stmt_listContext)

+ func (s *BaseSQLiteParserListener) EnterTable_alias(ctx *Table_aliasContext)

+ func (s *BaseSQLiteParserListener) EnterTable_constraint(ctx *Table_constraintContext)

+ func (s *BaseSQLiteParserListener) EnterTable_function_name(ctx *Table_function_nameContext)

+ func (s *BaseSQLiteParserListener) EnterTable_name(ctx *Table_nameContext)

+ func (s *BaseSQLiteParserListener) EnterTable_or_index_name(ctx *Table_or_index_nameContext)

+ func (s *BaseSQLiteParserListener) EnterTable_or_subquery(ctx *Table_or_subqueryContext)

+ func (s *BaseSQLiteParserListener) EnterTransaction_name(ctx *Transaction_nameContext)

+ func (s *BaseSQLiteParserListener) EnterTrigger_name(ctx *Trigger_nameContext)

+ func (s *BaseSQLiteParserListener) EnterType_name(ctx *Type_nameContext)

+ func (s *BaseSQLiteParserListener) EnterUnary_operator(ctx *Unary_operatorContext)

+ func (s *BaseSQLiteParserListener) EnterUpdate_stmt(ctx *Update_stmtContext)

+ func (s *BaseSQLiteParserListener) EnterUpdate_stmt_limited(ctx *Update_stmt_limitedContext)

+ func (s *BaseSQLiteParserListener) EnterUpsert_clause(ctx *Upsert_clauseContext)

+ func (s *BaseSQLiteParserListener) EnterVacuum_stmt(ctx *Vacuum_stmtContext)

+ func (s *BaseSQLiteParserListener) EnterView_name(ctx *View_nameContext)

+ func (s *BaseSQLiteParserListener) EnterWindow_defn(ctx *Window_defnContext)

+ func (s *BaseSQLiteParserListener) EnterWindow_function(ctx *Window_functionContext)

+ func (s *BaseSQLiteParserListener) EnterWindow_function_invocation(ctx *Window_function_invocationContext)

+ func (s *BaseSQLiteParserListener) EnterWindow_name(ctx *Window_nameContext)

+ func (s *BaseSQLiteParserListener) EnterWith_clause(ctx *With_clauseContext)

+ func (s *BaseSQLiteParserListener) ExitAggregate_func(ctx *Aggregate_funcContext)

+ func (s *BaseSQLiteParserListener) ExitAggregate_function_invocation(ctx *Aggregate_function_invocationContext)

+ func (s *BaseSQLiteParserListener) ExitAlias(ctx *AliasContext)

+ func (s *BaseSQLiteParserListener) ExitAlter_table_stmt(ctx *Alter_table_stmtContext)

+ func (s *BaseSQLiteParserListener) ExitAnalyze_stmt(ctx *Analyze_stmtContext)

+ func (s *BaseSQLiteParserListener) ExitAny_name(ctx *Any_nameContext)

+ func (s *BaseSQLiteParserListener) ExitAsc_desc(ctx *Asc_descContext)

+ func (s *BaseSQLiteParserListener) ExitAttach_stmt(ctx *Attach_stmtContext)

+ func (s *BaseSQLiteParserListener) ExitBase_window_name(ctx *Base_window_nameContext)

+ func (s *BaseSQLiteParserListener) ExitBegin_stmt(ctx *Begin_stmtContext)

+ func (s *BaseSQLiteParserListener) ExitCollation_name(ctx *Collation_nameContext)

+ func (s *BaseSQLiteParserListener) ExitColumn_alias(ctx *Column_aliasContext)

+ func (s *BaseSQLiteParserListener) ExitColumn_constraint(ctx *Column_constraintContext)

+ func (s *BaseSQLiteParserListener) ExitColumn_def(ctx *Column_defContext)

+ func (s *BaseSQLiteParserListener) ExitColumn_name(ctx *Column_nameContext)

+ func (s *BaseSQLiteParserListener) ExitColumn_name_list(ctx *Column_name_listContext)

+ func (s *BaseSQLiteParserListener) ExitCommit_stmt(ctx *Commit_stmtContext)

+ func (s *BaseSQLiteParserListener) ExitCommon_table_expression(ctx *Common_table_expressionContext)

+ func (s *BaseSQLiteParserListener) ExitCommon_table_stmt(ctx *Common_table_stmtContext)

+ func (s *BaseSQLiteParserListener) ExitCompound_operator(ctx *Compound_operatorContext)

+ func (s *BaseSQLiteParserListener) ExitCompound_select_stmt(ctx *Compound_select_stmtContext)

+ func (s *BaseSQLiteParserListener) ExitConflict_clause(ctx *Conflict_clauseContext)

+ func (s *BaseSQLiteParserListener) ExitCreate_index_stmt(ctx *Create_index_stmtContext)

+ func (s *BaseSQLiteParserListener) ExitCreate_table_stmt(ctx *Create_table_stmtContext)

+ func (s *BaseSQLiteParserListener) ExitCreate_trigger_stmt(ctx *Create_trigger_stmtContext)

+ func (s *BaseSQLiteParserListener) ExitCreate_view_stmt(ctx *Create_view_stmtContext)

+ func (s *BaseSQLiteParserListener) ExitCreate_virtual_table_stmt(ctx *Create_virtual_table_stmtContext)

+ func (s *BaseSQLiteParserListener) ExitCte_table_name(ctx *Cte_table_nameContext)

+ func (s *BaseSQLiteParserListener) ExitDefault_DEFAULT__value(ctx *Default_DEFAULT__valueContext)

+ func (s *BaseSQLiteParserListener) ExitDelete_stmt(ctx *Delete_stmtContext)

+ func (s *BaseSQLiteParserListener) ExitDelete_stmt_limited(ctx *Delete_stmt_limitedContext)

+ func (s *BaseSQLiteParserListener) ExitDetach_stmt(ctx *Detach_stmtContext)

+ func (s *BaseSQLiteParserListener) ExitDrop_stmt(ctx *Drop_stmtContext)

+ func (s *BaseSQLiteParserListener) ExitError_message(ctx *Error_messageContext)

+ func (s *BaseSQLiteParserListener) ExitEveryRule(ctx antlr.ParserRuleContext)

+ func (s *BaseSQLiteParserListener) ExitExpr_asc_desc(ctx *Expr_asc_descContext)

+ func (s *BaseSQLiteParserListener) ExitExpr_between(ctx *Expr_betweenContext)

+ func (s *BaseSQLiteParserListener) ExitExpr_binary(ctx *Expr_binaryContext)

+ func (s *BaseSQLiteParserListener) ExitExpr_bind(ctx *Expr_bindContext)

+ func (s *BaseSQLiteParserListener) ExitExpr_case(ctx *Expr_caseContext)

+ func (s *BaseSQLiteParserListener) ExitExpr_cast(ctx *Expr_castContext)

+ func (s *BaseSQLiteParserListener) ExitExpr_collate(ctx *Expr_collateContext)

+ func (s *BaseSQLiteParserListener) ExitExpr_comparison(ctx *Expr_comparisonContext)

+ func (s *BaseSQLiteParserListener) ExitExpr_function(ctx *Expr_functionContext)

+ func (s *BaseSQLiteParserListener) ExitExpr_in_select(ctx *Expr_in_selectContext)

+ func (s *BaseSQLiteParserListener) ExitExpr_list(ctx *Expr_listContext)

+ func (s *BaseSQLiteParserListener) ExitExpr_literal(ctx *Expr_literalContext)

+ func (s *BaseSQLiteParserListener) ExitExpr_math_op(ctx *Expr_math_opContext)

+ func (s *BaseSQLiteParserListener) ExitExpr_null_comp(ctx *Expr_null_compContext)

+ func (s *BaseSQLiteParserListener) ExitExpr_qualified_column_name(ctx *Expr_qualified_column_nameContext)

+ func (s *BaseSQLiteParserListener) ExitExpr_raise(ctx *Expr_raiseContext)

+ func (s *BaseSQLiteParserListener) ExitExpr_unary(ctx *Expr_unaryContext)

+ func (s *BaseSQLiteParserListener) ExitFactored_select_stmt(ctx *Factored_select_stmtContext)

+ func (s *BaseSQLiteParserListener) ExitFilename(ctx *FilenameContext)

+ func (s *BaseSQLiteParserListener) ExitFilter_clause(ctx *Filter_clauseContext)

+ func (s *BaseSQLiteParserListener) ExitForeign_key_clause(ctx *Foreign_key_clauseContext)

+ func (s *BaseSQLiteParserListener) ExitForeign_table(ctx *Foreign_tableContext)

+ func (s *BaseSQLiteParserListener) ExitFrame_clause(ctx *Frame_clauseContext)

+ func (s *BaseSQLiteParserListener) ExitFrame_left(ctx *Frame_leftContext)

+ func (s *BaseSQLiteParserListener) ExitFrame_right(ctx *Frame_rightContext)

+ func (s *BaseSQLiteParserListener) ExitFrame_single(ctx *Frame_singleContext)

+ func (s *BaseSQLiteParserListener) ExitFrame_spec(ctx *Frame_specContext)

+ func (s *BaseSQLiteParserListener) ExitFunction_name(ctx *Function_nameContext)

+ func (s *BaseSQLiteParserListener) ExitIndex_name(ctx *Index_nameContext)

+ func (s *BaseSQLiteParserListener) ExitIndexed_column(ctx *Indexed_columnContext)

+ func (s *BaseSQLiteParserListener) ExitInitial_select(ctx *Initial_selectContext)

+ func (s *BaseSQLiteParserListener) ExitInsert_stmt(ctx *Insert_stmtContext)

+ func (s *BaseSQLiteParserListener) ExitJoin_clause(ctx *Join_clauseContext)

+ func (s *BaseSQLiteParserListener) ExitJoin_constraint(ctx *Join_constraintContext)

+ func (s *BaseSQLiteParserListener) ExitJoin_operator(ctx *Join_operatorContext)

+ func (s *BaseSQLiteParserListener) ExitKeyword(ctx *KeywordContext)

+ func (s *BaseSQLiteParserListener) ExitLimit_stmt(ctx *Limit_stmtContext)

+ func (s *BaseSQLiteParserListener) ExitLiteral_value(ctx *Literal_valueContext)

+ func (s *BaseSQLiteParserListener) ExitModule_argument(ctx *Module_argumentContext)

+ func (s *BaseSQLiteParserListener) ExitModule_name(ctx *Module_nameContext)

+ func (s *BaseSQLiteParserListener) ExitName(ctx *NameContext)

+ func (s *BaseSQLiteParserListener) ExitNew_table_name(ctx *New_table_nameContext)

+ func (s *BaseSQLiteParserListener) ExitOf_OF_fset(ctx *Of_OF_fsetContext)

+ func (s *BaseSQLiteParserListener) ExitOrder_by_expr(ctx *Order_by_exprContext)

+ func (s *BaseSQLiteParserListener) ExitOrder_by_expr_asc_desc(ctx *Order_by_expr_asc_descContext)

+ func (s *BaseSQLiteParserListener) ExitOrder_by_stmt(ctx *Order_by_stmtContext)

+ func (s *BaseSQLiteParserListener) ExitOrdering_term(ctx *Ordering_termContext)

+ func (s *BaseSQLiteParserListener) ExitOver_clause(ctx *Over_clauseContext)

+ func (s *BaseSQLiteParserListener) ExitParse(ctx *ParseContext)

+ func (s *BaseSQLiteParserListener) ExitPartition_by(ctx *Partition_byContext)

+ func (s *BaseSQLiteParserListener) ExitPragma_name(ctx *Pragma_nameContext)

+ func (s *BaseSQLiteParserListener) ExitPragma_stmt(ctx *Pragma_stmtContext)

+ func (s *BaseSQLiteParserListener) ExitPragma_value(ctx *Pragma_valueContext)

+ func (s *BaseSQLiteParserListener) ExitQualified_table_name(ctx *Qualified_table_nameContext)

+ func (s *BaseSQLiteParserListener) ExitRaise_function(ctx *Raise_functionContext)

+ func (s *BaseSQLiteParserListener) ExitRecursive__select(ctx *Recursive__selectContext)

+ func (s *BaseSQLiteParserListener) ExitRecursive_cte(ctx *Recursive_cteContext)

+ func (s *BaseSQLiteParserListener) ExitReindex_stmt(ctx *Reindex_stmtContext)

+ func (s *BaseSQLiteParserListener) ExitRelease_stmt(ctx *Release_stmtContext)

+ func (s *BaseSQLiteParserListener) ExitResult_column(ctx *Result_columnContext)

+ func (s *BaseSQLiteParserListener) ExitRollback_stmt(ctx *Rollback_stmtContext)

+ func (s *BaseSQLiteParserListener) ExitSavepoint_name(ctx *Savepoint_nameContext)

+ func (s *BaseSQLiteParserListener) ExitSavepoint_stmt(ctx *Savepoint_stmtContext)

+ func (s *BaseSQLiteParserListener) ExitSchema_name(ctx *Schema_nameContext)

+ func (s *BaseSQLiteParserListener) ExitSelect_core(ctx *Select_coreContext)

+ func (s *BaseSQLiteParserListener) ExitSelect_stmt(ctx *Select_stmtContext)

+ func (s *BaseSQLiteParserListener) ExitSigned_number(ctx *Signed_numberContext)

+ func (s *BaseSQLiteParserListener) ExitSimple_func(ctx *Simple_funcContext)

+ func (s *BaseSQLiteParserListener) ExitSimple_function_invocation(ctx *Simple_function_invocationContext)

+ func (s *BaseSQLiteParserListener) ExitSimple_select_stmt(ctx *Simple_select_stmtContext)

+ func (s *BaseSQLiteParserListener) ExitSql_stmt(ctx *Sql_stmtContext)

+ func (s *BaseSQLiteParserListener) ExitSql_stmt_list(ctx *Sql_stmt_listContext)

+ func (s *BaseSQLiteParserListener) ExitTable_alias(ctx *Table_aliasContext)

+ func (s *BaseSQLiteParserListener) ExitTable_constraint(ctx *Table_constraintContext)

+ func (s *BaseSQLiteParserListener) ExitTable_function_name(ctx *Table_function_nameContext)

+ func (s *BaseSQLiteParserListener) ExitTable_name(ctx *Table_nameContext)

+ func (s *BaseSQLiteParserListener) ExitTable_or_index_name(ctx *Table_or_index_nameContext)

+ func (s *BaseSQLiteParserListener) ExitTable_or_subquery(ctx *Table_or_subqueryContext)

+ func (s *BaseSQLiteParserListener) ExitTransaction_name(ctx *Transaction_nameContext)

+ func (s *BaseSQLiteParserListener) ExitTrigger_name(ctx *Trigger_nameContext)

+ func (s *BaseSQLiteParserListener) ExitType_name(ctx *Type_nameContext)

+ func (s *BaseSQLiteParserListener) ExitUnary_operator(ctx *Unary_operatorContext)

+ func (s *BaseSQLiteParserListener) ExitUpdate_stmt(ctx *Update_stmtContext)

+ func (s *BaseSQLiteParserListener) ExitUpdate_stmt_limited(ctx *Update_stmt_limitedContext)

+ func (s *BaseSQLiteParserListener) ExitUpsert_clause(ctx *Upsert_clauseContext)

+ func (s *BaseSQLiteParserListener) ExitVacuum_stmt(ctx *Vacuum_stmtContext)

+ func (s *BaseSQLiteParserListener) ExitView_name(ctx *View_nameContext)

+ func (s *BaseSQLiteParserListener) ExitWindow_defn(ctx *Window_defnContext)

+ func (s *BaseSQLiteParserListener) ExitWindow_function(ctx *Window_functionContext)

+ func (s *BaseSQLiteParserListener) ExitWindow_function_invocation(ctx *Window_function_invocationContext)

+ func (s *BaseSQLiteParserListener) ExitWindow_name(ctx *Window_nameContext)

+ func (s *BaseSQLiteParserListener) ExitWith_clause(ctx *With_clauseContext)

+ func (s *BaseSQLiteParserListener) VisitErrorNode(node antlr.ErrorNode)

+ func (s *BaseSQLiteParserListener) VisitTerminal(node antlr.TerminalNode)

+ type Base_window_nameContext struct

+ func NewBase_window_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Base_window_nameContext

+ func NewEmptyBase_window_nameContext() *Base_window_nameContext

+ func (*Base_window_nameContext) IsBase_window_nameContext()

+ func (s *Base_window_nameContext) Any_name() IAny_nameContext

+ func (s *Base_window_nameContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Base_window_nameContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Base_window_nameContext) GetParser() antlr.Parser

+ func (s *Base_window_nameContext) GetRuleContext() antlr.RuleContext

+ func (s *Base_window_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Begin_stmtContext

+ func (s *Begin_stmtContext) BEGIN_() antlr.TerminalNode

+ func (s *Begin_stmtContext) DEFERRED_() antlr.TerminalNode

+ func (s *Begin_stmtContext) EXCLUSIVE_() antlr.TerminalNode

+ func (s *Begin_stmtContext) IMMEDIATE_() antlr.TerminalNode

+ func (s *Begin_stmtContext) TRANSACTION_() antlr.TerminalNode

type Column_constraintContext

+ func (s *Column_constraintContext) ALWAYS_() antlr.TerminalNode

+ func (s *Column_constraintContext) AS_() antlr.TerminalNode

+ func (s *Column_constraintContext) AUTOINCREMENT_() antlr.TerminalNode

+ func (s *Column_constraintContext) Asc_desc() IAsc_descContext

+ func (s *Column_constraintContext) CHECK_() antlr.TerminalNode

+ func (s *Column_constraintContext) COLLATE_() antlr.TerminalNode

+ func (s *Column_constraintContext) CONSTRAINT_() antlr.TerminalNode

+ func (s *Column_constraintContext) DEFAULT_() antlr.TerminalNode

+ func (s *Column_constraintContext) GENERATED_() antlr.TerminalNode

+ func (s *Column_constraintContext) KEY_() antlr.TerminalNode

+ func (s *Column_constraintContext) NOT_() antlr.TerminalNode

+ func (s *Column_constraintContext) NULL_() antlr.TerminalNode

+ func (s *Column_constraintContext) PRIMARY_() antlr.TerminalNode

+ func (s *Column_constraintContext) STORED_() antlr.TerminalNode

+ func (s *Column_constraintContext) UNIQUE_() antlr.TerminalNode

+ func (s *Column_constraintContext) VIRTUAL_() antlr.TerminalNode

+ type Column_name_listContext struct

+ func NewColumn_name_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Column_name_listContext

+ func NewEmptyColumn_name_listContext() *Column_name_listContext

+ func (*Column_name_listContext) IsColumn_name_listContext()

+ func (s *Column_name_listContext) AllCOMMA() []antlr.TerminalNode

+ func (s *Column_name_listContext) AllColumn_name() []IColumn_nameContext

+ func (s *Column_name_listContext) CLOSE_PAR() antlr.TerminalNode

+ func (s *Column_name_listContext) COMMA(i int) antlr.TerminalNode

+ func (s *Column_name_listContext) Column_name(i int) IColumn_nameContext

+ func (s *Column_name_listContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Column_name_listContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Column_name_listContext) GetParser() antlr.Parser

+ func (s *Column_name_listContext) GetRuleContext() antlr.RuleContext

+ func (s *Column_name_listContext) OPEN_PAR() antlr.TerminalNode

+ func (s *Column_name_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Commit_stmtContext

+ func (s *Commit_stmtContext) COMMIT_() antlr.TerminalNode

+ func (s *Commit_stmtContext) END_() antlr.TerminalNode

+ func (s *Commit_stmtContext) TRANSACTION_() antlr.TerminalNode

type Common_table_expressionContext

+ func (s *Common_table_expressionContext) AS_() antlr.TerminalNode

+ type Common_table_stmtContext struct

+ func NewCommon_table_stmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Common_table_stmtContext

+ func NewEmptyCommon_table_stmtContext() *Common_table_stmtContext

+ func (*Common_table_stmtContext) IsCommon_table_stmtContext()

+ func (s *Common_table_stmtContext) AllCOMMA() []antlr.TerminalNode

+ func (s *Common_table_stmtContext) AllCommon_table_expression() []ICommon_table_expressionContext

+ func (s *Common_table_stmtContext) COMMA(i int) antlr.TerminalNode

+ func (s *Common_table_stmtContext) Common_table_expression(i int) ICommon_table_expressionContext

+ func (s *Common_table_stmtContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Common_table_stmtContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Common_table_stmtContext) GetParser() antlr.Parser

+ func (s *Common_table_stmtContext) GetRuleContext() antlr.RuleContext

+ func (s *Common_table_stmtContext) RECURSIVE_() antlr.TerminalNode

+ func (s *Common_table_stmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ func (s *Common_table_stmtContext) WITH_() antlr.TerminalNode

type Compound_operatorContext

+ func (s *Compound_operatorContext) ALL_() antlr.TerminalNode

+ func (s *Compound_operatorContext) EXCEPT_() antlr.TerminalNode

+ func (s *Compound_operatorContext) INTERSECT_() antlr.TerminalNode

+ func (s *Compound_operatorContext) UNION_() antlr.TerminalNode

type Compound_select_stmtContext

+ func (s *Compound_select_stmtContext) ALL_(i int) antlr.TerminalNode

+ func (s *Compound_select_stmtContext) AllALL_() []antlr.TerminalNode

+ func (s *Compound_select_stmtContext) AllEXCEPT_() []antlr.TerminalNode

+ func (s *Compound_select_stmtContext) AllINTERSECT_() []antlr.TerminalNode

+ func (s *Compound_select_stmtContext) AllUNION_() []antlr.TerminalNode

+ func (s *Compound_select_stmtContext) Common_table_stmt() ICommon_table_stmtContext

+ func (s *Compound_select_stmtContext) EXCEPT_(i int) antlr.TerminalNode

+ func (s *Compound_select_stmtContext) INTERSECT_(i int) antlr.TerminalNode

+ func (s *Compound_select_stmtContext) Limit_stmt() ILimit_stmtContext

+ func (s *Compound_select_stmtContext) Order_by_stmt() IOrder_by_stmtContext

+ func (s *Compound_select_stmtContext) UNION_(i int) antlr.TerminalNode

type Conflict_clauseContext

+ func (s *Conflict_clauseContext) ABORT_() antlr.TerminalNode

+ func (s *Conflict_clauseContext) CONFLICT_() antlr.TerminalNode

+ func (s *Conflict_clauseContext) FAIL_() antlr.TerminalNode

+ func (s *Conflict_clauseContext) IGNORE_() antlr.TerminalNode

+ func (s *Conflict_clauseContext) ON_() antlr.TerminalNode

+ func (s *Conflict_clauseContext) REPLACE_() antlr.TerminalNode

+ func (s *Conflict_clauseContext) ROLLBACK_() antlr.TerminalNode

type Create_index_stmtContext

+ func (s *Create_index_stmtContext) CREATE_() antlr.TerminalNode

+ func (s *Create_index_stmtContext) EXISTS_() antlr.TerminalNode

+ func (s *Create_index_stmtContext) IF_() antlr.TerminalNode

+ func (s *Create_index_stmtContext) INDEX_() antlr.TerminalNode

+ func (s *Create_index_stmtContext) NOT_() antlr.TerminalNode

+ func (s *Create_index_stmtContext) ON_() antlr.TerminalNode

+ func (s *Create_index_stmtContext) Schema_name() ISchema_nameContext

+ func (s *Create_index_stmtContext) UNIQUE_() antlr.TerminalNode

+ func (s *Create_index_stmtContext) WHERE_() antlr.TerminalNode

type Create_table_stmtContext

+ func (s *Create_table_stmtContext) AS_() antlr.TerminalNode

+ func (s *Create_table_stmtContext) CREATE_() antlr.TerminalNode

+ func (s *Create_table_stmtContext) EXISTS_() antlr.TerminalNode

+ func (s *Create_table_stmtContext) GetRow_ROW_ID() antlr.Token

+ func (s *Create_table_stmtContext) IF_() antlr.TerminalNode

+ func (s *Create_table_stmtContext) NOT_() antlr.TerminalNode

+ func (s *Create_table_stmtContext) Schema_name() ISchema_nameContext

+ func (s *Create_table_stmtContext) SetRow_ROW_ID(v antlr.Token)

+ func (s *Create_table_stmtContext) TABLE_() antlr.TerminalNode

+ func (s *Create_table_stmtContext) TEMPORARY_() antlr.TerminalNode

+ func (s *Create_table_stmtContext) TEMP_() antlr.TerminalNode

+ func (s *Create_table_stmtContext) WITHOUT_() antlr.TerminalNode

type Create_trigger_stmtContext

+ func (s *Create_trigger_stmtContext) AFTER_() antlr.TerminalNode

+ func (s *Create_trigger_stmtContext) AllOF_() []antlr.TerminalNode

+ func (s *Create_trigger_stmtContext) BEFORE_() antlr.TerminalNode

+ func (s *Create_trigger_stmtContext) BEGIN_() antlr.TerminalNode

+ func (s *Create_trigger_stmtContext) CREATE_() antlr.TerminalNode

+ func (s *Create_trigger_stmtContext) DELETE_() antlr.TerminalNode

+ func (s *Create_trigger_stmtContext) EACH_() antlr.TerminalNode

+ func (s *Create_trigger_stmtContext) END_() antlr.TerminalNode

+ func (s *Create_trigger_stmtContext) EXISTS_() antlr.TerminalNode

+ func (s *Create_trigger_stmtContext) FOR_() antlr.TerminalNode

+ func (s *Create_trigger_stmtContext) IF_() antlr.TerminalNode

+ func (s *Create_trigger_stmtContext) INSERT_() antlr.TerminalNode

+ func (s *Create_trigger_stmtContext) INSTEAD_() antlr.TerminalNode

+ func (s *Create_trigger_stmtContext) NOT_() antlr.TerminalNode

+ func (s *Create_trigger_stmtContext) OF_(i int) antlr.TerminalNode

+ func (s *Create_trigger_stmtContext) ON_() antlr.TerminalNode

+ func (s *Create_trigger_stmtContext) ROW_() antlr.TerminalNode

+ func (s *Create_trigger_stmtContext) Schema_name() ISchema_nameContext

+ func (s *Create_trigger_stmtContext) TEMPORARY_() antlr.TerminalNode

+ func (s *Create_trigger_stmtContext) TEMP_() antlr.TerminalNode

+ func (s *Create_trigger_stmtContext) TRIGGER_() antlr.TerminalNode

+ func (s *Create_trigger_stmtContext) UPDATE_() antlr.TerminalNode

+ func (s *Create_trigger_stmtContext) WHEN_() antlr.TerminalNode

type Create_view_stmtContext

+ func (s *Create_view_stmtContext) AS_() antlr.TerminalNode

+ func (s *Create_view_stmtContext) AllCOMMA() []antlr.TerminalNode

+ func (s *Create_view_stmtContext) AllColumn_name() []IColumn_nameContext

+ func (s *Create_view_stmtContext) CLOSE_PAR() antlr.TerminalNode

+ func (s *Create_view_stmtContext) COMMA(i int) antlr.TerminalNode

+ func (s *Create_view_stmtContext) CREATE_() antlr.TerminalNode

+ func (s *Create_view_stmtContext) Column_name(i int) IColumn_nameContext

+ func (s *Create_view_stmtContext) EXISTS_() antlr.TerminalNode

+ func (s *Create_view_stmtContext) IF_() antlr.TerminalNode

+ func (s *Create_view_stmtContext) NOT_() antlr.TerminalNode

+ func (s *Create_view_stmtContext) OPEN_PAR() antlr.TerminalNode

+ func (s *Create_view_stmtContext) Schema_name() ISchema_nameContext

+ func (s *Create_view_stmtContext) TEMPORARY_() antlr.TerminalNode

+ func (s *Create_view_stmtContext) TEMP_() antlr.TerminalNode

+ func (s *Create_view_stmtContext) VIEW_() antlr.TerminalNode

type Create_virtual_table_stmtContext

+ func (s *Create_virtual_table_stmtContext) CREATE_() antlr.TerminalNode

+ func (s *Create_virtual_table_stmtContext) EXISTS_() antlr.TerminalNode

+ func (s *Create_virtual_table_stmtContext) IF_() antlr.TerminalNode

+ func (s *Create_virtual_table_stmtContext) NOT_() antlr.TerminalNode

+ func (s *Create_virtual_table_stmtContext) Schema_name() ISchema_nameContext

+ func (s *Create_virtual_table_stmtContext) TABLE_() antlr.TerminalNode

+ func (s *Create_virtual_table_stmtContext) USING_() antlr.TerminalNode

+ func (s *Create_virtual_table_stmtContext) VIRTUAL_() antlr.TerminalNode

+ type Cte_table_nameContext struct

+ func NewCte_table_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Cte_table_nameContext

+ func NewEmptyCte_table_nameContext() *Cte_table_nameContext

+ func (*Cte_table_nameContext) IsCte_table_nameContext()

+ func (s *Cte_table_nameContext) AllCOMMA() []antlr.TerminalNode

+ func (s *Cte_table_nameContext) AllColumn_name() []IColumn_nameContext

+ func (s *Cte_table_nameContext) CLOSE_PAR() antlr.TerminalNode

+ func (s *Cte_table_nameContext) COMMA(i int) antlr.TerminalNode

+ func (s *Cte_table_nameContext) Column_name(i int) IColumn_nameContext

+ func (s *Cte_table_nameContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Cte_table_nameContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Cte_table_nameContext) GetParser() antlr.Parser

+ func (s *Cte_table_nameContext) GetRuleContext() antlr.RuleContext

+ func (s *Cte_table_nameContext) OPEN_PAR() antlr.TerminalNode

+ func (s *Cte_table_nameContext) Table_name() ITable_nameContext

+ func (s *Cte_table_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type Default_DEFAULT__valueContext struct

+ func NewDefault_DEFAULT__valueContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Default_DEFAULT__valueContext

+ func NewEmptyDefault_DEFAULT__valueContext() *Default_DEFAULT__valueContext

+ func (*Default_DEFAULT__valueContext) IsDefault_DEFAULT__valueContext()

+ func (s *Default_DEFAULT__valueContext) COMMA() antlr.TerminalNode

+ func (s *Default_DEFAULT__valueContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Default_DEFAULT__valueContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Default_DEFAULT__valueContext) GetParser() antlr.Parser

+ func (s *Default_DEFAULT__valueContext) GetRuleContext() antlr.RuleContext

+ func (s *Default_DEFAULT__valueContext) Signed_number() ISigned_numberContext

+ func (s *Default_DEFAULT__valueContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Delete_stmtContext

+ func (s *Delete_stmtContext) DELETE_() antlr.TerminalNode

+ func (s *Delete_stmtContext) FROM_() antlr.TerminalNode

+ func (s *Delete_stmtContext) WHERE_() antlr.TerminalNode

type Delete_stmt_limitedContext

+ func (s *Delete_stmt_limitedContext) DELETE_() antlr.TerminalNode

+ func (s *Delete_stmt_limitedContext) FROM_() antlr.TerminalNode

+ func (s *Delete_stmt_limitedContext) Limit_stmt() ILimit_stmtContext

+ func (s *Delete_stmt_limitedContext) Order_by_stmt() IOrder_by_stmtContext

+ func (s *Delete_stmt_limitedContext) WHERE_() antlr.TerminalNode

type Detach_stmtContext

+ func (s *Detach_stmtContext) DATABASE_() antlr.TerminalNode

+ func (s *Detach_stmtContext) DETACH_() antlr.TerminalNode

+ func (s *Detach_stmtContext) Schema_name() ISchema_nameContext

+ type Drop_stmtContext struct

+ func NewDrop_stmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_stmtContext

+ func NewEmptyDrop_stmtContext() *Drop_stmtContext

+ func (*Drop_stmtContext) IsDrop_stmtContext()

+ func (s *Drop_stmtContext) Any_name() IAny_nameContext

+ func (s *Drop_stmtContext) DOT() antlr.TerminalNode

+ func (s *Drop_stmtContext) DROP_() antlr.TerminalNode

+ func (s *Drop_stmtContext) EXISTS_() antlr.TerminalNode

+ func (s *Drop_stmtContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Drop_stmtContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Drop_stmtContext) GetObject() antlr.Token

+ func (s *Drop_stmtContext) GetParser() antlr.Parser

+ func (s *Drop_stmtContext) GetRuleContext() antlr.RuleContext

+ func (s *Drop_stmtContext) IF_() antlr.TerminalNode

+ func (s *Drop_stmtContext) INDEX_() antlr.TerminalNode

+ func (s *Drop_stmtContext) Schema_name() ISchema_nameContext

+ func (s *Drop_stmtContext) SetObject(v antlr.Token)

+ func (s *Drop_stmtContext) TABLE_() antlr.TerminalNode

+ func (s *Drop_stmtContext) TRIGGER_() antlr.TerminalNode

+ func (s *Drop_stmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ func (s *Drop_stmtContext) VIEW_() antlr.TerminalNode

type ExprContext

+ func (s *ExprContext) CopyFrom(ctx *ExprContext)

+ type Expr_asc_descContext struct

+ func NewEmptyExpr_asc_descContext() *Expr_asc_descContext

+ func NewExpr_asc_descContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Expr_asc_descContext

+ func (*Expr_asc_descContext) IsExpr_asc_descContext()

+ func (s *Expr_asc_descContext) AllAsc_desc() []IAsc_descContext

+ func (s *Expr_asc_descContext) AllCOMMA() []antlr.TerminalNode

+ func (s *Expr_asc_descContext) AllExpr() []IExprContext

+ func (s *Expr_asc_descContext) Asc_desc(i int) IAsc_descContext

+ func (s *Expr_asc_descContext) COMMA(i int) antlr.TerminalNode

+ func (s *Expr_asc_descContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Expr_asc_descContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Expr_asc_descContext) Expr(i int) IExprContext

+ func (s *Expr_asc_descContext) GetParser() antlr.Parser

+ func (s *Expr_asc_descContext) GetRuleContext() antlr.RuleContext

+ func (s *Expr_asc_descContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type Expr_betweenContext struct

+ func NewExpr_betweenContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *Expr_betweenContext

+ func (s *Expr_betweenContext) AND_() antlr.TerminalNode

+ func (s *Expr_betweenContext) AllExpr() []IExprContext

+ func (s *Expr_betweenContext) BETWEEN_() antlr.TerminalNode

+ func (s *Expr_betweenContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Expr_betweenContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Expr_betweenContext) Expr(i int) IExprContext

+ func (s *Expr_betweenContext) GetRuleContext() antlr.RuleContext

+ func (s *Expr_betweenContext) NOT_() antlr.TerminalNode

+ type Expr_binaryContext struct

+ func NewExpr_binaryContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *Expr_binaryContext

+ func (s *Expr_binaryContext) AND_() antlr.TerminalNode

+ func (s *Expr_binaryContext) AllExpr() []IExprContext

+ func (s *Expr_binaryContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Expr_binaryContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Expr_binaryContext) Expr(i int) IExprContext

+ func (s *Expr_binaryContext) GetRuleContext() antlr.RuleContext

+ func (s *Expr_binaryContext) OR_() antlr.TerminalNode

+ func (s *Expr_binaryContext) PIPE2() antlr.TerminalNode

+ type Expr_bindContext struct

+ func NewExpr_bindContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *Expr_bindContext

+ func (s *Expr_bindContext) BIND_PARAMETER() antlr.TerminalNode

+ func (s *Expr_bindContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Expr_bindContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Expr_bindContext) GetRuleContext() antlr.RuleContext

+ type Expr_caseContext struct

+ func NewExpr_caseContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *Expr_caseContext

+ func (s *Expr_caseContext) AllExpr() []IExprContext

+ func (s *Expr_caseContext) AllTHEN_() []antlr.TerminalNode

+ func (s *Expr_caseContext) AllWHEN_() []antlr.TerminalNode

+ func (s *Expr_caseContext) CASE_() antlr.TerminalNode

+ func (s *Expr_caseContext) ELSE_() antlr.TerminalNode

+ func (s *Expr_caseContext) END_() antlr.TerminalNode

+ func (s *Expr_caseContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Expr_caseContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Expr_caseContext) Expr(i int) IExprContext

+ func (s *Expr_caseContext) GetRuleContext() antlr.RuleContext

+ func (s *Expr_caseContext) THEN_(i int) antlr.TerminalNode

+ func (s *Expr_caseContext) WHEN_(i int) antlr.TerminalNode

+ type Expr_castContext struct

+ func NewExpr_castContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *Expr_castContext

+ func (s *Expr_castContext) AS_() antlr.TerminalNode

+ func (s *Expr_castContext) CAST_() antlr.TerminalNode

+ func (s *Expr_castContext) CLOSE_PAR() antlr.TerminalNode

+ func (s *Expr_castContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Expr_castContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Expr_castContext) Expr() IExprContext

+ func (s *Expr_castContext) GetRuleContext() antlr.RuleContext

+ func (s *Expr_castContext) OPEN_PAR() antlr.TerminalNode

+ func (s *Expr_castContext) Type_name() IType_nameContext

+ type Expr_collateContext struct

+ func NewExpr_collateContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *Expr_collateContext

+ func (s *Expr_collateContext) COLLATE_() antlr.TerminalNode

+ func (s *Expr_collateContext) Collation_name() ICollation_nameContext

+ func (s *Expr_collateContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Expr_collateContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Expr_collateContext) Expr() IExprContext

+ func (s *Expr_collateContext) GetRuleContext() antlr.RuleContext

+ type Expr_comparisonContext struct

+ func NewExpr_comparisonContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *Expr_comparisonContext

+ func (s *Expr_comparisonContext) AMP() antlr.TerminalNode

+ func (s *Expr_comparisonContext) ASSIGN() antlr.TerminalNode

+ func (s *Expr_comparisonContext) AllExpr() []IExprContext

+ func (s *Expr_comparisonContext) EQ() antlr.TerminalNode

+ func (s *Expr_comparisonContext) ESCAPE_() antlr.TerminalNode

+ func (s *Expr_comparisonContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Expr_comparisonContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Expr_comparisonContext) Expr(i int) IExprContext

+ func (s *Expr_comparisonContext) GLOB_() antlr.TerminalNode

+ func (s *Expr_comparisonContext) GT() antlr.TerminalNode

+ func (s *Expr_comparisonContext) GT2() antlr.TerminalNode

+ func (s *Expr_comparisonContext) GT_EQ() antlr.TerminalNode

+ func (s *Expr_comparisonContext) GetRuleContext() antlr.RuleContext

+ func (s *Expr_comparisonContext) IN_() antlr.TerminalNode

+ func (s *Expr_comparisonContext) IS_() antlr.TerminalNode

+ func (s *Expr_comparisonContext) LIKE_() antlr.TerminalNode

+ func (s *Expr_comparisonContext) LT() antlr.TerminalNode

+ func (s *Expr_comparisonContext) LT2() antlr.TerminalNode

+ func (s *Expr_comparisonContext) LT_EQ() antlr.TerminalNode

+ func (s *Expr_comparisonContext) MATCH_() antlr.TerminalNode

+ func (s *Expr_comparisonContext) NOT_() antlr.TerminalNode

+ func (s *Expr_comparisonContext) NOT_EQ1() antlr.TerminalNode

+ func (s *Expr_comparisonContext) NOT_EQ2() antlr.TerminalNode

+ func (s *Expr_comparisonContext) PIPE() antlr.TerminalNode

+ func (s *Expr_comparisonContext) REGEXP_() antlr.TerminalNode

+ type Expr_functionContext struct

+ func NewExpr_functionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *Expr_functionContext

+ func (s *Expr_functionContext) AllCOMMA() []antlr.TerminalNode

+ func (s *Expr_functionContext) AllExpr() []IExprContext

+ func (s *Expr_functionContext) CLOSE_PAR() antlr.TerminalNode

+ func (s *Expr_functionContext) COMMA(i int) antlr.TerminalNode

+ func (s *Expr_functionContext) DISTINCT_() antlr.TerminalNode

+ func (s *Expr_functionContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Expr_functionContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Expr_functionContext) Expr(i int) IExprContext

+ func (s *Expr_functionContext) Filter_clause() IFilter_clauseContext

+ func (s *Expr_functionContext) Function_name() IFunction_nameContext

+ func (s *Expr_functionContext) GetRuleContext() antlr.RuleContext

+ func (s *Expr_functionContext) OPEN_PAR() antlr.TerminalNode

+ func (s *Expr_functionContext) Over_clause() IOver_clauseContext

+ func (s *Expr_functionContext) STAR() antlr.TerminalNode

+ type Expr_in_selectContext struct

+ func NewExpr_in_selectContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *Expr_in_selectContext

+ func (s *Expr_in_selectContext) AllCOMMA() []antlr.TerminalNode

+ func (s *Expr_in_selectContext) AllExpr() []IExprContext

+ func (s *Expr_in_selectContext) CLOSE_PAR() antlr.TerminalNode

+ func (s *Expr_in_selectContext) COMMA(i int) antlr.TerminalNode

+ func (s *Expr_in_selectContext) DOT() antlr.TerminalNode

+ func (s *Expr_in_selectContext) EXISTS_() antlr.TerminalNode

+ func (s *Expr_in_selectContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Expr_in_selectContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Expr_in_selectContext) Expr(i int) IExprContext

+ func (s *Expr_in_selectContext) GetRuleContext() antlr.RuleContext

+ func (s *Expr_in_selectContext) IN_() antlr.TerminalNode

+ func (s *Expr_in_selectContext) NOT_() antlr.TerminalNode

+ func (s *Expr_in_selectContext) OPEN_PAR() antlr.TerminalNode

+ func (s *Expr_in_selectContext) Schema_name() ISchema_nameContext

+ func (s *Expr_in_selectContext) Select_stmt() ISelect_stmtContext

+ func (s *Expr_in_selectContext) Table_function_name() ITable_function_nameContext

+ func (s *Expr_in_selectContext) Table_name() ITable_nameContext

+ type Expr_listContext struct

+ func NewExpr_listContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *Expr_listContext

+ func (s *Expr_listContext) AllCOMMA() []antlr.TerminalNode

+ func (s *Expr_listContext) AllExpr() []IExprContext

+ func (s *Expr_listContext) CLOSE_PAR() antlr.TerminalNode

+ func (s *Expr_listContext) COMMA(i int) antlr.TerminalNode

+ func (s *Expr_listContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Expr_listContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Expr_listContext) Expr(i int) IExprContext

+ func (s *Expr_listContext) GetRuleContext() antlr.RuleContext

+ func (s *Expr_listContext) OPEN_PAR() antlr.TerminalNode

+ type Expr_literalContext struct

+ func NewExpr_literalContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *Expr_literalContext

+ func (s *Expr_literalContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Expr_literalContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Expr_literalContext) GetRuleContext() antlr.RuleContext

+ func (s *Expr_literalContext) Literal_value() ILiteral_valueContext

+ type Expr_math_opContext struct

+ func NewExpr_math_opContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *Expr_math_opContext

+ func (s *Expr_math_opContext) AllExpr() []IExprContext

+ func (s *Expr_math_opContext) DIV() antlr.TerminalNode

+ func (s *Expr_math_opContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Expr_math_opContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Expr_math_opContext) Expr(i int) IExprContext

+ func (s *Expr_math_opContext) GetRuleContext() antlr.RuleContext

+ func (s *Expr_math_opContext) MINUS() antlr.TerminalNode

+ func (s *Expr_math_opContext) MOD() antlr.TerminalNode

+ func (s *Expr_math_opContext) PLUS() antlr.TerminalNode

+ func (s *Expr_math_opContext) STAR() antlr.TerminalNode

+ type Expr_null_compContext struct

+ func NewExpr_null_compContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *Expr_null_compContext

+ func (s *Expr_null_compContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Expr_null_compContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Expr_null_compContext) Expr() IExprContext

+ func (s *Expr_null_compContext) GetRuleContext() antlr.RuleContext

+ func (s *Expr_null_compContext) ISNULL_() antlr.TerminalNode

+ func (s *Expr_null_compContext) NOTNULL_() antlr.TerminalNode

+ func (s *Expr_null_compContext) NOT_() antlr.TerminalNode

+ func (s *Expr_null_compContext) NULL_() antlr.TerminalNode

+ type Expr_qualified_column_nameContext struct

+ func NewExpr_qualified_column_nameContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *Expr_qualified_column_nameContext

+ func (s *Expr_qualified_column_nameContext) AllDOT() []antlr.TerminalNode

+ func (s *Expr_qualified_column_nameContext) Column_name() IColumn_nameContext

+ func (s *Expr_qualified_column_nameContext) DOT(i int) antlr.TerminalNode

+ func (s *Expr_qualified_column_nameContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Expr_qualified_column_nameContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Expr_qualified_column_nameContext) GetRuleContext() antlr.RuleContext

+ func (s *Expr_qualified_column_nameContext) Schema_name() ISchema_nameContext

+ func (s *Expr_qualified_column_nameContext) Table_name() ITable_nameContext

+ type Expr_raiseContext struct

+ func NewExpr_raiseContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *Expr_raiseContext

+ func (s *Expr_raiseContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Expr_raiseContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Expr_raiseContext) GetRuleContext() antlr.RuleContext

+ func (s *Expr_raiseContext) Raise_function() IRaise_functionContext

+ type Expr_unaryContext struct

+ func NewExpr_unaryContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *Expr_unaryContext

+ func (s *Expr_unaryContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Expr_unaryContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Expr_unaryContext) Expr() IExprContext

+ func (s *Expr_unaryContext) GetRuleContext() antlr.RuleContext

+ func (s *Expr_unaryContext) Unary_operator() IUnary_operatorContext

type Factored_select_stmtContext

+ func (s *Factored_select_stmtContext) Select_stmt() ISelect_stmtContext

+ type FilenameContext struct

+ func NewEmptyFilenameContext() *FilenameContext

+ func NewFilenameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FilenameContext

+ func (*FilenameContext) IsFilenameContext()

+ func (s *FilenameContext) Any_name() IAny_nameContext

+ func (s *FilenameContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *FilenameContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *FilenameContext) GetParser() antlr.Parser

+ func (s *FilenameContext) GetRuleContext() antlr.RuleContext

+ func (s *FilenameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type Filter_clauseContext struct

+ func NewEmptyFilter_clauseContext() *Filter_clauseContext

+ func NewFilter_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Filter_clauseContext

+ func (*Filter_clauseContext) IsFilter_clauseContext()

+ func (s *Filter_clauseContext) CLOSE_PAR() antlr.TerminalNode

+ func (s *Filter_clauseContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Filter_clauseContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Filter_clauseContext) Expr() IExprContext

+ func (s *Filter_clauseContext) FILTER_() antlr.TerminalNode

+ func (s *Filter_clauseContext) GetParser() antlr.Parser

+ func (s *Filter_clauseContext) GetRuleContext() antlr.RuleContext

+ func (s *Filter_clauseContext) OPEN_PAR() antlr.TerminalNode

+ func (s *Filter_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ func (s *Filter_clauseContext) WHERE_() antlr.TerminalNode

type Foreign_key_clauseContext

+ func (s *Foreign_key_clauseContext) ACTION_(i int) antlr.TerminalNode

+ func (s *Foreign_key_clauseContext) AllACTION_() []antlr.TerminalNode

+ func (s *Foreign_key_clauseContext) AllCASCADE_() []antlr.TerminalNode

+ func (s *Foreign_key_clauseContext) AllDEFAULT_() []antlr.TerminalNode

+ func (s *Foreign_key_clauseContext) AllDELETE_() []antlr.TerminalNode

+ func (s *Foreign_key_clauseContext) AllMATCH_() []antlr.TerminalNode

+ func (s *Foreign_key_clauseContext) AllNO_() []antlr.TerminalNode

+ func (s *Foreign_key_clauseContext) AllNULL_() []antlr.TerminalNode

+ func (s *Foreign_key_clauseContext) AllON_() []antlr.TerminalNode

+ func (s *Foreign_key_clauseContext) AllRESTRICT_() []antlr.TerminalNode

+ func (s *Foreign_key_clauseContext) AllSET_() []antlr.TerminalNode

+ func (s *Foreign_key_clauseContext) AllUPDATE_() []antlr.TerminalNode

+ func (s *Foreign_key_clauseContext) CASCADE_(i int) antlr.TerminalNode

+ func (s *Foreign_key_clauseContext) DEFAULT_(i int) antlr.TerminalNode

+ func (s *Foreign_key_clauseContext) DEFERRABLE_() antlr.TerminalNode

+ func (s *Foreign_key_clauseContext) DEFERRED_() antlr.TerminalNode

+ func (s *Foreign_key_clauseContext) DELETE_(i int) antlr.TerminalNode

+ func (s *Foreign_key_clauseContext) IMMEDIATE_() antlr.TerminalNode

+ func (s *Foreign_key_clauseContext) INITIALLY_() antlr.TerminalNode

+ func (s *Foreign_key_clauseContext) MATCH_(i int) antlr.TerminalNode

+ func (s *Foreign_key_clauseContext) NOT_() antlr.TerminalNode

+ func (s *Foreign_key_clauseContext) NO_(i int) antlr.TerminalNode

+ func (s *Foreign_key_clauseContext) NULL_(i int) antlr.TerminalNode

+ func (s *Foreign_key_clauseContext) ON_(i int) antlr.TerminalNode

+ func (s *Foreign_key_clauseContext) REFERENCES_() antlr.TerminalNode

+ func (s *Foreign_key_clauseContext) RESTRICT_(i int) antlr.TerminalNode

+ func (s *Foreign_key_clauseContext) SET_(i int) antlr.TerminalNode

+ func (s *Foreign_key_clauseContext) UPDATE_(i int) antlr.TerminalNode

+ type Frame_clauseContext struct

+ func NewEmptyFrame_clauseContext() *Frame_clauseContext

+ func NewFrame_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Frame_clauseContext

+ func (*Frame_clauseContext) IsFrame_clauseContext()

+ func (s *Frame_clauseContext) AND_() antlr.TerminalNode

+ func (s *Frame_clauseContext) BETWEEN_() antlr.TerminalNode

+ func (s *Frame_clauseContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Frame_clauseContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Frame_clauseContext) Frame_left() IFrame_leftContext

+ func (s *Frame_clauseContext) Frame_right() IFrame_rightContext

+ func (s *Frame_clauseContext) Frame_single() IFrame_singleContext

+ func (s *Frame_clauseContext) GROUPS_() antlr.TerminalNode

+ func (s *Frame_clauseContext) GetParser() antlr.Parser

+ func (s *Frame_clauseContext) GetRuleContext() antlr.RuleContext

+ func (s *Frame_clauseContext) RANGE_() antlr.TerminalNode

+ func (s *Frame_clauseContext) ROWS_() antlr.TerminalNode

+ func (s *Frame_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type Frame_leftContext struct

+ func NewEmptyFrame_leftContext() *Frame_leftContext

+ func NewFrame_leftContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Frame_leftContext

+ func (*Frame_leftContext) IsFrame_leftContext()

+ func (s *Frame_leftContext) CURRENT_() antlr.TerminalNode

+ func (s *Frame_leftContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Frame_leftContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Frame_leftContext) Expr() IExprContext

+ func (s *Frame_leftContext) FOLLOWING_() antlr.TerminalNode

+ func (s *Frame_leftContext) GetParser() antlr.Parser

+ func (s *Frame_leftContext) GetRuleContext() antlr.RuleContext

+ func (s *Frame_leftContext) PRECEDING_() antlr.TerminalNode

+ func (s *Frame_leftContext) ROW_() antlr.TerminalNode

+ func (s *Frame_leftContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ func (s *Frame_leftContext) UNBOUNDED_() antlr.TerminalNode

+ type Frame_rightContext struct

+ func NewEmptyFrame_rightContext() *Frame_rightContext

+ func NewFrame_rightContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Frame_rightContext

+ func (*Frame_rightContext) IsFrame_rightContext()

+ func (s *Frame_rightContext) CURRENT_() antlr.TerminalNode

+ func (s *Frame_rightContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Frame_rightContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Frame_rightContext) Expr() IExprContext

+ func (s *Frame_rightContext) FOLLOWING_() antlr.TerminalNode

+ func (s *Frame_rightContext) GetParser() antlr.Parser

+ func (s *Frame_rightContext) GetRuleContext() antlr.RuleContext

+ func (s *Frame_rightContext) PRECEDING_() antlr.TerminalNode

+ func (s *Frame_rightContext) ROW_() antlr.TerminalNode

+ func (s *Frame_rightContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ func (s *Frame_rightContext) UNBOUNDED_() antlr.TerminalNode

+ type Frame_singleContext struct

+ func NewEmptyFrame_singleContext() *Frame_singleContext

+ func NewFrame_singleContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Frame_singleContext

+ func (*Frame_singleContext) IsFrame_singleContext()

+ func (s *Frame_singleContext) CURRENT_() antlr.TerminalNode

+ func (s *Frame_singleContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Frame_singleContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Frame_singleContext) Expr() IExprContext

+ func (s *Frame_singleContext) GetParser() antlr.Parser

+ func (s *Frame_singleContext) GetRuleContext() antlr.RuleContext

+ func (s *Frame_singleContext) PRECEDING_() antlr.TerminalNode

+ func (s *Frame_singleContext) ROW_() antlr.TerminalNode

+ func (s *Frame_singleContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ func (s *Frame_singleContext) UNBOUNDED_() antlr.TerminalNode

+ type Frame_specContext struct

+ func NewEmptyFrame_specContext() *Frame_specContext

+ func NewFrame_specContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Frame_specContext

+ func (*Frame_specContext) IsFrame_specContext()

+ func (s *Frame_specContext) CURRENT_() antlr.TerminalNode

+ func (s *Frame_specContext) EXCLUDE_() antlr.TerminalNode

+ func (s *Frame_specContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Frame_specContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Frame_specContext) Frame_clause() IFrame_clauseContext

+ func (s *Frame_specContext) GROUP_() antlr.TerminalNode

+ func (s *Frame_specContext) GetParser() antlr.Parser

+ func (s *Frame_specContext) GetRuleContext() antlr.RuleContext

+ func (s *Frame_specContext) NO_() antlr.TerminalNode

+ func (s *Frame_specContext) OTHERS_() antlr.TerminalNode

+ func (s *Frame_specContext) ROW_() antlr.TerminalNode

+ func (s *Frame_specContext) TIES_() antlr.TerminalNode

+ func (s *Frame_specContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type IAggregate_funcContext interface

+ GetParser func() antlr.Parser

+ IsAggregate_funcContext func()

+ type IAggregate_function_invocationContext interface

+ GetParser func() antlr.Parser

+ IsAggregate_function_invocationContext func()

+ type IAliasContext interface

+ GetParser func() antlr.Parser

+ IsAliasContext func()

type IAlter_table_stmtContext

+ GetNew_column_name func() IColumn_nameContext

+ GetOld_column_name func() IColumn_nameContext

+ SetNew_column_name func(IColumn_nameContext)

+ SetOld_column_name func(IColumn_nameContext)

+ type IAsc_descContext interface

+ GetParser func() antlr.Parser

+ IsAsc_descContext func()

+ type IBase_window_nameContext interface

+ GetParser func() antlr.Parser

+ IsBase_window_nameContext func()

+ type IColumn_name_listContext interface

+ GetParser func() antlr.Parser

+ IsColumn_name_listContext func()

+ type ICommon_table_stmtContext interface

+ GetParser func() antlr.Parser

+ IsCommon_table_stmtContext func()

type ICreate_table_stmtContext

+ GetRow_ROW_ID func() antlr.Token

+ SetRow_ROW_ID func(antlr.Token)

+ type ICte_table_nameContext interface

+ GetParser func() antlr.Parser

+ IsCte_table_nameContext func()

+ type IDefault_DEFAULT__valueContext interface

+ GetParser func() antlr.Parser

+ IsDefault_DEFAULT__valueContext func()

+ type IDrop_stmtContext interface

+ GetObject func() antlr.Token

+ GetParser func() antlr.Parser

+ IsDrop_stmtContext func()

+ SetObject func(antlr.Token)

+ type IExpr_asc_descContext interface

+ GetParser func() antlr.Parser

+ IsExpr_asc_descContext func()

+ type IFilenameContext interface

+ GetParser func() antlr.Parser

+ IsFilenameContext func()

+ type IFilter_clauseContext interface

+ GetParser func() antlr.Parser

+ IsFilter_clauseContext func()

+ type IFrame_clauseContext interface

+ GetParser func() antlr.Parser

+ IsFrame_clauseContext func()

+ type IFrame_leftContext interface

+ GetParser func() antlr.Parser

+ IsFrame_leftContext func()

+ type IFrame_rightContext interface

+ GetParser func() antlr.Parser

+ IsFrame_rightContext func()

+ type IFrame_singleContext interface

+ GetParser func() antlr.Parser

+ IsFrame_singleContext func()

+ type IFrame_specContext interface

+ GetParser func() antlr.Parser

+ IsFrame_specContext func()

+ type IInitial_selectContext interface

+ GetParser func() antlr.Parser

+ IsInitial_selectContext func()

+ type ILimit_stmtContext interface

+ GetParser func() antlr.Parser

+ IsLimit_stmtContext func()

+ type IOf_OF_fsetContext interface

+ GetParser func() antlr.Parser

+ IsOf_OF_fsetContext func()

+ type IOrder_by_exprContext interface

+ GetParser func() antlr.Parser

+ IsOrder_by_exprContext func()

+ type IOrder_by_expr_asc_descContext interface

+ GetParser func() antlr.Parser

+ IsOrder_by_expr_asc_descContext func()

+ type IOrder_by_stmtContext interface

+ GetParser func() antlr.Parser

+ IsOrder_by_stmtContext func()

+ type IOver_clauseContext interface

+ GetParser func() antlr.Parser

+ IsOver_clauseContext func()

+ type IPartition_byContext interface

+ GetParser func() antlr.Parser

+ IsPartition_byContext func()

+ type IRecursive__selectContext interface

+ GetParser func() antlr.Parser

+ IsRecursive__selectContext func()

+ type IRecursive_cteContext interface

+ GetParser func() antlr.Parser

+ IsRecursive_cteContext func()

+ type ISimple_funcContext interface

+ GetParser func() antlr.Parser

+ IsSimple_funcContext func()

+ type ISimple_function_invocationContext interface

+ GetParser func() antlr.Parser

+ IsSimple_function_invocationContext func()

+ type IUpsert_clauseContext interface

+ GetParser func() antlr.Parser

+ IsUpsert_clauseContext func()

+ type IWindow_defnContext interface

+ GetParser func() antlr.Parser

+ IsWindow_defnContext func()

+ type IWindow_functionContext interface

+ GetParser func() antlr.Parser

+ IsWindow_functionContext func()

+ type IWindow_function_invocationContext interface

+ GetParser func() antlr.Parser

+ IsWindow_function_invocationContext func()

+ type IWindow_nameContext interface

+ GetParser func() antlr.Parser

+ IsWindow_nameContext func()

type Indexed_columnContext

+ func (s *Indexed_columnContext) Asc_desc() IAsc_descContext

+ func (s *Indexed_columnContext) COLLATE_() antlr.TerminalNode

+ func (s *Indexed_columnContext) Expr() IExprContext

+ type Initial_selectContext struct

+ func NewEmptyInitial_selectContext() *Initial_selectContext

+ func NewInitial_selectContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Initial_selectContext

+ func (*Initial_selectContext) IsInitial_selectContext()

+ func (s *Initial_selectContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Initial_selectContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Initial_selectContext) GetParser() antlr.Parser

+ func (s *Initial_selectContext) GetRuleContext() antlr.RuleContext

+ func (s *Initial_selectContext) Select_stmt() ISelect_stmtContext

+ func (s *Initial_selectContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Insert_stmtContext

+ func (s *Insert_stmtContext) ABORT_() antlr.TerminalNode

+ func (s *Insert_stmtContext) AS_() antlr.TerminalNode

+ func (s *Insert_stmtContext) DEFAULT_() antlr.TerminalNode

+ func (s *Insert_stmtContext) FAIL_() antlr.TerminalNode

+ func (s *Insert_stmtContext) IGNORE_() antlr.TerminalNode

+ func (s *Insert_stmtContext) INSERT_() antlr.TerminalNode

+ func (s *Insert_stmtContext) INTO_() antlr.TerminalNode

+ func (s *Insert_stmtContext) OR_() antlr.TerminalNode

+ func (s *Insert_stmtContext) REPLACE_() antlr.TerminalNode

+ func (s *Insert_stmtContext) ROLLBACK_() antlr.TerminalNode

+ func (s *Insert_stmtContext) Schema_name() ISchema_nameContext

+ func (s *Insert_stmtContext) Table_alias() ITable_aliasContext

+ func (s *Insert_stmtContext) Upsert_clause() IUpsert_clauseContext

+ func (s *Insert_stmtContext) VALUES_() antlr.TerminalNode

type Join_constraintContext

+ func (s *Join_constraintContext) ON_() antlr.TerminalNode

+ func (s *Join_constraintContext) USING_() antlr.TerminalNode

type Join_operatorContext

+ func (s *Join_operatorContext) CROSS_() antlr.TerminalNode

+ func (s *Join_operatorContext) INNER_() antlr.TerminalNode

+ func (s *Join_operatorContext) JOIN_() antlr.TerminalNode

+ func (s *Join_operatorContext) LEFT_() antlr.TerminalNode

+ func (s *Join_operatorContext) NATURAL_() antlr.TerminalNode

+ func (s *Join_operatorContext) OUTER_() antlr.TerminalNode

type KeywordContext

+ func (s *KeywordContext) ABORT_() antlr.TerminalNode

+ func (s *KeywordContext) ACTION_() antlr.TerminalNode

+ func (s *KeywordContext) ADD_() antlr.TerminalNode

+ func (s *KeywordContext) AFTER_() antlr.TerminalNode

+ func (s *KeywordContext) ALL_() antlr.TerminalNode

+ func (s *KeywordContext) ALTER_() antlr.TerminalNode

+ func (s *KeywordContext) ALWAYS_() antlr.TerminalNode

+ func (s *KeywordContext) ANALYZE_() antlr.TerminalNode

+ func (s *KeywordContext) AND_() antlr.TerminalNode

+ func (s *KeywordContext) ASC_() antlr.TerminalNode

+ func (s *KeywordContext) AS_() antlr.TerminalNode

+ func (s *KeywordContext) ATTACH_() antlr.TerminalNode

+ func (s *KeywordContext) AUTOINCREMENT_() antlr.TerminalNode

+ func (s *KeywordContext) BEFORE_() antlr.TerminalNode

+ func (s *KeywordContext) BEGIN_() antlr.TerminalNode

+ func (s *KeywordContext) BETWEEN_() antlr.TerminalNode

+ func (s *KeywordContext) BY_() antlr.TerminalNode

+ func (s *KeywordContext) CASCADE_() antlr.TerminalNode

+ func (s *KeywordContext) CASE_() antlr.TerminalNode

+ func (s *KeywordContext) CAST_() antlr.TerminalNode

+ func (s *KeywordContext) CHECK_() antlr.TerminalNode

+ func (s *KeywordContext) COLLATE_() antlr.TerminalNode

+ func (s *KeywordContext) COLUMN_() antlr.TerminalNode

+ func (s *KeywordContext) COMMIT_() antlr.TerminalNode

+ func (s *KeywordContext) CONFLICT_() antlr.TerminalNode

+ func (s *KeywordContext) CONSTRAINT_() antlr.TerminalNode

+ func (s *KeywordContext) CREATE_() antlr.TerminalNode

+ func (s *KeywordContext) CROSS_() antlr.TerminalNode

+ func (s *KeywordContext) CUME_DIST_() antlr.TerminalNode

+ func (s *KeywordContext) CURRENT_() antlr.TerminalNode

+ func (s *KeywordContext) CURRENT_DATE_() antlr.TerminalNode

+ func (s *KeywordContext) CURRENT_TIMESTAMP_() antlr.TerminalNode

+ func (s *KeywordContext) CURRENT_TIME_() antlr.TerminalNode

+ func (s *KeywordContext) DATABASE_() antlr.TerminalNode

+ func (s *KeywordContext) DEFAULT_() antlr.TerminalNode

+ func (s *KeywordContext) DEFERRABLE_() antlr.TerminalNode

+ func (s *KeywordContext) DEFERRED_() antlr.TerminalNode

+ func (s *KeywordContext) DELETE_() antlr.TerminalNode

+ func (s *KeywordContext) DENSE_RANK_() antlr.TerminalNode

+ func (s *KeywordContext) DESC_() antlr.TerminalNode

+ func (s *KeywordContext) DETACH_() antlr.TerminalNode

+ func (s *KeywordContext) DISTINCT_() antlr.TerminalNode

+ func (s *KeywordContext) DROP_() antlr.TerminalNode

+ func (s *KeywordContext) EACH_() antlr.TerminalNode

+ func (s *KeywordContext) ELSE_() antlr.TerminalNode

+ func (s *KeywordContext) END_() antlr.TerminalNode

+ func (s *KeywordContext) ESCAPE_() antlr.TerminalNode

+ func (s *KeywordContext) EXCEPT_() antlr.TerminalNode

+ func (s *KeywordContext) EXCLUDE_() antlr.TerminalNode

+ func (s *KeywordContext) EXCLUSIVE_() antlr.TerminalNode

+ func (s *KeywordContext) EXISTS_() antlr.TerminalNode

+ func (s *KeywordContext) EXPLAIN_() antlr.TerminalNode

+ func (s *KeywordContext) FAIL_() antlr.TerminalNode

+ func (s *KeywordContext) FALSE_() antlr.TerminalNode

+ func (s *KeywordContext) FILTER_() antlr.TerminalNode

+ func (s *KeywordContext) FIRST_() antlr.TerminalNode

+ func (s *KeywordContext) FIRST_VALUE_() antlr.TerminalNode

+ func (s *KeywordContext) FOLLOWING_() antlr.TerminalNode

+ func (s *KeywordContext) FOREIGN_() antlr.TerminalNode

+ func (s *KeywordContext) FOR_() antlr.TerminalNode

+ func (s *KeywordContext) FROM_() antlr.TerminalNode

+ func (s *KeywordContext) FULL_() antlr.TerminalNode

+ func (s *KeywordContext) GENERATED_() antlr.TerminalNode

+ func (s *KeywordContext) GLOB_() antlr.TerminalNode

+ func (s *KeywordContext) GROUPS_() antlr.TerminalNode

+ func (s *KeywordContext) GROUP_() antlr.TerminalNode

+ func (s *KeywordContext) HAVING_() antlr.TerminalNode

+ func (s *KeywordContext) IF_() antlr.TerminalNode

+ func (s *KeywordContext) IGNORE_() antlr.TerminalNode

+ func (s *KeywordContext) IMMEDIATE_() antlr.TerminalNode

+ func (s *KeywordContext) INDEXED_() antlr.TerminalNode

+ func (s *KeywordContext) INDEX_() antlr.TerminalNode

+ func (s *KeywordContext) INITIALLY_() antlr.TerminalNode

+ func (s *KeywordContext) INNER_() antlr.TerminalNode

+ func (s *KeywordContext) INSERT_() antlr.TerminalNode

+ func (s *KeywordContext) INSTEAD_() antlr.TerminalNode

+ func (s *KeywordContext) INTERSECT_() antlr.TerminalNode

+ func (s *KeywordContext) INTO_() antlr.TerminalNode

+ func (s *KeywordContext) IN_() antlr.TerminalNode

+ func (s *KeywordContext) ISNULL_() antlr.TerminalNode

+ func (s *KeywordContext) IS_() antlr.TerminalNode

+ func (s *KeywordContext) JOIN_() antlr.TerminalNode

+ func (s *KeywordContext) KEY_() antlr.TerminalNode

+ func (s *KeywordContext) LAG_() antlr.TerminalNode

+ func (s *KeywordContext) LAST_() antlr.TerminalNode

+ func (s *KeywordContext) LAST_VALUE_() antlr.TerminalNode

+ func (s *KeywordContext) LEAD_() antlr.TerminalNode

+ func (s *KeywordContext) LEFT_() antlr.TerminalNode

+ func (s *KeywordContext) LIKE_() antlr.TerminalNode

+ func (s *KeywordContext) LIMIT_() antlr.TerminalNode

+ func (s *KeywordContext) MATCH_() antlr.TerminalNode

+ func (s *KeywordContext) NATURAL_() antlr.TerminalNode

+ func (s *KeywordContext) NOTNULL_() antlr.TerminalNode

+ func (s *KeywordContext) NOT_() antlr.TerminalNode

+ func (s *KeywordContext) NO_() antlr.TerminalNode

+ func (s *KeywordContext) NTH_VALUE_() antlr.TerminalNode

+ func (s *KeywordContext) NTILE_() antlr.TerminalNode

+ func (s *KeywordContext) NULLS_() antlr.TerminalNode

+ func (s *KeywordContext) NULL_() antlr.TerminalNode

+ func (s *KeywordContext) OFFSET_() antlr.TerminalNode

+ func (s *KeywordContext) OF_() antlr.TerminalNode

+ func (s *KeywordContext) ON_() antlr.TerminalNode

+ func (s *KeywordContext) ORDER_() antlr.TerminalNode

+ func (s *KeywordContext) OR_() antlr.TerminalNode

+ func (s *KeywordContext) OUTER_() antlr.TerminalNode

+ func (s *KeywordContext) OVER_() antlr.TerminalNode

+ func (s *KeywordContext) PARTITION_() antlr.TerminalNode

+ func (s *KeywordContext) PERCENT_RANK_() antlr.TerminalNode

+ func (s *KeywordContext) PLAN_() antlr.TerminalNode

+ func (s *KeywordContext) PRAGMA_() antlr.TerminalNode

+ func (s *KeywordContext) PRECEDING_() antlr.TerminalNode

+ func (s *KeywordContext) PRIMARY_() antlr.TerminalNode

+ func (s *KeywordContext) QUERY_() antlr.TerminalNode

+ func (s *KeywordContext) RAISE_() antlr.TerminalNode

+ func (s *KeywordContext) RANGE_() antlr.TerminalNode

+ func (s *KeywordContext) RANK_() antlr.TerminalNode

+ func (s *KeywordContext) RECURSIVE_() antlr.TerminalNode

+ func (s *KeywordContext) REFERENCES_() antlr.TerminalNode

+ func (s *KeywordContext) REGEXP_() antlr.TerminalNode

+ func (s *KeywordContext) REINDEX_() antlr.TerminalNode

+ func (s *KeywordContext) RELEASE_() antlr.TerminalNode

+ func (s *KeywordContext) RENAME_() antlr.TerminalNode

+ func (s *KeywordContext) REPLACE_() antlr.TerminalNode

+ func (s *KeywordContext) RESTRICT_() antlr.TerminalNode

+ func (s *KeywordContext) RIGHT_() antlr.TerminalNode

+ func (s *KeywordContext) ROLLBACK_() antlr.TerminalNode

+ func (s *KeywordContext) ROWS_() antlr.TerminalNode

+ func (s *KeywordContext) ROW_() antlr.TerminalNode

+ func (s *KeywordContext) ROW_NUMBER_() antlr.TerminalNode

+ func (s *KeywordContext) SAVEPOINT_() antlr.TerminalNode

+ func (s *KeywordContext) SELECT_() antlr.TerminalNode

+ func (s *KeywordContext) SET_() antlr.TerminalNode

+ func (s *KeywordContext) STORED_() antlr.TerminalNode

+ func (s *KeywordContext) TABLE_() antlr.TerminalNode

+ func (s *KeywordContext) TEMPORARY_() antlr.TerminalNode

+ func (s *KeywordContext) TEMP_() antlr.TerminalNode

+ func (s *KeywordContext) THEN_() antlr.TerminalNode

+ func (s *KeywordContext) TO_() antlr.TerminalNode

+ func (s *KeywordContext) TRANSACTION_() antlr.TerminalNode

+ func (s *KeywordContext) TRIGGER_() antlr.TerminalNode

+ func (s *KeywordContext) TRUE_() antlr.TerminalNode

+ func (s *KeywordContext) UNBOUNDED_() antlr.TerminalNode

+ func (s *KeywordContext) UNION_() antlr.TerminalNode

+ func (s *KeywordContext) UNIQUE_() antlr.TerminalNode

+ func (s *KeywordContext) UPDATE_() antlr.TerminalNode

+ func (s *KeywordContext) USING_() antlr.TerminalNode

+ func (s *KeywordContext) VACUUM_() antlr.TerminalNode

+ func (s *KeywordContext) VALUES_() antlr.TerminalNode

+ func (s *KeywordContext) VIEW_() antlr.TerminalNode

+ func (s *KeywordContext) VIRTUAL_() antlr.TerminalNode

+ func (s *KeywordContext) WHEN_() antlr.TerminalNode

+ func (s *KeywordContext) WHERE_() antlr.TerminalNode

+ func (s *KeywordContext) WINDOW_() antlr.TerminalNode

+ func (s *KeywordContext) WITHOUT_() antlr.TerminalNode

+ func (s *KeywordContext) WITH_() antlr.TerminalNode

+ type Limit_stmtContext struct

+ func NewEmptyLimit_stmtContext() *Limit_stmtContext

+ func NewLimit_stmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Limit_stmtContext

+ func (*Limit_stmtContext) IsLimit_stmtContext()

+ func (s *Limit_stmtContext) AllExpr() []IExprContext

+ func (s *Limit_stmtContext) COMMA() antlr.TerminalNode

+ func (s *Limit_stmtContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Limit_stmtContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Limit_stmtContext) Expr(i int) IExprContext

+ func (s *Limit_stmtContext) GetParser() antlr.Parser

+ func (s *Limit_stmtContext) GetRuleContext() antlr.RuleContext

+ func (s *Limit_stmtContext) LIMIT_() antlr.TerminalNode

+ func (s *Limit_stmtContext) OFFSET_() antlr.TerminalNode

+ func (s *Limit_stmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Literal_valueContext

+ func (s *Literal_valueContext) CURRENT_DATE_() antlr.TerminalNode

+ func (s *Literal_valueContext) CURRENT_TIMESTAMP_() antlr.TerminalNode

+ func (s *Literal_valueContext) CURRENT_TIME_() antlr.TerminalNode

+ func (s *Literal_valueContext) FALSE_() antlr.TerminalNode

+ func (s *Literal_valueContext) NULL_() antlr.TerminalNode

+ func (s *Literal_valueContext) TRUE_() antlr.TerminalNode

+ type Of_OF_fsetContext struct

+ func NewEmptyOf_OF_fsetContext() *Of_OF_fsetContext

+ func NewOf_OF_fsetContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Of_OF_fsetContext

+ func (*Of_OF_fsetContext) IsOf_OF_fsetContext()

+ func (s *Of_OF_fsetContext) COMMA() antlr.TerminalNode

+ func (s *Of_OF_fsetContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Of_OF_fsetContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Of_OF_fsetContext) GetParser() antlr.Parser

+ func (s *Of_OF_fsetContext) GetRuleContext() antlr.RuleContext

+ func (s *Of_OF_fsetContext) Signed_number() ISigned_numberContext

+ func (s *Of_OF_fsetContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type Order_by_exprContext struct

+ func NewEmptyOrder_by_exprContext() *Order_by_exprContext

+ func NewOrder_by_exprContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Order_by_exprContext

+ func (*Order_by_exprContext) IsOrder_by_exprContext()

+ func (s *Order_by_exprContext) AllExpr() []IExprContext

+ func (s *Order_by_exprContext) BY_() antlr.TerminalNode

+ func (s *Order_by_exprContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Order_by_exprContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Order_by_exprContext) Expr(i int) IExprContext

+ func (s *Order_by_exprContext) GetParser() antlr.Parser

+ func (s *Order_by_exprContext) GetRuleContext() antlr.RuleContext

+ func (s *Order_by_exprContext) ORDER_() antlr.TerminalNode

+ func (s *Order_by_exprContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type Order_by_expr_asc_descContext struct

+ func NewEmptyOrder_by_expr_asc_descContext() *Order_by_expr_asc_descContext

+ func NewOrder_by_expr_asc_descContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Order_by_expr_asc_descContext

+ func (*Order_by_expr_asc_descContext) IsOrder_by_expr_asc_descContext()

+ func (s *Order_by_expr_asc_descContext) BY_() antlr.TerminalNode

+ func (s *Order_by_expr_asc_descContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Order_by_expr_asc_descContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Order_by_expr_asc_descContext) GetParser() antlr.Parser

+ func (s *Order_by_expr_asc_descContext) GetRuleContext() antlr.RuleContext

+ func (s *Order_by_expr_asc_descContext) ORDER_() antlr.TerminalNode

+ func (s *Order_by_expr_asc_descContext) Order_by_expr_asc_desc() IOrder_by_expr_asc_descContext

+ func (s *Order_by_expr_asc_descContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type Order_by_stmtContext struct

+ func NewEmptyOrder_by_stmtContext() *Order_by_stmtContext

+ func NewOrder_by_stmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Order_by_stmtContext

+ func (*Order_by_stmtContext) IsOrder_by_stmtContext()

+ func (s *Order_by_stmtContext) AllCOMMA() []antlr.TerminalNode

+ func (s *Order_by_stmtContext) AllOrdering_term() []IOrdering_termContext

+ func (s *Order_by_stmtContext) BY_() antlr.TerminalNode

+ func (s *Order_by_stmtContext) COMMA(i int) antlr.TerminalNode

+ func (s *Order_by_stmtContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Order_by_stmtContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Order_by_stmtContext) GetParser() antlr.Parser

+ func (s *Order_by_stmtContext) GetRuleContext() antlr.RuleContext

+ func (s *Order_by_stmtContext) ORDER_() antlr.TerminalNode

+ func (s *Order_by_stmtContext) Ordering_term(i int) IOrdering_termContext

+ func (s *Order_by_stmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Ordering_termContext

+ func (s *Ordering_termContext) Asc_desc() IAsc_descContext

+ func (s *Ordering_termContext) COLLATE_() antlr.TerminalNode

+ func (s *Ordering_termContext) FIRST_() antlr.TerminalNode

+ func (s *Ordering_termContext) LAST_() antlr.TerminalNode

+ func (s *Ordering_termContext) NULLS_() antlr.TerminalNode

+ type Over_clauseContext struct

+ func NewEmptyOver_clauseContext() *Over_clauseContext

+ func NewOver_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Over_clauseContext

+ func (*Over_clauseContext) IsOver_clauseContext()

+ func (s *Over_clauseContext) AllBY_() []antlr.TerminalNode

+ func (s *Over_clauseContext) AllCOMMA() []antlr.TerminalNode

+ func (s *Over_clauseContext) AllExpr() []IExprContext

+ func (s *Over_clauseContext) AllOrdering_term() []IOrdering_termContext

+ func (s *Over_clauseContext) BY_(i int) antlr.TerminalNode

+ func (s *Over_clauseContext) Base_window_name() IBase_window_nameContext

+ func (s *Over_clauseContext) CLOSE_PAR() antlr.TerminalNode

+ func (s *Over_clauseContext) COMMA(i int) antlr.TerminalNode

+ func (s *Over_clauseContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Over_clauseContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Over_clauseContext) Expr(i int) IExprContext

+ func (s *Over_clauseContext) Frame_spec() IFrame_specContext

+ func (s *Over_clauseContext) GetParser() antlr.Parser

+ func (s *Over_clauseContext) GetRuleContext() antlr.RuleContext

+ func (s *Over_clauseContext) OPEN_PAR() antlr.TerminalNode

+ func (s *Over_clauseContext) ORDER_() antlr.TerminalNode

+ func (s *Over_clauseContext) OVER_() antlr.TerminalNode

+ func (s *Over_clauseContext) Ordering_term(i int) IOrdering_termContext

+ func (s *Over_clauseContext) PARTITION_() antlr.TerminalNode

+ func (s *Over_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ func (s *Over_clauseContext) Window_name() IWindow_nameContext

+ type Partition_byContext struct

+ func NewEmptyPartition_byContext() *Partition_byContext

+ func NewPartition_byContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Partition_byContext

+ func (*Partition_byContext) IsPartition_byContext()

+ func (s *Partition_byContext) AllExpr() []IExprContext

+ func (s *Partition_byContext) BY_() antlr.TerminalNode

+ func (s *Partition_byContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Partition_byContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Partition_byContext) Expr(i int) IExprContext

+ func (s *Partition_byContext) GetParser() antlr.Parser

+ func (s *Partition_byContext) GetRuleContext() antlr.RuleContext

+ func (s *Partition_byContext) PARTITION_() antlr.TerminalNode

+ func (s *Partition_byContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Pragma_stmtContext

+ func (s *Pragma_stmtContext) PRAGMA_() antlr.TerminalNode

+ func (s *Pragma_stmtContext) Schema_name() ISchema_nameContext

type Qualified_table_nameContext

+ func (s *Qualified_table_nameContext) AS_() antlr.TerminalNode

+ func (s *Qualified_table_nameContext) Alias() IAliasContext

+ func (s *Qualified_table_nameContext) BY_() antlr.TerminalNode

+ func (s *Qualified_table_nameContext) INDEXED_() antlr.TerminalNode

+ func (s *Qualified_table_nameContext) NOT_() antlr.TerminalNode

+ func (s *Qualified_table_nameContext) Schema_name() ISchema_nameContext

type Raise_functionContext

+ func (s *Raise_functionContext) ABORT_() antlr.TerminalNode

+ func (s *Raise_functionContext) FAIL_() antlr.TerminalNode

+ func (s *Raise_functionContext) IGNORE_() antlr.TerminalNode

+ func (s *Raise_functionContext) RAISE_() antlr.TerminalNode

+ func (s *Raise_functionContext) ROLLBACK_() antlr.TerminalNode

+ type Recursive__selectContext struct

+ func NewEmptyRecursive__selectContext() *Recursive__selectContext

+ func NewRecursive__selectContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Recursive__selectContext

+ func (*Recursive__selectContext) IsRecursive__selectContext()

+ func (s *Recursive__selectContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Recursive__selectContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Recursive__selectContext) GetParser() antlr.Parser

+ func (s *Recursive__selectContext) GetRuleContext() antlr.RuleContext

+ func (s *Recursive__selectContext) Select_stmt() ISelect_stmtContext

+ func (s *Recursive__selectContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type Recursive_cteContext struct

+ func NewEmptyRecursive_cteContext() *Recursive_cteContext

+ func NewRecursive_cteContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Recursive_cteContext

+ func (*Recursive_cteContext) IsRecursive_cteContext()

+ func (s *Recursive_cteContext) ALL_() antlr.TerminalNode

+ func (s *Recursive_cteContext) AS_() antlr.TerminalNode

+ func (s *Recursive_cteContext) CLOSE_PAR() antlr.TerminalNode

+ func (s *Recursive_cteContext) Cte_table_name() ICte_table_nameContext

+ func (s *Recursive_cteContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Recursive_cteContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Recursive_cteContext) GetParser() antlr.Parser

+ func (s *Recursive_cteContext) GetRuleContext() antlr.RuleContext

+ func (s *Recursive_cteContext) Initial_select() IInitial_selectContext

+ func (s *Recursive_cteContext) OPEN_PAR() antlr.TerminalNode

+ func (s *Recursive_cteContext) Recursive__select() IRecursive__selectContext

+ func (s *Recursive_cteContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ func (s *Recursive_cteContext) UNION_() antlr.TerminalNode

type Reindex_stmtContext

+ func (s *Reindex_stmtContext) REINDEX_() antlr.TerminalNode

+ func (s *Reindex_stmtContext) Schema_name() ISchema_nameContext

type Release_stmtContext

+ func (s *Release_stmtContext) RELEASE_() antlr.TerminalNode

+ func (s *Release_stmtContext) SAVEPOINT_() antlr.TerminalNode

type Result_columnContext

+ func (s *Result_columnContext) AS_() antlr.TerminalNode

type Rollback_stmtContext

+ func (s *Rollback_stmtContext) ROLLBACK_() antlr.TerminalNode

+ func (s *Rollback_stmtContext) SAVEPOINT_() antlr.TerminalNode

+ func (s *Rollback_stmtContext) TO_() antlr.TerminalNode

+ func (s *Rollback_stmtContext) TRANSACTION_() antlr.TerminalNode

type SQLiteParser

+ func (p *SQLiteParser) Aggregate_func() (localctx IAggregate_funcContext)

+ func (p *SQLiteParser) Aggregate_function_invocation() (localctx IAggregate_function_invocationContext)

+ func (p *SQLiteParser) Alias() (localctx IAliasContext)

+ func (p *SQLiteParser) Asc_desc() (localctx IAsc_descContext)

+ func (p *SQLiteParser) Base_window_name() (localctx IBase_window_nameContext)

+ func (p *SQLiteParser) Column_name_list() (localctx IColumn_name_listContext)

+ func (p *SQLiteParser) Common_table_stmt() (localctx ICommon_table_stmtContext)

+ func (p *SQLiteParser) Cte_table_name() (localctx ICte_table_nameContext)

+ func (p *SQLiteParser) Default_DEFAULT__value() (localctx IDefault_DEFAULT__valueContext)

+ func (p *SQLiteParser) Drop_stmt() (localctx IDrop_stmtContext)

+ func (p *SQLiteParser) Expr_asc_desc() (localctx IExpr_asc_descContext)

+ func (p *SQLiteParser) Filename() (localctx IFilenameContext)

+ func (p *SQLiteParser) Filter_clause() (localctx IFilter_clauseContext)

+ func (p *SQLiteParser) Frame_clause() (localctx IFrame_clauseContext)

+ func (p *SQLiteParser) Frame_left() (localctx IFrame_leftContext)

+ func (p *SQLiteParser) Frame_right() (localctx IFrame_rightContext)

+ func (p *SQLiteParser) Frame_single() (localctx IFrame_singleContext)

+ func (p *SQLiteParser) Frame_spec() (localctx IFrame_specContext)

+ func (p *SQLiteParser) Initial_select() (localctx IInitial_selectContext)

+ func (p *SQLiteParser) Limit_stmt() (localctx ILimit_stmtContext)

+ func (p *SQLiteParser) Of_OF_fset() (localctx IOf_OF_fsetContext)

+ func (p *SQLiteParser) Order_by_expr() (localctx IOrder_by_exprContext)

+ func (p *SQLiteParser) Order_by_expr_asc_desc() (localctx IOrder_by_expr_asc_descContext)

+ func (p *SQLiteParser) Order_by_stmt() (localctx IOrder_by_stmtContext)

+ func (p *SQLiteParser) Over_clause() (localctx IOver_clauseContext)

+ func (p *SQLiteParser) Partition_by() (localctx IPartition_byContext)

+ func (p *SQLiteParser) Recursive__select() (localctx IRecursive__selectContext)

+ func (p *SQLiteParser) Recursive_cte() (localctx IRecursive_cteContext)

+ func (p *SQLiteParser) Simple_func() (localctx ISimple_funcContext)

+ func (p *SQLiteParser) Simple_function_invocation() (localctx ISimple_function_invocationContext)

+ func (p *SQLiteParser) Upsert_clause() (localctx IUpsert_clauseContext)

+ func (p *SQLiteParser) Window_defn() (localctx IWindow_defnContext)

+ func (p *SQLiteParser) Window_function() (localctx IWindow_functionContext)

+ func (p *SQLiteParser) Window_function_invocation() (localctx IWindow_function_invocationContext)

+ func (p *SQLiteParser) Window_name() (localctx IWindow_nameContext)

+ type SQLiteParserListener interface

+ EnterAggregate_func func(c *Aggregate_funcContext)

+ EnterAggregate_function_invocation func(c *Aggregate_function_invocationContext)

+ EnterAlias func(c *AliasContext)

+ EnterAlter_table_stmt func(c *Alter_table_stmtContext)

+ EnterAnalyze_stmt func(c *Analyze_stmtContext)

+ EnterAny_name func(c *Any_nameContext)

+ EnterAsc_desc func(c *Asc_descContext)

+ EnterAttach_stmt func(c *Attach_stmtContext)

+ EnterBase_window_name func(c *Base_window_nameContext)

+ EnterBegin_stmt func(c *Begin_stmtContext)

+ EnterCollation_name func(c *Collation_nameContext)

+ EnterColumn_alias func(c *Column_aliasContext)

+ EnterColumn_constraint func(c *Column_constraintContext)

+ EnterColumn_def func(c *Column_defContext)

+ EnterColumn_name func(c *Column_nameContext)

+ EnterColumn_name_list func(c *Column_name_listContext)

+ EnterCommit_stmt func(c *Commit_stmtContext)

+ EnterCommon_table_expression func(c *Common_table_expressionContext)

+ EnterCommon_table_stmt func(c *Common_table_stmtContext)

+ EnterCompound_operator func(c *Compound_operatorContext)

+ EnterCompound_select_stmt func(c *Compound_select_stmtContext)

+ EnterConflict_clause func(c *Conflict_clauseContext)

+ EnterCreate_index_stmt func(c *Create_index_stmtContext)

+ EnterCreate_table_stmt func(c *Create_table_stmtContext)

+ EnterCreate_trigger_stmt func(c *Create_trigger_stmtContext)

+ EnterCreate_view_stmt func(c *Create_view_stmtContext)

+ EnterCreate_virtual_table_stmt func(c *Create_virtual_table_stmtContext)

+ EnterCte_table_name func(c *Cte_table_nameContext)

+ EnterDefault_DEFAULT__value func(c *Default_DEFAULT__valueContext)

+ EnterDelete_stmt func(c *Delete_stmtContext)

+ EnterDelete_stmt_limited func(c *Delete_stmt_limitedContext)

+ EnterDetach_stmt func(c *Detach_stmtContext)

+ EnterDrop_stmt func(c *Drop_stmtContext)

+ EnterError_message func(c *Error_messageContext)

+ EnterExpr_asc_desc func(c *Expr_asc_descContext)

+ EnterExpr_between func(c *Expr_betweenContext)

+ EnterExpr_binary func(c *Expr_binaryContext)

+ EnterExpr_bind func(c *Expr_bindContext)

+ EnterExpr_case func(c *Expr_caseContext)

+ EnterExpr_cast func(c *Expr_castContext)

+ EnterExpr_collate func(c *Expr_collateContext)

+ EnterExpr_comparison func(c *Expr_comparisonContext)

+ EnterExpr_function func(c *Expr_functionContext)

+ EnterExpr_in_select func(c *Expr_in_selectContext)

+ EnterExpr_list func(c *Expr_listContext)

+ EnterExpr_literal func(c *Expr_literalContext)

+ EnterExpr_math_op func(c *Expr_math_opContext)

+ EnterExpr_null_comp func(c *Expr_null_compContext)

+ EnterExpr_qualified_column_name func(c *Expr_qualified_column_nameContext)

+ EnterExpr_raise func(c *Expr_raiseContext)

+ EnterExpr_unary func(c *Expr_unaryContext)

+ EnterFactored_select_stmt func(c *Factored_select_stmtContext)

+ EnterFilename func(c *FilenameContext)

+ EnterFilter_clause func(c *Filter_clauseContext)

+ EnterForeign_key_clause func(c *Foreign_key_clauseContext)

+ EnterForeign_table func(c *Foreign_tableContext)

+ EnterFrame_clause func(c *Frame_clauseContext)

+ EnterFrame_left func(c *Frame_leftContext)

+ EnterFrame_right func(c *Frame_rightContext)

+ EnterFrame_single func(c *Frame_singleContext)

+ EnterFrame_spec func(c *Frame_specContext)

+ EnterFunction_name func(c *Function_nameContext)

+ EnterIndex_name func(c *Index_nameContext)

+ EnterIndexed_column func(c *Indexed_columnContext)

+ EnterInitial_select func(c *Initial_selectContext)

+ EnterInsert_stmt func(c *Insert_stmtContext)

+ EnterJoin_clause func(c *Join_clauseContext)

+ EnterJoin_constraint func(c *Join_constraintContext)

+ EnterJoin_operator func(c *Join_operatorContext)

+ EnterKeyword func(c *KeywordContext)

+ EnterLimit_stmt func(c *Limit_stmtContext)

+ EnterLiteral_value func(c *Literal_valueContext)

+ EnterModule_argument func(c *Module_argumentContext)

+ EnterModule_name func(c *Module_nameContext)

+ EnterName func(c *NameContext)

+ EnterNew_table_name func(c *New_table_nameContext)

+ EnterOf_OF_fset func(c *Of_OF_fsetContext)

+ EnterOrder_by_expr func(c *Order_by_exprContext)

+ EnterOrder_by_expr_asc_desc func(c *Order_by_expr_asc_descContext)

+ EnterOrder_by_stmt func(c *Order_by_stmtContext)

+ EnterOrdering_term func(c *Ordering_termContext)

+ EnterOver_clause func(c *Over_clauseContext)

+ EnterParse func(c *ParseContext)

+ EnterPartition_by func(c *Partition_byContext)

+ EnterPragma_name func(c *Pragma_nameContext)

+ EnterPragma_stmt func(c *Pragma_stmtContext)

+ EnterPragma_value func(c *Pragma_valueContext)

+ EnterQualified_table_name func(c *Qualified_table_nameContext)

+ EnterRaise_function func(c *Raise_functionContext)

+ EnterRecursive__select func(c *Recursive__selectContext)

+ EnterRecursive_cte func(c *Recursive_cteContext)

+ EnterReindex_stmt func(c *Reindex_stmtContext)

+ EnterRelease_stmt func(c *Release_stmtContext)

+ EnterResult_column func(c *Result_columnContext)

+ EnterRollback_stmt func(c *Rollback_stmtContext)

+ EnterSavepoint_name func(c *Savepoint_nameContext)

+ EnterSavepoint_stmt func(c *Savepoint_stmtContext)

+ EnterSchema_name func(c *Schema_nameContext)

+ EnterSelect_core func(c *Select_coreContext)

+ EnterSelect_stmt func(c *Select_stmtContext)

+ EnterSigned_number func(c *Signed_numberContext)

+ EnterSimple_func func(c *Simple_funcContext)

+ EnterSimple_function_invocation func(c *Simple_function_invocationContext)

+ EnterSimple_select_stmt func(c *Simple_select_stmtContext)

+ EnterSql_stmt func(c *Sql_stmtContext)

+ EnterSql_stmt_list func(c *Sql_stmt_listContext)

+ EnterTable_alias func(c *Table_aliasContext)

+ EnterTable_constraint func(c *Table_constraintContext)

+ EnterTable_function_name func(c *Table_function_nameContext)

+ EnterTable_name func(c *Table_nameContext)

+ EnterTable_or_index_name func(c *Table_or_index_nameContext)

+ EnterTable_or_subquery func(c *Table_or_subqueryContext)

+ EnterTransaction_name func(c *Transaction_nameContext)

+ EnterTrigger_name func(c *Trigger_nameContext)

+ EnterType_name func(c *Type_nameContext)

+ EnterUnary_operator func(c *Unary_operatorContext)

+ EnterUpdate_stmt func(c *Update_stmtContext)

+ EnterUpdate_stmt_limited func(c *Update_stmt_limitedContext)

+ EnterUpsert_clause func(c *Upsert_clauseContext)

+ EnterVacuum_stmt func(c *Vacuum_stmtContext)

+ EnterView_name func(c *View_nameContext)

+ EnterWindow_defn func(c *Window_defnContext)

+ EnterWindow_function func(c *Window_functionContext)

+ EnterWindow_function_invocation func(c *Window_function_invocationContext)

+ EnterWindow_name func(c *Window_nameContext)

+ EnterWith_clause func(c *With_clauseContext)

+ ExitAggregate_func func(c *Aggregate_funcContext)

+ ExitAggregate_function_invocation func(c *Aggregate_function_invocationContext)

+ ExitAlias func(c *AliasContext)

+ ExitAlter_table_stmt func(c *Alter_table_stmtContext)

+ ExitAnalyze_stmt func(c *Analyze_stmtContext)

+ ExitAny_name func(c *Any_nameContext)

+ ExitAsc_desc func(c *Asc_descContext)

+ ExitAttach_stmt func(c *Attach_stmtContext)

+ ExitBase_window_name func(c *Base_window_nameContext)

+ ExitBegin_stmt func(c *Begin_stmtContext)

+ ExitCollation_name func(c *Collation_nameContext)

+ ExitColumn_alias func(c *Column_aliasContext)

+ ExitColumn_constraint func(c *Column_constraintContext)

+ ExitColumn_def func(c *Column_defContext)

+ ExitColumn_name func(c *Column_nameContext)

+ ExitColumn_name_list func(c *Column_name_listContext)

+ ExitCommit_stmt func(c *Commit_stmtContext)

+ ExitCommon_table_expression func(c *Common_table_expressionContext)

+ ExitCommon_table_stmt func(c *Common_table_stmtContext)

+ ExitCompound_operator func(c *Compound_operatorContext)

+ ExitCompound_select_stmt func(c *Compound_select_stmtContext)

+ ExitConflict_clause func(c *Conflict_clauseContext)

+ ExitCreate_index_stmt func(c *Create_index_stmtContext)

+ ExitCreate_table_stmt func(c *Create_table_stmtContext)

+ ExitCreate_trigger_stmt func(c *Create_trigger_stmtContext)

+ ExitCreate_view_stmt func(c *Create_view_stmtContext)

+ ExitCreate_virtual_table_stmt func(c *Create_virtual_table_stmtContext)

+ ExitCte_table_name func(c *Cte_table_nameContext)

+ ExitDefault_DEFAULT__value func(c *Default_DEFAULT__valueContext)

+ ExitDelete_stmt func(c *Delete_stmtContext)

+ ExitDelete_stmt_limited func(c *Delete_stmt_limitedContext)

+ ExitDetach_stmt func(c *Detach_stmtContext)

+ ExitDrop_stmt func(c *Drop_stmtContext)

+ ExitError_message func(c *Error_messageContext)

+ ExitExpr_asc_desc func(c *Expr_asc_descContext)

+ ExitExpr_between func(c *Expr_betweenContext)

+ ExitExpr_binary func(c *Expr_binaryContext)

+ ExitExpr_bind func(c *Expr_bindContext)

+ ExitExpr_case func(c *Expr_caseContext)

+ ExitExpr_cast func(c *Expr_castContext)

+ ExitExpr_collate func(c *Expr_collateContext)

+ ExitExpr_comparison func(c *Expr_comparisonContext)

+ ExitExpr_function func(c *Expr_functionContext)

+ ExitExpr_in_select func(c *Expr_in_selectContext)

+ ExitExpr_list func(c *Expr_listContext)

+ ExitExpr_literal func(c *Expr_literalContext)

+ ExitExpr_math_op func(c *Expr_math_opContext)

+ ExitExpr_null_comp func(c *Expr_null_compContext)

+ ExitExpr_qualified_column_name func(c *Expr_qualified_column_nameContext)

+ ExitExpr_raise func(c *Expr_raiseContext)

+ ExitExpr_unary func(c *Expr_unaryContext)

+ ExitFactored_select_stmt func(c *Factored_select_stmtContext)

+ ExitFilename func(c *FilenameContext)

+ ExitFilter_clause func(c *Filter_clauseContext)

+ ExitForeign_key_clause func(c *Foreign_key_clauseContext)

+ ExitForeign_table func(c *Foreign_tableContext)

+ ExitFrame_clause func(c *Frame_clauseContext)

+ ExitFrame_left func(c *Frame_leftContext)

+ ExitFrame_right func(c *Frame_rightContext)

+ ExitFrame_single func(c *Frame_singleContext)

+ ExitFrame_spec func(c *Frame_specContext)

+ ExitFunction_name func(c *Function_nameContext)

+ ExitIndex_name func(c *Index_nameContext)

+ ExitIndexed_column func(c *Indexed_columnContext)

+ ExitInitial_select func(c *Initial_selectContext)

+ ExitInsert_stmt func(c *Insert_stmtContext)

+ ExitJoin_clause func(c *Join_clauseContext)

+ ExitJoin_constraint func(c *Join_constraintContext)

+ ExitJoin_operator func(c *Join_operatorContext)

+ ExitKeyword func(c *KeywordContext)

+ ExitLimit_stmt func(c *Limit_stmtContext)

+ ExitLiteral_value func(c *Literal_valueContext)

+ ExitModule_argument func(c *Module_argumentContext)

+ ExitModule_name func(c *Module_nameContext)

+ ExitName func(c *NameContext)

+ ExitNew_table_name func(c *New_table_nameContext)

+ ExitOf_OF_fset func(c *Of_OF_fsetContext)

+ ExitOrder_by_expr func(c *Order_by_exprContext)

+ ExitOrder_by_expr_asc_desc func(c *Order_by_expr_asc_descContext)

+ ExitOrder_by_stmt func(c *Order_by_stmtContext)

+ ExitOrdering_term func(c *Ordering_termContext)

+ ExitOver_clause func(c *Over_clauseContext)

+ ExitParse func(c *ParseContext)

+ ExitPartition_by func(c *Partition_byContext)

+ ExitPragma_name func(c *Pragma_nameContext)

+ ExitPragma_stmt func(c *Pragma_stmtContext)

+ ExitPragma_value func(c *Pragma_valueContext)

+ ExitQualified_table_name func(c *Qualified_table_nameContext)

+ ExitRaise_function func(c *Raise_functionContext)

+ ExitRecursive__select func(c *Recursive__selectContext)

+ ExitRecursive_cte func(c *Recursive_cteContext)

+ ExitReindex_stmt func(c *Reindex_stmtContext)

+ ExitRelease_stmt func(c *Release_stmtContext)

+ ExitResult_column func(c *Result_columnContext)

+ ExitRollback_stmt func(c *Rollback_stmtContext)

+ ExitSavepoint_name func(c *Savepoint_nameContext)

+ ExitSavepoint_stmt func(c *Savepoint_stmtContext)

+ ExitSchema_name func(c *Schema_nameContext)

+ ExitSelect_core func(c *Select_coreContext)

+ ExitSelect_stmt func(c *Select_stmtContext)

+ ExitSigned_number func(c *Signed_numberContext)

+ ExitSimple_func func(c *Simple_funcContext)

+ ExitSimple_function_invocation func(c *Simple_function_invocationContext)

+ ExitSimple_select_stmt func(c *Simple_select_stmtContext)

+ ExitSql_stmt func(c *Sql_stmtContext)

+ ExitSql_stmt_list func(c *Sql_stmt_listContext)

+ ExitTable_alias func(c *Table_aliasContext)

+ ExitTable_constraint func(c *Table_constraintContext)

+ ExitTable_function_name func(c *Table_function_nameContext)

+ ExitTable_name func(c *Table_nameContext)

+ ExitTable_or_index_name func(c *Table_or_index_nameContext)

+ ExitTable_or_subquery func(c *Table_or_subqueryContext)

+ ExitTransaction_name func(c *Transaction_nameContext)

+ ExitTrigger_name func(c *Trigger_nameContext)

+ ExitType_name func(c *Type_nameContext)

+ ExitUnary_operator func(c *Unary_operatorContext)

+ ExitUpdate_stmt func(c *Update_stmtContext)

+ ExitUpdate_stmt_limited func(c *Update_stmt_limitedContext)

+ ExitUpsert_clause func(c *Upsert_clauseContext)

+ ExitVacuum_stmt func(c *Vacuum_stmtContext)

+ ExitView_name func(c *View_nameContext)

+ ExitWindow_defn func(c *Window_defnContext)

+ ExitWindow_function func(c *Window_functionContext)

+ ExitWindow_function_invocation func(c *Window_function_invocationContext)

+ ExitWindow_name func(c *Window_nameContext)

+ ExitWith_clause func(c *With_clauseContext)

type Savepoint_stmtContext

+ func (s *Savepoint_stmtContext) SAVEPOINT_() antlr.TerminalNode

type Select_coreContext

+ func (s *Select_coreContext) ALL_() antlr.TerminalNode

+ func (s *Select_coreContext) AS_(i int) antlr.TerminalNode

+ func (s *Select_coreContext) AllAS_() []antlr.TerminalNode

+ func (s *Select_coreContext) AllWindow_defn() []IWindow_defnContext

+ func (s *Select_coreContext) AllWindow_name() []IWindow_nameContext

+ func (s *Select_coreContext) BY_() antlr.TerminalNode

+ func (s *Select_coreContext) DISTINCT_() antlr.TerminalNode

+ func (s *Select_coreContext) FROM_() antlr.TerminalNode

+ func (s *Select_coreContext) GROUP_() antlr.TerminalNode

+ func (s *Select_coreContext) HAVING_() antlr.TerminalNode

+ func (s *Select_coreContext) SELECT_() antlr.TerminalNode

+ func (s *Select_coreContext) VALUES_() antlr.TerminalNode

+ func (s *Select_coreContext) WHERE_() antlr.TerminalNode

+ func (s *Select_coreContext) WINDOW_() antlr.TerminalNode

+ func (s *Select_coreContext) Window_defn(i int) IWindow_defnContext

+ func (s *Select_coreContext) Window_name(i int) IWindow_nameContext

type Select_stmtContext

+ func (s *Select_stmtContext) AllSelect_core() []ISelect_coreContext

+ func (s *Select_stmtContext) Common_table_stmt() ICommon_table_stmtContext

+ func (s *Select_stmtContext) Limit_stmt() ILimit_stmtContext

+ func (s *Select_stmtContext) Order_by_stmt() IOrder_by_stmtContext

+ func (s *Select_stmtContext) Select_core(i int) ISelect_coreContext

+ type Simple_funcContext struct

+ func NewEmptySimple_funcContext() *Simple_funcContext

+ func NewSimple_funcContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Simple_funcContext

+ func (*Simple_funcContext) IsSimple_funcContext()

+ func (s *Simple_funcContext) Any_name() IAny_nameContext

+ func (s *Simple_funcContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Simple_funcContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Simple_funcContext) GetParser() antlr.Parser

+ func (s *Simple_funcContext) GetRuleContext() antlr.RuleContext

+ func (s *Simple_funcContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type Simple_function_invocationContext struct

+ func NewEmptySimple_function_invocationContext() *Simple_function_invocationContext

+ func NewSimple_function_invocationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Simple_function_invocationContext

+ func (*Simple_function_invocationContext) IsSimple_function_invocationContext()

+ func (s *Simple_function_invocationContext) AllCOMMA() []antlr.TerminalNode

+ func (s *Simple_function_invocationContext) AllExpr() []IExprContext

+ func (s *Simple_function_invocationContext) CLOSE_PAR() antlr.TerminalNode

+ func (s *Simple_function_invocationContext) COMMA(i int) antlr.TerminalNode

+ func (s *Simple_function_invocationContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Simple_function_invocationContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Simple_function_invocationContext) Expr(i int) IExprContext

+ func (s *Simple_function_invocationContext) GetParser() antlr.Parser

+ func (s *Simple_function_invocationContext) GetRuleContext() antlr.RuleContext

+ func (s *Simple_function_invocationContext) OPEN_PAR() antlr.TerminalNode

+ func (s *Simple_function_invocationContext) STAR() antlr.TerminalNode

+ func (s *Simple_function_invocationContext) Simple_func() ISimple_funcContext

+ func (s *Simple_function_invocationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Simple_select_stmtContext

+ func (s *Simple_select_stmtContext) Common_table_stmt() ICommon_table_stmtContext

+ func (s *Simple_select_stmtContext) Limit_stmt() ILimit_stmtContext

+ func (s *Simple_select_stmtContext) Order_by_stmt() IOrder_by_stmtContext

type Sql_stmtContext

+ func (s *Sql_stmtContext) Drop_stmt() IDrop_stmtContext

+ func (s *Sql_stmtContext) EXPLAIN_() antlr.TerminalNode

+ func (s *Sql_stmtContext) PLAN_() antlr.TerminalNode

+ func (s *Sql_stmtContext) QUERY_() antlr.TerminalNode

type Table_aliasContext

+ func (s *Table_aliasContext) Any_name() IAny_nameContext

type Table_constraintContext

+ func (s *Table_constraintContext) CHECK_() antlr.TerminalNode

+ func (s *Table_constraintContext) CONSTRAINT_() antlr.TerminalNode

+ func (s *Table_constraintContext) FOREIGN_() antlr.TerminalNode

+ func (s *Table_constraintContext) KEY_() antlr.TerminalNode

+ func (s *Table_constraintContext) PRIMARY_() antlr.TerminalNode

+ func (s *Table_constraintContext) UNIQUE_() antlr.TerminalNode

type Table_or_subqueryContext

+ func (s *Table_or_subqueryContext) AS_() antlr.TerminalNode

+ func (s *Table_or_subqueryContext) BY_() antlr.TerminalNode

+ func (s *Table_or_subqueryContext) INDEXED_() antlr.TerminalNode

+ func (s *Table_or_subqueryContext) NOT_() antlr.TerminalNode

type Unary_operatorContext

+ func (s *Unary_operatorContext) NOT_() antlr.TerminalNode

type Update_stmtContext

+ func (s *Update_stmtContext) ABORT_() antlr.TerminalNode

+ func (s *Update_stmtContext) AllColumn_name_list() []IColumn_name_listContext

+ func (s *Update_stmtContext) Column_name_list(i int) IColumn_name_listContext

+ func (s *Update_stmtContext) FAIL_() antlr.TerminalNode

+ func (s *Update_stmtContext) IGNORE_() antlr.TerminalNode

+ func (s *Update_stmtContext) OR_() antlr.TerminalNode

+ func (s *Update_stmtContext) REPLACE_() antlr.TerminalNode

+ func (s *Update_stmtContext) ROLLBACK_() antlr.TerminalNode

+ func (s *Update_stmtContext) SET_() antlr.TerminalNode

+ func (s *Update_stmtContext) UPDATE_() antlr.TerminalNode

+ func (s *Update_stmtContext) WHERE_() antlr.TerminalNode

type Update_stmt_limitedContext

+ func (s *Update_stmt_limitedContext) ABORT_() antlr.TerminalNode

+ func (s *Update_stmt_limitedContext) AllColumn_name_list() []IColumn_name_listContext

+ func (s *Update_stmt_limitedContext) Column_name_list(i int) IColumn_name_listContext

+ func (s *Update_stmt_limitedContext) FAIL_() antlr.TerminalNode

+ func (s *Update_stmt_limitedContext) IGNORE_() antlr.TerminalNode

+ func (s *Update_stmt_limitedContext) Limit_stmt() ILimit_stmtContext

+ func (s *Update_stmt_limitedContext) OR_() antlr.TerminalNode

+ func (s *Update_stmt_limitedContext) Order_by_stmt() IOrder_by_stmtContext

+ func (s *Update_stmt_limitedContext) REPLACE_() antlr.TerminalNode

+ func (s *Update_stmt_limitedContext) ROLLBACK_() antlr.TerminalNode

+ func (s *Update_stmt_limitedContext) SET_() antlr.TerminalNode

+ func (s *Update_stmt_limitedContext) UPDATE_() antlr.TerminalNode

+ func (s *Update_stmt_limitedContext) WHERE_() antlr.TerminalNode

+ type Upsert_clauseContext struct

+ func NewEmptyUpsert_clauseContext() *Upsert_clauseContext

+ func NewUpsert_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Upsert_clauseContext

+ func (*Upsert_clauseContext) IsUpsert_clauseContext()

+ func (s *Upsert_clauseContext) AllCOMMA() []antlr.TerminalNode

+ func (s *Upsert_clauseContext) AllColumn_name() []IColumn_nameContext

+ func (s *Upsert_clauseContext) AllColumn_name_list() []IColumn_name_listContext

+ func (s *Upsert_clauseContext) AllEQ() []antlr.TerminalNode

+ func (s *Upsert_clauseContext) AllExpr() []IExprContext

+ func (s *Upsert_clauseContext) AllIndexed_column() []IIndexed_columnContext

+ func (s *Upsert_clauseContext) AllWHERE_() []antlr.TerminalNode

+ func (s *Upsert_clauseContext) CLOSE_PAR() antlr.TerminalNode

+ func (s *Upsert_clauseContext) COMMA(i int) antlr.TerminalNode

+ func (s *Upsert_clauseContext) CONFLICT_() antlr.TerminalNode

+ func (s *Upsert_clauseContext) Column_name(i int) IColumn_nameContext

+ func (s *Upsert_clauseContext) Column_name_list(i int) IColumn_name_listContext

+ func (s *Upsert_clauseContext) DO_() antlr.TerminalNode

+ func (s *Upsert_clauseContext) EQ(i int) antlr.TerminalNode

+ func (s *Upsert_clauseContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Upsert_clauseContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Upsert_clauseContext) Expr(i int) IExprContext

+ func (s *Upsert_clauseContext) GetParser() antlr.Parser

+ func (s *Upsert_clauseContext) GetRuleContext() antlr.RuleContext

+ func (s *Upsert_clauseContext) Indexed_column(i int) IIndexed_columnContext

+ func (s *Upsert_clauseContext) NOTHING_() antlr.TerminalNode

+ func (s *Upsert_clauseContext) ON_() antlr.TerminalNode

+ func (s *Upsert_clauseContext) OPEN_PAR() antlr.TerminalNode

+ func (s *Upsert_clauseContext) SET_() antlr.TerminalNode

+ func (s *Upsert_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ func (s *Upsert_clauseContext) UPDATE_() antlr.TerminalNode

+ func (s *Upsert_clauseContext) WHERE_(i int) antlr.TerminalNode

type Vacuum_stmtContext

+ func (s *Vacuum_stmtContext) Filename() IFilenameContext

+ func (s *Vacuum_stmtContext) INTO_() antlr.TerminalNode

+ func (s *Vacuum_stmtContext) Schema_name() ISchema_nameContext

+ func (s *Vacuum_stmtContext) VACUUM_() antlr.TerminalNode

+ type Window_defnContext struct

+ func NewEmptyWindow_defnContext() *Window_defnContext

+ func NewWindow_defnContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Window_defnContext

+ func (*Window_defnContext) IsWindow_defnContext()

+ func (s *Window_defnContext) AllBY_() []antlr.TerminalNode

+ func (s *Window_defnContext) AllCOMMA() []antlr.TerminalNode

+ func (s *Window_defnContext) AllExpr() []IExprContext

+ func (s *Window_defnContext) AllOrdering_term() []IOrdering_termContext

+ func (s *Window_defnContext) BY_(i int) antlr.TerminalNode

+ func (s *Window_defnContext) Base_window_name() IBase_window_nameContext

+ func (s *Window_defnContext) CLOSE_PAR() antlr.TerminalNode

+ func (s *Window_defnContext) COMMA(i int) antlr.TerminalNode

+ func (s *Window_defnContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Window_defnContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Window_defnContext) Expr(i int) IExprContext

+ func (s *Window_defnContext) Frame_spec() IFrame_specContext

+ func (s *Window_defnContext) GetParser() antlr.Parser

+ func (s *Window_defnContext) GetRuleContext() antlr.RuleContext

+ func (s *Window_defnContext) OPEN_PAR() antlr.TerminalNode

+ func (s *Window_defnContext) ORDER_() antlr.TerminalNode

+ func (s *Window_defnContext) Ordering_term(i int) IOrdering_termContext

+ func (s *Window_defnContext) PARTITION_() antlr.TerminalNode

+ func (s *Window_defnContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type Window_functionContext struct

+ func NewEmptyWindow_functionContext() *Window_functionContext

+ func NewWindow_functionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Window_functionContext

+ func (*Window_functionContext) IsWindow_functionContext()

+ func (s *Window_functionContext) AllCLOSE_PAR() []antlr.TerminalNode

+ func (s *Window_functionContext) AllOPEN_PAR() []antlr.TerminalNode

+ func (s *Window_functionContext) CLOSE_PAR(i int) antlr.TerminalNode

+ func (s *Window_functionContext) COMMA() antlr.TerminalNode

+ func (s *Window_functionContext) CUME_DIST_() antlr.TerminalNode

+ func (s *Window_functionContext) DENSE_RANK_() antlr.TerminalNode

+ func (s *Window_functionContext) Default_DEFAULT__value() IDefault_DEFAULT__valueContext

+ func (s *Window_functionContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Window_functionContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Window_functionContext) Expr() IExprContext

+ func (s *Window_functionContext) FIRST_VALUE_() antlr.TerminalNode

+ func (s *Window_functionContext) Frame_clause() IFrame_clauseContext

+ func (s *Window_functionContext) GetParser() antlr.Parser

+ func (s *Window_functionContext) GetRuleContext() antlr.RuleContext

+ func (s *Window_functionContext) LAG_() antlr.TerminalNode

+ func (s *Window_functionContext) LAST_VALUE_() antlr.TerminalNode

+ func (s *Window_functionContext) LEAD_() antlr.TerminalNode

+ func (s *Window_functionContext) NTH_VALUE_() antlr.TerminalNode

+ func (s *Window_functionContext) NTILE_() antlr.TerminalNode

+ func (s *Window_functionContext) OPEN_PAR(i int) antlr.TerminalNode

+ func (s *Window_functionContext) OVER_() antlr.TerminalNode

+ func (s *Window_functionContext) Of_OF_fset() IOf_OF_fsetContext

+ func (s *Window_functionContext) Order_by_expr() IOrder_by_exprContext

+ func (s *Window_functionContext) Order_by_expr_asc_desc() IOrder_by_expr_asc_descContext

+ func (s *Window_functionContext) PERCENT_RANK_() antlr.TerminalNode

+ func (s *Window_functionContext) Partition_by() IPartition_byContext

+ func (s *Window_functionContext) RANK_() antlr.TerminalNode

+ func (s *Window_functionContext) ROW_NUMBER_() antlr.TerminalNode

+ func (s *Window_functionContext) Signed_number() ISigned_numberContext

+ func (s *Window_functionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type Window_function_invocationContext struct

+ func NewEmptyWindow_function_invocationContext() *Window_function_invocationContext

+ func NewWindow_function_invocationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Window_function_invocationContext

+ func (*Window_function_invocationContext) IsWindow_function_invocationContext()

+ func (s *Window_function_invocationContext) AllCOMMA() []antlr.TerminalNode

+ func (s *Window_function_invocationContext) AllExpr() []IExprContext

+ func (s *Window_function_invocationContext) CLOSE_PAR() antlr.TerminalNode

+ func (s *Window_function_invocationContext) COMMA(i int) antlr.TerminalNode

+ func (s *Window_function_invocationContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Window_function_invocationContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Window_function_invocationContext) Expr(i int) IExprContext

+ func (s *Window_function_invocationContext) Filter_clause() IFilter_clauseContext

+ func (s *Window_function_invocationContext) GetParser() antlr.Parser

+ func (s *Window_function_invocationContext) GetRuleContext() antlr.RuleContext

+ func (s *Window_function_invocationContext) OPEN_PAR() antlr.TerminalNode

+ func (s *Window_function_invocationContext) OVER_() antlr.TerminalNode

+ func (s *Window_function_invocationContext) STAR() antlr.TerminalNode

+ func (s *Window_function_invocationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ func (s *Window_function_invocationContext) Window_defn() IWindow_defnContext

+ func (s *Window_function_invocationContext) Window_function() IWindow_functionContext

+ func (s *Window_function_invocationContext) Window_name() IWindow_nameContext

+ type Window_nameContext struct

+ func NewEmptyWindow_nameContext() *Window_nameContext

+ func NewWindow_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Window_nameContext

+ func (*Window_nameContext) IsWindow_nameContext()

+ func (s *Window_nameContext) Any_name() IAny_nameContext

+ func (s *Window_nameContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Window_nameContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Window_nameContext) GetParser() antlr.Parser

+ func (s *Window_nameContext) GetRuleContext() antlr.RuleContext

+ func (s *Window_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type With_clauseContext

+ func (s *With_clauseContext) AS_(i int) antlr.TerminalNode

+ func (s *With_clauseContext) AllAS_() []antlr.TerminalNode

+ func (s *With_clauseContext) AllCLOSE_PAR() []antlr.TerminalNode

+ func (s *With_clauseContext) AllCte_table_name() []ICte_table_nameContext

+ func (s *With_clauseContext) AllOPEN_PAR() []antlr.TerminalNode

+ func (s *With_clauseContext) AllSelect_stmt() []ISelect_stmtContext

+ func (s *With_clauseContext) CLOSE_PAR(i int) antlr.TerminalNode

+ func (s *With_clauseContext) Cte_table_name(i int) ICte_table_nameContext

+ func (s *With_clauseContext) OPEN_PAR(i int) antlr.TerminalNode

+ func (s *With_clauseContext) RECURSIVE_() antlr.TerminalNode

+ func (s *With_clauseContext) Select_stmt(i int) ISelect_stmtContext

+ func (s *With_clauseContext) WITH_() antlr.TerminalNode

v1.15.0

Apr 20, 2022

v1.14.8

Jan 11, 2022

v1.14.7

Jan 11, 2022

v1.14.6

Jan 10, 2022

v1.14.5

Jan 10, 2022

v1.14.4

Dec 14, 2021

v1.14.3

Nov 29, 2021

v1.14.2

Jul 29, 2021

v1.14.1

Jun 11, 2021

v1.14.0

Jun 11, 2021

v1.13.10

Jun 10, 2021

v1.13.9

Jun 10, 2021

v1.13.8

Jun 9, 2021

v1.13.7

Jun 9, 2021

v1.13.6

Jun 8, 2021

v1.13.5

Jun 8, 2021

v1.13.4

Jun 3, 2021

v1.13.3

Jun 3, 2021

v1.13.2

Jun 3, 2021

v1.13.1

Jun 3, 2021

v1.13.0

Jun 3, 2021

v1.12.1

May 25, 2021

v1.12.0

May 25, 2021

v1.11.0

May 21, 2021

v1.10.0

Apr 29, 2021

v1.9.0

Mar 21, 2021

v1.8.0

Mar 6, 2021

v1.7.0

Mar 6, 2021

Changes in this version

+ const SQLiteLexerAMP

+ const SQLiteLexerASSIGN

+ const SQLiteLexerBIND_PARAMETER

+ const SQLiteLexerBLOB_LITERAL

+ const SQLiteLexerCLOSE_PAR

+ const SQLiteLexerCOMMA

+ const SQLiteLexerDIV

+ const SQLiteLexerDOT

+ const SQLiteLexerEQ

+ const SQLiteLexerGT

+ const SQLiteLexerGT2

+ const SQLiteLexerGT_EQ

+ const SQLiteLexerIDENTIFIER

+ const SQLiteLexerK_ABORT

+ const SQLiteLexerK_ACTION

+ const SQLiteLexerK_ADD

+ const SQLiteLexerK_AFTER

+ const SQLiteLexerK_ALL

+ const SQLiteLexerK_ALTER

+ const SQLiteLexerK_ANALYZE

+ const SQLiteLexerK_AND

+ const SQLiteLexerK_AS

+ const SQLiteLexerK_ASC

+ const SQLiteLexerK_ATTACH

+ const SQLiteLexerK_AUTOINCREMENT

+ const SQLiteLexerK_BEFORE

+ const SQLiteLexerK_BEGIN

+ const SQLiteLexerK_BETWEEN

+ const SQLiteLexerK_BY

+ const SQLiteLexerK_CASCADE

+ const SQLiteLexerK_CASE

+ const SQLiteLexerK_CAST

+ const SQLiteLexerK_CHECK

+ const SQLiteLexerK_COLLATE

+ const SQLiteLexerK_COLUMN

+ const SQLiteLexerK_COMMIT

+ const SQLiteLexerK_CONFLICT

+ const SQLiteLexerK_CONSTRAINT

+ const SQLiteLexerK_CREATE

+ const SQLiteLexerK_CROSS

+ const SQLiteLexerK_CURRENT_DATE

+ const SQLiteLexerK_CURRENT_TIME

+ const SQLiteLexerK_CURRENT_TIMESTAMP

+ const SQLiteLexerK_DATABASE

+ const SQLiteLexerK_DEFAULT

+ const SQLiteLexerK_DEFERRABLE

+ const SQLiteLexerK_DEFERRED

+ const SQLiteLexerK_DELETE

+ const SQLiteLexerK_DESC

+ const SQLiteLexerK_DETACH

+ const SQLiteLexerK_DISTINCT

+ const SQLiteLexerK_DROP

+ const SQLiteLexerK_EACH

+ const SQLiteLexerK_ELSE

+ const SQLiteLexerK_END

+ const SQLiteLexerK_ESCAPE

+ const SQLiteLexerK_EXCEPT

+ const SQLiteLexerK_EXCLUSIVE

+ const SQLiteLexerK_EXISTS

+ const SQLiteLexerK_EXPLAIN

+ const SQLiteLexerK_FAIL

+ const SQLiteLexerK_FOR

+ const SQLiteLexerK_FOREIGN

+ const SQLiteLexerK_FROM

+ const SQLiteLexerK_FULL

+ const SQLiteLexerK_GLOB

+ const SQLiteLexerK_GROUP

+ const SQLiteLexerK_HAVING

+ const SQLiteLexerK_IF

+ const SQLiteLexerK_IGNORE

+ const SQLiteLexerK_IMMEDIATE

+ const SQLiteLexerK_IN

+ const SQLiteLexerK_INDEX

+ const SQLiteLexerK_INDEXED

+ const SQLiteLexerK_INITIALLY

+ const SQLiteLexerK_INNER

+ const SQLiteLexerK_INSERT

+ const SQLiteLexerK_INSTEAD

+ const SQLiteLexerK_INTERSECT

+ const SQLiteLexerK_INTO

+ const SQLiteLexerK_IS

+ const SQLiteLexerK_ISNULL

+ const SQLiteLexerK_JOIN

+ const SQLiteLexerK_KEY

+ const SQLiteLexerK_LEFT

+ const SQLiteLexerK_LIKE

+ const SQLiteLexerK_LIMIT

+ const SQLiteLexerK_MATCH

+ const SQLiteLexerK_NATURAL

+ const SQLiteLexerK_NO

+ const SQLiteLexerK_NOT

+ const SQLiteLexerK_NOTNULL

+ const SQLiteLexerK_NULL

+ const SQLiteLexerK_OF

+ const SQLiteLexerK_OFFSET

+ const SQLiteLexerK_ON

+ const SQLiteLexerK_OR

+ const SQLiteLexerK_ORDER

+ const SQLiteLexerK_OUTER

+ const SQLiteLexerK_PLAN

+ const SQLiteLexerK_PRAGMA

+ const SQLiteLexerK_PRIMARY

+ const SQLiteLexerK_QUERY

+ const SQLiteLexerK_RAISE

+ const SQLiteLexerK_RECURSIVE

+ const SQLiteLexerK_REFERENCES

+ const SQLiteLexerK_REGEXP

+ const SQLiteLexerK_REINDEX

+ const SQLiteLexerK_RELEASE

+ const SQLiteLexerK_RENAME

+ const SQLiteLexerK_REPLACE

+ const SQLiteLexerK_RESTRICT

+ const SQLiteLexerK_RIGHT

+ const SQLiteLexerK_ROLLBACK

+ const SQLiteLexerK_ROW

+ const SQLiteLexerK_SAVEPOINT

+ const SQLiteLexerK_SELECT

+ const SQLiteLexerK_SET

+ const SQLiteLexerK_TABLE

+ const SQLiteLexerK_TEMP

+ const SQLiteLexerK_TEMPORARY

+ const SQLiteLexerK_THEN

+ const SQLiteLexerK_TO

+ const SQLiteLexerK_TRANSACTION

+ const SQLiteLexerK_TRIGGER

+ const SQLiteLexerK_UNION

+ const SQLiteLexerK_UNIQUE

+ const SQLiteLexerK_UPDATE

+ const SQLiteLexerK_USING

+ const SQLiteLexerK_VACUUM

+ const SQLiteLexerK_VALUES

+ const SQLiteLexerK_VIEW

+ const SQLiteLexerK_VIRTUAL

+ const SQLiteLexerK_WHEN

+ const SQLiteLexerK_WHERE

+ const SQLiteLexerK_WITH

+ const SQLiteLexerK_WITHOUT

+ const SQLiteLexerLT

+ const SQLiteLexerLT2

+ const SQLiteLexerLT_EQ

+ const SQLiteLexerMINUS

+ const SQLiteLexerMOD

+ const SQLiteLexerMULTILINE_COMMENT

+ const SQLiteLexerNOT_EQ1

+ const SQLiteLexerNOT_EQ2

+ const SQLiteLexerNUMERIC_LITERAL

+ const SQLiteLexerOPEN_PAR

+ const SQLiteLexerPIPE

+ const SQLiteLexerPIPE2

+ const SQLiteLexerPLUS

+ const SQLiteLexerSCOL

+ const SQLiteLexerSINGLE_LINE_COMMENT

+ const SQLiteLexerSPACES

+ const SQLiteLexerSTAR

+ const SQLiteLexerSTRING_LITERAL

+ const SQLiteLexerTILDE

+ const SQLiteLexerUNEXPECTED_CHAR

+ const SQLiteParserAMP

+ const SQLiteParserASSIGN

+ const SQLiteParserBIND_PARAMETER

+ const SQLiteParserBLOB_LITERAL

+ const SQLiteParserCLOSE_PAR

+ const SQLiteParserCOMMA

+ const SQLiteParserDIV

+ const SQLiteParserDOT

+ const SQLiteParserEOF

+ const SQLiteParserEQ

+ const SQLiteParserGT

+ const SQLiteParserGT2

+ const SQLiteParserGT_EQ

+ const SQLiteParserIDENTIFIER

+ const SQLiteParserK_ABORT

+ const SQLiteParserK_ACTION

+ const SQLiteParserK_ADD

+ const SQLiteParserK_AFTER

+ const SQLiteParserK_ALL

+ const SQLiteParserK_ALTER

+ const SQLiteParserK_ANALYZE

+ const SQLiteParserK_AND

+ const SQLiteParserK_AS

+ const SQLiteParserK_ASC

+ const SQLiteParserK_ATTACH

+ const SQLiteParserK_AUTOINCREMENT

+ const SQLiteParserK_BEFORE

+ const SQLiteParserK_BEGIN

+ const SQLiteParserK_BETWEEN

+ const SQLiteParserK_BY

+ const SQLiteParserK_CASCADE

+ const SQLiteParserK_CASE

+ const SQLiteParserK_CAST

+ const SQLiteParserK_CHECK

+ const SQLiteParserK_COLLATE

+ const SQLiteParserK_COLUMN

+ const SQLiteParserK_COMMIT

+ const SQLiteParserK_CONFLICT

+ const SQLiteParserK_CONSTRAINT

+ const SQLiteParserK_CREATE

+ const SQLiteParserK_CROSS

+ const SQLiteParserK_CURRENT_DATE

+ const SQLiteParserK_CURRENT_TIME

+ const SQLiteParserK_CURRENT_TIMESTAMP

+ const SQLiteParserK_DATABASE

+ const SQLiteParserK_DEFAULT

+ const SQLiteParserK_DEFERRABLE

+ const SQLiteParserK_DEFERRED

+ const SQLiteParserK_DELETE

+ const SQLiteParserK_DESC

+ const SQLiteParserK_DETACH

+ const SQLiteParserK_DISTINCT

+ const SQLiteParserK_DROP

+ const SQLiteParserK_EACH

+ const SQLiteParserK_ELSE

+ const SQLiteParserK_END

+ const SQLiteParserK_ESCAPE

+ const SQLiteParserK_EXCEPT

+ const SQLiteParserK_EXCLUSIVE

+ const SQLiteParserK_EXISTS

+ const SQLiteParserK_EXPLAIN

+ const SQLiteParserK_FAIL

+ const SQLiteParserK_FOR

+ const SQLiteParserK_FOREIGN

+ const SQLiteParserK_FROM

+ const SQLiteParserK_FULL

+ const SQLiteParserK_GLOB

+ const SQLiteParserK_GROUP

+ const SQLiteParserK_HAVING

+ const SQLiteParserK_IF

+ const SQLiteParserK_IGNORE

+ const SQLiteParserK_IMMEDIATE

+ const SQLiteParserK_IN

+ const SQLiteParserK_INDEX

+ const SQLiteParserK_INDEXED

+ const SQLiteParserK_INITIALLY

+ const SQLiteParserK_INNER

+ const SQLiteParserK_INSERT

+ const SQLiteParserK_INSTEAD

+ const SQLiteParserK_INTERSECT

+ const SQLiteParserK_INTO

+ const SQLiteParserK_IS

+ const SQLiteParserK_ISNULL

+ const SQLiteParserK_JOIN

+ const SQLiteParserK_KEY

+ const SQLiteParserK_LEFT

+ const SQLiteParserK_LIKE

+ const SQLiteParserK_LIMIT

+ const SQLiteParserK_MATCH

+ const SQLiteParserK_NATURAL

+ const SQLiteParserK_NO

+ const SQLiteParserK_NOT

+ const SQLiteParserK_NOTNULL

+ const SQLiteParserK_NULL

+ const SQLiteParserK_OF

+ const SQLiteParserK_OFFSET

+ const SQLiteParserK_ON

+ const SQLiteParserK_OR

+ const SQLiteParserK_ORDER

+ const SQLiteParserK_OUTER

+ const SQLiteParserK_PLAN

+ const SQLiteParserK_PRAGMA

+ const SQLiteParserK_PRIMARY

+ const SQLiteParserK_QUERY

+ const SQLiteParserK_RAISE

+ const SQLiteParserK_RECURSIVE

+ const SQLiteParserK_REFERENCES

+ const SQLiteParserK_REGEXP

+ const SQLiteParserK_REINDEX

+ const SQLiteParserK_RELEASE

+ const SQLiteParserK_RENAME

+ const SQLiteParserK_REPLACE

+ const SQLiteParserK_RESTRICT

+ const SQLiteParserK_RIGHT

+ const SQLiteParserK_ROLLBACK

+ const SQLiteParserK_ROW

+ const SQLiteParserK_SAVEPOINT

+ const SQLiteParserK_SELECT

+ const SQLiteParserK_SET

+ const SQLiteParserK_TABLE

+ const SQLiteParserK_TEMP

+ const SQLiteParserK_TEMPORARY

+ const SQLiteParserK_THEN

+ const SQLiteParserK_TO

+ const SQLiteParserK_TRANSACTION

+ const SQLiteParserK_TRIGGER

+ const SQLiteParserK_UNION

+ const SQLiteParserK_UNIQUE

+ const SQLiteParserK_UPDATE

+ const SQLiteParserK_USING

+ const SQLiteParserK_VACUUM

+ const SQLiteParserK_VALUES

+ const SQLiteParserK_VIEW

+ const SQLiteParserK_VIRTUAL

+ const SQLiteParserK_WHEN

+ const SQLiteParserK_WHERE

+ const SQLiteParserK_WITH

+ const SQLiteParserK_WITHOUT

+ const SQLiteParserLT

+ const SQLiteParserLT2

+ const SQLiteParserLT_EQ

+ const SQLiteParserMINUS

+ const SQLiteParserMOD

+ const SQLiteParserMULTILINE_COMMENT

+ const SQLiteParserNOT_EQ1

+ const SQLiteParserNOT_EQ2

+ const SQLiteParserNUMERIC_LITERAL

+ const SQLiteParserOPEN_PAR

+ const SQLiteParserPIPE

+ const SQLiteParserPIPE2

+ const SQLiteParserPLUS

+ const SQLiteParserRULE_alter_table_stmt

+ const SQLiteParserRULE_analyze_stmt

+ const SQLiteParserRULE_any_name

+ const SQLiteParserRULE_attach_stmt

+ const SQLiteParserRULE_begin_stmt

+ const SQLiteParserRULE_collation_name

+ const SQLiteParserRULE_column_alias

+ const SQLiteParserRULE_column_constraint

+ const SQLiteParserRULE_column_def

+ const SQLiteParserRULE_column_name

+ const SQLiteParserRULE_commit_stmt

+ const SQLiteParserRULE_common_table_expression

+ const SQLiteParserRULE_compound_operator

+ const SQLiteParserRULE_compound_select_stmt

+ const SQLiteParserRULE_conflict_clause

+ const SQLiteParserRULE_create_index_stmt

+ const SQLiteParserRULE_create_table_stmt

+ const SQLiteParserRULE_create_trigger_stmt

+ const SQLiteParserRULE_create_view_stmt

+ const SQLiteParserRULE_create_virtual_table_stmt

+ const SQLiteParserRULE_database_name

+ const SQLiteParserRULE_delete_stmt

+ const SQLiteParserRULE_delete_stmt_limited

+ const SQLiteParserRULE_detach_stmt

+ const SQLiteParserRULE_drop_index_stmt

+ const SQLiteParserRULE_drop_table_stmt

+ const SQLiteParserRULE_drop_trigger_stmt

+ const SQLiteParserRULE_drop_view_stmt

+ const SQLiteParserRULE_error_message

+ const SQLiteParserRULE_expr

+ const SQLiteParserRULE_factored_select_stmt

+ const SQLiteParserRULE_foreign_key_clause

+ const SQLiteParserRULE_foreign_table

+ const SQLiteParserRULE_function_name

+ const SQLiteParserRULE_index_name

+ const SQLiteParserRULE_indexed_column

+ const SQLiteParserRULE_insert_stmt

+ const SQLiteParserRULE_join_clause

+ const SQLiteParserRULE_join_constraint

+ const SQLiteParserRULE_join_operator

+ const SQLiteParserRULE_keyword

+ const SQLiteParserRULE_literal_value

+ const SQLiteParserRULE_module_argument

+ const SQLiteParserRULE_module_name

+ const SQLiteParserRULE_name

+ const SQLiteParserRULE_new_column_name

+ const SQLiteParserRULE_new_table_name

+ const SQLiteParserRULE_ordering_term

+ const SQLiteParserRULE_parse

+ const SQLiteParserRULE_pragma_name

+ const SQLiteParserRULE_pragma_stmt

+ const SQLiteParserRULE_pragma_value

+ const SQLiteParserRULE_qualified_table_name

+ const SQLiteParserRULE_raise_function

+ const SQLiteParserRULE_reindex_stmt

+ const SQLiteParserRULE_release_stmt

+ const SQLiteParserRULE_result_column

+ const SQLiteParserRULE_rollback_stmt

+ const SQLiteParserRULE_savepoint_name

+ const SQLiteParserRULE_savepoint_stmt

+ const SQLiteParserRULE_schema_name

+ const SQLiteParserRULE_select_core

+ const SQLiteParserRULE_select_or_values

+ const SQLiteParserRULE_select_stmt

+ const SQLiteParserRULE_signed_number

+ const SQLiteParserRULE_simple_select_stmt

+ const SQLiteParserRULE_sql_stmt

+ const SQLiteParserRULE_sql_stmt_list

+ const SQLiteParserRULE_table_alias

+ const SQLiteParserRULE_table_constraint

+ const SQLiteParserRULE_table_function_name

+ const SQLiteParserRULE_table_name

+ const SQLiteParserRULE_table_or_index_name

+ const SQLiteParserRULE_table_or_subquery

+ const SQLiteParserRULE_transaction_name

+ const SQLiteParserRULE_trigger_name

+ const SQLiteParserRULE_type_name

+ const SQLiteParserRULE_unary_operator

+ const SQLiteParserRULE_update_stmt

+ const SQLiteParserRULE_update_stmt_limited

+ const SQLiteParserRULE_vacuum_stmt

+ const SQLiteParserRULE_view_name

+ const SQLiteParserRULE_with_clause

+ const SQLiteParserSCOL

+ const SQLiteParserSINGLE_LINE_COMMENT

+ const SQLiteParserSPACES

+ const SQLiteParserSTAR

+ const SQLiteParserSTRING_LITERAL

+ const SQLiteParserTILDE

+ const SQLiteParserUNEXPECTED_CHAR

+ type Alter_table_stmtContext struct

+ func NewAlter_table_stmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_table_stmtContext

+ func NewEmptyAlter_table_stmtContext() *Alter_table_stmtContext

+ func (*Alter_table_stmtContext) IsAlter_table_stmtContext()

+ func (s *Alter_table_stmtContext) Column_def() IColumn_defContext

+ func (s *Alter_table_stmtContext) Column_name() IColumn_nameContext

+ func (s *Alter_table_stmtContext) DOT() antlr.TerminalNode

+ func (s *Alter_table_stmtContext) Database_name() IDatabase_nameContext

+ func (s *Alter_table_stmtContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Alter_table_stmtContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Alter_table_stmtContext) GetParser() antlr.Parser

+ func (s *Alter_table_stmtContext) GetRuleContext() antlr.RuleContext

+ func (s *Alter_table_stmtContext) K_ADD() antlr.TerminalNode

+ func (s *Alter_table_stmtContext) K_ALTER() antlr.TerminalNode

+ func (s *Alter_table_stmtContext) K_COLUMN() antlr.TerminalNode

+ func (s *Alter_table_stmtContext) K_RENAME() antlr.TerminalNode

+ func (s *Alter_table_stmtContext) K_TABLE() antlr.TerminalNode

+ func (s *Alter_table_stmtContext) K_TO() antlr.TerminalNode

+ func (s *Alter_table_stmtContext) New_column_name() INew_column_nameContext

+ func (s *Alter_table_stmtContext) New_table_name() INew_table_nameContext

+ func (s *Alter_table_stmtContext) Table_name() ITable_nameContext

+ func (s *Alter_table_stmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type Analyze_stmtContext struct

+ func NewAnalyze_stmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Analyze_stmtContext

+ func NewEmptyAnalyze_stmtContext() *Analyze_stmtContext

+ func (*Analyze_stmtContext) IsAnalyze_stmtContext()

+ func (s *Analyze_stmtContext) DOT() antlr.TerminalNode

+ func (s *Analyze_stmtContext) Database_name() IDatabase_nameContext

+ func (s *Analyze_stmtContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Analyze_stmtContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Analyze_stmtContext) GetParser() antlr.Parser

+ func (s *Analyze_stmtContext) GetRuleContext() antlr.RuleContext

+ func (s *Analyze_stmtContext) K_ANALYZE() antlr.TerminalNode

+ func (s *Analyze_stmtContext) Table_or_index_name() ITable_or_index_nameContext

+ func (s *Analyze_stmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type Any_nameContext struct

+ func NewAny_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Any_nameContext

+ func NewEmptyAny_nameContext() *Any_nameContext

+ func (*Any_nameContext) IsAny_nameContext()

+ func (s *Any_nameContext) Any_name() IAny_nameContext

+ func (s *Any_nameContext) CLOSE_PAR() antlr.TerminalNode

+ func (s *Any_nameContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Any_nameContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Any_nameContext) GetParser() antlr.Parser

+ func (s *Any_nameContext) GetRuleContext() antlr.RuleContext

+ func (s *Any_nameContext) IDENTIFIER() antlr.TerminalNode

+ func (s *Any_nameContext) Keyword() IKeywordContext

+ func (s *Any_nameContext) OPEN_PAR() antlr.TerminalNode

+ func (s *Any_nameContext) STRING_LITERAL() antlr.TerminalNode

+ func (s *Any_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type Attach_stmtContext struct

+ func NewAttach_stmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Attach_stmtContext

+ func NewEmptyAttach_stmtContext() *Attach_stmtContext

+ func (*Attach_stmtContext) IsAttach_stmtContext()

+ func (s *Attach_stmtContext) Database_name() IDatabase_nameContext

+ func (s *Attach_stmtContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Attach_stmtContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Attach_stmtContext) Expr() IExprContext

+ func (s *Attach_stmtContext) GetParser() antlr.Parser

+ func (s *Attach_stmtContext) GetRuleContext() antlr.RuleContext

+ func (s *Attach_stmtContext) K_AS() antlr.TerminalNode

+ func (s *Attach_stmtContext) K_ATTACH() antlr.TerminalNode

+ func (s *Attach_stmtContext) K_DATABASE() antlr.TerminalNode

+ func (s *Attach_stmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type BaseSQLiteListener struct

+ func (s *BaseSQLiteListener) EnterAlter_table_stmt(ctx *Alter_table_stmtContext)

+ func (s *BaseSQLiteListener) EnterAnalyze_stmt(ctx *Analyze_stmtContext)

+ func (s *BaseSQLiteListener) EnterAny_name(ctx *Any_nameContext)

+ func (s *BaseSQLiteListener) EnterAttach_stmt(ctx *Attach_stmtContext)

+ func (s *BaseSQLiteListener) EnterBegin_stmt(ctx *Begin_stmtContext)

+ func (s *BaseSQLiteListener) EnterCollation_name(ctx *Collation_nameContext)

+ func (s *BaseSQLiteListener) EnterColumn_alias(ctx *Column_aliasContext)

+ func (s *BaseSQLiteListener) EnterColumn_constraint(ctx *Column_constraintContext)

+ func (s *BaseSQLiteListener) EnterColumn_def(ctx *Column_defContext)

+ func (s *BaseSQLiteListener) EnterColumn_name(ctx *Column_nameContext)

+ func (s *BaseSQLiteListener) EnterCommit_stmt(ctx *Commit_stmtContext)

+ func (s *BaseSQLiteListener) EnterCommon_table_expression(ctx *Common_table_expressionContext)

+ func (s *BaseSQLiteListener) EnterCompound_operator(ctx *Compound_operatorContext)

+ func (s *BaseSQLiteListener) EnterCompound_select_stmt(ctx *Compound_select_stmtContext)

+ func (s *BaseSQLiteListener) EnterConflict_clause(ctx *Conflict_clauseContext)

+ func (s *BaseSQLiteListener) EnterCreate_index_stmt(ctx *Create_index_stmtContext)

+ func (s *BaseSQLiteListener) EnterCreate_table_stmt(ctx *Create_table_stmtContext)

+ func (s *BaseSQLiteListener) EnterCreate_trigger_stmt(ctx *Create_trigger_stmtContext)

+ func (s *BaseSQLiteListener) EnterCreate_view_stmt(ctx *Create_view_stmtContext)

+ func (s *BaseSQLiteListener) EnterCreate_virtual_table_stmt(ctx *Create_virtual_table_stmtContext)

+ func (s *BaseSQLiteListener) EnterDatabase_name(ctx *Database_nameContext)

+ func (s *BaseSQLiteListener) EnterDelete_stmt(ctx *Delete_stmtContext)

+ func (s *BaseSQLiteListener) EnterDelete_stmt_limited(ctx *Delete_stmt_limitedContext)

+ func (s *BaseSQLiteListener) EnterDetach_stmt(ctx *Detach_stmtContext)

+ func (s *BaseSQLiteListener) EnterDrop_index_stmt(ctx *Drop_index_stmtContext)

+ func (s *BaseSQLiteListener) EnterDrop_table_stmt(ctx *Drop_table_stmtContext)

+ func (s *BaseSQLiteListener) EnterDrop_trigger_stmt(ctx *Drop_trigger_stmtContext)

+ func (s *BaseSQLiteListener) EnterDrop_view_stmt(ctx *Drop_view_stmtContext)

+ func (s *BaseSQLiteListener) EnterError_message(ctx *Error_messageContext)

+ func (s *BaseSQLiteListener) EnterEveryRule(ctx antlr.ParserRuleContext)

+ func (s *BaseSQLiteListener) EnterExpr(ctx *ExprContext)

+ func (s *BaseSQLiteListener) EnterFactored_select_stmt(ctx *Factored_select_stmtContext)

+ func (s *BaseSQLiteListener) EnterForeign_key_clause(ctx *Foreign_key_clauseContext)

+ func (s *BaseSQLiteListener) EnterForeign_table(ctx *Foreign_tableContext)

+ func (s *BaseSQLiteListener) EnterFunction_name(ctx *Function_nameContext)

+ func (s *BaseSQLiteListener) EnterIndex_name(ctx *Index_nameContext)

+ func (s *BaseSQLiteListener) EnterIndexed_column(ctx *Indexed_columnContext)

+ func (s *BaseSQLiteListener) EnterInsert_stmt(ctx *Insert_stmtContext)

+ func (s *BaseSQLiteListener) EnterJoin_clause(ctx *Join_clauseContext)

+ func (s *BaseSQLiteListener) EnterJoin_constraint(ctx *Join_constraintContext)

+ func (s *BaseSQLiteListener) EnterJoin_operator(ctx *Join_operatorContext)

+ func (s *BaseSQLiteListener) EnterKeyword(ctx *KeywordContext)

+ func (s *BaseSQLiteListener) EnterLiteral_value(ctx *Literal_valueContext)

+ func (s *BaseSQLiteListener) EnterModule_argument(ctx *Module_argumentContext)

+ func (s *BaseSQLiteListener) EnterModule_name(ctx *Module_nameContext)

+ func (s *BaseSQLiteListener) EnterName(ctx *NameContext)

+ func (s *BaseSQLiteListener) EnterNew_column_name(ctx *New_column_nameContext)

+ func (s *BaseSQLiteListener) EnterNew_table_name(ctx *New_table_nameContext)

+ func (s *BaseSQLiteListener) EnterOrdering_term(ctx *Ordering_termContext)

+ func (s *BaseSQLiteListener) EnterParse(ctx *ParseContext)

+ func (s *BaseSQLiteListener) EnterPragma_name(ctx *Pragma_nameContext)

+ func (s *BaseSQLiteListener) EnterPragma_stmt(ctx *Pragma_stmtContext)

+ func (s *BaseSQLiteListener) EnterPragma_value(ctx *Pragma_valueContext)

+ func (s *BaseSQLiteListener) EnterQualified_table_name(ctx *Qualified_table_nameContext)

+ func (s *BaseSQLiteListener) EnterRaise_function(ctx *Raise_functionContext)

+ func (s *BaseSQLiteListener) EnterReindex_stmt(ctx *Reindex_stmtContext)

+ func (s *BaseSQLiteListener) EnterRelease_stmt(ctx *Release_stmtContext)

+ func (s *BaseSQLiteListener) EnterResult_column(ctx *Result_columnContext)

+ func (s *BaseSQLiteListener) EnterRollback_stmt(ctx *Rollback_stmtContext)

+ func (s *BaseSQLiteListener) EnterSavepoint_name(ctx *Savepoint_nameContext)

+ func (s *BaseSQLiteListener) EnterSavepoint_stmt(ctx *Savepoint_stmtContext)

+ func (s *BaseSQLiteListener) EnterSchema_name(ctx *Schema_nameContext)

+ func (s *BaseSQLiteListener) EnterSelect_core(ctx *Select_coreContext)

+ func (s *BaseSQLiteListener) EnterSelect_or_values(ctx *Select_or_valuesContext)

+ func (s *BaseSQLiteListener) EnterSelect_stmt(ctx *Select_stmtContext)

+ func (s *BaseSQLiteListener) EnterSigned_number(ctx *Signed_numberContext)

+ func (s *BaseSQLiteListener) EnterSimple_select_stmt(ctx *Simple_select_stmtContext)

+ func (s *BaseSQLiteListener) EnterSql_stmt(ctx *Sql_stmtContext)

+ func (s *BaseSQLiteListener) EnterSql_stmt_list(ctx *Sql_stmt_listContext)

+ func (s *BaseSQLiteListener) EnterTable_alias(ctx *Table_aliasContext)

+ func (s *BaseSQLiteListener) EnterTable_constraint(ctx *Table_constraintContext)

+ func (s *BaseSQLiteListener) EnterTable_function_name(ctx *Table_function_nameContext)

+ func (s *BaseSQLiteListener) EnterTable_name(ctx *Table_nameContext)

+ func (s *BaseSQLiteListener) EnterTable_or_index_name(ctx *Table_or_index_nameContext)

+ func (s *BaseSQLiteListener) EnterTable_or_subquery(ctx *Table_or_subqueryContext)

+ func (s *BaseSQLiteListener) EnterTransaction_name(ctx *Transaction_nameContext)

+ func (s *BaseSQLiteListener) EnterTrigger_name(ctx *Trigger_nameContext)

+ func (s *BaseSQLiteListener) EnterType_name(ctx *Type_nameContext)

+ func (s *BaseSQLiteListener) EnterUnary_operator(ctx *Unary_operatorContext)

+ func (s *BaseSQLiteListener) EnterUpdate_stmt(ctx *Update_stmtContext)

+ func (s *BaseSQLiteListener) EnterUpdate_stmt_limited(ctx *Update_stmt_limitedContext)

+ func (s *BaseSQLiteListener) EnterVacuum_stmt(ctx *Vacuum_stmtContext)

+ func (s *BaseSQLiteListener) EnterView_name(ctx *View_nameContext)

+ func (s *BaseSQLiteListener) EnterWith_clause(ctx *With_clauseContext)

+ func (s *BaseSQLiteListener) ExitAlter_table_stmt(ctx *Alter_table_stmtContext)

+ func (s *BaseSQLiteListener) ExitAnalyze_stmt(ctx *Analyze_stmtContext)

+ func (s *BaseSQLiteListener) ExitAny_name(ctx *Any_nameContext)

+ func (s *BaseSQLiteListener) ExitAttach_stmt(ctx *Attach_stmtContext)

+ func (s *BaseSQLiteListener) ExitBegin_stmt(ctx *Begin_stmtContext)

+ func (s *BaseSQLiteListener) ExitCollation_name(ctx *Collation_nameContext)

+ func (s *BaseSQLiteListener) ExitColumn_alias(ctx *Column_aliasContext)

+ func (s *BaseSQLiteListener) ExitColumn_constraint(ctx *Column_constraintContext)

+ func (s *BaseSQLiteListener) ExitColumn_def(ctx *Column_defContext)

+ func (s *BaseSQLiteListener) ExitColumn_name(ctx *Column_nameContext)

+ func (s *BaseSQLiteListener) ExitCommit_stmt(ctx *Commit_stmtContext)

+ func (s *BaseSQLiteListener) ExitCommon_table_expression(ctx *Common_table_expressionContext)

+ func (s *BaseSQLiteListener) ExitCompound_operator(ctx *Compound_operatorContext)

+ func (s *BaseSQLiteListener) ExitCompound_select_stmt(ctx *Compound_select_stmtContext)

+ func (s *BaseSQLiteListener) ExitConflict_clause(ctx *Conflict_clauseContext)

+ func (s *BaseSQLiteListener) ExitCreate_index_stmt(ctx *Create_index_stmtContext)

+ func (s *BaseSQLiteListener) ExitCreate_table_stmt(ctx *Create_table_stmtContext)

+ func (s *BaseSQLiteListener) ExitCreate_trigger_stmt(ctx *Create_trigger_stmtContext)

+ func (s *BaseSQLiteListener) ExitCreate_view_stmt(ctx *Create_view_stmtContext)

+ func (s *BaseSQLiteListener) ExitCreate_virtual_table_stmt(ctx *Create_virtual_table_stmtContext)

+ func (s *BaseSQLiteListener) ExitDatabase_name(ctx *Database_nameContext)

+ func (s *BaseSQLiteListener) ExitDelete_stmt(ctx *Delete_stmtContext)

+ func (s *BaseSQLiteListener) ExitDelete_stmt_limited(ctx *Delete_stmt_limitedContext)

+ func (s *BaseSQLiteListener) ExitDetach_stmt(ctx *Detach_stmtContext)

+ func (s *BaseSQLiteListener) ExitDrop_index_stmt(ctx *Drop_index_stmtContext)

+ func (s *BaseSQLiteListener) ExitDrop_table_stmt(ctx *Drop_table_stmtContext)

+ func (s *BaseSQLiteListener) ExitDrop_trigger_stmt(ctx *Drop_trigger_stmtContext)

+ func (s *BaseSQLiteListener) ExitDrop_view_stmt(ctx *Drop_view_stmtContext)

+ func (s *BaseSQLiteListener) ExitError_message(ctx *Error_messageContext)

+ func (s *BaseSQLiteListener) ExitEveryRule(ctx antlr.ParserRuleContext)

+ func (s *BaseSQLiteListener) ExitExpr(ctx *ExprContext)

+ func (s *BaseSQLiteListener) ExitFactored_select_stmt(ctx *Factored_select_stmtContext)

+ func (s *BaseSQLiteListener) ExitForeign_key_clause(ctx *Foreign_key_clauseContext)

+ func (s *BaseSQLiteListener) ExitForeign_table(ctx *Foreign_tableContext)

+ func (s *BaseSQLiteListener) ExitFunction_name(ctx *Function_nameContext)

+ func (s *BaseSQLiteListener) ExitIndex_name(ctx *Index_nameContext)

+ func (s *BaseSQLiteListener) ExitIndexed_column(ctx *Indexed_columnContext)

+ func (s *BaseSQLiteListener) ExitInsert_stmt(ctx *Insert_stmtContext)

+ func (s *BaseSQLiteListener) ExitJoin_clause(ctx *Join_clauseContext)

+ func (s *BaseSQLiteListener) ExitJoin_constraint(ctx *Join_constraintContext)

+ func (s *BaseSQLiteListener) ExitJoin_operator(ctx *Join_operatorContext)

+ func (s *BaseSQLiteListener) ExitKeyword(ctx *KeywordContext)

+ func (s *BaseSQLiteListener) ExitLiteral_value(ctx *Literal_valueContext)

+ func (s *BaseSQLiteListener) ExitModule_argument(ctx *Module_argumentContext)

+ func (s *BaseSQLiteListener) ExitModule_name(ctx *Module_nameContext)

+ func (s *BaseSQLiteListener) ExitName(ctx *NameContext)

+ func (s *BaseSQLiteListener) ExitNew_column_name(ctx *New_column_nameContext)

+ func (s *BaseSQLiteListener) ExitNew_table_name(ctx *New_table_nameContext)

+ func (s *BaseSQLiteListener) ExitOrdering_term(ctx *Ordering_termContext)

+ func (s *BaseSQLiteListener) ExitParse(ctx *ParseContext)

+ func (s *BaseSQLiteListener) ExitPragma_name(ctx *Pragma_nameContext)

+ func (s *BaseSQLiteListener) ExitPragma_stmt(ctx *Pragma_stmtContext)

+ func (s *BaseSQLiteListener) ExitPragma_value(ctx *Pragma_valueContext)

+ func (s *BaseSQLiteListener) ExitQualified_table_name(ctx *Qualified_table_nameContext)

+ func (s *BaseSQLiteListener) ExitRaise_function(ctx *Raise_functionContext)

+ func (s *BaseSQLiteListener) ExitReindex_stmt(ctx *Reindex_stmtContext)

+ func (s *BaseSQLiteListener) ExitRelease_stmt(ctx *Release_stmtContext)

+ func (s *BaseSQLiteListener) ExitResult_column(ctx *Result_columnContext)

+ func (s *BaseSQLiteListener) ExitRollback_stmt(ctx *Rollback_stmtContext)

+ func (s *BaseSQLiteListener) ExitSavepoint_name(ctx *Savepoint_nameContext)

+ func (s *BaseSQLiteListener) ExitSavepoint_stmt(ctx *Savepoint_stmtContext)

+ func (s *BaseSQLiteListener) ExitSchema_name(ctx *Schema_nameContext)

+ func (s *BaseSQLiteListener) ExitSelect_core(ctx *Select_coreContext)

+ func (s *BaseSQLiteListener) ExitSelect_or_values(ctx *Select_or_valuesContext)

+ func (s *BaseSQLiteListener) ExitSelect_stmt(ctx *Select_stmtContext)

+ func (s *BaseSQLiteListener) ExitSigned_number(ctx *Signed_numberContext)

+ func (s *BaseSQLiteListener) ExitSimple_select_stmt(ctx *Simple_select_stmtContext)

+ func (s *BaseSQLiteListener) ExitSql_stmt(ctx *Sql_stmtContext)

+ func (s *BaseSQLiteListener) ExitSql_stmt_list(ctx *Sql_stmt_listContext)

+ func (s *BaseSQLiteListener) ExitTable_alias(ctx *Table_aliasContext)

+ func (s *BaseSQLiteListener) ExitTable_constraint(ctx *Table_constraintContext)

+ func (s *BaseSQLiteListener) ExitTable_function_name(ctx *Table_function_nameContext)

+ func (s *BaseSQLiteListener) ExitTable_name(ctx *Table_nameContext)

+ func (s *BaseSQLiteListener) ExitTable_or_index_name(ctx *Table_or_index_nameContext)

+ func (s *BaseSQLiteListener) ExitTable_or_subquery(ctx *Table_or_subqueryContext)

+ func (s *BaseSQLiteListener) ExitTransaction_name(ctx *Transaction_nameContext)

+ func (s *BaseSQLiteListener) ExitTrigger_name(ctx *Trigger_nameContext)

+ func (s *BaseSQLiteListener) ExitType_name(ctx *Type_nameContext)

+ func (s *BaseSQLiteListener) ExitUnary_operator(ctx *Unary_operatorContext)

+ func (s *BaseSQLiteListener) ExitUpdate_stmt(ctx *Update_stmtContext)

+ func (s *BaseSQLiteListener) ExitUpdate_stmt_limited(ctx *Update_stmt_limitedContext)

+ func (s *BaseSQLiteListener) ExitVacuum_stmt(ctx *Vacuum_stmtContext)

+ func (s *BaseSQLiteListener) ExitView_name(ctx *View_nameContext)

+ func (s *BaseSQLiteListener) ExitWith_clause(ctx *With_clauseContext)

+ func (s *BaseSQLiteListener) VisitErrorNode(node antlr.ErrorNode)

+ func (s *BaseSQLiteListener) VisitTerminal(node antlr.TerminalNode)

+ type Begin_stmtContext struct

+ func NewBegin_stmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Begin_stmtContext

+ func NewEmptyBegin_stmtContext() *Begin_stmtContext

+ func (*Begin_stmtContext) IsBegin_stmtContext()

+ func (s *Begin_stmtContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Begin_stmtContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Begin_stmtContext) GetParser() antlr.Parser

+ func (s *Begin_stmtContext) GetRuleContext() antlr.RuleContext

+ func (s *Begin_stmtContext) K_BEGIN() antlr.TerminalNode

+ func (s *Begin_stmtContext) K_DEFERRED() antlr.TerminalNode

+ func (s *Begin_stmtContext) K_EXCLUSIVE() antlr.TerminalNode

+ func (s *Begin_stmtContext) K_IMMEDIATE() antlr.TerminalNode

+ func (s *Begin_stmtContext) K_TRANSACTION() antlr.TerminalNode

+ func (s *Begin_stmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ func (s *Begin_stmtContext) Transaction_name() ITransaction_nameContext

+ type Collation_nameContext struct

+ func NewCollation_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Collation_nameContext

+ func NewEmptyCollation_nameContext() *Collation_nameContext

+ func (*Collation_nameContext) IsCollation_nameContext()

+ func (s *Collation_nameContext) Any_name() IAny_nameContext

+ func (s *Collation_nameContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Collation_nameContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Collation_nameContext) GetParser() antlr.Parser

+ func (s *Collation_nameContext) GetRuleContext() antlr.RuleContext

+ func (s *Collation_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type Column_aliasContext struct

+ func NewColumn_aliasContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Column_aliasContext

+ func NewEmptyColumn_aliasContext() *Column_aliasContext

+ func (*Column_aliasContext) IsColumn_aliasContext()

+ func (s *Column_aliasContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Column_aliasContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Column_aliasContext) GetParser() antlr.Parser

+ func (s *Column_aliasContext) GetRuleContext() antlr.RuleContext

+ func (s *Column_aliasContext) IDENTIFIER() antlr.TerminalNode

+ func (s *Column_aliasContext) STRING_LITERAL() antlr.TerminalNode

+ func (s *Column_aliasContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type Column_constraintContext struct

+ func NewColumn_constraintContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Column_constraintContext

+ func NewEmptyColumn_constraintContext() *Column_constraintContext

+ func (*Column_constraintContext) IsColumn_constraintContext()

+ func (s *Column_constraintContext) CLOSE_PAR() antlr.TerminalNode

+ func (s *Column_constraintContext) Collation_name() ICollation_nameContext

+ func (s *Column_constraintContext) Conflict_clause() IConflict_clauseContext

+ func (s *Column_constraintContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Column_constraintContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Column_constraintContext) Expr() IExprContext

+ func (s *Column_constraintContext) Foreign_key_clause() IForeign_key_clauseContext

+ func (s *Column_constraintContext) GetParser() antlr.Parser

+ func (s *Column_constraintContext) GetRuleContext() antlr.RuleContext

+ func (s *Column_constraintContext) K_ASC() antlr.TerminalNode

+ func (s *Column_constraintContext) K_AUTOINCREMENT() antlr.TerminalNode

+ func (s *Column_constraintContext) K_CHECK() antlr.TerminalNode

+ func (s *Column_constraintContext) K_COLLATE() antlr.TerminalNode

+ func (s *Column_constraintContext) K_CONSTRAINT() antlr.TerminalNode

+ func (s *Column_constraintContext) K_DEFAULT() antlr.TerminalNode

+ func (s *Column_constraintContext) K_DESC() antlr.TerminalNode

+ func (s *Column_constraintContext) K_KEY() antlr.TerminalNode

+ func (s *Column_constraintContext) K_NOT() antlr.TerminalNode

+ func (s *Column_constraintContext) K_NULL() antlr.TerminalNode

+ func (s *Column_constraintContext) K_PRIMARY() antlr.TerminalNode

+ func (s *Column_constraintContext) K_UNIQUE() antlr.TerminalNode

+ func (s *Column_constraintContext) Literal_value() ILiteral_valueContext

+ func (s *Column_constraintContext) Name() INameContext

+ func (s *Column_constraintContext) OPEN_PAR() antlr.TerminalNode

+ func (s *Column_constraintContext) Signed_number() ISigned_numberContext

+ func (s *Column_constraintContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type Column_defContext struct

+ func NewColumn_defContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Column_defContext

+ func NewEmptyColumn_defContext() *Column_defContext

+ func (*Column_defContext) IsColumn_defContext()

+ func (s *Column_defContext) AllColumn_constraint() []IColumn_constraintContext

+ func (s *Column_defContext) Column_constraint(i int) IColumn_constraintContext

+ func (s *Column_defContext) Column_name() IColumn_nameContext

+ func (s *Column_defContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Column_defContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Column_defContext) GetParser() antlr.Parser

+ func (s *Column_defContext) GetRuleContext() antlr.RuleContext

+ func (s *Column_defContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ func (s *Column_defContext) Type_name() IType_nameContext

+ type Column_nameContext struct

+ func NewColumn_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Column_nameContext

+ func NewEmptyColumn_nameContext() *Column_nameContext

+ func (*Column_nameContext) IsColumn_nameContext()

+ func (s *Column_nameContext) Any_name() IAny_nameContext

+ func (s *Column_nameContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Column_nameContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Column_nameContext) GetParser() antlr.Parser

+ func (s *Column_nameContext) GetRuleContext() antlr.RuleContext

+ func (s *Column_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type Commit_stmtContext struct

+ func NewCommit_stmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Commit_stmtContext

+ func NewEmptyCommit_stmtContext() *Commit_stmtContext

+ func (*Commit_stmtContext) IsCommit_stmtContext()

+ func (s *Commit_stmtContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Commit_stmtContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Commit_stmtContext) GetParser() antlr.Parser

+ func (s *Commit_stmtContext) GetRuleContext() antlr.RuleContext

+ func (s *Commit_stmtContext) K_COMMIT() antlr.TerminalNode

+ func (s *Commit_stmtContext) K_END() antlr.TerminalNode

+ func (s *Commit_stmtContext) K_TRANSACTION() antlr.TerminalNode

+ func (s *Commit_stmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ func (s *Commit_stmtContext) Transaction_name() ITransaction_nameContext

+ type Common_table_expressionContext struct

+ func NewCommon_table_expressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Common_table_expressionContext

+ func NewEmptyCommon_table_expressionContext() *Common_table_expressionContext

+ func (*Common_table_expressionContext) IsCommon_table_expressionContext()

+ func (s *Common_table_expressionContext) AllCLOSE_PAR() []antlr.TerminalNode

+ func (s *Common_table_expressionContext) AllCOMMA() []antlr.TerminalNode

+ func (s *Common_table_expressionContext) AllColumn_name() []IColumn_nameContext

+ func (s *Common_table_expressionContext) AllOPEN_PAR() []antlr.TerminalNode

+ func (s *Common_table_expressionContext) CLOSE_PAR(i int) antlr.TerminalNode

+ func (s *Common_table_expressionContext) COMMA(i int) antlr.TerminalNode

+ func (s *Common_table_expressionContext) Column_name(i int) IColumn_nameContext

+ func (s *Common_table_expressionContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Common_table_expressionContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Common_table_expressionContext) GetParser() antlr.Parser

+ func (s *Common_table_expressionContext) GetRuleContext() antlr.RuleContext

+ func (s *Common_table_expressionContext) K_AS() antlr.TerminalNode

+ func (s *Common_table_expressionContext) OPEN_PAR(i int) antlr.TerminalNode

+ func (s *Common_table_expressionContext) Select_stmt() ISelect_stmtContext

+ func (s *Common_table_expressionContext) Table_name() ITable_nameContext

+ func (s *Common_table_expressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type Compound_operatorContext struct

+ func NewCompound_operatorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Compound_operatorContext

+ func NewEmptyCompound_operatorContext() *Compound_operatorContext

+ func (*Compound_operatorContext) IsCompound_operatorContext()

+ func (s *Compound_operatorContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Compound_operatorContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Compound_operatorContext) GetParser() antlr.Parser

+ func (s *Compound_operatorContext) GetRuleContext() antlr.RuleContext

+ func (s *Compound_operatorContext) K_ALL() antlr.TerminalNode

+ func (s *Compound_operatorContext) K_EXCEPT() antlr.TerminalNode

+ func (s *Compound_operatorContext) K_INTERSECT() antlr.TerminalNode

+ func (s *Compound_operatorContext) K_UNION() antlr.TerminalNode

+ func (s *Compound_operatorContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type Compound_select_stmtContext struct

+ func NewCompound_select_stmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Compound_select_stmtContext

+ func NewEmptyCompound_select_stmtContext() *Compound_select_stmtContext

+ func (*Compound_select_stmtContext) IsCompound_select_stmtContext()

+ func (s *Compound_select_stmtContext) AllCOMMA() []antlr.TerminalNode

+ func (s *Compound_select_stmtContext) AllExpr() []IExprContext

+ func (s *Compound_select_stmtContext) AllK_ALL() []antlr.TerminalNode

+ func (s *Compound_select_stmtContext) AllK_EXCEPT() []antlr.TerminalNode

+ func (s *Compound_select_stmtContext) AllK_INTERSECT() []antlr.TerminalNode

+ func (s *Compound_select_stmtContext) AllK_UNION() []antlr.TerminalNode

+ func (s *Compound_select_stmtContext) AllOrdering_term() []IOrdering_termContext

+ func (s *Compound_select_stmtContext) AllSelect_core() []ISelect_coreContext

+ func (s *Compound_select_stmtContext) COMMA(i int) antlr.TerminalNode

+ func (s *Compound_select_stmtContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Compound_select_stmtContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Compound_select_stmtContext) Expr(i int) IExprContext

+ func (s *Compound_select_stmtContext) GetParser() antlr.Parser

+ func (s *Compound_select_stmtContext) GetRuleContext() antlr.RuleContext

+ func (s *Compound_select_stmtContext) K_ALL(i int) antlr.TerminalNode

+ func (s *Compound_select_stmtContext) K_BY() antlr.TerminalNode

+ func (s *Compound_select_stmtContext) K_EXCEPT(i int) antlr.TerminalNode

+ func (s *Compound_select_stmtContext) K_INTERSECT(i int) antlr.TerminalNode

+ func (s *Compound_select_stmtContext) K_LIMIT() antlr.TerminalNode

+ func (s *Compound_select_stmtContext) K_OFFSET() antlr.TerminalNode

+ func (s *Compound_select_stmtContext) K_ORDER() antlr.TerminalNode

+ func (s *Compound_select_stmtContext) K_UNION(i int) antlr.TerminalNode

+ func (s *Compound_select_stmtContext) Ordering_term(i int) IOrdering_termContext

+ func (s *Compound_select_stmtContext) Select_core(i int) ISelect_coreContext

+ func (s *Compound_select_stmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ func (s *Compound_select_stmtContext) With_clause() IWith_clauseContext

+ type Conflict_clauseContext struct

+ func NewConflict_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Conflict_clauseContext

+ func NewEmptyConflict_clauseContext() *Conflict_clauseContext

+ func (*Conflict_clauseContext) IsConflict_clauseContext()

+ func (s *Conflict_clauseContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Conflict_clauseContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Conflict_clauseContext) GetParser() antlr.Parser

+ func (s *Conflict_clauseContext) GetRuleContext() antlr.RuleContext

+ func (s *Conflict_clauseContext) K_ABORT() antlr.TerminalNode

+ func (s *Conflict_clauseContext) K_CONFLICT() antlr.TerminalNode

+ func (s *Conflict_clauseContext) K_FAIL() antlr.TerminalNode

+ func (s *Conflict_clauseContext) K_IGNORE() antlr.TerminalNode

+ func (s *Conflict_clauseContext) K_ON() antlr.TerminalNode

+ func (s *Conflict_clauseContext) K_REPLACE() antlr.TerminalNode

+ func (s *Conflict_clauseContext) K_ROLLBACK() antlr.TerminalNode

+ func (s *Conflict_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type Create_index_stmtContext struct

+ func NewCreate_index_stmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_index_stmtContext

+ func NewEmptyCreate_index_stmtContext() *Create_index_stmtContext

+ func (*Create_index_stmtContext) IsCreate_index_stmtContext()

+ func (s *Create_index_stmtContext) AllCOMMA() []antlr.TerminalNode

+ func (s *Create_index_stmtContext) AllIndexed_column() []IIndexed_columnContext

+ func (s *Create_index_stmtContext) CLOSE_PAR() antlr.TerminalNode

+ func (s *Create_index_stmtContext) COMMA(i int) antlr.TerminalNode

+ func (s *Create_index_stmtContext) DOT() antlr.TerminalNode

+ func (s *Create_index_stmtContext) Database_name() IDatabase_nameContext

+ func (s *Create_index_stmtContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Create_index_stmtContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Create_index_stmtContext) Expr() IExprContext

+ func (s *Create_index_stmtContext) GetParser() antlr.Parser

+ func (s *Create_index_stmtContext) GetRuleContext() antlr.RuleContext

+ func (s *Create_index_stmtContext) Index_name() IIndex_nameContext

+ func (s *Create_index_stmtContext) Indexed_column(i int) IIndexed_columnContext

+ func (s *Create_index_stmtContext) K_CREATE() antlr.TerminalNode

+ func (s *Create_index_stmtContext) K_EXISTS() antlr.TerminalNode

+ func (s *Create_index_stmtContext) K_IF() antlr.TerminalNode

+ func (s *Create_index_stmtContext) K_INDEX() antlr.TerminalNode

+ func (s *Create_index_stmtContext) K_NOT() antlr.TerminalNode

+ func (s *Create_index_stmtContext) K_ON() antlr.TerminalNode

+ func (s *Create_index_stmtContext) K_UNIQUE() antlr.TerminalNode

+ func (s *Create_index_stmtContext) K_WHERE() antlr.TerminalNode

+ func (s *Create_index_stmtContext) OPEN_PAR() antlr.TerminalNode

+ func (s *Create_index_stmtContext) Table_name() ITable_nameContext

+ func (s *Create_index_stmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type Create_table_stmtContext struct

+ func NewCreate_table_stmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_table_stmtContext

+ func NewEmptyCreate_table_stmtContext() *Create_table_stmtContext

+ func (*Create_table_stmtContext) IsCreate_table_stmtContext()

+ func (s *Create_table_stmtContext) AllCOMMA() []antlr.TerminalNode

+ func (s *Create_table_stmtContext) AllColumn_def() []IColumn_defContext

+ func (s *Create_table_stmtContext) AllTable_constraint() []ITable_constraintContext

+ func (s *Create_table_stmtContext) CLOSE_PAR() antlr.TerminalNode

+ func (s *Create_table_stmtContext) COMMA(i int) antlr.TerminalNode

+ func (s *Create_table_stmtContext) Column_def(i int) IColumn_defContext

+ func (s *Create_table_stmtContext) DOT() antlr.TerminalNode

+ func (s *Create_table_stmtContext) Database_name() IDatabase_nameContext

+ func (s *Create_table_stmtContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Create_table_stmtContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Create_table_stmtContext) GetParser() antlr.Parser

+ func (s *Create_table_stmtContext) GetRuleContext() antlr.RuleContext

+ func (s *Create_table_stmtContext) IDENTIFIER() antlr.TerminalNode

+ func (s *Create_table_stmtContext) K_AS() antlr.TerminalNode

+ func (s *Create_table_stmtContext) K_CREATE() antlr.TerminalNode

+ func (s *Create_table_stmtContext) K_EXISTS() antlr.TerminalNode

+ func (s *Create_table_stmtContext) K_IF() antlr.TerminalNode

+ func (s *Create_table_stmtContext) K_NOT() antlr.TerminalNode

+ func (s *Create_table_stmtContext) K_TABLE() antlr.TerminalNode

+ func (s *Create_table_stmtContext) K_TEMP() antlr.TerminalNode

+ func (s *Create_table_stmtContext) K_TEMPORARY() antlr.TerminalNode

+ func (s *Create_table_stmtContext) K_WITHOUT() antlr.TerminalNode

+ func (s *Create_table_stmtContext) OPEN_PAR() antlr.TerminalNode

+ func (s *Create_table_stmtContext) Select_stmt() ISelect_stmtContext

+ func (s *Create_table_stmtContext) Table_constraint(i int) ITable_constraintContext

+ func (s *Create_table_stmtContext) Table_name() ITable_nameContext

+ func (s *Create_table_stmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type Create_trigger_stmtContext struct

+ func NewCreate_trigger_stmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_trigger_stmtContext

+ func NewEmptyCreate_trigger_stmtContext() *Create_trigger_stmtContext

+ func (*Create_trigger_stmtContext) IsCreate_trigger_stmtContext()

+ func (s *Create_trigger_stmtContext) AllCOMMA() []antlr.TerminalNode

+ func (s *Create_trigger_stmtContext) AllColumn_name() []IColumn_nameContext

+ func (s *Create_trigger_stmtContext) AllDOT() []antlr.TerminalNode

+ func (s *Create_trigger_stmtContext) AllDatabase_name() []IDatabase_nameContext

+ func (s *Create_trigger_stmtContext) AllDelete_stmt() []IDelete_stmtContext

+ func (s *Create_trigger_stmtContext) AllInsert_stmt() []IInsert_stmtContext

+ func (s *Create_trigger_stmtContext) AllK_OF() []antlr.TerminalNode

+ func (s *Create_trigger_stmtContext) AllSCOL() []antlr.TerminalNode

+ func (s *Create_trigger_stmtContext) AllSelect_stmt() []ISelect_stmtContext

+ func (s *Create_trigger_stmtContext) AllUpdate_stmt() []IUpdate_stmtContext

+ func (s *Create_trigger_stmtContext) COMMA(i int) antlr.TerminalNode

+ func (s *Create_trigger_stmtContext) Column_name(i int) IColumn_nameContext

+ func (s *Create_trigger_stmtContext) DOT(i int) antlr.TerminalNode

+ func (s *Create_trigger_stmtContext) Database_name(i int) IDatabase_nameContext

+ func (s *Create_trigger_stmtContext) Delete_stmt(i int) IDelete_stmtContext

+ func (s *Create_trigger_stmtContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Create_trigger_stmtContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Create_trigger_stmtContext) Expr() IExprContext

+ func (s *Create_trigger_stmtContext) GetParser() antlr.Parser

+ func (s *Create_trigger_stmtContext) GetRuleContext() antlr.RuleContext

+ func (s *Create_trigger_stmtContext) Insert_stmt(i int) IInsert_stmtContext

+ func (s *Create_trigger_stmtContext) K_AFTER() antlr.TerminalNode

+ func (s *Create_trigger_stmtContext) K_BEFORE() antlr.TerminalNode

+ func (s *Create_trigger_stmtContext) K_BEGIN() antlr.TerminalNode

+ func (s *Create_trigger_stmtContext) K_CREATE() antlr.TerminalNode

+ func (s *Create_trigger_stmtContext) K_DELETE() antlr.TerminalNode

+ func (s *Create_trigger_stmtContext) K_EACH() antlr.TerminalNode

+ func (s *Create_trigger_stmtContext) K_END() antlr.TerminalNode

+ func (s *Create_trigger_stmtContext) K_EXISTS() antlr.TerminalNode

+ func (s *Create_trigger_stmtContext) K_FOR() antlr.TerminalNode

+ func (s *Create_trigger_stmtContext) K_IF() antlr.TerminalNode

+ func (s *Create_trigger_stmtContext) K_INSERT() antlr.TerminalNode

+ func (s *Create_trigger_stmtContext) K_INSTEAD() antlr.TerminalNode

+ func (s *Create_trigger_stmtContext) K_NOT() antlr.TerminalNode

+ func (s *Create_trigger_stmtContext) K_OF(i int) antlr.TerminalNode

+ func (s *Create_trigger_stmtContext) K_ON() antlr.TerminalNode

+ func (s *Create_trigger_stmtContext) K_ROW() antlr.TerminalNode

+ func (s *Create_trigger_stmtContext) K_TEMP() antlr.TerminalNode

+ func (s *Create_trigger_stmtContext) K_TEMPORARY() antlr.TerminalNode

+ func (s *Create_trigger_stmtContext) K_TRIGGER() antlr.TerminalNode

+ func (s *Create_trigger_stmtContext) K_UPDATE() antlr.TerminalNode

+ func (s *Create_trigger_stmtContext) K_WHEN() antlr.TerminalNode

+ func (s *Create_trigger_stmtContext) SCOL(i int) antlr.TerminalNode

+ func (s *Create_trigger_stmtContext) Select_stmt(i int) ISelect_stmtContext

+ func (s *Create_trigger_stmtContext) Table_name() ITable_nameContext

+ func (s *Create_trigger_stmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ func (s *Create_trigger_stmtContext) Trigger_name() ITrigger_nameContext

+ func (s *Create_trigger_stmtContext) Update_stmt(i int) IUpdate_stmtContext

+ type Create_view_stmtContext struct

+ func NewCreate_view_stmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_view_stmtContext

+ func NewEmptyCreate_view_stmtContext() *Create_view_stmtContext

+ func (*Create_view_stmtContext) IsCreate_view_stmtContext()

+ func (s *Create_view_stmtContext) DOT() antlr.TerminalNode

+ func (s *Create_view_stmtContext) Database_name() IDatabase_nameContext

+ func (s *Create_view_stmtContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Create_view_stmtContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Create_view_stmtContext) GetParser() antlr.Parser

+ func (s *Create_view_stmtContext) GetRuleContext() antlr.RuleContext

+ func (s *Create_view_stmtContext) K_AS() antlr.TerminalNode

+ func (s *Create_view_stmtContext) K_CREATE() antlr.TerminalNode

+ func (s *Create_view_stmtContext) K_EXISTS() antlr.TerminalNode

+ func (s *Create_view_stmtContext) K_IF() antlr.TerminalNode

+ func (s *Create_view_stmtContext) K_NOT() antlr.TerminalNode

+ func (s *Create_view_stmtContext) K_TEMP() antlr.TerminalNode

+ func (s *Create_view_stmtContext) K_TEMPORARY() antlr.TerminalNode

+ func (s *Create_view_stmtContext) K_VIEW() antlr.TerminalNode

+ func (s *Create_view_stmtContext) Select_stmt() ISelect_stmtContext

+ func (s *Create_view_stmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ func (s *Create_view_stmtContext) View_name() IView_nameContext

+ type Create_virtual_table_stmtContext struct

+ func NewCreate_virtual_table_stmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_virtual_table_stmtContext

+ func NewEmptyCreate_virtual_table_stmtContext() *Create_virtual_table_stmtContext

+ func (*Create_virtual_table_stmtContext) IsCreate_virtual_table_stmtContext()

+ func (s *Create_virtual_table_stmtContext) AllCOMMA() []antlr.TerminalNode

+ func (s *Create_virtual_table_stmtContext) AllModule_argument() []IModule_argumentContext

+ func (s *Create_virtual_table_stmtContext) CLOSE_PAR() antlr.TerminalNode

+ func (s *Create_virtual_table_stmtContext) COMMA(i int) antlr.TerminalNode

+ func (s *Create_virtual_table_stmtContext) DOT() antlr.TerminalNode

+ func (s *Create_virtual_table_stmtContext) Database_name() IDatabase_nameContext

+ func (s *Create_virtual_table_stmtContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Create_virtual_table_stmtContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Create_virtual_table_stmtContext) GetParser() antlr.Parser

+ func (s *Create_virtual_table_stmtContext) GetRuleContext() antlr.RuleContext

+ func (s *Create_virtual_table_stmtContext) K_CREATE() antlr.TerminalNode

+ func (s *Create_virtual_table_stmtContext) K_EXISTS() antlr.TerminalNode

+ func (s *Create_virtual_table_stmtContext) K_IF() antlr.TerminalNode

+ func (s *Create_virtual_table_stmtContext) K_NOT() antlr.TerminalNode

+ func (s *Create_virtual_table_stmtContext) K_TABLE() antlr.TerminalNode

+ func (s *Create_virtual_table_stmtContext) K_USING() antlr.TerminalNode

+ func (s *Create_virtual_table_stmtContext) K_VIRTUAL() antlr.TerminalNode

+ func (s *Create_virtual_table_stmtContext) Module_argument(i int) IModule_argumentContext

+ func (s *Create_virtual_table_stmtContext) Module_name() IModule_nameContext

+ func (s *Create_virtual_table_stmtContext) OPEN_PAR() antlr.TerminalNode

+ func (s *Create_virtual_table_stmtContext) Table_name() ITable_nameContext

+ func (s *Create_virtual_table_stmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type Database_nameContext struct

+ func NewDatabase_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Database_nameContext

+ func NewEmptyDatabase_nameContext() *Database_nameContext

+ func (*Database_nameContext) IsDatabase_nameContext()

+ func (s *Database_nameContext) Any_name() IAny_nameContext

+ func (s *Database_nameContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Database_nameContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Database_nameContext) GetParser() antlr.Parser

+ func (s *Database_nameContext) GetRuleContext() antlr.RuleContext

+ func (s *Database_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type Delete_stmtContext struct

+ func NewDelete_stmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Delete_stmtContext

+ func NewEmptyDelete_stmtContext() *Delete_stmtContext

+ func (*Delete_stmtContext) IsDelete_stmtContext()

+ func (s *Delete_stmtContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Delete_stmtContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Delete_stmtContext) Expr() IExprContext

+ func (s *Delete_stmtContext) GetParser() antlr.Parser

+ func (s *Delete_stmtContext) GetRuleContext() antlr.RuleContext

+ func (s *Delete_stmtContext) K_DELETE() antlr.TerminalNode

+ func (s *Delete_stmtContext) K_FROM() antlr.TerminalNode

+ func (s *Delete_stmtContext) K_WHERE() antlr.TerminalNode

+ func (s *Delete_stmtContext) Qualified_table_name() IQualified_table_nameContext

+ func (s *Delete_stmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ func (s *Delete_stmtContext) With_clause() IWith_clauseContext

+ type Delete_stmt_limitedContext struct

+ func NewDelete_stmt_limitedContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Delete_stmt_limitedContext

+ func NewEmptyDelete_stmt_limitedContext() *Delete_stmt_limitedContext

+ func (*Delete_stmt_limitedContext) IsDelete_stmt_limitedContext()

+ func (s *Delete_stmt_limitedContext) AllCOMMA() []antlr.TerminalNode

+ func (s *Delete_stmt_limitedContext) AllExpr() []IExprContext

+ func (s *Delete_stmt_limitedContext) AllOrdering_term() []IOrdering_termContext

+ func (s *Delete_stmt_limitedContext) COMMA(i int) antlr.TerminalNode

+ func (s *Delete_stmt_limitedContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Delete_stmt_limitedContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Delete_stmt_limitedContext) Expr(i int) IExprContext

+ func (s *Delete_stmt_limitedContext) GetParser() antlr.Parser

+ func (s *Delete_stmt_limitedContext) GetRuleContext() antlr.RuleContext

+ func (s *Delete_stmt_limitedContext) K_BY() antlr.TerminalNode

+ func (s *Delete_stmt_limitedContext) K_DELETE() antlr.TerminalNode

+ func (s *Delete_stmt_limitedContext) K_FROM() antlr.TerminalNode

+ func (s *Delete_stmt_limitedContext) K_LIMIT() antlr.TerminalNode

+ func (s *Delete_stmt_limitedContext) K_OFFSET() antlr.TerminalNode

+ func (s *Delete_stmt_limitedContext) K_ORDER() antlr.TerminalNode

+ func (s *Delete_stmt_limitedContext) K_WHERE() antlr.TerminalNode

+ func (s *Delete_stmt_limitedContext) Ordering_term(i int) IOrdering_termContext

+ func (s *Delete_stmt_limitedContext) Qualified_table_name() IQualified_table_nameContext

+ func (s *Delete_stmt_limitedContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ func (s *Delete_stmt_limitedContext) With_clause() IWith_clauseContext

+ type Detach_stmtContext struct

+ func NewDetach_stmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Detach_stmtContext

+ func NewEmptyDetach_stmtContext() *Detach_stmtContext

+ func (*Detach_stmtContext) IsDetach_stmtContext()

+ func (s *Detach_stmtContext) Database_name() IDatabase_nameContext

+ func (s *Detach_stmtContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Detach_stmtContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Detach_stmtContext) GetParser() antlr.Parser

+ func (s *Detach_stmtContext) GetRuleContext() antlr.RuleContext

+ func (s *Detach_stmtContext) K_DATABASE() antlr.TerminalNode

+ func (s *Detach_stmtContext) K_DETACH() antlr.TerminalNode

+ func (s *Detach_stmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type Drop_index_stmtContext struct

+ func NewDrop_index_stmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_index_stmtContext

+ func NewEmptyDrop_index_stmtContext() *Drop_index_stmtContext

+ func (*Drop_index_stmtContext) IsDrop_index_stmtContext()

+ func (s *Drop_index_stmtContext) DOT() antlr.TerminalNode

+ func (s *Drop_index_stmtContext) Database_name() IDatabase_nameContext

+ func (s *Drop_index_stmtContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Drop_index_stmtContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Drop_index_stmtContext) GetParser() antlr.Parser

+ func (s *Drop_index_stmtContext) GetRuleContext() antlr.RuleContext

+ func (s *Drop_index_stmtContext) Index_name() IIndex_nameContext

+ func (s *Drop_index_stmtContext) K_DROP() antlr.TerminalNode

+ func (s *Drop_index_stmtContext) K_EXISTS() antlr.TerminalNode

+ func (s *Drop_index_stmtContext) K_IF() antlr.TerminalNode

+ func (s *Drop_index_stmtContext) K_INDEX() antlr.TerminalNode

+ func (s *Drop_index_stmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type Drop_table_stmtContext struct

+ func NewDrop_table_stmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_table_stmtContext

+ func NewEmptyDrop_table_stmtContext() *Drop_table_stmtContext

+ func (*Drop_table_stmtContext) IsDrop_table_stmtContext()

+ func (s *Drop_table_stmtContext) DOT() antlr.TerminalNode

+ func (s *Drop_table_stmtContext) Database_name() IDatabase_nameContext

+ func (s *Drop_table_stmtContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Drop_table_stmtContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Drop_table_stmtContext) GetParser() antlr.Parser

+ func (s *Drop_table_stmtContext) GetRuleContext() antlr.RuleContext

+ func (s *Drop_table_stmtContext) K_DROP() antlr.TerminalNode

+ func (s *Drop_table_stmtContext) K_EXISTS() antlr.TerminalNode

+ func (s *Drop_table_stmtContext) K_IF() antlr.TerminalNode

+ func (s *Drop_table_stmtContext) K_TABLE() antlr.TerminalNode

+ func (s *Drop_table_stmtContext) Table_name() ITable_nameContext

+ func (s *Drop_table_stmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type Drop_trigger_stmtContext struct

+ func NewDrop_trigger_stmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_trigger_stmtContext

+ func NewEmptyDrop_trigger_stmtContext() *Drop_trigger_stmtContext

+ func (*Drop_trigger_stmtContext) IsDrop_trigger_stmtContext()

+ func (s *Drop_trigger_stmtContext) DOT() antlr.TerminalNode

+ func (s *Drop_trigger_stmtContext) Database_name() IDatabase_nameContext

+ func (s *Drop_trigger_stmtContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Drop_trigger_stmtContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Drop_trigger_stmtContext) GetParser() antlr.Parser

+ func (s *Drop_trigger_stmtContext) GetRuleContext() antlr.RuleContext

+ func (s *Drop_trigger_stmtContext) K_DROP() antlr.TerminalNode

+ func (s *Drop_trigger_stmtContext) K_EXISTS() antlr.TerminalNode

+ func (s *Drop_trigger_stmtContext) K_IF() antlr.TerminalNode

+ func (s *Drop_trigger_stmtContext) K_TRIGGER() antlr.TerminalNode

+ func (s *Drop_trigger_stmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ func (s *Drop_trigger_stmtContext) Trigger_name() ITrigger_nameContext

+ type Drop_view_stmtContext struct

+ func NewDrop_view_stmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_view_stmtContext

+ func NewEmptyDrop_view_stmtContext() *Drop_view_stmtContext

+ func (*Drop_view_stmtContext) IsDrop_view_stmtContext()

+ func (s *Drop_view_stmtContext) DOT() antlr.TerminalNode

+ func (s *Drop_view_stmtContext) Database_name() IDatabase_nameContext

+ func (s *Drop_view_stmtContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Drop_view_stmtContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Drop_view_stmtContext) GetParser() antlr.Parser

+ func (s *Drop_view_stmtContext) GetRuleContext() antlr.RuleContext

+ func (s *Drop_view_stmtContext) K_DROP() antlr.TerminalNode

+ func (s *Drop_view_stmtContext) K_EXISTS() antlr.TerminalNode

+ func (s *Drop_view_stmtContext) K_IF() antlr.TerminalNode

+ func (s *Drop_view_stmtContext) K_VIEW() antlr.TerminalNode

+ func (s *Drop_view_stmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ func (s *Drop_view_stmtContext) View_name() IView_nameContext

+ type Error_messageContext struct

+ func NewEmptyError_messageContext() *Error_messageContext

+ func NewError_messageContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Error_messageContext

+ func (*Error_messageContext) IsError_messageContext()

+ func (s *Error_messageContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Error_messageContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Error_messageContext) GetParser() antlr.Parser

+ func (s *Error_messageContext) GetRuleContext() antlr.RuleContext

+ func (s *Error_messageContext) STRING_LITERAL() antlr.TerminalNode

+ func (s *Error_messageContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type ExprContext struct

+ func NewEmptyExprContext() *ExprContext

+ func NewExprContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ExprContext

+ func (*ExprContext) IsExprContext()

+ func (s *ExprContext) AMP() antlr.TerminalNode

+ func (s *ExprContext) ASSIGN() antlr.TerminalNode

+ func (s *ExprContext) AllCOMMA() []antlr.TerminalNode

+ func (s *ExprContext) AllDOT() []antlr.TerminalNode

+ func (s *ExprContext) AllExpr() []IExprContext

+ func (s *ExprContext) AllK_THEN() []antlr.TerminalNode

+ func (s *ExprContext) AllK_WHEN() []antlr.TerminalNode

+ func (s *ExprContext) BIND_PARAMETER() antlr.TerminalNode

+ func (s *ExprContext) CLOSE_PAR() antlr.TerminalNode

+ func (s *ExprContext) COMMA(i int) antlr.TerminalNode

+ func (s *ExprContext) Collation_name() ICollation_nameContext

+ func (s *ExprContext) Column_name() IColumn_nameContext

+ func (s *ExprContext) DIV() antlr.TerminalNode

+ func (s *ExprContext) DOT(i int) antlr.TerminalNode

+ func (s *ExprContext) Database_name() IDatabase_nameContext

+ func (s *ExprContext) EQ() antlr.TerminalNode

+ func (s *ExprContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *ExprContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *ExprContext) Expr(i int) IExprContext

+ func (s *ExprContext) Function_name() IFunction_nameContext

+ func (s *ExprContext) GT() antlr.TerminalNode

+ func (s *ExprContext) GT2() antlr.TerminalNode

+ func (s *ExprContext) GT_EQ() antlr.TerminalNode

+ func (s *ExprContext) GetParser() antlr.Parser

+ func (s *ExprContext) GetRuleContext() antlr.RuleContext

+ func (s *ExprContext) K_AND() antlr.TerminalNode

+ func (s *ExprContext) K_AS() antlr.TerminalNode

+ func (s *ExprContext) K_BETWEEN() antlr.TerminalNode

+ func (s *ExprContext) K_CASE() antlr.TerminalNode

+ func (s *ExprContext) K_CAST() antlr.TerminalNode

+ func (s *ExprContext) K_COLLATE() antlr.TerminalNode

+ func (s *ExprContext) K_DISTINCT() antlr.TerminalNode

+ func (s *ExprContext) K_ELSE() antlr.TerminalNode

+ func (s *ExprContext) K_END() antlr.TerminalNode

+ func (s *ExprContext) K_ESCAPE() antlr.TerminalNode

+ func (s *ExprContext) K_EXISTS() antlr.TerminalNode

+ func (s *ExprContext) K_GLOB() antlr.TerminalNode

+ func (s *ExprContext) K_IN() antlr.TerminalNode

+ func (s *ExprContext) K_IS() antlr.TerminalNode

+ func (s *ExprContext) K_ISNULL() antlr.TerminalNode

+ func (s *ExprContext) K_LIKE() antlr.TerminalNode

+ func (s *ExprContext) K_MATCH() antlr.TerminalNode

+ func (s *ExprContext) K_NOT() antlr.TerminalNode

+ func (s *ExprContext) K_NOTNULL() antlr.TerminalNode

+ func (s *ExprContext) K_NULL() antlr.TerminalNode

+ func (s *ExprContext) K_OR() antlr.TerminalNode

+ func (s *ExprContext) K_REGEXP() antlr.TerminalNode

+ func (s *ExprContext) K_THEN(i int) antlr.TerminalNode

+ func (s *ExprContext) K_WHEN(i int) antlr.TerminalNode

+ func (s *ExprContext) LT() antlr.TerminalNode

+ func (s *ExprContext) LT2() antlr.TerminalNode

+ func (s *ExprContext) LT_EQ() antlr.TerminalNode

+ func (s *ExprContext) Literal_value() ILiteral_valueContext

+ func (s *ExprContext) MINUS() antlr.TerminalNode

+ func (s *ExprContext) MOD() antlr.TerminalNode

+ func (s *ExprContext) NOT_EQ1() antlr.TerminalNode

+ func (s *ExprContext) NOT_EQ2() antlr.TerminalNode

+ func (s *ExprContext) OPEN_PAR() antlr.TerminalNode

+ func (s *ExprContext) PIPE() antlr.TerminalNode

+ func (s *ExprContext) PIPE2() antlr.TerminalNode

+ func (s *ExprContext) PLUS() antlr.TerminalNode

+ func (s *ExprContext) Raise_function() IRaise_functionContext

+ func (s *ExprContext) STAR() antlr.TerminalNode

+ func (s *ExprContext) Select_stmt() ISelect_stmtContext

+ func (s *ExprContext) Table_name() ITable_nameContext

+ func (s *ExprContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ func (s *ExprContext) Type_name() IType_nameContext

+ func (s *ExprContext) Unary_operator() IUnary_operatorContext

+ type Factored_select_stmtContext struct

+ func NewEmptyFactored_select_stmtContext() *Factored_select_stmtContext

+ func NewFactored_select_stmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Factored_select_stmtContext

+ func (*Factored_select_stmtContext) IsFactored_select_stmtContext()

+ func (s *Factored_select_stmtContext) AllCOMMA() []antlr.TerminalNode

+ func (s *Factored_select_stmtContext) AllCompound_operator() []ICompound_operatorContext

+ func (s *Factored_select_stmtContext) AllExpr() []IExprContext

+ func (s *Factored_select_stmtContext) AllOrdering_term() []IOrdering_termContext

+ func (s *Factored_select_stmtContext) AllSelect_core() []ISelect_coreContext

+ func (s *Factored_select_stmtContext) COMMA(i int) antlr.TerminalNode

+ func (s *Factored_select_stmtContext) Compound_operator(i int) ICompound_operatorContext

+ func (s *Factored_select_stmtContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Factored_select_stmtContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Factored_select_stmtContext) Expr(i int) IExprContext

+ func (s *Factored_select_stmtContext) GetParser() antlr.Parser

+ func (s *Factored_select_stmtContext) GetRuleContext() antlr.RuleContext

+ func (s *Factored_select_stmtContext) K_BY() antlr.TerminalNode

+ func (s *Factored_select_stmtContext) K_LIMIT() antlr.TerminalNode

+ func (s *Factored_select_stmtContext) K_OFFSET() antlr.TerminalNode

+ func (s *Factored_select_stmtContext) K_ORDER() antlr.TerminalNode

+ func (s *Factored_select_stmtContext) Ordering_term(i int) IOrdering_termContext

+ func (s *Factored_select_stmtContext) Select_core(i int) ISelect_coreContext

+ func (s *Factored_select_stmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ func (s *Factored_select_stmtContext) With_clause() IWith_clauseContext

+ type Foreign_key_clauseContext struct

+ func NewEmptyForeign_key_clauseContext() *Foreign_key_clauseContext

+ func NewForeign_key_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Foreign_key_clauseContext

+ func (*Foreign_key_clauseContext) IsForeign_key_clauseContext()

+ func (s *Foreign_key_clauseContext) AllCOMMA() []antlr.TerminalNode

+ func (s *Foreign_key_clauseContext) AllColumn_name() []IColumn_nameContext

+ func (s *Foreign_key_clauseContext) AllK_ACTION() []antlr.TerminalNode

+ func (s *Foreign_key_clauseContext) AllK_CASCADE() []antlr.TerminalNode

+ func (s *Foreign_key_clauseContext) AllK_DEFAULT() []antlr.TerminalNode

+ func (s *Foreign_key_clauseContext) AllK_DELETE() []antlr.TerminalNode

+ func (s *Foreign_key_clauseContext) AllK_MATCH() []antlr.TerminalNode

+ func (s *Foreign_key_clauseContext) AllK_NO() []antlr.TerminalNode

+ func (s *Foreign_key_clauseContext) AllK_NULL() []antlr.TerminalNode

+ func (s *Foreign_key_clauseContext) AllK_ON() []antlr.TerminalNode

+ func (s *Foreign_key_clauseContext) AllK_RESTRICT() []antlr.TerminalNode

+ func (s *Foreign_key_clauseContext) AllK_SET() []antlr.TerminalNode

+ func (s *Foreign_key_clauseContext) AllK_UPDATE() []antlr.TerminalNode

+ func (s *Foreign_key_clauseContext) AllName() []INameContext

+ func (s *Foreign_key_clauseContext) CLOSE_PAR() antlr.TerminalNode

+ func (s *Foreign_key_clauseContext) COMMA(i int) antlr.TerminalNode

+ func (s *Foreign_key_clauseContext) Column_name(i int) IColumn_nameContext

+ func (s *Foreign_key_clauseContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Foreign_key_clauseContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Foreign_key_clauseContext) Foreign_table() IForeign_tableContext

+ func (s *Foreign_key_clauseContext) GetParser() antlr.Parser

+ func (s *Foreign_key_clauseContext) GetRuleContext() antlr.RuleContext

+ func (s *Foreign_key_clauseContext) K_ACTION(i int) antlr.TerminalNode

+ func (s *Foreign_key_clauseContext) K_CASCADE(i int) antlr.TerminalNode

+ func (s *Foreign_key_clauseContext) K_DEFAULT(i int) antlr.TerminalNode

+ func (s *Foreign_key_clauseContext) K_DEFERRABLE() antlr.TerminalNode

+ func (s *Foreign_key_clauseContext) K_DEFERRED() antlr.TerminalNode

+ func (s *Foreign_key_clauseContext) K_DELETE(i int) antlr.TerminalNode

+ func (s *Foreign_key_clauseContext) K_IMMEDIATE() antlr.TerminalNode

+ func (s *Foreign_key_clauseContext) K_INITIALLY() antlr.TerminalNode

+ func (s *Foreign_key_clauseContext) K_MATCH(i int) antlr.TerminalNode

+ func (s *Foreign_key_clauseContext) K_NO(i int) antlr.TerminalNode

+ func (s *Foreign_key_clauseContext) K_NOT() antlr.TerminalNode

+ func (s *Foreign_key_clauseContext) K_NULL(i int) antlr.TerminalNode

+ func (s *Foreign_key_clauseContext) K_ON(i int) antlr.TerminalNode

+ func (s *Foreign_key_clauseContext) K_REFERENCES() antlr.TerminalNode

+ func (s *Foreign_key_clauseContext) K_RESTRICT(i int) antlr.TerminalNode

+ func (s *Foreign_key_clauseContext) K_SET(i int) antlr.TerminalNode

+ func (s *Foreign_key_clauseContext) K_UPDATE(i int) antlr.TerminalNode

+ func (s *Foreign_key_clauseContext) Name(i int) INameContext

+ func (s *Foreign_key_clauseContext) OPEN_PAR() antlr.TerminalNode

+ func (s *Foreign_key_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type Foreign_tableContext struct

+ func NewEmptyForeign_tableContext() *Foreign_tableContext

+ func NewForeign_tableContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Foreign_tableContext

+ func (*Foreign_tableContext) IsForeign_tableContext()

+ func (s *Foreign_tableContext) Any_name() IAny_nameContext

+ func (s *Foreign_tableContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Foreign_tableContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Foreign_tableContext) GetParser() antlr.Parser

+ func (s *Foreign_tableContext) GetRuleContext() antlr.RuleContext

+ func (s *Foreign_tableContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type Function_nameContext struct

+ func NewEmptyFunction_nameContext() *Function_nameContext

+ func NewFunction_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Function_nameContext

+ func (*Function_nameContext) IsFunction_nameContext()

+ func (s *Function_nameContext) Any_name() IAny_nameContext

+ func (s *Function_nameContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Function_nameContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Function_nameContext) GetParser() antlr.Parser

+ func (s *Function_nameContext) GetRuleContext() antlr.RuleContext

+ func (s *Function_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type IAlter_table_stmtContext interface

+ GetParser func() antlr.Parser

+ IsAlter_table_stmtContext func()

+ type IAnalyze_stmtContext interface

+ GetParser func() antlr.Parser

+ IsAnalyze_stmtContext func()

+ type IAny_nameContext interface

+ GetParser func() antlr.Parser

+ IsAny_nameContext func()

+ type IAttach_stmtContext interface

+ GetParser func() antlr.Parser

+ IsAttach_stmtContext func()

+ type IBegin_stmtContext interface

+ GetParser func() antlr.Parser

+ IsBegin_stmtContext func()

+ type ICollation_nameContext interface

+ GetParser func() antlr.Parser

+ IsCollation_nameContext func()

+ type IColumn_aliasContext interface

+ GetParser func() antlr.Parser

+ IsColumn_aliasContext func()

+ type IColumn_constraintContext interface

+ GetParser func() antlr.Parser

+ IsColumn_constraintContext func()

+ type IColumn_defContext interface

+ GetParser func() antlr.Parser

+ IsColumn_defContext func()

+ type IColumn_nameContext interface

+ GetParser func() antlr.Parser

+ IsColumn_nameContext func()

+ type ICommit_stmtContext interface

+ GetParser func() antlr.Parser

+ IsCommit_stmtContext func()

+ type ICommon_table_expressionContext interface

+ GetParser func() antlr.Parser

+ IsCommon_table_expressionContext func()

+ type ICompound_operatorContext interface

+ GetParser func() antlr.Parser

+ IsCompound_operatorContext func()

+ type ICompound_select_stmtContext interface

+ GetParser func() antlr.Parser

+ IsCompound_select_stmtContext func()

+ type IConflict_clauseContext interface

+ GetParser func() antlr.Parser

+ IsConflict_clauseContext func()

+ type ICreate_index_stmtContext interface

+ GetParser func() antlr.Parser

+ IsCreate_index_stmtContext func()

+ type ICreate_table_stmtContext interface

+ GetParser func() antlr.Parser

+ IsCreate_table_stmtContext func()

+ type ICreate_trigger_stmtContext interface

+ GetParser func() antlr.Parser

+ IsCreate_trigger_stmtContext func()

+ type ICreate_view_stmtContext interface

+ GetParser func() antlr.Parser

+ IsCreate_view_stmtContext func()

+ type ICreate_virtual_table_stmtContext interface

+ GetParser func() antlr.Parser

+ IsCreate_virtual_table_stmtContext func()

+ type IDatabase_nameContext interface

+ GetParser func() antlr.Parser

+ IsDatabase_nameContext func()

+ type IDelete_stmtContext interface

+ GetParser func() antlr.Parser

+ IsDelete_stmtContext func()

+ type IDelete_stmt_limitedContext interface

+ GetParser func() antlr.Parser

+ IsDelete_stmt_limitedContext func()

+ type IDetach_stmtContext interface

+ GetParser func() antlr.Parser

+ IsDetach_stmtContext func()

+ type IDrop_index_stmtContext interface

+ GetParser func() antlr.Parser

+ IsDrop_index_stmtContext func()

+ type IDrop_table_stmtContext interface

+ GetParser func() antlr.Parser

+ IsDrop_table_stmtContext func()

+ type IDrop_trigger_stmtContext interface

+ GetParser func() antlr.Parser

+ IsDrop_trigger_stmtContext func()

+ type IDrop_view_stmtContext interface

+ GetParser func() antlr.Parser

+ IsDrop_view_stmtContext func()

+ type IError_messageContext interface

+ GetParser func() antlr.Parser

+ IsError_messageContext func()

+ type IExprContext interface

+ GetParser func() antlr.Parser

+ IsExprContext func()

+ type IFactored_select_stmtContext interface

+ GetParser func() antlr.Parser

+ IsFactored_select_stmtContext func()

+ type IForeign_key_clauseContext interface

+ GetParser func() antlr.Parser

+ IsForeign_key_clauseContext func()

+ type IForeign_tableContext interface

+ GetParser func() antlr.Parser

+ IsForeign_tableContext func()

+ type IFunction_nameContext interface

+ GetParser func() antlr.Parser

+ IsFunction_nameContext func()

+ type IIndex_nameContext interface

+ GetParser func() antlr.Parser

+ IsIndex_nameContext func()

+ type IIndexed_columnContext interface

+ GetParser func() antlr.Parser

+ IsIndexed_columnContext func()

+ type IInsert_stmtContext interface

+ GetParser func() antlr.Parser

+ IsInsert_stmtContext func()

+ type IJoin_clauseContext interface

+ GetParser func() antlr.Parser

+ IsJoin_clauseContext func()

+ type IJoin_constraintContext interface

+ GetParser func() antlr.Parser

+ IsJoin_constraintContext func()

+ type IJoin_operatorContext interface

+ GetParser func() antlr.Parser

+ IsJoin_operatorContext func()

+ type IKeywordContext interface

+ GetParser func() antlr.Parser

+ IsKeywordContext func()

+ type ILiteral_valueContext interface

+ GetParser func() antlr.Parser

+ IsLiteral_valueContext func()

+ type IModule_argumentContext interface

+ GetParser func() antlr.Parser

+ IsModule_argumentContext func()

+ type IModule_nameContext interface

+ GetParser func() antlr.Parser

+ IsModule_nameContext func()

+ type INameContext interface

+ GetParser func() antlr.Parser

+ IsNameContext func()

+ type INew_column_nameContext interface

+ GetParser func() antlr.Parser

+ IsNew_column_nameContext func()

+ type INew_table_nameContext interface

+ GetParser func() antlr.Parser

+ IsNew_table_nameContext func()

+ type IOrdering_termContext interface

+ GetParser func() antlr.Parser

+ IsOrdering_termContext func()

+ type IParseContext interface

+ GetParser func() antlr.Parser

+ IsParseContext func()

+ type IPragma_nameContext interface

+ GetParser func() antlr.Parser

+ IsPragma_nameContext func()

+ type IPragma_stmtContext interface

+ GetParser func() antlr.Parser

+ IsPragma_stmtContext func()

+ type IPragma_valueContext interface

+ GetParser func() antlr.Parser

+ IsPragma_valueContext func()

+ type IQualified_table_nameContext interface

+ GetParser func() antlr.Parser

+ IsQualified_table_nameContext func()

+ type IRaise_functionContext interface

+ GetParser func() antlr.Parser

+ IsRaise_functionContext func()

+ type IReindex_stmtContext interface

+ GetParser func() antlr.Parser

+ IsReindex_stmtContext func()

+ type IRelease_stmtContext interface

+ GetParser func() antlr.Parser

+ IsRelease_stmtContext func()

+ type IResult_columnContext interface

+ GetParser func() antlr.Parser

+ IsResult_columnContext func()

+ type IRollback_stmtContext interface

+ GetParser func() antlr.Parser

+ IsRollback_stmtContext func()

+ type ISavepoint_nameContext interface

+ GetParser func() antlr.Parser

+ IsSavepoint_nameContext func()

+ type ISavepoint_stmtContext interface

+ GetParser func() antlr.Parser

+ IsSavepoint_stmtContext func()

+ type ISchema_nameContext interface

+ GetParser func() antlr.Parser

+ IsSchema_nameContext func()

+ type ISelect_coreContext interface

+ GetParser func() antlr.Parser

+ IsSelect_coreContext func()

+ type ISelect_or_valuesContext interface

+ GetParser func() antlr.Parser

+ IsSelect_or_valuesContext func()

+ type ISelect_stmtContext interface

+ GetParser func() antlr.Parser

+ IsSelect_stmtContext func()

+ type ISigned_numberContext interface

+ GetParser func() antlr.Parser

+ IsSigned_numberContext func()

+ type ISimple_select_stmtContext interface

+ GetParser func() antlr.Parser

+ IsSimple_select_stmtContext func()

+ type ISql_stmtContext interface

+ GetParser func() antlr.Parser

+ IsSql_stmtContext func()

+ type ISql_stmt_listContext interface

+ GetParser func() antlr.Parser

+ IsSql_stmt_listContext func()

+ type ITable_aliasContext interface

+ GetParser func() antlr.Parser

+ IsTable_aliasContext func()

+ type ITable_constraintContext interface

+ GetParser func() antlr.Parser

+ IsTable_constraintContext func()

+ type ITable_function_nameContext interface

+ GetParser func() antlr.Parser

+ IsTable_function_nameContext func()

+ type ITable_nameContext interface

+ GetParser func() antlr.Parser

+ IsTable_nameContext func()

+ type ITable_or_index_nameContext interface

+ GetParser func() antlr.Parser

+ IsTable_or_index_nameContext func()

+ type ITable_or_subqueryContext interface

+ GetParser func() antlr.Parser

+ IsTable_or_subqueryContext func()

+ type ITransaction_nameContext interface

+ GetParser func() antlr.Parser

+ IsTransaction_nameContext func()

+ type ITrigger_nameContext interface

+ GetParser func() antlr.Parser

+ IsTrigger_nameContext func()

+ type IType_nameContext interface

+ GetParser func() antlr.Parser

+ IsType_nameContext func()

+ type IUnary_operatorContext interface

+ GetParser func() antlr.Parser

+ IsUnary_operatorContext func()

+ type IUpdate_stmtContext interface

+ GetParser func() antlr.Parser

+ IsUpdate_stmtContext func()

+ type IUpdate_stmt_limitedContext interface

+ GetParser func() antlr.Parser

+ IsUpdate_stmt_limitedContext func()

+ type IVacuum_stmtContext interface

+ GetParser func() antlr.Parser

+ IsVacuum_stmtContext func()

+ type IView_nameContext interface

+ GetParser func() antlr.Parser

+ IsView_nameContext func()

+ type IWith_clauseContext interface

+ GetParser func() antlr.Parser

+ IsWith_clauseContext func()

+ type Index_nameContext struct

+ func NewEmptyIndex_nameContext() *Index_nameContext

+ func NewIndex_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Index_nameContext

+ func (*Index_nameContext) IsIndex_nameContext()

+ func (s *Index_nameContext) Any_name() IAny_nameContext

+ func (s *Index_nameContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Index_nameContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Index_nameContext) GetParser() antlr.Parser

+ func (s *Index_nameContext) GetRuleContext() antlr.RuleContext

+ func (s *Index_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type Indexed_columnContext struct

+ func NewEmptyIndexed_columnContext() *Indexed_columnContext

+ func NewIndexed_columnContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Indexed_columnContext

+ func (*Indexed_columnContext) IsIndexed_columnContext()

+ func (s *Indexed_columnContext) Collation_name() ICollation_nameContext

+ func (s *Indexed_columnContext) Column_name() IColumn_nameContext

+ func (s *Indexed_columnContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Indexed_columnContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Indexed_columnContext) GetParser() antlr.Parser

+ func (s *Indexed_columnContext) GetRuleContext() antlr.RuleContext

+ func (s *Indexed_columnContext) K_ASC() antlr.TerminalNode

+ func (s *Indexed_columnContext) K_COLLATE() antlr.TerminalNode

+ func (s *Indexed_columnContext) K_DESC() antlr.TerminalNode

+ func (s *Indexed_columnContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type Insert_stmtContext struct

+ func NewEmptyInsert_stmtContext() *Insert_stmtContext

+ func NewInsert_stmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Insert_stmtContext

+ func (*Insert_stmtContext) IsInsert_stmtContext()

+ func (s *Insert_stmtContext) AllCLOSE_PAR() []antlr.TerminalNode

+ func (s *Insert_stmtContext) AllCOMMA() []antlr.TerminalNode

+ func (s *Insert_stmtContext) AllColumn_name() []IColumn_nameContext

+ func (s *Insert_stmtContext) AllExpr() []IExprContext

+ func (s *Insert_stmtContext) AllOPEN_PAR() []antlr.TerminalNode

+ func (s *Insert_stmtContext) CLOSE_PAR(i int) antlr.TerminalNode

+ func (s *Insert_stmtContext) COMMA(i int) antlr.TerminalNode

+ func (s *Insert_stmtContext) Column_name(i int) IColumn_nameContext

+ func (s *Insert_stmtContext) DOT() antlr.TerminalNode

+ func (s *Insert_stmtContext) Database_name() IDatabase_nameContext

+ func (s *Insert_stmtContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Insert_stmtContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Insert_stmtContext) Expr(i int) IExprContext

+ func (s *Insert_stmtContext) GetParser() antlr.Parser

+ func (s *Insert_stmtContext) GetRuleContext() antlr.RuleContext

+ func (s *Insert_stmtContext) K_ABORT() antlr.TerminalNode

+ func (s *Insert_stmtContext) K_DEFAULT() antlr.TerminalNode

+ func (s *Insert_stmtContext) K_FAIL() antlr.TerminalNode

+ func (s *Insert_stmtContext) K_IGNORE() antlr.TerminalNode

+ func (s *Insert_stmtContext) K_INSERT() antlr.TerminalNode

+ func (s *Insert_stmtContext) K_INTO() antlr.TerminalNode

+ func (s *Insert_stmtContext) K_OR() antlr.TerminalNode

+ func (s *Insert_stmtContext) K_REPLACE() antlr.TerminalNode

+ func (s *Insert_stmtContext) K_ROLLBACK() antlr.TerminalNode

+ func (s *Insert_stmtContext) K_VALUES() antlr.TerminalNode

+ func (s *Insert_stmtContext) OPEN_PAR(i int) antlr.TerminalNode

+ func (s *Insert_stmtContext) Select_stmt() ISelect_stmtContext

+ func (s *Insert_stmtContext) Table_name() ITable_nameContext

+ func (s *Insert_stmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ func (s *Insert_stmtContext) With_clause() IWith_clauseContext

+ type Join_clauseContext struct

+ func NewEmptyJoin_clauseContext() *Join_clauseContext

+ func NewJoin_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Join_clauseContext

+ func (*Join_clauseContext) IsJoin_clauseContext()

+ func (s *Join_clauseContext) AllJoin_constraint() []IJoin_constraintContext

+ func (s *Join_clauseContext) AllJoin_operator() []IJoin_operatorContext

+ func (s *Join_clauseContext) AllTable_or_subquery() []ITable_or_subqueryContext

+ func (s *Join_clauseContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Join_clauseContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Join_clauseContext) GetParser() antlr.Parser

+ func (s *Join_clauseContext) GetRuleContext() antlr.RuleContext

+ func (s *Join_clauseContext) Join_constraint(i int) IJoin_constraintContext

+ func (s *Join_clauseContext) Join_operator(i int) IJoin_operatorContext

+ func (s *Join_clauseContext) Table_or_subquery(i int) ITable_or_subqueryContext

+ func (s *Join_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type Join_constraintContext struct

+ func NewEmptyJoin_constraintContext() *Join_constraintContext

+ func NewJoin_constraintContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Join_constraintContext

+ func (*Join_constraintContext) IsJoin_constraintContext()

+ func (s *Join_constraintContext) AllCOMMA() []antlr.TerminalNode

+ func (s *Join_constraintContext) AllColumn_name() []IColumn_nameContext

+ func (s *Join_constraintContext) CLOSE_PAR() antlr.TerminalNode

+ func (s *Join_constraintContext) COMMA(i int) antlr.TerminalNode

+ func (s *Join_constraintContext) Column_name(i int) IColumn_nameContext

+ func (s *Join_constraintContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Join_constraintContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Join_constraintContext) Expr() IExprContext

+ func (s *Join_constraintContext) GetParser() antlr.Parser

+ func (s *Join_constraintContext) GetRuleContext() antlr.RuleContext

+ func (s *Join_constraintContext) K_ON() antlr.TerminalNode

+ func (s *Join_constraintContext) K_USING() antlr.TerminalNode

+ func (s *Join_constraintContext) OPEN_PAR() antlr.TerminalNode

+ func (s *Join_constraintContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type Join_operatorContext struct

+ func NewEmptyJoin_operatorContext() *Join_operatorContext

+ func NewJoin_operatorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Join_operatorContext

+ func (*Join_operatorContext) IsJoin_operatorContext()

+ func (s *Join_operatorContext) COMMA() antlr.TerminalNode

+ func (s *Join_operatorContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Join_operatorContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Join_operatorContext) GetParser() antlr.Parser

+ func (s *Join_operatorContext) GetRuleContext() antlr.RuleContext

+ func (s *Join_operatorContext) K_CROSS() antlr.TerminalNode

+ func (s *Join_operatorContext) K_INNER() antlr.TerminalNode

+ func (s *Join_operatorContext) K_JOIN() antlr.TerminalNode

+ func (s *Join_operatorContext) K_LEFT() antlr.TerminalNode

+ func (s *Join_operatorContext) K_NATURAL() antlr.TerminalNode

+ func (s *Join_operatorContext) K_OUTER() antlr.TerminalNode

+ func (s *Join_operatorContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type KeywordContext struct

+ func NewEmptyKeywordContext() *KeywordContext

+ func NewKeywordContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KeywordContext

+ func (*KeywordContext) IsKeywordContext()

+ func (s *KeywordContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *KeywordContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *KeywordContext) GetParser() antlr.Parser

+ func (s *KeywordContext) GetRuleContext() antlr.RuleContext

+ func (s *KeywordContext) K_ABORT() antlr.TerminalNode

+ func (s *KeywordContext) K_ACTION() antlr.TerminalNode

+ func (s *KeywordContext) K_ADD() antlr.TerminalNode

+ func (s *KeywordContext) K_AFTER() antlr.TerminalNode

+ func (s *KeywordContext) K_ALL() antlr.TerminalNode

+ func (s *KeywordContext) K_ALTER() antlr.TerminalNode

+ func (s *KeywordContext) K_ANALYZE() antlr.TerminalNode

+ func (s *KeywordContext) K_AND() antlr.TerminalNode

+ func (s *KeywordContext) K_AS() antlr.TerminalNode

+ func (s *KeywordContext) K_ASC() antlr.TerminalNode

+ func (s *KeywordContext) K_ATTACH() antlr.TerminalNode

+ func (s *KeywordContext) K_AUTOINCREMENT() antlr.TerminalNode

+ func (s *KeywordContext) K_BEFORE() antlr.TerminalNode

+ func (s *KeywordContext) K_BEGIN() antlr.TerminalNode

+ func (s *KeywordContext) K_BETWEEN() antlr.TerminalNode

+ func (s *KeywordContext) K_BY() antlr.TerminalNode

+ func (s *KeywordContext) K_CASCADE() antlr.TerminalNode

+ func (s *KeywordContext) K_CASE() antlr.TerminalNode

+ func (s *KeywordContext) K_CAST() antlr.TerminalNode

+ func (s *KeywordContext) K_CHECK() antlr.TerminalNode

+ func (s *KeywordContext) K_COLLATE() antlr.TerminalNode

+ func (s *KeywordContext) K_COLUMN() antlr.TerminalNode

+ func (s *KeywordContext) K_COMMIT() antlr.TerminalNode

+ func (s *KeywordContext) K_CONFLICT() antlr.TerminalNode

+ func (s *KeywordContext) K_CONSTRAINT() antlr.TerminalNode

+ func (s *KeywordContext) K_CREATE() antlr.TerminalNode

+ func (s *KeywordContext) K_CROSS() antlr.TerminalNode

+ func (s *KeywordContext) K_CURRENT_DATE() antlr.TerminalNode

+ func (s *KeywordContext) K_CURRENT_TIME() antlr.TerminalNode

+ func (s *KeywordContext) K_CURRENT_TIMESTAMP() antlr.TerminalNode

+ func (s *KeywordContext) K_DATABASE() antlr.TerminalNode

+ func (s *KeywordContext) K_DEFAULT() antlr.TerminalNode

+ func (s *KeywordContext) K_DEFERRABLE() antlr.TerminalNode

+ func (s *KeywordContext) K_DEFERRED() antlr.TerminalNode

+ func (s *KeywordContext) K_DELETE() antlr.TerminalNode

+ func (s *KeywordContext) K_DESC() antlr.TerminalNode

+ func (s *KeywordContext) K_DETACH() antlr.TerminalNode

+ func (s *KeywordContext) K_DISTINCT() antlr.TerminalNode

+ func (s *KeywordContext) K_DROP() antlr.TerminalNode

+ func (s *KeywordContext) K_EACH() antlr.TerminalNode

+ func (s *KeywordContext) K_ELSE() antlr.TerminalNode

+ func (s *KeywordContext) K_END() antlr.TerminalNode

+ func (s *KeywordContext) K_ESCAPE() antlr.TerminalNode

+ func (s *KeywordContext) K_EXCEPT() antlr.TerminalNode

+ func (s *KeywordContext) K_EXCLUSIVE() antlr.TerminalNode

+ func (s *KeywordContext) K_EXISTS() antlr.TerminalNode

+ func (s *KeywordContext) K_EXPLAIN() antlr.TerminalNode

+ func (s *KeywordContext) K_FAIL() antlr.TerminalNode

+ func (s *KeywordContext) K_FOR() antlr.TerminalNode

+ func (s *KeywordContext) K_FOREIGN() antlr.TerminalNode

+ func (s *KeywordContext) K_FROM() antlr.TerminalNode

+ func (s *KeywordContext) K_FULL() antlr.TerminalNode

+ func (s *KeywordContext) K_GLOB() antlr.TerminalNode

+ func (s *KeywordContext) K_GROUP() antlr.TerminalNode

+ func (s *KeywordContext) K_HAVING() antlr.TerminalNode

+ func (s *KeywordContext) K_IF() antlr.TerminalNode

+ func (s *KeywordContext) K_IGNORE() antlr.TerminalNode

+ func (s *KeywordContext) K_IMMEDIATE() antlr.TerminalNode

+ func (s *KeywordContext) K_IN() antlr.TerminalNode

+ func (s *KeywordContext) K_INDEX() antlr.TerminalNode

+ func (s *KeywordContext) K_INDEXED() antlr.TerminalNode

+ func (s *KeywordContext) K_INITIALLY() antlr.TerminalNode

+ func (s *KeywordContext) K_INNER() antlr.TerminalNode

+ func (s *KeywordContext) K_INSERT() antlr.TerminalNode

+ func (s *KeywordContext) K_INSTEAD() antlr.TerminalNode

+ func (s *KeywordContext) K_INTERSECT() antlr.TerminalNode

+ func (s *KeywordContext) K_INTO() antlr.TerminalNode

+ func (s *KeywordContext) K_IS() antlr.TerminalNode

+ func (s *KeywordContext) K_ISNULL() antlr.TerminalNode

+ func (s *KeywordContext) K_JOIN() antlr.TerminalNode

+ func (s *KeywordContext) K_KEY() antlr.TerminalNode

+ func (s *KeywordContext) K_LEFT() antlr.TerminalNode

+ func (s *KeywordContext) K_LIKE() antlr.TerminalNode

+ func (s *KeywordContext) K_LIMIT() antlr.TerminalNode

+ func (s *KeywordContext) K_MATCH() antlr.TerminalNode

+ func (s *KeywordContext) K_NATURAL() antlr.TerminalNode

+ func (s *KeywordContext) K_NO() antlr.TerminalNode

+ func (s *KeywordContext) K_NOT() antlr.TerminalNode

+ func (s *KeywordContext) K_NOTNULL() antlr.TerminalNode

+ func (s *KeywordContext) K_NULL() antlr.TerminalNode

+ func (s *KeywordContext) K_OF() antlr.TerminalNode

+ func (s *KeywordContext) K_OFFSET() antlr.TerminalNode

+ func (s *KeywordContext) K_ON() antlr.TerminalNode

+ func (s *KeywordContext) K_OR() antlr.TerminalNode

+ func (s *KeywordContext) K_ORDER() antlr.TerminalNode

+ func (s *KeywordContext) K_OUTER() antlr.TerminalNode

+ func (s *KeywordContext) K_PLAN() antlr.TerminalNode

+ func (s *KeywordContext) K_PRAGMA() antlr.TerminalNode

+ func (s *KeywordContext) K_PRIMARY() antlr.TerminalNode

+ func (s *KeywordContext) K_QUERY() antlr.TerminalNode

+ func (s *KeywordContext) K_RAISE() antlr.TerminalNode

+ func (s *KeywordContext) K_RECURSIVE() antlr.TerminalNode

+ func (s *KeywordContext) K_REFERENCES() antlr.TerminalNode

+ func (s *KeywordContext) K_REGEXP() antlr.TerminalNode

+ func (s *KeywordContext) K_REINDEX() antlr.TerminalNode

+ func (s *KeywordContext) K_RELEASE() antlr.TerminalNode

+ func (s *KeywordContext) K_RENAME() antlr.TerminalNode

+ func (s *KeywordContext) K_REPLACE() antlr.TerminalNode

+ func (s *KeywordContext) K_RESTRICT() antlr.TerminalNode

+ func (s *KeywordContext) K_RIGHT() antlr.TerminalNode

+ func (s *KeywordContext) K_ROLLBACK() antlr.TerminalNode

+ func (s *KeywordContext) K_ROW() antlr.TerminalNode

+ func (s *KeywordContext) K_SAVEPOINT() antlr.TerminalNode

+ func (s *KeywordContext) K_SELECT() antlr.TerminalNode

+ func (s *KeywordContext) K_SET() antlr.TerminalNode

+ func (s *KeywordContext) K_TABLE() antlr.TerminalNode

+ func (s *KeywordContext) K_TEMP() antlr.TerminalNode

+ func (s *KeywordContext) K_TEMPORARY() antlr.TerminalNode

+ func (s *KeywordContext) K_THEN() antlr.TerminalNode

+ func (s *KeywordContext) K_TO() antlr.TerminalNode

+ func (s *KeywordContext) K_TRANSACTION() antlr.TerminalNode

+ func (s *KeywordContext) K_TRIGGER() antlr.TerminalNode

+ func (s *KeywordContext) K_UNION() antlr.TerminalNode

+ func (s *KeywordContext) K_UNIQUE() antlr.TerminalNode

+ func (s *KeywordContext) K_UPDATE() antlr.TerminalNode

+ func (s *KeywordContext) K_USING() antlr.TerminalNode

+ func (s *KeywordContext) K_VACUUM() antlr.TerminalNode

+ func (s *KeywordContext) K_VALUES() antlr.TerminalNode

+ func (s *KeywordContext) K_VIEW() antlr.TerminalNode

+ func (s *KeywordContext) K_VIRTUAL() antlr.TerminalNode

+ func (s *KeywordContext) K_WHEN() antlr.TerminalNode

+ func (s *KeywordContext) K_WHERE() antlr.TerminalNode

+ func (s *KeywordContext) K_WITH() antlr.TerminalNode

+ func (s *KeywordContext) K_WITHOUT() antlr.TerminalNode

+ func (s *KeywordContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type Literal_valueContext struct

+ func NewEmptyLiteral_valueContext() *Literal_valueContext

+ func NewLiteral_valueContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Literal_valueContext

+ func (*Literal_valueContext) IsLiteral_valueContext()

+ func (s *Literal_valueContext) BLOB_LITERAL() antlr.TerminalNode

+ func (s *Literal_valueContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Literal_valueContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Literal_valueContext) GetParser() antlr.Parser

+ func (s *Literal_valueContext) GetRuleContext() antlr.RuleContext

+ func (s *Literal_valueContext) K_CURRENT_DATE() antlr.TerminalNode

+ func (s *Literal_valueContext) K_CURRENT_TIME() antlr.TerminalNode

+ func (s *Literal_valueContext) K_CURRENT_TIMESTAMP() antlr.TerminalNode

+ func (s *Literal_valueContext) K_NULL() antlr.TerminalNode

+ func (s *Literal_valueContext) NUMERIC_LITERAL() antlr.TerminalNode

+ func (s *Literal_valueContext) STRING_LITERAL() antlr.TerminalNode

+ func (s *Literal_valueContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type Module_argumentContext struct

+ func NewEmptyModule_argumentContext() *Module_argumentContext

+ func NewModule_argumentContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Module_argumentContext

+ func (*Module_argumentContext) IsModule_argumentContext()

+ func (s *Module_argumentContext) Column_def() IColumn_defContext

+ func (s *Module_argumentContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Module_argumentContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Module_argumentContext) Expr() IExprContext

+ func (s *Module_argumentContext) GetParser() antlr.Parser

+ func (s *Module_argumentContext) GetRuleContext() antlr.RuleContext

+ func (s *Module_argumentContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type Module_nameContext struct

+ func NewEmptyModule_nameContext() *Module_nameContext

+ func NewModule_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Module_nameContext

+ func (*Module_nameContext) IsModule_nameContext()

+ func (s *Module_nameContext) Any_name() IAny_nameContext

+ func (s *Module_nameContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Module_nameContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Module_nameContext) GetParser() antlr.Parser

+ func (s *Module_nameContext) GetRuleContext() antlr.RuleContext

+ func (s *Module_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type NameContext struct

+ func NewEmptyNameContext() *NameContext

+ func NewNameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *NameContext

+ func (*NameContext) IsNameContext()

+ func (s *NameContext) Any_name() IAny_nameContext

+ func (s *NameContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *NameContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *NameContext) GetParser() antlr.Parser

+ func (s *NameContext) GetRuleContext() antlr.RuleContext

+ func (s *NameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type New_column_nameContext struct

+ func NewEmptyNew_column_nameContext() *New_column_nameContext

+ func NewNew_column_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *New_column_nameContext

+ func (*New_column_nameContext) IsNew_column_nameContext()

+ func (s *New_column_nameContext) Any_name() IAny_nameContext

+ func (s *New_column_nameContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *New_column_nameContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *New_column_nameContext) GetParser() antlr.Parser

+ func (s *New_column_nameContext) GetRuleContext() antlr.RuleContext

+ func (s *New_column_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type New_table_nameContext struct

+ func NewEmptyNew_table_nameContext() *New_table_nameContext

+ func NewNew_table_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *New_table_nameContext

+ func (*New_table_nameContext) IsNew_table_nameContext()

+ func (s *New_table_nameContext) Any_name() IAny_nameContext

+ func (s *New_table_nameContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *New_table_nameContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *New_table_nameContext) GetParser() antlr.Parser

+ func (s *New_table_nameContext) GetRuleContext() antlr.RuleContext

+ func (s *New_table_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type Ordering_termContext struct

+ func NewEmptyOrdering_termContext() *Ordering_termContext

+ func NewOrdering_termContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Ordering_termContext

+ func (*Ordering_termContext) IsOrdering_termContext()

+ func (s *Ordering_termContext) Collation_name() ICollation_nameContext

+ func (s *Ordering_termContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Ordering_termContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Ordering_termContext) Expr() IExprContext

+ func (s *Ordering_termContext) GetParser() antlr.Parser

+ func (s *Ordering_termContext) GetRuleContext() antlr.RuleContext

+ func (s *Ordering_termContext) K_ASC() antlr.TerminalNode

+ func (s *Ordering_termContext) K_COLLATE() antlr.TerminalNode

+ func (s *Ordering_termContext) K_DESC() antlr.TerminalNode

+ func (s *Ordering_termContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type ParseContext struct

+ func NewEmptyParseContext() *ParseContext

+ func NewParseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ParseContext

+ func (*ParseContext) IsParseContext()

+ func (s *ParseContext) AllSql_stmt_list() []ISql_stmt_listContext

+ func (s *ParseContext) EOF() antlr.TerminalNode

+ func (s *ParseContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *ParseContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *ParseContext) GetParser() antlr.Parser

+ func (s *ParseContext) GetRuleContext() antlr.RuleContext

+ func (s *ParseContext) Sql_stmt_list(i int) ISql_stmt_listContext

+ func (s *ParseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type Pragma_nameContext struct

+ func NewEmptyPragma_nameContext() *Pragma_nameContext

+ func NewPragma_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Pragma_nameContext

+ func (*Pragma_nameContext) IsPragma_nameContext()

+ func (s *Pragma_nameContext) Any_name() IAny_nameContext

+ func (s *Pragma_nameContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Pragma_nameContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Pragma_nameContext) GetParser() antlr.Parser

+ func (s *Pragma_nameContext) GetRuleContext() antlr.RuleContext

+ func (s *Pragma_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type Pragma_stmtContext struct

+ func NewEmptyPragma_stmtContext() *Pragma_stmtContext

+ func NewPragma_stmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Pragma_stmtContext

+ func (*Pragma_stmtContext) IsPragma_stmtContext()

+ func (s *Pragma_stmtContext) ASSIGN() antlr.TerminalNode

+ func (s *Pragma_stmtContext) CLOSE_PAR() antlr.TerminalNode

+ func (s *Pragma_stmtContext) DOT() antlr.TerminalNode

+ func (s *Pragma_stmtContext) Database_name() IDatabase_nameContext

+ func (s *Pragma_stmtContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Pragma_stmtContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Pragma_stmtContext) GetParser() antlr.Parser

+ func (s *Pragma_stmtContext) GetRuleContext() antlr.RuleContext

+ func (s *Pragma_stmtContext) K_PRAGMA() antlr.TerminalNode

+ func (s *Pragma_stmtContext) OPEN_PAR() antlr.TerminalNode

+ func (s *Pragma_stmtContext) Pragma_name() IPragma_nameContext

+ func (s *Pragma_stmtContext) Pragma_value() IPragma_valueContext

+ func (s *Pragma_stmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type Pragma_valueContext struct

+ func NewEmptyPragma_valueContext() *Pragma_valueContext

+ func NewPragma_valueContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Pragma_valueContext

+ func (*Pragma_valueContext) IsPragma_valueContext()

+ func (s *Pragma_valueContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Pragma_valueContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Pragma_valueContext) GetParser() antlr.Parser

+ func (s *Pragma_valueContext) GetRuleContext() antlr.RuleContext

+ func (s *Pragma_valueContext) Name() INameContext

+ func (s *Pragma_valueContext) STRING_LITERAL() antlr.TerminalNode

+ func (s *Pragma_valueContext) Signed_number() ISigned_numberContext

+ func (s *Pragma_valueContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type Qualified_table_nameContext struct

+ func NewEmptyQualified_table_nameContext() *Qualified_table_nameContext

+ func NewQualified_table_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Qualified_table_nameContext

+ func (*Qualified_table_nameContext) IsQualified_table_nameContext()

+ func (s *Qualified_table_nameContext) DOT() antlr.TerminalNode

+ func (s *Qualified_table_nameContext) Database_name() IDatabase_nameContext

+ func (s *Qualified_table_nameContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Qualified_table_nameContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Qualified_table_nameContext) GetParser() antlr.Parser

+ func (s *Qualified_table_nameContext) GetRuleContext() antlr.RuleContext

+ func (s *Qualified_table_nameContext) Index_name() IIndex_nameContext

+ func (s *Qualified_table_nameContext) K_BY() antlr.TerminalNode

+ func (s *Qualified_table_nameContext) K_INDEXED() antlr.TerminalNode

+ func (s *Qualified_table_nameContext) K_NOT() antlr.TerminalNode

+ func (s *Qualified_table_nameContext) Table_name() ITable_nameContext

+ func (s *Qualified_table_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type Raise_functionContext struct

+ func NewEmptyRaise_functionContext() *Raise_functionContext

+ func NewRaise_functionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Raise_functionContext

+ func (*Raise_functionContext) IsRaise_functionContext()

+ func (s *Raise_functionContext) CLOSE_PAR() antlr.TerminalNode

+ func (s *Raise_functionContext) COMMA() antlr.TerminalNode

+ func (s *Raise_functionContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Raise_functionContext) Error_message() IError_messageContext

+ func (s *Raise_functionContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Raise_functionContext) GetParser() antlr.Parser

+ func (s *Raise_functionContext) GetRuleContext() antlr.RuleContext

+ func (s *Raise_functionContext) K_ABORT() antlr.TerminalNode

+ func (s *Raise_functionContext) K_FAIL() antlr.TerminalNode

+ func (s *Raise_functionContext) K_IGNORE() antlr.TerminalNode

+ func (s *Raise_functionContext) K_RAISE() antlr.TerminalNode

+ func (s *Raise_functionContext) K_ROLLBACK() antlr.TerminalNode

+ func (s *Raise_functionContext) OPEN_PAR() antlr.TerminalNode

+ func (s *Raise_functionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type Reindex_stmtContext struct

+ func NewEmptyReindex_stmtContext() *Reindex_stmtContext

+ func NewReindex_stmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Reindex_stmtContext

+ func (*Reindex_stmtContext) IsReindex_stmtContext()

+ func (s *Reindex_stmtContext) Collation_name() ICollation_nameContext

+ func (s *Reindex_stmtContext) DOT() antlr.TerminalNode

+ func (s *Reindex_stmtContext) Database_name() IDatabase_nameContext

+ func (s *Reindex_stmtContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Reindex_stmtContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Reindex_stmtContext) GetParser() antlr.Parser

+ func (s *Reindex_stmtContext) GetRuleContext() antlr.RuleContext

+ func (s *Reindex_stmtContext) Index_name() IIndex_nameContext

+ func (s *Reindex_stmtContext) K_REINDEX() antlr.TerminalNode

+ func (s *Reindex_stmtContext) Table_name() ITable_nameContext

+ func (s *Reindex_stmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type Release_stmtContext struct

+ func NewEmptyRelease_stmtContext() *Release_stmtContext

+ func NewRelease_stmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Release_stmtContext

+ func (*Release_stmtContext) IsRelease_stmtContext()

+ func (s *Release_stmtContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Release_stmtContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Release_stmtContext) GetParser() antlr.Parser

+ func (s *Release_stmtContext) GetRuleContext() antlr.RuleContext

+ func (s *Release_stmtContext) K_RELEASE() antlr.TerminalNode

+ func (s *Release_stmtContext) K_SAVEPOINT() antlr.TerminalNode

+ func (s *Release_stmtContext) Savepoint_name() ISavepoint_nameContext

+ func (s *Release_stmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type Result_columnContext struct

+ func NewEmptyResult_columnContext() *Result_columnContext

+ func NewResult_columnContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Result_columnContext

+ func (*Result_columnContext) IsResult_columnContext()

+ func (s *Result_columnContext) Column_alias() IColumn_aliasContext

+ func (s *Result_columnContext) DOT() antlr.TerminalNode

+ func (s *Result_columnContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Result_columnContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Result_columnContext) Expr() IExprContext

+ func (s *Result_columnContext) GetParser() antlr.Parser

+ func (s *Result_columnContext) GetRuleContext() antlr.RuleContext

+ func (s *Result_columnContext) K_AS() antlr.TerminalNode

+ func (s *Result_columnContext) STAR() antlr.TerminalNode

+ func (s *Result_columnContext) Table_name() ITable_nameContext

+ func (s *Result_columnContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type Rollback_stmtContext struct

+ func NewEmptyRollback_stmtContext() *Rollback_stmtContext

+ func NewRollback_stmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Rollback_stmtContext

+ func (*Rollback_stmtContext) IsRollback_stmtContext()

+ func (s *Rollback_stmtContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Rollback_stmtContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Rollback_stmtContext) GetParser() antlr.Parser

+ func (s *Rollback_stmtContext) GetRuleContext() antlr.RuleContext

+ func (s *Rollback_stmtContext) K_ROLLBACK() antlr.TerminalNode

+ func (s *Rollback_stmtContext) K_SAVEPOINT() antlr.TerminalNode

+ func (s *Rollback_stmtContext) K_TO() antlr.TerminalNode

+ func (s *Rollback_stmtContext) K_TRANSACTION() antlr.TerminalNode

+ func (s *Rollback_stmtContext) Savepoint_name() ISavepoint_nameContext

+ func (s *Rollback_stmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ func (s *Rollback_stmtContext) Transaction_name() ITransaction_nameContext

+ type SQLiteLexer struct

+ func NewSQLiteLexer(input antlr.CharStream) *SQLiteLexer

+ type SQLiteListener interface

+ EnterAlter_table_stmt func(c *Alter_table_stmtContext)

+ EnterAnalyze_stmt func(c *Analyze_stmtContext)

+ EnterAny_name func(c *Any_nameContext)

+ EnterAttach_stmt func(c *Attach_stmtContext)

+ EnterBegin_stmt func(c *Begin_stmtContext)

+ EnterCollation_name func(c *Collation_nameContext)

+ EnterColumn_alias func(c *Column_aliasContext)

+ EnterColumn_constraint func(c *Column_constraintContext)

+ EnterColumn_def func(c *Column_defContext)

+ EnterColumn_name func(c *Column_nameContext)

+ EnterCommit_stmt func(c *Commit_stmtContext)

+ EnterCommon_table_expression func(c *Common_table_expressionContext)

+ EnterCompound_operator func(c *Compound_operatorContext)

+ EnterCompound_select_stmt func(c *Compound_select_stmtContext)

+ EnterConflict_clause func(c *Conflict_clauseContext)

+ EnterCreate_index_stmt func(c *Create_index_stmtContext)

+ EnterCreate_table_stmt func(c *Create_table_stmtContext)

+ EnterCreate_trigger_stmt func(c *Create_trigger_stmtContext)

+ EnterCreate_view_stmt func(c *Create_view_stmtContext)

+ EnterCreate_virtual_table_stmt func(c *Create_virtual_table_stmtContext)

+ EnterDatabase_name func(c *Database_nameContext)

+ EnterDelete_stmt func(c *Delete_stmtContext)

+ EnterDelete_stmt_limited func(c *Delete_stmt_limitedContext)

+ EnterDetach_stmt func(c *Detach_stmtContext)

+ EnterDrop_index_stmt func(c *Drop_index_stmtContext)

+ EnterDrop_table_stmt func(c *Drop_table_stmtContext)

+ EnterDrop_trigger_stmt func(c *Drop_trigger_stmtContext)

+ EnterDrop_view_stmt func(c *Drop_view_stmtContext)

+ EnterError_message func(c *Error_messageContext)

+ EnterExpr func(c *ExprContext)

+ EnterFactored_select_stmt func(c *Factored_select_stmtContext)

+ EnterForeign_key_clause func(c *Foreign_key_clauseContext)

+ EnterForeign_table func(c *Foreign_tableContext)

+ EnterFunction_name func(c *Function_nameContext)

+ EnterIndex_name func(c *Index_nameContext)

+ EnterIndexed_column func(c *Indexed_columnContext)

+ EnterInsert_stmt func(c *Insert_stmtContext)

+ EnterJoin_clause func(c *Join_clauseContext)

+ EnterJoin_constraint func(c *Join_constraintContext)

+ EnterJoin_operator func(c *Join_operatorContext)

+ EnterKeyword func(c *KeywordContext)

+ EnterLiteral_value func(c *Literal_valueContext)

+ EnterModule_argument func(c *Module_argumentContext)

+ EnterModule_name func(c *Module_nameContext)

+ EnterName func(c *NameContext)

+ EnterNew_column_name func(c *New_column_nameContext)

+ EnterNew_table_name func(c *New_table_nameContext)

+ EnterOrdering_term func(c *Ordering_termContext)

+ EnterParse func(c *ParseContext)

+ EnterPragma_name func(c *Pragma_nameContext)

+ EnterPragma_stmt func(c *Pragma_stmtContext)

+ EnterPragma_value func(c *Pragma_valueContext)

+ EnterQualified_table_name func(c *Qualified_table_nameContext)

+ EnterRaise_function func(c *Raise_functionContext)

+ EnterReindex_stmt func(c *Reindex_stmtContext)

+ EnterRelease_stmt func(c *Release_stmtContext)

+ EnterResult_column func(c *Result_columnContext)

+ EnterRollback_stmt func(c *Rollback_stmtContext)

+ EnterSavepoint_name func(c *Savepoint_nameContext)

+ EnterSavepoint_stmt func(c *Savepoint_stmtContext)

+ EnterSchema_name func(c *Schema_nameContext)

+ EnterSelect_core func(c *Select_coreContext)

+ EnterSelect_or_values func(c *Select_or_valuesContext)

+ EnterSelect_stmt func(c *Select_stmtContext)

+ EnterSigned_number func(c *Signed_numberContext)

+ EnterSimple_select_stmt func(c *Simple_select_stmtContext)

+ EnterSql_stmt func(c *Sql_stmtContext)

+ EnterSql_stmt_list func(c *Sql_stmt_listContext)

+ EnterTable_alias func(c *Table_aliasContext)

+ EnterTable_constraint func(c *Table_constraintContext)

+ EnterTable_function_name func(c *Table_function_nameContext)

+ EnterTable_name func(c *Table_nameContext)

+ EnterTable_or_index_name func(c *Table_or_index_nameContext)

+ EnterTable_or_subquery func(c *Table_or_subqueryContext)

+ EnterTransaction_name func(c *Transaction_nameContext)

+ EnterTrigger_name func(c *Trigger_nameContext)

+ EnterType_name func(c *Type_nameContext)

+ EnterUnary_operator func(c *Unary_operatorContext)

+ EnterUpdate_stmt func(c *Update_stmtContext)

+ EnterUpdate_stmt_limited func(c *Update_stmt_limitedContext)

+ EnterVacuum_stmt func(c *Vacuum_stmtContext)

+ EnterView_name func(c *View_nameContext)

+ EnterWith_clause func(c *With_clauseContext)

+ ExitAlter_table_stmt func(c *Alter_table_stmtContext)

+ ExitAnalyze_stmt func(c *Analyze_stmtContext)

+ ExitAny_name func(c *Any_nameContext)

+ ExitAttach_stmt func(c *Attach_stmtContext)

+ ExitBegin_stmt func(c *Begin_stmtContext)

+ ExitCollation_name func(c *Collation_nameContext)

+ ExitColumn_alias func(c *Column_aliasContext)

+ ExitColumn_constraint func(c *Column_constraintContext)

+ ExitColumn_def func(c *Column_defContext)

+ ExitColumn_name func(c *Column_nameContext)

+ ExitCommit_stmt func(c *Commit_stmtContext)

+ ExitCommon_table_expression func(c *Common_table_expressionContext)

+ ExitCompound_operator func(c *Compound_operatorContext)

+ ExitCompound_select_stmt func(c *Compound_select_stmtContext)

+ ExitConflict_clause func(c *Conflict_clauseContext)

+ ExitCreate_index_stmt func(c *Create_index_stmtContext)

+ ExitCreate_table_stmt func(c *Create_table_stmtContext)

+ ExitCreate_trigger_stmt func(c *Create_trigger_stmtContext)

+ ExitCreate_view_stmt func(c *Create_view_stmtContext)

+ ExitCreate_virtual_table_stmt func(c *Create_virtual_table_stmtContext)

+ ExitDatabase_name func(c *Database_nameContext)

+ ExitDelete_stmt func(c *Delete_stmtContext)

+ ExitDelete_stmt_limited func(c *Delete_stmt_limitedContext)

+ ExitDetach_stmt func(c *Detach_stmtContext)

+ ExitDrop_index_stmt func(c *Drop_index_stmtContext)

+ ExitDrop_table_stmt func(c *Drop_table_stmtContext)

+ ExitDrop_trigger_stmt func(c *Drop_trigger_stmtContext)

+ ExitDrop_view_stmt func(c *Drop_view_stmtContext)

+ ExitError_message func(c *Error_messageContext)

+ ExitExpr func(c *ExprContext)

+ ExitFactored_select_stmt func(c *Factored_select_stmtContext)

+ ExitForeign_key_clause func(c *Foreign_key_clauseContext)

+ ExitForeign_table func(c *Foreign_tableContext)

+ ExitFunction_name func(c *Function_nameContext)

+ ExitIndex_name func(c *Index_nameContext)

+ ExitIndexed_column func(c *Indexed_columnContext)

+ ExitInsert_stmt func(c *Insert_stmtContext)

+ ExitJoin_clause func(c *Join_clauseContext)

+ ExitJoin_constraint func(c *Join_constraintContext)

+ ExitJoin_operator func(c *Join_operatorContext)

+ ExitKeyword func(c *KeywordContext)

+ ExitLiteral_value func(c *Literal_valueContext)

+ ExitModule_argument func(c *Module_argumentContext)

+ ExitModule_name func(c *Module_nameContext)

+ ExitName func(c *NameContext)

+ ExitNew_column_name func(c *New_column_nameContext)

+ ExitNew_table_name func(c *New_table_nameContext)

+ ExitOrdering_term func(c *Ordering_termContext)

+ ExitParse func(c *ParseContext)

+ ExitPragma_name func(c *Pragma_nameContext)

+ ExitPragma_stmt func(c *Pragma_stmtContext)

+ ExitPragma_value func(c *Pragma_valueContext)

+ ExitQualified_table_name func(c *Qualified_table_nameContext)

+ ExitRaise_function func(c *Raise_functionContext)

+ ExitReindex_stmt func(c *Reindex_stmtContext)

+ ExitRelease_stmt func(c *Release_stmtContext)

+ ExitResult_column func(c *Result_columnContext)

+ ExitRollback_stmt func(c *Rollback_stmtContext)

+ ExitSavepoint_name func(c *Savepoint_nameContext)

+ ExitSavepoint_stmt func(c *Savepoint_stmtContext)

+ ExitSchema_name func(c *Schema_nameContext)

+ ExitSelect_core func(c *Select_coreContext)

+ ExitSelect_or_values func(c *Select_or_valuesContext)

+ ExitSelect_stmt func(c *Select_stmtContext)

+ ExitSigned_number func(c *Signed_numberContext)

+ ExitSimple_select_stmt func(c *Simple_select_stmtContext)

+ ExitSql_stmt func(c *Sql_stmtContext)

+ ExitSql_stmt_list func(c *Sql_stmt_listContext)

+ ExitTable_alias func(c *Table_aliasContext)

+ ExitTable_constraint func(c *Table_constraintContext)

+ ExitTable_function_name func(c *Table_function_nameContext)

+ ExitTable_name func(c *Table_nameContext)

+ ExitTable_or_index_name func(c *Table_or_index_nameContext)

+ ExitTable_or_subquery func(c *Table_or_subqueryContext)

+ ExitTransaction_name func(c *Transaction_nameContext)

+ ExitTrigger_name func(c *Trigger_nameContext)

+ ExitType_name func(c *Type_nameContext)

+ ExitUnary_operator func(c *Unary_operatorContext)

+ ExitUpdate_stmt func(c *Update_stmtContext)

+ ExitUpdate_stmt_limited func(c *Update_stmt_limitedContext)

+ ExitVacuum_stmt func(c *Vacuum_stmtContext)

+ ExitView_name func(c *View_nameContext)

+ ExitWith_clause func(c *With_clauseContext)

+ type SQLiteParser struct

+ func NewSQLiteParser(input antlr.TokenStream) *SQLiteParser

+ func (p *SQLiteParser) Alter_table_stmt() (localctx IAlter_table_stmtContext)

+ func (p *SQLiteParser) Analyze_stmt() (localctx IAnalyze_stmtContext)

+ func (p *SQLiteParser) Any_name() (localctx IAny_nameContext)

+ func (p *SQLiteParser) Attach_stmt() (localctx IAttach_stmtContext)

+ func (p *SQLiteParser) Begin_stmt() (localctx IBegin_stmtContext)

+ func (p *SQLiteParser) Collation_name() (localctx ICollation_nameContext)

+ func (p *SQLiteParser) Column_alias() (localctx IColumn_aliasContext)

+ func (p *SQLiteParser) Column_constraint() (localctx IColumn_constraintContext)

+ func (p *SQLiteParser) Column_def() (localctx IColumn_defContext)

+ func (p *SQLiteParser) Column_name() (localctx IColumn_nameContext)

+ func (p *SQLiteParser) Commit_stmt() (localctx ICommit_stmtContext)

+ func (p *SQLiteParser) Common_table_expression() (localctx ICommon_table_expressionContext)

+ func (p *SQLiteParser) Compound_operator() (localctx ICompound_operatorContext)

+ func (p *SQLiteParser) Compound_select_stmt() (localctx ICompound_select_stmtContext)

+ func (p *SQLiteParser) Conflict_clause() (localctx IConflict_clauseContext)

+ func (p *SQLiteParser) Create_index_stmt() (localctx ICreate_index_stmtContext)

+ func (p *SQLiteParser) Create_table_stmt() (localctx ICreate_table_stmtContext)

+ func (p *SQLiteParser) Create_trigger_stmt() (localctx ICreate_trigger_stmtContext)

+ func (p *SQLiteParser) Create_view_stmt() (localctx ICreate_view_stmtContext)

+ func (p *SQLiteParser) Create_virtual_table_stmt() (localctx ICreate_virtual_table_stmtContext)

+ func (p *SQLiteParser) Database_name() (localctx IDatabase_nameContext)

+ func (p *SQLiteParser) Delete_stmt() (localctx IDelete_stmtContext)

+ func (p *SQLiteParser) Delete_stmt_limited() (localctx IDelete_stmt_limitedContext)

+ func (p *SQLiteParser) Detach_stmt() (localctx IDetach_stmtContext)

+ func (p *SQLiteParser) Drop_index_stmt() (localctx IDrop_index_stmtContext)

+ func (p *SQLiteParser) Drop_table_stmt() (localctx IDrop_table_stmtContext)

+ func (p *SQLiteParser) Drop_trigger_stmt() (localctx IDrop_trigger_stmtContext)

+ func (p *SQLiteParser) Drop_view_stmt() (localctx IDrop_view_stmtContext)

+ func (p *SQLiteParser) Error_message() (localctx IError_messageContext)

+ func (p *SQLiteParser) Expr() (localctx IExprContext)

+ func (p *SQLiteParser) Expr_Sempred(localctx antlr.RuleContext, predIndex int) bool

+ func (p *SQLiteParser) Factored_select_stmt() (localctx IFactored_select_stmtContext)

+ func (p *SQLiteParser) Foreign_key_clause() (localctx IForeign_key_clauseContext)

+ func (p *SQLiteParser) Foreign_table() (localctx IForeign_tableContext)

+ func (p *SQLiteParser) Function_name() (localctx IFunction_nameContext)

+ func (p *SQLiteParser) Index_name() (localctx IIndex_nameContext)

+ func (p *SQLiteParser) Indexed_column() (localctx IIndexed_columnContext)

+ func (p *SQLiteParser) Insert_stmt() (localctx IInsert_stmtContext)

+ func (p *SQLiteParser) Join_clause() (localctx IJoin_clauseContext)

+ func (p *SQLiteParser) Join_constraint() (localctx IJoin_constraintContext)

+ func (p *SQLiteParser) Join_operator() (localctx IJoin_operatorContext)

+ func (p *SQLiteParser) Keyword() (localctx IKeywordContext)

+ func (p *SQLiteParser) Literal_value() (localctx ILiteral_valueContext)

+ func (p *SQLiteParser) Module_argument() (localctx IModule_argumentContext)

+ func (p *SQLiteParser) Module_name() (localctx IModule_nameContext)

+ func (p *SQLiteParser) Name() (localctx INameContext)

+ func (p *SQLiteParser) New_column_name() (localctx INew_column_nameContext)

+ func (p *SQLiteParser) New_table_name() (localctx INew_table_nameContext)

+ func (p *SQLiteParser) Ordering_term() (localctx IOrdering_termContext)

+ func (p *SQLiteParser) Parse() (localctx IParseContext)

+ func (p *SQLiteParser) Pragma_name() (localctx IPragma_nameContext)

+ func (p *SQLiteParser) Pragma_stmt() (localctx IPragma_stmtContext)

+ func (p *SQLiteParser) Pragma_value() (localctx IPragma_valueContext)

+ func (p *SQLiteParser) Qualified_table_name() (localctx IQualified_table_nameContext)

+ func (p *SQLiteParser) Raise_function() (localctx IRaise_functionContext)

+ func (p *SQLiteParser) Reindex_stmt() (localctx IReindex_stmtContext)

+ func (p *SQLiteParser) Release_stmt() (localctx IRelease_stmtContext)

+ func (p *SQLiteParser) Result_column() (localctx IResult_columnContext)

+ func (p *SQLiteParser) Rollback_stmt() (localctx IRollback_stmtContext)

+ func (p *SQLiteParser) Savepoint_name() (localctx ISavepoint_nameContext)

+ func (p *SQLiteParser) Savepoint_stmt() (localctx ISavepoint_stmtContext)

+ func (p *SQLiteParser) Schema_name() (localctx ISchema_nameContext)

+ func (p *SQLiteParser) Select_core() (localctx ISelect_coreContext)

+ func (p *SQLiteParser) Select_or_values() (localctx ISelect_or_valuesContext)

+ func (p *SQLiteParser) Select_stmt() (localctx ISelect_stmtContext)

+ func (p *SQLiteParser) Sempred(localctx antlr.RuleContext, ruleIndex, predIndex int) bool

+ func (p *SQLiteParser) Signed_number() (localctx ISigned_numberContext)

+ func (p *SQLiteParser) Simple_select_stmt() (localctx ISimple_select_stmtContext)

+ func (p *SQLiteParser) Sql_stmt() (localctx ISql_stmtContext)

+ func (p *SQLiteParser) Sql_stmt_list() (localctx ISql_stmt_listContext)

+ func (p *SQLiteParser) Table_alias() (localctx ITable_aliasContext)

+ func (p *SQLiteParser) Table_constraint() (localctx ITable_constraintContext)

+ func (p *SQLiteParser) Table_function_name() (localctx ITable_function_nameContext)

+ func (p *SQLiteParser) Table_name() (localctx ITable_nameContext)

+ func (p *SQLiteParser) Table_or_index_name() (localctx ITable_or_index_nameContext)

+ func (p *SQLiteParser) Table_or_subquery() (localctx ITable_or_subqueryContext)

+ func (p *SQLiteParser) Transaction_name() (localctx ITransaction_nameContext)

+ func (p *SQLiteParser) Trigger_name() (localctx ITrigger_nameContext)

+ func (p *SQLiteParser) Type_name() (localctx IType_nameContext)

+ func (p *SQLiteParser) Unary_operator() (localctx IUnary_operatorContext)

+ func (p *SQLiteParser) Update_stmt() (localctx IUpdate_stmtContext)

+ func (p *SQLiteParser) Update_stmt_limited() (localctx IUpdate_stmt_limitedContext)

+ func (p *SQLiteParser) Vacuum_stmt() (localctx IVacuum_stmtContext)

+ func (p *SQLiteParser) View_name() (localctx IView_nameContext)

+ func (p *SQLiteParser) With_clause() (localctx IWith_clauseContext)

+ type Savepoint_nameContext struct

+ func NewEmptySavepoint_nameContext() *Savepoint_nameContext

+ func NewSavepoint_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Savepoint_nameContext

+ func (*Savepoint_nameContext) IsSavepoint_nameContext()

+ func (s *Savepoint_nameContext) Any_name() IAny_nameContext

+ func (s *Savepoint_nameContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Savepoint_nameContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Savepoint_nameContext) GetParser() antlr.Parser

+ func (s *Savepoint_nameContext) GetRuleContext() antlr.RuleContext

+ func (s *Savepoint_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type Savepoint_stmtContext struct

+ func NewEmptySavepoint_stmtContext() *Savepoint_stmtContext

+ func NewSavepoint_stmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Savepoint_stmtContext

+ func (*Savepoint_stmtContext) IsSavepoint_stmtContext()

+ func (s *Savepoint_stmtContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Savepoint_stmtContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Savepoint_stmtContext) GetParser() antlr.Parser

+ func (s *Savepoint_stmtContext) GetRuleContext() antlr.RuleContext

+ func (s *Savepoint_stmtContext) K_SAVEPOINT() antlr.TerminalNode

+ func (s *Savepoint_stmtContext) Savepoint_name() ISavepoint_nameContext

+ func (s *Savepoint_stmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type Schema_nameContext struct

+ func NewEmptySchema_nameContext() *Schema_nameContext

+ func NewSchema_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Schema_nameContext

+ func (*Schema_nameContext) IsSchema_nameContext()

+ func (s *Schema_nameContext) Any_name() IAny_nameContext

+ func (s *Schema_nameContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Schema_nameContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Schema_nameContext) GetParser() antlr.Parser

+ func (s *Schema_nameContext) GetRuleContext() antlr.RuleContext

+ func (s *Schema_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type Select_coreContext struct

+ func NewEmptySelect_coreContext() *Select_coreContext

+ func NewSelect_coreContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Select_coreContext

+ func (*Select_coreContext) IsSelect_coreContext()

+ func (s *Select_coreContext) AllCLOSE_PAR() []antlr.TerminalNode

+ func (s *Select_coreContext) AllCOMMA() []antlr.TerminalNode

+ func (s *Select_coreContext) AllExpr() []IExprContext

+ func (s *Select_coreContext) AllOPEN_PAR() []antlr.TerminalNode

+ func (s *Select_coreContext) AllResult_column() []IResult_columnContext

+ func (s *Select_coreContext) AllTable_or_subquery() []ITable_or_subqueryContext

+ func (s *Select_coreContext) CLOSE_PAR(i int) antlr.TerminalNode

+ func (s *Select_coreContext) COMMA(i int) antlr.TerminalNode

+ func (s *Select_coreContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Select_coreContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Select_coreContext) Expr(i int) IExprContext

+ func (s *Select_coreContext) GetParser() antlr.Parser

+ func (s *Select_coreContext) GetRuleContext() antlr.RuleContext

+ func (s *Select_coreContext) Join_clause() IJoin_clauseContext

+ func (s *Select_coreContext) K_ALL() antlr.TerminalNode

+ func (s *Select_coreContext) K_BY() antlr.TerminalNode

+ func (s *Select_coreContext) K_DISTINCT() antlr.TerminalNode

+ func (s *Select_coreContext) K_FROM() antlr.TerminalNode

+ func (s *Select_coreContext) K_GROUP() antlr.TerminalNode

+ func (s *Select_coreContext) K_HAVING() antlr.TerminalNode

+ func (s *Select_coreContext) K_SELECT() antlr.TerminalNode

+ func (s *Select_coreContext) K_VALUES() antlr.TerminalNode

+ func (s *Select_coreContext) K_WHERE() antlr.TerminalNode

+ func (s *Select_coreContext) OPEN_PAR(i int) antlr.TerminalNode

+ func (s *Select_coreContext) Result_column(i int) IResult_columnContext

+ func (s *Select_coreContext) Table_or_subquery(i int) ITable_or_subqueryContext

+ func (s *Select_coreContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type Select_or_valuesContext struct

+ func NewEmptySelect_or_valuesContext() *Select_or_valuesContext

+ func NewSelect_or_valuesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Select_or_valuesContext

+ func (*Select_or_valuesContext) IsSelect_or_valuesContext()

+ func (s *Select_or_valuesContext) AllCLOSE_PAR() []antlr.TerminalNode

+ func (s *Select_or_valuesContext) AllCOMMA() []antlr.TerminalNode

+ func (s *Select_or_valuesContext) AllExpr() []IExprContext

+ func (s *Select_or_valuesContext) AllOPEN_PAR() []antlr.TerminalNode

+ func (s *Select_or_valuesContext) AllResult_column() []IResult_columnContext

+ func (s *Select_or_valuesContext) AllTable_or_subquery() []ITable_or_subqueryContext

+ func (s *Select_or_valuesContext) CLOSE_PAR(i int) antlr.TerminalNode

+ func (s *Select_or_valuesContext) COMMA(i int) antlr.TerminalNode

+ func (s *Select_or_valuesContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Select_or_valuesContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Select_or_valuesContext) Expr(i int) IExprContext

+ func (s *Select_or_valuesContext) GetParser() antlr.Parser

+ func (s *Select_or_valuesContext) GetRuleContext() antlr.RuleContext

+ func (s *Select_or_valuesContext) Join_clause() IJoin_clauseContext

+ func (s *Select_or_valuesContext) K_ALL() antlr.TerminalNode

+ func (s *Select_or_valuesContext) K_BY() antlr.TerminalNode

+ func (s *Select_or_valuesContext) K_DISTINCT() antlr.TerminalNode

+ func (s *Select_or_valuesContext) K_FROM() antlr.TerminalNode

+ func (s *Select_or_valuesContext) K_GROUP() antlr.TerminalNode

+ func (s *Select_or_valuesContext) K_HAVING() antlr.TerminalNode

+ func (s *Select_or_valuesContext) K_SELECT() antlr.TerminalNode

+ func (s *Select_or_valuesContext) K_VALUES() antlr.TerminalNode

+ func (s *Select_or_valuesContext) K_WHERE() antlr.TerminalNode

+ func (s *Select_or_valuesContext) OPEN_PAR(i int) antlr.TerminalNode

+ func (s *Select_or_valuesContext) Result_column(i int) IResult_columnContext

+ func (s *Select_or_valuesContext) Table_or_subquery(i int) ITable_or_subqueryContext

+ func (s *Select_or_valuesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type Select_stmtContext struct

+ func NewEmptySelect_stmtContext() *Select_stmtContext

+ func NewSelect_stmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Select_stmtContext

+ func (*Select_stmtContext) IsSelect_stmtContext()

+ func (s *Select_stmtContext) AllCOMMA() []antlr.TerminalNode

+ func (s *Select_stmtContext) AllCompound_operator() []ICompound_operatorContext

+ func (s *Select_stmtContext) AllExpr() []IExprContext

+ func (s *Select_stmtContext) AllOrdering_term() []IOrdering_termContext

+ func (s *Select_stmtContext) AllSelect_or_values() []ISelect_or_valuesContext

+ func (s *Select_stmtContext) COMMA(i int) antlr.TerminalNode

+ func (s *Select_stmtContext) Compound_operator(i int) ICompound_operatorContext

+ func (s *Select_stmtContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Select_stmtContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Select_stmtContext) Expr(i int) IExprContext

+ func (s *Select_stmtContext) GetParser() antlr.Parser

+ func (s *Select_stmtContext) GetRuleContext() antlr.RuleContext

+ func (s *Select_stmtContext) K_BY() antlr.TerminalNode

+ func (s *Select_stmtContext) K_LIMIT() antlr.TerminalNode

+ func (s *Select_stmtContext) K_OFFSET() antlr.TerminalNode

+ func (s *Select_stmtContext) K_ORDER() antlr.TerminalNode

+ func (s *Select_stmtContext) Ordering_term(i int) IOrdering_termContext

+ func (s *Select_stmtContext) Select_or_values(i int) ISelect_or_valuesContext

+ func (s *Select_stmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ func (s *Select_stmtContext) With_clause() IWith_clauseContext

+ type Signed_numberContext struct

+ func NewEmptySigned_numberContext() *Signed_numberContext

+ func NewSigned_numberContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Signed_numberContext

+ func (*Signed_numberContext) IsSigned_numberContext()

+ func (s *Signed_numberContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Signed_numberContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Signed_numberContext) GetParser() antlr.Parser

+ func (s *Signed_numberContext) GetRuleContext() antlr.RuleContext

+ func (s *Signed_numberContext) MINUS() antlr.TerminalNode

+ func (s *Signed_numberContext) NUMERIC_LITERAL() antlr.TerminalNode

+ func (s *Signed_numberContext) PLUS() antlr.TerminalNode

+ func (s *Signed_numberContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type Simple_select_stmtContext struct

+ func NewEmptySimple_select_stmtContext() *Simple_select_stmtContext

+ func NewSimple_select_stmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Simple_select_stmtContext

+ func (*Simple_select_stmtContext) IsSimple_select_stmtContext()

+ func (s *Simple_select_stmtContext) AllCOMMA() []antlr.TerminalNode

+ func (s *Simple_select_stmtContext) AllExpr() []IExprContext

+ func (s *Simple_select_stmtContext) AllOrdering_term() []IOrdering_termContext

+ func (s *Simple_select_stmtContext) COMMA(i int) antlr.TerminalNode

+ func (s *Simple_select_stmtContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Simple_select_stmtContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Simple_select_stmtContext) Expr(i int) IExprContext

+ func (s *Simple_select_stmtContext) GetParser() antlr.Parser

+ func (s *Simple_select_stmtContext) GetRuleContext() antlr.RuleContext

+ func (s *Simple_select_stmtContext) K_BY() antlr.TerminalNode

+ func (s *Simple_select_stmtContext) K_LIMIT() antlr.TerminalNode

+ func (s *Simple_select_stmtContext) K_OFFSET() antlr.TerminalNode

+ func (s *Simple_select_stmtContext) K_ORDER() antlr.TerminalNode

+ func (s *Simple_select_stmtContext) Ordering_term(i int) IOrdering_termContext

+ func (s *Simple_select_stmtContext) Select_core() ISelect_coreContext

+ func (s *Simple_select_stmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ func (s *Simple_select_stmtContext) With_clause() IWith_clauseContext

+ type Sql_stmtContext struct

+ func NewEmptySql_stmtContext() *Sql_stmtContext

+ func NewSql_stmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Sql_stmtContext

+ func (*Sql_stmtContext) IsSql_stmtContext()

+ func (s *Sql_stmtContext) Alter_table_stmt() IAlter_table_stmtContext

+ func (s *Sql_stmtContext) Analyze_stmt() IAnalyze_stmtContext

+ func (s *Sql_stmtContext) Attach_stmt() IAttach_stmtContext

+ func (s *Sql_stmtContext) Begin_stmt() IBegin_stmtContext

+ func (s *Sql_stmtContext) Commit_stmt() ICommit_stmtContext

+ func (s *Sql_stmtContext) Compound_select_stmt() ICompound_select_stmtContext

+ func (s *Sql_stmtContext) Create_index_stmt() ICreate_index_stmtContext

+ func (s *Sql_stmtContext) Create_table_stmt() ICreate_table_stmtContext

+ func (s *Sql_stmtContext) Create_trigger_stmt() ICreate_trigger_stmtContext

+ func (s *Sql_stmtContext) Create_view_stmt() ICreate_view_stmtContext

+ func (s *Sql_stmtContext) Create_virtual_table_stmt() ICreate_virtual_table_stmtContext

+ func (s *Sql_stmtContext) Delete_stmt() IDelete_stmtContext

+ func (s *Sql_stmtContext) Delete_stmt_limited() IDelete_stmt_limitedContext

+ func (s *Sql_stmtContext) Detach_stmt() IDetach_stmtContext

+ func (s *Sql_stmtContext) Drop_index_stmt() IDrop_index_stmtContext

+ func (s *Sql_stmtContext) Drop_table_stmt() IDrop_table_stmtContext

+ func (s *Sql_stmtContext) Drop_trigger_stmt() IDrop_trigger_stmtContext

+ func (s *Sql_stmtContext) Drop_view_stmt() IDrop_view_stmtContext

+ func (s *Sql_stmtContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Sql_stmtContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Sql_stmtContext) Factored_select_stmt() IFactored_select_stmtContext

+ func (s *Sql_stmtContext) GetParser() antlr.Parser

+ func (s *Sql_stmtContext) GetRuleContext() antlr.RuleContext

+ func (s *Sql_stmtContext) Insert_stmt() IInsert_stmtContext

+ func (s *Sql_stmtContext) K_EXPLAIN() antlr.TerminalNode

+ func (s *Sql_stmtContext) K_PLAN() antlr.TerminalNode

+ func (s *Sql_stmtContext) K_QUERY() antlr.TerminalNode

+ func (s *Sql_stmtContext) Pragma_stmt() IPragma_stmtContext

+ func (s *Sql_stmtContext) Reindex_stmt() IReindex_stmtContext

+ func (s *Sql_stmtContext) Release_stmt() IRelease_stmtContext

+ func (s *Sql_stmtContext) Rollback_stmt() IRollback_stmtContext

+ func (s *Sql_stmtContext) Savepoint_stmt() ISavepoint_stmtContext

+ func (s *Sql_stmtContext) Select_stmt() ISelect_stmtContext

+ func (s *Sql_stmtContext) Simple_select_stmt() ISimple_select_stmtContext

+ func (s *Sql_stmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ func (s *Sql_stmtContext) Update_stmt() IUpdate_stmtContext

+ func (s *Sql_stmtContext) Update_stmt_limited() IUpdate_stmt_limitedContext

+ func (s *Sql_stmtContext) Vacuum_stmt() IVacuum_stmtContext

+ type Sql_stmt_listContext struct

+ func NewEmptySql_stmt_listContext() *Sql_stmt_listContext

+ func NewSql_stmt_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Sql_stmt_listContext

+ func (*Sql_stmt_listContext) IsSql_stmt_listContext()

+ func (s *Sql_stmt_listContext) AllSCOL() []antlr.TerminalNode

+ func (s *Sql_stmt_listContext) AllSql_stmt() []ISql_stmtContext

+ func (s *Sql_stmt_listContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Sql_stmt_listContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Sql_stmt_listContext) GetParser() antlr.Parser

+ func (s *Sql_stmt_listContext) GetRuleContext() antlr.RuleContext

+ func (s *Sql_stmt_listContext) SCOL(i int) antlr.TerminalNode

+ func (s *Sql_stmt_listContext) Sql_stmt(i int) ISql_stmtContext

+ func (s *Sql_stmt_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type Table_aliasContext struct

+ func NewEmptyTable_aliasContext() *Table_aliasContext

+ func NewTable_aliasContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Table_aliasContext

+ func (*Table_aliasContext) IsTable_aliasContext()

+ func (s *Table_aliasContext) CLOSE_PAR() antlr.TerminalNode

+ func (s *Table_aliasContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Table_aliasContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Table_aliasContext) GetParser() antlr.Parser

+ func (s *Table_aliasContext) GetRuleContext() antlr.RuleContext

+ func (s *Table_aliasContext) IDENTIFIER() antlr.TerminalNode

+ func (s *Table_aliasContext) OPEN_PAR() antlr.TerminalNode

+ func (s *Table_aliasContext) STRING_LITERAL() antlr.TerminalNode

+ func (s *Table_aliasContext) Table_alias() ITable_aliasContext

+ func (s *Table_aliasContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type Table_constraintContext struct

+ func NewEmptyTable_constraintContext() *Table_constraintContext

+ func NewTable_constraintContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Table_constraintContext

+ func (*Table_constraintContext) IsTable_constraintContext()

+ func (s *Table_constraintContext) AllCOMMA() []antlr.TerminalNode

+ func (s *Table_constraintContext) AllColumn_name() []IColumn_nameContext

+ func (s *Table_constraintContext) AllIndexed_column() []IIndexed_columnContext

+ func (s *Table_constraintContext) CLOSE_PAR() antlr.TerminalNode

+ func (s *Table_constraintContext) COMMA(i int) antlr.TerminalNode

+ func (s *Table_constraintContext) Column_name(i int) IColumn_nameContext

+ func (s *Table_constraintContext) Conflict_clause() IConflict_clauseContext

+ func (s *Table_constraintContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Table_constraintContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Table_constraintContext) Expr() IExprContext

+ func (s *Table_constraintContext) Foreign_key_clause() IForeign_key_clauseContext

+ func (s *Table_constraintContext) GetParser() antlr.Parser

+ func (s *Table_constraintContext) GetRuleContext() antlr.RuleContext

+ func (s *Table_constraintContext) Indexed_column(i int) IIndexed_columnContext

+ func (s *Table_constraintContext) K_CHECK() antlr.TerminalNode

+ func (s *Table_constraintContext) K_CONSTRAINT() antlr.TerminalNode

+ func (s *Table_constraintContext) K_FOREIGN() antlr.TerminalNode

+ func (s *Table_constraintContext) K_KEY() antlr.TerminalNode

+ func (s *Table_constraintContext) K_PRIMARY() antlr.TerminalNode

+ func (s *Table_constraintContext) K_UNIQUE() antlr.TerminalNode

+ func (s *Table_constraintContext) Name() INameContext

+ func (s *Table_constraintContext) OPEN_PAR() antlr.TerminalNode

+ func (s *Table_constraintContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type Table_function_nameContext struct

+ func NewEmptyTable_function_nameContext() *Table_function_nameContext

+ func NewTable_function_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Table_function_nameContext

+ func (*Table_function_nameContext) IsTable_function_nameContext()

+ func (s *Table_function_nameContext) Any_name() IAny_nameContext

+ func (s *Table_function_nameContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Table_function_nameContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Table_function_nameContext) GetParser() antlr.Parser

+ func (s *Table_function_nameContext) GetRuleContext() antlr.RuleContext

+ func (s *Table_function_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type Table_nameContext struct

+ func NewEmptyTable_nameContext() *Table_nameContext

+ func NewTable_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Table_nameContext

+ func (*Table_nameContext) IsTable_nameContext()

+ func (s *Table_nameContext) Any_name() IAny_nameContext

+ func (s *Table_nameContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Table_nameContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Table_nameContext) GetParser() antlr.Parser

+ func (s *Table_nameContext) GetRuleContext() antlr.RuleContext

+ func (s *Table_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type Table_or_index_nameContext struct

+ func NewEmptyTable_or_index_nameContext() *Table_or_index_nameContext

+ func NewTable_or_index_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Table_or_index_nameContext

+ func (*Table_or_index_nameContext) IsTable_or_index_nameContext()

+ func (s *Table_or_index_nameContext) Any_name() IAny_nameContext

+ func (s *Table_or_index_nameContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Table_or_index_nameContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Table_or_index_nameContext) GetParser() antlr.Parser

+ func (s *Table_or_index_nameContext) GetRuleContext() antlr.RuleContext

+ func (s *Table_or_index_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type Table_or_subqueryContext struct

+ func NewEmptyTable_or_subqueryContext() *Table_or_subqueryContext

+ func NewTable_or_subqueryContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Table_or_subqueryContext

+ func (*Table_or_subqueryContext) IsTable_or_subqueryContext()

+ func (s *Table_or_subqueryContext) AllCOMMA() []antlr.TerminalNode

+ func (s *Table_or_subqueryContext) AllExpr() []IExprContext

+ func (s *Table_or_subqueryContext) AllTable_or_subquery() []ITable_or_subqueryContext

+ func (s *Table_or_subqueryContext) CLOSE_PAR() antlr.TerminalNode

+ func (s *Table_or_subqueryContext) COMMA(i int) antlr.TerminalNode

+ func (s *Table_or_subqueryContext) DOT() antlr.TerminalNode

+ func (s *Table_or_subqueryContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Table_or_subqueryContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Table_or_subqueryContext) Expr(i int) IExprContext

+ func (s *Table_or_subqueryContext) GetParser() antlr.Parser

+ func (s *Table_or_subqueryContext) GetRuleContext() antlr.RuleContext

+ func (s *Table_or_subqueryContext) Index_name() IIndex_nameContext

+ func (s *Table_or_subqueryContext) Join_clause() IJoin_clauseContext

+ func (s *Table_or_subqueryContext) K_AS() antlr.TerminalNode

+ func (s *Table_or_subqueryContext) K_BY() antlr.TerminalNode

+ func (s *Table_or_subqueryContext) K_INDEXED() antlr.TerminalNode

+ func (s *Table_or_subqueryContext) K_NOT() antlr.TerminalNode

+ func (s *Table_or_subqueryContext) OPEN_PAR() antlr.TerminalNode

+ func (s *Table_or_subqueryContext) Schema_name() ISchema_nameContext

+ func (s *Table_or_subqueryContext) Select_stmt() ISelect_stmtContext

+ func (s *Table_or_subqueryContext) Table_alias() ITable_aliasContext

+ func (s *Table_or_subqueryContext) Table_function_name() ITable_function_nameContext

+ func (s *Table_or_subqueryContext) Table_name() ITable_nameContext

+ func (s *Table_or_subqueryContext) Table_or_subquery(i int) ITable_or_subqueryContext

+ func (s *Table_or_subqueryContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type Transaction_nameContext struct

+ func NewEmptyTransaction_nameContext() *Transaction_nameContext

+ func NewTransaction_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Transaction_nameContext

+ func (*Transaction_nameContext) IsTransaction_nameContext()

+ func (s *Transaction_nameContext) Any_name() IAny_nameContext

+ func (s *Transaction_nameContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Transaction_nameContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Transaction_nameContext) GetParser() antlr.Parser

+ func (s *Transaction_nameContext) GetRuleContext() antlr.RuleContext

+ func (s *Transaction_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type Trigger_nameContext struct

+ func NewEmptyTrigger_nameContext() *Trigger_nameContext

+ func NewTrigger_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Trigger_nameContext

+ func (*Trigger_nameContext) IsTrigger_nameContext()

+ func (s *Trigger_nameContext) Any_name() IAny_nameContext

+ func (s *Trigger_nameContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Trigger_nameContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Trigger_nameContext) GetParser() antlr.Parser

+ func (s *Trigger_nameContext) GetRuleContext() antlr.RuleContext

+ func (s *Trigger_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type Type_nameContext struct

+ func NewEmptyType_nameContext() *Type_nameContext

+ func NewType_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Type_nameContext

+ func (*Type_nameContext) IsType_nameContext()

+ func (s *Type_nameContext) AllName() []INameContext

+ func (s *Type_nameContext) AllSigned_number() []ISigned_numberContext

+ func (s *Type_nameContext) CLOSE_PAR() antlr.TerminalNode

+ func (s *Type_nameContext) COMMA() antlr.TerminalNode

+ func (s *Type_nameContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Type_nameContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Type_nameContext) GetParser() antlr.Parser

+ func (s *Type_nameContext) GetRuleContext() antlr.RuleContext

+ func (s *Type_nameContext) Name(i int) INameContext

+ func (s *Type_nameContext) OPEN_PAR() antlr.TerminalNode

+ func (s *Type_nameContext) Signed_number(i int) ISigned_numberContext

+ func (s *Type_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type Unary_operatorContext struct

+ func NewEmptyUnary_operatorContext() *Unary_operatorContext

+ func NewUnary_operatorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Unary_operatorContext

+ func (*Unary_operatorContext) IsUnary_operatorContext()

+ func (s *Unary_operatorContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Unary_operatorContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Unary_operatorContext) GetParser() antlr.Parser

+ func (s *Unary_operatorContext) GetRuleContext() antlr.RuleContext

+ func (s *Unary_operatorContext) K_NOT() antlr.TerminalNode

+ func (s *Unary_operatorContext) MINUS() antlr.TerminalNode

+ func (s *Unary_operatorContext) PLUS() antlr.TerminalNode

+ func (s *Unary_operatorContext) TILDE() antlr.TerminalNode

+ func (s *Unary_operatorContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type Update_stmtContext struct

+ func NewEmptyUpdate_stmtContext() *Update_stmtContext

+ func NewUpdate_stmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Update_stmtContext

+ func (*Update_stmtContext) IsUpdate_stmtContext()

+ func (s *Update_stmtContext) ASSIGN(i int) antlr.TerminalNode

+ func (s *Update_stmtContext) AllASSIGN() []antlr.TerminalNode

+ func (s *Update_stmtContext) AllCOMMA() []antlr.TerminalNode

+ func (s *Update_stmtContext) AllColumn_name() []IColumn_nameContext

+ func (s *Update_stmtContext) AllExpr() []IExprContext

+ func (s *Update_stmtContext) COMMA(i int) antlr.TerminalNode

+ func (s *Update_stmtContext) Column_name(i int) IColumn_nameContext

+ func (s *Update_stmtContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Update_stmtContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Update_stmtContext) Expr(i int) IExprContext

+ func (s *Update_stmtContext) GetParser() antlr.Parser

+ func (s *Update_stmtContext) GetRuleContext() antlr.RuleContext

+ func (s *Update_stmtContext) K_ABORT() antlr.TerminalNode

+ func (s *Update_stmtContext) K_FAIL() antlr.TerminalNode

+ func (s *Update_stmtContext) K_IGNORE() antlr.TerminalNode

+ func (s *Update_stmtContext) K_OR() antlr.TerminalNode

+ func (s *Update_stmtContext) K_REPLACE() antlr.TerminalNode

+ func (s *Update_stmtContext) K_ROLLBACK() antlr.TerminalNode

+ func (s *Update_stmtContext) K_SET() antlr.TerminalNode

+ func (s *Update_stmtContext) K_UPDATE() antlr.TerminalNode

+ func (s *Update_stmtContext) K_WHERE() antlr.TerminalNode

+ func (s *Update_stmtContext) Qualified_table_name() IQualified_table_nameContext

+ func (s *Update_stmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ func (s *Update_stmtContext) With_clause() IWith_clauseContext

+ type Update_stmt_limitedContext struct

+ func NewEmptyUpdate_stmt_limitedContext() *Update_stmt_limitedContext

+ func NewUpdate_stmt_limitedContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Update_stmt_limitedContext

+ func (*Update_stmt_limitedContext) IsUpdate_stmt_limitedContext()

+ func (s *Update_stmt_limitedContext) ASSIGN(i int) antlr.TerminalNode

+ func (s *Update_stmt_limitedContext) AllASSIGN() []antlr.TerminalNode

+ func (s *Update_stmt_limitedContext) AllCOMMA() []antlr.TerminalNode

+ func (s *Update_stmt_limitedContext) AllColumn_name() []IColumn_nameContext

+ func (s *Update_stmt_limitedContext) AllExpr() []IExprContext

+ func (s *Update_stmt_limitedContext) AllOrdering_term() []IOrdering_termContext

+ func (s *Update_stmt_limitedContext) COMMA(i int) antlr.TerminalNode

+ func (s *Update_stmt_limitedContext) Column_name(i int) IColumn_nameContext

+ func (s *Update_stmt_limitedContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Update_stmt_limitedContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Update_stmt_limitedContext) Expr(i int) IExprContext

+ func (s *Update_stmt_limitedContext) GetParser() antlr.Parser

+ func (s *Update_stmt_limitedContext) GetRuleContext() antlr.RuleContext

+ func (s *Update_stmt_limitedContext) K_ABORT() antlr.TerminalNode

+ func (s *Update_stmt_limitedContext) K_BY() antlr.TerminalNode

+ func (s *Update_stmt_limitedContext) K_FAIL() antlr.TerminalNode

+ func (s *Update_stmt_limitedContext) K_IGNORE() antlr.TerminalNode

+ func (s *Update_stmt_limitedContext) K_LIMIT() antlr.TerminalNode

+ func (s *Update_stmt_limitedContext) K_OFFSET() antlr.TerminalNode

+ func (s *Update_stmt_limitedContext) K_OR() antlr.TerminalNode

+ func (s *Update_stmt_limitedContext) K_ORDER() antlr.TerminalNode

+ func (s *Update_stmt_limitedContext) K_REPLACE() antlr.TerminalNode

+ func (s *Update_stmt_limitedContext) K_ROLLBACK() antlr.TerminalNode

+ func (s *Update_stmt_limitedContext) K_SET() antlr.TerminalNode

+ func (s *Update_stmt_limitedContext) K_UPDATE() antlr.TerminalNode

+ func (s *Update_stmt_limitedContext) K_WHERE() antlr.TerminalNode

+ func (s *Update_stmt_limitedContext) Ordering_term(i int) IOrdering_termContext

+ func (s *Update_stmt_limitedContext) Qualified_table_name() IQualified_table_nameContext

+ func (s *Update_stmt_limitedContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ func (s *Update_stmt_limitedContext) With_clause() IWith_clauseContext

+ type Vacuum_stmtContext struct

+ func NewEmptyVacuum_stmtContext() *Vacuum_stmtContext

+ func NewVacuum_stmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Vacuum_stmtContext

+ func (*Vacuum_stmtContext) IsVacuum_stmtContext()

+ func (s *Vacuum_stmtContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Vacuum_stmtContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Vacuum_stmtContext) GetParser() antlr.Parser

+ func (s *Vacuum_stmtContext) GetRuleContext() antlr.RuleContext

+ func (s *Vacuum_stmtContext) K_VACUUM() antlr.TerminalNode

+ func (s *Vacuum_stmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type View_nameContext struct

+ func NewEmptyView_nameContext() *View_nameContext

+ func NewView_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *View_nameContext

+ func (*View_nameContext) IsView_nameContext()

+ func (s *View_nameContext) Any_name() IAny_nameContext

+ func (s *View_nameContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *View_nameContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *View_nameContext) GetParser() antlr.Parser

+ func (s *View_nameContext) GetRuleContext() antlr.RuleContext

+ func (s *View_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type With_clauseContext struct

+ func NewEmptyWith_clauseContext() *With_clauseContext

+ func NewWith_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *With_clauseContext

+ func (*With_clauseContext) IsWith_clauseContext()

+ func (s *With_clauseContext) AllCOMMA() []antlr.TerminalNode

+ func (s *With_clauseContext) AllCommon_table_expression() []ICommon_table_expressionContext

+ func (s *With_clauseContext) COMMA(i int) antlr.TerminalNode

+ func (s *With_clauseContext) Common_table_expression(i int) ICommon_table_expressionContext

+ func (s *With_clauseContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *With_clauseContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *With_clauseContext) GetParser() antlr.Parser

+ func (s *With_clauseContext) GetRuleContext() antlr.RuleContext

+ func (s *With_clauseContext) K_RECURSIVE() antlr.TerminalNode

+ func (s *With_clauseContext) K_WITH() antlr.TerminalNode

+ func (s *With_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

?	: This menu
/	: Search site
f or F	: Jump to
y or Y	: Canonical URL