parser

package

Go to main page

Versions in this module

v1

v1.28.0

Jan 20, 2025

v1.27.0

Aug 5, 2024

v1.26.0

Mar 28, 2024

v1.25.0

Jan 4, 2024

Changes in this version

+ var SQLiteLexerLexerStaticData struct

+ var SQLiteParserParserStaticData struct

+ func InitEmptyAggregate_funcContext(p *Aggregate_funcContext)

+ func InitEmptyAggregate_function_invocationContext(p *Aggregate_function_invocationContext)

+ func InitEmptyAliasContext(p *AliasContext)

+ func InitEmptyAlter_table_stmtContext(p *Alter_table_stmtContext)

+ func InitEmptyAnalyze_stmtContext(p *Analyze_stmtContext)

+ func InitEmptyAny_nameContext(p *Any_nameContext)

+ func InitEmptyAsc_descContext(p *Asc_descContext)

+ func InitEmptyAttach_stmtContext(p *Attach_stmtContext)

+ func InitEmptyBase_window_nameContext(p *Base_window_nameContext)

+ func InitEmptyBegin_stmtContext(p *Begin_stmtContext)

+ func InitEmptyCollation_nameContext(p *Collation_nameContext)

+ func InitEmptyColumn_aliasContext(p *Column_aliasContext)

+ func InitEmptyColumn_constraintContext(p *Column_constraintContext)

+ func InitEmptyColumn_defContext(p *Column_defContext)

+ func InitEmptyColumn_nameContext(p *Column_nameContext)

+ func InitEmptyColumn_name_listContext(p *Column_name_listContext)

+ func InitEmptyCommit_stmtContext(p *Commit_stmtContext)

+ func InitEmptyCommon_table_expressionContext(p *Common_table_expressionContext)

+ func InitEmptyCommon_table_stmtContext(p *Common_table_stmtContext)

+ func InitEmptyCompound_operatorContext(p *Compound_operatorContext)

+ func InitEmptyCompound_select_stmtContext(p *Compound_select_stmtContext)

+ func InitEmptyConflict_clauseContext(p *Conflict_clauseContext)

+ func InitEmptyCreate_index_stmtContext(p *Create_index_stmtContext)

+ func InitEmptyCreate_table_stmtContext(p *Create_table_stmtContext)

+ func InitEmptyCreate_trigger_stmtContext(p *Create_trigger_stmtContext)

+ func InitEmptyCreate_view_stmtContext(p *Create_view_stmtContext)

+ func InitEmptyCreate_virtual_table_stmtContext(p *Create_virtual_table_stmtContext)

+ func InitEmptyCte_table_nameContext(p *Cte_table_nameContext)

+ func InitEmptyDefault_DEFAULT__valueContext(p *Default_DEFAULT__valueContext)

+ func InitEmptyDelete_stmtContext(p *Delete_stmtContext)

+ func InitEmptyDelete_stmt_limitedContext(p *Delete_stmt_limitedContext)

+ func InitEmptyDetach_stmtContext(p *Detach_stmtContext)

+ func InitEmptyDrop_stmtContext(p *Drop_stmtContext)

+ func InitEmptyError_messageContext(p *Error_messageContext)

+ func InitEmptyExprContext(p *ExprContext)

+ func InitEmptyExpr_asc_descContext(p *Expr_asc_descContext)

+ func InitEmptyFactored_select_stmtContext(p *Factored_select_stmtContext)

+ func InitEmptyFilenameContext(p *FilenameContext)

+ func InitEmptyFilter_clauseContext(p *Filter_clauseContext)

+ func InitEmptyForeign_key_clauseContext(p *Foreign_key_clauseContext)

+ func InitEmptyForeign_tableContext(p *Foreign_tableContext)

+ func InitEmptyFrame_clauseContext(p *Frame_clauseContext)

+ func InitEmptyFrame_leftContext(p *Frame_leftContext)

+ func InitEmptyFrame_rightContext(p *Frame_rightContext)

+ func InitEmptyFrame_singleContext(p *Frame_singleContext)

+ func InitEmptyFrame_specContext(p *Frame_specContext)

+ func InitEmptyFunction_nameContext(p *Function_nameContext)

+ func InitEmptyIndex_nameContext(p *Index_nameContext)

+ func InitEmptyIndexed_columnContext(p *Indexed_columnContext)

+ func InitEmptyInitial_selectContext(p *Initial_selectContext)

+ func InitEmptyInsert_stmtContext(p *Insert_stmtContext)

+ func InitEmptyJoin_clauseContext(p *Join_clauseContext)

+ func InitEmptyJoin_constraintContext(p *Join_constraintContext)

+ func InitEmptyJoin_operatorContext(p *Join_operatorContext)

+ func InitEmptyKeywordContext(p *KeywordContext)

+ func InitEmptyLimit_stmtContext(p *Limit_stmtContext)

+ func InitEmptyLiteral_valueContext(p *Literal_valueContext)

+ func InitEmptyModule_argumentContext(p *Module_argumentContext)

+ func InitEmptyModule_nameContext(p *Module_nameContext)

+ func InitEmptyNameContext(p *NameContext)

+ func InitEmptyNew_table_nameContext(p *New_table_nameContext)

+ func InitEmptyOf_OF_fsetContext(p *Of_OF_fsetContext)

+ func InitEmptyOrder_by_exprContext(p *Order_by_exprContext)

+ func InitEmptyOrder_by_expr_asc_descContext(p *Order_by_expr_asc_descContext)

+ func InitEmptyOrder_by_stmtContext(p *Order_by_stmtContext)

+ func InitEmptyOrdering_termContext(p *Ordering_termContext)

+ func InitEmptyOver_clauseContext(p *Over_clauseContext)

+ func InitEmptyParseContext(p *ParseContext)

+ func InitEmptyPartition_byContext(p *Partition_byContext)

+ func InitEmptyPragma_nameContext(p *Pragma_nameContext)

+ func InitEmptyPragma_stmtContext(p *Pragma_stmtContext)

+ func InitEmptyPragma_valueContext(p *Pragma_valueContext)

+ func InitEmptyQualified_function_nameContext(p *Qualified_function_nameContext)

+ func InitEmptyQualified_table_nameContext(p *Qualified_table_nameContext)

+ func InitEmptyRaise_functionContext(p *Raise_functionContext)

+ func InitEmptyRecursive__selectContext(p *Recursive__selectContext)

+ func InitEmptyRecursive_cteContext(p *Recursive_cteContext)

+ func InitEmptyReindex_stmtContext(p *Reindex_stmtContext)

+ func InitEmptyRelease_stmtContext(p *Release_stmtContext)

+ func InitEmptyResult_columnContext(p *Result_columnContext)

+ func InitEmptyReturning_clauseContext(p *Returning_clauseContext)

+ func InitEmptyRollback_stmtContext(p *Rollback_stmtContext)

+ func InitEmptySavepoint_nameContext(p *Savepoint_nameContext)

+ func InitEmptySavepoint_stmtContext(p *Savepoint_stmtContext)

+ func InitEmptySchema_nameContext(p *Schema_nameContext)

+ func InitEmptySelect_coreContext(p *Select_coreContext)

+ func InitEmptySelect_stmtContext(p *Select_stmtContext)

+ func InitEmptySigned_numberContext(p *Signed_numberContext)

+ func InitEmptySimple_funcContext(p *Simple_funcContext)

+ func InitEmptySimple_function_invocationContext(p *Simple_function_invocationContext)

+ func InitEmptySimple_select_stmtContext(p *Simple_select_stmtContext)

+ func InitEmptySql_stmtContext(p *Sql_stmtContext)

+ func InitEmptySql_stmt_listContext(p *Sql_stmt_listContext)

+ func InitEmptyTable_aliasContext(p *Table_aliasContext)

+ func InitEmptyTable_alias_fallbackContext(p *Table_alias_fallbackContext)

+ func InitEmptyTable_constraintContext(p *Table_constraintContext)

+ func InitEmptyTable_function_nameContext(p *Table_function_nameContext)

+ func InitEmptyTable_nameContext(p *Table_nameContext)

+ func InitEmptyTable_optionContext(p *Table_optionContext)

+ func InitEmptyTable_or_index_nameContext(p *Table_or_index_nameContext)

+ func InitEmptyTable_or_subqueryContext(p *Table_or_subqueryContext)

+ func InitEmptyTransaction_nameContext(p *Transaction_nameContext)

+ func InitEmptyTrigger_nameContext(p *Trigger_nameContext)

+ func InitEmptyType_nameContext(p *Type_nameContext)

+ func InitEmptyUnary_operatorContext(p *Unary_operatorContext)

+ func InitEmptyUpdate_stmtContext(p *Update_stmtContext)

+ func InitEmptyUpdate_stmt_limitedContext(p *Update_stmt_limitedContext)

+ func InitEmptyUpsert_clauseContext(p *Upsert_clauseContext)

+ func InitEmptyVacuum_stmtContext(p *Vacuum_stmtContext)

+ func InitEmptyView_nameContext(p *View_nameContext)

+ func InitEmptyWindow_defnContext(p *Window_defnContext)

+ func InitEmptyWindow_functionContext(p *Window_functionContext)

+ func InitEmptyWindow_function_invocationContext(p *Window_function_invocationContext)

+ func InitEmptyWindow_nameContext(p *Window_nameContext)

+ func InitEmptyWith_clauseContext(p *With_clauseContext)

type ExprContext

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

v1.24.0

Nov 22, 2023

Changes in this version

+ const SQLiteLexerPTR

+ const SQLiteLexerPTR2

+ const SQLiteParserPTR

+ const SQLiteParserPTR2

type BaseSQLiteParserListener

+ func (s *BaseSQLiteParserListener) EnterExpr_bool(ctx *Expr_boolContext)

+ func (s *BaseSQLiteParserListener) ExitExpr_bool(ctx *Expr_boolContext)

type Expr_binaryContext

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

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

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

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

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

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

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

+ type Expr_boolContext struct

+ func NewExpr_boolContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *Expr_boolContext

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

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

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

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

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

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

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

type SQLiteParserListener

+ EnterExpr_bool func(c *Expr_boolContext)

+ ExitExpr_bool func(c *Expr_boolContext)

v1.23.0

Oct 24, 2023

v1.22.0

Sep 26, 2023

v1.21.0

