Why Go
- Case Studies
  
  Common problems companies solve with Go
- Use Cases
  
  Stories about how and why companies use Go
- Security
  
  How Go can help keep you secure by default
Learn
Docs
- Effective Go
  
  Tips for writing clear, performant, and idiomatic Go code
- Go User Manual
  
  A complete introduction to building software with Go
- Standard library
  
  Reference documentation for Go's standard library
- Release Notes
  
  Learn what's new in each Go release
Packages
Community
- Recorded Talks
  
  Videos from prior events
- Meetups
  
  Meet other local Go developers
- Conferences
  
  Learn and network with Go developers from around the world
- Go blog
  
  The Go project's official blog.
- Go project
  
  Get help and stay informed from Go
- Get connected

parser

package

Go to main page

Versions in this module

v0

v0.2.5

Feb 21, 2022

v0.2.4

Feb 21, 2022

v0.2.3

Feb 21, 2022

v0.2.2

Feb 21, 2022

v0.2.1

Feb 18, 2022

v0.2.0

Feb 17, 2022

Changes in this version

+ const SQLiteLexerABORT_

+ const SQLiteLexerACTION_

+ const SQLiteLexerADD_

+ const SQLiteLexerAFTER_

+ const SQLiteLexerALL_

+ const SQLiteLexerALTER_

+ const SQLiteLexerALWAYS_

+ const SQLiteLexerAMP

+ const SQLiteLexerANALYZE_

+ const SQLiteLexerAND_

+ const SQLiteLexerASC_

+ const SQLiteLexerASSIGN

+ const SQLiteLexerAS_

+ const SQLiteLexerATTACH_

+ const SQLiteLexerAUTOINCREMENT_

+ const SQLiteLexerBEFORE_

+ const SQLiteLexerBEGIN_

+ const SQLiteLexerBETWEEN_

+ const SQLiteLexerBIND_PARAMETER

+ const SQLiteLexerBLOB_LITERAL

+ const SQLiteLexerBY_

+ const SQLiteLexerCASCADE_

+ const SQLiteLexerCASE_

+ const SQLiteLexerCAST_

+ const SQLiteLexerCHECK_

+ const SQLiteLexerCLOSE_PAR

+ const SQLiteLexerCOLLATE_

+ const SQLiteLexerCOLUMN_

+ const SQLiteLexerCOMMA

+ const SQLiteLexerCOMMIT_

+ const SQLiteLexerCONFLICT_

+ const SQLiteLexerCONSTRAINT_

+ const SQLiteLexerCREATE_

+ const SQLiteLexerCROSS_

+ const SQLiteLexerCUME_DIST_

+ const SQLiteLexerCURRENT_

+ const SQLiteLexerCURRENT_DATE_

+ const SQLiteLexerCURRENT_TIMESTAMP_

+ const SQLiteLexerCURRENT_TIME_

+ const SQLiteLexerDATABASE_

+ const SQLiteLexerDEFAULT_

+ const SQLiteLexerDEFERRABLE_

+ const SQLiteLexerDEFERRED_

+ const SQLiteLexerDELETE_

+ const SQLiteLexerDENSE_RANK_

+ const SQLiteLexerDESC_

+ const SQLiteLexerDETACH_

+ const SQLiteLexerDISTINCT_

+ const SQLiteLexerDIV

+ const SQLiteLexerDOT

+ const SQLiteLexerDO_

+ const SQLiteLexerDROP_

+ const SQLiteLexerEACH_

+ const SQLiteLexerELSE_

+ const SQLiteLexerEND_

+ const SQLiteLexerEQ

+ const SQLiteLexerESCAPE_

+ const SQLiteLexerEXCEPT_

+ const SQLiteLexerEXCLUDE_

+ const SQLiteLexerEXCLUSIVE_

+ const SQLiteLexerEXISTS_

+ const SQLiteLexerEXPLAIN_

+ const SQLiteLexerFAIL_

+ const SQLiteLexerFALSE_

+ const SQLiteLexerFILTER_

+ const SQLiteLexerFIRST_

+ const SQLiteLexerFIRST_VALUE_

+ const SQLiteLexerFOLLOWING_

+ const SQLiteLexerFOREIGN_

+ const SQLiteLexerFOR_

+ const SQLiteLexerFROM_

+ const SQLiteLexerFULL_

+ const SQLiteLexerGENERATED_

+ const SQLiteLexerGLOB_

+ const SQLiteLexerGROUPS_

+ const SQLiteLexerGROUP_

+ const SQLiteLexerGT

+ const SQLiteLexerGT2

+ const SQLiteLexerGT_EQ

+ const SQLiteLexerHAVING_

+ const SQLiteLexerIDENTIFIER

+ const SQLiteLexerIF_

+ const SQLiteLexerIGNORE_

+ const SQLiteLexerIMMEDIATE_

+ const SQLiteLexerINDEXED_

+ const SQLiteLexerINDEX_

+ const SQLiteLexerINITIALLY_

+ const SQLiteLexerINNER_

+ const SQLiteLexerINSERT_

+ const SQLiteLexerINSTEAD_

+ const SQLiteLexerINTERSECT_

+ const SQLiteLexerINTO_

+ const SQLiteLexerIN_

+ const SQLiteLexerISNULL_

+ const SQLiteLexerIS_

+ const SQLiteLexerJOIN_

+ const SQLiteLexerKEY_

+ const SQLiteLexerLAG_

+ const SQLiteLexerLAST_

+ const SQLiteLexerLAST_VALUE_

+ const SQLiteLexerLEAD_

+ const SQLiteLexerLEFT_

+ const SQLiteLexerLIKE_

+ const SQLiteLexerLIMIT_

+ const SQLiteLexerLT

+ const SQLiteLexerLT2

+ const SQLiteLexerLT_EQ

+ const SQLiteLexerMATCH_

+ const SQLiteLexerMINUS

+ const SQLiteLexerMOD

+ const SQLiteLexerMULTILINE_COMMENT

+ const SQLiteLexerNATURAL_

+ const SQLiteLexerNOTHING_

+ const SQLiteLexerNOTNULL_

+ const SQLiteLexerNOT_

+ const SQLiteLexerNOT_EQ1

+ const SQLiteLexerNOT_EQ2

+ const SQLiteLexerNO_

+ const SQLiteLexerNTH_VALUE_

+ const SQLiteLexerNTILE_

+ const SQLiteLexerNULLS_

+ const SQLiteLexerNULL_

+ const SQLiteLexerNUMERIC_LITERAL

+ const SQLiteLexerOFFSET_

+ const SQLiteLexerOF_

+ const SQLiteLexerON_

+ const SQLiteLexerOPEN_PAR

+ const SQLiteLexerORDER_

+ const SQLiteLexerOR_

+ const SQLiteLexerOTHERS_

+ const SQLiteLexerOUTER_

+ const SQLiteLexerOVER_

+ const SQLiteLexerPARTITION_

+ const SQLiteLexerPERCENT_RANK_

+ const SQLiteLexerPIPE

+ const SQLiteLexerPIPE2

+ const SQLiteLexerPLAN_

+ const SQLiteLexerPLUS

+ const SQLiteLexerPRAGMA_

+ const SQLiteLexerPRECEDING_

+ const SQLiteLexerPRIMARY_

+ const SQLiteLexerQUERY_

+ const SQLiteLexerRAISE_

+ const SQLiteLexerRANGE_

+ const SQLiteLexerRANK_

+ const SQLiteLexerRECURSIVE_

+ const SQLiteLexerREFERENCES_

+ const SQLiteLexerREGEXP_

+ const SQLiteLexerREINDEX_

+ const SQLiteLexerRELEASE_

+ const SQLiteLexerRENAME_

+ const SQLiteLexerREPLACE_

+ const SQLiteLexerRESTRICT_

+ const SQLiteLexerRIGHT_

+ const SQLiteLexerROLLBACK_

+ const SQLiteLexerROWS_

+ const SQLiteLexerROW_

+ const SQLiteLexerROW_NUMBER_

+ const SQLiteLexerSAVEPOINT_

+ const SQLiteLexerSCOL

+ const SQLiteLexerSELECT_

+ const SQLiteLexerSET_

+ const SQLiteLexerSINGLE_LINE_COMMENT

+ const SQLiteLexerSPACES

+ const SQLiteLexerSTAR

+ const SQLiteLexerSTORED_

+ const SQLiteLexerSTRING_LITERAL

+ const SQLiteLexerTABLE_

+ const SQLiteLexerTEMPORARY_

+ const SQLiteLexerTEMP_

+ const SQLiteLexerTHEN_

+ const SQLiteLexerTIES_

+ const SQLiteLexerTILDE

+ const SQLiteLexerTO_

+ const SQLiteLexerTRANSACTION_

+ const SQLiteLexerTRIGGER_

+ const SQLiteLexerTRUE_

+ const SQLiteLexerUNBOUNDED_

+ const SQLiteLexerUNEXPECTED_CHAR

+ const SQLiteLexerUNION_

+ const SQLiteLexerUNIQUE_

+ const SQLiteLexerUPDATE_

+ const SQLiteLexerUSING_

+ const SQLiteLexerVACUUM_

+ const SQLiteLexerVALUES_

+ const SQLiteLexerVIEW_

+ const SQLiteLexerVIRTUAL_

+ const SQLiteLexerWHEN_

+ const SQLiteLexerWHERE_

+ const SQLiteLexerWINDOW_

+ const SQLiteLexerWITHOUT_

+ const SQLiteLexerWITH_

+ const SQLiteParserABORT_

+ const SQLiteParserACTION_

+ const SQLiteParserADD_

+ const SQLiteParserAFTER_

+ const SQLiteParserALL_

+ const SQLiteParserALTER_

+ const SQLiteParserALWAYS_

+ const SQLiteParserAMP

+ const SQLiteParserANALYZE_

+ const SQLiteParserAND_

+ const SQLiteParserASC_

+ const SQLiteParserASSIGN

+ const SQLiteParserAS_

+ const SQLiteParserATTACH_

+ const SQLiteParserAUTOINCREMENT_

+ const SQLiteParserBEFORE_

+ const SQLiteParserBEGIN_

+ const SQLiteParserBETWEEN_

+ const SQLiteParserBIND_PARAMETER

+ const SQLiteParserBLOB_LITERAL

+ const SQLiteParserBY_

+ const SQLiteParserCASCADE_

+ const SQLiteParserCASE_

+ const SQLiteParserCAST_

+ const SQLiteParserCHECK_

+ const SQLiteParserCLOSE_PAR

+ const SQLiteParserCOLLATE_

+ const SQLiteParserCOLUMN_

+ const SQLiteParserCOMMA

+ const SQLiteParserCOMMIT_

+ const SQLiteParserCONFLICT_

+ const SQLiteParserCONSTRAINT_

+ const SQLiteParserCREATE_

+ const SQLiteParserCROSS_

+ const SQLiteParserCUME_DIST_

+ const SQLiteParserCURRENT_

+ const SQLiteParserCURRENT_DATE_

+ const SQLiteParserCURRENT_TIMESTAMP_

+ const SQLiteParserCURRENT_TIME_

+ const SQLiteParserDATABASE_

+ const SQLiteParserDEFAULT_

+ const SQLiteParserDEFERRABLE_

+ const SQLiteParserDEFERRED_

+ const SQLiteParserDELETE_

+ const SQLiteParserDENSE_RANK_

+ const SQLiteParserDESC_

+ const SQLiteParserDETACH_

+ const SQLiteParserDISTINCT_

+ const SQLiteParserDIV

+ const SQLiteParserDOT

+ const SQLiteParserDO_

+ const SQLiteParserDROP_

+ const SQLiteParserEACH_

+ const SQLiteParserELSE_

+ const SQLiteParserEND_

+ const SQLiteParserEOF

+ const SQLiteParserEQ

+ const SQLiteParserESCAPE_

+ const SQLiteParserEXCEPT_

+ const SQLiteParserEXCLUDE_

+ const SQLiteParserEXCLUSIVE_

+ const SQLiteParserEXISTS_

+ const SQLiteParserEXPLAIN_

+ const SQLiteParserFAIL_

+ const SQLiteParserFALSE_

+ const SQLiteParserFILTER_

+ const SQLiteParserFIRST_

+ const SQLiteParserFIRST_VALUE_

+ const SQLiteParserFOLLOWING_

+ const SQLiteParserFOREIGN_

+ const SQLiteParserFOR_

+ const SQLiteParserFROM_

+ const SQLiteParserFULL_

+ const SQLiteParserGENERATED_

+ const SQLiteParserGLOB_

+ const SQLiteParserGROUPS_

+ const SQLiteParserGROUP_

+ const SQLiteParserGT

+ const SQLiteParserGT2

+ const SQLiteParserGT_EQ

+ const SQLiteParserHAVING_

+ const SQLiteParserIDENTIFIER

+ const SQLiteParserIF_

+ const SQLiteParserIGNORE_

+ const SQLiteParserIMMEDIATE_

+ const SQLiteParserINDEXED_

+ const SQLiteParserINDEX_

+ const SQLiteParserINITIALLY_

+ const SQLiteParserINNER_

+ const SQLiteParserINSERT_

+ const SQLiteParserINSTEAD_

+ const SQLiteParserINTERSECT_

+ const SQLiteParserINTO_

+ const SQLiteParserIN_

+ const SQLiteParserISNULL_

+ const SQLiteParserIS_

+ const SQLiteParserJOIN_

+ const SQLiteParserKEY_

+ const SQLiteParserLAG_

+ const SQLiteParserLAST_

+ const SQLiteParserLAST_VALUE_

+ const SQLiteParserLEAD_

+ const SQLiteParserLEFT_

+ const SQLiteParserLIKE_

+ const SQLiteParserLIMIT_

+ const SQLiteParserLT

+ const SQLiteParserLT2

+ const SQLiteParserLT_EQ

+ const SQLiteParserMATCH_

+ const SQLiteParserMINUS

+ const SQLiteParserMOD

+ const SQLiteParserMULTILINE_COMMENT

+ const SQLiteParserNATURAL_

+ const SQLiteParserNOTHING_

+ const SQLiteParserNOTNULL_

+ const SQLiteParserNOT_

+ const SQLiteParserNOT_EQ1

+ const SQLiteParserNOT_EQ2

+ const SQLiteParserNO_

+ const SQLiteParserNTH_VALUE_

+ const SQLiteParserNTILE_

+ const SQLiteParserNULLS_

+ const SQLiteParserNULL_

+ const SQLiteParserNUMERIC_LITERAL

+ const SQLiteParserOFFSET_

+ const SQLiteParserOF_

+ const SQLiteParserON_

+ const SQLiteParserOPEN_PAR

+ const SQLiteParserORDER_

+ const SQLiteParserOR_

+ const SQLiteParserOTHERS_

+ const SQLiteParserOUTER_

+ const SQLiteParserOVER_

+ const SQLiteParserPARTITION_

+ const SQLiteParserPERCENT_RANK_

+ const SQLiteParserPIPE

+ const SQLiteParserPIPE2

+ const SQLiteParserPLAN_

+ const SQLiteParserPLUS

+ const SQLiteParserPRAGMA_

+ const SQLiteParserPRECEDING_

+ const SQLiteParserPRIMARY_

+ const SQLiteParserQUERY_

+ const SQLiteParserRAISE_

+ const SQLiteParserRANGE_

+ const SQLiteParserRANK_

+ const SQLiteParserRECURSIVE_

+ const SQLiteParserREFERENCES_

+ const SQLiteParserREGEXP_

+ const SQLiteParserREINDEX_

+ const SQLiteParserRELEASE_

+ const SQLiteParserRENAME_

+ const SQLiteParserREPLACE_

+ const SQLiteParserRESTRICT_

+ const SQLiteParserRIGHT_

+ const SQLiteParserROLLBACK_

+ const SQLiteParserROWS_

+ const SQLiteParserROW_

+ const SQLiteParserROW_NUMBER_

+ const SQLiteParserRULE_aggregate_func

+ const SQLiteParserRULE_aggregate_function_invocation

+ const SQLiteParserRULE_alias

+ const SQLiteParserRULE_alter_table_stmt

+ const SQLiteParserRULE_analyze_stmt

+ const SQLiteParserRULE_any_name

+ const SQLiteParserRULE_asc_desc

+ const SQLiteParserRULE_attach_stmt

+ const SQLiteParserRULE_base_window_name

+ const SQLiteParserRULE_begin_stmt

+ const SQLiteParserRULE_collation_name

+ const SQLiteParserRULE_column_alias

+ const SQLiteParserRULE_column_constraint

+ const SQLiteParserRULE_column_def

+ const SQLiteParserRULE_column_name

+ const SQLiteParserRULE_column_name_list

+ const SQLiteParserRULE_commit_stmt

+ const SQLiteParserRULE_common_table_expression

+ const SQLiteParserRULE_common_table_stmt

+ const SQLiteParserRULE_compound_operator

+ const SQLiteParserRULE_compound_select_stmt

+ const SQLiteParserRULE_conflict_clause

+ const SQLiteParserRULE_create_index_stmt

+ const SQLiteParserRULE_create_table_stmt

+ const SQLiteParserRULE_create_trigger_stmt

+ const SQLiteParserRULE_create_view_stmt

+ const SQLiteParserRULE_create_virtual_table_stmt

+ const SQLiteParserRULE_cte_table_name

+ const SQLiteParserRULE_default_DEFAULT__value

+ const SQLiteParserRULE_delete_stmt

+ const SQLiteParserRULE_delete_stmt_limited

+ const SQLiteParserRULE_detach_stmt

+ const SQLiteParserRULE_drop_stmt

+ const SQLiteParserRULE_error_message

+ const SQLiteParserRULE_expr

+ const SQLiteParserRULE_expr_asc_desc

+ const SQLiteParserRULE_factored_select_stmt

+ const SQLiteParserRULE_filename

+ const SQLiteParserRULE_filter_clause

+ const SQLiteParserRULE_foreign_key_clause

+ const SQLiteParserRULE_foreign_table

+ const SQLiteParserRULE_frame_clause

+ const SQLiteParserRULE_frame_left

+ const SQLiteParserRULE_frame_right

+ const SQLiteParserRULE_frame_single

+ const SQLiteParserRULE_frame_spec

+ const SQLiteParserRULE_function_name

+ const SQLiteParserRULE_index_name

+ const SQLiteParserRULE_indexed_column

+ const SQLiteParserRULE_initial_select

+ const SQLiteParserRULE_insert_stmt

+ const SQLiteParserRULE_join_clause

+ const SQLiteParserRULE_join_constraint

+ const SQLiteParserRULE_join_operator

+ const SQLiteParserRULE_keyword

+ const SQLiteParserRULE_limit_stmt

+ const SQLiteParserRULE_literal_value

+ const SQLiteParserRULE_module_argument

+ const SQLiteParserRULE_module_name

+ const SQLiteParserRULE_name

+ const SQLiteParserRULE_new_table_name

+ const SQLiteParserRULE_of_OF_fset

+ const SQLiteParserRULE_order_by_expr

+ const SQLiteParserRULE_order_by_expr_asc_desc

+ const SQLiteParserRULE_order_by_stmt

+ const SQLiteParserRULE_ordering_term

+ const SQLiteParserRULE_over_clause

+ const SQLiteParserRULE_parse

+ const SQLiteParserRULE_partition_by

+ const SQLiteParserRULE_pragma_name

+ const SQLiteParserRULE_pragma_stmt

+ const SQLiteParserRULE_pragma_value

+ const SQLiteParserRULE_qualified_table_name

+ const SQLiteParserRULE_raise_function

+ const SQLiteParserRULE_recursive__select

+ const SQLiteParserRULE_recursive_cte

+ const SQLiteParserRULE_reindex_stmt

+ const SQLiteParserRULE_release_stmt

+ const SQLiteParserRULE_result_column

+ const SQLiteParserRULE_rollback_stmt

+ const SQLiteParserRULE_savepoint_name

+ const SQLiteParserRULE_savepoint_stmt

+ const SQLiteParserRULE_schema_name

+ const SQLiteParserRULE_select_core

+ const SQLiteParserRULE_select_stmt

+ const SQLiteParserRULE_signed_number

+ const SQLiteParserRULE_simple_func

+ const SQLiteParserRULE_simple_function_invocation

+ const SQLiteParserRULE_simple_select_stmt

+ const SQLiteParserRULE_sql_stmt

+ const SQLiteParserRULE_table_alias

+ const SQLiteParserRULE_table_constraint

+ const SQLiteParserRULE_table_function_name

+ const SQLiteParserRULE_table_name

+ const SQLiteParserRULE_table_or_index_name

+ const SQLiteParserRULE_table_or_subquery

+ const SQLiteParserRULE_transaction_name

+ const SQLiteParserRULE_trigger_name

+ const SQLiteParserRULE_type_name

+ const SQLiteParserRULE_unary_operator

+ const SQLiteParserRULE_update_stmt

+ const SQLiteParserRULE_update_stmt_limited

+ const SQLiteParserRULE_upsert_clause

+ const SQLiteParserRULE_vacuum_stmt

+ const SQLiteParserRULE_view_name

+ const SQLiteParserRULE_window_defn

+ const SQLiteParserRULE_window_function

+ const SQLiteParserRULE_window_function_invocation

+ const SQLiteParserRULE_window_name

