parser

package

Go to main page

Versions in this module

v1

v1.17.2

Mar 11, 2023

v1.16.0

Nov 17, 2022

v1.15.0

Aug 15, 2022

Changes in this version

+ const SQLiteLexerRETURNING_

+ const SQLiteParserRETURNING_

+ const SQLiteParserRULE_returning_clause

+ func SQLiteLexerInit()

+ func SQLiteParserInit()

type BaseSQLiteParserListener

+ func (s *BaseSQLiteParserListener) EnterReturning_clause(ctx *Returning_clauseContext)

+ func (s *BaseSQLiteParserListener) ExitReturning_clause(ctx *Returning_clauseContext)

type Delete_stmtContext

+ func (s *Delete_stmtContext) Returning_clause() IReturning_clauseContext

type Delete_stmt_limitedContext

+ func (s *Delete_stmt_limitedContext) Returning_clause() IReturning_clauseContext

+ type IReturning_clauseContext interface

+ GetParser func() antlr.Parser

+ IsReturning_clauseContext func()

type Insert_stmtContext

+ func (s *Insert_stmtContext) Returning_clause() IReturning_clauseContext

type KeywordContext

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

+ type Returning_clauseContext struct

+ func NewEmptyReturning_clauseContext() *Returning_clauseContext

+ func NewReturning_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Returning_clauseContext

+ func (*Returning_clauseContext) IsReturning_clauseContext()

+ func (s *Returning_clauseContext) AS_(i int) antlr.TerminalNode

+ func (s *Returning_clauseContext) AllAS_() []antlr.TerminalNode

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

+ func (s *Returning_clauseContext) AllColumn_alias() []IColumn_aliasContext

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

+ func (s *Returning_clauseContext) AllSTAR() []antlr.TerminalNode

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

+ func (s *Returning_clauseContext) Column_alias(i int) IColumn_aliasContext

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

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

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

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

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

+ func (s *Returning_clauseContext) RETURNING_() antlr.TerminalNode

+ func (s *Returning_clauseContext) STAR(i int) antlr.TerminalNode

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

type SQLiteParser

+ func (p *SQLiteParser) Returning_clause() (localctx IReturning_clauseContext)

type SQLiteParserListener

+ EnterReturning_clause func(c *Returning_clauseContext)

+ ExitReturning_clause func(c *Returning_clauseContext)

type Update_stmtContext

+ func (s *Update_stmtContext) Returning_clause() IReturning_clauseContext

type Upsert_clauseContext

+ func (s *Upsert_clauseContext) ASSIGN(i int) antlr.TerminalNode

+ func (s *Upsert_clauseContext) AllASSIGN() []antlr.TerminalNode

v1.14.1

Jun 20, 2022

v1.14.0

Jun 14, 2022

Changes in this version

+ const SQLiteLexerABORT_

+ const SQLiteLexerACTION_

+ const SQLiteLexerADD_

+ const SQLiteLexerAFTER_

+ const SQLiteLexerALL_

+ const SQLiteLexerALTER_

+ const SQLiteLexerALWAYS_

+ const SQLiteLexerAMP

+ const SQLiteLexerANALYZE_

+ const SQLiteLexerAND_

+ const SQLiteLexerASC_

+ const SQLiteLexerASSIGN

+ const SQLiteLexerAS_

+ const SQLiteLexerATTACH_

+ const SQLiteLexerAUTOINCREMENT_

+ const SQLiteLexerBEFORE_

+ const SQLiteLexerBEGIN_

+ const SQLiteLexerBETWEEN_

+ const SQLiteLexerBIND_PARAMETER

+ const SQLiteLexerBLOB_LITERAL

+ const SQLiteLexerBY_

+ const SQLiteLexerCASCADE_

+ const SQLiteLexerCASE_

+ const SQLiteLexerCAST_

+ const SQLiteLexerCHECK_

+ const SQLiteLexerCLOSE_PAR

+ const SQLiteLexerCOLLATE_

+ const SQLiteLexerCOLUMN_

+ const SQLiteLexerCOMMA

+ 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 SQLiteLexerDIV

+ const SQLiteLexerDOT

+ const SQLiteLexerDO_

+ const SQLiteLexerDROP_

+ const SQLiteLexerEACH_

+ const SQLiteLexerELSE_