Sep 6, 2023

v1.20.0

Jul 31, 2023

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 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 SQLiteLexerNAMED_BIND_PARAMETER

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

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

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

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

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

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

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

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

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

+ const SQLiteParserRULE_table_constraint

+ const SQLiteParserRULE_table_function_name

+ const SQLiteParserRULE_table_name

+ const SQLiteParserRULE_table_option

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

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

+ func SQLiteLexerInit()

+ func SQLiteParserInit()

+ 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_function_name(ctx *Qualified_function_nameContext)

+ 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) EnterReturning_clause(ctx *Returning_clauseContext)

+ 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_alias_fallback(ctx *Table_alias_fallbackContext)

+ 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_option(ctx *Table_optionContext)

+ 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_function_name(ctx *Qualified_function_nameContext)

+ 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) ExitReturning_clause(ctx *Returning_clauseContext)

+ 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_alias_fallback(ctx *Table_alias_fallbackContext)

+ 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_option(ctx *Table_optionContext)

+ 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) AllTable_option() []ITable_optionContext

+ 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) GetRuleContext() antlr.RuleContext

+ 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) 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) Table_option(i int) ITable_optionContext

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

+ type Create_trigger_stmtContext struct

+ func NewCreate_trigger_stmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_trigger_stmtContext

+ func NewEmptyCreate_trigger_stmtContext() *Create_trigger_stmtContext

+ func (*Create_trigger_stmtContext) IsCreate_trigger_stmtContext()

+ func (s *Create_trigger_stmtContext) 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) Returning_clause() IReturning_clauseContext

+ 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) Returning_clause() IReturning_clauseContext

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

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

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

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

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

+ 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) GetRuleContext() antlr.RuleContext

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

+ func (s *Expr_functionContext) Over_clause() IOver_clauseContext

+ func (s *Expr_functionContext) Qualified_function_name() IQualified_function_nameContext

+ 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

+ Any_name func() IAny_nameContext

+ GetParser func() antlr.Parser

+ IsAggregate_funcContext func()

+ type IAggregate_function_invocationContext interface

+ Aggregate_func func() IAggregate_funcContext

+ AllCOMMA func() []antlr.TerminalNode

+ AllExpr func() []IExprContext

+ CLOSE_PAR func() antlr.TerminalNode

+ COMMA func(i int) antlr.TerminalNode

+ DISTINCT_ func() antlr.TerminalNode

+ Expr func(i int) IExprContext

+ Filter_clause func() IFilter_clauseContext

+ GetParser func() antlr.Parser

+ IsAggregate_function_invocationContext func()

+ OPEN_PAR func() antlr.TerminalNode

+ STAR func() antlr.TerminalNode

+ type IAliasContext interface

+ Any_name func() IAny_nameContext

+ GetParser func() antlr.Parser

+ IsAliasContext func()

+ type IAlter_table_stmtContext interface

+ ADD_ func() antlr.TerminalNode

+ ALTER_ func() antlr.TerminalNode

+ AllColumn_name func() []IColumn_nameContext

+ COLUMN_ func() antlr.TerminalNode

+ Column_def func() IColumn_defContext

+ Column_name func(i int) IColumn_nameContext

+ DOT func() antlr.TerminalNode

+ DROP_ func() antlr.TerminalNode

+ GetNew_column_name func() IColumn_nameContext

+ GetOld_column_name func() IColumn_nameContext

+ GetParser func() antlr.Parser

+ IsAlter_table_stmtContext func()

+ New_table_name func() INew_table_nameContext

+ RENAME_ func() antlr.TerminalNode

+ Schema_name func() ISchema_nameContext

+ SetNew_column_name func(IColumn_nameContext)

+ SetOld_column_name func(IColumn_nameContext)

+ TABLE_ func() antlr.TerminalNode

+ TO_ func() antlr.TerminalNode

+ Table_name func() ITable_nameContext

+ type IAnalyze_stmtContext interface

+ ANALYZE_ func() antlr.TerminalNode

+ DOT func() antlr.TerminalNode

+ GetParser func() antlr.Parser

+ IsAnalyze_stmtContext func()

+ Schema_name func() ISchema_nameContext

+ Table_or_index_name func() ITable_or_index_nameContext

+ type IAny_nameContext interface

+ Any_name func() IAny_nameContext

+ CLOSE_PAR func() antlr.TerminalNode

+ GetParser func() antlr.Parser

+ IDENTIFIER func() antlr.TerminalNode

+ IsAny_nameContext func()

+ Keyword func() IKeywordContext

+ OPEN_PAR func() antlr.TerminalNode

+ STRING_LITERAL func() antlr.TerminalNode

+ type IAsc_descContext interface

+ ASC_ func() antlr.TerminalNode

+ DESC_ func() antlr.TerminalNode

+ GetParser func() antlr.Parser

+ IsAsc_descContext func()

+ type IAttach_stmtContext interface

+ AS_ func() antlr.TerminalNode

+ ATTACH_ func() antlr.TerminalNode

+ DATABASE_ func() antlr.TerminalNode

+ Expr func() IExprContext

+ GetParser func() antlr.Parser

+ IsAttach_stmtContext func()

+ Schema_name func() ISchema_nameContext

+ type IBase_window_nameContext interface

+ Any_name func() IAny_nameContext

+ GetParser func() antlr.Parser

+ IsBase_window_nameContext func()

+ type IBegin_stmtContext interface

+ BEGIN_ func() antlr.TerminalNode

+ DEFERRED_ func() antlr.TerminalNode

+ EXCLUSIVE_ func() antlr.TerminalNode

+ GetParser func() antlr.Parser

+ IMMEDIATE_ func() antlr.TerminalNode

+ IsBegin_stmtContext func()

+ TRANSACTION_ func() antlr.TerminalNode

+ Transaction_name func() ITransaction_nameContext

+ type ICollation_nameContext interface

+ Any_name func() IAny_nameContext

+ GetParser func() antlr.Parser

+ IsCollation_nameContext func()

+ type IColumn_aliasContext interface

+ GetParser func() antlr.Parser

+ IDENTIFIER func() antlr.TerminalNode

+ IsColumn_aliasContext func()

+ STRING_LITERAL func() antlr.TerminalNode

+ type IColumn_constraintContext interface

+ ALWAYS_ func() antlr.TerminalNode

+ AS_ func() antlr.TerminalNode

+ AUTOINCREMENT_ func() antlr.TerminalNode

+ Asc_desc func() IAsc_descContext

+ CHECK_ func() antlr.TerminalNode

+ CLOSE_PAR func() antlr.TerminalNode

+ COLLATE_ func() antlr.TerminalNode

+ CONSTRAINT_ func() antlr.TerminalNode

+ Collation_name func() ICollation_nameContext

+ Conflict_clause func() IConflict_clauseContext

+ DEFAULT_ func() antlr.TerminalNode

+ Expr func() IExprContext

+ Foreign_key_clause func() IForeign_key_clauseContext

+ GENERATED_ func() antlr.TerminalNode

+ GetParser func() antlr.Parser

+ IsColumn_constraintContext func()

+ KEY_ func() antlr.TerminalNode

+ Literal_value func() ILiteral_valueContext

+ NOT_ func() antlr.TerminalNode

+ NULL_ func() antlr.TerminalNode

+ Name func() INameContext

+ OPEN_PAR func() antlr.TerminalNode

+ PRIMARY_ func() antlr.TerminalNode

+ STORED_ func() antlr.TerminalNode

+ Signed_number func() ISigned_numberContext

+ UNIQUE_ func() antlr.TerminalNode

+ VIRTUAL_ func() antlr.TerminalNode

+ type IColumn_defContext interface

+ AllColumn_constraint func() []IColumn_constraintContext

+ Column_constraint func(i int) IColumn_constraintContext

+ Column_name func() IColumn_nameContext

+ GetParser func() antlr.Parser

+ IsColumn_defContext func()

+ Type_name func() IType_nameContext

+ type IColumn_nameContext interface

+ Any_name func() IAny_nameContext

+ GetParser func() antlr.Parser

+ IsColumn_nameContext func()

+ type IColumn_name_listContext interface

+ AllCOMMA func() []antlr.TerminalNode

+ AllColumn_name func() []IColumn_nameContext

+ CLOSE_PAR func() antlr.TerminalNode

+ COMMA func(i int) antlr.TerminalNode

+ Column_name func(i int) IColumn_nameContext

+ GetParser func() antlr.Parser

+ IsColumn_name_listContext func()

+ OPEN_PAR func() antlr.TerminalNode

+ type ICommit_stmtContext interface

+ COMMIT_ func() antlr.TerminalNode

+ END_ func() antlr.TerminalNode

+ GetParser func() antlr.Parser

+ IsCommit_stmtContext func()

+ TRANSACTION_ func() antlr.TerminalNode

+ type ICommon_table_expressionContext interface

+ AS_ func() antlr.TerminalNode

+ AllCLOSE_PAR func() []antlr.TerminalNode

+ AllCOMMA func() []antlr.TerminalNode

+ AllColumn_name func() []IColumn_nameContext

+ AllOPEN_PAR func() []antlr.TerminalNode

+ CLOSE_PAR func(i int) antlr.TerminalNode

+ COMMA func(i int) antlr.TerminalNode

+ Column_name func(i int) IColumn_nameContext

+ GetParser func() antlr.Parser

+ IsCommon_table_expressionContext func()

+ OPEN_PAR func(i int) antlr.TerminalNode

+ Select_stmt func() ISelect_stmtContext

+ Table_name func() ITable_nameContext

+ type ICommon_table_stmtContext interface

+ AllCOMMA func() []antlr.TerminalNode

+ AllCommon_table_expression func() []ICommon_table_expressionContext

+ COMMA func(i int) antlr.TerminalNode

+ Common_table_expression func(i int) ICommon_table_expressionContext

+ GetParser func() antlr.Parser

+ IsCommon_table_stmtContext func()

+ RECURSIVE_ func() antlr.TerminalNode

+ WITH_ func() antlr.TerminalNode

+ type ICompound_operatorContext interface

+ ALL_ func() antlr.TerminalNode

+ EXCEPT_ func() antlr.TerminalNode

+ GetParser func() antlr.Parser

+ INTERSECT_ func() antlr.TerminalNode

+ IsCompound_operatorContext func()

+ UNION_ func() antlr.TerminalNode