+ const SQLiteParserRULE_with_clause

+ const SQLiteParserSAVEPOINT_

+ const SQLiteParserSCOL

+ const SQLiteParserSELECT_

+ const SQLiteParserSET_

+ const SQLiteParserSINGLE_LINE_COMMENT

+ const SQLiteParserSPACES

+ const SQLiteParserSTAR

+ const SQLiteParserSTORED_

+ const SQLiteParserSTRING_LITERAL

+ const SQLiteParserTABLE_

+ const SQLiteParserTEMPORARY_

+ const SQLiteParserTEMP_

+ const SQLiteParserTHEN_

+ const SQLiteParserTIES_

+ const SQLiteParserTILDE

+ const SQLiteParserTO_

+ const SQLiteParserTRANSACTION_

+ const SQLiteParserTRIGGER_

+ const SQLiteParserTRUE_

+ const SQLiteParserUNBOUNDED_

+ const SQLiteParserUNEXPECTED_CHAR

+ const SQLiteParserUNION_

+ const SQLiteParserUNIQUE_

+ const SQLiteParserUPDATE_

+ const SQLiteParserUSING_

+ const SQLiteParserVACUUM_

+ const SQLiteParserVALUES_

+ const SQLiteParserVIEW_

+ const SQLiteParserVIRTUAL_

+ const SQLiteParserWHEN_

+ const SQLiteParserWHERE_

+ const SQLiteParserWINDOW_

+ const SQLiteParserWITHOUT_

+ const SQLiteParserWITH_

+ type Aggregate_funcContext struct

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

+ func NewEmptyAggregate_funcContext() *Aggregate_funcContext

+ func (*Aggregate_funcContext) IsAggregate_funcContext()

+ func (s *Aggregate_funcContext) Any_name() IAny_nameContext

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

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

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

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

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

+ type Aggregate_function_invocationContext struct

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

+ func NewEmptyAggregate_function_invocationContext() *Aggregate_function_invocationContext

+ func (*Aggregate_function_invocationContext) IsAggregate_function_invocationContext()

+ func (s *Aggregate_function_invocationContext) Aggregate_func() IAggregate_funcContext

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

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

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

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

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

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

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

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

+ func (s *Aggregate_function_invocationContext) Filter_clause() IFilter_clauseContext

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

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

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

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

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

+ type AliasContext struct

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

+ func NewEmptyAliasContext() *AliasContext

+ func (*AliasContext) IsAliasContext()

+ func (s *AliasContext) Any_name() IAny_nameContext

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

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

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

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

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

+ type Alter_table_stmtContext struct

+ func NewAlter_table_stmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_table_stmtContext

+ func NewEmptyAlter_table_stmtContext() *Alter_table_stmtContext

+ func (*Alter_table_stmtContext) IsAlter_table_stmtContext()

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

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

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

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

+ func (s *Alter_table_stmtContext) Column_def() IColumn_defContext

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

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

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

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

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

+ func (s *Alter_table_stmtContext) GetNew_column_name() IColumn_nameContext

+ func (s *Alter_table_stmtContext) GetOld_column_name() IColumn_nameContext

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

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

+ func (s *Alter_table_stmtContext) New_table_name() INew_table_nameContext

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

+ func (s *Alter_table_stmtContext) Schema_name() ISchema_nameContext

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

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

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

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

+ func (s *Alter_table_stmtContext) Table_name() ITable_nameContext

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

+ type Analyze_stmtContext struct

+ func NewAnalyze_stmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Analyze_stmtContext

+ func NewEmptyAnalyze_stmtContext() *Analyze_stmtContext

+ func (*Analyze_stmtContext) IsAnalyze_stmtContext()

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

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

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

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

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

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

+ func (s *Analyze_stmtContext) Schema_name() ISchema_nameContext

+ func (s *Analyze_stmtContext) Table_or_index_name() ITable_or_index_nameContext

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

+ type Any_nameContext struct

+ func NewAny_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Any_nameContext

+ func NewEmptyAny_nameContext() *Any_nameContext

+ func (*Any_nameContext) IsAny_nameContext()

+ func (s *Any_nameContext) Any_name() IAny_nameContext

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

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

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

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

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

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

+ func (s *Any_nameContext) Keyword() IKeywordContext

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

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

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

+ type Asc_descContext struct

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

+ func NewEmptyAsc_descContext() *Asc_descContext

+ func (*Asc_descContext) IsAsc_descContext()

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

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

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

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

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

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

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

+ type Attach_stmtContext struct

+ func NewAttach_stmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Attach_stmtContext

+ func NewEmptyAttach_stmtContext() *Attach_stmtContext

+ func (*Attach_stmtContext) IsAttach_stmtContext()

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

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

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

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

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

+ func (s *Attach_stmtContext) Expr() IExprContext

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

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

+ func (s *Attach_stmtContext) Schema_name() ISchema_nameContext

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

+ type BaseSQLiteParserListener struct

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

+ func (s *BaseSQLiteParserListener) EnterExpr(ctx *ExprContext)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

+ func (s *BaseSQLiteParserListener) ExitExpr(ctx *ExprContext)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

+ type Base_window_nameContext struct

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

+ func NewEmptyBase_window_nameContext() *Base_window_nameContext

+ func (*Base_window_nameContext) IsBase_window_nameContext()

+ func (s *Base_window_nameContext) Any_name() IAny_nameContext

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

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

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

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

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

+ type Begin_stmtContext struct

+ func NewBegin_stmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Begin_stmtContext

+ func NewEmptyBegin_stmtContext() *Begin_stmtContext

+ func (*Begin_stmtContext) IsBegin_stmtContext()

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

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

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

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

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

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

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

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

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

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

+ func (s *Begin_stmtContext) Transaction_name() ITransaction_nameContext

+ type Collation_nameContext struct

+ func NewCollation_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Collation_nameContext

+ func NewEmptyCollation_nameContext() *Collation_nameContext

+ func (*Collation_nameContext) IsCollation_nameContext()

+ func (s *Collation_nameContext) Any_name() IAny_nameContext

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

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

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

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

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

+ type Column_aliasContext struct

+ func NewColumn_aliasContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Column_aliasContext

+ func NewEmptyColumn_aliasContext() *Column_aliasContext

+ func (*Column_aliasContext) IsColumn_aliasContext()

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

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

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

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

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

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

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

+ type Column_constraintContext struct

+ func NewColumn_constraintContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Column_constraintContext

+ func NewEmptyColumn_constraintContext() *Column_constraintContext

+ func (*Column_constraintContext) IsColumn_constraintContext()

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

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

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

+ func (s *Column_constraintContext) Asc_desc() IAsc_descContext

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

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

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

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

+ func (s *Column_constraintContext) Collation_name() ICollation_nameContext

+ func (s *Column_constraintContext) Conflict_clause() IConflict_clauseContext

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

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

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

+ func (s *Column_constraintContext) Expr() IExprContext

+ func (s *Column_constraintContext) Foreign_key_clause() IForeign_key_clauseContext

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

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

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

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

+ func (s *Column_constraintContext) Literal_value() ILiteral_valueContext

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

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

+ func (s *Column_constraintContext) Name() INameContext

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

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

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

+ func (s *Column_constraintContext) Signed_number() ISigned_numberContext

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

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

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

+ type Column_defContext struct

+ func NewColumn_defContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Column_defContext

+ func NewEmptyColumn_defContext() *Column_defContext

+ func (*Column_defContext) IsColumn_defContext()

+ func (s *Column_defContext) AllColumn_constraint() []IColumn_constraintContext

+ func (s *Column_defContext) Column_constraint(i int) IColumn_constraintContext

+ func (s *Column_defContext) Column_name() IColumn_nameContext

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

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

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

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

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

+ func (s *Column_defContext) Type_name() IType_nameContext

+ type Column_nameContext struct

+ func NewColumn_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Column_nameContext

+ func NewEmptyColumn_nameContext() *Column_nameContext

+ func (*Column_nameContext) IsColumn_nameContext()

+ func (s *Column_nameContext) Any_name() IAny_nameContext

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

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

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

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

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

+ type Column_name_listContext struct

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

+ func NewEmptyColumn_name_listContext() *Column_name_listContext

+ func (*Column_name_listContext) IsColumn_name_listContext()

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

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

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

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

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

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

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

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

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

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

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

+ type Commit_stmtContext struct

+ func NewCommit_stmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Commit_stmtContext

+ func NewEmptyCommit_stmtContext() *Commit_stmtContext

+ func (*Commit_stmtContext) IsCommit_stmtContext()

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

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

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

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

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

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

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

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

+ type Common_table_expressionContext struct

+ func NewCommon_table_expressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Common_table_expressionContext

+ func NewEmptyCommon_table_expressionContext() *Common_table_expressionContext

+ func (*Common_table_expressionContext) IsCommon_table_expressionContext()

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

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

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

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

+ func (s *Common_table_expressionContext) AllOPEN_PAR() []antlr.TerminalNode

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

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

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

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

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

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

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

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

+ func (s *Common_table_expressionContext) Select_stmt() ISelect_stmtContext

+ func (s *Common_table_expressionContext) Table_name() ITable_nameContext

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

+ type Common_table_stmtContext struct

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

+ func NewEmptyCommon_table_stmtContext() *Common_table_stmtContext

+ func (*Common_table_stmtContext) IsCommon_table_stmtContext()

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

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

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

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

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

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

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

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

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

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

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

+ type Compound_operatorContext struct

+ func NewCompound_operatorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Compound_operatorContext

+ func NewEmptyCompound_operatorContext() *Compound_operatorContext

+ func (*Compound_operatorContext) IsCompound_operatorContext()

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

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

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

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

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

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

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

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

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

+ type Compound_select_stmtContext struct

+ func NewCompound_select_stmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Compound_select_stmtContext

+ func NewEmptyCompound_select_stmtContext() *Compound_select_stmtContext

+ func (*Compound_select_stmtContext) IsCompound_select_stmtContext()

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

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

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

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

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

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

+ func (s *Compound_select_stmtContext) Common_table_stmt() ICommon_table_stmtContext

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

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

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

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

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

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

+ func (s *Compound_select_stmtContext) Limit_stmt() ILimit_stmtContext

+ func (s *Compound_select_stmtContext) Order_by_stmt() IOrder_by_stmtContext

+ func (s *Compound_select_stmtContext) Select_core(i int) ISelect_coreContext

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

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

+ type Conflict_clauseContext struct

+ func NewConflict_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Conflict_clauseContext

+ func NewEmptyConflict_clauseContext() *Conflict_clauseContext

+ func (*Conflict_clauseContext) IsConflict_clauseContext()

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

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

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

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

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

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

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

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

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

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

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

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

+ type Create_index_stmtContext struct

+ func NewCreate_index_stmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_index_stmtContext

+ func NewEmptyCreate_index_stmtContext() *Create_index_stmtContext

+ func (*Create_index_stmtContext) IsCreate_index_stmtContext()

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

+ func (s *Create_index_stmtContext) AllIndexed_column() []IIndexed_columnContext

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

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

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

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

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

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

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

+ func (s *Create_index_stmtContext) Expr() IExprContext

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

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

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

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

+ func (s *Create_index_stmtContext) Index_name() IIndex_nameContext

+ func (s *Create_index_stmtContext) Indexed_column(i int) IIndexed_columnContext

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

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

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

+ func (s *Create_index_stmtContext) Schema_name() ISchema_nameContext

+ func (s *Create_index_stmtContext) Table_name() ITable_nameContext

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

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

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

+ type Create_table_stmtContext struct

+ func NewCreate_table_stmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_table_stmtContext

+ func NewEmptyCreate_table_stmtContext() *Create_table_stmtContext

+ func (*Create_table_stmtContext) IsCreate_table_stmtContext()

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

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

+ func (s *Create_table_stmtContext) AllColumn_def() []IColumn_defContext

+ func (s *Create_table_stmtContext) AllTable_constraint() []ITable_constraintContext

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

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

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

+ func (s *Create_table_stmtContext) Column_def(i int) IColumn_defContext

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

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

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

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

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

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

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

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

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

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

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

+ func (s *Create_table_stmtContext) Schema_name() ISchema_nameContext

+ func (s *Create_table_stmtContext) Select_stmt() ISelect_stmtContext

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

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

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

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

+ func (s *Create_table_stmtContext) Table_constraint(i int) ITable_constraintContext

+ func (s *Create_table_stmtContext) Table_name() ITable_nameContext

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

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

+ type Create_trigger_stmtContext struct

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

+ func NewEmptyCreate_trigger_stmtContext() *Create_trigger_stmtContext

+ func (*Create_trigger_stmtContext) IsCreate_trigger_stmtContext()

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

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

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

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

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

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

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

+ func (s *Create_trigger_stmtContext) AllSelect_stmt() []ISelect_stmtContext

+ func (s *Create_trigger_stmtContext) AllUpdate_stmt() []IUpdate_stmtContext

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

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

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

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

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

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

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

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

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

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

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

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

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

+ func (s *Create_trigger_stmtContext) Expr() IExprContext

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

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

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

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

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

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

+ func (s *Create_trigger_stmtContext) Insert_stmt(i int) IInsert_stmtContext

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

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

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

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

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

+ func (s *Create_trigger_stmtContext) Schema_name() ISchema_nameContext

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

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

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

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

+ func (s *Create_trigger_stmtContext) Table_name() ITable_nameContext

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

+ func (s *Create_trigger_stmtContext) Trigger_name() ITrigger_nameContext

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

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

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

+ type Create_view_stmtContext struct

+ func NewCreate_view_stmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_view_stmtContext

+ func NewEmptyCreate_view_stmtContext() *Create_view_stmtContext

+ func (*Create_view_stmtContext) IsCreate_view_stmtContext()

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

+ func (s *Create_view_stmtContext) Schema_name() ISchema_nameContext

+ func (s *Create_view_stmtContext) Select_stmt() ISelect_stmtContext

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

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

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

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

+ func (s *Create_view_stmtContext) View_name() IView_nameContext

+ type Create_virtual_table_stmtContext struct

+ func NewCreate_virtual_table_stmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_virtual_table_stmtContext

+ func NewEmptyCreate_virtual_table_stmtContext() *Create_virtual_table_stmtContext

+ func (*Create_virtual_table_stmtContext) IsCreate_virtual_table_stmtContext()

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

+ func (s *Create_virtual_table_stmtContext) AllModule_argument() []IModule_argumentContext

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

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

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

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

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

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

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

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

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

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

+ func (s *Create_virtual_table_stmtContext) Module_argument(i int) IModule_argumentContext

+ func (s *Create_virtual_table_stmtContext) Module_name() IModule_nameContext

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

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

+ func (s *Create_virtual_table_stmtContext) Schema_name() ISchema_nameContext

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

+ func (s *Create_virtual_table_stmtContext) Table_name() ITable_nameContext

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

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

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

+ type Cte_table_nameContext struct

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

+ func NewEmptyCte_table_nameContext() *Cte_table_nameContext

+ func (*Cte_table_nameContext) IsCte_table_nameContext()

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

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

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

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

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

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

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

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

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

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

+ func (s *Cte_table_nameContext) Table_name() ITable_nameContext

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

+ type Default_DEFAULT__valueContext struct

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

+ func NewEmptyDefault_DEFAULT__valueContext() *Default_DEFAULT__valueContext

+ func (*Default_DEFAULT__valueContext) IsDefault_DEFAULT__valueContext()

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

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

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

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

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

+ func (s *Default_DEFAULT__valueContext) Signed_number() ISigned_numberContext

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

+ type Delete_stmtContext struct

+ func NewDelete_stmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Delete_stmtContext

+ func NewEmptyDelete_stmtContext() *Delete_stmtContext

+ func (*Delete_stmtContext) IsDelete_stmtContext()

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

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

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

+ func (s *Delete_stmtContext) Expr() IExprContext

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

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

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

+ func (s *Delete_stmtContext) Qualified_table_name() IQualified_table_nameContext

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

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

+ func (s *Delete_stmtContext) With_clause() IWith_clauseContext

+ type Delete_stmt_limitedContext struct

+ func NewDelete_stmt_limitedContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Delete_stmt_limitedContext

+ func NewEmptyDelete_stmt_limitedContext() *Delete_stmt_limitedContext

+ func (*Delete_stmt_limitedContext) IsDelete_stmt_limitedContext()

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

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

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

+ func (s *Delete_stmt_limitedContext) Expr() IExprContext

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

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

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

+ func (s *Delete_stmt_limitedContext) Limit_stmt() ILimit_stmtContext

+ func (s *Delete_stmt_limitedContext) Order_by_stmt() IOrder_by_stmtContext

+ func (s *Delete_stmt_limitedContext) Qualified_table_name() IQualified_table_nameContext

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

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

+ func (s *Delete_stmt_limitedContext) With_clause() IWith_clauseContext

+ type Detach_stmtContext struct

+ func NewDetach_stmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Detach_stmtContext

+ func NewEmptyDetach_stmtContext() *Detach_stmtContext

+ func (*Detach_stmtContext) IsDetach_stmtContext()

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

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

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

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

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

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

+ func (s *Detach_stmtContext) Schema_name() ISchema_nameContext

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

+ type Drop_stmtContext struct

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

+ func NewEmptyDrop_stmtContext() *Drop_stmtContext

+ func (*Drop_stmtContext) IsDrop_stmtContext()

+ func (s *Drop_stmtContext) Any_name() IAny_nameContext

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

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

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

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

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

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

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

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

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

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

+ func (s *Drop_stmtContext) Schema_name() ISchema_nameContext

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

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

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

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

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

+ type Error_messageContext struct

+ func NewEmptyError_messageContext() *Error_messageContext

+ func NewError_messageContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Error_messageContext

+ func (*Error_messageContext) IsError_messageContext()

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

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

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

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

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

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

+ type ExprContext struct

+ func NewEmptyExprContext() *ExprContext

+ func NewExprContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ExprContext

+ func (*ExprContext) IsExprContext()

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

+ func (s *ExprContext) Collation_name() ICollation_nameContext

+ func (s *ExprContext) Column_name() IColumn_nameContext

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

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

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

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

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

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

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

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

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

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

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

+ func (s *ExprContext) Filter_clause() IFilter_clauseContext

+ func (s *ExprContext) Function_name() IFunction_nameContext

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

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

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

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

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

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

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

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

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

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

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

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

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

+ func (s *ExprContext) Literal_value() ILiteral_valueContext

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

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

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

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

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

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

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

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

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

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

+ func (s *ExprContext) Over_clause() IOver_clauseContext

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

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

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

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

+ func (s *ExprContext) Raise_function() IRaise_functionContext

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

+ func (s *ExprContext) Schema_name() ISchema_nameContext

+ func (s *ExprContext) Select_stmt() ISelect_stmtContext

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

+ func (s *ExprContext) Table_function_name() ITable_function_nameContext

+ func (s *ExprContext) Table_name() ITable_nameContext

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

+ func (s *ExprContext) Type_name() IType_nameContext

+ func (s *ExprContext) Unary_operator() IUnary_operatorContext

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

+ 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 Factored_select_stmtContext struct

+ func NewEmptyFactored_select_stmtContext() *Factored_select_stmtContext

+ func NewFactored_select_stmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Factored_select_stmtContext

+ func (*Factored_select_stmtContext) IsFactored_select_stmtContext()

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

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

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

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

+ func (s *Factored_select_stmtContext) Select_stmt() ISelect_stmtContext

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

+ type FilenameContext struct

+ func NewEmptyFilenameContext() *FilenameContext

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

+ func (*FilenameContext) IsFilenameContext()

+ func (s *FilenameContext) Any_name() IAny_nameContext

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

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

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

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

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

+ type Filter_clauseContext struct

+ func NewEmptyFilter_clauseContext() *Filter_clauseContext

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

+ func (*Filter_clauseContext) IsFilter_clauseContext()

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

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

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

+ func (s *Filter_clauseContext) Expr() IExprContext

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

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

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

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

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

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

+ type Foreign_key_clauseContext struct

+ func NewEmptyForeign_key_clauseContext() *Foreign_key_clauseContext

+ func NewForeign_key_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Foreign_key_clauseContext

+ func (*Foreign_key_clauseContext) IsForeign_key_clauseContext()

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

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

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

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

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

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

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

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

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

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

+ func (s *Foreign_key_clauseContext) AllName() []INameContext

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

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

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

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

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

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

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

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

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

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

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

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

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

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

+ func (s *Foreign_key_clauseContext) Foreign_table() IForeign_tableContext

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

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

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

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

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

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

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

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

+ func (s *Foreign_key_clauseContext) Name(i int) INameContext

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

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

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

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

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

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

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

+ type Foreign_tableContext struct

+ func NewEmptyForeign_tableContext() *Foreign_tableContext

+ func NewForeign_tableContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Foreign_tableContext

+ func (*Foreign_tableContext) IsForeign_tableContext()

+ func (s *Foreign_tableContext) Any_name() IAny_nameContext

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

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

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

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

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

+ type Frame_clauseContext struct

+ func NewEmptyFrame_clauseContext() *Frame_clauseContext

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

+ func (*Frame_clauseContext) IsFrame_clauseContext()

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

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

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

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

+ func (s *Frame_clauseContext) Frame_left() IFrame_leftContext

+ func (s *Frame_clauseContext) Frame_right() IFrame_rightContext