+ const SQLiteLexerEND_

+ const SQLiteLexerEQ

+ 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 SQLiteLexerGT

+ const SQLiteLexerGT2

+ const SQLiteLexerGT_EQ

+ const SQLiteLexerHAVING_

+ const SQLiteLexerIDENTIFIER

+ 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 SQLiteLexerLT

+ const SQLiteLexerLT2

+ const SQLiteLexerLT_EQ

+ const SQLiteLexerMATCH_

+ const SQLiteLexerMINUS

+ const SQLiteLexerMOD

+ const SQLiteLexerMULTILINE_COMMENT

+ const SQLiteLexerNATURAL_

+ const SQLiteLexerNOTHING_

+ const SQLiteLexerNOTNULL_

+ const SQLiteLexerNOT_

+ const SQLiteLexerNOT_EQ1

+ const SQLiteLexerNOT_EQ2

+ const SQLiteLexerNO_

+ const SQLiteLexerNTH_VALUE_

+ const SQLiteLexerNTILE_

+ const SQLiteLexerNULLS_

+ const SQLiteLexerNULL_

+ const SQLiteLexerNUMERIC_LITERAL

+ const SQLiteLexerOFFSET_

+ const SQLiteLexerOF_

+ const SQLiteLexerON_

+ const SQLiteLexerOPEN_PAR

+ const SQLiteLexerORDER_

+ const SQLiteLexerOR_

+ const SQLiteLexerOTHERS_

+ const SQLiteLexerOUTER_

+ const SQLiteLexerOVER_

+ const SQLiteLexerPARTITION_

+ const SQLiteLexerPERCENT_RANK_

+ const SQLiteLexerPIPE

+ const SQLiteLexerPIPE2

+ const SQLiteLexerPLAN_

+ const SQLiteLexerPLUS

+ 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 SQLiteLexerSCOL

+ const SQLiteLexerSELECT_

+ const SQLiteLexerSET_

+ const SQLiteLexerSINGLE_LINE_COMMENT

+ const SQLiteLexerSPACES

+ const SQLiteLexerSTAR

+ const SQLiteLexerSTORED_

+ const SQLiteLexerSTRING_LITERAL

+ const SQLiteLexerTABLE_

+ const SQLiteLexerTEMPORARY_

+ const SQLiteLexerTEMP_

+ const SQLiteLexerTHEN_

+ const SQLiteLexerTIES_

+ const SQLiteLexerTILDE

+ const SQLiteLexerTO_

+ const SQLiteLexerTRANSACTION_

+ const SQLiteLexerTRIGGER_

+ const SQLiteLexerTRUE_

+ const SQLiteLexerUNBOUNDED_

+ const SQLiteLexerUNEXPECTED_CHAR

+ 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 SQLiteParserAMP

+ const SQLiteParserANALYZE_

+ const SQLiteParserAND_

+ const SQLiteParserASC_

+ const SQLiteParserASSIGN

+ const SQLiteParserAS_

+ const SQLiteParserATTACH_

+ const SQLiteParserAUTOINCREMENT_

+ const SQLiteParserBEFORE_

+ const SQLiteParserBEGIN_

+ const SQLiteParserBETWEEN_

+ const SQLiteParserBIND_PARAMETER

+ const SQLiteParserBLOB_LITERAL

+ const SQLiteParserBY_

+ const SQLiteParserCASCADE_

+ const SQLiteParserCASE_

+ const SQLiteParserCAST_

+ const SQLiteParserCHECK_

+ const SQLiteParserCLOSE_PAR

+ const SQLiteParserCOLLATE_

+ const SQLiteParserCOLUMN_

+ const SQLiteParserCOMMA

+ 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 SQLiteParserDIV

+ const SQLiteParserDOT

+ const SQLiteParserDO_

+ const SQLiteParserDROP_

+ const SQLiteParserEACH_

+ const SQLiteParserELSE_

+ const SQLiteParserEND_

+ const SQLiteParserEOF

+ const SQLiteParserEQ

+ 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 SQLiteParserGT

+ const SQLiteParserGT2

+ const SQLiteParserGT_EQ

+ const SQLiteParserHAVING_

+ const SQLiteParserIDENTIFIER

+ 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 SQLiteParserLT

+ const SQLiteParserLT2

+ const SQLiteParserLT_EQ

