parser

package

Go to main page

Versions in this module

v1

v1.4.0

Jun 17, 2020

v1.3.0

May 12, 2020

v1.2.0

Apr 7, 2020

Changes in this version

+ const SQLiteParserRULE_new_column_name

type Alter_table_stmtContext

+ func (s *Alter_table_stmtContext) Column_name() IColumn_nameContext

+ func (s *Alter_table_stmtContext) New_column_name() INew_column_nameContext

type BaseSQLiteListener

+ func (s *BaseSQLiteListener) EnterNew_column_name(ctx *New_column_nameContext)

+ func (s *BaseSQLiteListener) ExitNew_column_name(ctx *New_column_nameContext)

+ type INew_column_nameContext interface

+ GetParser func() antlr.Parser

+ IsNew_column_nameContext func()

+ type New_column_nameContext struct

+ func NewEmptyNew_column_nameContext() *New_column_nameContext

+ func NewNew_column_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *New_column_nameContext

+ func (*New_column_nameContext) IsNew_column_nameContext()

+ func (s *New_column_nameContext) Any_name() IAny_nameContext

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

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

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

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

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

type SQLiteListener

+ EnterNew_column_name func(c *New_column_nameContext)

+ ExitNew_column_name func(c *New_column_nameContext)

type SQLiteParser

+ func (p *SQLiteParser) New_column_name() (localctx INew_column_nameContext)

v1.1.0

Mar 17, 2020

Changes in this version

+ const SQLiteLexerAMP

+ const SQLiteLexerASSIGN

+ const SQLiteLexerBIND_PARAMETER

+ const SQLiteLexerBLOB_LITERAL

+ const SQLiteLexerCLOSE_PAR

+ const SQLiteLexerCOMMA

+ const SQLiteLexerDIV

+ const SQLiteLexerDOT

+ const SQLiteLexerEQ

+ const SQLiteLexerGT

+ const SQLiteLexerGT2

+ const SQLiteLexerGT_EQ

+ const SQLiteLexerIDENTIFIER

+ const SQLiteLexerK_ABORT

+ const SQLiteLexerK_ACTION

+ const SQLiteLexerK_ADD

+ const SQLiteLexerK_AFTER

+ const SQLiteLexerK_ALL

+ const SQLiteLexerK_ALTER

+ const SQLiteLexerK_ANALYZE

+ const SQLiteLexerK_AND

+ const SQLiteLexerK_AS

+ const SQLiteLexerK_ASC

+ const SQLiteLexerK_ATTACH

+ const SQLiteLexerK_AUTOINCREMENT

+ const SQLiteLexerK_BEFORE

+ const SQLiteLexerK_BEGIN

+ const SQLiteLexerK_BETWEEN

+ const SQLiteLexerK_BY

+ const SQLiteLexerK_CASCADE

+ const SQLiteLexerK_CASE

+ const SQLiteLexerK_CAST

+ const SQLiteLexerK_CHECK

+ const SQLiteLexerK_COLLATE

+ const SQLiteLexerK_COLUMN

+ const SQLiteLexerK_COMMIT

+ const SQLiteLexerK_CONFLICT

+ const SQLiteLexerK_CONSTRAINT

+ const SQLiteLexerK_CREATE

+ const SQLiteLexerK_CROSS

+ const SQLiteLexerK_CURRENT_DATE

+ const SQLiteLexerK_CURRENT_TIME

+ const SQLiteLexerK_CURRENT_TIMESTAMP

+ const SQLiteLexerK_DATABASE

+ const SQLiteLexerK_DEFAULT

+ const SQLiteLexerK_DEFERRABLE

+ const SQLiteLexerK_DEFERRED

+ const SQLiteLexerK_DELETE

+ const SQLiteLexerK_DESC

+ const SQLiteLexerK_DETACH

+ const SQLiteLexerK_DISTINCT

+ const SQLiteLexerK_DROP

+ const SQLiteLexerK_EACH

+ const SQLiteLexerK_ELSE

+ const SQLiteLexerK_END

+ const SQLiteLexerK_ESCAPE

+ const SQLiteLexerK_EXCEPT

+ const SQLiteLexerK_EXCLUSIVE

+ const SQLiteLexerK_EXISTS

+ const SQLiteLexerK_EXPLAIN

+ const SQLiteLexerK_FAIL

+ const SQLiteLexerK_FOR

+ const SQLiteLexerK_FOREIGN

+ const SQLiteLexerK_FROM

+ const SQLiteLexerK_FULL

+ const SQLiteLexerK_GLOB

+ const SQLiteLexerK_GROUP

+ const SQLiteLexerK_HAVING

+ const SQLiteLexerK_IF

+ const SQLiteLexerK_IGNORE

+ const SQLiteLexerK_IMMEDIATE

+ const SQLiteLexerK_IN

+ const SQLiteLexerK_INDEX

+ const SQLiteLexerK_INDEXED

+ const SQLiteLexerK_INITIALLY

+ const SQLiteLexerK_INNER

+ const SQLiteLexerK_INSERT

+ const SQLiteLexerK_INSTEAD

+ const SQLiteLexerK_INTERSECT

+ const SQLiteLexerK_INTO

+ const SQLiteLexerK_IS

+ const SQLiteLexerK_ISNULL

+ const SQLiteLexerK_JOIN

+ const SQLiteLexerK_KEY

+ const SQLiteLexerK_LEFT

+ const SQLiteLexerK_LIKE

+ const SQLiteLexerK_LIMIT

+ const SQLiteLexerK_MATCH

+ const SQLiteLexerK_NATURAL

+ const SQLiteLexerK_NO

+ const SQLiteLexerK_NOT

+ const SQLiteLexerK_NOTNULL

+ const SQLiteLexerK_NULL

+ const SQLiteLexerK_OF

+ const SQLiteLexerK_OFFSET

+ const SQLiteLexerK_ON

+ const SQLiteLexerK_OR

+ const SQLiteLexerK_ORDER

+ const SQLiteLexerK_OUTER

+ const SQLiteLexerK_PLAN

+ const SQLiteLexerK_PRAGMA

+ const SQLiteLexerK_PRIMARY

+ const SQLiteLexerK_QUERY

+ const SQLiteLexerK_RAISE

+ const SQLiteLexerK_RECURSIVE

+ const SQLiteLexerK_REFERENCES

+ const SQLiteLexerK_REGEXP

+ const SQLiteLexerK_REINDEX

+ const SQLiteLexerK_RELEASE

+ const SQLiteLexerK_RENAME

+ const SQLiteLexerK_REPLACE

+ const SQLiteLexerK_RESTRICT

+ const SQLiteLexerK_RIGHT

+ const SQLiteLexerK_ROLLBACK

+ const SQLiteLexerK_ROW

+ const SQLiteLexerK_SAVEPOINT

+ const SQLiteLexerK_SELECT

+ const SQLiteLexerK_SET

+ const SQLiteLexerK_TABLE

+ const SQLiteLexerK_TEMP

+ const SQLiteLexerK_TEMPORARY

+ const SQLiteLexerK_THEN

+ const SQLiteLexerK_TO

+ const SQLiteLexerK_TRANSACTION

+ const SQLiteLexerK_TRIGGER

+ const SQLiteLexerK_UNION

+ const SQLiteLexerK_UNIQUE

+ const SQLiteLexerK_UPDATE

+ const SQLiteLexerK_USING

+ const SQLiteLexerK_VACUUM

+ const SQLiteLexerK_VALUES

+ const SQLiteLexerK_VIEW

+ const SQLiteLexerK_VIRTUAL

+ const SQLiteLexerK_WHEN

+ const SQLiteLexerK_WHERE

+ const SQLiteLexerK_WITH

+ const SQLiteLexerK_WITHOUT

+ const SQLiteLexerLT

+ const SQLiteLexerLT2

+ const SQLiteLexerLT_EQ

+ const SQLiteLexerMINUS

+ const SQLiteLexerMOD

+ const SQLiteLexerMULTILINE_COMMENT

+ const SQLiteLexerNOT_EQ1

+ const SQLiteLexerNOT_EQ2

+ const SQLiteLexerNUMERIC_LITERAL

+ const SQLiteLexerOPEN_PAR

+ const SQLiteLexerPIPE

+ const SQLiteLexerPIPE2

+ const SQLiteLexerPLUS

+ const SQLiteLexerSCOL

+ const SQLiteLexerSINGLE_LINE_COMMENT

+ const SQLiteLexerSPACES

+ const SQLiteLexerSTAR

+ const SQLiteLexerSTRING_LITERAL

+ const SQLiteLexerTILDE

+ const SQLiteLexerUNEXPECTED_CHAR

+ const SQLiteParserAMP

+ const SQLiteParserASSIGN

+ const SQLiteParserBIND_PARAMETER

+ const SQLiteParserBLOB_LITERAL

+ const SQLiteParserCLOSE_PAR

+ const SQLiteParserCOMMA

+ const SQLiteParserDIV

+ const SQLiteParserDOT

+ const SQLiteParserEOF

+ const SQLiteParserEQ

+ const SQLiteParserGT

+ const SQLiteParserGT2

+ const SQLiteParserGT_EQ

+ const SQLiteParserIDENTIFIER

+ const SQLiteParserK_ABORT

+ const SQLiteParserK_ACTION

+ const SQLiteParserK_ADD

+ const SQLiteParserK_AFTER

+ const SQLiteParserK_ALL

+ const SQLiteParserK_ALTER

+ const SQLiteParserK_ANALYZE

+ const SQLiteParserK_AND

+ const SQLiteParserK_AS

+ const SQLiteParserK_ASC

+ const SQLiteParserK_ATTACH

+ const SQLiteParserK_AUTOINCREMENT

+ const SQLiteParserK_BEFORE

+ const SQLiteParserK_BEGIN

+ const SQLiteParserK_BETWEEN

+ const SQLiteParserK_BY

+ const SQLiteParserK_CASCADE

+ const SQLiteParserK_CASE

+ const SQLiteParserK_CAST

+ const SQLiteParserK_CHECK

+ const SQLiteParserK_COLLATE

+ const SQLiteParserK_COLUMN

+ const SQLiteParserK_COMMIT

+ const SQLiteParserK_CONFLICT

+ const SQLiteParserK_CONSTRAINT

+ const SQLiteParserK_CREATE

+ const SQLiteParserK_CROSS

+ const SQLiteParserK_CURRENT_DATE

+ const SQLiteParserK_CURRENT_TIME

+ const SQLiteParserK_CURRENT_TIMESTAMP

+ const SQLiteParserK_DATABASE

+ const SQLiteParserK_DEFAULT

+ const SQLiteParserK_DEFERRABLE

+ const SQLiteParserK_DEFERRED

+ const SQLiteParserK_DELETE

+ const SQLiteParserK_DESC

+ const SQLiteParserK_DETACH

+ const SQLiteParserK_DISTINCT

+ const SQLiteParserK_DROP

+ const SQLiteParserK_EACH

+ const SQLiteParserK_ELSE

+ const SQLiteParserK_END

+ const SQLiteParserK_ESCAPE

+ const SQLiteParserK_EXCEPT

+ const SQLiteParserK_EXCLUSIVE

+ const SQLiteParserK_EXISTS

+ const SQLiteParserK_EXPLAIN

+ const SQLiteParserK_FAIL

+ const SQLiteParserK_FOR

+ const SQLiteParserK_FOREIGN

+ const SQLiteParserK_FROM

+ const SQLiteParserK_FULL

+ const SQLiteParserK_GLOB

+ const SQLiteParserK_GROUP

+ const SQLiteParserK_HAVING

+ const SQLiteParserK_IF

+ const SQLiteParserK_IGNORE

+ const SQLiteParserK_IMMEDIATE

+ const SQLiteParserK_IN

+ const SQLiteParserK_INDEX

+ const SQLiteParserK_INDEXED

+ const SQLiteParserK_INITIALLY

+ const SQLiteParserK_INNER

+ const SQLiteParserK_INSERT

+ const SQLiteParserK_INSTEAD

+ const SQLiteParserK_INTERSECT

+ const SQLiteParserK_INTO

+ const SQLiteParserK_IS

+ const SQLiteParserK_ISNULL

+ const SQLiteParserK_JOIN

+ const SQLiteParserK_KEY

+ const SQLiteParserK_LEFT

+ const SQLiteParserK_LIKE

+ const SQLiteParserK_LIMIT

+ const SQLiteParserK_MATCH

+ const SQLiteParserK_NATURAL

+ const SQLiteParserK_NO

+ const SQLiteParserK_NOT

+ const SQLiteParserK_NOTNULL

+ const SQLiteParserK_NULL

+ const SQLiteParserK_OF

+ const SQLiteParserK_OFFSET

+ const SQLiteParserK_ON

+ const SQLiteParserK_OR

+ const SQLiteParserK_ORDER

+ const SQLiteParserK_OUTER

+ const SQLiteParserK_PLAN

+ const SQLiteParserK_PRAGMA

+ const SQLiteParserK_PRIMARY

+ const SQLiteParserK_QUERY

+ const SQLiteParserK_RAISE

+ const SQLiteParserK_RECURSIVE

+ const SQLiteParserK_REFERENCES

+ const SQLiteParserK_REGEXP

+ const SQLiteParserK_REINDEX

+ const SQLiteParserK_RELEASE

+ const SQLiteParserK_RENAME

+ const SQLiteParserK_REPLACE

+ const SQLiteParserK_RESTRICT

+ const SQLiteParserK_RIGHT

+ const SQLiteParserK_ROLLBACK

+ const SQLiteParserK_ROW

+ const SQLiteParserK_SAVEPOINT

+ const SQLiteParserK_SELECT

+ const SQLiteParserK_SET

+ const SQLiteParserK_TABLE

+ const SQLiteParserK_TEMP

+ const SQLiteParserK_TEMPORARY

+ const SQLiteParserK_THEN

+ const SQLiteParserK_TO

+ const SQLiteParserK_TRANSACTION

+ const SQLiteParserK_TRIGGER

+ const SQLiteParserK_UNION

+ const SQLiteParserK_UNIQUE

+ const SQLiteParserK_UPDATE

+ const SQLiteParserK_USING

+ const SQLiteParserK_VACUUM

+ const SQLiteParserK_VALUES

+ const SQLiteParserK_VIEW

+ const SQLiteParserK_VIRTUAL

+ const SQLiteParserK_WHEN

+ const SQLiteParserK_WHERE

+ const SQLiteParserK_WITH

+ const SQLiteParserK_WITHOUT

+ const SQLiteParserLT

+ const SQLiteParserLT2

+ const SQLiteParserLT_EQ

+ const SQLiteParserMINUS

+ const SQLiteParserMOD

+ const SQLiteParserMULTILINE_COMMENT

+ const SQLiteParserNOT_EQ1

+ const SQLiteParserNOT_EQ2

+ const SQLiteParserNUMERIC_LITERAL

+ const SQLiteParserOPEN_PAR

+ const SQLiteParserPIPE

+ const SQLiteParserPIPE2

+ const SQLiteParserPLUS

+ const SQLiteParserRULE_alter_table_stmt

+ const SQLiteParserRULE_analyze_stmt

+ const SQLiteParserRULE_any_name

+ const SQLiteParserRULE_attach_stmt

+ const SQLiteParserRULE_begin_stmt

+ const SQLiteParserRULE_collation_name

+ const SQLiteParserRULE_column_alias