+ func (s *Frame_clauseContext) Frame_single() IFrame_singleContext

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

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

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

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

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

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

+ type Frame_leftContext struct

+ func NewEmptyFrame_leftContext() *Frame_leftContext

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

+ func (*Frame_leftContext) IsFrame_leftContext()

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

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

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

+ func (s *Frame_leftContext) Expr() IExprContext

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

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

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

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

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

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

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

+ type Frame_rightContext struct

+ func NewEmptyFrame_rightContext() *Frame_rightContext

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

+ func (*Frame_rightContext) IsFrame_rightContext()

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

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

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

+ func (s *Frame_rightContext) Expr() IExprContext

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

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

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

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

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

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

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

+ type Frame_singleContext struct

+ func NewEmptyFrame_singleContext() *Frame_singleContext

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

+ func (*Frame_singleContext) IsFrame_singleContext()

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

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

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

+ func (s *Frame_singleContext) Expr() IExprContext

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

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

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

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

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

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

+ type Frame_specContext struct

+ func NewEmptyFrame_specContext() *Frame_specContext

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

+ func (*Frame_specContext) IsFrame_specContext()

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

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

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

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

+ func (s *Frame_specContext) Frame_clause() IFrame_clauseContext

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

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

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

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

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

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

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

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

+ type Function_nameContext struct

+ func NewEmptyFunction_nameContext() *Function_nameContext

+ func NewFunction_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Function_nameContext

+ func (*Function_nameContext) IsFunction_nameContext()

+ func (s *Function_nameContext) Any_name() IAny_nameContext

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

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

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

+ func (s *Function_nameContext) GetRuleContext() antlr.RuleContext