+ const SQLiteParserMATCH_

+ const SQLiteParserMINUS

+ const SQLiteParserMOD

+ const SQLiteParserMULTILINE_COMMENT

+ const SQLiteParserNATURAL_

+ const SQLiteParserNOTHING_

+ const SQLiteParserNOTNULL_

+ const SQLiteParserNOT_

+ const SQLiteParserNOT_EQ1

+ const SQLiteParserNOT_EQ2

+ const SQLiteParserNO_

+ const SQLiteParserNTH_VALUE_

+ const SQLiteParserNTILE_

+ const SQLiteParserNULLS_

+ const SQLiteParserNULL_

+ const SQLiteParserNUMERIC_LITERAL

+ const SQLiteParserOFFSET_

+ const SQLiteParserOF_

+ const SQLiteParserON_

+ const SQLiteParserOPEN_PAR

+ const SQLiteParserORDER_

+ const SQLiteParserOR_

+ const SQLiteParserOTHERS_

+ const SQLiteParserOUTER_

+ const SQLiteParserOVER_

+ const SQLiteParserPARTITION_

+ const SQLiteParserPERCENT_RANK_

+ const SQLiteParserPIPE

+ const SQLiteParserPIPE2

+ const SQLiteParserPLAN_

+ const SQLiteParserPLUS

+ 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_alter_table_stmt

+ const SQLiteParserRULE_analyze_stmt

+ const SQLiteParserRULE_any_name

+ const SQLiteParserRULE_asc_desc

+ const SQLiteParserRULE_attach_stmt

+ const SQLiteParserRULE_base_window_name

+ 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_column_name_list

+ const SQLiteParserRULE_commit_stmt

+ const SQLiteParserRULE_common_table_expression

+ const SQLiteParserRULE_common_table_stmt

+ 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_cte_table_name

+ const SQLiteParserRULE_default_DEFAULT__value

+ const SQLiteParserRULE_delete_stmt

+ const SQLiteParserRULE_delete_stmt_limited

+ const SQLiteParserRULE_detach_stmt

+ const SQLiteParserRULE_drop_stmt

+ const SQLiteParserRULE_error_message

+ const SQLiteParserRULE_expr

+ const SQLiteParserRULE_expr_asc_desc

+ const SQLiteParserRULE_factored_select_stmt

+ const SQLiteParserRULE_filename

+ const SQLiteParserRULE_filter_clause

+ const SQLiteParserRULE_foreign_key_clause

+ const SQLiteParserRULE_foreign_table

+ const SQLiteParserRULE_frame_clause

+ const SQLiteParserRULE_frame_left

+ const SQLiteParserRULE_frame_right

+ const SQLiteParserRULE_frame_single

+ const SQLiteParserRULE_frame_spec

+ const SQLiteParserRULE_function_name

+ const SQLiteParserRULE_index_name

+ const SQLiteParserRULE_indexed_column

+ const SQLiteParserRULE_initial_select

+ const SQLiteParserRULE_insert_stmt

+ const SQLiteParserRULE_join_clause

+ const SQLiteParserRULE_join_constraint

+ const SQLiteParserRULE_join_operator

+ const SQLiteParserRULE_keyword

+ const SQLiteParserRULE_limit_stmt

+ const SQLiteParserRULE_literal_value

+ const SQLiteParserRULE_module_argument

+ const SQLiteParserRULE_module_name

+ const SQLiteParserRULE_name

+ const SQLiteParserRULE_new_table_name

+ const SQLiteParserRULE_of_OF_fset

+ const SQLiteParserRULE_order_by_expr

+ const SQLiteParserRULE_order_by_expr_asc_desc

+ const SQLiteParserRULE_order_by_stmt

+ const SQLiteParserRULE_ordering_term

+ const SQLiteParserRULE_over_clause

+ const SQLiteParserRULE_parse

+ const SQLiteParserRULE_partition_by

+ const SQLiteParserRULE_pragma_name

+ const SQLiteParserRULE_pragma_stmt

+ const SQLiteParserRULE_pragma_value

+ const SQLiteParserRULE_qualified_table_name

+ const SQLiteParserRULE_raise_function

+ const SQLiteParserRULE_recursive__select

+ const SQLiteParserRULE_recursive_cte

+ 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_stmt