+ const SQLiteParserRULE_column_constraint

+ const SQLiteParserRULE_column_def

+ const SQLiteParserRULE_column_name

+ const SQLiteParserRULE_commit_stmt

+ const SQLiteParserRULE_common_table_expression

+ const SQLiteParserRULE_compound_operator

+ const SQLiteParserRULE_compound_select_stmt

+ const SQLiteParserRULE_conflict_clause

+ const SQLiteParserRULE_create_index_stmt

+ const SQLiteParserRULE_create_table_stmt

+ const SQLiteParserRULE_create_trigger_stmt

+ const SQLiteParserRULE_create_view_stmt

+ const SQLiteParserRULE_create_virtual_table_stmt

+ const SQLiteParserRULE_database_name

+ const SQLiteParserRULE_delete_stmt

+ const SQLiteParserRULE_delete_stmt_limited

+ const SQLiteParserRULE_detach_stmt

+ const SQLiteParserRULE_drop_index_stmt

+ const SQLiteParserRULE_drop_table_stmt

+ const SQLiteParserRULE_drop_trigger_stmt

+ const SQLiteParserRULE_drop_view_stmt

+ const SQLiteParserRULE_error_message

+ const SQLiteParserRULE_expr

+ const SQLiteParserRULE_factored_select_stmt

+ const SQLiteParserRULE_foreign_key_clause

+ const SQLiteParserRULE_foreign_table

+ const SQLiteParserRULE_function_name

+ const SQLiteParserRULE_index_name

+ const SQLiteParserRULE_indexed_column

+ const SQLiteParserRULE_insert_stmt

+ const SQLiteParserRULE_join_clause

+ const SQLiteParserRULE_join_constraint

+ const SQLiteParserRULE_join_operator

+ const SQLiteParserRULE_keyword

+ const SQLiteParserRULE_literal_value

+ const SQLiteParserRULE_module_argument

+ const SQLiteParserRULE_module_name

+ const SQLiteParserRULE_name

+ const SQLiteParserRULE_new_table_name

+ const SQLiteParserRULE_ordering_term

+ const SQLiteParserRULE_parse

+ const SQLiteParserRULE_pragma_name

+ const SQLiteParserRULE_pragma_stmt

+ const SQLiteParserRULE_pragma_value

+ const SQLiteParserRULE_qualified_table_name

+ const SQLiteParserRULE_raise_function

+ const SQLiteParserRULE_reindex_stmt

+ const SQLiteParserRULE_release_stmt

+ const SQLiteParserRULE_result_column

+ const SQLiteParserRULE_rollback_stmt

+ const SQLiteParserRULE_savepoint_name

+ const SQLiteParserRULE_savepoint_stmt

+ const SQLiteParserRULE_schema_name

+ const SQLiteParserRULE_select_core

+ const SQLiteParserRULE_select_or_values

+ const SQLiteParserRULE_select_stmt

+ const SQLiteParserRULE_signed_number

+ const SQLiteParserRULE_simple_select_stmt

+ const SQLiteParserRULE_sql_stmt

+ const SQLiteParserRULE_sql_stmt_list

+ const SQLiteParserRULE_table_alias

+ const SQLiteParserRULE_table_constraint

+ const SQLiteParserRULE_table_function_name

+ const SQLiteParserRULE_table_name

+ const SQLiteParserRULE_table_or_index_name

+ const SQLiteParserRULE_table_or_subquery

+ const SQLiteParserRULE_transaction_name

+ const SQLiteParserRULE_trigger_name

+ const SQLiteParserRULE_type_name

+ const SQLiteParserRULE_unary_operator

+ const SQLiteParserRULE_update_stmt

+ const SQLiteParserRULE_update_stmt_limited

+ const SQLiteParserRULE_vacuum_stmt

+ const SQLiteParserRULE_view_name

+ const SQLiteParserRULE_with_clause

+ const SQLiteParserSCOL

+ const SQLiteParserSINGLE_LINE_COMMENT

+ const SQLiteParserSPACES

+ const SQLiteParserSTAR

+ const SQLiteParserSTRING_LITERAL

+ const SQLiteParserTILDE

+ const SQLiteParserUNEXPECTED_CHAR

+ type Alter_table_stmtContext struct

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

+ func NewEmptyAlter_table_stmtContext() *Alter_table_stmtContext

+ func (*Alter_table_stmtContext) IsAlter_table_stmtContext()