+ type ICompound_select_stmtContext interface

+ ALL_ func(i int) antlr.TerminalNode

+ AllALL_ func() []antlr.TerminalNode

+ AllEXCEPT_ func() []antlr.TerminalNode

+ AllINTERSECT_ func() []antlr.TerminalNode

+ AllSelect_core func() []ISelect_coreContext

+ AllUNION_ func() []antlr.TerminalNode

+ Common_table_stmt func() ICommon_table_stmtContext

+ EXCEPT_ func(i int) antlr.TerminalNode

+ GetParser func() antlr.Parser

+ INTERSECT_ func(i int) antlr.TerminalNode

+ IsCompound_select_stmtContext func()

+ Limit_stmt func() ILimit_stmtContext

+ Order_by_stmt func() IOrder_by_stmtContext

+ Select_core func(i int) ISelect_coreContext

+ UNION_ func(i int) antlr.TerminalNode

+ type IConflict_clauseContext interface

+ ABORT_ func() antlr.TerminalNode

+ CONFLICT_ func() antlr.TerminalNode

+ FAIL_ func() antlr.TerminalNode

+ GetParser func() antlr.Parser

+ IGNORE_ func() antlr.TerminalNode

+ IsConflict_clauseContext func()

+ ON_ func() antlr.TerminalNode

+ REPLACE_ func() antlr.TerminalNode

+ ROLLBACK_ func() antlr.TerminalNode

+ type ICreate_index_stmtContext interface

+ AllCOMMA func() []antlr.TerminalNode

+ AllIndexed_column func() []IIndexed_columnContext

+ CLOSE_PAR func() antlr.TerminalNode

+ COMMA func(i int) antlr.TerminalNode

+ CREATE_ func() antlr.TerminalNode

+ DOT func() antlr.TerminalNode

+ EXISTS_ func() antlr.TerminalNode

+ Expr func() IExprContext

+ GetParser func() antlr.Parser

+ IF_ func() antlr.TerminalNode

+ INDEX_ func() antlr.TerminalNode

+ Index_name func() IIndex_nameContext

+ Indexed_column func(i int) IIndexed_columnContext

+ IsCreate_index_stmtContext func()

+ NOT_ func() antlr.TerminalNode

+ ON_ func() antlr.TerminalNode

+ OPEN_PAR func() antlr.TerminalNode

+ Schema_name func() ISchema_nameContext

+ Table_name func() ITable_nameContext

+ UNIQUE_ func() antlr.TerminalNode

+ WHERE_ func() antlr.TerminalNode

+ type ICreate_table_stmtContext interface

+ AS_ func() antlr.TerminalNode

+ AllCOMMA func() []antlr.TerminalNode

+ AllColumn_def func() []IColumn_defContext

+ AllTable_constraint func() []ITable_constraintContext

+ AllTable_option func() []ITable_optionContext

+ CLOSE_PAR func() antlr.TerminalNode

+ COMMA func(i int) antlr.TerminalNode

+ CREATE_ func() antlr.TerminalNode

+ Column_def func(i int) IColumn_defContext

+ DOT func() antlr.TerminalNode

+ EXISTS_ func() antlr.TerminalNode

+ GetParser func() antlr.Parser

+ IF_ func() antlr.TerminalNode

+ IsCreate_table_stmtContext func()

+ NOT_ func() antlr.TerminalNode

+ OPEN_PAR func() antlr.TerminalNode

+ Schema_name func() ISchema_nameContext

+ Select_stmt func() ISelect_stmtContext

+ TABLE_ func() antlr.TerminalNode

+ TEMPORARY_ func() antlr.TerminalNode

+ TEMP_ func() antlr.TerminalNode

+ Table_constraint func(i int) ITable_constraintContext

+ Table_name func() ITable_nameContext

+ Table_option func(i int) ITable_optionContext

+ type ICreate_trigger_stmtContext interface

+ AFTER_ func() antlr.TerminalNode

+ AllCOMMA func() []antlr.TerminalNode

+ AllColumn_name func() []IColumn_nameContext

+ AllDelete_stmt func() []IDelete_stmtContext

+ AllInsert_stmt func() []IInsert_stmtContext

+ AllOF_ func() []antlr.TerminalNode

+ AllSCOL func() []antlr.TerminalNode

+ AllSelect_stmt func() []ISelect_stmtContext

+ AllUpdate_stmt func() []IUpdate_stmtContext

+ BEFORE_ func() antlr.TerminalNode

+ BEGIN_ func() antlr.TerminalNode

+ COMMA func(i int) antlr.TerminalNode

+ CREATE_ func() antlr.TerminalNode

+ Column_name func(i int) IColumn_nameContext

+ DELETE_ func() antlr.TerminalNode

+ DOT func() antlr.TerminalNode

+ Delete_stmt func(i int) IDelete_stmtContext

+ EACH_ func() antlr.TerminalNode

+ END_ func() antlr.TerminalNode

+ EXISTS_ func() antlr.TerminalNode

+ Expr func() IExprContext

+ FOR_ func() antlr.TerminalNode

+ GetParser func() antlr.Parser

+ IF_ func() antlr.TerminalNode

+ INSERT_ func() antlr.TerminalNode

+ INSTEAD_ func() antlr.TerminalNode

+ Insert_stmt func(i int) IInsert_stmtContext

+ IsCreate_trigger_stmtContext func()

+ NOT_ func() antlr.TerminalNode

+ OF_ func(i int) antlr.TerminalNode

+ ON_ func() antlr.TerminalNode

+ ROW_ func() antlr.TerminalNode

+ SCOL func(i int) antlr.TerminalNode

+ Schema_name func() ISchema_nameContext

+ Select_stmt func(i int) ISelect_stmtContext

+ TEMPORARY_ func() antlr.TerminalNode

+ TEMP_ func() antlr.TerminalNode

+ TRIGGER_ func() antlr.TerminalNode

+ Table_name func() ITable_nameContext

+ Trigger_name func() ITrigger_nameContext

+ UPDATE_ func() antlr.TerminalNode

+ Update_stmt func(i int) IUpdate_stmtContext

+ WHEN_ func() antlr.TerminalNode

+ type ICreate_view_stmtContext interface

+ AS_ func() antlr.TerminalNode

+ AllCOMMA func() []antlr.TerminalNode

+ AllColumn_name func() []IColumn_nameContext

+ CLOSE_PAR func() antlr.TerminalNode

+ COMMA func(i int) antlr.TerminalNode

+ CREATE_ func() antlr.TerminalNode

+ Column_name func(i int) IColumn_nameContext

+ DOT func() antlr.TerminalNode

+ EXISTS_ func() antlr.TerminalNode

+ GetParser func() antlr.Parser

+ IF_ func() antlr.TerminalNode

+ IsCreate_view_stmtContext func()

+ NOT_ func() antlr.TerminalNode

+ OPEN_PAR func() antlr.TerminalNode

+ Schema_name func() ISchema_nameContext

+ Select_stmt func() ISelect_stmtContext

+ TEMPORARY_ func() antlr.TerminalNode

+ TEMP_ func() antlr.TerminalNode

+ VIEW_ func() antlr.TerminalNode

+ View_name func() IView_nameContext

+ type ICreate_virtual_table_stmtContext interface

+ AllCOMMA func() []antlr.TerminalNode

+ AllModule_argument func() []IModule_argumentContext

+ CLOSE_PAR func() antlr.TerminalNode

+ COMMA func(i int) antlr.TerminalNode

+ CREATE_ func() antlr.TerminalNode

+ DOT func() antlr.TerminalNode

+ EXISTS_ func() antlr.TerminalNode

+ GetParser func() antlr.Parser

+ IF_ func() antlr.TerminalNode

+ IsCreate_virtual_table_stmtContext func()

+ Module_argument func(i int) IModule_argumentContext

+ Module_name func() IModule_nameContext

+ NOT_ func() antlr.TerminalNode

+ OPEN_PAR func() antlr.TerminalNode

+ Schema_name func() ISchema_nameContext

+ TABLE_ func() antlr.TerminalNode

+ Table_name func() ITable_nameContext

+ USING_ func() antlr.TerminalNode

+ VIRTUAL_ func() antlr.TerminalNode

+ type ICte_table_nameContext interface

+ AllCOMMA func() []antlr.TerminalNode

+ AllColumn_name func() []IColumn_nameContext

+ CLOSE_PAR func() antlr.TerminalNode

+ COMMA func(i int) antlr.TerminalNode

+ Column_name func(i int) IColumn_nameContext

+ GetParser func() antlr.Parser

+ IsCte_table_nameContext func()

+ OPEN_PAR func() antlr.TerminalNode

+ Table_name func() ITable_nameContext

+ type IDefault_DEFAULT__valueContext interface

+ COMMA func() antlr.TerminalNode

+ GetParser func() antlr.Parser

+ IsDefault_DEFAULT__valueContext func()

+ Signed_number func() ISigned_numberContext

+ type IDelete_stmtContext interface

+ DELETE_ func() antlr.TerminalNode

+ Expr func() IExprContext

+ FROM_ func() antlr.TerminalNode

+ GetParser func() antlr.Parser

+ IsDelete_stmtContext func()

+ Qualified_table_name func() IQualified_table_nameContext

+ Returning_clause func() IReturning_clauseContext

+ WHERE_ func() antlr.TerminalNode

+ With_clause func() IWith_clauseContext

+ type IDelete_stmt_limitedContext interface

+ DELETE_ func() antlr.TerminalNode

+ Expr func() IExprContext

+ FROM_ func() antlr.TerminalNode

+ GetParser func() antlr.Parser

+ IsDelete_stmt_limitedContext func()

+ Limit_stmt func() ILimit_stmtContext

+ Order_by_stmt func() IOrder_by_stmtContext

+ Qualified_table_name func() IQualified_table_nameContext

+ Returning_clause func() IReturning_clauseContext

+ WHERE_ func() antlr.TerminalNode

+ With_clause func() IWith_clauseContext

+ type IDetach_stmtContext interface

+ DATABASE_ func() antlr.TerminalNode

+ DETACH_ func() antlr.TerminalNode

+ GetParser func() antlr.Parser

+ IsDetach_stmtContext func()

+ Schema_name func() ISchema_nameContext

+ type IDrop_stmtContext interface

+ Any_name func() IAny_nameContext