+ func (s *Function_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type IAggregate_funcContext interface

+ GetParser func() antlr.Parser

+ IsAggregate_funcContext func()

+ type IAggregate_function_invocationContext interface

+ GetParser func() antlr.Parser

+ IsAggregate_function_invocationContext func()

+ type IAliasContext interface

+ GetParser func() antlr.Parser

+ IsAliasContext func()

+ type IAlter_table_stmtContext interface

+ GetNew_column_name func() IColumn_nameContext

+ GetOld_column_name func() IColumn_nameContext

+ GetParser func() antlr.Parser

+ IsAlter_table_stmtContext func()

+ SetNew_column_name func(IColumn_nameContext)

+ SetOld_column_name func(IColumn_nameContext)

+ type IAnalyze_stmtContext interface

+ GetParser func() antlr.Parser

+ IsAnalyze_stmtContext func()

+ type IAny_nameContext interface

+ GetParser func() antlr.Parser

+ IsAny_nameContext func()

+ type IAsc_descContext interface

+ GetParser func() antlr.Parser

+ IsAsc_descContext func()

+ type IAttach_stmtContext interface

+ GetParser func() antlr.Parser

+ IsAttach_stmtContext func()

+ type IBase_window_nameContext interface

+ GetParser func() antlr.Parser

+ IsBase_window_nameContext func()

+ type IBegin_stmtContext interface

+ GetParser func() antlr.Parser

+ IsBegin_stmtContext func()

+ type ICollation_nameContext interface

+ GetParser func() antlr.Parser

+ IsCollation_nameContext func()

+ type IColumn_aliasContext interface

+ GetParser func() antlr.Parser

+ IsColumn_aliasContext func()

+ type IColumn_constraintContext interface

+ GetParser func() antlr.Parser

+ IsColumn_constraintContext func()

+ type IColumn_defContext interface

+ GetParser func() antlr.Parser

+ IsColumn_defContext func()

+ type IColumn_nameContext interface

+ GetParser func() antlr.Parser

+ IsColumn_nameContext func()

+ type IColumn_name_listContext interface

+ GetParser func() antlr.Parser

+ IsColumn_name_listContext func()

+ type ICommit_stmtContext interface

+ GetParser func() antlr.Parser

+ IsCommit_stmtContext func()

+ type ICommon_table_expressionContext interface

+ GetParser func() antlr.Parser

+ IsCommon_table_expressionContext func()

+ type ICommon_table_stmtContext interface

+ GetParser func() antlr.Parser

+ IsCommon_table_stmtContext func()

+ type ICompound_operatorContext interface

+ GetParser func() antlr.Parser

+ IsCompound_operatorContext func()

+ type ICompound_select_stmtContext interface

+ GetParser func() antlr.Parser

+ IsCompound_select_stmtContext func()

+ type IConflict_clauseContext interface

+ GetParser func() antlr.Parser

+ IsConflict_clauseContext func()

+ type ICreate_index_stmtContext interface

+ GetParser func() antlr.Parser

+ IsCreate_index_stmtContext func()

+ type ICreate_table_stmtContext interface

+ GetParser func() antlr.Parser

+ GetRow_ROW_ID func() antlr.Token

+ IsCreate_table_stmtContext func()

+ SetRow_ROW_ID func(antlr.Token)

+ type ICreate_trigger_stmtContext interface

+ GetParser func() antlr.Parser

+ IsCreate_trigger_stmtContext func()

+ type ICreate_view_stmtContext interface

+ GetParser func() antlr.Parser

+ IsCreate_view_stmtContext func()

+ type ICreate_virtual_table_stmtContext interface

+ GetParser func() antlr.Parser

+ IsCreate_virtual_table_stmtContext func()

+ type ICte_table_nameContext interface

+ GetParser func() antlr.Parser

+ IsCte_table_nameContext func()

+ type IDefault_DEFAULT__valueContext interface

+ GetParser func() antlr.Parser

+ IsDefault_DEFAULT__valueContext func()

+ type IDelete_stmtContext interface

+ GetParser func() antlr.Parser

+ IsDelete_stmtContext func()

+ type IDelete_stmt_limitedContext interface

+ GetParser func() antlr.Parser

+ IsDelete_stmt_limitedContext func()

+ type IDetach_stmtContext interface

+ GetParser func() antlr.Parser

+ IsDetach_stmtContext func()

+ type IDrop_stmtContext interface

+ GetObject func() antlr.Token

+ GetParser func() antlr.Parser

+ IsDrop_stmtContext func()

+ SetObject func(antlr.Token)

+ type IError_messageContext interface

+ GetParser func() antlr.Parser

+ IsError_messageContext func()

+ type IExprContext interface

+ GetParser func() antlr.Parser

+ IsExprContext func()

+ type IExpr_asc_descContext interface

+ GetParser func() antlr.Parser

+ IsExpr_asc_descContext func()

+ type IFactored_select_stmtContext interface

+ GetParser func() antlr.Parser

+ IsFactored_select_stmtContext func()

+ type IFilenameContext interface

+ GetParser func() antlr.Parser

+ IsFilenameContext func()

+ type IFilter_clauseContext interface

+ GetParser func() antlr.Parser

+ IsFilter_clauseContext func()

+ type IForeign_key_clauseContext interface

+ GetParser func() antlr.Parser

+ IsForeign_key_clauseContext func()

+ type IForeign_tableContext interface

+ GetParser func() antlr.Parser

+ IsForeign_tableContext func()

+ type IFrame_clauseContext interface

+ GetParser func() antlr.Parser

+ IsFrame_clauseContext func()

+ type IFrame_leftContext interface

+ GetParser func() antlr.Parser

+ IsFrame_leftContext func()

+ type IFrame_rightContext interface

+ GetParser func() antlr.Parser

+ IsFrame_rightContext func()

+ type IFrame_singleContext interface

+ GetParser func() antlr.Parser

+ IsFrame_singleContext func()

+ type IFrame_specContext interface

+ GetParser func() antlr.Parser

+ IsFrame_specContext func()

+ type IFunction_nameContext interface

+ GetParser func() antlr.Parser

+ IsFunction_nameContext func()

+ type IIndex_nameContext interface

+ GetParser func() antlr.Parser

+ IsIndex_nameContext func()

+ type IIndexed_columnContext interface

+ GetParser func() antlr.Parser

+ IsIndexed_columnContext func()

+ type IInitial_selectContext interface

+ GetParser func() antlr.Parser

+ IsInitial_selectContext func()

+ type IInsert_stmtContext interface

+ GetParser func() antlr.Parser

+ IsInsert_stmtContext func()

+ type IJoin_clauseContext interface

+ GetParser func() antlr.Parser

+ IsJoin_clauseContext func()

+ type IJoin_constraintContext interface

+ GetParser func() antlr.Parser

+ IsJoin_constraintContext func()

+ type IJoin_operatorContext interface

+ GetParser func() antlr.Parser

+ IsJoin_operatorContext func()

+ type IKeywordContext interface

+ GetParser func() antlr.Parser

+ IsKeywordContext func()

+ type ILimit_stmtContext interface

+ GetParser func() antlr.Parser

+ IsLimit_stmtContext func()

+ type ILiteral_valueContext interface

+ GetParser func() antlr.Parser

+ IsLiteral_valueContext func()

+ type IModule_argumentContext interface

+ GetParser func() antlr.Parser

+ IsModule_argumentContext func()

+ type IModule_nameContext interface

+ GetParser func() antlr.Parser

+ IsModule_nameContext func()

+ type INameContext interface

+ GetParser func() antlr.Parser

+ IsNameContext func()

+ type INew_table_nameContext interface

+ GetParser func() antlr.Parser

+ IsNew_table_nameContext func()

+ type IOf_OF_fsetContext interface

+ GetParser func() antlr.Parser

+ IsOf_OF_fsetContext func()

+ type IOrder_by_exprContext interface

+ GetParser func() antlr.Parser

+ IsOrder_by_exprContext func()

+ type IOrder_by_expr_asc_descContext interface

+ GetParser func() antlr.Parser

+ IsOrder_by_expr_asc_descContext func()

+ type IOrder_by_stmtContext interface

+ GetParser func() antlr.Parser

+ IsOrder_by_stmtContext func()

+ type IOrdering_termContext interface

+ GetParser func() antlr.Parser

+ IsOrdering_termContext func()

+ type IOver_clauseContext interface

+ GetParser func() antlr.Parser

+ IsOver_clauseContext func()

+ type IParseContext interface

+ GetParser func() antlr.Parser

+ IsParseContext func()

+ type IPartition_byContext interface

+ GetParser func() antlr.Parser

+ IsPartition_byContext func()

+ type IPragma_nameContext interface

+ GetParser func() antlr.Parser

+ IsPragma_nameContext func()

+ type IPragma_stmtContext interface

+ GetParser func() antlr.Parser

+ IsPragma_stmtContext func()

+ type IPragma_valueContext interface

+ GetParser func() antlr.Parser

+ IsPragma_valueContext func()

+ type IQualified_table_nameContext interface

+ GetParser func() antlr.Parser

+ IsQualified_table_nameContext func()

+ type IRaise_functionContext interface

+ GetParser func() antlr.Parser

+ IsRaise_functionContext func()

+ type IRecursive__selectContext interface

+ GetParser func() antlr.Parser

+ IsRecursive__selectContext func()

+ type IRecursive_cteContext interface

+ GetParser func() antlr.Parser

+ IsRecursive_cteContext func()

+ type IReindex_stmtContext interface

+ GetParser func() antlr.Parser

+ IsReindex_stmtContext func()

+ type IRelease_stmtContext interface

+ GetParser func() antlr.Parser

+ IsRelease_stmtContext func()

+ type IResult_columnContext interface

+ GetParser func() antlr.Parser

+ IsResult_columnContext func()

+ type IRollback_stmtContext interface

+ GetParser func() antlr.Parser

+ IsRollback_stmtContext func()

+ type ISavepoint_nameContext interface

+ GetParser func() antlr.Parser

+ IsSavepoint_nameContext func()

+ type ISavepoint_stmtContext interface

+ GetParser func() antlr.Parser

+ IsSavepoint_stmtContext func()

+ type ISchema_nameContext interface

+ GetParser func() antlr.Parser

+ IsSchema_nameContext func()

+ type ISelect_coreContext interface

+ GetParser func() antlr.Parser

+ IsSelect_coreContext func()

+ type ISelect_stmtContext interface

+ GetParser func() antlr.Parser

+ IsSelect_stmtContext func()

+ type ISigned_numberContext interface

+ GetParser func() antlr.Parser

+ IsSigned_numberContext func()

+ type ISimple_funcContext interface

+ GetParser func() antlr.Parser

+ IsSimple_funcContext func()

+ type ISimple_function_invocationContext interface

+ GetParser func() antlr.Parser

+ IsSimple_function_invocationContext func()

+ type ISimple_select_stmtContext interface

+ GetParser func() antlr.Parser

+ IsSimple_select_stmtContext func()

+ type ISql_stmtContext interface

+ GetParser func() antlr.Parser

+ IsSql_stmtContext func()

+ type ITable_aliasContext interface

+ GetParser func() antlr.Parser

+ IsTable_aliasContext func()

+ type ITable_constraintContext interface

+ GetParser func() antlr.Parser

+ IsTable_constraintContext func()

+ type ITable_function_nameContext interface

+ GetParser func() antlr.Parser

+ IsTable_function_nameContext func()

+ type ITable_nameContext interface

+ GetParser func() antlr.Parser

+ IsTable_nameContext func()

+ type ITable_or_index_nameContext interface

+ GetParser func() antlr.Parser

+ IsTable_or_index_nameContext func()

+ type ITable_or_subqueryContext interface

+ GetParser func() antlr.Parser

+ IsTable_or_subqueryContext func()

+ type ITransaction_nameContext interface

+ GetParser func() antlr.Parser

+ IsTransaction_nameContext func()

+ type ITrigger_nameContext interface

+ GetParser func() antlr.Parser

+ IsTrigger_nameContext func()

+ type IType_nameContext interface

+ GetParser func() antlr.Parser

+ IsType_nameContext func()

+ type IUnary_operatorContext interface

+ GetParser func() antlr.Parser

+ IsUnary_operatorContext func()

+ type IUpdate_stmtContext interface

+ GetParser func() antlr.Parser

+ IsUpdate_stmtContext func()

+ type IUpdate_stmt_limitedContext interface

+ GetParser func() antlr.Parser

+ IsUpdate_stmt_limitedContext func()

+ type IUpsert_clauseContext interface

+ GetParser func() antlr.Parser

+ IsUpsert_clauseContext func()

+ type IVacuum_stmtContext interface

+ GetParser func() antlr.Parser

+ IsVacuum_stmtContext func()

+ type IView_nameContext interface

+ GetParser func() antlr.Parser

+ IsView_nameContext func()

+ type IWindow_defnContext interface

+ GetParser func() antlr.Parser

+ IsWindow_defnContext func()

+ type IWindow_functionContext interface

+ GetParser func() antlr.Parser

+ IsWindow_functionContext func()

+ type IWindow_function_invocationContext interface

+ GetParser func() antlr.Parser

+ IsWindow_function_invocationContext func()

+ type IWindow_nameContext interface

+ GetParser func() antlr.Parser

+ IsWindow_nameContext func()

+ type IWith_clauseContext interface

+ GetParser func() antlr.Parser

+ IsWith_clauseContext func()

+ type Index_nameContext struct

+ func NewEmptyIndex_nameContext() *Index_nameContext

+ func NewIndex_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Index_nameContext

+ func (*Index_nameContext) IsIndex_nameContext()

+ func (s *Index_nameContext) Any_name() IAny_nameContext

+ func (s *Index_nameContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Index_nameContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Index_nameContext) GetParser() antlr.Parser

+ func (s *Index_nameContext) GetRuleContext() antlr.RuleContext

+ func (s *Index_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type Indexed_columnContext struct

+ func NewEmptyIndexed_columnContext() *Indexed_columnContext

+ func NewIndexed_columnContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Indexed_columnContext

+ func (*Indexed_columnContext) IsIndexed_columnContext()

+ func (s *Indexed_columnContext) Asc_desc() IAsc_descContext

+ func (s *Indexed_columnContext) COLLATE_() antlr.TerminalNode

+ func (s *Indexed_columnContext) Collation_name() ICollation_nameContext

+ func (s *Indexed_columnContext) Column_name() IColumn_nameContext

+ func (s *Indexed_columnContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Indexed_columnContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Indexed_columnContext) Expr() IExprContext

+ func (s *Indexed_columnContext) GetParser() antlr.Parser

+ func (s *Indexed_columnContext) GetRuleContext() antlr.RuleContext

+ func (s *Indexed_columnContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type Initial_selectContext struct

+ func NewEmptyInitial_selectContext() *Initial_selectContext

+ func NewInitial_selectContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Initial_selectContext

+ func (*Initial_selectContext) IsInitial_selectContext()

+ func (s *Initial_selectContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Initial_selectContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Initial_selectContext) GetParser() antlr.Parser

+ func (s *Initial_selectContext) GetRuleContext() antlr.RuleContext

+ func (s *Initial_selectContext) Select_stmt() ISelect_stmtContext

+ func (s *Initial_selectContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type Insert_stmtContext struct

+ func NewEmptyInsert_stmtContext() *Insert_stmtContext

+ func NewInsert_stmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Insert_stmtContext

+ func (*Insert_stmtContext) IsInsert_stmtContext()

+ func (s *Insert_stmtContext) ABORT_() antlr.TerminalNode

+ func (s *Insert_stmtContext) AS_() antlr.TerminalNode

+ func (s *Insert_stmtContext) AllCLOSE_PAR() []antlr.TerminalNode

+ func (s *Insert_stmtContext) AllCOMMA() []antlr.TerminalNode

+ func (s *Insert_stmtContext) AllColumn_name() []IColumn_nameContext

+ func (s *Insert_stmtContext) AllExpr() []IExprContext

+ func (s *Insert_stmtContext) AllOPEN_PAR() []antlr.TerminalNode

+ func (s *Insert_stmtContext) CLOSE_PAR(i int) antlr.TerminalNode

+ func (s *Insert_stmtContext) COMMA(i int) antlr.TerminalNode

+ func (s *Insert_stmtContext) Column_name(i int) IColumn_nameContext

+ func (s *Insert_stmtContext) DEFAULT_() antlr.TerminalNode

+ func (s *Insert_stmtContext) DOT() antlr.TerminalNode

+ func (s *Insert_stmtContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Insert_stmtContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Insert_stmtContext) Expr(i int) IExprContext

+ func (s *Insert_stmtContext) FAIL_() antlr.TerminalNode

+ func (s *Insert_stmtContext) GetParser() antlr.Parser

+ func (s *Insert_stmtContext) GetRuleContext() antlr.RuleContext

+ func (s *Insert_stmtContext) IGNORE_() antlr.TerminalNode

+ func (s *Insert_stmtContext) INSERT_() antlr.TerminalNode

+ func (s *Insert_stmtContext) INTO_() antlr.TerminalNode

+ func (s *Insert_stmtContext) OPEN_PAR(i int) antlr.TerminalNode

+ func (s *Insert_stmtContext) OR_() antlr.TerminalNode

+ func (s *Insert_stmtContext) REPLACE_() antlr.TerminalNode

+ func (s *Insert_stmtContext) ROLLBACK_() antlr.TerminalNode

+ func (s *Insert_stmtContext) Schema_name() ISchema_nameContext

+ func (s *Insert_stmtContext) Select_stmt() ISelect_stmtContext

+ func (s *Insert_stmtContext) Table_alias() ITable_aliasContext

+ func (s *Insert_stmtContext) Table_name() ITable_nameContext

+ func (s *Insert_stmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ func (s *Insert_stmtContext) Upsert_clause() IUpsert_clauseContext

+ func (s *Insert_stmtContext) VALUES_() antlr.TerminalNode

+ func (s *Insert_stmtContext) With_clause() IWith_clauseContext

+ type Join_clauseContext struct

+ func NewEmptyJoin_clauseContext() *Join_clauseContext

+ func NewJoin_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Join_clauseContext

+ func (*Join_clauseContext) IsJoin_clauseContext()

+ func (s *Join_clauseContext) AllJoin_constraint() []IJoin_constraintContext

+ func (s *Join_clauseContext) AllJoin_operator() []IJoin_operatorContext

+ func (s *Join_clauseContext) AllTable_or_subquery() []ITable_or_subqueryContext

+ func (s *Join_clauseContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Join_clauseContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Join_clauseContext) GetParser() antlr.Parser

+ func (s *Join_clauseContext) GetRuleContext() antlr.RuleContext

+ func (s *Join_clauseContext) Join_constraint(i int) IJoin_constraintContext

+ func (s *Join_clauseContext) Join_operator(i int) IJoin_operatorContext

+ func (s *Join_clauseContext) Table_or_subquery(i int) ITable_or_subqueryContext

+ func (s *Join_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type Join_constraintContext struct

+ func NewEmptyJoin_constraintContext() *Join_constraintContext

+ func NewJoin_constraintContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Join_constraintContext

+ func (*Join_constraintContext) IsJoin_constraintContext()

+ func (s *Join_constraintContext) AllCOMMA() []antlr.TerminalNode

+ func (s *Join_constraintContext) AllColumn_name() []IColumn_nameContext

+ func (s *Join_constraintContext) CLOSE_PAR() antlr.TerminalNode

+ func (s *Join_constraintContext) COMMA(i int) antlr.TerminalNode

+ func (s *Join_constraintContext) Column_name(i int) IColumn_nameContext

+ func (s *Join_constraintContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Join_constraintContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Join_constraintContext) Expr() IExprContext

+ func (s *Join_constraintContext) GetParser() antlr.Parser

+ func (s *Join_constraintContext) GetRuleContext() antlr.RuleContext

+ func (s *Join_constraintContext) ON_() antlr.TerminalNode

+ func (s *Join_constraintContext) OPEN_PAR() antlr.TerminalNode

+ func (s *Join_constraintContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ func (s *Join_constraintContext) USING_() antlr.TerminalNode

+ type Join_operatorContext struct

+ func NewEmptyJoin_operatorContext() *Join_operatorContext

+ func NewJoin_operatorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Join_operatorContext

+ func (*Join_operatorContext) IsJoin_operatorContext()

+ func (s *Join_operatorContext) COMMA() antlr.TerminalNode

+ func (s *Join_operatorContext) CROSS_() antlr.TerminalNode

+ func (s *Join_operatorContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Join_operatorContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Join_operatorContext) GetParser() antlr.Parser

+ func (s *Join_operatorContext) GetRuleContext() antlr.RuleContext

+ func (s *Join_operatorContext) INNER_() antlr.TerminalNode

+ func (s *Join_operatorContext) JOIN_() antlr.TerminalNode

+ func (s *Join_operatorContext) LEFT_() antlr.TerminalNode

+ func (s *Join_operatorContext) NATURAL_() antlr.TerminalNode

+ func (s *Join_operatorContext) OUTER_() antlr.TerminalNode

+ func (s *Join_operatorContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type KeywordContext struct

+ func NewEmptyKeywordContext() *KeywordContext

+ func NewKeywordContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KeywordContext

+ func (*KeywordContext) IsKeywordContext()

+ func (s *KeywordContext) ABORT_() antlr.TerminalNode

+ func (s *KeywordContext) ACTION_() antlr.TerminalNode

+ func (s *KeywordContext) ADD_() antlr.TerminalNode

+ func (s *KeywordContext) AFTER_() antlr.TerminalNode

+ func (s *KeywordContext) ALL_() antlr.TerminalNode

+ func (s *KeywordContext) ALTER_() antlr.TerminalNode

+ func (s *KeywordContext) ALWAYS_() antlr.TerminalNode

+ func (s *KeywordContext) ANALYZE_() antlr.TerminalNode

+ func (s *KeywordContext) AND_() antlr.TerminalNode

+ func (s *KeywordContext) ASC_() antlr.TerminalNode

+ func (s *KeywordContext) AS_() antlr.TerminalNode

+ func (s *KeywordContext) ATTACH_() antlr.TerminalNode

+ func (s *KeywordContext) AUTOINCREMENT_() antlr.TerminalNode

+ func (s *KeywordContext) BEFORE_() antlr.TerminalNode

+ func (s *KeywordContext) BEGIN_() antlr.TerminalNode

+ func (s *KeywordContext) BETWEEN_() antlr.TerminalNode

+ func (s *KeywordContext) BY_() antlr.TerminalNode

+ func (s *KeywordContext) CASCADE_() antlr.TerminalNode

+ func (s *KeywordContext) CASE_() antlr.TerminalNode

+ func (s *KeywordContext) CAST_() antlr.TerminalNode

+ func (s *KeywordContext) CHECK_() antlr.TerminalNode

+ func (s *KeywordContext) COLLATE_() antlr.TerminalNode

+ func (s *KeywordContext) COLUMN_() antlr.TerminalNode

+ func (s *KeywordContext) COMMIT_() antlr.TerminalNode

+ func (s *KeywordContext) CONFLICT_() antlr.TerminalNode

+ func (s *KeywordContext) CONSTRAINT_() antlr.TerminalNode

+ func (s *KeywordContext) CREATE_() antlr.TerminalNode

+ func (s *KeywordContext) CROSS_() antlr.TerminalNode

+ func (s *KeywordContext) CUME_DIST_() antlr.TerminalNode

+ func (s *KeywordContext) CURRENT_() antlr.TerminalNode

+ func (s *KeywordContext) CURRENT_DATE_() antlr.TerminalNode

+ func (s *KeywordContext) CURRENT_TIMESTAMP_() antlr.TerminalNode

+ func (s *KeywordContext) CURRENT_TIME_() antlr.TerminalNode

+ func (s *KeywordContext) DATABASE_() antlr.TerminalNode

+ func (s *KeywordContext) DEFAULT_() antlr.TerminalNode

+ func (s *KeywordContext) DEFERRABLE_() antlr.TerminalNode

+ func (s *KeywordContext) DEFERRED_() antlr.TerminalNode

+ func (s *KeywordContext) DELETE_() antlr.TerminalNode

+ func (s *KeywordContext) DENSE_RANK_() antlr.TerminalNode

+ func (s *KeywordContext) DESC_() antlr.TerminalNode

+ func (s *KeywordContext) DETACH_() antlr.TerminalNode

+ func (s *KeywordContext) DISTINCT_() antlr.TerminalNode

+ func (s *KeywordContext) DROP_() antlr.TerminalNode

+ func (s *KeywordContext) EACH_() antlr.TerminalNode

+ func (s *KeywordContext) ELSE_() antlr.TerminalNode

+ func (s *KeywordContext) END_() antlr.TerminalNode

+ func (s *KeywordContext) ESCAPE_() antlr.TerminalNode

+ func (s *KeywordContext) EXCEPT_() antlr.TerminalNode

+ func (s *KeywordContext) EXCLUDE_() antlr.TerminalNode

+ func (s *KeywordContext) EXCLUSIVE_() antlr.TerminalNode

+ func (s *KeywordContext) EXISTS_() antlr.TerminalNode

+ func (s *KeywordContext) EXPLAIN_() antlr.TerminalNode

+ func (s *KeywordContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *KeywordContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *KeywordContext) FAIL_() antlr.TerminalNode

+ func (s *KeywordContext) FALSE_() antlr.TerminalNode

+ func (s *KeywordContext) FILTER_() antlr.TerminalNode

+ func (s *KeywordContext) FIRST_() antlr.TerminalNode

+ func (s *KeywordContext) FIRST_VALUE_() antlr.TerminalNode

+ func (s *KeywordContext) FOLLOWING_() antlr.TerminalNode

+ func (s *KeywordContext) FOREIGN_() antlr.TerminalNode

+ func (s *KeywordContext) FOR_() antlr.TerminalNode

+ func (s *KeywordContext) FROM_() antlr.TerminalNode

+ func (s *KeywordContext) FULL_() antlr.TerminalNode

+ func (s *KeywordContext) GENERATED_() antlr.TerminalNode

+ func (s *KeywordContext) GLOB_() antlr.TerminalNode

+ func (s *KeywordContext) GROUPS_() antlr.TerminalNode

+ func (s *KeywordContext) GROUP_() antlr.TerminalNode

+ func (s *KeywordContext) GetParser() antlr.Parser

+ func (s *KeywordContext) GetRuleContext() antlr.RuleContext

+ func (s *KeywordContext) HAVING_() antlr.TerminalNode

+ func (s *KeywordContext) IF_() antlr.TerminalNode

+ func (s *KeywordContext) IGNORE_() antlr.TerminalNode

+ func (s *KeywordContext) IMMEDIATE_() antlr.TerminalNode

+ func (s *KeywordContext) INDEXED_() antlr.TerminalNode

+ func (s *KeywordContext) INDEX_() antlr.TerminalNode

+ func (s *KeywordContext) INITIALLY_() antlr.TerminalNode

+ func (s *KeywordContext) INNER_() antlr.TerminalNode

+ func (s *KeywordContext) INSERT_() antlr.TerminalNode

+ func (s *KeywordContext) INSTEAD_() antlr.TerminalNode

+ func (s *KeywordContext) INTERSECT_() antlr.TerminalNode

+ func (s *KeywordContext) INTO_() antlr.TerminalNode

+ func (s *KeywordContext) IN_() antlr.TerminalNode

+ func (s *KeywordContext) ISNULL_() antlr.TerminalNode

+ func (s *KeywordContext) IS_() antlr.TerminalNode

+ func (s *KeywordContext) JOIN_() antlr.TerminalNode

+ func (s *KeywordContext) KEY_() antlr.TerminalNode

+ func (s *KeywordContext) LAG_() antlr.TerminalNode

+ func (s *KeywordContext) LAST_() antlr.TerminalNode

+ func (s *KeywordContext) LAST_VALUE_() antlr.TerminalNode

+ func (s *KeywordContext) LEAD_() antlr.TerminalNode

+ func (s *KeywordContext) LEFT_() antlr.TerminalNode

+ func (s *KeywordContext) LIKE_() antlr.TerminalNode

+ func (s *KeywordContext) LIMIT_() antlr.TerminalNode

+ func (s *KeywordContext) MATCH_() antlr.TerminalNode

+ func (s *KeywordContext) NATURAL_() antlr.TerminalNode

+ func (s *KeywordContext) NOTNULL_() antlr.TerminalNode

+ func (s *KeywordContext) NOT_() antlr.TerminalNode

+ func (s *KeywordContext) NO_() antlr.TerminalNode

+ func (s *KeywordContext) NTH_VALUE_() antlr.TerminalNode

+ func (s *KeywordContext) NTILE_() antlr.TerminalNode

+ func (s *KeywordContext) NULLS_() antlr.TerminalNode

+ func (s *KeywordContext) NULL_() antlr.TerminalNode

+ func (s *KeywordContext) OFFSET_() antlr.TerminalNode

+ func (s *KeywordContext) OF_() antlr.TerminalNode

+ func (s *KeywordContext) ON_() antlr.TerminalNode

+ func (s *KeywordContext) ORDER_() antlr.TerminalNode

+ func (s *KeywordContext) OR_() antlr.TerminalNode

+ func (s *KeywordContext) OUTER_() antlr.TerminalNode

+ func (s *KeywordContext) OVER_() antlr.TerminalNode

+ func (s *KeywordContext) PARTITION_() antlr.TerminalNode

+ func (s *KeywordContext) PERCENT_RANK_() antlr.TerminalNode

+ func (s *KeywordContext) PLAN_() antlr.TerminalNode

+ func (s *KeywordContext) PRAGMA_() antlr.TerminalNode

+ func (s *KeywordContext) PRECEDING_() antlr.TerminalNode

+ func (s *KeywordContext) PRIMARY_() antlr.TerminalNode

+ func (s *KeywordContext) QUERY_() antlr.TerminalNode

+ func (s *KeywordContext) RAISE_() antlr.TerminalNode

+ func (s *KeywordContext) RANGE_() antlr.TerminalNode

+ func (s *KeywordContext) RANK_() antlr.TerminalNode

+ func (s *KeywordContext) RECURSIVE_() antlr.TerminalNode

+ func (s *KeywordContext) REFERENCES_() antlr.TerminalNode

+ func (s *KeywordContext) REGEXP_() antlr.TerminalNode

+ func (s *KeywordContext) REINDEX_() antlr.TerminalNode

+ func (s *KeywordContext) RELEASE_() antlr.TerminalNode

+ func (s *KeywordContext) RENAME_() antlr.TerminalNode

+ func (s *KeywordContext) REPLACE_() antlr.TerminalNode

+ func (s *KeywordContext) RESTRICT_() antlr.TerminalNode

+ func (s *KeywordContext) RIGHT_() antlr.TerminalNode

+ func (s *KeywordContext) ROLLBACK_() antlr.TerminalNode

+ func (s *KeywordContext) ROWS_() antlr.TerminalNode

+ func (s *KeywordContext) ROW_() antlr.TerminalNode

+ func (s *KeywordContext) ROW_NUMBER_() antlr.TerminalNode

+ func (s *KeywordContext) SAVEPOINT_() antlr.TerminalNode

+ func (s *KeywordContext) SELECT_() antlr.TerminalNode

+ func (s *KeywordContext) SET_() antlr.TerminalNode

+ func (s *KeywordContext) STORED_() antlr.TerminalNode

+ func (s *KeywordContext) TABLE_() antlr.TerminalNode

+ func (s *KeywordContext) TEMPORARY_() antlr.TerminalNode

+ func (s *KeywordContext) TEMP_() antlr.TerminalNode

+ func (s *KeywordContext) THEN_() antlr.TerminalNode

+ func (s *KeywordContext) TO_() antlr.TerminalNode

+ func (s *KeywordContext) TRANSACTION_() antlr.TerminalNode

+ func (s *KeywordContext) TRIGGER_() antlr.TerminalNode

+ func (s *KeywordContext) TRUE_() antlr.TerminalNode

+ func (s *KeywordContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ func (s *KeywordContext) UNBOUNDED_() antlr.TerminalNode

+ func (s *KeywordContext) UNION_() antlr.TerminalNode

+ func (s *KeywordContext) UNIQUE_() antlr.TerminalNode

+ func (s *KeywordContext) UPDATE_() antlr.TerminalNode

+ func (s *KeywordContext) USING_() antlr.TerminalNode

+ func (s *KeywordContext) VACUUM_() antlr.TerminalNode

+ func (s *KeywordContext) VALUES_() antlr.TerminalNode

+ func (s *KeywordContext) VIEW_() antlr.TerminalNode

+ func (s *KeywordContext) VIRTUAL_() antlr.TerminalNode

+ func (s *KeywordContext) WHEN_() antlr.TerminalNode

+ func (s *KeywordContext) WHERE_() antlr.TerminalNode

+ func (s *KeywordContext) WINDOW_() antlr.TerminalNode

+ func (s *KeywordContext) WITHOUT_() antlr.TerminalNode

+ func (s *KeywordContext) WITH_() antlr.TerminalNode

+ type Limit_stmtContext struct

+ func NewEmptyLimit_stmtContext() *Limit_stmtContext

+ func NewLimit_stmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Limit_stmtContext

+ func (*Limit_stmtContext) IsLimit_stmtContext()

+ func (s *Limit_stmtContext) AllExpr() []IExprContext

+ func (s *Limit_stmtContext) COMMA() antlr.TerminalNode

+ func (s *Limit_stmtContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Limit_stmtContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Limit_stmtContext) Expr(i int) IExprContext

+ func (s *Limit_stmtContext) GetParser() antlr.Parser

+ func (s *Limit_stmtContext) GetRuleContext() antlr.RuleContext

+ func (s *Limit_stmtContext) LIMIT_() antlr.TerminalNode

+ func (s *Limit_stmtContext) OFFSET_() antlr.TerminalNode

+ func (s *Limit_stmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type Literal_valueContext struct

+ func NewEmptyLiteral_valueContext() *Literal_valueContext

+ func NewLiteral_valueContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Literal_valueContext

+ func (*Literal_valueContext) IsLiteral_valueContext()

+ func (s *Literal_valueContext) BLOB_LITERAL() antlr.TerminalNode

+ func (s *Literal_valueContext) CURRENT_DATE_() antlr.TerminalNode

+ func (s *Literal_valueContext) CURRENT_TIMESTAMP_() antlr.TerminalNode

+ func (s *Literal_valueContext) CURRENT_TIME_() antlr.TerminalNode

+ func (s *Literal_valueContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Literal_valueContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Literal_valueContext) FALSE_() antlr.TerminalNode

+ func (s *Literal_valueContext) GetParser() antlr.Parser

+ func (s *Literal_valueContext) GetRuleContext() antlr.RuleContext

+ func (s *Literal_valueContext) NULL_() antlr.TerminalNode

+ func (s *Literal_valueContext) NUMERIC_LITERAL() antlr.TerminalNode

+ func (s *Literal_valueContext) STRING_LITERAL() antlr.TerminalNode

+ func (s *Literal_valueContext) TRUE_() antlr.TerminalNode

+ func (s *Literal_valueContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type Module_argumentContext struct

+ func NewEmptyModule_argumentContext() *Module_argumentContext

+ func NewModule_argumentContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Module_argumentContext

+ func (*Module_argumentContext) IsModule_argumentContext()

+ func (s *Module_argumentContext) Column_def() IColumn_defContext

+ func (s *Module_argumentContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Module_argumentContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Module_argumentContext) Expr() IExprContext

+ func (s *Module_argumentContext) GetParser() antlr.Parser

+ func (s *Module_argumentContext) GetRuleContext() antlr.RuleContext

+ func (s *Module_argumentContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type Module_nameContext struct

+ func NewEmptyModule_nameContext() *Module_nameContext

+ func NewModule_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Module_nameContext

+ func (*Module_nameContext) IsModule_nameContext()

+ func (s *Module_nameContext) Any_name() IAny_nameContext

+ func (s *Module_nameContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Module_nameContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Module_nameContext) GetParser() antlr.Parser

+ func (s *Module_nameContext) GetRuleContext() antlr.RuleContext

+ func (s *Module_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type NameContext struct

+ func NewEmptyNameContext() *NameContext

+ func NewNameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *NameContext

+ func (*NameContext) IsNameContext()

+ func (s *NameContext) Any_name() IAny_nameContext

+ func (s *NameContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *NameContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *NameContext) GetParser() antlr.Parser

+ func (s *NameContext) GetRuleContext() antlr.RuleContext

+ func (s *NameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type New_table_nameContext struct

+ func NewEmptyNew_table_nameContext() *New_table_nameContext

+ func NewNew_table_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *New_table_nameContext

+ func (*New_table_nameContext) IsNew_table_nameContext()

+ func (s *New_table_nameContext) Any_name() IAny_nameContext

+ func (s *New_table_nameContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *New_table_nameContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *New_table_nameContext) GetParser() antlr.Parser

+ func (s *New_table_nameContext) GetRuleContext() antlr.RuleContext

+ func (s *New_table_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type Of_OF_fsetContext struct

+ func NewEmptyOf_OF_fsetContext() *Of_OF_fsetContext

+ func NewOf_OF_fsetContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Of_OF_fsetContext

+ func (*Of_OF_fsetContext) IsOf_OF_fsetContext()

+ func (s *Of_OF_fsetContext) COMMA() antlr.TerminalNode

+ func (s *Of_OF_fsetContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Of_OF_fsetContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Of_OF_fsetContext) GetParser() antlr.Parser

+ func (s *Of_OF_fsetContext) GetRuleContext() antlr.RuleContext

+ func (s *Of_OF_fsetContext) Signed_number() ISigned_numberContext

+ func (s *Of_OF_fsetContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type Order_by_exprContext struct

+ func NewEmptyOrder_by_exprContext() *Order_by_exprContext

+ func NewOrder_by_exprContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Order_by_exprContext

+ func (*Order_by_exprContext) IsOrder_by_exprContext()

+ func (s *Order_by_exprContext) AllExpr() []IExprContext

+ func (s *Order_by_exprContext) BY_() antlr.TerminalNode

+ func (s *Order_by_exprContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Order_by_exprContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Order_by_exprContext) Expr(i int) IExprContext

+ func (s *Order_by_exprContext) GetParser() antlr.Parser

+ func (s *Order_by_exprContext) GetRuleContext() antlr.RuleContext

+ func (s *Order_by_exprContext) ORDER_() antlr.TerminalNode

+ func (s *Order_by_exprContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type Order_by_expr_asc_descContext struct

+ func NewEmptyOrder_by_expr_asc_descContext() *Order_by_expr_asc_descContext

+ func NewOrder_by_expr_asc_descContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Order_by_expr_asc_descContext

+ func (*Order_by_expr_asc_descContext) IsOrder_by_expr_asc_descContext()

+ func (s *Order_by_expr_asc_descContext) BY_() antlr.TerminalNode

+ func (s *Order_by_expr_asc_descContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Order_by_expr_asc_descContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Order_by_expr_asc_descContext) Expr_asc_desc() IExpr_asc_descContext

+ 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) 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) 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() ISql_stmtContext

+ func (s *ParseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type Partition_byContext struct

+ func NewEmptyPartition_byContext() *Partition_byContext

+ func NewPartition_byContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Partition_byContext

+ func (*Partition_byContext) IsPartition_byContext()

+ func (s *Partition_byContext) AllExpr() []IExprContext

+ func (s *Partition_byContext) BY_() antlr.TerminalNode

+ func (s *Partition_byContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Partition_byContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Partition_byContext) Expr(i int) IExprContext

+ func (s *Partition_byContext) GetParser() antlr.Parser

+ func (s *Partition_byContext) GetRuleContext() antlr.RuleContext

+ func (s *Partition_byContext) PARTITION_() antlr.TerminalNode

+ func (s *Partition_byContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type Pragma_nameContext struct

+ func NewEmptyPragma_nameContext() *Pragma_nameContext

+ func NewPragma_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Pragma_nameContext

+ func (*Pragma_nameContext) IsPragma_nameContext()

+ func (s *Pragma_nameContext) Any_name() IAny_nameContext

+ func (s *Pragma_nameContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Pragma_nameContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Pragma_nameContext) GetParser() antlr.Parser

+ func (s *Pragma_nameContext) GetRuleContext() antlr.RuleContext

+ func (s *Pragma_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type Pragma_stmtContext struct

+ func NewEmptyPragma_stmtContext() *Pragma_stmtContext

+ func NewPragma_stmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Pragma_stmtContext

+ func (*Pragma_stmtContext) IsPragma_stmtContext()

+ func (s *Pragma_stmtContext) ASSIGN() antlr.TerminalNode

+ func (s *Pragma_stmtContext) CLOSE_PAR() antlr.TerminalNode

+ func (s *Pragma_stmtContext) DOT() antlr.TerminalNode

+ func (s *Pragma_stmtContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Pragma_stmtContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Pragma_stmtContext) GetParser() antlr.Parser

+ func (s *Pragma_stmtContext) GetRuleContext() antlr.RuleContext

+ func (s *Pragma_stmtContext) OPEN_PAR() antlr.TerminalNode

+ func (s *Pragma_stmtContext) PRAGMA_() antlr.TerminalNode

+ func (s *Pragma_stmtContext) Pragma_name() IPragma_nameContext

+ func (s *Pragma_stmtContext) Pragma_value() IPragma_valueContext

+ func (s *Pragma_stmtContext) Schema_name() ISchema_nameContext

+ func (s *Pragma_stmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type Pragma_valueContext struct

+ func NewEmptyPragma_valueContext() *Pragma_valueContext

+ func NewPragma_valueContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Pragma_valueContext

+ func (*Pragma_valueContext) IsPragma_valueContext()

+ func (s *Pragma_valueContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Pragma_valueContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Pragma_valueContext) GetParser() antlr.Parser

+ func (s *Pragma_valueContext) GetRuleContext() antlr.RuleContext

+ func (s *Pragma_valueContext) Name() INameContext

+ func (s *Pragma_valueContext) STRING_LITERAL() antlr.TerminalNode

+ func (s *Pragma_valueContext) Signed_number() ISigned_numberContext

+ func (s *Pragma_valueContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type Qualified_table_nameContext struct

+ func NewEmptyQualified_table_nameContext() *Qualified_table_nameContext

+ func NewQualified_table_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Qualified_table_nameContext

+ func (*Qualified_table_nameContext) IsQualified_table_nameContext()

+ func (s *Qualified_table_nameContext) AS_() antlr.TerminalNode

+ func (s *Qualified_table_nameContext) Alias() IAliasContext

+ func (s *Qualified_table_nameContext) BY_() antlr.TerminalNode

+ func (s *Qualified_table_nameContext) DOT() antlr.TerminalNode

+ func (s *Qualified_table_nameContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Qualified_table_nameContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Qualified_table_nameContext) GetParser() antlr.Parser

+ func (s *Qualified_table_nameContext) GetRuleContext() antlr.RuleContext

+ func (s *Qualified_table_nameContext) INDEXED_() antlr.TerminalNode

+ func (s *Qualified_table_nameContext) Index_name() IIndex_nameContext

+ func (s *Qualified_table_nameContext) NOT_() antlr.TerminalNode

+ func (s *Qualified_table_nameContext) Schema_name() ISchema_nameContext

+ func (s *Qualified_table_nameContext) Table_name() ITable_nameContext

+ func (s *Qualified_table_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type Raise_functionContext struct

+ func NewEmptyRaise_functionContext() *Raise_functionContext

+ func NewRaise_functionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Raise_functionContext

+ func (*Raise_functionContext) IsRaise_functionContext()

+ func (s *Raise_functionContext) ABORT_() antlr.TerminalNode

+ func (s *Raise_functionContext) CLOSE_PAR() antlr.TerminalNode

+ func (s *Raise_functionContext) COMMA() antlr.TerminalNode

+ func (s *Raise_functionContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Raise_functionContext) Error_message() IError_messageContext

+ func (s *Raise_functionContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Raise_functionContext) FAIL_() antlr.TerminalNode

+ func (s *Raise_functionContext) GetParser() antlr.Parser

+ func (s *Raise_functionContext) GetRuleContext() antlr.RuleContext

+ func (s *Raise_functionContext) IGNORE_() antlr.TerminalNode

+ func (s *Raise_functionContext) OPEN_PAR() antlr.TerminalNode

+ func (s *Raise_functionContext) RAISE_() antlr.TerminalNode

+ func (s *Raise_functionContext) ROLLBACK_() antlr.TerminalNode

+ func (s *Raise_functionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type Recursive__selectContext struct

+ func NewEmptyRecursive__selectContext() *Recursive__selectContext

+ func NewRecursive__selectContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Recursive__selectContext

+ func (*Recursive__selectContext) IsRecursive__selectContext()

+ func (s *Recursive__selectContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Recursive__selectContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Recursive__selectContext) GetParser() antlr.Parser

+ func (s *Recursive__selectContext) GetRuleContext() antlr.RuleContext

+ func (s *Recursive__selectContext) Select_stmt() ISelect_stmtContext

+ func (s *Recursive__selectContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type Recursive_cteContext struct

+ func NewEmptyRecursive_cteContext() *Recursive_cteContext

+ func NewRecursive_cteContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Recursive_cteContext

+ func (*Recursive_cteContext) IsRecursive_cteContext()

+ func (s *Recursive_cteContext) ALL_() antlr.TerminalNode

+ func (s *Recursive_cteContext) AS_() antlr.TerminalNode

+ func (s *Recursive_cteContext) CLOSE_PAR() antlr.TerminalNode

+ func (s *Recursive_cteContext) Cte_table_name() ICte_table_nameContext

+ func (s *Recursive_cteContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Recursive_cteContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Recursive_cteContext) GetParser() antlr.Parser

+ func (s *Recursive_cteContext) GetRuleContext() antlr.RuleContext

+ func (s *Recursive_cteContext) Initial_select() IInitial_selectContext

+ func (s *Recursive_cteContext) OPEN_PAR() antlr.TerminalNode

+ func (s *Recursive_cteContext) Recursive__select() IRecursive__selectContext

+ func (s *Recursive_cteContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ func (s *Recursive_cteContext) UNION_() antlr.TerminalNode

+ type Reindex_stmtContext struct

+ func NewEmptyReindex_stmtContext() *Reindex_stmtContext

+ func NewReindex_stmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Reindex_stmtContext

+ func (*Reindex_stmtContext) IsReindex_stmtContext()

+ func (s *Reindex_stmtContext) Collation_name() ICollation_nameContext

+ func (s *Reindex_stmtContext) DOT() antlr.TerminalNode

+ func (s *Reindex_stmtContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Reindex_stmtContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Reindex_stmtContext) GetParser() antlr.Parser

+ func (s *Reindex_stmtContext) GetRuleContext() antlr.RuleContext

+ func (s *Reindex_stmtContext) Index_name() IIndex_nameContext

+ func (s *Reindex_stmtContext) REINDEX_() antlr.TerminalNode

+ func (s *Reindex_stmtContext) Schema_name() ISchema_nameContext

+ func (s *Reindex_stmtContext) Table_name() ITable_nameContext

+ func (s *Reindex_stmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type Release_stmtContext struct

+ func NewEmptyRelease_stmtContext() *Release_stmtContext

+ func NewRelease_stmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Release_stmtContext

+ func (*Release_stmtContext) IsRelease_stmtContext()

+ func (s *Release_stmtContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Release_stmtContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Release_stmtContext) GetParser() antlr.Parser

+ func (s *Release_stmtContext) GetRuleContext() antlr.RuleContext

+ func (s *Release_stmtContext) RELEASE_() antlr.TerminalNode

+ func (s *Release_stmtContext) SAVEPOINT_() antlr.TerminalNode

+ func (s *Release_stmtContext) Savepoint_name() ISavepoint_nameContext

+ func (s *Release_stmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type Result_columnContext struct

+ func NewEmptyResult_columnContext() *Result_columnContext

+ func NewResult_columnContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Result_columnContext

+ func (*Result_columnContext) IsResult_columnContext()

+ func (s *Result_columnContext) AS_() antlr.TerminalNode

+ func (s *Result_columnContext) Column_alias() IColumn_aliasContext

+ func (s *Result_columnContext) DOT() antlr.TerminalNode

+ func (s *Result_columnContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Result_columnContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Result_columnContext) Expr() IExprContext

+ func (s *Result_columnContext) GetParser() antlr.Parser

+ func (s *Result_columnContext) GetRuleContext() antlr.RuleContext

+ func (s *Result_columnContext) STAR() antlr.TerminalNode

+ func (s *Result_columnContext) Table_name() ITable_nameContext

+ func (s *Result_columnContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type Rollback_stmtContext struct

+ func NewEmptyRollback_stmtContext() *Rollback_stmtContext

+ func NewRollback_stmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Rollback_stmtContext

+ func (*Rollback_stmtContext) IsRollback_stmtContext()

+ func (s *Rollback_stmtContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Rollback_stmtContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Rollback_stmtContext) GetParser() antlr.Parser

+ func (s *Rollback_stmtContext) GetRuleContext() antlr.RuleContext

+ func (s *Rollback_stmtContext) ROLLBACK_() antlr.TerminalNode

+ func (s *Rollback_stmtContext) SAVEPOINT_() antlr.TerminalNode

+ func (s *Rollback_stmtContext) Savepoint_name() ISavepoint_nameContext

+ func (s *Rollback_stmtContext) TO_() antlr.TerminalNode

+ func (s *Rollback_stmtContext) TRANSACTION_() antlr.TerminalNode

+ func (s *Rollback_stmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type SQLiteLexer struct

+ func NewSQLiteLexer(input antlr.CharStream) *SQLiteLexer

+ type SQLiteParser struct

+ func NewSQLiteParser(input antlr.TokenStream) *SQLiteParser

+ func (p *SQLiteParser) Aggregate_func() (localctx IAggregate_funcContext)

+ func (p *SQLiteParser) Aggregate_function_invocation() (localctx IAggregate_function_invocationContext)

+ func (p *SQLiteParser) Alias() (localctx IAliasContext)

+ func (p *SQLiteParser) Alter_table_stmt() (localctx IAlter_table_stmtContext)

+ func (p *SQLiteParser) Analyze_stmt() (localctx IAnalyze_stmtContext)

+ func (p *SQLiteParser) Any_name() (localctx IAny_nameContext)

+ func (p *SQLiteParser) Asc_desc() (localctx IAsc_descContext)

+ func (p *SQLiteParser) Attach_stmt() (localctx IAttach_stmtContext)

+ func (p *SQLiteParser) Base_window_name() (localctx IBase_window_nameContext)

+ func (p *SQLiteParser) Begin_stmt() (localctx IBegin_stmtContext)

+ func (p *SQLiteParser) Collation_name() (localctx ICollation_nameContext)

+ func (p *SQLiteParser) Column_alias() (localctx IColumn_aliasContext)

+ func (p *SQLiteParser) Column_constraint() (localctx IColumn_constraintContext)

+ func (p *SQLiteParser) Column_def() (localctx IColumn_defContext)

+ func (p *SQLiteParser) Column_name() (localctx IColumn_nameContext)

+ func (p *SQLiteParser) Column_name_list() (localctx IColumn_name_listContext)

+ func (p *SQLiteParser) Commit_stmt() (localctx ICommit_stmtContext)

+ func (p *SQLiteParser) Common_table_expression() (localctx ICommon_table_expressionContext)

+ func (p *SQLiteParser) Common_table_stmt() (localctx ICommon_table_stmtContext)

+ func (p *SQLiteParser) Compound_operator() (localctx ICompound_operatorContext)

+ func (p *SQLiteParser) Compound_select_stmt() (localctx ICompound_select_stmtContext)

+ func (p *SQLiteParser) Conflict_clause() (localctx IConflict_clauseContext)

+ func (p *SQLiteParser) Create_index_stmt() (localctx ICreate_index_stmtContext)

+ func (p *SQLiteParser) Create_table_stmt() (localctx ICreate_table_stmtContext)

+ func (p *SQLiteParser) Create_trigger_stmt() (localctx ICreate_trigger_stmtContext)

+ func (p *SQLiteParser) Create_view_stmt() (localctx ICreate_view_stmtContext)

+ func (p *SQLiteParser) Create_virtual_table_stmt() (localctx ICreate_virtual_table_stmtContext)

+ func (p *SQLiteParser) Cte_table_name() (localctx ICte_table_nameContext)

+ func (p *SQLiteParser) Default_DEFAULT__value() (localctx IDefault_DEFAULT__valueContext)

+ func (p *SQLiteParser) Delete_stmt() (localctx IDelete_stmtContext)

+ func (p *SQLiteParser) Delete_stmt_limited() (localctx IDelete_stmt_limitedContext)

+ func (p *SQLiteParser) Detach_stmt() (localctx IDetach_stmtContext)

+ func (p *SQLiteParser) Drop_stmt() (localctx IDrop_stmtContext)

+ func (p *SQLiteParser) Error_message() (localctx IError_messageContext)

+ func (p *SQLiteParser) Expr() (localctx IExprContext)

+ func (p *SQLiteParser) Expr_Sempred(localctx antlr.RuleContext, predIndex int) bool

+ func (p *SQLiteParser) Expr_asc_desc() (localctx IExpr_asc_descContext)

+ func (p *SQLiteParser) Factored_select_stmt() (localctx IFactored_select_stmtContext)

+ func (p *SQLiteParser) Filename() (localctx IFilenameContext)

+ func (p *SQLiteParser) Filter_clause() (localctx IFilter_clauseContext)

+ func (p *SQLiteParser) Foreign_key_clause() (localctx IForeign_key_clauseContext)

+ func (p *SQLiteParser) Foreign_table() (localctx IForeign_tableContext)

+ func (p *SQLiteParser) Frame_clause() (localctx IFrame_clauseContext)

+ func (p *SQLiteParser) Frame_left() (localctx IFrame_leftContext)

+ func (p *SQLiteParser) Frame_right() (localctx IFrame_rightContext)

+ func (p *SQLiteParser) Frame_single() (localctx IFrame_singleContext)

+ func (p *SQLiteParser) Frame_spec() (localctx IFrame_specContext)

+ func (p *SQLiteParser) Function_name() (localctx IFunction_nameContext)

+ func (p *SQLiteParser) Index_name() (localctx IIndex_nameContext)

+ func (p *SQLiteParser) Indexed_column() (localctx IIndexed_columnContext)

+ func (p *SQLiteParser) Initial_select() (localctx IInitial_selectContext)

+ func (p *SQLiteParser) Insert_stmt() (localctx IInsert_stmtContext)

+ func (p *SQLiteParser) Join_clause() (localctx IJoin_clauseContext)

+ func (p *SQLiteParser) Join_constraint() (localctx IJoin_constraintContext)

+ func (p *SQLiteParser) Join_operator() (localctx IJoin_operatorContext)

+ func (p *SQLiteParser) Keyword() (localctx IKeywordContext)

+ func (p *SQLiteParser) Limit_stmt() (localctx ILimit_stmtContext)

+ func (p *SQLiteParser) Literal_value() (localctx ILiteral_valueContext)

+ func (p *SQLiteParser) Module_argument() (localctx IModule_argumentContext)

+ func (p *SQLiteParser) Module_name() (localctx IModule_nameContext)

+ func (p *SQLiteParser) Name() (localctx INameContext)

+ func (p *SQLiteParser) New_table_name() (localctx INew_table_nameContext)

+ func (p *SQLiteParser) Of_OF_fset() (localctx IOf_OF_fsetContext)

+ func (p *SQLiteParser) Order_by_expr() (localctx IOrder_by_exprContext)

+ func (p *SQLiteParser) Order_by_expr_asc_desc() (localctx IOrder_by_expr_asc_descContext)

+ func (p *SQLiteParser) Order_by_stmt() (localctx IOrder_by_stmtContext)

+ func (p *SQLiteParser) Ordering_term() (localctx IOrdering_termContext)

+ func (p *SQLiteParser) Over_clause() (localctx IOver_clauseContext)

+ func (p *SQLiteParser) Parse() (localctx IParseContext)

+ func (p *SQLiteParser) Partition_by() (localctx IPartition_byContext)

+ func (p *SQLiteParser) Pragma_name() (localctx IPragma_nameContext)

+ func (p *SQLiteParser) Pragma_stmt() (localctx IPragma_stmtContext)

+ func (p *SQLiteParser) Pragma_value() (localctx IPragma_valueContext)

+ func (p *SQLiteParser) Qualified_table_name() (localctx IQualified_table_nameContext)

+ func (p *SQLiteParser) Raise_function() (localctx IRaise_functionContext)

+ func (p *SQLiteParser) Recursive__select() (localctx IRecursive__selectContext)

+ func (p *SQLiteParser) Recursive_cte() (localctx IRecursive_cteContext)

+ func (p *SQLiteParser) Reindex_stmt() (localctx IReindex_stmtContext)

+ func (p *SQLiteParser) Release_stmt() (localctx IRelease_stmtContext)

+ func (p *SQLiteParser) Result_column() (localctx IResult_columnContext)

+ func (p *SQLiteParser) Rollback_stmt() (localctx IRollback_stmtContext)

+ func (p *SQLiteParser) Savepoint_name() (localctx ISavepoint_nameContext)

+ func (p *SQLiteParser) Savepoint_stmt() (localctx ISavepoint_stmtContext)

+ func (p *SQLiteParser) Schema_name() (localctx ISchema_nameContext)

+ func (p *SQLiteParser) Select_core() (localctx ISelect_coreContext)

+ func (p *SQLiteParser) Select_stmt() (localctx ISelect_stmtContext)

+ func (p *SQLiteParser) Sempred(localctx antlr.RuleContext, ruleIndex, predIndex int) bool

+ func (p *SQLiteParser) Signed_number() (localctx ISigned_numberContext)

+ func (p *SQLiteParser) Simple_func() (localctx ISimple_funcContext)

+ func (p *SQLiteParser) Simple_function_invocation() (localctx ISimple_function_invocationContext)

+ func (p *SQLiteParser) Simple_select_stmt() (localctx ISimple_select_stmtContext)

+ func (p *SQLiteParser) Sql_stmt() (localctx ISql_stmtContext)

+ func (p *SQLiteParser) Table_alias() (localctx ITable_aliasContext)

+ func (p *SQLiteParser) Table_constraint() (localctx ITable_constraintContext)

+ func (p *SQLiteParser) Table_function_name() (localctx ITable_function_nameContext)

+ func (p *SQLiteParser) Table_name() (localctx ITable_nameContext)

+ func (p *SQLiteParser) Table_or_index_name() (localctx ITable_or_index_nameContext)

+ func (p *SQLiteParser) Table_or_subquery() (localctx ITable_or_subqueryContext)

+ func (p *SQLiteParser) Transaction_name() (localctx ITransaction_nameContext)

+ func (p *SQLiteParser) Trigger_name() (localctx ITrigger_nameContext)

+ func (p *SQLiteParser) Type_name() (localctx IType_nameContext)

+ func (p *SQLiteParser) Unary_operator() (localctx IUnary_operatorContext)

+ func (p *SQLiteParser) Update_stmt() (localctx IUpdate_stmtContext)

+ func (p *SQLiteParser) Update_stmt_limited() (localctx IUpdate_stmt_limitedContext)

+ func (p *SQLiteParser) Upsert_clause() (localctx IUpsert_clauseContext)

+ func (p *SQLiteParser) Vacuum_stmt() (localctx IVacuum_stmtContext)

+ func (p *SQLiteParser) View_name() (localctx IView_nameContext)

+ func (p *SQLiteParser) Window_defn() (localctx IWindow_defnContext)

+ func (p *SQLiteParser) Window_function() (localctx IWindow_functionContext)

+ func (p *SQLiteParser) Window_function_invocation() (localctx IWindow_function_invocationContext)

+ func (p *SQLiteParser) Window_name() (localctx IWindow_nameContext)

+ func (p *SQLiteParser) With_clause() (localctx IWith_clauseContext)

+ type SQLiteParserListener interface

+ EnterAggregate_func func(c *Aggregate_funcContext)

+ EnterAggregate_function_invocation func(c *Aggregate_function_invocationContext)

+ EnterAlias func(c *AliasContext)

+ EnterAlter_table_stmt func(c *Alter_table_stmtContext)

+ EnterAnalyze_stmt func(c *Analyze_stmtContext)

+ EnterAny_name func(c *Any_nameContext)

+ EnterAsc_desc func(c *Asc_descContext)

+ EnterAttach_stmt func(c *Attach_stmtContext)

+ EnterBase_window_name func(c *Base_window_nameContext)

+ EnterBegin_stmt func(c *Begin_stmtContext)

+ EnterCollation_name func(c *Collation_nameContext)

+ EnterColumn_alias func(c *Column_aliasContext)

+ EnterColumn_constraint func(c *Column_constraintContext)

+ EnterColumn_def func(c *Column_defContext)

+ EnterColumn_name func(c *Column_nameContext)

+ EnterColumn_name_list func(c *Column_name_listContext)

+ EnterCommit_stmt func(c *Commit_stmtContext)

+ EnterCommon_table_expression func(c *Common_table_expressionContext)

+ EnterCommon_table_stmt func(c *Common_table_stmtContext)

+ EnterCompound_operator func(c *Compound_operatorContext)

+ EnterCompound_select_stmt func(c *Compound_select_stmtContext)

+ EnterConflict_clause func(c *Conflict_clauseContext)

+ EnterCreate_index_stmt func(c *Create_index_stmtContext)

+ EnterCreate_table_stmt func(c *Create_table_stmtContext)

+ EnterCreate_trigger_stmt func(c *Create_trigger_stmtContext)

+ EnterCreate_view_stmt func(c *Create_view_stmtContext)

+ EnterCreate_virtual_table_stmt func(c *Create_virtual_table_stmtContext)

+ EnterCte_table_name func(c *Cte_table_nameContext)

+ EnterDefault_DEFAULT__value func(c *Default_DEFAULT__valueContext)

+ EnterDelete_stmt func(c *Delete_stmtContext)

+ EnterDelete_stmt_limited func(c *Delete_stmt_limitedContext)

+ EnterDetach_stmt func(c *Detach_stmtContext)

+ EnterDrop_stmt func(c *Drop_stmtContext)

+ EnterError_message func(c *Error_messageContext)

+ EnterExpr func(c *ExprContext)

+ EnterExpr_asc_desc func(c *Expr_asc_descContext)

+ EnterFactored_select_stmt func(c *Factored_select_stmtContext)

+ EnterFilename func(c *FilenameContext)

+ EnterFilter_clause func(c *Filter_clauseContext)

+ EnterForeign_key_clause func(c *Foreign_key_clauseContext)

+ EnterForeign_table func(c *Foreign_tableContext)

+ EnterFrame_clause func(c *Frame_clauseContext)

+ EnterFrame_left func(c *Frame_leftContext)

+ EnterFrame_right func(c *Frame_rightContext)

+ EnterFrame_single func(c *Frame_singleContext)

+ EnterFrame_spec func(c *Frame_specContext)

+ EnterFunction_name func(c *Function_nameContext)

+ EnterIndex_name func(c *Index_nameContext)

+ EnterIndexed_column func(c *Indexed_columnContext)

+ EnterInitial_select func(c *Initial_selectContext)

+ EnterInsert_stmt func(c *Insert_stmtContext)

+ EnterJoin_clause func(c *Join_clauseContext)

+ EnterJoin_constraint func(c *Join_constraintContext)

+ EnterJoin_operator func(c *Join_operatorContext)

+ EnterKeyword func(c *KeywordContext)

+ EnterLimit_stmt func(c *Limit_stmtContext)

+ EnterLiteral_value func(c *Literal_valueContext)

+ EnterModule_argument func(c *Module_argumentContext)

+ EnterModule_name func(c *Module_nameContext)

+ EnterName func(c *NameContext)

+ EnterNew_table_name func(c *New_table_nameContext)

+ EnterOf_OF_fset func(c *Of_OF_fsetContext)

+ EnterOrder_by_expr func(c *Order_by_exprContext)

+ EnterOrder_by_expr_asc_desc func(c *Order_by_expr_asc_descContext)

+ EnterOrder_by_stmt func(c *Order_by_stmtContext)

+ EnterOrdering_term func(c *Ordering_termContext)

+ EnterOver_clause func(c *Over_clauseContext)

+ EnterParse func(c *ParseContext)

+ EnterPartition_by func(c *Partition_byContext)

+ EnterPragma_name func(c *Pragma_nameContext)

+ EnterPragma_stmt func(c *Pragma_stmtContext)

+ EnterPragma_value func(c *Pragma_valueContext)

+ EnterQualified_table_name func(c *Qualified_table_nameContext)

+ EnterRaise_function func(c *Raise_functionContext)

+ EnterRecursive__select func(c *Recursive__selectContext)

+ EnterRecursive_cte func(c *Recursive_cteContext)

+ EnterReindex_stmt func(c *Reindex_stmtContext)

+ EnterRelease_stmt func(c *Release_stmtContext)

+ EnterResult_column func(c *Result_columnContext)

+ EnterRollback_stmt func(c *Rollback_stmtContext)

+ EnterSavepoint_name func(c *Savepoint_nameContext)

+ EnterSavepoint_stmt func(c *Savepoint_stmtContext)

+ EnterSchema_name func(c *Schema_nameContext)

+ EnterSelect_core func(c *Select_coreContext)

+ EnterSelect_stmt func(c *Select_stmtContext)

+ EnterSigned_number func(c *Signed_numberContext)

+ EnterSimple_func func(c *Simple_funcContext)

+ EnterSimple_function_invocation func(c *Simple_function_invocationContext)

+ EnterSimple_select_stmt func(c *Simple_select_stmtContext)

+ EnterSql_stmt func(c *Sql_stmtContext)

+ EnterTable_alias func(c *Table_aliasContext)

+ EnterTable_constraint func(c *Table_constraintContext)

+ EnterTable_function_name func(c *Table_function_nameContext)

+ EnterTable_name func(c *Table_nameContext)

+ EnterTable_or_index_name func(c *Table_or_index_nameContext)

+ EnterTable_or_subquery func(c *Table_or_subqueryContext)

+ EnterTransaction_name func(c *Transaction_nameContext)

+ EnterTrigger_name func(c *Trigger_nameContext)

+ EnterType_name func(c *Type_nameContext)

+ EnterUnary_operator func(c *Unary_operatorContext)

+ EnterUpdate_stmt func(c *Update_stmtContext)

+ EnterUpdate_stmt_limited func(c *Update_stmt_limitedContext)

+ EnterUpsert_clause func(c *Upsert_clauseContext)

+ EnterVacuum_stmt func(c *Vacuum_stmtContext)

+ EnterView_name func(c *View_nameContext)

+ EnterWindow_defn func(c *Window_defnContext)

+ EnterWindow_function func(c *Window_functionContext)

+ EnterWindow_function_invocation func(c *Window_function_invocationContext)

+ EnterWindow_name func(c *Window_nameContext)

+ EnterWith_clause func(c *With_clauseContext)

+ ExitAggregate_func func(c *Aggregate_funcContext)

+ ExitAggregate_function_invocation func(c *Aggregate_function_invocationContext)

+ ExitAlias func(c *AliasContext)

+ ExitAlter_table_stmt func(c *Alter_table_stmtContext)

+ ExitAnalyze_stmt func(c *Analyze_stmtContext)

+ ExitAny_name func(c *Any_nameContext)

+ ExitAsc_desc func(c *Asc_descContext)

+ ExitAttach_stmt func(c *Attach_stmtContext)

+ ExitBase_window_name func(c *Base_window_nameContext)

+ ExitBegin_stmt func(c *Begin_stmtContext)

+ ExitCollation_name func(c *Collation_nameContext)

+ ExitColumn_alias func(c *Column_aliasContext)

+ ExitColumn_constraint func(c *Column_constraintContext)

+ ExitColumn_def func(c *Column_defContext)

+ ExitColumn_name func(c *Column_nameContext)

+ ExitColumn_name_list func(c *Column_name_listContext)

+ ExitCommit_stmt func(c *Commit_stmtContext)

+ ExitCommon_table_expression func(c *Common_table_expressionContext)

+ ExitCommon_table_stmt func(c *Common_table_stmtContext)

+ ExitCompound_operator func(c *Compound_operatorContext)

+ ExitCompound_select_stmt func(c *Compound_select_stmtContext)

+ ExitConflict_clause func(c *Conflict_clauseContext)

+ ExitCreate_index_stmt func(c *Create_index_stmtContext)

+ ExitCreate_table_stmt func(c *Create_table_stmtContext)

+ ExitCreate_trigger_stmt func(c *Create_trigger_stmtContext)

+ ExitCreate_view_stmt func(c *Create_view_stmtContext)

+ ExitCreate_virtual_table_stmt func(c *Create_virtual_table_stmtContext)

+ ExitCte_table_name func(c *Cte_table_nameContext)

+ ExitDefault_DEFAULT__value func(c *Default_DEFAULT__valueContext)

+ ExitDelete_stmt func(c *Delete_stmtContext)

+ ExitDelete_stmt_limited func(c *Delete_stmt_limitedContext)

+ ExitDetach_stmt func(c *Detach_stmtContext)

+ ExitDrop_stmt func(c *Drop_stmtContext)

+ ExitError_message func(c *Error_messageContext)

+ ExitExpr func(c *ExprContext)

+ ExitExpr_asc_desc func(c *Expr_asc_descContext)

+ ExitFactored_select_stmt func(c *Factored_select_stmtContext)

+ ExitFilename func(c *FilenameContext)

+ ExitFilter_clause func(c *Filter_clauseContext)

+ ExitForeign_key_clause func(c *Foreign_key_clauseContext)

+ ExitForeign_table func(c *Foreign_tableContext)

+ ExitFrame_clause func(c *Frame_clauseContext)

+ ExitFrame_left func(c *Frame_leftContext)

+ ExitFrame_right func(c *Frame_rightContext)

+ ExitFrame_single func(c *Frame_singleContext)

+ ExitFrame_spec func(c *Frame_specContext)

+ ExitFunction_name func(c *Function_nameContext)

+ ExitIndex_name func(c *Index_nameContext)

+ ExitIndexed_column func(c *Indexed_columnContext)

+ ExitInitial_select func(c *Initial_selectContext)

+ ExitInsert_stmt func(c *Insert_stmtContext)

+ ExitJoin_clause func(c *Join_clauseContext)

+ ExitJoin_constraint func(c *Join_constraintContext)

+ ExitJoin_operator func(c *Join_operatorContext)

+ ExitKeyword func(c *KeywordContext)

+ ExitLimit_stmt func(c *Limit_stmtContext)

+ ExitLiteral_value func(c *Literal_valueContext)

+ ExitModule_argument func(c *Module_argumentContext)

+ ExitModule_name func(c *Module_nameContext)

+ ExitName func(c *NameContext)

+ ExitNew_table_name func(c *New_table_nameContext)

+ ExitOf_OF_fset func(c *Of_OF_fsetContext)

+ ExitOrder_by_expr func(c *Order_by_exprContext)

+ ExitOrder_by_expr_asc_desc func(c *Order_by_expr_asc_descContext)

+ ExitOrder_by_stmt func(c *Order_by_stmtContext)

+ ExitOrdering_term func(c *Ordering_termContext)

+ ExitOver_clause func(c *Over_clauseContext)

+ ExitParse func(c *ParseContext)

+ ExitPartition_by func(c *Partition_byContext)

+ ExitPragma_name func(c *Pragma_nameContext)

+ ExitPragma_stmt func(c *Pragma_stmtContext)

+ ExitPragma_value func(c *Pragma_valueContext)

+ ExitQualified_table_name func(c *Qualified_table_nameContext)

+ ExitRaise_function func(c *Raise_functionContext)

+ ExitRecursive__select func(c *Recursive__selectContext)

+ ExitRecursive_cte func(c *Recursive_cteContext)

+ ExitReindex_stmt func(c *Reindex_stmtContext)

+ ExitRelease_stmt func(c *Release_stmtContext)

+ ExitResult_column func(c *Result_columnContext)

+ ExitRollback_stmt func(c *Rollback_stmtContext)

+ ExitSavepoint_name func(c *Savepoint_nameContext)

+ ExitSavepoint_stmt func(c *Savepoint_stmtContext)

+ ExitSchema_name func(c *Schema_nameContext)

+ ExitSelect_core func(c *Select_coreContext)

+ ExitSelect_stmt func(c *Select_stmtContext)

+ ExitSigned_number func(c *Signed_numberContext)

+ ExitSimple_func func(c *Simple_funcContext)

+ ExitSimple_function_invocation func(c *Simple_function_invocationContext)

+ ExitSimple_select_stmt func(c *Simple_select_stmtContext)

+ ExitSql_stmt func(c *Sql_stmtContext)

+ ExitTable_alias func(c *Table_aliasContext)

+ ExitTable_constraint func(c *Table_constraintContext)

+ ExitTable_function_name func(c *Table_function_nameContext)

+ ExitTable_name func(c *Table_nameContext)

+ ExitTable_or_index_name func(c *Table_or_index_nameContext)

+ ExitTable_or_subquery func(c *Table_or_subqueryContext)

+ ExitTransaction_name func(c *Transaction_nameContext)

+ ExitTrigger_name func(c *Trigger_nameContext)

+ ExitType_name func(c *Type_nameContext)

+ ExitUnary_operator func(c *Unary_operatorContext)

+ ExitUpdate_stmt func(c *Update_stmtContext)

+ ExitUpdate_stmt_limited func(c *Update_stmt_limitedContext)

+ ExitUpsert_clause func(c *Upsert_clauseContext)

+ ExitVacuum_stmt func(c *Vacuum_stmtContext)

+ ExitView_name func(c *View_nameContext)

+ ExitWindow_defn func(c *Window_defnContext)

+ ExitWindow_function func(c *Window_functionContext)

+ ExitWindow_function_invocation func(c *Window_function_invocationContext)

+ ExitWindow_name func(c *Window_nameContext)

+ ExitWith_clause func(c *With_clauseContext)

+ type Savepoint_nameContext struct

+ func NewEmptySavepoint_nameContext() *Savepoint_nameContext

+ func NewSavepoint_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Savepoint_nameContext

+ func (*Savepoint_nameContext) IsSavepoint_nameContext()

+ func (s *Savepoint_nameContext) Any_name() IAny_nameContext

+ func (s *Savepoint_nameContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Savepoint_nameContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Savepoint_nameContext) GetParser() antlr.Parser

+ func (s *Savepoint_nameContext) GetRuleContext() antlr.RuleContext

+ func (s *Savepoint_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type Savepoint_stmtContext struct

+ func NewEmptySavepoint_stmtContext() *Savepoint_stmtContext

+ func NewSavepoint_stmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Savepoint_stmtContext

+ func (*Savepoint_stmtContext) IsSavepoint_stmtContext()

+ func (s *Savepoint_stmtContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Savepoint_stmtContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Savepoint_stmtContext) GetParser() antlr.Parser

+ func (s *Savepoint_stmtContext) GetRuleContext() antlr.RuleContext

+ func (s *Savepoint_stmtContext) SAVEPOINT_() antlr.TerminalNode

+ func (s *Savepoint_stmtContext) Savepoint_name() ISavepoint_nameContext

+ func (s *Savepoint_stmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type Schema_nameContext struct

+ func NewEmptySchema_nameContext() *Schema_nameContext

+ func NewSchema_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Schema_nameContext

+ func (*Schema_nameContext) IsSchema_nameContext()

+ func (s *Schema_nameContext) Any_name() IAny_nameContext

+ func (s *Schema_nameContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Schema_nameContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Schema_nameContext) GetParser() antlr.Parser

+ func (s *Schema_nameContext) GetRuleContext() antlr.RuleContext

+ func (s *Schema_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type Select_coreContext struct

+ func NewEmptySelect_coreContext() *Select_coreContext

+ func NewSelect_coreContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Select_coreContext

+ func (*Select_coreContext) IsSelect_coreContext()

+ func (s *Select_coreContext) ALL_() antlr.TerminalNode

+ func (s *Select_coreContext) AS_(i int) antlr.TerminalNode

+ func (s *Select_coreContext) AllAS_() []antlr.TerminalNode

+ func (s *Select_coreContext) AllCLOSE_PAR() []antlr.TerminalNode

+ func (s *Select_coreContext) AllCOMMA() []antlr.TerminalNode

+ func (s *Select_coreContext) AllExpr() []IExprContext

+ func (s *Select_coreContext) AllOPEN_PAR() []antlr.TerminalNode

+ func (s *Select_coreContext) AllResult_column() []IResult_columnContext

+ func (s *Select_coreContext) AllTable_or_subquery() []ITable_or_subqueryContext

+ func (s *Select_coreContext) AllWindow_defn() []IWindow_defnContext

+ func (s *Select_coreContext) AllWindow_name() []IWindow_nameContext

+ func (s *Select_coreContext) BY_() antlr.TerminalNode

+ func (s *Select_coreContext) CLOSE_PAR(i int) antlr.TerminalNode

+ func (s *Select_coreContext) COMMA(i int) antlr.TerminalNode

+ func (s *Select_coreContext) DISTINCT_() antlr.TerminalNode

+ func (s *Select_coreContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Select_coreContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Select_coreContext) Expr(i int) IExprContext

+ func (s *Select_coreContext) FROM_() antlr.TerminalNode

+ func (s *Select_coreContext) GROUP_() antlr.TerminalNode

+ func (s *Select_coreContext) GetParser() antlr.Parser

+ func (s *Select_coreContext) GetRuleContext() antlr.RuleContext

+ func (s *Select_coreContext) HAVING_() antlr.TerminalNode

+ func (s *Select_coreContext) Join_clause() IJoin_clauseContext

+ func (s *Select_coreContext) OPEN_PAR(i int) antlr.TerminalNode

+ func (s *Select_coreContext) Result_column(i int) IResult_columnContext

+ func (s *Select_coreContext) SELECT_() antlr.TerminalNode

+ func (s *Select_coreContext) Table_or_subquery(i int) ITable_or_subqueryContext

+ func (s *Select_coreContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ func (s *Select_coreContext) VALUES_() antlr.TerminalNode

+ func (s *Select_coreContext) WHERE_() antlr.TerminalNode

+ func (s *Select_coreContext) WINDOW_() antlr.TerminalNode

+ func (s *Select_coreContext) Window_defn(i int) IWindow_defnContext

+ func (s *Select_coreContext) Window_name(i int) IWindow_nameContext

+ type Select_stmtContext struct

+ func NewEmptySelect_stmtContext() *Select_stmtContext

+ func NewSelect_stmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Select_stmtContext

+ func (*Select_stmtContext) IsSelect_stmtContext()

+ func (s *Select_stmtContext) AllCompound_operator() []ICompound_operatorContext

+ func (s *Select_stmtContext) AllSelect_core() []ISelect_coreContext

+ func (s *Select_stmtContext) Common_table_stmt() ICommon_table_stmtContext

+ func (s *Select_stmtContext) Compound_operator(i int) ICompound_operatorContext

+ func (s *Select_stmtContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Select_stmtContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Select_stmtContext) GetParser() antlr.Parser

+ func (s *Select_stmtContext) GetRuleContext() antlr.RuleContext

+ func (s *Select_stmtContext) Limit_stmt() ILimit_stmtContext

+ func (s *Select_stmtContext) Order_by_stmt() IOrder_by_stmtContext

+ func (s *Select_stmtContext) Select_core(i int) ISelect_coreContext

+ func (s *Select_stmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type Signed_numberContext struct

+ func NewEmptySigned_numberContext() *Signed_numberContext

+ func NewSigned_numberContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Signed_numberContext

+ func (*Signed_numberContext) IsSigned_numberContext()

+ func (s *Signed_numberContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Signed_numberContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Signed_numberContext) GetParser() antlr.Parser

+ func (s *Signed_numberContext) GetRuleContext() antlr.RuleContext

+ func (s *Signed_numberContext) MINUS() antlr.TerminalNode

+ func (s *Signed_numberContext) NUMERIC_LITERAL() antlr.TerminalNode

+ func (s *Signed_numberContext) PLUS() antlr.TerminalNode

+ func (s *Signed_numberContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type Simple_funcContext struct

+ func NewEmptySimple_funcContext() *Simple_funcContext

+ func NewSimple_funcContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Simple_funcContext

+ func (*Simple_funcContext) IsSimple_funcContext()

+ func (s *Simple_funcContext) Any_name() IAny_nameContext

+ func (s *Simple_funcContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Simple_funcContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Simple_funcContext) GetParser() antlr.Parser

+ func (s *Simple_funcContext) GetRuleContext() antlr.RuleContext

+ func (s *Simple_funcContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type Simple_function_invocationContext struct

+ func NewEmptySimple_function_invocationContext() *Simple_function_invocationContext

+ func NewSimple_function_invocationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Simple_function_invocationContext

+ func (*Simple_function_invocationContext) IsSimple_function_invocationContext()

+ func (s *Simple_function_invocationContext) AllCOMMA() []antlr.TerminalNode

+ func (s *Simple_function_invocationContext) AllExpr() []IExprContext

+ func (s *Simple_function_invocationContext) CLOSE_PAR() antlr.TerminalNode

+ func (s *Simple_function_invocationContext) COMMA(i int) antlr.TerminalNode

+ func (s *Simple_function_invocationContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Simple_function_invocationContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Simple_function_invocationContext) Expr(i int) IExprContext

+ func (s *Simple_function_invocationContext) GetParser() antlr.Parser

+ func (s *Simple_function_invocationContext) GetRuleContext() antlr.RuleContext

+ func (s *Simple_function_invocationContext) OPEN_PAR() antlr.TerminalNode

+ func (s *Simple_function_invocationContext) STAR() antlr.TerminalNode

+ func (s *Simple_function_invocationContext) Simple_func() ISimple_funcContext

+ func (s *Simple_function_invocationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type Simple_select_stmtContext struct

+ func NewEmptySimple_select_stmtContext() *Simple_select_stmtContext

+ func NewSimple_select_stmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Simple_select_stmtContext

+ func (*Simple_select_stmtContext) IsSimple_select_stmtContext()

+ func (s *Simple_select_stmtContext) Common_table_stmt() ICommon_table_stmtContext

+ func (s *Simple_select_stmtContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Simple_select_stmtContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Simple_select_stmtContext) GetParser() antlr.Parser

+ func (s *Simple_select_stmtContext) GetRuleContext() antlr.RuleContext

+ func (s *Simple_select_stmtContext) Limit_stmt() ILimit_stmtContext

+ func (s *Simple_select_stmtContext) Order_by_stmt() IOrder_by_stmtContext

+ func (s *Simple_select_stmtContext) Select_core() ISelect_coreContext

+ func (s *Simple_select_stmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type Sql_stmtContext struct

+ func NewEmptySql_stmtContext() *Sql_stmtContext

+ func NewSql_stmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Sql_stmtContext

+ func (*Sql_stmtContext) IsSql_stmtContext()

+ func (s *Sql_stmtContext) Alter_table_stmt() IAlter_table_stmtContext

+ func (s *Sql_stmtContext) Analyze_stmt() IAnalyze_stmtContext

+ func (s *Sql_stmtContext) Attach_stmt() IAttach_stmtContext

+ func (s *Sql_stmtContext) Begin_stmt() IBegin_stmtContext

+ func (s *Sql_stmtContext) Commit_stmt() ICommit_stmtContext

+ func (s *Sql_stmtContext) Create_index_stmt() ICreate_index_stmtContext

+ func (s *Sql_stmtContext) Create_table_stmt() ICreate_table_stmtContext

+ func (s *Sql_stmtContext) Create_trigger_stmt() ICreate_trigger_stmtContext

+ func (s *Sql_stmtContext) Create_view_stmt() ICreate_view_stmtContext

+ func (s *Sql_stmtContext) Create_virtual_table_stmt() ICreate_virtual_table_stmtContext

+ func (s *Sql_stmtContext) Delete_stmt() IDelete_stmtContext

+ func (s *Sql_stmtContext) Delete_stmt_limited() IDelete_stmt_limitedContext

+ func (s *Sql_stmtContext) Detach_stmt() IDetach_stmtContext

+ func (s *Sql_stmtContext) Drop_stmt() IDrop_stmtContext

+ func (s *Sql_stmtContext) EXPLAIN_() antlr.TerminalNode

+ func (s *Sql_stmtContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Sql_stmtContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Sql_stmtContext) GetParser() antlr.Parser

+ func (s *Sql_stmtContext) GetRuleContext() antlr.RuleContext

+ func (s *Sql_stmtContext) Insert_stmt() IInsert_stmtContext

+ func (s *Sql_stmtContext) PLAN_() antlr.TerminalNode

+ func (s *Sql_stmtContext) Pragma_stmt() IPragma_stmtContext

+ func (s *Sql_stmtContext) QUERY_() antlr.TerminalNode

+ func (s *Sql_stmtContext) Reindex_stmt() IReindex_stmtContext

+ func (s *Sql_stmtContext) Release_stmt() IRelease_stmtContext

+ func (s *Sql_stmtContext) Rollback_stmt() IRollback_stmtContext

+ func (s *Sql_stmtContext) Savepoint_stmt() ISavepoint_stmtContext

+ func (s *Sql_stmtContext) Select_stmt() ISelect_stmtContext

+ func (s *Sql_stmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ func (s *Sql_stmtContext) Update_stmt() IUpdate_stmtContext

+ func (s *Sql_stmtContext) Update_stmt_limited() IUpdate_stmt_limitedContext

+ func (s *Sql_stmtContext) Vacuum_stmt() IVacuum_stmtContext

+ type Table_aliasContext struct

+ func NewEmptyTable_aliasContext() *Table_aliasContext

+ func NewTable_aliasContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Table_aliasContext

+ func (*Table_aliasContext) IsTable_aliasContext()

+ func (s *Table_aliasContext) Any_name() IAny_nameContext

+ func (s *Table_aliasContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Table_aliasContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Table_aliasContext) GetParser() antlr.Parser

+ func (s *Table_aliasContext) GetRuleContext() antlr.RuleContext

+ func (s *Table_aliasContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type Table_constraintContext struct

+ func NewEmptyTable_constraintContext() *Table_constraintContext

+ func NewTable_constraintContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Table_constraintContext

+ func (*Table_constraintContext) IsTable_constraintContext()

+ func (s *Table_constraintContext) AllCOMMA() []antlr.TerminalNode

+ func (s *Table_constraintContext) AllColumn_name() []IColumn_nameContext

+ func (s *Table_constraintContext) AllIndexed_column() []IIndexed_columnContext

+ func (s *Table_constraintContext) CHECK_() antlr.TerminalNode

+ func (s *Table_constraintContext) CLOSE_PAR() antlr.TerminalNode

+ func (s *Table_constraintContext) COMMA(i int) antlr.TerminalNode

+ func (s *Table_constraintContext) CONSTRAINT_() antlr.TerminalNode

+ func (s *Table_constraintContext) Column_name(i int) IColumn_nameContext

+ func (s *Table_constraintContext) Conflict_clause() IConflict_clauseContext

+ func (s *Table_constraintContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Table_constraintContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Table_constraintContext) Expr() IExprContext

+ func (s *Table_constraintContext) FOREIGN_() antlr.TerminalNode

+ func (s *Table_constraintContext) Foreign_key_clause() IForeign_key_clauseContext

+ func (s *Table_constraintContext) GetParser() antlr.Parser

+ func (s *Table_constraintContext) GetRuleContext() antlr.RuleContext

+ func (s *Table_constraintContext) Indexed_column(i int) IIndexed_columnContext

+ func (s *Table_constraintContext) KEY_() antlr.TerminalNode

+ func (s *Table_constraintContext) Name() INameContext

+ func (s *Table_constraintContext) OPEN_PAR() antlr.TerminalNode

+ func (s *Table_constraintContext) PRIMARY_() antlr.TerminalNode

+ func (s *Table_constraintContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ func (s *Table_constraintContext) UNIQUE_() antlr.TerminalNode

+ type Table_function_nameContext struct

+ func NewEmptyTable_function_nameContext() *Table_function_nameContext

+ func NewTable_function_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Table_function_nameContext

+ func (*Table_function_nameContext) IsTable_function_nameContext()

+ func (s *Table_function_nameContext) Any_name() IAny_nameContext

+ func (s *Table_function_nameContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Table_function_nameContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Table_function_nameContext) GetParser() antlr.Parser

+ func (s *Table_function_nameContext) GetRuleContext() antlr.RuleContext

+ func (s *Table_function_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type Table_nameContext struct

+ func NewEmptyTable_nameContext() *Table_nameContext

+ func NewTable_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Table_nameContext

+ func (*Table_nameContext) IsTable_nameContext()

+ func (s *Table_nameContext) Any_name() IAny_nameContext

+ func (s *Table_nameContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Table_nameContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Table_nameContext) GetParser() antlr.Parser

+ func (s *Table_nameContext) GetRuleContext() antlr.RuleContext

+ func (s *Table_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type Table_or_index_nameContext struct

+ func NewEmptyTable_or_index_nameContext() *Table_or_index_nameContext

+ func NewTable_or_index_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Table_or_index_nameContext

+ func (*Table_or_index_nameContext) IsTable_or_index_nameContext()

+ func (s *Table_or_index_nameContext) Any_name() IAny_nameContext

+ func (s *Table_or_index_nameContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Table_or_index_nameContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Table_or_index_nameContext) GetParser() antlr.Parser

+ func (s *Table_or_index_nameContext) GetRuleContext() antlr.RuleContext

+ func (s *Table_or_index_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type Table_or_subqueryContext struct

+ func NewEmptyTable_or_subqueryContext() *Table_or_subqueryContext

+ func NewTable_or_subqueryContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Table_or_subqueryContext

+ func (*Table_or_subqueryContext) IsTable_or_subqueryContext()

+ func (s *Table_or_subqueryContext) AS_() antlr.TerminalNode

+ func (s *Table_or_subqueryContext) AllCOMMA() []antlr.TerminalNode

+ func (s *Table_or_subqueryContext) AllExpr() []IExprContext

+ func (s *Table_or_subqueryContext) AllTable_or_subquery() []ITable_or_subqueryContext

+ func (s *Table_or_subqueryContext) BY_() antlr.TerminalNode

+ func (s *Table_or_subqueryContext) CLOSE_PAR() antlr.TerminalNode

+ func (s *Table_or_subqueryContext) COMMA(i int) antlr.TerminalNode

+ func (s *Table_or_subqueryContext) DOT() antlr.TerminalNode

+ func (s *Table_or_subqueryContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Table_or_subqueryContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Table_or_subqueryContext) Expr(i int) IExprContext

+ func (s *Table_or_subqueryContext) GetParser() antlr.Parser

+ func (s *Table_or_subqueryContext) GetRuleContext() antlr.RuleContext

+ func (s *Table_or_subqueryContext) INDEXED_() antlr.TerminalNode

+ func (s *Table_or_subqueryContext) Index_name() IIndex_nameContext

+ func (s *Table_or_subqueryContext) Join_clause() IJoin_clauseContext

+ func (s *Table_or_subqueryContext) NOT_() antlr.TerminalNode

+ func (s *Table_or_subqueryContext) OPEN_PAR() antlr.TerminalNode

+ func (s *Table_or_subqueryContext) Schema_name() ISchema_nameContext

+ func (s *Table_or_subqueryContext) Select_stmt() ISelect_stmtContext

+ func (s *Table_or_subqueryContext) Table_alias() ITable_aliasContext

+ func (s *Table_or_subqueryContext) Table_function_name() ITable_function_nameContext

+ func (s *Table_or_subqueryContext) Table_name() ITable_nameContext

+ func (s *Table_or_subqueryContext) Table_or_subquery(i int) ITable_or_subqueryContext

+ func (s *Table_or_subqueryContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type Transaction_nameContext struct

+ func NewEmptyTransaction_nameContext() *Transaction_nameContext

+ func NewTransaction_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Transaction_nameContext

+ func (*Transaction_nameContext) IsTransaction_nameContext()

+ func (s *Transaction_nameContext) Any_name() IAny_nameContext

+ func (s *Transaction_nameContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Transaction_nameContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Transaction_nameContext) GetParser() antlr.Parser

+ func (s *Transaction_nameContext) GetRuleContext() antlr.RuleContext

+ func (s *Transaction_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type Trigger_nameContext struct

+ func NewEmptyTrigger_nameContext() *Trigger_nameContext

+ func NewTrigger_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Trigger_nameContext

+ func (*Trigger_nameContext) IsTrigger_nameContext()

+ func (s *Trigger_nameContext) Any_name() IAny_nameContext

+ func (s *Trigger_nameContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Trigger_nameContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Trigger_nameContext) GetParser() antlr.Parser

+ func (s *Trigger_nameContext) GetRuleContext() antlr.RuleContext

+ func (s *Trigger_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type Type_nameContext struct

+ func NewEmptyType_nameContext() *Type_nameContext

+ func NewType_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Type_nameContext

+ func (*Type_nameContext) IsType_nameContext()

+ func (s *Type_nameContext) AllName() []INameContext

+ func (s *Type_nameContext) AllSigned_number() []ISigned_numberContext

+ func (s *Type_nameContext) CLOSE_PAR() antlr.TerminalNode

+ func (s *Type_nameContext) COMMA() antlr.TerminalNode

+ func (s *Type_nameContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Type_nameContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Type_nameContext) GetParser() antlr.Parser

+ func (s *Type_nameContext) GetRuleContext() antlr.RuleContext

+ func (s *Type_nameContext) Name(i int) INameContext

+ func (s *Type_nameContext) OPEN_PAR() antlr.TerminalNode

+ func (s *Type_nameContext) Signed_number(i int) ISigned_numberContext

+ func (s *Type_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type Unary_operatorContext struct

+ func NewEmptyUnary_operatorContext() *Unary_operatorContext

+ func NewUnary_operatorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Unary_operatorContext

+ func (*Unary_operatorContext) IsUnary_operatorContext()

+ func (s *Unary_operatorContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Unary_operatorContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Unary_operatorContext) GetParser() antlr.Parser

+ func (s *Unary_operatorContext) GetRuleContext() antlr.RuleContext

+ func (s *Unary_operatorContext) MINUS() antlr.TerminalNode

+ func (s *Unary_operatorContext) NOT_() antlr.TerminalNode

+ func (s *Unary_operatorContext) PLUS() antlr.TerminalNode

+ func (s *Unary_operatorContext) TILDE() antlr.TerminalNode

+ func (s *Unary_operatorContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type Update_stmtContext struct

+ func NewEmptyUpdate_stmtContext() *Update_stmtContext

+ func NewUpdate_stmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Update_stmtContext

+ func (*Update_stmtContext) IsUpdate_stmtContext()

+ func (s *Update_stmtContext) ABORT_() antlr.TerminalNode

+ func (s *Update_stmtContext) ASSIGN(i int) antlr.TerminalNode

+ func (s *Update_stmtContext) AllASSIGN() []antlr.TerminalNode

+ func (s *Update_stmtContext) AllCOMMA() []antlr.TerminalNode

+ func (s *Update_stmtContext) AllColumn_name() []IColumn_nameContext

+ func (s *Update_stmtContext) AllColumn_name_list() []IColumn_name_listContext

+ func (s *Update_stmtContext) AllExpr() []IExprContext

+ func (s *Update_stmtContext) COMMA(i int) antlr.TerminalNode

+ func (s *Update_stmtContext) Column_name(i int) IColumn_nameContext

+ func (s *Update_stmtContext) Column_name_list(i int) IColumn_name_listContext

+ func (s *Update_stmtContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Update_stmtContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Update_stmtContext) Expr(i int) IExprContext

+ func (s *Update_stmtContext) FAIL_() antlr.TerminalNode

+ func (s *Update_stmtContext) GetParser() antlr.Parser

+ func (s *Update_stmtContext) GetRuleContext() antlr.RuleContext

+ func (s *Update_stmtContext) IGNORE_() antlr.TerminalNode

+ func (s *Update_stmtContext) OR_() antlr.TerminalNode

+ func (s *Update_stmtContext) Qualified_table_name() IQualified_table_nameContext

+ func (s *Update_stmtContext) REPLACE_() antlr.TerminalNode

+ func (s *Update_stmtContext) ROLLBACK_() antlr.TerminalNode

+ func (s *Update_stmtContext) SET_() antlr.TerminalNode

+ func (s *Update_stmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ func (s *Update_stmtContext) UPDATE_() antlr.TerminalNode

+ func (s *Update_stmtContext) WHERE_() antlr.TerminalNode

+ func (s *Update_stmtContext) With_clause() IWith_clauseContext

+ type Update_stmt_limitedContext struct

+ func NewEmptyUpdate_stmt_limitedContext() *Update_stmt_limitedContext

+ func NewUpdate_stmt_limitedContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Update_stmt_limitedContext

+ func (*Update_stmt_limitedContext) IsUpdate_stmt_limitedContext()

+ func (s *Update_stmt_limitedContext) ABORT_() antlr.TerminalNode

+ func (s *Update_stmt_limitedContext) ASSIGN(i int) antlr.TerminalNode

+ func (s *Update_stmt_limitedContext) AllASSIGN() []antlr.TerminalNode

+ func (s *Update_stmt_limitedContext) AllCOMMA() []antlr.TerminalNode

+ func (s *Update_stmt_limitedContext) AllColumn_name() []IColumn_nameContext

+ func (s *Update_stmt_limitedContext) AllColumn_name_list() []IColumn_name_listContext

+ func (s *Update_stmt_limitedContext) AllExpr() []IExprContext

+ func (s *Update_stmt_limitedContext) COMMA(i int) antlr.TerminalNode

+ func (s *Update_stmt_limitedContext) Column_name(i int) IColumn_nameContext

+ func (s *Update_stmt_limitedContext) Column_name_list(i int) IColumn_name_listContext

+ func (s *Update_stmt_limitedContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Update_stmt_limitedContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Update_stmt_limitedContext) Expr(i int) IExprContext

+ func (s *Update_stmt_limitedContext) FAIL_() antlr.TerminalNode

+ func (s *Update_stmt_limitedContext) GetParser() antlr.Parser

+ func (s *Update_stmt_limitedContext) GetRuleContext() antlr.RuleContext

+ func (s *Update_stmt_limitedContext) IGNORE_() antlr.TerminalNode

+ func (s *Update_stmt_limitedContext) Limit_stmt() ILimit_stmtContext

+ func (s *Update_stmt_limitedContext) OR_() antlr.TerminalNode

+ func (s *Update_stmt_limitedContext) Order_by_stmt() IOrder_by_stmtContext

+ func (s *Update_stmt_limitedContext) Qualified_table_name() IQualified_table_nameContext

+ func (s *Update_stmt_limitedContext) REPLACE_() antlr.TerminalNode

+ func (s *Update_stmt_limitedContext) ROLLBACK_() antlr.TerminalNode

+ func (s *Update_stmt_limitedContext) SET_() antlr.TerminalNode

+ func (s *Update_stmt_limitedContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ func (s *Update_stmt_limitedContext) UPDATE_() antlr.TerminalNode

+ func (s *Update_stmt_limitedContext) WHERE_() antlr.TerminalNode

+ func (s *Update_stmt_limitedContext) With_clause() IWith_clauseContext

+ type Upsert_clauseContext struct

+ func NewEmptyUpsert_clauseContext() *Upsert_clauseContext

+ func NewUpsert_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Upsert_clauseContext

+ func (*Upsert_clauseContext) IsUpsert_clauseContext()

+ func (s *Upsert_clauseContext) AllCOMMA() []antlr.TerminalNode

+ func (s *Upsert_clauseContext) AllColumn_name() []IColumn_nameContext

+ func (s *Upsert_clauseContext) AllColumn_name_list() []IColumn_name_listContext

+ func (s *Upsert_clauseContext) AllEQ() []antlr.TerminalNode

+ func (s *Upsert_clauseContext) AllExpr() []IExprContext

+ func (s *Upsert_clauseContext) AllIndexed_column() []IIndexed_columnContext

+ func (s *Upsert_clauseContext) AllWHERE_() []antlr.TerminalNode

+ func (s *Upsert_clauseContext) CLOSE_PAR() antlr.TerminalNode

+ func (s *Upsert_clauseContext) COMMA(i int) antlr.TerminalNode

+ func (s *Upsert_clauseContext) CONFLICT_() antlr.TerminalNode

+ func (s *Upsert_clauseContext) Column_name(i int) IColumn_nameContext

+ func (s *Upsert_clauseContext) Column_name_list(i int) IColumn_name_listContext

+ func (s *Upsert_clauseContext) DO_() antlr.TerminalNode

+ func (s *Upsert_clauseContext) EQ(i int) antlr.TerminalNode

+ func (s *Upsert_clauseContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Upsert_clauseContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Upsert_clauseContext) Expr(i int) IExprContext

+ func (s *Upsert_clauseContext) GetParser() antlr.Parser

+ func (s *Upsert_clauseContext) GetRuleContext() antlr.RuleContext

+ func (s *Upsert_clauseContext) Indexed_column(i int) IIndexed_columnContext

+ func (s *Upsert_clauseContext) NOTHING_() antlr.TerminalNode

+ func (s *Upsert_clauseContext) ON_() antlr.TerminalNode

+ func (s *Upsert_clauseContext) OPEN_PAR() antlr.TerminalNode

+ func (s *Upsert_clauseContext) SET_() antlr.TerminalNode

+ func (s *Upsert_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ func (s *Upsert_clauseContext) UPDATE_() antlr.TerminalNode

+ func (s *Upsert_clauseContext) WHERE_(i int) antlr.TerminalNode

+ type Vacuum_stmtContext struct

+ func NewEmptyVacuum_stmtContext() *Vacuum_stmtContext

+ func NewVacuum_stmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Vacuum_stmtContext

+ func (*Vacuum_stmtContext) IsVacuum_stmtContext()

+ func (s *Vacuum_stmtContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Vacuum_stmtContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Vacuum_stmtContext) Filename() IFilenameContext

+ func (s *Vacuum_stmtContext) GetParser() antlr.Parser

+ func (s *Vacuum_stmtContext) GetRuleContext() antlr.RuleContext

+ func (s *Vacuum_stmtContext) INTO_() antlr.TerminalNode

+ func (s *Vacuum_stmtContext) Schema_name() ISchema_nameContext

+ func (s *Vacuum_stmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ func (s *Vacuum_stmtContext) VACUUM_() antlr.TerminalNode

+ type View_nameContext struct

+ func NewEmptyView_nameContext() *View_nameContext

+ func NewView_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *View_nameContext

+ func (*View_nameContext) IsView_nameContext()

+ func (s *View_nameContext) Any_name() IAny_nameContext

+ func (s *View_nameContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *View_nameContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *View_nameContext) GetParser() antlr.Parser

+ func (s *View_nameContext) GetRuleContext() antlr.RuleContext

+ func (s *View_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type Window_defnContext struct

+ func NewEmptyWindow_defnContext() *Window_defnContext

+ func NewWindow_defnContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Window_defnContext

+ func (*Window_defnContext) IsWindow_defnContext()

+ func (s *Window_defnContext) AllBY_() []antlr.TerminalNode

+ func (s *Window_defnContext) AllCOMMA() []antlr.TerminalNode

+ func (s *Window_defnContext) AllExpr() []IExprContext

+ func (s *Window_defnContext) AllOrdering_term() []IOrdering_termContext

+ func (s *Window_defnContext) BY_(i int) antlr.TerminalNode

+ func (s *Window_defnContext) Base_window_name() IBase_window_nameContext

+ func (s *Window_defnContext) CLOSE_PAR() antlr.TerminalNode

+ func (s *Window_defnContext) COMMA(i int) antlr.TerminalNode

+ func (s *Window_defnContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Window_defnContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Window_defnContext) Expr(i int) IExprContext

+ func (s *Window_defnContext) Frame_spec() IFrame_specContext

+ func (s *Window_defnContext) GetParser() antlr.Parser

+ func (s *Window_defnContext) GetRuleContext() antlr.RuleContext

+ func (s *Window_defnContext) OPEN_PAR() antlr.TerminalNode

+ func (s *Window_defnContext) ORDER_() antlr.TerminalNode

+ func (s *Window_defnContext) Ordering_term(i int) IOrdering_termContext

+ func (s *Window_defnContext) PARTITION_() antlr.TerminalNode

+ func (s *Window_defnContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type Window_functionContext struct

+ func NewEmptyWindow_functionContext() *Window_functionContext

+ func NewWindow_functionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Window_functionContext

+ func (*Window_functionContext) IsWindow_functionContext()

+ func (s *Window_functionContext) AllCLOSE_PAR() []antlr.TerminalNode

+ func (s *Window_functionContext) AllOPEN_PAR() []antlr.TerminalNode

+ func (s *Window_functionContext) CLOSE_PAR(i int) antlr.TerminalNode

+ func (s *Window_functionContext) COMMA() antlr.TerminalNode

+ func (s *Window_functionContext) CUME_DIST_() antlr.TerminalNode

+ func (s *Window_functionContext) DENSE_RANK_() antlr.TerminalNode

+ func (s *Window_functionContext) Default_DEFAULT__value() IDefault_DEFAULT__valueContext

+ func (s *Window_functionContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Window_functionContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Window_functionContext) Expr() IExprContext

+ func (s *Window_functionContext) FIRST_VALUE_() antlr.TerminalNode

+ func (s *Window_functionContext) Frame_clause() IFrame_clauseContext

+ func (s *Window_functionContext) GetParser() antlr.Parser

+ func (s *Window_functionContext) GetRuleContext() antlr.RuleContext

+ func (s *Window_functionContext) LAG_() antlr.TerminalNode

+ func (s *Window_functionContext) LAST_VALUE_() antlr.TerminalNode

+ func (s *Window_functionContext) LEAD_() antlr.TerminalNode

+ func (s *Window_functionContext) NTH_VALUE_() antlr.TerminalNode

+ func (s *Window_functionContext) NTILE_() antlr.TerminalNode

+ func (s *Window_functionContext) OPEN_PAR(i int) antlr.TerminalNode

+ func (s *Window_functionContext) OVER_() antlr.TerminalNode

+ func (s *Window_functionContext) Of_OF_fset() IOf_OF_fsetContext

+ func (s *Window_functionContext) Order_by_expr() IOrder_by_exprContext

+ func (s *Window_functionContext) Order_by_expr_asc_desc() IOrder_by_expr_asc_descContext

+ func (s *Window_functionContext) PERCENT_RANK_() antlr.TerminalNode

+ func (s *Window_functionContext) Partition_by() IPartition_byContext

+ func (s *Window_functionContext) RANK_() antlr.TerminalNode

+ func (s *Window_functionContext) ROW_NUMBER_() antlr.TerminalNode

+ func (s *Window_functionContext) Signed_number() ISigned_numberContext

+ func (s *Window_functionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type Window_function_invocationContext struct

+ func NewEmptyWindow_function_invocationContext() *Window_function_invocationContext

+ func NewWindow_function_invocationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Window_function_invocationContext

+ func (*Window_function_invocationContext) IsWindow_function_invocationContext()

+ func (s *Window_function_invocationContext) AllCOMMA() []antlr.TerminalNode

+ func (s *Window_function_invocationContext) AllExpr() []IExprContext

+ func (s *Window_function_invocationContext) CLOSE_PAR() antlr.TerminalNode

+ func (s *Window_function_invocationContext) COMMA(i int) antlr.TerminalNode

+ func (s *Window_function_invocationContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Window_function_invocationContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Window_function_invocationContext) Expr(i int) IExprContext

+ func (s *Window_function_invocationContext) Filter_clause() IFilter_clauseContext

+ func (s *Window_function_invocationContext) GetParser() antlr.Parser

+ func (s *Window_function_invocationContext) GetRuleContext() antlr.RuleContext

+ func (s *Window_function_invocationContext) OPEN_PAR() antlr.TerminalNode

+ func (s *Window_function_invocationContext) OVER_() antlr.TerminalNode

+ func (s *Window_function_invocationContext) STAR() antlr.TerminalNode

+ func (s *Window_function_invocationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ func (s *Window_function_invocationContext) Window_defn() IWindow_defnContext

+ func (s *Window_function_invocationContext) Window_function() IWindow_functionContext

+ func (s *Window_function_invocationContext) Window_name() IWindow_nameContext

+ type Window_nameContext struct

+ func NewEmptyWindow_nameContext() *Window_nameContext

+ func NewWindow_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Window_nameContext

+ func (*Window_nameContext) IsWindow_nameContext()

+ func (s *Window_nameContext) Any_name() IAny_nameContext

+ func (s *Window_nameContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Window_nameContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Window_nameContext) GetParser() antlr.Parser

+ func (s *Window_nameContext) GetRuleContext() antlr.RuleContext

+ func (s *Window_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type With_clauseContext struct

+ func NewEmptyWith_clauseContext() *With_clauseContext

+ func NewWith_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *With_clauseContext

+ func (*With_clauseContext) IsWith_clauseContext()

+ func (s *With_clauseContext) AS_(i int) antlr.TerminalNode

+ func (s *With_clauseContext) AllAS_() []antlr.TerminalNode

+ func (s *With_clauseContext) AllCLOSE_PAR() []antlr.TerminalNode

+ func (s *With_clauseContext) AllCOMMA() []antlr.TerminalNode

+ func (s *With_clauseContext) AllCte_table_name() []ICte_table_nameContext

+ func (s *With_clauseContext) AllOPEN_PAR() []antlr.TerminalNode

+ func (s *With_clauseContext) AllSelect_stmt() []ISelect_stmtContext

+ func (s *With_clauseContext) CLOSE_PAR(i int) antlr.TerminalNode

+ func (s *With_clauseContext) COMMA(i int) antlr.TerminalNode

+ func (s *With_clauseContext) Cte_table_name(i int) ICte_table_nameContext

+ func (s *With_clauseContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *With_clauseContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *With_clauseContext) GetParser() antlr.Parser

+ func (s *With_clauseContext) GetRuleContext() antlr.RuleContext

+ func (s *With_clauseContext) OPEN_PAR(i int) antlr.TerminalNode

+ func (s *With_clauseContext) RECURSIVE_() antlr.TerminalNode

+ func (s *With_clauseContext) Select_stmt(i int) ISelect_stmtContext

+ func (s *With_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ func (s *With_clauseContext) WITH_() antlr.TerminalNode

v0.1.0

Jan 31, 2022

Changes in this version

+ const SQLQueryLexerALL_COLUMNS

+ const SQLQueryLexerAND

+ const SQLQueryLexerEQ

+ const SQLQueryLexerFROM

+ const SQLQueryLexerIDENTIFIER

+ const SQLQueryLexerSELECT

+ const SQLQueryLexerT__0

+ const SQLQueryLexerWHERE

+ const SQLQueryLexerWHITESPACE

+ const SQLQueryParserALL_COLUMNS

+ const SQLQueryParserAND

+ const SQLQueryParserEOF

+ const SQLQueryParserEQ

+ const SQLQueryParserFROM

+ const SQLQueryParserIDENTIFIER

+ const SQLQueryParserRULE_column

+ const SQLQueryParserRULE_columns

+ const SQLQueryParserRULE_comparison

+ const SQLQueryParserRULE_fromClause

+ const SQLQueryParserRULE_lhs

+ const SQLQueryParserRULE_predicate

+ const SQLQueryParserRULE_query

+ const SQLQueryParserRULE_rhs

+ const SQLQueryParserRULE_selectClause

+ const SQLQueryParserRULE_selectStatement

+ const SQLQueryParserRULE_table

+ const SQLQueryParserRULE_whereClause

+ const SQLQueryParserSELECT

+ const SQLQueryParserT__0

+ const SQLQueryParserWHERE

+ const SQLQueryParserWHITESPACE

+ type BaseSQLQueryListener struct

+ func (s *BaseSQLQueryListener) EnterColumn(ctx *ColumnContext)

+ func (s *BaseSQLQueryListener) EnterColumns(ctx *ColumnsContext)

+ func (s *BaseSQLQueryListener) EnterComparison(ctx *ComparisonContext)

+ func (s *BaseSQLQueryListener) EnterEveryRule(ctx antlr.ParserRuleContext)

+ func (s *BaseSQLQueryListener) EnterFromClause(ctx *FromClauseContext)

+ func (s *BaseSQLQueryListener) EnterLhs(ctx *LhsContext)

+ func (s *BaseSQLQueryListener) EnterPredicate(ctx *PredicateContext)

+ func (s *BaseSQLQueryListener) EnterQuery(ctx *QueryContext)

+ func (s *BaseSQLQueryListener) EnterRhs(ctx *RhsContext)

+ func (s *BaseSQLQueryListener) EnterSelectClause(ctx *SelectClauseContext)

+ func (s *BaseSQLQueryListener) EnterSelectStatement(ctx *SelectStatementContext)

+ func (s *BaseSQLQueryListener) EnterTable(ctx *TableContext)

+ func (s *BaseSQLQueryListener) EnterWhereClause(ctx *WhereClauseContext)

+ func (s *BaseSQLQueryListener) ExitColumn(ctx *ColumnContext)

+ func (s *BaseSQLQueryListener) ExitColumns(ctx *ColumnsContext)

+ func (s *BaseSQLQueryListener) ExitComparison(ctx *ComparisonContext)

+ func (s *BaseSQLQueryListener) ExitEveryRule(ctx antlr.ParserRuleContext)

+ func (s *BaseSQLQueryListener) ExitFromClause(ctx *FromClauseContext)

+ func (s *BaseSQLQueryListener) ExitLhs(ctx *LhsContext)

+ func (s *BaseSQLQueryListener) ExitPredicate(ctx *PredicateContext)

+ func (s *BaseSQLQueryListener) ExitQuery(ctx *QueryContext)

+ func (s *BaseSQLQueryListener) ExitRhs(ctx *RhsContext)

+ func (s *BaseSQLQueryListener) ExitSelectClause(ctx *SelectClauseContext)

+ func (s *BaseSQLQueryListener) ExitSelectStatement(ctx *SelectStatementContext)

+ func (s *BaseSQLQueryListener) ExitTable(ctx *TableContext)

+ func (s *BaseSQLQueryListener) ExitWhereClause(ctx *WhereClauseContext)

+ func (s *BaseSQLQueryListener) VisitErrorNode(node antlr.ErrorNode)

+ func (s *BaseSQLQueryListener) VisitTerminal(node antlr.TerminalNode)

+ type ColumnContext struct

+ func NewColumnContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ColumnContext

+ func NewEmptyColumnContext() *ColumnContext

+ func (*ColumnContext) IsColumnContext()

+ func (s *ColumnContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *ColumnContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *ColumnContext) GetParser() antlr.Parser

+ func (s *ColumnContext) GetRuleContext() antlr.RuleContext

+ func (s *ColumnContext) IDENTIFIER() antlr.TerminalNode

+ func (s *ColumnContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type ColumnsContext struct

+ func NewColumnsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ColumnsContext

+ func NewEmptyColumnsContext() *ColumnsContext

+ func (*ColumnsContext) IsColumnsContext()

+ func (s *ColumnsContext) ALL_COLUMNS() antlr.TerminalNode

+ func (s *ColumnsContext) AllColumn() []IColumnContext

+ func (s *ColumnsContext) Column(i int) IColumnContext

+ func (s *ColumnsContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *ColumnsContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *ColumnsContext) GetParser() antlr.Parser

+ func (s *ColumnsContext) GetRuleContext() antlr.RuleContext

+ func (s *ColumnsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type ComparisonContext struct

+ func NewComparisonContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ComparisonContext

+ func NewEmptyComparisonContext() *ComparisonContext

+ func (*ComparisonContext) IsComparisonContext()

+ func (s *ComparisonContext) EQ() antlr.TerminalNode

+ func (s *ComparisonContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *ComparisonContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *ComparisonContext) GetParser() antlr.Parser

+ func (s *ComparisonContext) GetRuleContext() antlr.RuleContext

+ func (s *ComparisonContext) Lhs() ILhsContext

+ func (s *ComparisonContext) Rhs() IRhsContext

+ func (s *ComparisonContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type FromClauseContext struct

+ func NewEmptyFromClauseContext() *FromClauseContext

+ func NewFromClauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FromClauseContext

+ func (*FromClauseContext) IsFromClauseContext()

+ func (s *FromClauseContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *FromClauseContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *FromClauseContext) FROM() antlr.TerminalNode

+ func (s *FromClauseContext) GetParser() antlr.Parser

+ func (s *FromClauseContext) GetRuleContext() antlr.RuleContext

+ func (s *FromClauseContext) Table() ITableContext

+ func (s *FromClauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type IColumnContext interface

+ GetParser func() antlr.Parser

+ IsColumnContext func()

+ type IColumnsContext interface

+ GetParser func() antlr.Parser

+ IsColumnsContext func()

+ type IComparisonContext interface

+ GetParser func() antlr.Parser

+ IsComparisonContext func()

+ type IFromClauseContext interface

+ GetParser func() antlr.Parser

+ IsFromClauseContext func()

+ type ILhsContext interface

+ GetParser func() antlr.Parser

+ IsLhsContext func()

+ type IPredicateContext interface

+ GetParser func() antlr.Parser

+ IsPredicateContext func()

+ type IQueryContext interface

+ GetParser func() antlr.Parser

+ IsQueryContext func()

+ type IRhsContext interface

+ GetParser func() antlr.Parser

+ IsRhsContext func()

+ type ISelectClauseContext interface

+ GetParser func() antlr.Parser

+ IsSelectClauseContext func()

+ type ISelectStatementContext interface

+ GetParser func() antlr.Parser

+ IsSelectStatementContext func()

+ type ITableContext interface

+ GetParser func() antlr.Parser

+ IsTableContext func()

+ type IWhereClauseContext interface

+ GetParser func() antlr.Parser

+ IsWhereClauseContext func()

+ type LhsContext struct

+ func NewEmptyLhsContext() *LhsContext

+ func NewLhsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *LhsContext

+ func (*LhsContext) IsLhsContext()

+ func (s *LhsContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *LhsContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *LhsContext) GetParser() antlr.Parser

+ func (s *LhsContext) GetRuleContext() antlr.RuleContext

+ func (s *LhsContext) IDENTIFIER() antlr.TerminalNode

+ func (s *LhsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type PredicateContext struct

+ func NewEmptyPredicateContext() *PredicateContext

+ func NewPredicateContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PredicateContext

+ func (*PredicateContext) IsPredicateContext()

+ func (s *PredicateContext) AND() antlr.TerminalNode

+ func (s *PredicateContext) AllPredicate() []IPredicateContext

+ func (s *PredicateContext) Comparison() IComparisonContext

+ func (s *PredicateContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *PredicateContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *PredicateContext) GetParser() antlr.Parser

+ func (s *PredicateContext) GetRuleContext() antlr.RuleContext

+ func (s *PredicateContext) Predicate(i int) IPredicateContext

+ func (s *PredicateContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type QueryContext struct

+ func NewEmptyQueryContext() *QueryContext

+ func NewQueryContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *QueryContext

+ func (*QueryContext) IsQueryContext()

+ func (s *QueryContext) EOF() antlr.TerminalNode

+ func (s *QueryContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *QueryContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *QueryContext) GetParser() antlr.Parser

+ func (s *QueryContext) GetRuleContext() antlr.RuleContext

+ func (s *QueryContext) SelectStatement() ISelectStatementContext

+ func (s *QueryContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type RhsContext struct

+ func NewEmptyRhsContext() *RhsContext

+ func NewRhsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *RhsContext

+ func (*RhsContext) IsRhsContext()

+ func (s *RhsContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *RhsContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *RhsContext) GetParser() antlr.Parser

+ func (s *RhsContext) GetRuleContext() antlr.RuleContext

+ func (s *RhsContext) IDENTIFIER() antlr.TerminalNode

+ func (s *RhsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type SQLQueryLexer struct

+ func NewSQLQueryLexer(input antlr.CharStream) *SQLQueryLexer

+ type SQLQueryListener interface

+ EnterColumn func(c *ColumnContext)

+ EnterColumns func(c *ColumnsContext)

+ EnterComparison func(c *ComparisonContext)

+ EnterFromClause func(c *FromClauseContext)

+ EnterLhs func(c *LhsContext)

+ EnterPredicate func(c *PredicateContext)

+ EnterQuery func(c *QueryContext)

+ EnterRhs func(c *RhsContext)

+ EnterSelectClause func(c *SelectClauseContext)

+ EnterSelectStatement func(c *SelectStatementContext)

+ EnterTable func(c *TableContext)

+ EnterWhereClause func(c *WhereClauseContext)

+ ExitColumn func(c *ColumnContext)

+ ExitColumns func(c *ColumnsContext)

+ ExitComparison func(c *ComparisonContext)

+ ExitFromClause func(c *FromClauseContext)

+ ExitLhs func(c *LhsContext)

+ ExitPredicate func(c *PredicateContext)

+ ExitQuery func(c *QueryContext)

+ ExitRhs func(c *RhsContext)

+ ExitSelectClause func(c *SelectClauseContext)

+ ExitSelectStatement func(c *SelectStatementContext)

+ ExitTable func(c *TableContext)

+ ExitWhereClause func(c *WhereClauseContext)

+ type SQLQueryParser struct

+ func NewSQLQueryParser(input antlr.TokenStream) *SQLQueryParser

+ func (p *SQLQueryParser) Column() (localctx IColumnContext)

+ func (p *SQLQueryParser) Columns() (localctx IColumnsContext)

+ func (p *SQLQueryParser) Comparison() (localctx IComparisonContext)

+ func (p *SQLQueryParser) FromClause() (localctx IFromClauseContext)

+ func (p *SQLQueryParser) Lhs() (localctx ILhsContext)

+ func (p *SQLQueryParser) Predicate() (localctx IPredicateContext)

+ func (p *SQLQueryParser) Predicate_Sempred(localctx antlr.RuleContext, predIndex int) bool

+ func (p *SQLQueryParser) Query() (localctx IQueryContext)

+ func (p *SQLQueryParser) Rhs() (localctx IRhsContext)

+ func (p *SQLQueryParser) SelectClause() (localctx ISelectClauseContext)

+ func (p *SQLQueryParser) SelectStatement() (localctx ISelectStatementContext)

+ func (p *SQLQueryParser) Sempred(localctx antlr.RuleContext, ruleIndex, predIndex int) bool

+ func (p *SQLQueryParser) Table() (localctx ITableContext)

+ func (p *SQLQueryParser) WhereClause() (localctx IWhereClauseContext)

+ type SelectClauseContext struct

+ func NewEmptySelectClauseContext() *SelectClauseContext

+ func NewSelectClauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SelectClauseContext

+ func (*SelectClauseContext) IsSelectClauseContext()

+ func (s *SelectClauseContext) Columns() IColumnsContext

+ func (s *SelectClauseContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *SelectClauseContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *SelectClauseContext) GetParser() antlr.Parser

+ func (s *SelectClauseContext) GetRuleContext() antlr.RuleContext

+ func (s *SelectClauseContext) SELECT() antlr.TerminalNode

+ func (s *SelectClauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type SelectStatementContext struct

+ func NewEmptySelectStatementContext() *SelectStatementContext

+ func NewSelectStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SelectStatementContext

+ func (*SelectStatementContext) IsSelectStatementContext()

+ func (s *SelectStatementContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *SelectStatementContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *SelectStatementContext) FromClause() IFromClauseContext

+ func (s *SelectStatementContext) GetParser() antlr.Parser

+ func (s *SelectStatementContext) GetRuleContext() antlr.RuleContext

+ func (s *SelectStatementContext) SelectClause() ISelectClauseContext

+ func (s *SelectStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ func (s *SelectStatementContext) WhereClause() IWhereClauseContext

+ type TableContext struct

+ func NewEmptyTableContext() *TableContext

+ func NewTableContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TableContext

+ func (*TableContext) IsTableContext()

+ func (s *TableContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *TableContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *TableContext) GetParser() antlr.Parser

+ func (s *TableContext) GetRuleContext() antlr.RuleContext

+ func (s *TableContext) IDENTIFIER() antlr.TerminalNode

+ func (s *TableContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type WhereClauseContext struct

+ func NewEmptyWhereClauseContext() *WhereClauseContext

+ func NewWhereClauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *WhereClauseContext

+ func (*WhereClauseContext) IsWhereClauseContext()

+ func (s *WhereClauseContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *WhereClauseContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *WhereClauseContext) GetParser() antlr.Parser

+ func (s *WhereClauseContext) GetRuleContext() antlr.RuleContext

+ func (s *WhereClauseContext) Predicate() IPredicateContext

+ func (s *WhereClauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ func (s *WhereClauseContext) WHERE() antlr.TerminalNode