+ func (s *Alter_table_stmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ func (s *Alter_table_stmtContext) Column_def() IColumn_defContext

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

+ func (s *Alter_table_stmtContext) Database_name() IDatabase_nameContext

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

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

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

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

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

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

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

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

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

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

+ func (s *Alter_table_stmtContext) New_table_name() INew_table_nameContext

+ func (s *Alter_table_stmtContext) Table_name() ITable_nameContext

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

+ type Analyze_stmtContext struct

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

+ func NewEmptyAnalyze_stmtContext() *Analyze_stmtContext

+ func (*Analyze_stmtContext) IsAnalyze_stmtContext()

+ func (s *Analyze_stmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

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

+ func (s *Analyze_stmtContext) Database_name() IDatabase_nameContext

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

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

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

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

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

+ func (s *Analyze_stmtContext) Table_or_index_name() ITable_or_index_nameContext

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

+ type Any_nameContext struct

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

+ func NewEmptyAny_nameContext() *Any_nameContext

+ func (*Any_nameContext) IsAny_nameContext()

+ func (s *Any_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ func (s *Any_nameContext) Any_name() IAny_nameContext

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

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

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

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

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

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

+ func (s *Any_nameContext) Keyword() IKeywordContext

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

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

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

+ type Attach_stmtContext struct

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

+ func NewEmptyAttach_stmtContext() *Attach_stmtContext

+ func (*Attach_stmtContext) IsAttach_stmtContext()

+ func (s *Attach_stmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ func (s *Attach_stmtContext) Database_name() IDatabase_nameContext

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

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

+ func (s *Attach_stmtContext) Expr() IExprContext

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

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

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

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

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

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

+ type BaseSQLiteListener struct

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

+ func (s *BaseSQLiteListener) EnterDatabase_name(ctx *Database_nameContext)

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

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

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

+ func (s *BaseSQLiteListener) EnterDrop_index_stmt(ctx *Drop_index_stmtContext)

+ func (s *BaseSQLiteListener) EnterDrop_table_stmt(ctx *Drop_table_stmtContext)

+ func (s *BaseSQLiteListener) EnterDrop_trigger_stmt(ctx *Drop_trigger_stmtContext)

+ func (s *BaseSQLiteListener) EnterDrop_view_stmt(ctx *Drop_view_stmtContext)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

+ func (s *BaseSQLiteListener) EnterSelect_or_values(ctx *Select_or_valuesContext)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

+ func (s *BaseSQLiteListener) ExitDatabase_name(ctx *Database_nameContext)

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

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

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

+ func (s *BaseSQLiteListener) ExitDrop_index_stmt(ctx *Drop_index_stmtContext)

+ func (s *BaseSQLiteListener) ExitDrop_table_stmt(ctx *Drop_table_stmtContext)

+ func (s *BaseSQLiteListener) ExitDrop_trigger_stmt(ctx *Drop_trigger_stmtContext)

+ func (s *BaseSQLiteListener) ExitDrop_view_stmt(ctx *Drop_view_stmtContext)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

+ func (s *BaseSQLiteListener) ExitSelect_or_values(ctx *Select_or_valuesContext)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

+ type BaseSQLiteVisitor struct

+ func (v *BaseSQLiteVisitor) VisitAlter_table_stmt(ctx *Alter_table_stmtContext) interface{}

+ func (v *BaseSQLiteVisitor) VisitAnalyze_stmt(ctx *Analyze_stmtContext) interface{}

+ func (v *BaseSQLiteVisitor) VisitAny_name(ctx *Any_nameContext) interface{}

+ func (v *BaseSQLiteVisitor) VisitAttach_stmt(ctx *Attach_stmtContext) interface{}

+ func (v *BaseSQLiteVisitor) VisitBegin_stmt(ctx *Begin_stmtContext) interface{}

+ func (v *BaseSQLiteVisitor) VisitCollation_name(ctx *Collation_nameContext) interface{}

+ func (v *BaseSQLiteVisitor) VisitColumn_alias(ctx *Column_aliasContext) interface{}

+ func (v *BaseSQLiteVisitor) VisitColumn_constraint(ctx *Column_constraintContext) interface{}

+ func (v *BaseSQLiteVisitor) VisitColumn_def(ctx *Column_defContext) interface{}

+ func (v *BaseSQLiteVisitor) VisitColumn_name(ctx *Column_nameContext) interface{}

+ func (v *BaseSQLiteVisitor) VisitCommit_stmt(ctx *Commit_stmtContext) interface{}

+ func (v *BaseSQLiteVisitor) VisitCommon_table_expression(ctx *Common_table_expressionContext) interface{}

+ func (v *BaseSQLiteVisitor) VisitCompound_operator(ctx *Compound_operatorContext) interface{}

+ func (v *BaseSQLiteVisitor) VisitCompound_select_stmt(ctx *Compound_select_stmtContext) interface{}

+ func (v *BaseSQLiteVisitor) VisitConflict_clause(ctx *Conflict_clauseContext) interface{}

+ func (v *BaseSQLiteVisitor) VisitCreate_index_stmt(ctx *Create_index_stmtContext) interface{}

+ func (v *BaseSQLiteVisitor) VisitCreate_table_stmt(ctx *Create_table_stmtContext) interface{}

+ func (v *BaseSQLiteVisitor) VisitCreate_trigger_stmt(ctx *Create_trigger_stmtContext) interface{}

+ func (v *BaseSQLiteVisitor) VisitCreate_view_stmt(ctx *Create_view_stmtContext) interface{}

+ func (v *BaseSQLiteVisitor) VisitCreate_virtual_table_stmt(ctx *Create_virtual_table_stmtContext) interface{}

+ func (v *BaseSQLiteVisitor) VisitDatabase_name(ctx *Database_nameContext) interface{}

+ func (v *BaseSQLiteVisitor) VisitDelete_stmt(ctx *Delete_stmtContext) interface{}

+ func (v *BaseSQLiteVisitor) VisitDelete_stmt_limited(ctx *Delete_stmt_limitedContext) interface{}

+ func (v *BaseSQLiteVisitor) VisitDetach_stmt(ctx *Detach_stmtContext) interface{}

+ func (v *BaseSQLiteVisitor) VisitDrop_index_stmt(ctx *Drop_index_stmtContext) interface{}

+ func (v *BaseSQLiteVisitor) VisitDrop_table_stmt(ctx *Drop_table_stmtContext) interface{}

+ func (v *BaseSQLiteVisitor) VisitDrop_trigger_stmt(ctx *Drop_trigger_stmtContext) interface{}

+ func (v *BaseSQLiteVisitor) VisitDrop_view_stmt(ctx *Drop_view_stmtContext) interface{}

+ func (v *BaseSQLiteVisitor) VisitError_message(ctx *Error_messageContext) interface{}

+ func (v *BaseSQLiteVisitor) VisitExpr(ctx *ExprContext) interface{}

+ func (v *BaseSQLiteVisitor) VisitFactored_select_stmt(ctx *Factored_select_stmtContext) interface{}

+ func (v *BaseSQLiteVisitor) VisitForeign_key_clause(ctx *Foreign_key_clauseContext) interface{}

+ func (v *BaseSQLiteVisitor) VisitForeign_table(ctx *Foreign_tableContext) interface{}

+ func (v *BaseSQLiteVisitor) VisitFunction_name(ctx *Function_nameContext) interface{}

+ func (v *BaseSQLiteVisitor) VisitIndex_name(ctx *Index_nameContext) interface{}

+ func (v *BaseSQLiteVisitor) VisitIndexed_column(ctx *Indexed_columnContext) interface{}

+ func (v *BaseSQLiteVisitor) VisitInsert_stmt(ctx *Insert_stmtContext) interface{}

+ func (v *BaseSQLiteVisitor) VisitJoin_clause(ctx *Join_clauseContext) interface{}

+ func (v *BaseSQLiteVisitor) VisitJoin_constraint(ctx *Join_constraintContext) interface{}

+ func (v *BaseSQLiteVisitor) VisitJoin_operator(ctx *Join_operatorContext) interface{}

+ func (v *BaseSQLiteVisitor) VisitKeyword(ctx *KeywordContext) interface{}

+ func (v *BaseSQLiteVisitor) VisitLiteral_value(ctx *Literal_valueContext) interface{}

+ func (v *BaseSQLiteVisitor) VisitModule_argument(ctx *Module_argumentContext) interface{}

+ func (v *BaseSQLiteVisitor) VisitModule_name(ctx *Module_nameContext) interface{}

+ func (v *BaseSQLiteVisitor) VisitName(ctx *NameContext) interface{}

+ func (v *BaseSQLiteVisitor) VisitNew_table_name(ctx *New_table_nameContext) interface{}

+ func (v *BaseSQLiteVisitor) VisitOrdering_term(ctx *Ordering_termContext) interface{}

+ func (v *BaseSQLiteVisitor) VisitParse(ctx *ParseContext) interface{}

+ func (v *BaseSQLiteVisitor) VisitPragma_name(ctx *Pragma_nameContext) interface{}

+ func (v *BaseSQLiteVisitor) VisitPragma_stmt(ctx *Pragma_stmtContext) interface{}

+ func (v *BaseSQLiteVisitor) VisitPragma_value(ctx *Pragma_valueContext) interface{}

+ func (v *BaseSQLiteVisitor) VisitQualified_table_name(ctx *Qualified_table_nameContext) interface{}

+ func (v *BaseSQLiteVisitor) VisitRaise_function(ctx *Raise_functionContext) interface{}

+ func (v *BaseSQLiteVisitor) VisitReindex_stmt(ctx *Reindex_stmtContext) interface{}

+ func (v *BaseSQLiteVisitor) VisitRelease_stmt(ctx *Release_stmtContext) interface{}

+ func (v *BaseSQLiteVisitor) VisitResult_column(ctx *Result_columnContext) interface{}

+ func (v *BaseSQLiteVisitor) VisitRollback_stmt(ctx *Rollback_stmtContext) interface{}

+ func (v *BaseSQLiteVisitor) VisitSavepoint_name(ctx *Savepoint_nameContext) interface{}

+ func (v *BaseSQLiteVisitor) VisitSavepoint_stmt(ctx *Savepoint_stmtContext) interface{}

+ func (v *BaseSQLiteVisitor) VisitSchema_name(ctx *Schema_nameContext) interface{}

+ func (v *BaseSQLiteVisitor) VisitSelect_core(ctx *Select_coreContext) interface{}

+ func (v *BaseSQLiteVisitor) VisitSelect_or_values(ctx *Select_or_valuesContext) interface{}

+ func (v *BaseSQLiteVisitor) VisitSelect_stmt(ctx *Select_stmtContext) interface{}

+ func (v *BaseSQLiteVisitor) VisitSigned_number(ctx *Signed_numberContext) interface{}

+ func (v *BaseSQLiteVisitor) VisitSimple_select_stmt(ctx *Simple_select_stmtContext) interface{}

+ func (v *BaseSQLiteVisitor) VisitSql_stmt(ctx *Sql_stmtContext) interface{}

+ func (v *BaseSQLiteVisitor) VisitSql_stmt_list(ctx *Sql_stmt_listContext) interface{}

+ func (v *BaseSQLiteVisitor) VisitTable_alias(ctx *Table_aliasContext) interface{}

+ func (v *BaseSQLiteVisitor) VisitTable_constraint(ctx *Table_constraintContext) interface{}

+ func (v *BaseSQLiteVisitor) VisitTable_function_name(ctx *Table_function_nameContext) interface{}

+ func (v *BaseSQLiteVisitor) VisitTable_name(ctx *Table_nameContext) interface{}

+ func (v *BaseSQLiteVisitor) VisitTable_or_index_name(ctx *Table_or_index_nameContext) interface{}

+ func (v *BaseSQLiteVisitor) VisitTable_or_subquery(ctx *Table_or_subqueryContext) interface{}

+ func (v *BaseSQLiteVisitor) VisitTransaction_name(ctx *Transaction_nameContext) interface{}

+ func (v *BaseSQLiteVisitor) VisitTrigger_name(ctx *Trigger_nameContext) interface{}

+ func (v *BaseSQLiteVisitor) VisitType_name(ctx *Type_nameContext) interface{}

+ func (v *BaseSQLiteVisitor) VisitUnary_operator(ctx *Unary_operatorContext) interface{}

+ func (v *BaseSQLiteVisitor) VisitUpdate_stmt(ctx *Update_stmtContext) interface{}

+ func (v *BaseSQLiteVisitor) VisitUpdate_stmt_limited(ctx *Update_stmt_limitedContext) interface{}

+ func (v *BaseSQLiteVisitor) VisitVacuum_stmt(ctx *Vacuum_stmtContext) interface{}

+ func (v *BaseSQLiteVisitor) VisitView_name(ctx *View_nameContext) interface{}

+ func (v *BaseSQLiteVisitor) VisitWith_clause(ctx *With_clauseContext) interface{}

+ 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) Accept(visitor antlr.ParseTreeVisitor) interface{}

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

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

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

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

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

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

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

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

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

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

+ func (s *Begin_stmtContext) Transaction_name() ITransaction_nameContext

+ type Collation_nameContext struct

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

+ func NewEmptyCollation_nameContext() *Collation_nameContext

+ func (*Collation_nameContext) IsCollation_nameContext()

+ func (s *Collation_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ 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) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ 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) Accept(visitor antlr.ParseTreeVisitor) interface{}

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

+ func (s *Column_constraintContext) Collation_name() ICollation_nameContext

+ func (s *Column_constraintContext) Conflict_clause() IConflict_clauseContext

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

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

+ func (s *Column_constraintContext) Expr() IExprContext

+ func (s *Column_constraintContext) Foreign_key_clause() IForeign_key_clauseContext

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

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

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

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

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

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

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

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

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

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

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

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

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

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

+ func (s *Column_constraintContext) Literal_value() ILiteral_valueContext

+ func (s *Column_constraintContext) Name() INameContext

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

+ func (s *Column_constraintContext) Signed_number() ISigned_numberContext

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

+ type Column_defContext struct

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

+ func NewEmptyColumn_defContext() *Column_defContext

+ func (*Column_defContext) IsColumn_defContext()

+ func (s *Column_defContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ 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) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ func (s *Column_nameContext) Any_name() IAny_nameContext

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

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

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

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

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

+ type Commit_stmtContext struct

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

+ func NewEmptyCommit_stmtContext() *Commit_stmtContext

+ func (*Commit_stmtContext) IsCommit_stmtContext()

+ func (s *Commit_stmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

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

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

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

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

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

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

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

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

+ func (s *Commit_stmtContext) Transaction_name() ITransaction_nameContext

+ type Common_table_expressionContext struct

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

+ func NewEmptyCommon_table_expressionContext() *Common_table_expressionContext

+ func (*Common_table_expressionContext) IsCommon_table_expressionContext()

+ func (s *Common_table_expressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

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

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

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

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

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

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

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

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

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

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

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

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

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

+ func (s *Common_table_expressionContext) Select_stmt() ISelect_stmtContext

+ func (s *Common_table_expressionContext) Table_name() ITable_nameContext

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

+ type Compound_operatorContext struct

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

+ func NewEmptyCompound_operatorContext() *Compound_operatorContext

+ func (*Compound_operatorContext) IsCompound_operatorContext()

+ func (s *Compound_operatorContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

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

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

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

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

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

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

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

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

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

+ type Compound_select_stmtContext struct

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

+ func NewEmptyCompound_select_stmtContext() *Compound_select_stmtContext

+ func (*Compound_select_stmtContext) IsCompound_select_stmtContext()

+ func (s *Compound_select_stmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

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

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

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

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

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

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

+ func (s *Compound_select_stmtContext) AllOrdering_term() []IOrdering_termContext

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

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

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

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

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

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

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

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

+ func (s *Compound_select_stmtContext) K_BY() antlr.TerminalNode

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

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

+ func (s *Compound_select_stmtContext) K_LIMIT() antlr.TerminalNode

+ func (s *Compound_select_stmtContext) K_OFFSET() antlr.TerminalNode

+ func (s *Compound_select_stmtContext) K_ORDER() antlr.TerminalNode

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

+ func (s *Compound_select_stmtContext) Ordering_term(i int) IOrdering_termContext

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

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

+ func (s *Compound_select_stmtContext) With_clause() IWith_clauseContext

+ type Conflict_clauseContext struct

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

+ func NewEmptyConflict_clauseContext() *Conflict_clauseContext

+ func (*Conflict_clauseContext) IsConflict_clauseContext()

+ func (s *Conflict_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

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

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

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

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

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

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

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

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

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

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

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

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

+ type Create_index_stmtContext struct

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

+ func NewEmptyCreate_index_stmtContext() *Create_index_stmtContext

+ func (*Create_index_stmtContext) IsCreate_index_stmtContext()

+ func (s *Create_index_stmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

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

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

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

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

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

+ func (s *Create_index_stmtContext) Database_name() IDatabase_nameContext

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

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

+ func (s *Create_index_stmtContext) Expr() IExprContext

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

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

+ func (s *Create_index_stmtContext) Index_name() IIndex_nameContext

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

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

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

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

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

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

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

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

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

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

+ func (s *Create_index_stmtContext) Table_name() ITable_nameContext

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

+ type Create_table_stmtContext struct

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

+ func NewEmptyCreate_table_stmtContext() *Create_table_stmtContext

+ func (*Create_table_stmtContext) IsCreate_table_stmtContext()

+ func (s *Create_table_stmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

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

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

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

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

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

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

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

+ func (s *Create_table_stmtContext) Database_name() IDatabase_nameContext

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

+ func (s *Create_table_stmtContext) Select_stmt() ISelect_stmtContext

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

+ func (s *Create_table_stmtContext) Table_name() ITable_nameContext

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

+ type Create_trigger_stmtContext struct

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

+ func NewEmptyCreate_trigger_stmtContext() *Create_trigger_stmtContext

+ func (*Create_trigger_stmtContext) IsCreate_trigger_stmtContext()

+ func (s *Create_trigger_stmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

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

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

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

+ func (s *Create_trigger_stmtContext) AllDatabase_name() []IDatabase_nameContext

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

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

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

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

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

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

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

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

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

+ func (s *Create_trigger_stmtContext) Database_name(i int) IDatabase_nameContext

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

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

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

+ func (s *Create_trigger_stmtContext) Expr() IExprContext

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

+ func (s *Create_trigger_stmtContext) Table_name() ITable_nameContext

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

+ func (s *Create_trigger_stmtContext) Trigger_name() ITrigger_nameContext

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

+ type Create_view_stmtContext struct

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

+ func NewEmptyCreate_view_stmtContext() *Create_view_stmtContext

+ func (*Create_view_stmtContext) IsCreate_view_stmtContext()

+ func (s *Create_view_stmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

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

+ func (s *Create_view_stmtContext) Database_name() IDatabase_nameContext

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

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

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

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

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

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

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

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

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

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

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

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

+ func (s *Create_view_stmtContext) Select_stmt() ISelect_stmtContext

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

+ func (s *Create_view_stmtContext) View_name() IView_nameContext

+ type Create_virtual_table_stmtContext struct

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

+ func NewEmptyCreate_virtual_table_stmtContext() *Create_virtual_table_stmtContext

+ func (*Create_virtual_table_stmtContext) IsCreate_virtual_table_stmtContext()

+ func (s *Create_virtual_table_stmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

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

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

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

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

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

+ func (s *Create_virtual_table_stmtContext) Database_name() IDatabase_nameContext

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

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

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

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

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

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

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

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

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

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

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

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

+ func (s *Create_virtual_table_stmtContext) Module_name() IModule_nameContext

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

+ func (s *Create_virtual_table_stmtContext) Table_name() ITable_nameContext

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

+ type Database_nameContext struct

+ func NewDatabase_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Database_nameContext

+ func NewEmptyDatabase_nameContext() *Database_nameContext

+ func (*Database_nameContext) IsDatabase_nameContext()

+ func (s *Database_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ func (s *Database_nameContext) Any_name() IAny_nameContext

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

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

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

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

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

+ type Delete_stmtContext struct

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

+ func NewEmptyDelete_stmtContext() *Delete_stmtContext

+ func (*Delete_stmtContext) IsDelete_stmtContext()

+ func (s *Delete_stmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

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

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

+ func (s *Delete_stmtContext) Expr() IExprContext

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

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

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

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

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

+ func (s *Delete_stmtContext) Qualified_table_name() IQualified_table_nameContext

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

+ func (s *Delete_stmtContext) With_clause() IWith_clauseContext

+ type Delete_stmt_limitedContext struct

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

+ func NewEmptyDelete_stmt_limitedContext() *Delete_stmt_limitedContext

+ func (*Delete_stmt_limitedContext) IsDelete_stmt_limitedContext()

+ func (s *Delete_stmt_limitedContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

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

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

+ func (s *Delete_stmt_limitedContext) AllOrdering_term() []IOrdering_termContext

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

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

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

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

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

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

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

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

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

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

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

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

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

+ func (s *Delete_stmt_limitedContext) Ordering_term(i int) IOrdering_termContext

+ func (s *Delete_stmt_limitedContext) Qualified_table_name() IQualified_table_nameContext

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

+ func (s *Delete_stmt_limitedContext) With_clause() IWith_clauseContext

+ type Detach_stmtContext struct

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

+ func NewEmptyDetach_stmtContext() *Detach_stmtContext

+ func (*Detach_stmtContext) IsDetach_stmtContext()

+ func (s *Detach_stmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ func (s *Detach_stmtContext) Database_name() IDatabase_nameContext

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

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

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

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

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

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

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

+ type Drop_index_stmtContext struct

+ func NewDrop_index_stmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_index_stmtContext

+ func NewEmptyDrop_index_stmtContext() *Drop_index_stmtContext

+ func (*Drop_index_stmtContext) IsDrop_index_stmtContext()

+ func (s *Drop_index_stmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

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

+ func (s *Drop_index_stmtContext) Database_name() IDatabase_nameContext

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

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

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

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

+ func (s *Drop_index_stmtContext) Index_name() IIndex_nameContext

+ func (s *Drop_index_stmtContext) K_DROP() antlr.TerminalNode

+ func (s *Drop_index_stmtContext) K_EXISTS() antlr.TerminalNode

+ func (s *Drop_index_stmtContext) K_IF() antlr.TerminalNode

+ func (s *Drop_index_stmtContext) K_INDEX() antlr.TerminalNode

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

+ type Drop_table_stmtContext struct

+ func NewDrop_table_stmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_table_stmtContext

+ func NewEmptyDrop_table_stmtContext() *Drop_table_stmtContext

+ func (*Drop_table_stmtContext) IsDrop_table_stmtContext()

+ func (s *Drop_table_stmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

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

+ func (s *Drop_table_stmtContext) Database_name() IDatabase_nameContext

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

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

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

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

+ func (s *Drop_table_stmtContext) K_DROP() antlr.TerminalNode

+ func (s *Drop_table_stmtContext) K_EXISTS() antlr.TerminalNode

+ func (s *Drop_table_stmtContext) K_IF() antlr.TerminalNode

+ func (s *Drop_table_stmtContext) K_TABLE() antlr.TerminalNode

+ func (s *Drop_table_stmtContext) Table_name() ITable_nameContext

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

+ type Drop_trigger_stmtContext struct

+ func NewDrop_trigger_stmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_trigger_stmtContext

+ func NewEmptyDrop_trigger_stmtContext() *Drop_trigger_stmtContext

+ func (*Drop_trigger_stmtContext) IsDrop_trigger_stmtContext()

+ func (s *Drop_trigger_stmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

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

+ func (s *Drop_trigger_stmtContext) Database_name() IDatabase_nameContext

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

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

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

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

+ func (s *Drop_trigger_stmtContext) K_DROP() antlr.TerminalNode

+ func (s *Drop_trigger_stmtContext) K_EXISTS() antlr.TerminalNode

+ func (s *Drop_trigger_stmtContext) K_IF() antlr.TerminalNode

+ func (s *Drop_trigger_stmtContext) K_TRIGGER() antlr.TerminalNode

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

+ func (s *Drop_trigger_stmtContext) Trigger_name() ITrigger_nameContext

+ type Drop_view_stmtContext struct

+ func NewDrop_view_stmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_view_stmtContext

+ func NewEmptyDrop_view_stmtContext() *Drop_view_stmtContext

+ func (*Drop_view_stmtContext) IsDrop_view_stmtContext()

+ func (s *Drop_view_stmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

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

+ func (s *Drop_view_stmtContext) Database_name() IDatabase_nameContext

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

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

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

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

+ func (s *Drop_view_stmtContext) K_DROP() antlr.TerminalNode

+ func (s *Drop_view_stmtContext) K_EXISTS() antlr.TerminalNode

+ func (s *Drop_view_stmtContext) K_IF() antlr.TerminalNode

+ func (s *Drop_view_stmtContext) K_VIEW() antlr.TerminalNode

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

+ func (s *Drop_view_stmtContext) View_name() IView_nameContext

+ type Error_messageContext struct

+ func NewEmptyError_messageContext() *Error_messageContext

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

+ func (*Error_messageContext) IsError_messageContext()

+ func (s *Error_messageContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

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

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

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

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

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

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

+ type ExprContext struct

+ func NewEmptyExprContext() *ExprContext

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

+ func (*ExprContext) IsExprContext()

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

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

+ func (s *ExprContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

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

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

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

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

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

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

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

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

+ func (s *ExprContext) Collation_name() ICollation_nameContext

+ func (s *ExprContext) Column_name() IColumn_nameContext

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

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

+ func (s *ExprContext) Database_name() IDatabase_nameContext

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

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

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

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

+ func (s *ExprContext) Function_name() IFunction_nameContext

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

+ func (s *ExprContext) Literal_value() ILiteral_valueContext

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

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

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

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

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

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

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

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

+ func (s *ExprContext) Raise_function() IRaise_functionContext

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

+ func (s *ExprContext) Select_stmt() ISelect_stmtContext

+ func (s *ExprContext) Table_name() ITable_nameContext

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

+ func (s *ExprContext) Type_name() IType_nameContext

+ func (s *ExprContext) Unary_operator() IUnary_operatorContext

+ type Factored_select_stmtContext struct

+ func NewEmptyFactored_select_stmtContext() *Factored_select_stmtContext

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

+ func (*Factored_select_stmtContext) IsFactored_select_stmtContext()

+ func (s *Factored_select_stmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

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

+ func (s *Factored_select_stmtContext) AllCompound_operator() []ICompound_operatorContext

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

+ func (s *Factored_select_stmtContext) AllOrdering_term() []IOrdering_termContext

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

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

+ func (s *Factored_select_stmtContext) Compound_operator(i int) ICompound_operatorContext

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

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

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

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

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

+ func (s *Factored_select_stmtContext) K_BY() antlr.TerminalNode

+ func (s *Factored_select_stmtContext) K_LIMIT() antlr.TerminalNode

+ func (s *Factored_select_stmtContext) K_OFFSET() antlr.TerminalNode

+ func (s *Factored_select_stmtContext) K_ORDER() antlr.TerminalNode

+ func (s *Factored_select_stmtContext) Ordering_term(i int) IOrdering_termContext

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

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

+ func (s *Factored_select_stmtContext) With_clause() IWith_clauseContext

+ type Foreign_key_clauseContext struct

+ func NewEmptyForeign_key_clauseContext() *Foreign_key_clauseContext

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

+ func (*Foreign_key_clauseContext) IsForeign_key_clauseContext()

+ func (s *Foreign_key_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

+ func (s *Foreign_key_clauseContext) Foreign_table() IForeign_tableContext

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

+ type Foreign_tableContext struct

+ func NewEmptyForeign_tableContext() *Foreign_tableContext

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

+ func (*Foreign_tableContext) IsForeign_tableContext()

+ func (s *Foreign_tableContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ func (s *Foreign_tableContext) Any_name() IAny_nameContext

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

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

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

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

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

+ type Function_nameContext struct

+ func NewEmptyFunction_nameContext() *Function_nameContext

+ func NewFunction_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Function_nameContext

+ func (*Function_nameContext) IsFunction_nameContext()

+ func (s *Function_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ func (s *Function_nameContext) Any_name() IAny_nameContext

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

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

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

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

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

+ type IAlter_table_stmtContext interface

+ GetParser func() antlr.Parser

+ IsAlter_table_stmtContext func()

+ type IAnalyze_stmtContext interface

+ GetParser func() antlr.Parser

+ IsAnalyze_stmtContext func()

+ type IAny_nameContext interface

+ GetParser func() antlr.Parser

+ IsAny_nameContext func()

+ type IAttach_stmtContext interface

+ GetParser func() antlr.Parser

+ IsAttach_stmtContext func()

+ type IBegin_stmtContext interface

+ GetParser func() antlr.Parser

+ IsBegin_stmtContext func()

+ type ICollation_nameContext interface

+ GetParser func() antlr.Parser

+ IsCollation_nameContext func()

+ type IColumn_aliasContext interface

+ GetParser func() antlr.Parser

+ IsColumn_aliasContext func()

+ type IColumn_constraintContext interface

+ GetParser func() antlr.Parser

+ IsColumn_constraintContext func()

+ type IColumn_defContext interface

+ GetParser func() antlr.Parser

+ IsColumn_defContext func()

+ type IColumn_nameContext interface

+ GetParser func() antlr.Parser

+ IsColumn_nameContext func()

+ type ICommit_stmtContext interface

+ GetParser func() antlr.Parser

+ IsCommit_stmtContext func()

+ type ICommon_table_expressionContext interface

+ GetParser func() antlr.Parser

+ IsCommon_table_expressionContext func()

+ type ICompound_operatorContext interface

+ GetParser func() antlr.Parser

+ IsCompound_operatorContext func()

+ type ICompound_select_stmtContext interface

+ GetParser func() antlr.Parser

+ IsCompound_select_stmtContext func()

+ type IConflict_clauseContext interface

+ GetParser func() antlr.Parser

+ IsConflict_clauseContext func()

+ type ICreate_index_stmtContext interface

+ GetParser func() antlr.Parser

+ IsCreate_index_stmtContext func()

+ type ICreate_table_stmtContext interface

+ GetParser func() antlr.Parser

+ IsCreate_table_stmtContext func()

+ type ICreate_trigger_stmtContext interface

+ GetParser func() antlr.Parser

+ IsCreate_trigger_stmtContext func()

+ type ICreate_view_stmtContext interface

+ GetParser func() antlr.Parser

+ IsCreate_view_stmtContext func()

+ type ICreate_virtual_table_stmtContext interface

+ GetParser func() antlr.Parser

+ IsCreate_virtual_table_stmtContext func()

+ type IDatabase_nameContext interface

+ GetParser func() antlr.Parser

+ IsDatabase_nameContext func()

+ type IDelete_stmtContext interface

+ GetParser func() antlr.Parser

+ IsDelete_stmtContext func()

+ type IDelete_stmt_limitedContext interface

+ GetParser func() antlr.Parser

+ IsDelete_stmt_limitedContext func()

+ type IDetach_stmtContext interface

+ GetParser func() antlr.Parser

+ IsDetach_stmtContext func()

+ type IDrop_index_stmtContext interface

+ GetParser func() antlr.Parser

+ IsDrop_index_stmtContext func()

+ type IDrop_table_stmtContext interface

+ GetParser func() antlr.Parser

+ IsDrop_table_stmtContext func()

+ type IDrop_trigger_stmtContext interface

+ GetParser func() antlr.Parser

+ IsDrop_trigger_stmtContext func()

+ type IDrop_view_stmtContext interface

+ GetParser func() antlr.Parser

+ IsDrop_view_stmtContext func()

+ type IError_messageContext interface

+ GetParser func() antlr.Parser

+ IsError_messageContext func()

+ type IExprContext interface

+ GetParser func() antlr.Parser

+ IsExprContext func()

+ type IFactored_select_stmtContext interface

+ GetParser func() antlr.Parser

+ IsFactored_select_stmtContext func()

+ type IForeign_key_clauseContext interface

+ GetParser func() antlr.Parser

+ IsForeign_key_clauseContext func()

+ type IForeign_tableContext interface

+ GetParser func() antlr.Parser

+ IsForeign_tableContext func()

+ type IFunction_nameContext interface

+ GetParser func() antlr.Parser

+ IsFunction_nameContext func()

+ type IIndex_nameContext interface

+ GetParser func() antlr.Parser

+ IsIndex_nameContext func()

+ type IIndexed_columnContext interface

+ GetParser func() antlr.Parser

+ IsIndexed_columnContext func()

+ type IInsert_stmtContext interface

+ GetParser func() antlr.Parser

+ IsInsert_stmtContext func()

+ type IJoin_clauseContext interface

+ GetParser func() antlr.Parser

+ IsJoin_clauseContext func()

+ type IJoin_constraintContext interface

+ GetParser func() antlr.Parser

+ IsJoin_constraintContext func()

+ type IJoin_operatorContext interface

+ GetParser func() antlr.Parser

+ IsJoin_operatorContext func()

+ type IKeywordContext interface

+ GetParser func() antlr.Parser

+ IsKeywordContext func()

+ type ILiteral_valueContext interface

+ GetParser func() antlr.Parser

+ IsLiteral_valueContext func()

+ type IModule_argumentContext interface

+ GetParser func() antlr.Parser

+ IsModule_argumentContext func()

+ type IModule_nameContext interface

+ GetParser func() antlr.Parser

+ IsModule_nameContext func()

+ type INameContext interface

+ GetParser func() antlr.Parser

+ IsNameContext func()

+ type INew_table_nameContext interface

+ GetParser func() antlr.Parser

+ IsNew_table_nameContext func()

+ type IOrdering_termContext interface

+ GetParser func() antlr.Parser

+ IsOrdering_termContext func()

+ type IParseContext interface

+ GetParser func() antlr.Parser

+ IsParseContext func()

+ type IPragma_nameContext interface

+ GetParser func() antlr.Parser

+ IsPragma_nameContext func()

+ type IPragma_stmtContext interface

+ GetParser func() antlr.Parser

+ IsPragma_stmtContext func()

+ type IPragma_valueContext interface

+ GetParser func() antlr.Parser

+ IsPragma_valueContext func()

+ type IQualified_table_nameContext interface

+ GetParser func() antlr.Parser

+ IsQualified_table_nameContext func()

+ type IRaise_functionContext interface

+ GetParser func() antlr.Parser

+ IsRaise_functionContext func()

+ type IReindex_stmtContext interface

+ GetParser func() antlr.Parser

+ IsReindex_stmtContext func()

+ type IRelease_stmtContext interface

+ GetParser func() antlr.Parser

+ IsRelease_stmtContext func()

+ type IResult_columnContext interface

+ GetParser func() antlr.Parser

+ IsResult_columnContext func()

+ type IRollback_stmtContext interface

+ GetParser func() antlr.Parser

+ IsRollback_stmtContext func()

+ type ISavepoint_nameContext interface

+ GetParser func() antlr.Parser

+ IsSavepoint_nameContext func()

+ type ISavepoint_stmtContext interface

+ GetParser func() antlr.Parser

+ IsSavepoint_stmtContext func()

+ type ISchema_nameContext interface

+ GetParser func() antlr.Parser

+ IsSchema_nameContext func()

+ type ISelect_coreContext interface

+ GetParser func() antlr.Parser

+ IsSelect_coreContext func()

+ type ISelect_or_valuesContext interface

+ GetParser func() antlr.Parser

+ IsSelect_or_valuesContext func()

+ type ISelect_stmtContext interface

+ GetParser func() antlr.Parser

+ IsSelect_stmtContext func()

+ type ISigned_numberContext interface

+ GetParser func() antlr.Parser

+ IsSigned_numberContext func()

+ type ISimple_select_stmtContext interface

+ GetParser func() antlr.Parser

+ IsSimple_select_stmtContext func()

+ type ISql_stmtContext interface

+ GetParser func() antlr.Parser

+ IsSql_stmtContext func()

+ type ISql_stmt_listContext interface

+ GetParser func() antlr.Parser

+ IsSql_stmt_listContext func()

+ type ITable_aliasContext interface

+ GetParser func() antlr.Parser

+ IsTable_aliasContext func()

+ type ITable_constraintContext interface

+ GetParser func() antlr.Parser

+ IsTable_constraintContext func()

+ type ITable_function_nameContext interface

+ GetParser func() antlr.Parser

+ IsTable_function_nameContext func()

+ type ITable_nameContext interface

+ GetParser func() antlr.Parser

+ IsTable_nameContext func()

+ type ITable_or_index_nameContext interface

+ GetParser func() antlr.Parser

+ IsTable_or_index_nameContext func()

+ type ITable_or_subqueryContext interface

+ GetParser func() antlr.Parser

+ IsTable_or_subqueryContext func()

+ type ITransaction_nameContext interface

+ GetParser func() antlr.Parser

+ IsTransaction_nameContext func()

+ type ITrigger_nameContext interface

+ GetParser func() antlr.Parser

+ IsTrigger_nameContext func()

+ type IType_nameContext interface

+ GetParser func() antlr.Parser

+ IsType_nameContext func()

+ type IUnary_operatorContext interface

+ GetParser func() antlr.Parser

+ IsUnary_operatorContext func()

+ type IUpdate_stmtContext interface

+ GetParser func() antlr.Parser

+ IsUpdate_stmtContext func()

+ type IUpdate_stmt_limitedContext interface

+ GetParser func() antlr.Parser

+ IsUpdate_stmt_limitedContext func()

+ type IVacuum_stmtContext interface

+ GetParser func() antlr.Parser

+ IsVacuum_stmtContext func()

+ type IView_nameContext interface

+ GetParser func() antlr.Parser

+ IsView_nameContext func()

+ type IWith_clauseContext interface

+ GetParser func() antlr.Parser

+ IsWith_clauseContext func()

+ type Index_nameContext struct

+ func NewEmptyIndex_nameContext() *Index_nameContext

+ func NewIndex_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Index_nameContext

+ func (*Index_nameContext) IsIndex_nameContext()

+ func (s *Index_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ 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) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ func (s *Indexed_columnContext) Collation_name() ICollation_nameContext

+ func (s *Indexed_columnContext) Column_name() IColumn_nameContext

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

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

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

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

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

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

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

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

+ type Insert_stmtContext struct

+ func NewEmptyInsert_stmtContext() *Insert_stmtContext

+ func NewInsert_stmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Insert_stmtContext

+ func (*Insert_stmtContext) IsInsert_stmtContext()

+ func (s *Insert_stmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

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

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

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

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

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

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

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

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

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

+ func (s *Insert_stmtContext) Database_name() IDatabase_nameContext

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

+ func (s *Insert_stmtContext) Select_stmt() ISelect_stmtContext

+ func (s *Insert_stmtContext) Table_name() ITable_nameContext

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

+ func (s *Insert_stmtContext) With_clause() IWith_clauseContext

+ type Join_clauseContext struct

+ func NewEmptyJoin_clauseContext() *Join_clauseContext

+ func NewJoin_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Join_clauseContext

+ func (*Join_clauseContext) IsJoin_clauseContext()

+ func (s *Join_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ 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) Accept(visitor antlr.ParseTreeVisitor) interface{}

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

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

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

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

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

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

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

+ func (s *Join_constraintContext) Expr() IExprContext

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

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

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

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

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

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

+ type Join_operatorContext struct

+ func NewEmptyJoin_operatorContext() *Join_operatorContext

+ func NewJoin_operatorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Join_operatorContext

+ func (*Join_operatorContext) IsJoin_operatorContext()

+ func (s *Join_operatorContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

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

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

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

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

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

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

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

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

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

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

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

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

+ type KeywordContext struct

+ func NewEmptyKeywordContext() *KeywordContext

+ func NewKeywordContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KeywordContext

+ func (*KeywordContext) IsKeywordContext()

+ func (s *KeywordContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

+ func (s *KeywordContext) K_UPDATE() antlr.TerminalNode

+ func (s *KeywordContext) K_USING() antlr.TerminalNode

+ func (s *KeywordContext) K_VACUUM() antlr.TerminalNode

+ func (s *KeywordContext) K_VALUES() antlr.TerminalNode

+ func (s *KeywordContext) K_VIEW() antlr.TerminalNode

+ func (s *KeywordContext) K_VIRTUAL() antlr.TerminalNode

+ func (s *KeywordContext) K_WHEN() antlr.TerminalNode

+ func (s *KeywordContext) K_WHERE() antlr.TerminalNode

+ func (s *KeywordContext) K_WITH() antlr.TerminalNode

+ func (s *KeywordContext) K_WITHOUT() antlr.TerminalNode

+ func (s *KeywordContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type Literal_valueContext struct

+ func NewEmptyLiteral_valueContext() *Literal_valueContext

+ func NewLiteral_valueContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Literal_valueContext

+ func (*Literal_valueContext) IsLiteral_valueContext()

+ func (s *Literal_valueContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ func (s *Literal_valueContext) BLOB_LITERAL() antlr.TerminalNode

+ func (s *Literal_valueContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Literal_valueContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Literal_valueContext) GetParser() antlr.Parser

+ func (s *Literal_valueContext) GetRuleContext() antlr.RuleContext

+ func (s *Literal_valueContext) K_CURRENT_DATE() antlr.TerminalNode

+ func (s *Literal_valueContext) K_CURRENT_TIME() antlr.TerminalNode

+ func (s *Literal_valueContext) K_CURRENT_TIMESTAMP() antlr.TerminalNode

+ func (s *Literal_valueContext) K_NULL() antlr.TerminalNode

+ func (s *Literal_valueContext) NUMERIC_LITERAL() antlr.TerminalNode

+ func (s *Literal_valueContext) STRING_LITERAL() antlr.TerminalNode

+ func (s *Literal_valueContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type Module_argumentContext struct

+ func NewEmptyModule_argumentContext() *Module_argumentContext

+ func NewModule_argumentContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Module_argumentContext

+ func (*Module_argumentContext) IsModule_argumentContext()

+ func (s *Module_argumentContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ 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) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ 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) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ 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) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ func (s *New_table_nameContext) Any_name() IAny_nameContext

+ func (s *New_table_nameContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *New_table_nameContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *New_table_nameContext) GetParser() antlr.Parser

+ func (s *New_table_nameContext) GetRuleContext() antlr.RuleContext

+ func (s *New_table_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type Ordering_termContext struct

+ func NewEmptyOrdering_termContext() *Ordering_termContext

+ func NewOrdering_termContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Ordering_termContext

+ func (*Ordering_termContext) IsOrdering_termContext()

+ func (s *Ordering_termContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ func (s *Ordering_termContext) Collation_name() ICollation_nameContext

+ func (s *Ordering_termContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Ordering_termContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Ordering_termContext) Expr() IExprContext

+ func (s *Ordering_termContext) GetParser() antlr.Parser

+ func (s *Ordering_termContext) GetRuleContext() antlr.RuleContext

+ func (s *Ordering_termContext) K_ASC() antlr.TerminalNode

+ func (s *Ordering_termContext) K_COLLATE() antlr.TerminalNode

+ func (s *Ordering_termContext) K_DESC() antlr.TerminalNode

+ func (s *Ordering_termContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type ParseContext struct

+ func NewEmptyParseContext() *ParseContext

+ func NewParseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ParseContext

+ func (*ParseContext) IsParseContext()

+ func (s *ParseContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ func (s *ParseContext) AllSql_stmt_list() []ISql_stmt_listContext

+ func (s *ParseContext) EOF() antlr.TerminalNode

+ func (s *ParseContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *ParseContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *ParseContext) GetParser() antlr.Parser

+ func (s *ParseContext) GetRuleContext() antlr.RuleContext

+ func (s *ParseContext) Sql_stmt_list(i int) ISql_stmt_listContext

+ func (s *ParseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type Pragma_nameContext struct

+ func NewEmptyPragma_nameContext() *Pragma_nameContext

+ func NewPragma_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Pragma_nameContext

+ func (*Pragma_nameContext) IsPragma_nameContext()

+ func (s *Pragma_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ 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) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ func (s *Pragma_stmtContext) CLOSE_PAR() antlr.TerminalNode

+ func (s *Pragma_stmtContext) DOT() antlr.TerminalNode

+ func (s *Pragma_stmtContext) Database_name() IDatabase_nameContext

+ func (s *Pragma_stmtContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Pragma_stmtContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Pragma_stmtContext) GetParser() antlr.Parser

+ func (s *Pragma_stmtContext) GetRuleContext() antlr.RuleContext

+ func (s *Pragma_stmtContext) K_PRAGMA() antlr.TerminalNode

+ func (s *Pragma_stmtContext) OPEN_PAR() antlr.TerminalNode

+ func (s *Pragma_stmtContext) Pragma_name() IPragma_nameContext

+ func (s *Pragma_stmtContext) Pragma_value() IPragma_valueContext

+ func (s *Pragma_stmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type Pragma_valueContext struct

+ func NewEmptyPragma_valueContext() *Pragma_valueContext

+ func NewPragma_valueContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Pragma_valueContext

+ func (*Pragma_valueContext) IsPragma_valueContext()

+ func (s *Pragma_valueContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ 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) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ func (s *Qualified_table_nameContext) DOT() antlr.TerminalNode

+ func (s *Qualified_table_nameContext) Database_name() IDatabase_nameContext

+ func (s *Qualified_table_nameContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Qualified_table_nameContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Qualified_table_nameContext) GetParser() antlr.Parser

+ func (s *Qualified_table_nameContext) GetRuleContext() antlr.RuleContext

+ func (s *Qualified_table_nameContext) Index_name() IIndex_nameContext

+ func (s *Qualified_table_nameContext) K_BY() antlr.TerminalNode

+ func (s *Qualified_table_nameContext) K_INDEXED() antlr.TerminalNode

+ func (s *Qualified_table_nameContext) K_NOT() antlr.TerminalNode

+ func (s *Qualified_table_nameContext) Table_name() ITable_nameContext

+ func (s *Qualified_table_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type Raise_functionContext struct

+ func NewEmptyRaise_functionContext() *Raise_functionContext

+ func NewRaise_functionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Raise_functionContext

+ func (*Raise_functionContext) IsRaise_functionContext()

+ func (s *Raise_functionContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ func (s *Raise_functionContext) CLOSE_PAR() antlr.TerminalNode

+ func (s *Raise_functionContext) COMMA() antlr.TerminalNode

+ func (s *Raise_functionContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Raise_functionContext) Error_message() IError_messageContext

+ func (s *Raise_functionContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Raise_functionContext) GetParser() antlr.Parser

+ func (s *Raise_functionContext) GetRuleContext() antlr.RuleContext

+ func (s *Raise_functionContext) K_ABORT() antlr.TerminalNode

+ func (s *Raise_functionContext) K_FAIL() antlr.TerminalNode

+ func (s *Raise_functionContext) K_IGNORE() antlr.TerminalNode

+ func (s *Raise_functionContext) K_RAISE() antlr.TerminalNode

+ func (s *Raise_functionContext) K_ROLLBACK() antlr.TerminalNode

+ func (s *Raise_functionContext) OPEN_PAR() antlr.TerminalNode

+ func (s *Raise_functionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type Reindex_stmtContext struct

+ func NewEmptyReindex_stmtContext() *Reindex_stmtContext

+ func NewReindex_stmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Reindex_stmtContext

+ func (*Reindex_stmtContext) IsReindex_stmtContext()

+ func (s *Reindex_stmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ func (s *Reindex_stmtContext) Collation_name() ICollation_nameContext

+ func (s *Reindex_stmtContext) DOT() antlr.TerminalNode

+ func (s *Reindex_stmtContext) Database_name() IDatabase_nameContext

+ func (s *Reindex_stmtContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Reindex_stmtContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Reindex_stmtContext) GetParser() antlr.Parser

+ func (s *Reindex_stmtContext) GetRuleContext() antlr.RuleContext

+ func (s *Reindex_stmtContext) Index_name() IIndex_nameContext

+ func (s *Reindex_stmtContext) K_REINDEX() antlr.TerminalNode

+ func (s *Reindex_stmtContext) Table_name() ITable_nameContext

+ func (s *Reindex_stmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type Release_stmtContext struct

+ func NewEmptyRelease_stmtContext() *Release_stmtContext

+ func NewRelease_stmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Release_stmtContext

+ func (*Release_stmtContext) IsRelease_stmtContext()

+ func (s *Release_stmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ func (s *Release_stmtContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Release_stmtContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Release_stmtContext) GetParser() antlr.Parser

+ func (s *Release_stmtContext) GetRuleContext() antlr.RuleContext

+ func (s *Release_stmtContext) K_RELEASE() antlr.TerminalNode

+ func (s *Release_stmtContext) K_SAVEPOINT() antlr.TerminalNode

+ func (s *Release_stmtContext) Savepoint_name() ISavepoint_nameContext

+ func (s *Release_stmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type Result_columnContext struct

+ func NewEmptyResult_columnContext() *Result_columnContext

+ func NewResult_columnContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Result_columnContext

+ func (*Result_columnContext) IsResult_columnContext()

+ func (s *Result_columnContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ func (s *Result_columnContext) Column_alias() IColumn_aliasContext

+ func (s *Result_columnContext) DOT() antlr.TerminalNode

+ func (s *Result_columnContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Result_columnContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Result_columnContext) Expr() IExprContext

+ func (s *Result_columnContext) GetParser() antlr.Parser

+ func (s *Result_columnContext) GetRuleContext() antlr.RuleContext

+ func (s *Result_columnContext) K_AS() antlr.TerminalNode

+ func (s *Result_columnContext) STAR() antlr.TerminalNode

+ func (s *Result_columnContext) Table_name() ITable_nameContext

+ func (s *Result_columnContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type Rollback_stmtContext struct

+ func NewEmptyRollback_stmtContext() *Rollback_stmtContext

+ func NewRollback_stmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Rollback_stmtContext

+ func (*Rollback_stmtContext) IsRollback_stmtContext()

+ func (s *Rollback_stmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ func (s *Rollback_stmtContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Rollback_stmtContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Rollback_stmtContext) GetParser() antlr.Parser

+ func (s *Rollback_stmtContext) GetRuleContext() antlr.RuleContext

+ func (s *Rollback_stmtContext) K_ROLLBACK() antlr.TerminalNode

+ func (s *Rollback_stmtContext) K_SAVEPOINT() antlr.TerminalNode

+ func (s *Rollback_stmtContext) K_TO() antlr.TerminalNode

+ func (s *Rollback_stmtContext) K_TRANSACTION() antlr.TerminalNode

+ func (s *Rollback_stmtContext) Savepoint_name() ISavepoint_nameContext

+ func (s *Rollback_stmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ func (s *Rollback_stmtContext) Transaction_name() ITransaction_nameContext

+ type SQLiteLexer struct

+ func NewSQLiteLexer(input antlr.CharStream) *SQLiteLexer

+ type SQLiteListener interface

+ EnterAlter_table_stmt func(c *Alter_table_stmtContext)

+ EnterAnalyze_stmt func(c *Analyze_stmtContext)

+ EnterAny_name func(c *Any_nameContext)

+ EnterAttach_stmt func(c *Attach_stmtContext)

+ EnterBegin_stmt func(c *Begin_stmtContext)

+ EnterCollation_name func(c *Collation_nameContext)

+ EnterColumn_alias func(c *Column_aliasContext)

+ EnterColumn_constraint func(c *Column_constraintContext)

+ EnterColumn_def func(c *Column_defContext)

+ EnterColumn_name func(c *Column_nameContext)

+ EnterCommit_stmt func(c *Commit_stmtContext)

+ EnterCommon_table_expression func(c *Common_table_expressionContext)

+ EnterCompound_operator func(c *Compound_operatorContext)

+ EnterCompound_select_stmt func(c *Compound_select_stmtContext)

+ EnterConflict_clause func(c *Conflict_clauseContext)

+ EnterCreate_index_stmt func(c *Create_index_stmtContext)

+ EnterCreate_table_stmt func(c *Create_table_stmtContext)

+ EnterCreate_trigger_stmt func(c *Create_trigger_stmtContext)

+ EnterCreate_view_stmt func(c *Create_view_stmtContext)

+ EnterCreate_virtual_table_stmt func(c *Create_virtual_table_stmtContext)

+ EnterDatabase_name func(c *Database_nameContext)

+ EnterDelete_stmt func(c *Delete_stmtContext)

+ EnterDelete_stmt_limited func(c *Delete_stmt_limitedContext)

+ EnterDetach_stmt func(c *Detach_stmtContext)

+ EnterDrop_index_stmt func(c *Drop_index_stmtContext)

+ EnterDrop_table_stmt func(c *Drop_table_stmtContext)

+ EnterDrop_trigger_stmt func(c *Drop_trigger_stmtContext)

+ EnterDrop_view_stmt func(c *Drop_view_stmtContext)

+ EnterError_message func(c *Error_messageContext)

+ EnterExpr func(c *ExprContext)

+ EnterFactored_select_stmt func(c *Factored_select_stmtContext)

+ EnterForeign_key_clause func(c *Foreign_key_clauseContext)

+ EnterForeign_table func(c *Foreign_tableContext)

+ EnterFunction_name func(c *Function_nameContext)

+ EnterIndex_name func(c *Index_nameContext)

+ EnterIndexed_column func(c *Indexed_columnContext)

+ EnterInsert_stmt func(c *Insert_stmtContext)

+ EnterJoin_clause func(c *Join_clauseContext)

+ EnterJoin_constraint func(c *Join_constraintContext)

+ EnterJoin_operator func(c *Join_operatorContext)

+ EnterKeyword func(c *KeywordContext)

+ EnterLiteral_value func(c *Literal_valueContext)

+ EnterModule_argument func(c *Module_argumentContext)

+ EnterModule_name func(c *Module_nameContext)

+ EnterName func(c *NameContext)

+ EnterNew_table_name func(c *New_table_nameContext)

+ EnterOrdering_term func(c *Ordering_termContext)

+ EnterParse func(c *ParseContext)

+ EnterPragma_name func(c *Pragma_nameContext)

+ EnterPragma_stmt func(c *Pragma_stmtContext)

+ EnterPragma_value func(c *Pragma_valueContext)

+ EnterQualified_table_name func(c *Qualified_table_nameContext)

+ EnterRaise_function func(c *Raise_functionContext)

+ EnterReindex_stmt func(c *Reindex_stmtContext)

+ EnterRelease_stmt func(c *Release_stmtContext)

+ EnterResult_column func(c *Result_columnContext)

+ EnterRollback_stmt func(c *Rollback_stmtContext)

+ EnterSavepoint_name func(c *Savepoint_nameContext)

+ EnterSavepoint_stmt func(c *Savepoint_stmtContext)

+ EnterSchema_name func(c *Schema_nameContext)

+ EnterSelect_core func(c *Select_coreContext)

+ EnterSelect_or_values func(c *Select_or_valuesContext)

+ EnterSelect_stmt func(c *Select_stmtContext)

+ EnterSigned_number func(c *Signed_numberContext)

+ EnterSimple_select_stmt func(c *Simple_select_stmtContext)

+ EnterSql_stmt func(c *Sql_stmtContext)

+ EnterSql_stmt_list func(c *Sql_stmt_listContext)

+ EnterTable_alias func(c *Table_aliasContext)

+ EnterTable_constraint func(c *Table_constraintContext)

+ EnterTable_function_name func(c *Table_function_nameContext)

+ EnterTable_name func(c *Table_nameContext)

+ EnterTable_or_index_name func(c *Table_or_index_nameContext)

+ EnterTable_or_subquery func(c *Table_or_subqueryContext)

+ EnterTransaction_name func(c *Transaction_nameContext)

+ EnterTrigger_name func(c *Trigger_nameContext)

+ EnterType_name func(c *Type_nameContext)

+ EnterUnary_operator func(c *Unary_operatorContext)

+ EnterUpdate_stmt func(c *Update_stmtContext)

+ EnterUpdate_stmt_limited func(c *Update_stmt_limitedContext)

+ EnterVacuum_stmt func(c *Vacuum_stmtContext)

+ EnterView_name func(c *View_nameContext)

+ EnterWith_clause func(c *With_clauseContext)

+ ExitAlter_table_stmt func(c *Alter_table_stmtContext)

+ ExitAnalyze_stmt func(c *Analyze_stmtContext)

+ ExitAny_name func(c *Any_nameContext)

+ ExitAttach_stmt func(c *Attach_stmtContext)

+ ExitBegin_stmt func(c *Begin_stmtContext)

+ ExitCollation_name func(c *Collation_nameContext)

+ ExitColumn_alias func(c *Column_aliasContext)

+ ExitColumn_constraint func(c *Column_constraintContext)

+ ExitColumn_def func(c *Column_defContext)

+ ExitColumn_name func(c *Column_nameContext)

+ ExitCommit_stmt func(c *Commit_stmtContext)

+ ExitCommon_table_expression func(c *Common_table_expressionContext)

+ ExitCompound_operator func(c *Compound_operatorContext)

+ ExitCompound_select_stmt func(c *Compound_select_stmtContext)

+ ExitConflict_clause func(c *Conflict_clauseContext)

+ ExitCreate_index_stmt func(c *Create_index_stmtContext)

+ ExitCreate_table_stmt func(c *Create_table_stmtContext)

+ ExitCreate_trigger_stmt func(c *Create_trigger_stmtContext)

+ ExitCreate_view_stmt func(c *Create_view_stmtContext)

+ ExitCreate_virtual_table_stmt func(c *Create_virtual_table_stmtContext)

+ ExitDatabase_name func(c *Database_nameContext)

+ ExitDelete_stmt func(c *Delete_stmtContext)

+ ExitDelete_stmt_limited func(c *Delete_stmt_limitedContext)

+ ExitDetach_stmt func(c *Detach_stmtContext)

+ ExitDrop_index_stmt func(c *Drop_index_stmtContext)

+ ExitDrop_table_stmt func(c *Drop_table_stmtContext)

+ ExitDrop_trigger_stmt func(c *Drop_trigger_stmtContext)

+ ExitDrop_view_stmt func(c *Drop_view_stmtContext)

+ ExitError_message func(c *Error_messageContext)

+ ExitExpr func(c *ExprContext)

+ ExitFactored_select_stmt func(c *Factored_select_stmtContext)

+ ExitForeign_key_clause func(c *Foreign_key_clauseContext)

+ ExitForeign_table func(c *Foreign_tableContext)

+ ExitFunction_name func(c *Function_nameContext)

+ ExitIndex_name func(c *Index_nameContext)

+ ExitIndexed_column func(c *Indexed_columnContext)

+ ExitInsert_stmt func(c *Insert_stmtContext)

+ ExitJoin_clause func(c *Join_clauseContext)

+ ExitJoin_constraint func(c *Join_constraintContext)

+ ExitJoin_operator func(c *Join_operatorContext)

+ ExitKeyword func(c *KeywordContext)

+ ExitLiteral_value func(c *Literal_valueContext)

+ ExitModule_argument func(c *Module_argumentContext)

+ ExitModule_name func(c *Module_nameContext)

+ ExitName func(c *NameContext)

+ ExitNew_table_name func(c *New_table_nameContext)

+ ExitOrdering_term func(c *Ordering_termContext)

+ ExitParse func(c *ParseContext)

+ ExitPragma_name func(c *Pragma_nameContext)

+ ExitPragma_stmt func(c *Pragma_stmtContext)

+ ExitPragma_value func(c *Pragma_valueContext)

+ ExitQualified_table_name func(c *Qualified_table_nameContext)

+ ExitRaise_function func(c *Raise_functionContext)

+ ExitReindex_stmt func(c *Reindex_stmtContext)

+ ExitRelease_stmt func(c *Release_stmtContext)

+ ExitResult_column func(c *Result_columnContext)

+ ExitRollback_stmt func(c *Rollback_stmtContext)

+ ExitSavepoint_name func(c *Savepoint_nameContext)

+ ExitSavepoint_stmt func(c *Savepoint_stmtContext)

+ ExitSchema_name func(c *Schema_nameContext)

+ ExitSelect_core func(c *Select_coreContext)

+ ExitSelect_or_values func(c *Select_or_valuesContext)

+ ExitSelect_stmt func(c *Select_stmtContext)

+ ExitSigned_number func(c *Signed_numberContext)

+ ExitSimple_select_stmt func(c *Simple_select_stmtContext)

+ ExitSql_stmt func(c *Sql_stmtContext)

+ ExitSql_stmt_list func(c *Sql_stmt_listContext)

+ ExitTable_alias func(c *Table_aliasContext)

+ ExitTable_constraint func(c *Table_constraintContext)

+ ExitTable_function_name func(c *Table_function_nameContext)

+ ExitTable_name func(c *Table_nameContext)

+ ExitTable_or_index_name func(c *Table_or_index_nameContext)

+ ExitTable_or_subquery func(c *Table_or_subqueryContext)

+ ExitTransaction_name func(c *Transaction_nameContext)

+ ExitTrigger_name func(c *Trigger_nameContext)

+ ExitType_name func(c *Type_nameContext)

+ ExitUnary_operator func(c *Unary_operatorContext)

+ ExitUpdate_stmt func(c *Update_stmtContext)

+ ExitUpdate_stmt_limited func(c *Update_stmt_limitedContext)

+ ExitVacuum_stmt func(c *Vacuum_stmtContext)

+ ExitView_name func(c *View_nameContext)

+ ExitWith_clause func(c *With_clauseContext)

+ type SQLiteParser struct

+ func NewSQLiteParser(input antlr.TokenStream) *SQLiteParser

+ func (p *SQLiteParser) Alter_table_stmt() (localctx IAlter_table_stmtContext)

+ func (p *SQLiteParser) Analyze_stmt() (localctx IAnalyze_stmtContext)

+ func (p *SQLiteParser) Any_name() (localctx IAny_nameContext)

+ func (p *SQLiteParser) Attach_stmt() (localctx IAttach_stmtContext)

+ func (p *SQLiteParser) Begin_stmt() (localctx IBegin_stmtContext)

+ func (p *SQLiteParser) Collation_name() (localctx ICollation_nameContext)

+ func (p *SQLiteParser) Column_alias() (localctx IColumn_aliasContext)

+ func (p *SQLiteParser) Column_constraint() (localctx IColumn_constraintContext)

+ func (p *SQLiteParser) Column_def() (localctx IColumn_defContext)

+ func (p *SQLiteParser) Column_name() (localctx IColumn_nameContext)

+ func (p *SQLiteParser) Commit_stmt() (localctx ICommit_stmtContext)

+ func (p *SQLiteParser) Common_table_expression() (localctx ICommon_table_expressionContext)

+ func (p *SQLiteParser) Compound_operator() (localctx ICompound_operatorContext)

+ func (p *SQLiteParser) Compound_select_stmt() (localctx ICompound_select_stmtContext)

+ func (p *SQLiteParser) Conflict_clause() (localctx IConflict_clauseContext)

+ func (p *SQLiteParser) Create_index_stmt() (localctx ICreate_index_stmtContext)

+ func (p *SQLiteParser) Create_table_stmt() (localctx ICreate_table_stmtContext)

+ func (p *SQLiteParser) Create_trigger_stmt() (localctx ICreate_trigger_stmtContext)

+ func (p *SQLiteParser) Create_view_stmt() (localctx ICreate_view_stmtContext)

+ func (p *SQLiteParser) Create_virtual_table_stmt() (localctx ICreate_virtual_table_stmtContext)

+ func (p *SQLiteParser) Database_name() (localctx IDatabase_nameContext)

+ func (p *SQLiteParser) Delete_stmt() (localctx IDelete_stmtContext)

+ func (p *SQLiteParser) Delete_stmt_limited() (localctx IDelete_stmt_limitedContext)

+ func (p *SQLiteParser) Detach_stmt() (localctx IDetach_stmtContext)

+ func (p *SQLiteParser) Drop_index_stmt() (localctx IDrop_index_stmtContext)

+ func (p *SQLiteParser) Drop_table_stmt() (localctx IDrop_table_stmtContext)

+ func (p *SQLiteParser) Drop_trigger_stmt() (localctx IDrop_trigger_stmtContext)

+ func (p *SQLiteParser) Drop_view_stmt() (localctx IDrop_view_stmtContext)

+ func (p *SQLiteParser) Error_message() (localctx IError_messageContext)

+ func (p *SQLiteParser) Expr() (localctx IExprContext)

+ func (p *SQLiteParser) Expr_Sempred(localctx antlr.RuleContext, predIndex int) bool

+ func (p *SQLiteParser) Factored_select_stmt() (localctx IFactored_select_stmtContext)

+ func (p *SQLiteParser) Foreign_key_clause() (localctx IForeign_key_clauseContext)

+ func (p *SQLiteParser) Foreign_table() (localctx IForeign_tableContext)

+ func (p *SQLiteParser) Function_name() (localctx IFunction_nameContext)

+ func (p *SQLiteParser) Index_name() (localctx IIndex_nameContext)

+ func (p *SQLiteParser) Indexed_column() (localctx IIndexed_columnContext)

+ func (p *SQLiteParser) Insert_stmt() (localctx IInsert_stmtContext)

+ func (p *SQLiteParser) Join_clause() (localctx IJoin_clauseContext)

+ func (p *SQLiteParser) Join_constraint() (localctx IJoin_constraintContext)

+ func (p *SQLiteParser) Join_operator() (localctx IJoin_operatorContext)

+ func (p *SQLiteParser) Keyword() (localctx IKeywordContext)

+ func (p *SQLiteParser) Literal_value() (localctx ILiteral_valueContext)

+ func (p *SQLiteParser) Module_argument() (localctx IModule_argumentContext)

+ func (p *SQLiteParser) Module_name() (localctx IModule_nameContext)

+ func (p *SQLiteParser) Name() (localctx INameContext)

+ func (p *SQLiteParser) New_table_name() (localctx INew_table_nameContext)

+ func (p *SQLiteParser) Ordering_term() (localctx IOrdering_termContext)

+ func (p *SQLiteParser) Parse() (localctx IParseContext)

+ func (p *SQLiteParser) Pragma_name() (localctx IPragma_nameContext)

+ func (p *SQLiteParser) Pragma_stmt() (localctx IPragma_stmtContext)

+ func (p *SQLiteParser) Pragma_value() (localctx IPragma_valueContext)

+ func (p *SQLiteParser) Qualified_table_name() (localctx IQualified_table_nameContext)

+ func (p *SQLiteParser) Raise_function() (localctx IRaise_functionContext)

+ func (p *SQLiteParser) Reindex_stmt() (localctx IReindex_stmtContext)

+ func (p *SQLiteParser) Release_stmt() (localctx IRelease_stmtContext)

+ func (p *SQLiteParser) Result_column() (localctx IResult_columnContext)

+ func (p *SQLiteParser) Rollback_stmt() (localctx IRollback_stmtContext)

+ func (p *SQLiteParser) Savepoint_name() (localctx ISavepoint_nameContext)

+ func (p *SQLiteParser) Savepoint_stmt() (localctx ISavepoint_stmtContext)

+ func (p *SQLiteParser) Schema_name() (localctx ISchema_nameContext)

+ func (p *SQLiteParser) Select_core() (localctx ISelect_coreContext)

+ func (p *SQLiteParser) Select_or_values() (localctx ISelect_or_valuesContext)

+ func (p *SQLiteParser) Select_stmt() (localctx ISelect_stmtContext)

+ func (p *SQLiteParser) Sempred(localctx antlr.RuleContext, ruleIndex, predIndex int) bool

+ func (p *SQLiteParser) Signed_number() (localctx ISigned_numberContext)

+ func (p *SQLiteParser) Simple_select_stmt() (localctx ISimple_select_stmtContext)

+ func (p *SQLiteParser) Sql_stmt() (localctx ISql_stmtContext)

+ func (p *SQLiteParser) Sql_stmt_list() (localctx ISql_stmt_listContext)

+ func (p *SQLiteParser) Table_alias() (localctx ITable_aliasContext)

+ func (p *SQLiteParser) Table_constraint() (localctx ITable_constraintContext)

+ func (p *SQLiteParser) Table_function_name() (localctx ITable_function_nameContext)

+ func (p *SQLiteParser) Table_name() (localctx ITable_nameContext)

+ func (p *SQLiteParser) Table_or_index_name() (localctx ITable_or_index_nameContext)

+ func (p *SQLiteParser) Table_or_subquery() (localctx ITable_or_subqueryContext)

+ func (p *SQLiteParser) Transaction_name() (localctx ITransaction_nameContext)

+ func (p *SQLiteParser) Trigger_name() (localctx ITrigger_nameContext)

+ func (p *SQLiteParser) Type_name() (localctx IType_nameContext)

+ func (p *SQLiteParser) Unary_operator() (localctx IUnary_operatorContext)

+ func (p *SQLiteParser) Update_stmt() (localctx IUpdate_stmtContext)

+ func (p *SQLiteParser) Update_stmt_limited() (localctx IUpdate_stmt_limitedContext)

+ func (p *SQLiteParser) Vacuum_stmt() (localctx IVacuum_stmtContext)

+ func (p *SQLiteParser) View_name() (localctx IView_nameContext)

+ func (p *SQLiteParser) With_clause() (localctx IWith_clauseContext)

+ type SQLiteVisitor interface

+ VisitAlter_table_stmt func(ctx *Alter_table_stmtContext) interface{}

+ VisitAnalyze_stmt func(ctx *Analyze_stmtContext) interface{}

+ VisitAny_name func(ctx *Any_nameContext) interface{}

+ VisitAttach_stmt func(ctx *Attach_stmtContext) interface{}

+ VisitBegin_stmt func(ctx *Begin_stmtContext) interface{}

+ VisitCollation_name func(ctx *Collation_nameContext) interface{}

+ VisitColumn_alias func(ctx *Column_aliasContext) interface{}

+ VisitColumn_constraint func(ctx *Column_constraintContext) interface{}

+ VisitColumn_def func(ctx *Column_defContext) interface{}

+ VisitColumn_name func(ctx *Column_nameContext) interface{}

+ VisitCommit_stmt func(ctx *Commit_stmtContext) interface{}

+ VisitCommon_table_expression func(ctx *Common_table_expressionContext) interface{}

+ VisitCompound_operator func(ctx *Compound_operatorContext) interface{}

+ VisitCompound_select_stmt func(ctx *Compound_select_stmtContext) interface{}

+ VisitConflict_clause func(ctx *Conflict_clauseContext) interface{}

+ VisitCreate_index_stmt func(ctx *Create_index_stmtContext) interface{}

+ VisitCreate_table_stmt func(ctx *Create_table_stmtContext) interface{}

+ VisitCreate_trigger_stmt func(ctx *Create_trigger_stmtContext) interface{}

+ VisitCreate_view_stmt func(ctx *Create_view_stmtContext) interface{}

+ VisitCreate_virtual_table_stmt func(ctx *Create_virtual_table_stmtContext) interface{}

+ VisitDatabase_name func(ctx *Database_nameContext) interface{}

+ VisitDelete_stmt func(ctx *Delete_stmtContext) interface{}

+ VisitDelete_stmt_limited func(ctx *Delete_stmt_limitedContext) interface{}

+ VisitDetach_stmt func(ctx *Detach_stmtContext) interface{}

+ VisitDrop_index_stmt func(ctx *Drop_index_stmtContext) interface{}

+ VisitDrop_table_stmt func(ctx *Drop_table_stmtContext) interface{}

+ VisitDrop_trigger_stmt func(ctx *Drop_trigger_stmtContext) interface{}

+ VisitDrop_view_stmt func(ctx *Drop_view_stmtContext) interface{}

+ VisitError_message func(ctx *Error_messageContext) interface{}

+ VisitExpr func(ctx *ExprContext) interface{}

+ VisitFactored_select_stmt func(ctx *Factored_select_stmtContext) interface{}

+ VisitForeign_key_clause func(ctx *Foreign_key_clauseContext) interface{}

+ VisitForeign_table func(ctx *Foreign_tableContext) interface{}

+ VisitFunction_name func(ctx *Function_nameContext) interface{}

+ VisitIndex_name func(ctx *Index_nameContext) interface{}

+ VisitIndexed_column func(ctx *Indexed_columnContext) interface{}

+ VisitInsert_stmt func(ctx *Insert_stmtContext) interface{}

+ VisitJoin_clause func(ctx *Join_clauseContext) interface{}

+ VisitJoin_constraint func(ctx *Join_constraintContext) interface{}

+ VisitJoin_operator func(ctx *Join_operatorContext) interface{}

+ VisitKeyword func(ctx *KeywordContext) interface{}

+ VisitLiteral_value func(ctx *Literal_valueContext) interface{}

+ VisitModule_argument func(ctx *Module_argumentContext) interface{}

+ VisitModule_name func(ctx *Module_nameContext) interface{}

+ VisitName func(ctx *NameContext) interface{}

+ VisitNew_table_name func(ctx *New_table_nameContext) interface{}

+ VisitOrdering_term func(ctx *Ordering_termContext) interface{}

+ VisitParse func(ctx *ParseContext) interface{}

+ VisitPragma_name func(ctx *Pragma_nameContext) interface{}

+ VisitPragma_stmt func(ctx *Pragma_stmtContext) interface{}

+ VisitPragma_value func(ctx *Pragma_valueContext) interface{}

+ VisitQualified_table_name func(ctx *Qualified_table_nameContext) interface{}

+ VisitRaise_function func(ctx *Raise_functionContext) interface{}

+ VisitReindex_stmt func(ctx *Reindex_stmtContext) interface{}

+ VisitRelease_stmt func(ctx *Release_stmtContext) interface{}

+ VisitResult_column func(ctx *Result_columnContext) interface{}

+ VisitRollback_stmt func(ctx *Rollback_stmtContext) interface{}

+ VisitSavepoint_name func(ctx *Savepoint_nameContext) interface{}

+ VisitSavepoint_stmt func(ctx *Savepoint_stmtContext) interface{}

+ VisitSchema_name func(ctx *Schema_nameContext) interface{}

+ VisitSelect_core func(ctx *Select_coreContext) interface{}

+ VisitSelect_or_values func(ctx *Select_or_valuesContext) interface{}

+ VisitSelect_stmt func(ctx *Select_stmtContext) interface{}

+ VisitSigned_number func(ctx *Signed_numberContext) interface{}

+ VisitSimple_select_stmt func(ctx *Simple_select_stmtContext) interface{}

+ VisitSql_stmt func(ctx *Sql_stmtContext) interface{}

+ VisitSql_stmt_list func(ctx *Sql_stmt_listContext) interface{}

+ VisitTable_alias func(ctx *Table_aliasContext) interface{}

+ VisitTable_constraint func(ctx *Table_constraintContext) interface{}

+ VisitTable_function_name func(ctx *Table_function_nameContext) interface{}

+ VisitTable_name func(ctx *Table_nameContext) interface{}

+ VisitTable_or_index_name func(ctx *Table_or_index_nameContext) interface{}

+ VisitTable_or_subquery func(ctx *Table_or_subqueryContext) interface{}

+ VisitTransaction_name func(ctx *Transaction_nameContext) interface{}

+ VisitTrigger_name func(ctx *Trigger_nameContext) interface{}

+ VisitType_name func(ctx *Type_nameContext) interface{}

+ VisitUnary_operator func(ctx *Unary_operatorContext) interface{}

+ VisitUpdate_stmt func(ctx *Update_stmtContext) interface{}

+ VisitUpdate_stmt_limited func(ctx *Update_stmt_limitedContext) interface{}

+ VisitVacuum_stmt func(ctx *Vacuum_stmtContext) interface{}

+ VisitView_name func(ctx *View_nameContext) interface{}

+ VisitWith_clause func(ctx *With_clauseContext) interface{}

+ 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) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ 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) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ func (s *Savepoint_stmtContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Savepoint_stmtContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Savepoint_stmtContext) GetParser() antlr.Parser

+ func (s *Savepoint_stmtContext) GetRuleContext() antlr.RuleContext

+ func (s *Savepoint_stmtContext) K_SAVEPOINT() antlr.TerminalNode

+ func (s *Savepoint_stmtContext) Savepoint_name() ISavepoint_nameContext

+ func (s *Savepoint_stmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type Schema_nameContext struct

+ func NewEmptySchema_nameContext() *Schema_nameContext

+ func NewSchema_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Schema_nameContext

+ func (*Schema_nameContext) IsSchema_nameContext()

+ func (s *Schema_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ 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) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ func (s *Select_coreContext) AllCLOSE_PAR() []antlr.TerminalNode

+ func (s *Select_coreContext) AllCOMMA() []antlr.TerminalNode

+ func (s *Select_coreContext) AllExpr() []IExprContext

+ func (s *Select_coreContext) AllOPEN_PAR() []antlr.TerminalNode

+ func (s *Select_coreContext) AllResult_column() []IResult_columnContext

+ func (s *Select_coreContext) AllTable_or_subquery() []ITable_or_subqueryContext

+ func (s *Select_coreContext) CLOSE_PAR(i int) antlr.TerminalNode

+ func (s *Select_coreContext) COMMA(i int) antlr.TerminalNode

+ func (s *Select_coreContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Select_coreContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Select_coreContext) Expr(i int) IExprContext

+ func (s *Select_coreContext) GetParser() antlr.Parser

+ func (s *Select_coreContext) GetRuleContext() antlr.RuleContext

+ func (s *Select_coreContext) Join_clause() IJoin_clauseContext

+ func (s *Select_coreContext) K_ALL() antlr.TerminalNode

+ func (s *Select_coreContext) K_BY() antlr.TerminalNode

+ func (s *Select_coreContext) K_DISTINCT() antlr.TerminalNode

+ func (s *Select_coreContext) K_FROM() antlr.TerminalNode

+ func (s *Select_coreContext) K_GROUP() antlr.TerminalNode

+ func (s *Select_coreContext) K_HAVING() antlr.TerminalNode

+ func (s *Select_coreContext) K_SELECT() antlr.TerminalNode

+ func (s *Select_coreContext) K_VALUES() antlr.TerminalNode

+ func (s *Select_coreContext) K_WHERE() antlr.TerminalNode

+ func (s *Select_coreContext) OPEN_PAR(i int) antlr.TerminalNode

+ func (s *Select_coreContext) Result_column(i int) IResult_columnContext

+ func (s *Select_coreContext) Table_or_subquery(i int) ITable_or_subqueryContext

+ func (s *Select_coreContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type Select_or_valuesContext struct

+ func NewEmptySelect_or_valuesContext() *Select_or_valuesContext

+ func NewSelect_or_valuesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Select_or_valuesContext

+ func (*Select_or_valuesContext) IsSelect_or_valuesContext()

+ func (s *Select_or_valuesContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ func (s *Select_or_valuesContext) AllCLOSE_PAR() []antlr.TerminalNode

+ func (s *Select_or_valuesContext) AllCOMMA() []antlr.TerminalNode

+ func (s *Select_or_valuesContext) AllExpr() []IExprContext

+ func (s *Select_or_valuesContext) AllOPEN_PAR() []antlr.TerminalNode

+ func (s *Select_or_valuesContext) AllResult_column() []IResult_columnContext

+ func (s *Select_or_valuesContext) AllTable_or_subquery() []ITable_or_subqueryContext

+ func (s *Select_or_valuesContext) CLOSE_PAR(i int) antlr.TerminalNode

+ func (s *Select_or_valuesContext) COMMA(i int) antlr.TerminalNode

+ func (s *Select_or_valuesContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Select_or_valuesContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Select_or_valuesContext) Expr(i int) IExprContext

+ func (s *Select_or_valuesContext) GetParser() antlr.Parser

+ func (s *Select_or_valuesContext) GetRuleContext() antlr.RuleContext

+ func (s *Select_or_valuesContext) Join_clause() IJoin_clauseContext

+ func (s *Select_or_valuesContext) K_ALL() antlr.TerminalNode

+ func (s *Select_or_valuesContext) K_BY() antlr.TerminalNode

+ func (s *Select_or_valuesContext) K_DISTINCT() antlr.TerminalNode

+ func (s *Select_or_valuesContext) K_FROM() antlr.TerminalNode

+ func (s *Select_or_valuesContext) K_GROUP() antlr.TerminalNode

+ func (s *Select_or_valuesContext) K_HAVING() antlr.TerminalNode

+ func (s *Select_or_valuesContext) K_SELECT() antlr.TerminalNode

+ func (s *Select_or_valuesContext) K_VALUES() antlr.TerminalNode

+ func (s *Select_or_valuesContext) K_WHERE() antlr.TerminalNode

+ func (s *Select_or_valuesContext) OPEN_PAR(i int) antlr.TerminalNode

+ func (s *Select_or_valuesContext) Result_column(i int) IResult_columnContext

+ func (s *Select_or_valuesContext) Table_or_subquery(i int) ITable_or_subqueryContext

+ func (s *Select_or_valuesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type Select_stmtContext struct

+ func NewEmptySelect_stmtContext() *Select_stmtContext

+ func NewSelect_stmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Select_stmtContext

+ func (*Select_stmtContext) IsSelect_stmtContext()

+ func (s *Select_stmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ func (s *Select_stmtContext) AllCOMMA() []antlr.TerminalNode

+ func (s *Select_stmtContext) AllCompound_operator() []ICompound_operatorContext

+ func (s *Select_stmtContext) AllExpr() []IExprContext

+ func (s *Select_stmtContext) AllOrdering_term() []IOrdering_termContext

+ func (s *Select_stmtContext) AllSelect_or_values() []ISelect_or_valuesContext

+ func (s *Select_stmtContext) COMMA(i int) antlr.TerminalNode

+ func (s *Select_stmtContext) Compound_operator(i int) ICompound_operatorContext

+ func (s *Select_stmtContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Select_stmtContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Select_stmtContext) Expr(i int) IExprContext

+ func (s *Select_stmtContext) GetParser() antlr.Parser

+ func (s *Select_stmtContext) GetRuleContext() antlr.RuleContext

+ func (s *Select_stmtContext) K_BY() antlr.TerminalNode

+ func (s *Select_stmtContext) K_LIMIT() antlr.TerminalNode

+ func (s *Select_stmtContext) K_OFFSET() antlr.TerminalNode

+ func (s *Select_stmtContext) K_ORDER() antlr.TerminalNode

+ func (s *Select_stmtContext) Ordering_term(i int) IOrdering_termContext

+ func (s *Select_stmtContext) Select_or_values(i int) ISelect_or_valuesContext

+ func (s *Select_stmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ func (s *Select_stmtContext) With_clause() IWith_clauseContext

+ type Signed_numberContext struct

+ func NewEmptySigned_numberContext() *Signed_numberContext

+ func NewSigned_numberContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Signed_numberContext

+ func (*Signed_numberContext) IsSigned_numberContext()

+ func (s *Signed_numberContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ func (s *Signed_numberContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Signed_numberContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Signed_numberContext) GetParser() antlr.Parser

+ func (s *Signed_numberContext) GetRuleContext() antlr.RuleContext

+ func (s *Signed_numberContext) MINUS() antlr.TerminalNode

+ func (s *Signed_numberContext) NUMERIC_LITERAL() antlr.TerminalNode

+ func (s *Signed_numberContext) PLUS() antlr.TerminalNode

+ func (s *Signed_numberContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type Simple_select_stmtContext struct

+ func NewEmptySimple_select_stmtContext() *Simple_select_stmtContext

+ func NewSimple_select_stmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Simple_select_stmtContext

+ func (*Simple_select_stmtContext) IsSimple_select_stmtContext()

+ func (s *Simple_select_stmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ func (s *Simple_select_stmtContext) AllCOMMA() []antlr.TerminalNode

+ func (s *Simple_select_stmtContext) AllExpr() []IExprContext

+ func (s *Simple_select_stmtContext) AllOrdering_term() []IOrdering_termContext

+ func (s *Simple_select_stmtContext) COMMA(i int) antlr.TerminalNode

+ func (s *Simple_select_stmtContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Simple_select_stmtContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Simple_select_stmtContext) Expr(i int) IExprContext

+ func (s *Simple_select_stmtContext) GetParser() antlr.Parser

+ func (s *Simple_select_stmtContext) GetRuleContext() antlr.RuleContext

+ func (s *Simple_select_stmtContext) K_BY() antlr.TerminalNode

+ func (s *Simple_select_stmtContext) K_LIMIT() antlr.TerminalNode

+ func (s *Simple_select_stmtContext) K_OFFSET() antlr.TerminalNode

+ func (s *Simple_select_stmtContext) K_ORDER() antlr.TerminalNode

+ func (s *Simple_select_stmtContext) Ordering_term(i int) IOrdering_termContext

+ func (s *Simple_select_stmtContext) Select_core() ISelect_coreContext

+ func (s *Simple_select_stmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ func (s *Simple_select_stmtContext) With_clause() IWith_clauseContext

+ type Sql_stmtContext struct

+ func NewEmptySql_stmtContext() *Sql_stmtContext

+ func NewSql_stmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Sql_stmtContext

+ func (*Sql_stmtContext) IsSql_stmtContext()

+ func (s *Sql_stmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ func (s *Sql_stmtContext) Alter_table_stmt() IAlter_table_stmtContext

+ func (s *Sql_stmtContext) Analyze_stmt() IAnalyze_stmtContext

+ func (s *Sql_stmtContext) Attach_stmt() IAttach_stmtContext

+ func (s *Sql_stmtContext) Begin_stmt() IBegin_stmtContext

+ func (s *Sql_stmtContext) Commit_stmt() ICommit_stmtContext

+ func (s *Sql_stmtContext) Compound_select_stmt() ICompound_select_stmtContext

+ func (s *Sql_stmtContext) Create_index_stmt() ICreate_index_stmtContext

+ func (s *Sql_stmtContext) Create_table_stmt() ICreate_table_stmtContext

+ func (s *Sql_stmtContext) Create_trigger_stmt() ICreate_trigger_stmtContext

+ func (s *Sql_stmtContext) Create_view_stmt() ICreate_view_stmtContext

+ func (s *Sql_stmtContext) Create_virtual_table_stmt() ICreate_virtual_table_stmtContext

+ func (s *Sql_stmtContext) Delete_stmt() IDelete_stmtContext

+ func (s *Sql_stmtContext) Delete_stmt_limited() IDelete_stmt_limitedContext

+ func (s *Sql_stmtContext) Detach_stmt() IDetach_stmtContext

+ func (s *Sql_stmtContext) Drop_index_stmt() IDrop_index_stmtContext

+ func (s *Sql_stmtContext) Drop_table_stmt() IDrop_table_stmtContext

+ func (s *Sql_stmtContext) Drop_trigger_stmt() IDrop_trigger_stmtContext

+ func (s *Sql_stmtContext) Drop_view_stmt() IDrop_view_stmtContext

+ func (s *Sql_stmtContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Sql_stmtContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Sql_stmtContext) Factored_select_stmt() IFactored_select_stmtContext

+ func (s *Sql_stmtContext) GetParser() antlr.Parser

+ func (s *Sql_stmtContext) GetRuleContext() antlr.RuleContext

+ func (s *Sql_stmtContext) Insert_stmt() IInsert_stmtContext

+ func (s *Sql_stmtContext) K_EXPLAIN() antlr.TerminalNode

+ func (s *Sql_stmtContext) K_PLAN() antlr.TerminalNode

+ func (s *Sql_stmtContext) K_QUERY() antlr.TerminalNode

+ func (s *Sql_stmtContext) Pragma_stmt() IPragma_stmtContext

+ func (s *Sql_stmtContext) Reindex_stmt() IReindex_stmtContext

+ func (s *Sql_stmtContext) Release_stmt() IRelease_stmtContext

+ func (s *Sql_stmtContext) Rollback_stmt() IRollback_stmtContext

+ func (s *Sql_stmtContext) Savepoint_stmt() ISavepoint_stmtContext

+ func (s *Sql_stmtContext) Select_stmt() ISelect_stmtContext

+ func (s *Sql_stmtContext) Simple_select_stmt() ISimple_select_stmtContext

+ func (s *Sql_stmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ func (s *Sql_stmtContext) Update_stmt() IUpdate_stmtContext

+ func (s *Sql_stmtContext) Update_stmt_limited() IUpdate_stmt_limitedContext

+ func (s *Sql_stmtContext) Vacuum_stmt() IVacuum_stmtContext

+ type Sql_stmt_listContext struct

+ func NewEmptySql_stmt_listContext() *Sql_stmt_listContext

+ func NewSql_stmt_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Sql_stmt_listContext

+ func (*Sql_stmt_listContext) IsSql_stmt_listContext()

+ func (s *Sql_stmt_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ func (s *Sql_stmt_listContext) AllSCOL() []antlr.TerminalNode

+ func (s *Sql_stmt_listContext) AllSql_stmt() []ISql_stmtContext

+ func (s *Sql_stmt_listContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Sql_stmt_listContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Sql_stmt_listContext) GetParser() antlr.Parser

+ func (s *Sql_stmt_listContext) GetRuleContext() antlr.RuleContext

+ func (s *Sql_stmt_listContext) SCOL(i int) antlr.TerminalNode

+ func (s *Sql_stmt_listContext) Sql_stmt(i int) ISql_stmtContext

+ func (s *Sql_stmt_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type Table_aliasContext struct

+ func NewEmptyTable_aliasContext() *Table_aliasContext

+ func NewTable_aliasContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Table_aliasContext

+ func (*Table_aliasContext) IsTable_aliasContext()

+ func (s *Table_aliasContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ func (s *Table_aliasContext) CLOSE_PAR() antlr.TerminalNode

+ func (s *Table_aliasContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Table_aliasContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Table_aliasContext) GetParser() antlr.Parser

+ func (s *Table_aliasContext) GetRuleContext() antlr.RuleContext

+ func (s *Table_aliasContext) IDENTIFIER() antlr.TerminalNode

+ func (s *Table_aliasContext) OPEN_PAR() antlr.TerminalNode

+ func (s *Table_aliasContext) STRING_LITERAL() antlr.TerminalNode

+ func (s *Table_aliasContext) Table_alias() ITable_aliasContext

+ func (s *Table_aliasContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type Table_constraintContext struct

+ func NewEmptyTable_constraintContext() *Table_constraintContext

+ func NewTable_constraintContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Table_constraintContext

+ func (*Table_constraintContext) IsTable_constraintContext()

+ func (s *Table_constraintContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ func (s *Table_constraintContext) AllCOMMA() []antlr.TerminalNode

+ func (s *Table_constraintContext) AllColumn_name() []IColumn_nameContext

+ func (s *Table_constraintContext) AllIndexed_column() []IIndexed_columnContext

+ func (s *Table_constraintContext) CLOSE_PAR() antlr.TerminalNode

+ func (s *Table_constraintContext) COMMA(i int) antlr.TerminalNode

+ func (s *Table_constraintContext) Column_name(i int) IColumn_nameContext

+ func (s *Table_constraintContext) Conflict_clause() IConflict_clauseContext

+ func (s *Table_constraintContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Table_constraintContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Table_constraintContext) Expr() IExprContext

+ func (s *Table_constraintContext) Foreign_key_clause() IForeign_key_clauseContext

+ func (s *Table_constraintContext) GetParser() antlr.Parser

+ func (s *Table_constraintContext) GetRuleContext() antlr.RuleContext

+ func (s *Table_constraintContext) Indexed_column(i int) IIndexed_columnContext

+ func (s *Table_constraintContext) K_CHECK() antlr.TerminalNode

+ func (s *Table_constraintContext) K_CONSTRAINT() antlr.TerminalNode

+ func (s *Table_constraintContext) K_FOREIGN() antlr.TerminalNode

+ func (s *Table_constraintContext) K_KEY() antlr.TerminalNode

+ func (s *Table_constraintContext) K_PRIMARY() antlr.TerminalNode

+ func (s *Table_constraintContext) K_UNIQUE() antlr.TerminalNode

+ func (s *Table_constraintContext) Name() INameContext

+ func (s *Table_constraintContext) OPEN_PAR() antlr.TerminalNode

+ func (s *Table_constraintContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type Table_function_nameContext struct

+ func NewEmptyTable_function_nameContext() *Table_function_nameContext

+ func NewTable_function_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Table_function_nameContext

+ func (*Table_function_nameContext) IsTable_function_nameContext()

+ func (s *Table_function_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ 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) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ 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) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ 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) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ func (s *Table_or_subqueryContext) AllCOMMA() []antlr.TerminalNode

+ func (s *Table_or_subqueryContext) AllExpr() []IExprContext

+ func (s *Table_or_subqueryContext) AllTable_or_subquery() []ITable_or_subqueryContext

+ func (s *Table_or_subqueryContext) CLOSE_PAR() antlr.TerminalNode

+ func (s *Table_or_subqueryContext) COMMA(i int) antlr.TerminalNode

+ func (s *Table_or_subqueryContext) DOT() antlr.TerminalNode

+ func (s *Table_or_subqueryContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Table_or_subqueryContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Table_or_subqueryContext) Expr(i int) IExprContext

+ func (s *Table_or_subqueryContext) GetParser() antlr.Parser

+ func (s *Table_or_subqueryContext) GetRuleContext() antlr.RuleContext

+ func (s *Table_or_subqueryContext) Index_name() IIndex_nameContext

+ func (s *Table_or_subqueryContext) Join_clause() IJoin_clauseContext

+ func (s *Table_or_subqueryContext) K_AS() antlr.TerminalNode

+ func (s *Table_or_subqueryContext) K_BY() antlr.TerminalNode

+ func (s *Table_or_subqueryContext) K_INDEXED() antlr.TerminalNode

+ func (s *Table_or_subqueryContext) K_NOT() antlr.TerminalNode

+ func (s *Table_or_subqueryContext) OPEN_PAR() antlr.TerminalNode

+ func (s *Table_or_subqueryContext) Schema_name() ISchema_nameContext

+ func (s *Table_or_subqueryContext) Select_stmt() ISelect_stmtContext

+ func (s *Table_or_subqueryContext) Table_alias() ITable_aliasContext

+ func (s *Table_or_subqueryContext) Table_function_name() ITable_function_nameContext

+ func (s *Table_or_subqueryContext) Table_name() ITable_nameContext

+ func (s *Table_or_subqueryContext) Table_or_subquery(i int) ITable_or_subqueryContext

+ func (s *Table_or_subqueryContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type Transaction_nameContext struct

+ func NewEmptyTransaction_nameContext() *Transaction_nameContext

+ func NewTransaction_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Transaction_nameContext

+ func (*Transaction_nameContext) IsTransaction_nameContext()

+ func (s *Transaction_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ 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) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ 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) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ 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) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ func (s *Unary_operatorContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Unary_operatorContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Unary_operatorContext) GetParser() antlr.Parser

+ func (s *Unary_operatorContext) GetRuleContext() antlr.RuleContext

+ func (s *Unary_operatorContext) K_NOT() antlr.TerminalNode

+ func (s *Unary_operatorContext) MINUS() antlr.TerminalNode

+ func (s *Unary_operatorContext) PLUS() antlr.TerminalNode

+ func (s *Unary_operatorContext) TILDE() antlr.TerminalNode

+ func (s *Unary_operatorContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type Update_stmtContext struct

+ func NewEmptyUpdate_stmtContext() *Update_stmtContext

+ func NewUpdate_stmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Update_stmtContext

+ func (*Update_stmtContext) IsUpdate_stmtContext()

+ func (s *Update_stmtContext) ASSIGN(i int) antlr.TerminalNode

+ func (s *Update_stmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ func (s *Update_stmtContext) AllASSIGN() []antlr.TerminalNode

+ func (s *Update_stmtContext) AllCOMMA() []antlr.TerminalNode

+ func (s *Update_stmtContext) AllColumn_name() []IColumn_nameContext

+ func (s *Update_stmtContext) AllExpr() []IExprContext

+ func (s *Update_stmtContext) COMMA(i int) antlr.TerminalNode

+ func (s *Update_stmtContext) Column_name(i int) IColumn_nameContext

+ func (s *Update_stmtContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Update_stmtContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Update_stmtContext) Expr(i int) IExprContext

+ func (s *Update_stmtContext) GetParser() antlr.Parser

+ func (s *Update_stmtContext) GetRuleContext() antlr.RuleContext

+ func (s *Update_stmtContext) K_ABORT() antlr.TerminalNode

+ func (s *Update_stmtContext) K_FAIL() antlr.TerminalNode

+ func (s *Update_stmtContext) K_IGNORE() antlr.TerminalNode

+ func (s *Update_stmtContext) K_OR() antlr.TerminalNode

+ func (s *Update_stmtContext) K_REPLACE() antlr.TerminalNode

+ func (s *Update_stmtContext) K_ROLLBACK() antlr.TerminalNode

+ func (s *Update_stmtContext) K_SET() antlr.TerminalNode

+ func (s *Update_stmtContext) K_UPDATE() antlr.TerminalNode

+ func (s *Update_stmtContext) K_WHERE() antlr.TerminalNode

+ func (s *Update_stmtContext) Qualified_table_name() IQualified_table_nameContext

+ func (s *Update_stmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ func (s *Update_stmtContext) With_clause() IWith_clauseContext

+ type Update_stmt_limitedContext struct

+ func NewEmptyUpdate_stmt_limitedContext() *Update_stmt_limitedContext

+ func NewUpdate_stmt_limitedContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Update_stmt_limitedContext

+ func (*Update_stmt_limitedContext) IsUpdate_stmt_limitedContext()

+ func (s *Update_stmt_limitedContext) ASSIGN(i int) antlr.TerminalNode

+ func (s *Update_stmt_limitedContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ func (s *Update_stmt_limitedContext) AllASSIGN() []antlr.TerminalNode

+ func (s *Update_stmt_limitedContext) AllCOMMA() []antlr.TerminalNode

+ func (s *Update_stmt_limitedContext) AllColumn_name() []IColumn_nameContext

+ func (s *Update_stmt_limitedContext) AllExpr() []IExprContext

+ func (s *Update_stmt_limitedContext) AllOrdering_term() []IOrdering_termContext

+ func (s *Update_stmt_limitedContext) COMMA(i int) antlr.TerminalNode

+ func (s *Update_stmt_limitedContext) Column_name(i int) IColumn_nameContext

+ func (s *Update_stmt_limitedContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Update_stmt_limitedContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Update_stmt_limitedContext) Expr(i int) IExprContext

+ func (s *Update_stmt_limitedContext) GetParser() antlr.Parser

+ func (s *Update_stmt_limitedContext) GetRuleContext() antlr.RuleContext

+ func (s *Update_stmt_limitedContext) K_ABORT() antlr.TerminalNode

+ func (s *Update_stmt_limitedContext) K_BY() antlr.TerminalNode

+ func (s *Update_stmt_limitedContext) K_FAIL() antlr.TerminalNode

+ func (s *Update_stmt_limitedContext) K_IGNORE() antlr.TerminalNode

+ func (s *Update_stmt_limitedContext) K_LIMIT() antlr.TerminalNode

+ func (s *Update_stmt_limitedContext) K_OFFSET() antlr.TerminalNode

+ func (s *Update_stmt_limitedContext) K_OR() antlr.TerminalNode

+ func (s *Update_stmt_limitedContext) K_ORDER() antlr.TerminalNode

+ func (s *Update_stmt_limitedContext) K_REPLACE() antlr.TerminalNode

+ func (s *Update_stmt_limitedContext) K_ROLLBACK() antlr.TerminalNode

+ func (s *Update_stmt_limitedContext) K_SET() antlr.TerminalNode

+ func (s *Update_stmt_limitedContext) K_UPDATE() antlr.TerminalNode

+ func (s *Update_stmt_limitedContext) K_WHERE() antlr.TerminalNode

+ func (s *Update_stmt_limitedContext) Ordering_term(i int) IOrdering_termContext

+ func (s *Update_stmt_limitedContext) Qualified_table_name() IQualified_table_nameContext

+ func (s *Update_stmt_limitedContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ func (s *Update_stmt_limitedContext) With_clause() IWith_clauseContext

+ type Vacuum_stmtContext struct

+ func NewEmptyVacuum_stmtContext() *Vacuum_stmtContext

+ func NewVacuum_stmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Vacuum_stmtContext

+ func (*Vacuum_stmtContext) IsVacuum_stmtContext()

+ func (s *Vacuum_stmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ func (s *Vacuum_stmtContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Vacuum_stmtContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Vacuum_stmtContext) GetParser() antlr.Parser

+ func (s *Vacuum_stmtContext) GetRuleContext() antlr.RuleContext

+ func (s *Vacuum_stmtContext) K_VACUUM() antlr.TerminalNode

+ func (s *Vacuum_stmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type View_nameContext struct

+ func NewEmptyView_nameContext() *View_nameContext

+ func NewView_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *View_nameContext

+ func (*View_nameContext) IsView_nameContext()

+ func (s *View_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ func (s *View_nameContext) Any_name() IAny_nameContext

+ func (s *View_nameContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *View_nameContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *View_nameContext) GetParser() antlr.Parser

+ func (s *View_nameContext) GetRuleContext() antlr.RuleContext

+ func (s *View_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type With_clauseContext struct

+ func NewEmptyWith_clauseContext() *With_clauseContext

+ func NewWith_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *With_clauseContext

+ func (*With_clauseContext) IsWith_clauseContext()

+ func (s *With_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

+ func (s *With_clauseContext) AllCOMMA() []antlr.TerminalNode

+ func (s *With_clauseContext) AllCommon_table_expression() []ICommon_table_expressionContext

+ func (s *With_clauseContext) COMMA(i int) antlr.TerminalNode

+ func (s *With_clauseContext) Common_table_expression(i int) ICommon_table_expressionContext

+ func (s *With_clauseContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *With_clauseContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *With_clauseContext) GetParser() antlr.Parser

+ func (s *With_clauseContext) GetRuleContext() antlr.RuleContext

+ func (s *With_clauseContext) K_RECURSIVE() antlr.TerminalNode

+ func (s *With_clauseContext) K_WITH() antlr.TerminalNode

+ func (s *With_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

?	: This menu
/	: Search site
f or F	: Jump to
y or Y	: Canonical URL