+ DOT func() antlr.TerminalNode

+ DROP_ func() antlr.TerminalNode

+ EXISTS_ func() antlr.TerminalNode

+ GetObject func() antlr.Token

+ GetParser func() antlr.Parser

+ IF_ func() antlr.TerminalNode

+ INDEX_ func() antlr.TerminalNode

+ IsDrop_stmtContext func()

+ Schema_name func() ISchema_nameContext

+ SetObject func(antlr.Token)

+ TABLE_ func() antlr.TerminalNode

+ TRIGGER_ func() antlr.TerminalNode

+ VIEW_ func() antlr.TerminalNode

+ type IError_messageContext interface

+ GetParser func() antlr.Parser

+ IsError_messageContext func()

+ STRING_LITERAL func() antlr.TerminalNode

+ type IExprContext interface

+ GetParser func() antlr.Parser

+ IsExprContext func()

+ type IExpr_asc_descContext interface

+ AllAsc_desc func() []IAsc_descContext

+ AllCOMMA func() []antlr.TerminalNode

+ AllExpr func() []IExprContext

+ Asc_desc func(i int) IAsc_descContext

+ COMMA func(i int) antlr.TerminalNode

+ Expr func(i int) IExprContext

+ GetParser func() antlr.Parser

+ IsExpr_asc_descContext func()

+ type IFactored_select_stmtContext interface

+ GetParser func() antlr.Parser

+ IsFactored_select_stmtContext func()

+ Select_stmt func() ISelect_stmtContext

+ type IFilenameContext interface

+ Any_name func() IAny_nameContext

+ GetParser func() antlr.Parser

+ IsFilenameContext func()

+ type IFilter_clauseContext interface

+ CLOSE_PAR func() antlr.TerminalNode

+ Expr func() IExprContext

+ FILTER_ func() antlr.TerminalNode

+ GetParser func() antlr.Parser

+ IsFilter_clauseContext func()

+ OPEN_PAR func() antlr.TerminalNode

+ WHERE_ func() antlr.TerminalNode

+ type IForeign_key_clauseContext interface

+ ACTION_ func(i int) antlr.TerminalNode

+ AllACTION_ func() []antlr.TerminalNode

+ AllCASCADE_ func() []antlr.TerminalNode

+ AllCOMMA func() []antlr.TerminalNode

+ AllColumn_name func() []IColumn_nameContext

+ AllDEFAULT_ func() []antlr.TerminalNode

+ AllDELETE_ func() []antlr.TerminalNode

+ AllMATCH_ func() []antlr.TerminalNode

+ AllNO_ func() []antlr.TerminalNode

+ AllNULL_ func() []antlr.TerminalNode

+ AllName func() []INameContext

+ AllON_ func() []antlr.TerminalNode

+ AllRESTRICT_ func() []antlr.TerminalNode

+ AllSET_ func() []antlr.TerminalNode

+ AllUPDATE_ func() []antlr.TerminalNode

+ CASCADE_ func(i int) antlr.TerminalNode

+ CLOSE_PAR func() antlr.TerminalNode

+ COMMA func(i int) antlr.TerminalNode

+ Column_name func(i int) IColumn_nameContext

+ DEFAULT_ func(i int) antlr.TerminalNode

+ DEFERRABLE_ func() antlr.TerminalNode

+ DEFERRED_ func() antlr.TerminalNode

+ DELETE_ func(i int) antlr.TerminalNode

+ Foreign_table func() IForeign_tableContext

+ GetParser func() antlr.Parser

+ IMMEDIATE_ func() antlr.TerminalNode

+ INITIALLY_ func() antlr.TerminalNode

+ IsForeign_key_clauseContext func()

+ MATCH_ func(i int) antlr.TerminalNode

+ NOT_ func() antlr.TerminalNode

+ NO_ func(i int) antlr.TerminalNode

+ NULL_ func(i int) antlr.TerminalNode

+ Name func(i int) INameContext

+ ON_ func(i int) antlr.TerminalNode

+ OPEN_PAR func() antlr.TerminalNode

+ REFERENCES_ func() antlr.TerminalNode

+ RESTRICT_ func(i int) antlr.TerminalNode

+ SET_ func(i int) antlr.TerminalNode

+ UPDATE_ func(i int) antlr.TerminalNode

+ type IForeign_tableContext interface

+ Any_name func() IAny_nameContext

+ GetParser func() antlr.Parser

+ IsForeign_tableContext func()

+ type IFrame_clauseContext interface

+ AND_ func() antlr.TerminalNode

+ BETWEEN_ func() antlr.TerminalNode

+ Frame_left func() IFrame_leftContext

+ Frame_right func() IFrame_rightContext

+ Frame_single func() IFrame_singleContext

+ GROUPS_ func() antlr.TerminalNode

+ GetParser func() antlr.Parser

+ IsFrame_clauseContext func()

+ RANGE_ func() antlr.TerminalNode

+ ROWS_ func() antlr.TerminalNode

+ type IFrame_leftContext interface

+ CURRENT_ func() antlr.TerminalNode

+ Expr func() IExprContext

+ FOLLOWING_ func() antlr.TerminalNode

+ GetParser func() antlr.Parser

+ IsFrame_leftContext func()

+ PRECEDING_ func() antlr.TerminalNode

+ ROW_ func() antlr.TerminalNode

+ UNBOUNDED_ func() antlr.TerminalNode

+ type IFrame_rightContext interface

+ CURRENT_ func() antlr.TerminalNode

+ Expr func() IExprContext

+ FOLLOWING_ func() antlr.TerminalNode

+ GetParser func() antlr.Parser

+ IsFrame_rightContext func()

+ PRECEDING_ func() antlr.TerminalNode

+ ROW_ func() antlr.TerminalNode

+ UNBOUNDED_ func() antlr.TerminalNode

+ type IFrame_singleContext interface

+ CURRENT_ func() antlr.TerminalNode

+ Expr func() IExprContext

+ GetParser func() antlr.Parser

+ IsFrame_singleContext func()

+ PRECEDING_ func() antlr.TerminalNode

+ ROW_ func() antlr.TerminalNode

+ UNBOUNDED_ func() antlr.TerminalNode

+ type IFrame_specContext interface

+ CURRENT_ func() antlr.TerminalNode

+ EXCLUDE_ func() antlr.TerminalNode

+ Frame_clause func() IFrame_clauseContext

+ GROUP_ func() antlr.TerminalNode

+ GetParser func() antlr.Parser

+ IsFrame_specContext func()

+ NO_ func() antlr.TerminalNode

+ OTHERS_ func() antlr.TerminalNode

+ ROW_ func() antlr.TerminalNode

+ TIES_ func() antlr.TerminalNode

+ type IFunction_nameContext interface

+ Any_name func() IAny_nameContext

+ GetParser func() antlr.Parser

+ IsFunction_nameContext func()

+ type IIndex_nameContext interface

+ Any_name func() IAny_nameContext

+ GetParser func() antlr.Parser

+ IsIndex_nameContext func()

+ type IIndexed_columnContext interface

+ Asc_desc func() IAsc_descContext

+ COLLATE_ func() antlr.TerminalNode

+ Collation_name func() ICollation_nameContext

+ Column_name func() IColumn_nameContext

+ Expr func() IExprContext

+ GetParser func() antlr.Parser

+ IsIndexed_columnContext func()

+ type IInitial_selectContext interface

+ GetParser func() antlr.Parser

+ IsInitial_selectContext func()

+ Select_stmt func() ISelect_stmtContext

+ type IInsert_stmtContext interface

+ ABORT_ func() antlr.TerminalNode

+ AS_ func() antlr.TerminalNode

+ AllCLOSE_PAR func() []antlr.TerminalNode

+ AllCOMMA func() []antlr.TerminalNode

+ AllColumn_name func() []IColumn_nameContext

+ AllExpr func() []IExprContext

+ AllOPEN_PAR func() []antlr.TerminalNode

+ CLOSE_PAR func(i int) antlr.TerminalNode

+ COMMA func(i int) antlr.TerminalNode

+ Column_name func(i int) IColumn_nameContext

+ DEFAULT_ func() antlr.TerminalNode

+ DOT func() antlr.TerminalNode

+ Expr func(i int) IExprContext

+ FAIL_ func() antlr.TerminalNode

+ GetParser func() antlr.Parser

+ IGNORE_ func() antlr.TerminalNode

+ INSERT_ func() antlr.TerminalNode

+ INTO_ func() antlr.TerminalNode

+ IsInsert_stmtContext func()

+ OPEN_PAR func(i int) antlr.TerminalNode

+ OR_ func() antlr.TerminalNode

+ REPLACE_ func() antlr.TerminalNode

+ ROLLBACK_ func() antlr.TerminalNode

+ Returning_clause func() IReturning_clauseContext

+ Schema_name func() ISchema_nameContext

+ Select_stmt func() ISelect_stmtContext

+ Table_alias func() ITable_aliasContext

+ Table_name func() ITable_nameContext

+ Upsert_clause func() IUpsert_clauseContext

+ VALUES_ func() antlr.TerminalNode

+ With_clause func() IWith_clauseContext

+ type IJoin_clauseContext interface

+ AllJoin_constraint func() []IJoin_constraintContext

+ AllJoin_operator func() []IJoin_operatorContext

+ AllTable_or_subquery func() []ITable_or_subqueryContext

+ GetParser func() antlr.Parser

+ IsJoin_clauseContext func()

+ Join_constraint func(i int) IJoin_constraintContext

+ Join_operator func(i int) IJoin_operatorContext

+ Table_or_subquery func(i int) ITable_or_subqueryContext

+ type IJoin_constraintContext interface

+ AllCOMMA func() []antlr.TerminalNode

+ AllColumn_name func() []IColumn_nameContext

+ CLOSE_PAR func() antlr.TerminalNode

+ COMMA func(i int) antlr.TerminalNode

+ Column_name func(i int) IColumn_nameContext

+ Expr func() IExprContext

+ GetParser func() antlr.Parser

+ IsJoin_constraintContext func()

+ ON_ func() antlr.TerminalNode

+ OPEN_PAR func() antlr.TerminalNode

+ USING_ func() antlr.TerminalNode

+ type IJoin_operatorContext interface

+ COMMA func() antlr.TerminalNode

+ CROSS_ func() antlr.TerminalNode