+ const SQLiteParserRULE_signed_number

+ const SQLiteParserRULE_simple_func

+ const SQLiteParserRULE_simple_function_invocation

+ 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_upsert_clause

+ const SQLiteParserRULE_vacuum_stmt

+ const SQLiteParserRULE_view_name

+ const SQLiteParserRULE_window_defn

+ const SQLiteParserRULE_window_function

+ const SQLiteParserRULE_window_function_invocation

+ const SQLiteParserRULE_window_name

+ const SQLiteParserRULE_with_clause

+ const SQLiteParserSAVEPOINT_

+ const SQLiteParserSCOL

+ const SQLiteParserSELECT_

+ const SQLiteParserSET_

+ const SQLiteParserSINGLE_LINE_COMMENT

+ const SQLiteParserSPACES

+ const SQLiteParserSTAR

+ const SQLiteParserSTORED_

+ const SQLiteParserSTRING_LITERAL

+ const SQLiteParserTABLE_

+ const SQLiteParserTEMPORARY_

+ const SQLiteParserTEMP_

+ const SQLiteParserTHEN_

+ const SQLiteParserTIES_

+ const SQLiteParserTILDE

+ const SQLiteParserTO_

+ const SQLiteParserTRANSACTION_

+ const SQLiteParserTRIGGER_

+ const SQLiteParserTRUE_

+ const SQLiteParserUNBOUNDED_

+ const SQLiteParserUNEXPECTED_CHAR

+ 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 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) 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) Column_def() IColumn_defContext

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

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

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

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

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

+ 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) GetParser() antlr.Parser

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

+ func (s *Alter_table_stmtContext) New_table_name() INew_table_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

+ 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) ANALYZE_() antlr.TerminalNode

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

+ 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) Schema_name() ISchema_nameContext

+ 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 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 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) AS_() antlr.TerminalNode

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

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

+ 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) Schema_name() ISchema_nameContext

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

+ 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 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) BEGIN_() antlr.TerminalNode

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

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

+ 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) IMMEDIATE_() antlr.TerminalNode

+ func (s *Begin_stmtContext) 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) 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) CLOSE_PAR() antlr.TerminalNode

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

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

+ func (s *Column_constraintContext) Collation_name() ICollation_nameContext

+ func (s *Column_constraintContext) Conflict_clause() IConflict_clauseContext

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

+ 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) GENERATED_() antlr.TerminalNode

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

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

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

+ func (s *Column_constraintContext) Literal_value() ILiteral_valueContext

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

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

+ func (s *Column_constraintContext) Name() INameContext

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

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

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

+ func (s *Column_constraintContext) Signed_number() ISigned_numberContext

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

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

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

+ 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 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 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) COMMIT_() antlr.TerminalNode

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

+ 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) TRANSACTION_() antlr.TerminalNode

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

+ 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) AS_() antlr.TerminalNode

+ 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) 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 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 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) ALL_() antlr.TerminalNode

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

+ 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) INTERSECT_() antlr.TerminalNode

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

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

+ 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) 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) AllSelect_core() []ISelect_coreContext

+ 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) EnterRule(listener antlr.ParseTreeListener)

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

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

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

+ 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) Select_core(i int) ISelect_coreContext

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

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

+ 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) ABORT_() antlr.TerminalNode

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

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

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

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

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

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

+ 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

+ 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) CREATE_() antlr.TerminalNode

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

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

+ 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) IF_() antlr.TerminalNode

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

+ 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) NOT_() antlr.TerminalNode

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

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

+ func (s *Create_index_stmtContext) Schema_name() ISchema_nameContext

+ func (s *Create_index_stmtContext) Table_name() ITable_nameContext

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

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

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

+ 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) AS_() antlr.TerminalNode

+ 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) CREATE_() 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) EXISTS_() antlr.TerminalNode

+ 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) GetRow_ROW_ID() antlr.Token

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

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

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

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

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

+ func (s *Create_table_stmtContext) Schema_name() ISchema_nameContext

+ func (s *Create_table_stmtContext) Select_stmt() ISelect_stmtContext

+ 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) 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

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

+ 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) AFTER_() antlr.TerminalNode

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

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

+ func (s *Create_trigger_stmtContext) AllDelete_stmt() []IDelete_stmtContext

+ func (s *Create_trigger_stmtContext) AllInsert_stmt() []IInsert_stmtContext

+ func (s *Create_trigger_stmtContext) AllOF_() []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) BEFORE_() antlr.TerminalNode

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

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

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

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

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

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

+ func (s *Create_trigger_stmtContext) Delete_stmt(i int) IDelete_stmtContext

+ 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) 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) FOR_() antlr.TerminalNode

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

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

+ 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) Insert_stmt(i int) IInsert_stmtContext

+ 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) SCOL(i int) antlr.TerminalNode

+ func (s *Create_trigger_stmtContext) Schema_name() ISchema_nameContext

+ func (s *Create_trigger_stmtContext) Select_stmt(i int) ISelect_stmtContext

+ 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) 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_() antlr.TerminalNode

+ func (s *Create_trigger_stmtContext) Update_stmt(i int) IUpdate_stmtContext

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

+ 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) 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) DOT() antlr.TerminalNode

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

+ 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) 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) Select_stmt() ISelect_stmtContext

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

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

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

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

+ 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) CREATE_() antlr.TerminalNode

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

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

+ 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) IF_() 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) NOT_() antlr.TerminalNode

+ func (s *Create_virtual_table_stmtContext) OPEN_PAR() 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) Table_name() ITable_nameContext

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

+ 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 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) DELETE_() antlr.TerminalNode

+ 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) FROM_() antlr.TerminalNode

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

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

+ 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) WHERE_() antlr.TerminalNode

+ 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) DELETE_() 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() IExprContext

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

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

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

+ 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) Qualified_table_name() IQualified_table_nameContext

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

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

+ 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_() antlr.TerminalNode

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

+ 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) Schema_name() ISchema_nameContext

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

+ 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 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) CopyFrom(ctx *ExprContext)

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

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

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

+ 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 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) EnterRule(listener antlr.ParseTreeListener)

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

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

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

+ func (s *Factored_select_stmtContext) Select_stmt() ISelect_stmtContext

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

+ 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 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) 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) AllCOMMA() []antlr.TerminalNode

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

+ 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) AllName() []INameContext

+ 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) 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) 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) 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) 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) Name(i int) INameContext

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

+ func (s *Foreign_key_clauseContext) OPEN_PAR() 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) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

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

+ 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 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 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 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 interface

+ GetNew_column_name func() IColumn_nameContext

+ GetOld_column_name func() IColumn_nameContext

+ GetParser func() antlr.Parser

+ IsAlter_table_stmtContext func()

+ SetNew_column_name func(IColumn_nameContext)

+ SetOld_column_name func(IColumn_nameContext)

+ type IAnalyze_stmtContext interface

+ GetParser func() antlr.Parser

+ IsAnalyze_stmtContext func()

+ type IAny_nameContext interface

+ GetParser func() antlr.Parser

+ IsAny_nameContext func()

+ type IAsc_descContext interface

+ GetParser func() antlr.Parser

+ IsAsc_descContext func()

+ type IAttach_stmtContext interface

+ GetParser func() antlr.Parser

+ IsAttach_stmtContext func()

+ type IBase_window_nameContext interface

+ GetParser func() antlr.Parser

+ IsBase_window_nameContext 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 IColumn_name_listContext interface

+ GetParser func() antlr.Parser

+ IsColumn_name_listContext 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 ICommon_table_stmtContext interface

+ GetParser func() antlr.Parser

+ IsCommon_table_stmtContext 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

+ GetRow_ROW_ID func() antlr.Token

+ IsCreate_table_stmtContext func()

+ SetRow_ROW_ID func(antlr.Token)

+ 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 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 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_stmtContext interface

+ GetObject func() antlr.Token

+ GetParser func() antlr.Parser

+ IsDrop_stmtContext func()

+ SetObject func(antlr.Token)

+ type IError_messageContext interface

+ GetParser func() antlr.Parser

+ IsError_messageContext func()

+ type IExprContext interface

+ GetParser func() antlr.Parser

+ IsExprContext func()

+ type IExpr_asc_descContext interface

+ GetParser func() antlr.Parser

+ IsExpr_asc_descContext func()

+ type IFactored_select_stmtContext interface

+ GetParser func() antlr.Parser

+ IsFactored_select_stmtContext func()

+ type IFilenameContext interface

+ GetParser func() antlr.Parser