+ FULL_ func() antlr.TerminalNode

+ GetParser func() antlr.Parser

+ INNER_ func() antlr.TerminalNode

+ IsJoin_operatorContext func()

+ JOIN_ func() antlr.TerminalNode

+ LEFT_ func() antlr.TerminalNode

+ NATURAL_ func() antlr.TerminalNode

+ OUTER_ func() antlr.TerminalNode

+ RIGHT_ func() antlr.TerminalNode

+ type IKeywordContext interface

+ ABORT_ func() antlr.TerminalNode

+ ACTION_ func() antlr.TerminalNode

+ ADD_ func() antlr.TerminalNode

+ AFTER_ func() antlr.TerminalNode

+ ALL_ func() antlr.TerminalNode

+ ALTER_ func() antlr.TerminalNode

+ ALWAYS_ func() antlr.TerminalNode

+ ANALYZE_ func() antlr.TerminalNode

+ AND_ func() antlr.TerminalNode

+ ASC_ func() antlr.TerminalNode

+ AS_ func() antlr.TerminalNode

+ ATTACH_ func() antlr.TerminalNode

+ AUTOINCREMENT_ func() antlr.TerminalNode

+ BEFORE_ func() antlr.TerminalNode

+ BEGIN_ func() antlr.TerminalNode

+ BETWEEN_ func() antlr.TerminalNode

+ BY_ func() antlr.TerminalNode

+ CASCADE_ func() antlr.TerminalNode

+ CASE_ func() antlr.TerminalNode

+ CAST_ func() antlr.TerminalNode

+ CHECK_ func() antlr.TerminalNode

+ COLLATE_ func() antlr.TerminalNode

+ COLUMN_ func() antlr.TerminalNode

+ COMMIT_ func() antlr.TerminalNode

+ CONFLICT_ func() antlr.TerminalNode

+ CONSTRAINT_ func() antlr.TerminalNode

+ CREATE_ func() antlr.TerminalNode

+ CROSS_ func() antlr.TerminalNode

+ CUME_DIST_ func() antlr.TerminalNode

+ CURRENT_ func() antlr.TerminalNode

+ CURRENT_DATE_ func() antlr.TerminalNode

+ CURRENT_TIMESTAMP_ func() antlr.TerminalNode

+ CURRENT_TIME_ func() antlr.TerminalNode

+ DATABASE_ func() antlr.TerminalNode

+ DEFAULT_ func() antlr.TerminalNode

+ DEFERRABLE_ func() antlr.TerminalNode

+ DEFERRED_ func() antlr.TerminalNode

+ DELETE_ func() antlr.TerminalNode

+ DENSE_RANK_ func() antlr.TerminalNode

+ DESC_ func() antlr.TerminalNode

+ DETACH_ func() antlr.TerminalNode

+ DISTINCT_ func() antlr.TerminalNode

+ DROP_ func() antlr.TerminalNode

+ EACH_ func() antlr.TerminalNode

+ ELSE_ func() antlr.TerminalNode

+ END_ func() antlr.TerminalNode

+ ESCAPE_ func() antlr.TerminalNode

+ EXCEPT_ func() antlr.TerminalNode

+ EXCLUDE_ func() antlr.TerminalNode

+ EXCLUSIVE_ func() antlr.TerminalNode

+ EXISTS_ func() antlr.TerminalNode

+ EXPLAIN_ func() antlr.TerminalNode

+ FAIL_ func() antlr.TerminalNode

+ FALSE_ func() antlr.TerminalNode

+ FILTER_ func() antlr.TerminalNode

+ FIRST_ func() antlr.TerminalNode

+ FIRST_VALUE_ func() antlr.TerminalNode

+ FOLLOWING_ func() antlr.TerminalNode

+ FOREIGN_ func() antlr.TerminalNode

+ FOR_ func() antlr.TerminalNode

+ FROM_ func() antlr.TerminalNode

+ FULL_ func() antlr.TerminalNode

+ GENERATED_ func() antlr.TerminalNode

+ GLOB_ func() antlr.TerminalNode

+ GROUPS_ func() antlr.TerminalNode

+ GROUP_ func() antlr.TerminalNode

+ GetParser func() antlr.Parser

+ HAVING_ func() antlr.TerminalNode

+ IF_ func() antlr.TerminalNode

+ IGNORE_ func() antlr.TerminalNode

+ IMMEDIATE_ func() antlr.TerminalNode

+ INDEXED_ func() antlr.TerminalNode

+ INDEX_ func() antlr.TerminalNode

+ INITIALLY_ func() antlr.TerminalNode

+ INNER_ func() antlr.TerminalNode

+ INSERT_ func() antlr.TerminalNode

+ INSTEAD_ func() antlr.TerminalNode

+ INTERSECT_ func() antlr.TerminalNode

+ INTO_ func() antlr.TerminalNode

+ IN_ func() antlr.TerminalNode

+ ISNULL_ func() antlr.TerminalNode

+ IS_ func() antlr.TerminalNode

+ IsKeywordContext func()

+ JOIN_ func() antlr.TerminalNode

+ KEY_ func() antlr.TerminalNode

+ LAG_ func() antlr.TerminalNode

+ LAST_ func() antlr.TerminalNode

+ LAST_VALUE_ func() antlr.TerminalNode

+ LEAD_ func() antlr.TerminalNode

+ LEFT_ func() antlr.TerminalNode

+ LIKE_ func() antlr.TerminalNode

+ LIMIT_ func() antlr.TerminalNode

+ MATCH_ func() antlr.TerminalNode

+ NATURAL_ func() antlr.TerminalNode

+ NOTNULL_ func() antlr.TerminalNode

+ NOT_ func() antlr.TerminalNode

+ NO_ func() antlr.TerminalNode

+ NTH_VALUE_ func() antlr.TerminalNode

+ NTILE_ func() antlr.TerminalNode

+ NULLS_ func() antlr.TerminalNode

+ NULL_ func() antlr.TerminalNode

+ OFFSET_ func() antlr.TerminalNode

+ OF_ func() antlr.TerminalNode

+ ON_ func() antlr.TerminalNode

+ ORDER_ func() antlr.TerminalNode

+ OR_ func() antlr.TerminalNode

+ OUTER_ func() antlr.TerminalNode

+ OVER_ func() antlr.TerminalNode

+ PARTITION_ func() antlr.TerminalNode

+ PERCENT_RANK_ func() antlr.TerminalNode

+ PLAN_ func() antlr.TerminalNode

+ PRAGMA_ func() antlr.TerminalNode

+ PRECEDING_ func() antlr.TerminalNode

+ PRIMARY_ func() antlr.TerminalNode

+ QUERY_ func() antlr.TerminalNode

+ RAISE_ func() antlr.TerminalNode

+ RANGE_ func() antlr.TerminalNode

+ RANK_ func() antlr.TerminalNode

+ RECURSIVE_ func() antlr.TerminalNode

+ REFERENCES_ func() antlr.TerminalNode

+ REGEXP_ func() antlr.TerminalNode

+ REINDEX_ func() antlr.TerminalNode

+ RELEASE_ func() antlr.TerminalNode

+ RENAME_ func() antlr.TerminalNode

+ REPLACE_ func() antlr.TerminalNode

+ RESTRICT_ func() antlr.TerminalNode

+ RETURNING_ func() antlr.TerminalNode

+ RIGHT_ func() antlr.TerminalNode

+ ROLLBACK_ func() antlr.TerminalNode

+ ROWS_ func() antlr.TerminalNode

+ ROW_ func() antlr.TerminalNode

+ ROW_NUMBER_ func() antlr.TerminalNode

+ SAVEPOINT_ func() antlr.TerminalNode

+ SELECT_ func() antlr.TerminalNode

+ SET_ func() antlr.TerminalNode

+ STORED_ func() antlr.TerminalNode

+ STRICT_ func() antlr.TerminalNode

+ TABLE_ func() antlr.TerminalNode

+ TEMPORARY_ func() antlr.TerminalNode

+ TEMP_ func() antlr.TerminalNode

+ THEN_ func() antlr.TerminalNode

+ TO_ func() antlr.TerminalNode

+ TRANSACTION_ func() antlr.TerminalNode

+ TRIGGER_ func() antlr.TerminalNode

+ TRUE_ func() antlr.TerminalNode

+ UNBOUNDED_ func() antlr.TerminalNode

+ UNION_ func() antlr.TerminalNode

+ UNIQUE_ func() antlr.TerminalNode

+ UPDATE_ func() antlr.TerminalNode

+ USING_ func() antlr.TerminalNode

+ VACUUM_ func() antlr.TerminalNode

+ VALUES_ func() antlr.TerminalNode

+ VIEW_ func() antlr.TerminalNode

+ VIRTUAL_ func() antlr.TerminalNode

+ WHEN_ func() antlr.TerminalNode

+ WHERE_ func() antlr.TerminalNode

+ WINDOW_ func() antlr.TerminalNode

+ WITHOUT_ func() antlr.TerminalNode

+ WITH_ func() antlr.TerminalNode

+ type ILimit_stmtContext interface

+ AllExpr func() []IExprContext

+ COMMA func() antlr.TerminalNode

+ Expr func(i int) IExprContext

+ GetParser func() antlr.Parser

+ IsLimit_stmtContext func()

+ LIMIT_ func() antlr.TerminalNode

+ OFFSET_ func() antlr.TerminalNode

+ type ILiteral_valueContext interface

+ BLOB_LITERAL func() antlr.TerminalNode

+ CURRENT_DATE_ func() antlr.TerminalNode

+ CURRENT_TIMESTAMP_ func() antlr.TerminalNode

+ CURRENT_TIME_ func() antlr.TerminalNode

+ FALSE_ func() antlr.TerminalNode

+ GetParser func() antlr.Parser

+ IsLiteral_valueContext func()

+ NULL_ func() antlr.TerminalNode

+ NUMERIC_LITERAL func() antlr.TerminalNode

+ STRING_LITERAL func() antlr.TerminalNode

+ TRUE_ func() antlr.TerminalNode

+ type IModule_argumentContext interface

+ Column_def func() IColumn_defContext

+ Expr func() IExprContext

+ GetParser func() antlr.Parser

+ IsModule_argumentContext func()

+ type IModule_nameContext interface

+ Any_name func() IAny_nameContext

+ GetParser func() antlr.Parser