+ IsFilenameContext func()

+ type IFilter_clauseContext interface

+ GetParser func() antlr.Parser

+ IsFilter_clauseContext 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 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 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 IInitial_selectContext interface

+ GetParser func() antlr.Parser

+ IsInitial_selectContext 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 ILimit_stmtContext interface

+ GetParser func() antlr.Parser

+ IsLimit_stmtContext 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_table_nameContext interface

+ GetParser func() antlr.Parser

+ IsNew_table_nameContext 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 IOrdering_termContext interface

+ GetParser func() antlr.Parser

+ IsOrdering_termContext func()

+ type IOver_clauseContext interface

+ GetParser func() antlr.Parser

+ IsOver_clauseContext func()

+ type IParseContext interface

+ GetParser func() antlr.Parser

+ IsParseContext func()

+ type IPartition_byContext interface

+ GetParser func() antlr.Parser

+ IsPartition_byContext 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 IRecursive__selectContext interface

+ GetParser func() antlr.Parser

+ IsRecursive__selectContext func()

+ type IRecursive_cteContext interface

+ GetParser func() antlr.Parser

+ IsRecursive_cteContext 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_stmtContext interface

+ GetParser func() antlr.Parser

+ IsSelect_stmtContext func()

+ type ISigned_numberContext interface

+ GetParser func() antlr.Parser

+ IsSigned_numberContext 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 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 IUpsert_clauseContext interface

+ GetParser func() antlr.Parser

+ IsUpsert_clauseContext func()

+ type IVacuum_stmtContext interface

+ GetParser func() antlr.Parser

+ IsVacuum_stmtContext func()

+ type IView_nameContext interface

+ GetParser func() antlr.Parser

+ IsView_nameContext 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 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) Asc_desc() IAsc_descContext

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

+ 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) Expr() IExprContext

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

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

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

+ 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 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) ABORT_() antlr.TerminalNode

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

+ 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) DEFAULT_() antlr.TerminalNode

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

+ 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) FAIL_() antlr.TerminalNode

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

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

+ 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) OPEN_PAR(i int) 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) Select_stmt() ISelect_stmtContext

+ func (s *Insert_stmtContext) Table_alias() ITable_aliasContext

+ func (s *Insert_stmtContext) Table_name() ITable_nameContext

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

+ func (s *Insert_stmtContext) Upsert_clause() IUpsert_clauseContext

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

+ 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) ON_() antlr.TerminalNode

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

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

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

+ 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) CROSS_() 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) 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

+ 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) 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) EnterRule(listener antlr.ParseTreeListener)

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

+ 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) GetParser() antlr.Parser

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

+ 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) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ 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 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) CURRENT_DATE_() antlr.TerminalNode

+ func (s *Literal_valueContext) CURRENT_TIMESTAMP_() antlr.TerminalNode

+ func (s *Literal_valueContext) CURRENT_TIME_() antlr.TerminalNode

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

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

+ func (s *Literal_valueContext) FALSE_() antlr.TerminalNode

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

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

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

+ func (s *Literal_valueContext) NUMERIC_LITERAL() antlr.TerminalNode

+ func (s *Literal_valueContext) STRING_LITERAL() antlr.TerminalNode

+ func (s *Literal_valueContext) TRUE_() 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_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 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 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) Asc_desc() IAsc_descContext

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

+ 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) FIRST_() antlr.TerminalNode

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

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

+ func (s *Ordering_termContext) LAST_() antlr.TerminalNode

+ func (s *Ordering_termContext) NULLS_() antlr.TerminalNode

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

+ 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 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 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_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) 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) OPEN_PAR() antlr.TerminalNode

+ func (s *Pragma_stmtContext) PRAGMA_() antlr.TerminalNode

+ func (s *Pragma_stmtContext) Pragma_name() IPragma_nameContext

+ func (s *Pragma_stmtContext) Pragma_value() IPragma_valueContext

+ func (s *Pragma_stmtContext) Schema_name() ISchema_nameContext

+ 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) AS_() antlr.TerminalNode

+ func (s *Qualified_table_nameContext) Alias() IAliasContext

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

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

+ 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) INDEXED_() antlr.TerminalNode

+ func (s *Qualified_table_nameContext) Index_name() IIndex_nameContext

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