+ IsModule_nameContext func()

+ type INameContext interface

+ Any_name func() IAny_nameContext

+ GetParser func() antlr.Parser

+ IsNameContext func()

+ type INew_table_nameContext interface

+ Any_name func() IAny_nameContext

+ GetParser func() antlr.Parser

+ IsNew_table_nameContext func()

+ type IOf_OF_fsetContext interface

+ COMMA func() antlr.TerminalNode

+ GetParser func() antlr.Parser

+ IsOf_OF_fsetContext func()

+ Signed_number func() ISigned_numberContext

+ type IOrder_by_exprContext interface

+ AllExpr func() []IExprContext

+ BY_ func() antlr.TerminalNode

+ Expr func(i int) IExprContext

+ GetParser func() antlr.Parser

+ IsOrder_by_exprContext func()

+ ORDER_ func() antlr.TerminalNode

+ type IOrder_by_expr_asc_descContext interface

+ BY_ func() antlr.TerminalNode

+ GetParser func() antlr.Parser

+ IsOrder_by_expr_asc_descContext func()

+ ORDER_ func() antlr.TerminalNode

+ Order_by_expr_asc_desc func() IOrder_by_expr_asc_descContext

+ type IOrder_by_stmtContext interface

+ AllCOMMA func() []antlr.TerminalNode

+ AllOrdering_term func() []IOrdering_termContext

+ BY_ func() antlr.TerminalNode

+ COMMA func(i int) antlr.TerminalNode

+ GetParser func() antlr.Parser

+ IsOrder_by_stmtContext func()

+ ORDER_ func() antlr.TerminalNode

+ Ordering_term func(i int) IOrdering_termContext

+ type IOrdering_termContext interface

+ Asc_desc func() IAsc_descContext

+ COLLATE_ func() antlr.TerminalNode

+ Collation_name func() ICollation_nameContext

+ Expr func() IExprContext

+ FIRST_ func() antlr.TerminalNode

+ GetParser func() antlr.Parser

+ IsOrdering_termContext func()

+ LAST_ func() antlr.TerminalNode

+ NULLS_ func() antlr.TerminalNode

+ type IOver_clauseContext interface

+ AllBY_ func() []antlr.TerminalNode

+ AllCOMMA func() []antlr.TerminalNode

+ AllExpr func() []IExprContext

+ AllOrdering_term func() []IOrdering_termContext

+ BY_ func(i int) antlr.TerminalNode

+ Base_window_name func() IBase_window_nameContext

+ CLOSE_PAR func() antlr.TerminalNode

+ COMMA func(i int) antlr.TerminalNode

+ Expr func(i int) IExprContext

+ Frame_spec func() IFrame_specContext

+ GetParser func() antlr.Parser

+ IsOver_clauseContext func()

+ OPEN_PAR func() antlr.TerminalNode

+ ORDER_ func() antlr.TerminalNode

+ OVER_ func() antlr.TerminalNode

+ Ordering_term func(i int) IOrdering_termContext

+ PARTITION_ func() antlr.TerminalNode

+ Window_name func() IWindow_nameContext

+ type IParseContext interface

+ AllSql_stmt_list func() []ISql_stmt_listContext

+ EOF func() antlr.TerminalNode

+ GetParser func() antlr.Parser

+ IsParseContext func()

+ Sql_stmt_list func(i int) ISql_stmt_listContext

+ type IPartition_byContext interface

+ AllExpr func() []IExprContext

+ BY_ func() antlr.TerminalNode

+ Expr func(i int) IExprContext

+ GetParser func() antlr.Parser

+ IsPartition_byContext func()

+ PARTITION_ func() antlr.TerminalNode

+ type IPragma_nameContext interface

+ Any_name func() IAny_nameContext

+ GetParser func() antlr.Parser

+ IsPragma_nameContext func()

+ type IPragma_stmtContext interface

+ ASSIGN func() antlr.TerminalNode

+ CLOSE_PAR func() antlr.TerminalNode

+ DOT func() antlr.TerminalNode

+ GetParser func() antlr.Parser

+ IsPragma_stmtContext func()

+ OPEN_PAR func() antlr.TerminalNode

+ PRAGMA_ func() antlr.TerminalNode

+ Pragma_name func() IPragma_nameContext

+ Pragma_value func() IPragma_valueContext

+ Schema_name func() ISchema_nameContext

+ type IPragma_valueContext interface

+ GetParser func() antlr.Parser

+ IsPragma_valueContext func()

+ Name func() INameContext

+ STRING_LITERAL func() antlr.TerminalNode

+ Signed_number func() ISigned_numberContext

+ type IQualified_function_nameContext interface

+ DOT func() antlr.TerminalNode

+ Function_name func() IFunction_nameContext

+ GetParser func() antlr.Parser

+ IsQualified_function_nameContext func()

+ Schema_name func() ISchema_nameContext

+ type IQualified_table_nameContext interface

+ AS_ func() antlr.TerminalNode

+ Alias func() IAliasContext

+ BY_ func() antlr.TerminalNode

+ DOT func() antlr.TerminalNode

+ GetParser func() antlr.Parser

+ INDEXED_ func() antlr.TerminalNode

+ Index_name func() IIndex_nameContext

+ IsQualified_table_nameContext func()

+ NOT_ func() antlr.TerminalNode

+ Schema_name func() ISchema_nameContext

+ Table_name func() ITable_nameContext

+ type IRaise_functionContext interface

+ ABORT_ func() antlr.TerminalNode

+ CLOSE_PAR func() antlr.TerminalNode

+ COMMA func() antlr.TerminalNode

+ Error_message func() IError_messageContext

+ FAIL_ func() antlr.TerminalNode

+ GetParser func() antlr.Parser

+ IGNORE_ func() antlr.TerminalNode

+ IsRaise_functionContext func()

+ OPEN_PAR func() antlr.TerminalNode

+ RAISE_ func() antlr.TerminalNode

+ ROLLBACK_ func() antlr.TerminalNode

+ type IRecursive__selectContext interface

+ GetParser func() antlr.Parser

+ IsRecursive__selectContext func()

+ Select_stmt func() ISelect_stmtContext

+ type IRecursive_cteContext interface

+ ALL_ func() antlr.TerminalNode

+ AS_ func() antlr.TerminalNode

+ CLOSE_PAR func() antlr.TerminalNode

+ Cte_table_name func() ICte_table_nameContext

+ GetParser func() antlr.Parser

+ Initial_select func() IInitial_selectContext

+ IsRecursive_cteContext func()

+ OPEN_PAR func() antlr.TerminalNode

+ Recursive__select func() IRecursive__selectContext

+ UNION_ func() antlr.TerminalNode

+ type IReindex_stmtContext interface

+ Collation_name func() ICollation_nameContext

+ DOT func() antlr.TerminalNode

+ GetParser func() antlr.Parser

+ Index_name func() IIndex_nameContext

+ IsReindex_stmtContext func()

+ REINDEX_ func() antlr.TerminalNode

+ Schema_name func() ISchema_nameContext

+ Table_name func() ITable_nameContext

+ type IRelease_stmtContext interface

+ GetParser func() antlr.Parser

+ IsRelease_stmtContext func()

+ RELEASE_ func() antlr.TerminalNode

+ SAVEPOINT_ func() antlr.TerminalNode

+ Savepoint_name func() ISavepoint_nameContext

+ type IResult_columnContext interface

+ AS_ func() antlr.TerminalNode

+ Column_alias func() IColumn_aliasContext

+ DOT func() antlr.TerminalNode

+ Expr func() IExprContext

+ GetParser func() antlr.Parser

+ IsResult_columnContext func()

+ STAR func() antlr.TerminalNode

+ Table_name func() ITable_nameContext

+ type IReturning_clauseContext interface

+ AS_ func(i int) antlr.TerminalNode

+ AllAS_ func() []antlr.TerminalNode

+ AllCOMMA func() []antlr.TerminalNode

+ AllColumn_alias func() []IColumn_aliasContext

+ AllExpr func() []IExprContext

+ AllSTAR func() []antlr.TerminalNode

+ COMMA func(i int) antlr.TerminalNode

+ Column_alias func(i int) IColumn_aliasContext

+ Expr func(i int) IExprContext

+ GetParser func() antlr.Parser

+ IsReturning_clauseContext func()

+ RETURNING_ func() antlr.TerminalNode

+ STAR func(i int) antlr.TerminalNode

+ type IRollback_stmtContext interface

+ GetParser func() antlr.Parser

+ IsRollback_stmtContext func()

+ ROLLBACK_ func() antlr.TerminalNode

+ SAVEPOINT_ func() antlr.TerminalNode

+ Savepoint_name func() ISavepoint_nameContext

+ TO_ func() antlr.TerminalNode

+ TRANSACTION_ func() antlr.TerminalNode

+ type ISavepoint_nameContext interface

+ Any_name func() IAny_nameContext

+ GetParser func() antlr.Parser

+ IsSavepoint_nameContext func()

+ type ISavepoint_stmtContext interface

+ GetParser func() antlr.Parser

+ IsSavepoint_stmtContext func()

+ SAVEPOINT_ func() antlr.TerminalNode

+ Savepoint_name func() ISavepoint_nameContext

+ type ISchema_nameContext interface

+ Any_name func() IAny_nameContext

+ GetParser func() antlr.Parser

+ IsSchema_nameContext func()

+ type ISelect_coreContext interface

+ ALL_ func() antlr.TerminalNode

+ AS_ func(i int) antlr.TerminalNode

+ AllAS_ func() []antlr.TerminalNode

+ AllCLOSE_PAR func() []antlr.TerminalNode

+ AllCOMMA func() []antlr.TerminalNode

+ AllExpr func() []IExprContext

+ AllOPEN_PAR func() []antlr.TerminalNode

+ AllResult_column func() []IResult_columnContext

+ AllTable_or_subquery func() []ITable_or_subqueryContext

+ AllWindow_defn func() []IWindow_defnContext

+ AllWindow_name func() []IWindow_nameContext

+ BY_ func() antlr.TerminalNode

+ CLOSE_PAR func(i int) antlr.TerminalNode

+ COMMA func(i int) antlr.TerminalNode

+ DISTINCT_ func() antlr.TerminalNode

+ Expr func(i int) IExprContext

+ FROM_ func() antlr.TerminalNode