+ func (s *Qualified_table_nameContext) Schema_name() ISchema_nameContext

+ 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) ABORT_() antlr.TerminalNode

+ 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) FAIL_() antlr.TerminalNode

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

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

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

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

+ func (s *Raise_functionContext) RAISE_() antlr.TerminalNode

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

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

+ 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 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) 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) REINDEX_() antlr.TerminalNode

+ func (s *Reindex_stmtContext) Schema_name() ISchema_nameContext

+ 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) RELEASE_() antlr.TerminalNode

+ func (s *Release_stmtContext) 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) AS_() antlr.TerminalNode

+ 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) 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) ROLLBACK_() antlr.TerminalNode

+ func (s *Rollback_stmtContext) SAVEPOINT_() antlr.TerminalNode

+ func (s *Rollback_stmtContext) Savepoint_name() ISavepoint_nameContext

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

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

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

+ type SQLiteLexer struct

+ func NewSQLiteLexer(input antlr.CharStream) *SQLiteLexer

+ type SQLiteParser struct

+ func NewSQLiteParser(input antlr.TokenStream) *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) 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) Asc_desc() (localctx IAsc_descContext)

+ func (p *SQLiteParser) Attach_stmt() (localctx IAttach_stmtContext)

+ func (p *SQLiteParser) Base_window_name() (localctx IBase_window_nameContext)

+ 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) Column_name_list() (localctx IColumn_name_listContext)

+ func (p *SQLiteParser) Commit_stmt() (localctx ICommit_stmtContext)

+ func (p *SQLiteParser) Common_table_expression() (localctx ICommon_table_expressionContext)

+ func (p *SQLiteParser) Common_table_stmt() (localctx ICommon_table_stmtContext)

+ 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) Cte_table_name() (localctx ICte_table_nameContext)

+ func (p *SQLiteParser) Default_DEFAULT__value() (localctx IDefault_DEFAULT__valueContext)

+ 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_stmt() (localctx IDrop_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) Expr_asc_desc() (localctx IExpr_asc_descContext)

+ func (p *SQLiteParser) Factored_select_stmt() (localctx IFactored_select_stmtContext)

+ func (p *SQLiteParser) Filename() (localctx IFilenameContext)

+ func (p *SQLiteParser) Filter_clause() (localctx IFilter_clauseContext)

+ func (p *SQLiteParser) Foreign_key_clause() (localctx IForeign_key_clauseContext)

+ func (p *SQLiteParser) Foreign_table() (localctx IForeign_tableContext)

+ 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) Function_name() (localctx IFunction_nameContext)

+ func (p *SQLiteParser) Index_name() (localctx IIndex_nameContext)

+ func (p *SQLiteParser) Indexed_column() (localctx IIndexed_columnContext)

+ func (p *SQLiteParser) Initial_select() (localctx IInitial_selectContext)

+ 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) Limit_stmt() (localctx ILimit_stmtContext)

+ 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_table_name() (localctx INew_table_nameContext)

+ 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) Ordering_term() (localctx IOrdering_termContext)

+ func (p *SQLiteParser) Over_clause() (localctx IOver_clauseContext)

+ func (p *SQLiteParser) Parse() (localctx IParseContext)

+ func (p *SQLiteParser) Partition_by() (localctx IPartition_byContext)

+ 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) Recursive__select() (localctx IRecursive__selectContext)

+ func (p *SQLiteParser) Recursive_cte() (localctx IRecursive_cteContext)

+ 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_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_func() (localctx ISimple_funcContext)

+ func (p *SQLiteParser) Simple_function_invocation() (localctx ISimple_function_invocationContext)

+ 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) Upsert_clause() (localctx IUpsert_clauseContext)

+ func (p *SQLiteParser) Vacuum_stmt() (localctx IVacuum_stmtContext)

+ func (p *SQLiteParser) View_name() (localctx IView_nameContext)

+ 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)

+ func (p *SQLiteParser) With_clause() (localctx IWith_clauseContext)

+ 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_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) 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) ALL_() antlr.TerminalNode

+ func (s *Select_coreContext) AS_(i int) antlr.TerminalNode

+ func (s *Select_coreContext) AllAS_() []antlr.TerminalNode

+ 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) AllWindow_defn() []IWindow_defnContext

+ func (s *Select_coreContext) AllWindow_name() []IWindow_nameContext

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