+ GROUP_ func() antlr.TerminalNode

+ GetParser func() antlr.Parser

+ HAVING_ func() antlr.TerminalNode

+ IsSelect_coreContext func()

+ Join_clause func() IJoin_clauseContext

+ OPEN_PAR func(i int) antlr.TerminalNode

+ Result_column func(i int) IResult_columnContext

+ SELECT_ func() antlr.TerminalNode

+ Table_or_subquery func(i int) ITable_or_subqueryContext

+ VALUES_ func() antlr.TerminalNode

+ WHERE_ func() antlr.TerminalNode

+ WINDOW_ func() antlr.TerminalNode

+ Window_defn func(i int) IWindow_defnContext

+ Window_name func(i int) IWindow_nameContext

+ type ISelect_stmtContext interface

+ AllCompound_operator func() []ICompound_operatorContext

+ AllSelect_core func() []ISelect_coreContext

+ Common_table_stmt func() ICommon_table_stmtContext

+ Compound_operator func(i int) ICompound_operatorContext

+ GetParser func() antlr.Parser

+ IsSelect_stmtContext func()

+ Limit_stmt func() ILimit_stmtContext

+ Order_by_stmt func() IOrder_by_stmtContext

+ Select_core func(i int) ISelect_coreContext

+ type ISigned_numberContext interface

+ GetParser func() antlr.Parser

+ IsSigned_numberContext func()

+ MINUS func() antlr.TerminalNode

+ NUMERIC_LITERAL func() antlr.TerminalNode

+ PLUS func() antlr.TerminalNode

+ type ISimple_funcContext interface

+ Any_name func() IAny_nameContext

+ GetParser func() antlr.Parser

+ IsSimple_funcContext func()

+ type ISimple_function_invocationContext interface

+ AllCOMMA func() []antlr.TerminalNode

+ AllExpr func() []IExprContext

+ CLOSE_PAR func() antlr.TerminalNode

+ COMMA func(i int) antlr.TerminalNode

+ Expr func(i int) IExprContext

+ GetParser func() antlr.Parser

+ IsSimple_function_invocationContext func()

+ OPEN_PAR func() antlr.TerminalNode

+ STAR func() antlr.TerminalNode

+ Simple_func func() ISimple_funcContext

+ type ISimple_select_stmtContext interface

+ Common_table_stmt func() ICommon_table_stmtContext

+ GetParser func() antlr.Parser

+ IsSimple_select_stmtContext func()

+ Limit_stmt func() ILimit_stmtContext

+ Order_by_stmt func() IOrder_by_stmtContext

+ Select_core func() ISelect_coreContext

+ type ISql_stmtContext interface

+ Alter_table_stmt func() IAlter_table_stmtContext

+ Analyze_stmt func() IAnalyze_stmtContext

+ Attach_stmt func() IAttach_stmtContext

+ Begin_stmt func() IBegin_stmtContext

+ Commit_stmt func() ICommit_stmtContext

+ Create_index_stmt func() ICreate_index_stmtContext

+ Create_table_stmt func() ICreate_table_stmtContext

+ Create_trigger_stmt func() ICreate_trigger_stmtContext

+ Create_view_stmt func() ICreate_view_stmtContext

+ Create_virtual_table_stmt func() ICreate_virtual_table_stmtContext

+ Delete_stmt func() IDelete_stmtContext

+ Delete_stmt_limited func() IDelete_stmt_limitedContext

+ Detach_stmt func() IDetach_stmtContext

+ Drop_stmt func() IDrop_stmtContext

+ EXPLAIN_ func() antlr.TerminalNode

+ GetParser func() antlr.Parser

+ Insert_stmt func() IInsert_stmtContext

+ IsSql_stmtContext func()

+ PLAN_ func() antlr.TerminalNode

+ Pragma_stmt func() IPragma_stmtContext

+ QUERY_ func() antlr.TerminalNode

+ Reindex_stmt func() IReindex_stmtContext

+ Release_stmt func() IRelease_stmtContext

+ Rollback_stmt func() IRollback_stmtContext

+ Savepoint_stmt func() ISavepoint_stmtContext

+ Select_stmt func() ISelect_stmtContext

+ Update_stmt func() IUpdate_stmtContext

+ Update_stmt_limited func() IUpdate_stmt_limitedContext

+ Vacuum_stmt func() IVacuum_stmtContext

+ type ISql_stmt_listContext interface

+ AllSCOL func() []antlr.TerminalNode

+ AllSql_stmt func() []ISql_stmtContext

+ GetParser func() antlr.Parser

+ IsSql_stmt_listContext func()

+ SCOL func(i int) antlr.TerminalNode

+ Sql_stmt func(i int) ISql_stmtContext

+ type ITable_aliasContext interface

+ GetParser func() antlr.Parser

+ IDENTIFIER func() antlr.TerminalNode

+ IsTable_aliasContext func()

+ STRING_LITERAL func() antlr.TerminalNode

+ type ITable_alias_fallbackContext interface

+ Any_name func() IAny_nameContext

+ GetParser func() antlr.Parser

+ IsTable_alias_fallbackContext func()

+ type ITable_constraintContext interface

+ AllCOMMA func() []antlr.TerminalNode

+ AllColumn_name func() []IColumn_nameContext

+ AllIndexed_column func() []IIndexed_columnContext

+ CHECK_ func() antlr.TerminalNode

+ CLOSE_PAR func() antlr.TerminalNode

+ COMMA func(i int) antlr.TerminalNode

+ CONSTRAINT_ func() antlr.TerminalNode

+ Column_name func(i int) IColumn_nameContext

+ Conflict_clause func() IConflict_clauseContext

+ Expr func() IExprContext

+ FOREIGN_ func() antlr.TerminalNode

+ Foreign_key_clause func() IForeign_key_clauseContext

+ GetParser func() antlr.Parser

+ Indexed_column func(i int) IIndexed_columnContext

+ IsTable_constraintContext func()

+ KEY_ func() antlr.TerminalNode

+ Name func() INameContext

+ OPEN_PAR func() antlr.TerminalNode

+ PRIMARY_ func() antlr.TerminalNode

+ UNIQUE_ func() antlr.TerminalNode

+ type ITable_function_nameContext interface

+ Any_name func() IAny_nameContext

+ GetParser func() antlr.Parser

+ IsTable_function_nameContext func()

+ type ITable_nameContext interface

+ Any_name func() IAny_nameContext

+ GetParser func() antlr.Parser

+ IsTable_nameContext func()

+ type ITable_optionContext interface

+ GetParser func() antlr.Parser

+ GetRow_ROW_ID func() antlr.Token

+ IDENTIFIER func() antlr.TerminalNode

+ IsTable_optionContext func()

+ STRICT_ func() antlr.TerminalNode

+ SetRow_ROW_ID func(antlr.Token)

+ WITHOUT_ func() antlr.TerminalNode

+ type ITable_or_index_nameContext interface

+ Any_name func() IAny_nameContext

+ GetParser func() antlr.Parser

+ IsTable_or_index_nameContext func()

+ type ITable_or_subqueryContext interface

+ AS_ func() antlr.TerminalNode

+ AllCOMMA func() []antlr.TerminalNode

+ AllExpr func() []IExprContext

+ AllTable_or_subquery func() []ITable_or_subqueryContext

+ BY_ func() antlr.TerminalNode

+ CLOSE_PAR func() antlr.TerminalNode

+ COMMA func(i int) antlr.TerminalNode

+ DOT func() antlr.TerminalNode

+ Expr func(i int) IExprContext

+ GetParser func() antlr.Parser

+ INDEXED_ func() antlr.TerminalNode

+ Index_name func() IIndex_nameContext

+ IsTable_or_subqueryContext func()

+ Join_clause func() IJoin_clauseContext

+ NOT_ func() antlr.TerminalNode

+ OPEN_PAR func() antlr.TerminalNode

+ Schema_name func() ISchema_nameContext

+ Select_stmt func() ISelect_stmtContext

+ Table_alias func() ITable_aliasContext

+ Table_alias_fallback func() ITable_alias_fallbackContext

+ Table_function_name func() ITable_function_nameContext

+ Table_name func() ITable_nameContext

+ Table_or_subquery func(i int) ITable_or_subqueryContext

+ type ITransaction_nameContext interface

+ Any_name func() IAny_nameContext

+ GetParser func() antlr.Parser

+ IsTransaction_nameContext func()

+ type ITrigger_nameContext interface

+ Any_name func() IAny_nameContext

+ GetParser func() antlr.Parser

+ IsTrigger_nameContext func()

+ type IType_nameContext interface

+ AllName func() []INameContext

+ AllSigned_number func() []ISigned_numberContext

+ CLOSE_PAR func() antlr.TerminalNode

+ COMMA func() antlr.TerminalNode

+ GetParser func() antlr.Parser

+ IsType_nameContext func()

+ Name func(i int) INameContext

+ OPEN_PAR func() antlr.TerminalNode

+ Signed_number func(i int) ISigned_numberContext

+ type IUnary_operatorContext interface

+ GetParser func() antlr.Parser

+ IsUnary_operatorContext func()

+ MINUS func() antlr.TerminalNode

+ NOT_ func() antlr.TerminalNode

+ PLUS func() antlr.TerminalNode

+ TILDE func() antlr.TerminalNode

+ type IUpdate_stmtContext interface

+ ABORT_ func() antlr.TerminalNode

+ ASSIGN func(i int) antlr.TerminalNode

+ AllASSIGN func() []antlr.TerminalNode

+ AllCOMMA func() []antlr.TerminalNode

+ AllColumn_name func() []IColumn_nameContext

+ AllColumn_name_list func() []IColumn_name_listContext

+ AllExpr func() []IExprContext

+ COMMA func(i int) antlr.TerminalNode

+ Column_name func(i int) IColumn_nameContext

+ Column_name_list func(i int) IColumn_name_listContext

+ Expr func(i int) IExprContext

+ FAIL_ func() antlr.TerminalNode

+ GetParser func() antlr.Parser

+ IGNORE_ func() antlr.TerminalNode

+ IsUpdate_stmtContext func()

+ OR_ func() antlr.TerminalNode

+ Qualified_table_name func() IQualified_table_nameContext

+ REPLACE_ func() antlr.TerminalNode

+ ROLLBACK_ func() antlr.TerminalNode

+ Returning_clause func() IReturning_clauseContext

+ SET_ func() antlr.TerminalNode

+ UPDATE_ func() antlr.TerminalNode

+ WHERE_ func() antlr.TerminalNode

+ With_clause func() IWith_clauseContext

+ type IUpdate_stmt_limitedContext interface

+ ABORT_ func() antlr.TerminalNode

+ ASSIGN func(i int) antlr.TerminalNode

+ AllASSIGN func() []antlr.TerminalNode

+ AllCOMMA func() []antlr.TerminalNode

+ AllColumn_name func() []IColumn_nameContext

+ AllColumn_name_list func() []IColumn_name_listContext

+ AllExpr func() []IExprContext

+ COMMA func(i int) antlr.TerminalNode

+ Column_name func(i int) IColumn_nameContext

+ Column_name_list func(i int) IColumn_name_listContext

+ Expr func(i int) IExprContext

+ FAIL_ func() antlr.TerminalNode

+ GetParser func() antlr.Parser

+ IGNORE_ func() antlr.TerminalNode

+ IsUpdate_stmt_limitedContext func()

+ Limit_stmt func() ILimit_stmtContext

+ OR_ func() antlr.TerminalNode

+ Order_by_stmt func() IOrder_by_stmtContext

+ Qualified_table_name func() IQualified_table_nameContext

+ REPLACE_ func() antlr.TerminalNode

+ ROLLBACK_ func() antlr.TerminalNode

+ SET_ func() antlr.TerminalNode

+ UPDATE_ func() antlr.TerminalNode

+ WHERE_ func() antlr.TerminalNode

+ With_clause func() IWith_clauseContext

+ type IUpsert_clauseContext interface

+ ASSIGN func(i int) antlr.TerminalNode

+ AllASSIGN func() []antlr.TerminalNode

+ AllCOMMA func() []antlr.TerminalNode

+ AllColumn_name func() []IColumn_nameContext

+ AllColumn_name_list func() []IColumn_name_listContext

+ AllExpr func() []IExprContext

+ AllIndexed_column func() []IIndexed_columnContext

+ AllWHERE_ func() []antlr.TerminalNode

+ CLOSE_PAR func() antlr.TerminalNode

+ COMMA func(i int) antlr.TerminalNode

+ CONFLICT_ func() antlr.TerminalNode

+ Column_name func(i int) IColumn_nameContext

+ Column_name_list func(i int) IColumn_name_listContext

+ DO_ func() antlr.TerminalNode

+ Expr func(i int) IExprContext

+ GetParser func() antlr.Parser

+ Indexed_column func(i int) IIndexed_columnContext

+ IsUpsert_clauseContext func()

+ NOTHING_ func() antlr.TerminalNode

+ ON_ func() antlr.TerminalNode

+ OPEN_PAR func() antlr.TerminalNode

+ SET_ func() antlr.TerminalNode

+ UPDATE_ func() antlr.TerminalNode

+ WHERE_ func(i int) antlr.TerminalNode

+ type IVacuum_stmtContext interface

+ Filename func() IFilenameContext

+ GetParser func() antlr.Parser

+ INTO_ func() antlr.TerminalNode

+ IsVacuum_stmtContext func()

+ Schema_name func() ISchema_nameContext

+ VACUUM_ func() antlr.TerminalNode

+ type IView_nameContext interface

+ Any_name func() IAny_nameContext

+ GetParser func() antlr.Parser

+ IsView_nameContext func()

+ type IWindow_defnContext interface

+ AllBY_ func() []antlr.TerminalNode

+ AllCOMMA func() []antlr.TerminalNode

+ AllExpr func() []IExprContext

+ AllOrdering_term func() []IOrdering_termContext

+ BY_ func(i int) antlr.TerminalNode

+ Base_window_name func() IBase_window_nameContext

+ CLOSE_PAR func() antlr.TerminalNode

+ COMMA func(i int) antlr.TerminalNode

+ Expr func(i int) IExprContext

+ Frame_spec func() IFrame_specContext

+ GetParser func() antlr.Parser

+ IsWindow_defnContext func()

+ OPEN_PAR func() antlr.TerminalNode

+ ORDER_ func() antlr.TerminalNode

+ Ordering_term func(i int) IOrdering_termContext

+ PARTITION_ func() antlr.TerminalNode

+ type IWindow_functionContext interface

+ AllCLOSE_PAR func() []antlr.TerminalNode

+ AllOPEN_PAR func() []antlr.TerminalNode

+ CLOSE_PAR func(i int) antlr.TerminalNode

+ COMMA func() antlr.TerminalNode

+ CUME_DIST_ func() antlr.TerminalNode

+ DENSE_RANK_ func() antlr.TerminalNode

+ Default_DEFAULT__value func() IDefault_DEFAULT__valueContext

+ Expr func() IExprContext

+ FIRST_VALUE_ func() antlr.TerminalNode

+ Frame_clause func() IFrame_clauseContext

+ GetParser func() antlr.Parser

+ IsWindow_functionContext func()

+ LAG_ func() antlr.TerminalNode

+ LAST_VALUE_ func() antlr.TerminalNode

+ LEAD_ func() antlr.TerminalNode

+ NTH_VALUE_ func() antlr.TerminalNode

+ NTILE_ func() antlr.TerminalNode

+ OPEN_PAR func(i int) antlr.TerminalNode

+ OVER_ func() antlr.TerminalNode

+ Of_OF_fset func() IOf_OF_fsetContext

+ Order_by_expr func() IOrder_by_exprContext

+ Order_by_expr_asc_desc func() IOrder_by_expr_asc_descContext

+ PERCENT_RANK_ func() antlr.TerminalNode

+ Partition_by func() IPartition_byContext

+ RANK_ func() antlr.TerminalNode

+ ROW_NUMBER_ func() antlr.TerminalNode

+ Signed_number func() ISigned_numberContext

+ type IWindow_function_invocationContext interface

+ AllCOMMA func() []antlr.TerminalNode

+ AllExpr func() []IExprContext

+ CLOSE_PAR func() antlr.TerminalNode

+ COMMA func(i int) antlr.TerminalNode

+ Expr func(i int) IExprContext

+ Filter_clause func() IFilter_clauseContext

+ GetParser func() antlr.Parser

+ IsWindow_function_invocationContext func()

+ OPEN_PAR func() antlr.TerminalNode

+ OVER_ func() antlr.TerminalNode

+ STAR func() antlr.TerminalNode

+ Window_defn func() IWindow_defnContext

+ Window_function func() IWindow_functionContext

+ Window_name func() IWindow_nameContext

+ type IWindow_nameContext interface

+ Any_name func() IAny_nameContext

+ GetParser func() antlr.Parser

+ IsWindow_nameContext func()

+ type IWith_clauseContext interface

+ AS_ func(i int) antlr.TerminalNode

+ AllAS_ func() []antlr.TerminalNode

+ AllCLOSE_PAR func() []antlr.TerminalNode

+ AllCOMMA func() []antlr.TerminalNode

+ AllCte_table_name func() []ICte_table_nameContext

+ AllOPEN_PAR func() []antlr.TerminalNode

+ AllSelect_stmt func() []ISelect_stmtContext

+ CLOSE_PAR func(i int) antlr.TerminalNode

+ COMMA func(i int) antlr.TerminalNode

+ Cte_table_name func(i int) ICte_table_nameContext

+ GetParser func() antlr.Parser

+ IsWith_clauseContext func()

+ OPEN_PAR func(i int) antlr.TerminalNode

+ RECURSIVE_ func() antlr.TerminalNode

+ Select_stmt func(i int) ISelect_stmtContext

+ WITH_ func() antlr.TerminalNode

+ 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) Returning_clause() IReturning_clauseContext

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

+ 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) RIGHT_() 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) RETURNING_() 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) STRICT_() 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_function_nameContext struct

+ func NewEmptyQualified_function_nameContext() *Qualified_function_nameContext

+ func NewQualified_function_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Qualified_function_nameContext

+ func (*Qualified_function_nameContext) IsQualified_function_nameContext()

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

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

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

+ func (s *Qualified_function_nameContext) Function_name() IFunction_nameContext

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

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

+ func (s *Qualified_function_nameContext) Schema_name() ISchema_nameContext

+ func (s *Qualified_function_nameContext) 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 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 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_function_name() (localctx IQualified_function_nameContext)

+ 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) Returning_clause() (localctx IReturning_clauseContext)

+ 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_alias_fallback() (localctx ITable_alias_fallbackContext)

+ 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_option() (localctx ITable_optionContext)

+ 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_function_name func(c *Qualified_function_nameContext)

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

+ EnterReturning_clause func(c *Returning_clauseContext)

+ 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_alias_fallback func(c *Table_alias_fallbackContext)

+ EnterTable_constraint func(c *Table_constraintContext)

+ EnterTable_function_name func(c *Table_function_nameContext)

+ EnterTable_name func(c *Table_nameContext)

+ EnterTable_option func(c *Table_optionContext)

+ 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_function_name func(c *Qualified_function_nameContext)

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

+ ExitReturning_clause func(c *Returning_clauseContext)

+ 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_alias_fallback func(c *Table_alias_fallbackContext)

+ ExitTable_constraint func(c *Table_constraintContext)

+ ExitTable_function_name func(c *Table_function_nameContext)

+ ExitTable_name func(c *Table_nameContext)

+ ExitTable_option func(c *Table_optionContext)

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

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

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

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

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

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

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

+ type Table_alias_fallbackContext struct

+ func NewEmptyTable_alias_fallbackContext() *Table_alias_fallbackContext

+ func NewTable_alias_fallbackContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Table_alias_fallbackContext

+ func (*Table_alias_fallbackContext) IsTable_alias_fallbackContext()

+ func (s *Table_alias_fallbackContext) Any_name() IAny_nameContext

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

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

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

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

+ func (s *Table_alias_fallbackContext) 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_optionContext struct

+ func NewEmptyTable_optionContext() *Table_optionContext

+ func NewTable_optionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Table_optionContext

+ func (*Table_optionContext) IsTable_optionContext()

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

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

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

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

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

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

+ func (s *Table_optionContext) STRICT_() antlr.TerminalNode

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

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

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

+ 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_alias_fallback() ITable_alias_fallbackContext

+ 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) Returning_clause() IReturning_clauseContext

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

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

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