+ func (s *Select_coreContext) CLOSE_PAR(i int) antlr.TerminalNode

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

+ func (s *Select_coreContext) DISTINCT_() 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) FROM_() antlr.TerminalNode

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

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

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

+ func (s *Select_coreContext) HAVING_() antlr.TerminalNode

+ func (s *Select_coreContext) Join_clause() IJoin_clauseContext

+ func (s *Select_coreContext) OPEN_PAR(i int) antlr.TerminalNode

+ func (s *Select_coreContext) Result_column(i int) IResult_columnContext

+ func (s *Select_coreContext) SELECT_() antlr.TerminalNode

+ func (s *Select_coreContext) Table_or_subquery(i int) ITable_or_subqueryContext

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

+ 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 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) AllCompound_operator() []ICompound_operatorContext

+ func (s *Select_stmtContext) AllSelect_core() []ISelect_coreContext

+ func (s *Select_stmtContext) Common_table_stmt() ICommon_table_stmtContext

+ 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) GetParser() antlr.Parser

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

+ 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

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

+ 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_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 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) Common_table_stmt() ICommon_table_stmtContext

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

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

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

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

+ func (s *Simple_select_stmtContext) Limit_stmt() ILimit_stmtContext

+ func (s *Simple_select_stmtContext) Order_by_stmt() IOrder_by_stmtContext

+ func (s *Simple_select_stmtContext) Select_core() ISelect_coreContext

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

+ 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) 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_stmt() IDrop_stmtContext

+ func (s *Sql_stmtContext) EXPLAIN_() antlr.TerminalNode

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

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

+ 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) PLAN_() antlr.TerminalNode

+ func (s *Sql_stmtContext) Pragma_stmt() IPragma_stmtContext

+ func (s *Sql_stmtContext) QUERY_() antlr.TerminalNode

+ 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) 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) Any_name() IAny_nameContext

+ 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) 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) CHECK_() antlr.TerminalNode

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

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

+ func (s *Table_constraintContext) CONSTRAINT_() 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_() antlr.TerminalNode

+ 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) KEY_() antlr.TerminalNode

+ func (s *Table_constraintContext) Name() INameContext

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

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

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

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

+ 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) AS_() antlr.TerminalNode

+ 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) BY_() antlr.TerminalNode

+ 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) INDEXED_() antlr.TerminalNode

+ func (s *Table_or_subqueryContext) Index_name() IIndex_nameContext

+ func (s *Table_or_subqueryContext) Join_clause() IJoin_clauseContext

+ func (s *Table_or_subqueryContext) 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) MINUS() antlr.TerminalNode

+ func (s *Unary_operatorContext) NOT_() 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) ABORT_() antlr.TerminalNode

+ 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) AllColumn_name_list() []IColumn_name_listContext

+ 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) Column_name_list(i int) IColumn_name_listContext

+ 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) FAIL_() antlr.TerminalNode

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

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

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

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

+ func (s *Update_stmtContext) Qualified_table_name() IQualified_table_nameContext

+ 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) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

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

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

+ 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) ABORT_() antlr.TerminalNode

+ 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) AllColumn_name_list() []IColumn_name_listContext

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

+ 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) Column_name_list(i int) IColumn_name_listContext

+ 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) FAIL_() antlr.TerminalNode

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

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

+ 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) Qualified_table_name() IQualified_table_nameContext

+ 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) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

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

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

+ func (s *Update_stmt_limitedContext) With_clause() IWith_clauseContext

+ 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 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) Filename() IFilenameContext

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

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

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

+ func (s *Vacuum_stmtContext) Schema_name() ISchema_nameContext

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

+ func (s *Vacuum_stmtContext) VACUUM_() antlr.TerminalNode

+ 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 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 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) AS_(i int) antlr.TerminalNode

+ func (s *With_clauseContext) AllAS_() []antlr.TerminalNode

+ func (s *With_clauseContext) AllCLOSE_PAR() []antlr.TerminalNode

+ func (s *With_clauseContext) AllCOMMA() []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) COMMA(i int) antlr.TerminalNode

+ func (s *With_clauseContext) Cte_table_name(i int) ICte_table_nameContext

+ 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) 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) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

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

?	: This menu
/	: Search site
f or F	: Jump to
y or Y	: Canonical URL