parser

package
v0.0.4 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Dec 7, 2021 License: Apache-2.0 Imports: 5 Imported by: 0

README

Simplified CQL grammar

How to generate the grammar files

First, install antlr 4.

On a Mac: brew install antlr.

Second, generate the Go files for the SimplifiedCql grammar:

make

or:

antlr -Dlanguage=Go antlr/SimplifiedCql.g4

Documentation

Index

Constants

View Source 
const (
	SimplifiedCqlLexerT__0                = 1
	SimplifiedCqlLexerT__1                = 2
	SimplifiedCqlLexerT__2                = 3
	SimplifiedCqlLexerT__3                = 4
	SimplifiedCqlLexerT__4                = 5
	SimplifiedCqlLexerT__5                = 6
	SimplifiedCqlLexerT__6                = 7
	SimplifiedCqlLexerT__7                = 8
	SimplifiedCqlLexerT__8                = 9
	SimplifiedCqlLexerT__9                = 10
	SimplifiedCqlLexerT__10               = 11
	SimplifiedCqlLexerT__11               = 12
	SimplifiedCqlLexerT__12               = 13
	SimplifiedCqlLexerT__13               = 14
	SimplifiedCqlLexerT__14               = 15
	SimplifiedCqlLexerT__15               = 16
	SimplifiedCqlLexerT__16               = 17
	SimplifiedCqlLexerT__17               = 18
	SimplifiedCqlLexerT__18               = 19
	SimplifiedCqlLexerT__19               = 20
	SimplifiedCqlLexerK_ALLOW             = 21
	SimplifiedCqlLexerK_AND               = 22
	SimplifiedCqlLexerK_APPLY             = 23
	SimplifiedCqlLexerK_ASC               = 24
	SimplifiedCqlLexerK_AS                = 25
	SimplifiedCqlLexerK_ASCII             = 26
	SimplifiedCqlLexerK_BATCH             = 27
	SimplifiedCqlLexerK_BEGIN             = 28
	SimplifiedCqlLexerK_BIGINT            = 29
	SimplifiedCqlLexerK_BLOB              = 30
	SimplifiedCqlLexerK_BOOLEAN           = 31
	SimplifiedCqlLexerK_BY                = 32
	SimplifiedCqlLexerK_CAST              = 33
	SimplifiedCqlLexerK_CLUSTERING        = 34
	SimplifiedCqlLexerK_CONTAINS          = 35
	SimplifiedCqlLexerK_COUNTER           = 36
	SimplifiedCqlLexerK_COUNT             = 37
	SimplifiedCqlLexerK_DATE              = 38
	SimplifiedCqlLexerK_DECIMAL           = 39
	SimplifiedCqlLexerK_DELETE            = 40
	SimplifiedCqlLexerK_DESC              = 41
	SimplifiedCqlLexerK_DISTINCT          = 42
	SimplifiedCqlLexerK_DOUBLE            = 43
	SimplifiedCqlLexerK_DURATION          = 44
	SimplifiedCqlLexerK_EXISTS            = 45
	SimplifiedCqlLexerK_FILTERING         = 46
	SimplifiedCqlLexerK_FLOAT             = 47
	SimplifiedCqlLexerK_FROM              = 48
	SimplifiedCqlLexerK_FROZEN            = 49
	SimplifiedCqlLexerK_GROUP             = 50
	SimplifiedCqlLexerK_IF                = 51
	SimplifiedCqlLexerK_INET              = 52
	SimplifiedCqlLexerK_INFINITY          = 53
	SimplifiedCqlLexerK_INSERT            = 54
	SimplifiedCqlLexerK_INTO              = 55
	SimplifiedCqlLexerK_INT               = 56
	SimplifiedCqlLexerK_IN                = 57
	SimplifiedCqlLexerK_IS                = 58
	SimplifiedCqlLexerK_JSON              = 59
	SimplifiedCqlLexerK_KEY               = 60
	SimplifiedCqlLexerK_LIKE              = 61
	SimplifiedCqlLexerK_LIMIT             = 62
	SimplifiedCqlLexerK_LIST              = 63
	SimplifiedCqlLexerK_MAP               = 64
	SimplifiedCqlLexerK_NAN               = 65
	SimplifiedCqlLexerK_NOT               = 66
	SimplifiedCqlLexerK_NULL              = 67
	SimplifiedCqlLexerK_ORDER             = 68
	SimplifiedCqlLexerK_PARTITION         = 69
	SimplifiedCqlLexerK_PER               = 70
	SimplifiedCqlLexerK_SELECT            = 71
	SimplifiedCqlLexerK_SET               = 72
	SimplifiedCqlLexerK_SMALLINT          = 73
	SimplifiedCqlLexerK_TEXT              = 74
	SimplifiedCqlLexerK_TIMESTAMP         = 75
	SimplifiedCqlLexerK_TIMEUUID          = 76
	SimplifiedCqlLexerK_TIME              = 77
	SimplifiedCqlLexerK_TINYINT           = 78
	SimplifiedCqlLexerK_TOKEN             = 79
	SimplifiedCqlLexerK_TTL               = 80
	SimplifiedCqlLexerK_TUPLE             = 81
	SimplifiedCqlLexerK_TYPE              = 82
	SimplifiedCqlLexerK_UNLOGGED          = 83
	SimplifiedCqlLexerK_UPDATE            = 84
	SimplifiedCqlLexerK_USE               = 85
	SimplifiedCqlLexerK_USING             = 86
	SimplifiedCqlLexerK_UUID              = 87
	SimplifiedCqlLexerK_VALUES            = 88
	SimplifiedCqlLexerK_VARCHAR           = 89
	SimplifiedCqlLexerK_VARINT            = 90
	SimplifiedCqlLexerK_WHERE             = 91
	SimplifiedCqlLexerK_WRITETIME         = 92
	SimplifiedCqlLexerSTRING_LITERAL      = 93
	SimplifiedCqlLexerQUOTED_IDENTIFIER   = 94
	SimplifiedCqlLexerINTEGER             = 95
	SimplifiedCqlLexerQMARK               = 96
	SimplifiedCqlLexerFLOAT               = 97
	SimplifiedCqlLexerBOOLEAN             = 98
	SimplifiedCqlLexerDURATION            = 99
	SimplifiedCqlLexerUNQUOTED_IDENTIFIER = 100
	SimplifiedCqlLexerHEXNUMBER           = 101
	SimplifiedCqlLexerUUID                = 102
	SimplifiedCqlLexerWS                  = 103
	SimplifiedCqlLexerCOMMENT             = 104
	SimplifiedCqlLexerMULTILINE_COMMENT   = 105
	SimplifiedCqlLexerEOS                 = 106
	SimplifiedCqlLexerOTHER               = 107
)

SimplifiedCqlLexer tokens.

View Source 
const (
	SimplifiedCqlParserEOF                 = antlr.TokenEOF
	SimplifiedCqlParserT__0                = 1
	SimplifiedCqlParserT__1                = 2
	SimplifiedCqlParserT__2                = 3
	SimplifiedCqlParserT__3                = 4
	SimplifiedCqlParserT__4                = 5
	SimplifiedCqlParserT__5                = 6
	SimplifiedCqlParserT__6                = 7
	SimplifiedCqlParserT__7                = 8
	SimplifiedCqlParserT__8                = 9
	SimplifiedCqlParserT__9                = 10
	SimplifiedCqlParserT__10               = 11
	SimplifiedCqlParserT__11               = 12
	SimplifiedCqlParserT__12               = 13
	SimplifiedCqlParserT__13               = 14
	SimplifiedCqlParserT__14               = 15
	SimplifiedCqlParserT__15               = 16
	SimplifiedCqlParserT__16               = 17
	SimplifiedCqlParserT__17               = 18
	SimplifiedCqlParserT__18               = 19
	SimplifiedCqlParserT__19               = 20
	SimplifiedCqlParserK_ALLOW             = 21
	SimplifiedCqlParserK_AND               = 22
	SimplifiedCqlParserK_APPLY             = 23
	SimplifiedCqlParserK_ASC               = 24
	SimplifiedCqlParserK_AS                = 25
	SimplifiedCqlParserK_ASCII             = 26
	SimplifiedCqlParserK_BATCH             = 27
	SimplifiedCqlParserK_BEGIN             = 28
	SimplifiedCqlParserK_BIGINT            = 29
	SimplifiedCqlParserK_BLOB              = 30
	SimplifiedCqlParserK_BOOLEAN           = 31
	SimplifiedCqlParserK_BY                = 32
	SimplifiedCqlParserK_CAST              = 33
	SimplifiedCqlParserK_CLUSTERING        = 34
	SimplifiedCqlParserK_CONTAINS          = 35
	SimplifiedCqlParserK_COUNTER           = 36
	SimplifiedCqlParserK_COUNT             = 37
	SimplifiedCqlParserK_DATE              = 38
	SimplifiedCqlParserK_DECIMAL           = 39
	SimplifiedCqlParserK_DELETE            = 40
	SimplifiedCqlParserK_DESC              = 41
	SimplifiedCqlParserK_DISTINCT          = 42
	SimplifiedCqlParserK_DOUBLE            = 43
	SimplifiedCqlParserK_DURATION          = 44
	SimplifiedCqlParserK_EXISTS            = 45
	SimplifiedCqlParserK_FILTERING         = 46
	SimplifiedCqlParserK_FLOAT             = 47
	SimplifiedCqlParserK_FROM              = 48
	SimplifiedCqlParserK_FROZEN            = 49
	SimplifiedCqlParserK_GROUP             = 50
	SimplifiedCqlParserK_IF                = 51
	SimplifiedCqlParserK_INET              = 52
	SimplifiedCqlParserK_INFINITY          = 53
	SimplifiedCqlParserK_INSERT            = 54
	SimplifiedCqlParserK_INTO              = 55
	SimplifiedCqlParserK_INT               = 56
	SimplifiedCqlParserK_IN                = 57
	SimplifiedCqlParserK_IS                = 58
	SimplifiedCqlParserK_JSON              = 59
	SimplifiedCqlParserK_KEY               = 60
	SimplifiedCqlParserK_LIKE              = 61
	SimplifiedCqlParserK_LIMIT             = 62
	SimplifiedCqlParserK_LIST              = 63
	SimplifiedCqlParserK_MAP               = 64
	SimplifiedCqlParserK_NAN               = 65
	SimplifiedCqlParserK_NOT               = 66
	SimplifiedCqlParserK_NULL              = 67
	SimplifiedCqlParserK_ORDER             = 68
	SimplifiedCqlParserK_PARTITION         = 69
	SimplifiedCqlParserK_PER               = 70
	SimplifiedCqlParserK_SELECT            = 71
	SimplifiedCqlParserK_SET               = 72
	SimplifiedCqlParserK_SMALLINT          = 73
	SimplifiedCqlParserK_TEXT              = 74
	SimplifiedCqlParserK_TIMESTAMP         = 75
	SimplifiedCqlParserK_TIMEUUID          = 76
	SimplifiedCqlParserK_TIME              = 77
	SimplifiedCqlParserK_TINYINT           = 78
	SimplifiedCqlParserK_TOKEN             = 79
	SimplifiedCqlParserK_TTL               = 80
	SimplifiedCqlParserK_TUPLE             = 81
	SimplifiedCqlParserK_TYPE              = 82
	SimplifiedCqlParserK_UNLOGGED          = 83
	SimplifiedCqlParserK_UPDATE            = 84
	SimplifiedCqlParserK_USE               = 85
	SimplifiedCqlParserK_USING             = 86
	SimplifiedCqlParserK_UUID              = 87
	SimplifiedCqlParserK_VALUES            = 88
	SimplifiedCqlParserK_VARCHAR           = 89
	SimplifiedCqlParserK_VARINT            = 90
	SimplifiedCqlParserK_WHERE             = 91
	SimplifiedCqlParserK_WRITETIME         = 92
	SimplifiedCqlParserSTRING_LITERAL      = 93
	SimplifiedCqlParserQUOTED_IDENTIFIER   = 94
	SimplifiedCqlParserINTEGER             = 95
	SimplifiedCqlParserQMARK               = 96
	SimplifiedCqlParserFLOAT               = 97
	SimplifiedCqlParserBOOLEAN             = 98
	SimplifiedCqlParserDURATION            = 99
	SimplifiedCqlParserUNQUOTED_IDENTIFIER = 100
	SimplifiedCqlParserHEXNUMBER           = 101
	SimplifiedCqlParserUUID                = 102
	SimplifiedCqlParserWS                  = 103
	SimplifiedCqlParserCOMMENT             = 104
	SimplifiedCqlParserMULTILINE_COMMENT   = 105
	SimplifiedCqlParserEOS                 = 106
	SimplifiedCqlParserOTHER               = 107
)

SimplifiedCqlParser tokens.

View Source 
const (
	SimplifiedCqlParserRULE_cqlStatement            = 0
	SimplifiedCqlParserRULE_insertStatement         = 1
	SimplifiedCqlParserRULE_updateStatement         = 2
	SimplifiedCqlParserRULE_updateOperations        = 3
	SimplifiedCqlParserRULE_updateOperation         = 4
	SimplifiedCqlParserRULE_deleteStatement         = 5
	SimplifiedCqlParserRULE_deleteOperations        = 6
	SimplifiedCqlParserRULE_deleteOperation         = 7
	SimplifiedCqlParserRULE_batchStatement          = 8
	SimplifiedCqlParserRULE_batchChildStatement     = 9
	SimplifiedCqlParserRULE_selectStatement         = 10
	SimplifiedCqlParserRULE_selectClause            = 11
	SimplifiedCqlParserRULE_selectors               = 12
	SimplifiedCqlParserRULE_selector                = 13
	SimplifiedCqlParserRULE_unaliasedSelector       = 14
	SimplifiedCqlParserRULE_useStatement            = 15
	SimplifiedCqlParserRULE_orderByClause           = 16
	SimplifiedCqlParserRULE_orderings               = 17
	SimplifiedCqlParserRULE_ordering                = 18
	SimplifiedCqlParserRULE_groupByClause           = 19
	SimplifiedCqlParserRULE_perPartitionLimitClause = 20
	SimplifiedCqlParserRULE_limitClause             = 21
	SimplifiedCqlParserRULE_usingClause             = 22
	SimplifiedCqlParserRULE_timestamp               = 23
	SimplifiedCqlParserRULE_ttl                     = 24
	SimplifiedCqlParserRULE_conditions              = 25
	SimplifiedCqlParserRULE_condition               = 26
	SimplifiedCqlParserRULE_whereClause             = 27
	SimplifiedCqlParserRULE_relation                = 28
	SimplifiedCqlParserRULE_operator                = 29
	SimplifiedCqlParserRULE_literal                 = 30
	SimplifiedCqlParserRULE_primitiveLiteral        = 31
	SimplifiedCqlParserRULE_collectionLiteral       = 32
	SimplifiedCqlParserRULE_listLiteral             = 33
	SimplifiedCqlParserRULE_setLiteral              = 34
	SimplifiedCqlParserRULE_mapLiteral              = 35
	SimplifiedCqlParserRULE_mapEntries              = 36
	SimplifiedCqlParserRULE_mapEntry                = 37
	SimplifiedCqlParserRULE_tupleLiterals           = 38
	SimplifiedCqlParserRULE_tupleLiteral            = 39
	SimplifiedCqlParserRULE_udtLiteral              = 40
	SimplifiedCqlParserRULE_fieldLiterals           = 41
	SimplifiedCqlParserRULE_fieldLiteral            = 42
	SimplifiedCqlParserRULE_functionCall            = 43
	SimplifiedCqlParserRULE_functionArgs            = 44
	SimplifiedCqlParserRULE_functionArg             = 45
	SimplifiedCqlParserRULE_bindMarkers             = 46
	SimplifiedCqlParserRULE_bindMarker              = 47
	SimplifiedCqlParserRULE_positionalBindMarker    = 48
	SimplifiedCqlParserRULE_namedBindMarker         = 49
	SimplifiedCqlParserRULE_terms                   = 50
	SimplifiedCqlParserRULE_term                    = 51
	SimplifiedCqlParserRULE_typeCast                = 52
	SimplifiedCqlParserRULE_cqlType                 = 53
	SimplifiedCqlParserRULE_primitiveType           = 54
	SimplifiedCqlParserRULE_collectionType          = 55
	SimplifiedCqlParserRULE_tupleType               = 56
	SimplifiedCqlParserRULE_tableName               = 57
	SimplifiedCqlParserRULE_functionName            = 58
	SimplifiedCqlParserRULE_userTypeName            = 59
	SimplifiedCqlParserRULE_keyspaceName            = 60
	SimplifiedCqlParserRULE_qualifiedIdentifier     = 61
	SimplifiedCqlParserRULE_identifiers             = 62
	SimplifiedCqlParserRULE_identifier              = 63
	SimplifiedCqlParserRULE_unreservedKeyword       = 64
	SimplifiedCqlParserRULE_unrecognizedStatement   = 65
	SimplifiedCqlParserRULE_unrecognizedToken       = 66
)

SimplifiedCqlParser rules.

Variables

This section is empty.

Functions

This section is empty.

Types

type BaseSimplifiedCqlListener 

type BaseSimplifiedCqlListener struct{}

BaseSimplifiedCqlListener is a complete listener for a parse tree produced by SimplifiedCqlParser.

func (*BaseSimplifiedCqlListener) EnterBatchChildStatement 

func (s *BaseSimplifiedCqlListener) EnterBatchChildStatement(ctx *BatchChildStatementContext)

EnterBatchChildStatement is called when production batchChildStatement is entered.

func (*BaseSimplifiedCqlListener) EnterBatchStatement 

func (s *BaseSimplifiedCqlListener) EnterBatchStatement(ctx *BatchStatementContext)

EnterBatchStatement is called when production batchStatement is entered.

func (*BaseSimplifiedCqlListener) EnterBindMarker 

func (s *BaseSimplifiedCqlListener) EnterBindMarker(ctx *BindMarkerContext)

EnterBindMarker is called when production bindMarker is entered.

func (*BaseSimplifiedCqlListener) EnterBindMarkers 

func (s *BaseSimplifiedCqlListener) EnterBindMarkers(ctx *BindMarkersContext)

EnterBindMarkers is called when production bindMarkers is entered.

func (*BaseSimplifiedCqlListener) EnterCollectionLiteral 

func (s *BaseSimplifiedCqlListener) EnterCollectionLiteral(ctx *CollectionLiteralContext)

EnterCollectionLiteral is called when production collectionLiteral is entered.

func (*BaseSimplifiedCqlListener) EnterCollectionType 

func (s *BaseSimplifiedCqlListener) EnterCollectionType(ctx *CollectionTypeContext)

EnterCollectionType is called when production collectionType is entered.

func (*BaseSimplifiedCqlListener) EnterCondition 

func (s *BaseSimplifiedCqlListener) EnterCondition(ctx *ConditionContext)

EnterCondition is called when production condition is entered.

func (*BaseSimplifiedCqlListener) EnterConditions 

func (s *BaseSimplifiedCqlListener) EnterConditions(ctx *ConditionsContext)

EnterConditions is called when production conditions is entered.

func (*BaseSimplifiedCqlListener) EnterCqlStatement 

func (s *BaseSimplifiedCqlListener) EnterCqlStatement(ctx *CqlStatementContext)

EnterCqlStatement is called when production cqlStatement is entered.

func (*BaseSimplifiedCqlListener) EnterCqlType 

func (s *BaseSimplifiedCqlListener) EnterCqlType(ctx *CqlTypeContext)

EnterCqlType is called when production cqlType is entered.

func (*BaseSimplifiedCqlListener) EnterDeleteOperation 

func (s *BaseSimplifiedCqlListener) EnterDeleteOperation(ctx *DeleteOperationContext)

EnterDeleteOperation is called when production deleteOperation is entered.

func (*BaseSimplifiedCqlListener) EnterDeleteOperations 

func (s *BaseSimplifiedCqlListener) EnterDeleteOperations(ctx *DeleteOperationsContext)

EnterDeleteOperations is called when production deleteOperations is entered.

func (*BaseSimplifiedCqlListener) EnterDeleteStatement 

func (s *BaseSimplifiedCqlListener) EnterDeleteStatement(ctx *DeleteStatementContext)

EnterDeleteStatement is called when production deleteStatement is entered.

func (*BaseSimplifiedCqlListener) EnterEveryRule 

func (s *BaseSimplifiedCqlListener) EnterEveryRule(ctx antlr.ParserRuleContext)

EnterEveryRule is called when any rule is entered.

func (*BaseSimplifiedCqlListener) EnterFieldLiteral 

func (s *BaseSimplifiedCqlListener) EnterFieldLiteral(ctx *FieldLiteralContext)

EnterFieldLiteral is called when production fieldLiteral is entered.

func (*BaseSimplifiedCqlListener) EnterFieldLiterals 

func (s *BaseSimplifiedCqlListener) EnterFieldLiterals(ctx *FieldLiteralsContext)

EnterFieldLiterals is called when production fieldLiterals is entered.

func (*BaseSimplifiedCqlListener) EnterFunctionArg 

func (s *BaseSimplifiedCqlListener) EnterFunctionArg(ctx *FunctionArgContext)

EnterFunctionArg is called when production functionArg is entered.

func (*BaseSimplifiedCqlListener) EnterFunctionArgs 

func (s *BaseSimplifiedCqlListener) EnterFunctionArgs(ctx *FunctionArgsContext)

EnterFunctionArgs is called when production functionArgs is entered.

func (*BaseSimplifiedCqlListener) EnterFunctionCall 

func (s *BaseSimplifiedCqlListener) EnterFunctionCall(ctx *FunctionCallContext)

EnterFunctionCall is called when production functionCall is entered.

func (*BaseSimplifiedCqlListener) EnterFunctionName 

func (s *BaseSimplifiedCqlListener) EnterFunctionName(ctx *FunctionNameContext)

EnterFunctionName is called when production functionName is entered.

func (*BaseSimplifiedCqlListener) EnterGroupByClause 

func (s *BaseSimplifiedCqlListener) EnterGroupByClause(ctx *GroupByClauseContext)

EnterGroupByClause is called when production groupByClause is entered.

func (*BaseSimplifiedCqlListener) EnterIdentifier 

func (s *BaseSimplifiedCqlListener) EnterIdentifier(ctx *IdentifierContext)

EnterIdentifier is called when production identifier is entered.

func (*BaseSimplifiedCqlListener) EnterIdentifiers 

func (s *BaseSimplifiedCqlListener) EnterIdentifiers(ctx *IdentifiersContext)

EnterIdentifiers is called when production identifiers is entered.

func (*BaseSimplifiedCqlListener) EnterInsertStatement 

func (s *BaseSimplifiedCqlListener) EnterInsertStatement(ctx *InsertStatementContext)

EnterInsertStatement is called when production insertStatement is entered.

func (*BaseSimplifiedCqlListener) EnterKeyspaceName 

func (s *BaseSimplifiedCqlListener) EnterKeyspaceName(ctx *KeyspaceNameContext)

EnterKeyspaceName is called when production keyspaceName is entered.

func (*BaseSimplifiedCqlListener) EnterLimitClause 

func (s *BaseSimplifiedCqlListener) EnterLimitClause(ctx *LimitClauseContext)

EnterLimitClause is called when production limitClause is entered.

func (*BaseSimplifiedCqlListener) EnterListLiteral 

func (s *BaseSimplifiedCqlListener) EnterListLiteral(ctx *ListLiteralContext)

EnterListLiteral is called when production listLiteral is entered.

func (*BaseSimplifiedCqlListener) EnterLiteral 

func (s *BaseSimplifiedCqlListener) EnterLiteral(ctx *LiteralContext)

EnterLiteral is called when production literal is entered.

func (*BaseSimplifiedCqlListener) EnterMapEntries 

func (s *BaseSimplifiedCqlListener) EnterMapEntries(ctx *MapEntriesContext)

EnterMapEntries is called when production mapEntries is entered.

func (*BaseSimplifiedCqlListener) EnterMapEntry 

func (s *BaseSimplifiedCqlListener) EnterMapEntry(ctx *MapEntryContext)

EnterMapEntry is called when production mapEntry is entered.

func (*BaseSimplifiedCqlListener) EnterMapLiteral 

func (s *BaseSimplifiedCqlListener) EnterMapLiteral(ctx *MapLiteralContext)

EnterMapLiteral is called when production mapLiteral is entered.

func (*BaseSimplifiedCqlListener) EnterNamedBindMarker 

func (s *BaseSimplifiedCqlListener) EnterNamedBindMarker(ctx *NamedBindMarkerContext)

EnterNamedBindMarker is called when production namedBindMarker is entered.

func (*BaseSimplifiedCqlListener) EnterOperator 

func (s *BaseSimplifiedCqlListener) EnterOperator(ctx *OperatorContext)

EnterOperator is called when production operator is entered.

func (*BaseSimplifiedCqlListener) EnterOrderByClause 

func (s *BaseSimplifiedCqlListener) EnterOrderByClause(ctx *OrderByClauseContext)

EnterOrderByClause is called when production orderByClause is entered.

func (*BaseSimplifiedCqlListener) EnterOrdering 

func (s *BaseSimplifiedCqlListener) EnterOrdering(ctx *OrderingContext)

EnterOrdering is called when production ordering is entered.

func (*BaseSimplifiedCqlListener) EnterOrderings 

func (s *BaseSimplifiedCqlListener) EnterOrderings(ctx *OrderingsContext)

EnterOrderings is called when production orderings is entered.

func (*BaseSimplifiedCqlListener) EnterPerPartitionLimitClause 

func (s *BaseSimplifiedCqlListener) EnterPerPartitionLimitClause(ctx *PerPartitionLimitClauseContext)

EnterPerPartitionLimitClause is called when production perPartitionLimitClause is entered.

func (*BaseSimplifiedCqlListener) EnterPositionalBindMarker 

func (s *BaseSimplifiedCqlListener) EnterPositionalBindMarker(ctx *PositionalBindMarkerContext)

EnterPositionalBindMarker is called when production positionalBindMarker is entered.

func (*BaseSimplifiedCqlListener) EnterPrimitiveLiteral 

func (s *BaseSimplifiedCqlListener) EnterPrimitiveLiteral(ctx *PrimitiveLiteralContext)

EnterPrimitiveLiteral is called when production primitiveLiteral is entered.

func (*BaseSimplifiedCqlListener) EnterPrimitiveType 

func (s *BaseSimplifiedCqlListener) EnterPrimitiveType(ctx *PrimitiveTypeContext)

EnterPrimitiveType is called when production primitiveType is entered.

func (*BaseSimplifiedCqlListener) EnterQualifiedIdentifier 

func (s *BaseSimplifiedCqlListener) EnterQualifiedIdentifier(ctx *QualifiedIdentifierContext)

EnterQualifiedIdentifier is called when production qualifiedIdentifier is entered.

func (*BaseSimplifiedCqlListener) EnterRelation 

func (s *BaseSimplifiedCqlListener) EnterRelation(ctx *RelationContext)

EnterRelation is called when production relation is entered.

func (*BaseSimplifiedCqlListener) EnterSelectClause 

func (s *BaseSimplifiedCqlListener) EnterSelectClause(ctx *SelectClauseContext)

EnterSelectClause is called when production selectClause is entered.

func (*BaseSimplifiedCqlListener) EnterSelectStatement 

func (s *BaseSimplifiedCqlListener) EnterSelectStatement(ctx *SelectStatementContext)

EnterSelectStatement is called when production selectStatement is entered.

func (*BaseSimplifiedCqlListener) EnterSelector 

func (s *BaseSimplifiedCqlListener) EnterSelector(ctx *SelectorContext)

EnterSelector is called when production selector is entered.

func (*BaseSimplifiedCqlListener) EnterSelectors 

func (s *BaseSimplifiedCqlListener) EnterSelectors(ctx *SelectorsContext)

EnterSelectors is called when production selectors is entered.

func (*BaseSimplifiedCqlListener) EnterSetLiteral 

func (s *BaseSimplifiedCqlListener) EnterSetLiteral(ctx *SetLiteralContext)

EnterSetLiteral is called when production setLiteral is entered.

func (*BaseSimplifiedCqlListener) EnterTableName 

func (s *BaseSimplifiedCqlListener) EnterTableName(ctx *TableNameContext)

EnterTableName is called when production tableName is entered.

func (*BaseSimplifiedCqlListener) EnterTerm 

func (s *BaseSimplifiedCqlListener) EnterTerm(ctx *TermContext)

EnterTerm is called when production term is entered.

func (*BaseSimplifiedCqlListener) EnterTerms 

func (s *BaseSimplifiedCqlListener) EnterTerms(ctx *TermsContext)

EnterTerms is called when production terms is entered.

func (*BaseSimplifiedCqlListener) EnterTimestamp 

func (s *BaseSimplifiedCqlListener) EnterTimestamp(ctx *TimestampContext)

EnterTimestamp is called when production timestamp is entered.

func (*BaseSimplifiedCqlListener) EnterTtl 

func (s *BaseSimplifiedCqlListener) EnterTtl(ctx *TtlContext)

EnterTtl is called when production ttl is entered.

func (*BaseSimplifiedCqlListener) EnterTupleLiteral 

func (s *BaseSimplifiedCqlListener) EnterTupleLiteral(ctx *TupleLiteralContext)

EnterTupleLiteral is called when production tupleLiteral is entered.

func (*BaseSimplifiedCqlListener) EnterTupleLiterals 

func (s *BaseSimplifiedCqlListener) EnterTupleLiterals(ctx *TupleLiteralsContext)

EnterTupleLiterals is called when production tupleLiterals is entered.

func (*BaseSimplifiedCqlListener) EnterTupleType 

func (s *BaseSimplifiedCqlListener) EnterTupleType(ctx *TupleTypeContext)

EnterTupleType is called when production tupleType is entered.

func (*BaseSimplifiedCqlListener) EnterTypeCast 

func (s *BaseSimplifiedCqlListener) EnterTypeCast(ctx *TypeCastContext)

EnterTypeCast is called when production typeCast is entered.

func (*BaseSimplifiedCqlListener) EnterUdtLiteral 

func (s *BaseSimplifiedCqlListener) EnterUdtLiteral(ctx *UdtLiteralContext)

EnterUdtLiteral is called when production udtLiteral is entered.

func (*BaseSimplifiedCqlListener) EnterUnaliasedSelector 

func (s *BaseSimplifiedCqlListener) EnterUnaliasedSelector(ctx *UnaliasedSelectorContext)

EnterUnaliasedSelector is called when production unaliasedSelector is entered.

func (*BaseSimplifiedCqlListener) EnterUnrecognizedStatement 

func (s *BaseSimplifiedCqlListener) EnterUnrecognizedStatement(ctx *UnrecognizedStatementContext)

EnterUnrecognizedStatement is called when production unrecognizedStatement is entered.

func (*BaseSimplifiedCqlListener) EnterUnrecognizedToken 

func (s *BaseSimplifiedCqlListener) EnterUnrecognizedToken(ctx *UnrecognizedTokenContext)

EnterUnrecognizedToken is called when production unrecognizedToken is entered.

func (*BaseSimplifiedCqlListener) EnterUnreservedKeyword 

func (s *BaseSimplifiedCqlListener) EnterUnreservedKeyword(ctx *UnreservedKeywordContext)

EnterUnreservedKeyword is called when production unreservedKeyword is entered.

func (*BaseSimplifiedCqlListener) EnterUpdateOperation 

func (s *BaseSimplifiedCqlListener) EnterUpdateOperation(ctx *UpdateOperationContext)

EnterUpdateOperation is called when production updateOperation is entered.

func (*BaseSimplifiedCqlListener) EnterUpdateOperations 

func (s *BaseSimplifiedCqlListener) EnterUpdateOperations(ctx *UpdateOperationsContext)

EnterUpdateOperations is called when production updateOperations is entered.

func (*BaseSimplifiedCqlListener) EnterUpdateStatement 

func (s *BaseSimplifiedCqlListener) EnterUpdateStatement(ctx *UpdateStatementContext)

EnterUpdateStatement is called when production updateStatement is entered.

func (*BaseSimplifiedCqlListener) EnterUseStatement 

func (s *BaseSimplifiedCqlListener) EnterUseStatement(ctx *UseStatementContext)

EnterUseStatement is called when production useStatement is entered.

func (*BaseSimplifiedCqlListener) EnterUserTypeName 

func (s *BaseSimplifiedCqlListener) EnterUserTypeName(ctx *UserTypeNameContext)

EnterUserTypeName is called when production userTypeName is entered.

func (*BaseSimplifiedCqlListener) EnterUsingClause 

func (s *BaseSimplifiedCqlListener) EnterUsingClause(ctx *UsingClauseContext)

EnterUsingClause is called when production usingClause is entered.

func (*BaseSimplifiedCqlListener) EnterWhereClause 

func (s *BaseSimplifiedCqlListener) EnterWhereClause(ctx *WhereClauseContext)

EnterWhereClause is called when production whereClause is entered.

func (*BaseSimplifiedCqlListener) ExitBatchChildStatement 

func (s *BaseSimplifiedCqlListener) ExitBatchChildStatement(ctx *BatchChildStatementContext)

ExitBatchChildStatement is called when production batchChildStatement is exited.

func (*BaseSimplifiedCqlListener) ExitBatchStatement 

func (s *BaseSimplifiedCqlListener) ExitBatchStatement(ctx *BatchStatementContext)

ExitBatchStatement is called when production batchStatement is exited.

func (*BaseSimplifiedCqlListener) ExitBindMarker 

func (s *BaseSimplifiedCqlListener) ExitBindMarker(ctx *BindMarkerContext)

ExitBindMarker is called when production bindMarker is exited.

func (*BaseSimplifiedCqlListener) ExitBindMarkers 

func (s *BaseSimplifiedCqlListener) ExitBindMarkers(ctx *BindMarkersContext)

ExitBindMarkers is called when production bindMarkers is exited.

func (*BaseSimplifiedCqlListener) ExitCollectionLiteral 

func (s *BaseSimplifiedCqlListener) ExitCollectionLiteral(ctx *CollectionLiteralContext)

ExitCollectionLiteral is called when production collectionLiteral is exited.

func (*BaseSimplifiedCqlListener) ExitCollectionType 

func (s *BaseSimplifiedCqlListener) ExitCollectionType(ctx *CollectionTypeContext)

ExitCollectionType is called when production collectionType is exited.

func (*BaseSimplifiedCqlListener) ExitCondition 

func (s *BaseSimplifiedCqlListener) ExitCondition(ctx *ConditionContext)

ExitCondition is called when production condition is exited.

func (*BaseSimplifiedCqlListener) ExitConditions 

func (s *BaseSimplifiedCqlListener) ExitConditions(ctx *ConditionsContext)

ExitConditions is called when production conditions is exited.

func (*BaseSimplifiedCqlListener) ExitCqlStatement 

func (s *BaseSimplifiedCqlListener) ExitCqlStatement(ctx *CqlStatementContext)

ExitCqlStatement is called when production cqlStatement is exited.

func (*BaseSimplifiedCqlListener) ExitCqlType 

func (s *BaseSimplifiedCqlListener) ExitCqlType(ctx *CqlTypeContext)

ExitCqlType is called when production cqlType is exited.

func (*BaseSimplifiedCqlListener) ExitDeleteOperation 

func (s *BaseSimplifiedCqlListener) ExitDeleteOperation(ctx *DeleteOperationContext)

ExitDeleteOperation is called when production deleteOperation is exited.

func (*BaseSimplifiedCqlListener) ExitDeleteOperations 

func (s *BaseSimplifiedCqlListener) ExitDeleteOperations(ctx *DeleteOperationsContext)

ExitDeleteOperations is called when production deleteOperations is exited.

func (*BaseSimplifiedCqlListener) ExitDeleteStatement 

func (s *BaseSimplifiedCqlListener) ExitDeleteStatement(ctx *DeleteStatementContext)

ExitDeleteStatement is called when production deleteStatement is exited.

func (*BaseSimplifiedCqlListener) ExitEveryRule 

func (s *BaseSimplifiedCqlListener) ExitEveryRule(ctx antlr.ParserRuleContext)

ExitEveryRule is called when any rule is exited.

func (*BaseSimplifiedCqlListener) ExitFieldLiteral 

func (s *BaseSimplifiedCqlListener) ExitFieldLiteral(ctx *FieldLiteralContext)

ExitFieldLiteral is called when production fieldLiteral is exited.

func (*BaseSimplifiedCqlListener) ExitFieldLiterals 

func (s *BaseSimplifiedCqlListener) ExitFieldLiterals(ctx *FieldLiteralsContext)

ExitFieldLiterals is called when production fieldLiterals is exited.

func (*BaseSimplifiedCqlListener) ExitFunctionArg 

func (s *BaseSimplifiedCqlListener) ExitFunctionArg(ctx *FunctionArgContext)

ExitFunctionArg is called when production functionArg is exited.

func (*BaseSimplifiedCqlListener) ExitFunctionArgs 

func (s *BaseSimplifiedCqlListener) ExitFunctionArgs(ctx *FunctionArgsContext)

ExitFunctionArgs is called when production functionArgs is exited.

func (*BaseSimplifiedCqlListener) ExitFunctionCall 

func (s *BaseSimplifiedCqlListener) ExitFunctionCall(ctx *FunctionCallContext)

ExitFunctionCall is called when production functionCall is exited.

func (*BaseSimplifiedCqlListener) ExitFunctionName 

func (s *BaseSimplifiedCqlListener) ExitFunctionName(ctx *FunctionNameContext)

ExitFunctionName is called when production functionName is exited.

func (*BaseSimplifiedCqlListener) ExitGroupByClause 

func (s *BaseSimplifiedCqlListener) ExitGroupByClause(ctx *GroupByClauseContext)

ExitGroupByClause is called when production groupByClause is exited.

func (*BaseSimplifiedCqlListener) ExitIdentifier 

func (s *BaseSimplifiedCqlListener) ExitIdentifier(ctx *IdentifierContext)

ExitIdentifier is called when production identifier is exited.

func (*BaseSimplifiedCqlListener) ExitIdentifiers 

func (s *BaseSimplifiedCqlListener) ExitIdentifiers(ctx *IdentifiersContext)

ExitIdentifiers is called when production identifiers is exited.

func (*BaseSimplifiedCqlListener) ExitInsertStatement 

func (s *BaseSimplifiedCqlListener) ExitInsertStatement(ctx *InsertStatementContext)

ExitInsertStatement is called when production insertStatement is exited.

func (*BaseSimplifiedCqlListener) ExitKeyspaceName 

func (s *BaseSimplifiedCqlListener) ExitKeyspaceName(ctx *KeyspaceNameContext)

ExitKeyspaceName is called when production keyspaceName is exited.

func (*BaseSimplifiedCqlListener) ExitLimitClause 

func (s *BaseSimplifiedCqlListener) ExitLimitClause(ctx *LimitClauseContext)

ExitLimitClause is called when production limitClause is exited.

func (*BaseSimplifiedCqlListener) ExitListLiteral 

func (s *BaseSimplifiedCqlListener) ExitListLiteral(ctx *ListLiteralContext)

ExitListLiteral is called when production listLiteral is exited.

func (*BaseSimplifiedCqlListener) ExitLiteral 

func (s *BaseSimplifiedCqlListener) ExitLiteral(ctx *LiteralContext)

ExitLiteral is called when production literal is exited.

func (*BaseSimplifiedCqlListener) ExitMapEntries 

func (s *BaseSimplifiedCqlListener) ExitMapEntries(ctx *MapEntriesContext)

ExitMapEntries is called when production mapEntries is exited.

func (*BaseSimplifiedCqlListener) ExitMapEntry 

func (s *BaseSimplifiedCqlListener) ExitMapEntry(ctx *MapEntryContext)

ExitMapEntry is called when production mapEntry is exited.

func (*BaseSimplifiedCqlListener) ExitMapLiteral 

func (s *BaseSimplifiedCqlListener) ExitMapLiteral(ctx *MapLiteralContext)

ExitMapLiteral is called when production mapLiteral is exited.

func (*BaseSimplifiedCqlListener) ExitNamedBindMarker 

func (s *BaseSimplifiedCqlListener) ExitNamedBindMarker(ctx *NamedBindMarkerContext)

ExitNamedBindMarker is called when production namedBindMarker is exited.

func (*BaseSimplifiedCqlListener) ExitOperator 

func (s *BaseSimplifiedCqlListener) ExitOperator(ctx *OperatorContext)

ExitOperator is called when production operator is exited.

func (*BaseSimplifiedCqlListener) ExitOrderByClause 

func (s *BaseSimplifiedCqlListener) ExitOrderByClause(ctx *OrderByClauseContext)

ExitOrderByClause is called when production orderByClause is exited.

func (*BaseSimplifiedCqlListener) ExitOrdering 

func (s *BaseSimplifiedCqlListener) ExitOrdering(ctx *OrderingContext)

ExitOrdering is called when production ordering is exited.

func (*BaseSimplifiedCqlListener) ExitOrderings 

func (s *BaseSimplifiedCqlListener) ExitOrderings(ctx *OrderingsContext)

ExitOrderings is called when production orderings is exited.

func (*BaseSimplifiedCqlListener) ExitPerPartitionLimitClause 

func (s *BaseSimplifiedCqlListener) ExitPerPartitionLimitClause(ctx *PerPartitionLimitClauseContext)

ExitPerPartitionLimitClause is called when production perPartitionLimitClause is exited.

func (*BaseSimplifiedCqlListener) ExitPositionalBindMarker 

func (s *BaseSimplifiedCqlListener) ExitPositionalBindMarker(ctx *PositionalBindMarkerContext)

ExitPositionalBindMarker is called when production positionalBindMarker is exited.

func (*BaseSimplifiedCqlListener) ExitPrimitiveLiteral 

func (s *BaseSimplifiedCqlListener) ExitPrimitiveLiteral(ctx *PrimitiveLiteralContext)

ExitPrimitiveLiteral is called when production primitiveLiteral is exited.

func (*BaseSimplifiedCqlListener) ExitPrimitiveType 

func (s *BaseSimplifiedCqlListener) ExitPrimitiveType(ctx *PrimitiveTypeContext)

ExitPrimitiveType is called when production primitiveType is exited.

func (*BaseSimplifiedCqlListener) ExitQualifiedIdentifier 

func (s *BaseSimplifiedCqlListener) ExitQualifiedIdentifier(ctx *QualifiedIdentifierContext)

ExitQualifiedIdentifier is called when production qualifiedIdentifier is exited.

func (*BaseSimplifiedCqlListener) ExitRelation 

func (s *BaseSimplifiedCqlListener) ExitRelation(ctx *RelationContext)

ExitRelation is called when production relation is exited.

func (*BaseSimplifiedCqlListener) ExitSelectClause 

func (s *BaseSimplifiedCqlListener) ExitSelectClause(ctx *SelectClauseContext)

ExitSelectClause is called when production selectClause is exited.

func (*BaseSimplifiedCqlListener) ExitSelectStatement 

func (s *BaseSimplifiedCqlListener) ExitSelectStatement(ctx *SelectStatementContext)

ExitSelectStatement is called when production selectStatement is exited.

func (*BaseSimplifiedCqlListener) ExitSelector 

func (s *BaseSimplifiedCqlListener) ExitSelector(ctx *SelectorContext)

ExitSelector is called when production selector is exited.

func (*BaseSimplifiedCqlListener) ExitSelectors 

func (s *BaseSimplifiedCqlListener) ExitSelectors(ctx *SelectorsContext)

ExitSelectors is called when production selectors is exited.

func (*BaseSimplifiedCqlListener) ExitSetLiteral 

func (s *BaseSimplifiedCqlListener) ExitSetLiteral(ctx *SetLiteralContext)

ExitSetLiteral is called when production setLiteral is exited.

func (*BaseSimplifiedCqlListener) ExitTableName 

func (s *BaseSimplifiedCqlListener) ExitTableName(ctx *TableNameContext)

ExitTableName is called when production tableName is exited.

func (*BaseSimplifiedCqlListener) ExitTerm 

func (s *BaseSimplifiedCqlListener) ExitTerm(ctx *TermContext)

ExitTerm is called when production term is exited.

func (*BaseSimplifiedCqlListener) ExitTerms 

func (s *BaseSimplifiedCqlListener) ExitTerms(ctx *TermsContext)

ExitTerms is called when production terms is exited.

func (*BaseSimplifiedCqlListener) ExitTimestamp 

func (s *BaseSimplifiedCqlListener) ExitTimestamp(ctx *TimestampContext)

ExitTimestamp is called when production timestamp is exited.

func (*BaseSimplifiedCqlListener) ExitTtl 

func (s *BaseSimplifiedCqlListener) ExitTtl(ctx *TtlContext)

ExitTtl is called when production ttl is exited.

func (*BaseSimplifiedCqlListener) ExitTupleLiteral 

func (s *BaseSimplifiedCqlListener) ExitTupleLiteral(ctx *TupleLiteralContext)

ExitTupleLiteral is called when production tupleLiteral is exited.

func (*BaseSimplifiedCqlListener) ExitTupleLiterals 

func (s *BaseSimplifiedCqlListener) ExitTupleLiterals(ctx *TupleLiteralsContext)

ExitTupleLiterals is called when production tupleLiterals is exited.

func (*BaseSimplifiedCqlListener) ExitTupleType 

func (s *BaseSimplifiedCqlListener) ExitTupleType(ctx *TupleTypeContext)

ExitTupleType is called when production tupleType is exited.

func (*BaseSimplifiedCqlListener) ExitTypeCast 

func (s *BaseSimplifiedCqlListener) ExitTypeCast(ctx *TypeCastContext)

ExitTypeCast is called when production typeCast is exited.

func (*BaseSimplifiedCqlListener) ExitUdtLiteral 

func (s *BaseSimplifiedCqlListener) ExitUdtLiteral(ctx *UdtLiteralContext)

ExitUdtLiteral is called when production udtLiteral is exited.

func (*BaseSimplifiedCqlListener) ExitUnaliasedSelector 

func (s *BaseSimplifiedCqlListener) ExitUnaliasedSelector(ctx *UnaliasedSelectorContext)

ExitUnaliasedSelector is called when production unaliasedSelector is exited.

func (*BaseSimplifiedCqlListener) ExitUnrecognizedStatement 

func (s *BaseSimplifiedCqlListener) ExitUnrecognizedStatement(ctx *UnrecognizedStatementContext)

ExitUnrecognizedStatement is called when production unrecognizedStatement is exited.

func (*BaseSimplifiedCqlListener) ExitUnrecognizedToken 

func (s *BaseSimplifiedCqlListener) ExitUnrecognizedToken(ctx *UnrecognizedTokenContext)

ExitUnrecognizedToken is called when production unrecognizedToken is exited.

func (*BaseSimplifiedCqlListener) ExitUnreservedKeyword 

func (s *BaseSimplifiedCqlListener) ExitUnreservedKeyword(ctx *UnreservedKeywordContext)

ExitUnreservedKeyword is called when production unreservedKeyword is exited.

func (*BaseSimplifiedCqlListener) ExitUpdateOperation 

func (s *BaseSimplifiedCqlListener) ExitUpdateOperation(ctx *UpdateOperationContext)

ExitUpdateOperation is called when production updateOperation is exited.

func (*BaseSimplifiedCqlListener) ExitUpdateOperations 

func (s *BaseSimplifiedCqlListener) ExitUpdateOperations(ctx *UpdateOperationsContext)

ExitUpdateOperations is called when production updateOperations is exited.

func (*BaseSimplifiedCqlListener) ExitUpdateStatement 

func (s *BaseSimplifiedCqlListener) ExitUpdateStatement(ctx *UpdateStatementContext)

ExitUpdateStatement is called when production updateStatement is exited.

func (*BaseSimplifiedCqlListener) ExitUseStatement 

func (s *BaseSimplifiedCqlListener) ExitUseStatement(ctx *UseStatementContext)

ExitUseStatement is called when production useStatement is exited.

func (*BaseSimplifiedCqlListener) ExitUserTypeName 

func (s *BaseSimplifiedCqlListener) ExitUserTypeName(ctx *UserTypeNameContext)

ExitUserTypeName is called when production userTypeName is exited.

func (*BaseSimplifiedCqlListener) ExitUsingClause 

func (s *BaseSimplifiedCqlListener) ExitUsingClause(ctx *UsingClauseContext)

ExitUsingClause is called when production usingClause is exited.

func (*BaseSimplifiedCqlListener) ExitWhereClause 

func (s *BaseSimplifiedCqlListener) ExitWhereClause(ctx *WhereClauseContext)

ExitWhereClause is called when production whereClause is exited.

func (*BaseSimplifiedCqlListener) VisitErrorNode 

func (s *BaseSimplifiedCqlListener) VisitErrorNode(node antlr.ErrorNode)

VisitErrorNode is called when an error node is visited.

func (*BaseSimplifiedCqlListener) VisitTerminal 

func (s *BaseSimplifiedCqlListener) VisitTerminal(node antlr.TerminalNode)

VisitTerminal is called when a terminal node is visited.

type BatchChildStatementContext 

type BatchChildStatementContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewBatchChildStatementContext 

func NewBatchChildStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *BatchChildStatementContext

func NewEmptyBatchChildStatementContext 

func NewEmptyBatchChildStatementContext() *BatchChildStatementContext

func (*BatchChildStatementContext) DeleteStatement 

func (s *BatchChildStatementContext) DeleteStatement() IDeleteStatementContext

func (*BatchChildStatementContext) EnterRule 

func (s *BatchChildStatementContext) EnterRule(listener antlr.ParseTreeListener)

func (*BatchChildStatementContext) ExitRule 

func (s *BatchChildStatementContext) ExitRule(listener antlr.ParseTreeListener)

func (*BatchChildStatementContext) GetParser 

func (s *BatchChildStatementContext) GetParser() antlr.Parser

func (*BatchChildStatementContext) GetRuleContext 

func (s *BatchChildStatementContext) GetRuleContext() antlr.RuleContext

func (*BatchChildStatementContext) InsertStatement 

func (s *BatchChildStatementContext) InsertStatement() IInsertStatementContext

func (*BatchChildStatementContext) IsBatchChildStatementContext 

func (*BatchChildStatementContext) IsBatchChildStatementContext()

func (*BatchChildStatementContext) ToStringTree 

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

func (*BatchChildStatementContext) UpdateStatement 

func (s *BatchChildStatementContext) UpdateStatement() IUpdateStatementContext

type BatchStatementContext 

type BatchStatementContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewBatchStatementContext 

func NewBatchStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *BatchStatementContext

func NewEmptyBatchStatementContext 

func NewEmptyBatchStatementContext() *BatchStatementContext

func (*BatchStatementContext) AllBatchChildStatement 

func (s *BatchStatementContext) AllBatchChildStatement() []IBatchChildStatementContext

func (*BatchStatementContext) AllEOS 

func (s *BatchStatementContext) AllEOS() []antlr.TerminalNode

func (*BatchStatementContext) AllK_BATCH 

func (s *BatchStatementContext) AllK_BATCH() []antlr.TerminalNode

func (*BatchStatementContext) BatchChildStatement 

func (s *BatchStatementContext) BatchChildStatement(i int) IBatchChildStatementContext

func (*BatchStatementContext) EOS 

func (s *BatchStatementContext) EOS(i int) antlr.TerminalNode

func (*BatchStatementContext) EnterRule 

func (s *BatchStatementContext) EnterRule(listener antlr.ParseTreeListener)

func (*BatchStatementContext) ExitRule 

func (s *BatchStatementContext) ExitRule(listener antlr.ParseTreeListener)

func (*BatchStatementContext) GetParser 

func (s *BatchStatementContext) GetParser() antlr.Parser

func (*BatchStatementContext) GetRuleContext 

func (s *BatchStatementContext) GetRuleContext() antlr.RuleContext

func (*BatchStatementContext) IsBatchStatementContext 

func (*BatchStatementContext) IsBatchStatementContext()

func (*BatchStatementContext) K_APPLY 

func (s *BatchStatementContext) K_APPLY() antlr.TerminalNode

func (*BatchStatementContext) K_BATCH 

func (s *BatchStatementContext) K_BATCH(i int) antlr.TerminalNode

func (*BatchStatementContext) K_BEGIN 

func (s *BatchStatementContext) K_BEGIN() antlr.TerminalNode

func (*BatchStatementContext) K_COUNTER 

func (s *BatchStatementContext) K_COUNTER() antlr.TerminalNode

func (*BatchStatementContext) K_UNLOGGED 

func (s *BatchStatementContext) K_UNLOGGED() antlr.TerminalNode

func (*BatchStatementContext) ToStringTree 

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

func (*BatchStatementContext) UsingClause 

func (s *BatchStatementContext) UsingClause() IUsingClauseContext

type BindMarkerContext 

type BindMarkerContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewBindMarkerContext 

func NewBindMarkerContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *BindMarkerContext

func NewEmptyBindMarkerContext 

func NewEmptyBindMarkerContext() *BindMarkerContext

func (*BindMarkerContext) EnterRule 

func (s *BindMarkerContext) EnterRule(listener antlr.ParseTreeListener)

func (*BindMarkerContext) ExitRule 

func (s *BindMarkerContext) ExitRule(listener antlr.ParseTreeListener)

func (*BindMarkerContext) GetParser 

func (s *BindMarkerContext) GetParser() antlr.Parser

func (*BindMarkerContext) GetRuleContext 

func (s *BindMarkerContext) GetRuleContext() antlr.RuleContext

func (*BindMarkerContext) IsBindMarkerContext 

func (*BindMarkerContext) IsBindMarkerContext()

func (*BindMarkerContext) NamedBindMarker 

func (s *BindMarkerContext) NamedBindMarker() INamedBindMarkerContext

func (*BindMarkerContext) PositionalBindMarker 

func (s *BindMarkerContext) PositionalBindMarker() IPositionalBindMarkerContext

func (*BindMarkerContext) ToStringTree 

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

type BindMarkersContext 

type BindMarkersContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewBindMarkersContext 

func NewBindMarkersContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *BindMarkersContext

func NewEmptyBindMarkersContext 

func NewEmptyBindMarkersContext() *BindMarkersContext

func (*BindMarkersContext) AllBindMarker 

func (s *BindMarkersContext) AllBindMarker() []IBindMarkerContext

func (*BindMarkersContext) BindMarker 

func (s *BindMarkersContext) BindMarker(i int) IBindMarkerContext

func (*BindMarkersContext) EnterRule 

func (s *BindMarkersContext) EnterRule(listener antlr.ParseTreeListener)

func (*BindMarkersContext) ExitRule 

func (s *BindMarkersContext) ExitRule(listener antlr.ParseTreeListener)

func (*BindMarkersContext) GetParser 

func (s *BindMarkersContext) GetParser() antlr.Parser

func (*BindMarkersContext) GetRuleContext 

func (s *BindMarkersContext) GetRuleContext() antlr.RuleContext

func (*BindMarkersContext) IsBindMarkersContext 

func (*BindMarkersContext) IsBindMarkersContext()

func (*BindMarkersContext) ToStringTree 

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

type CollectionLiteralContext 

type CollectionLiteralContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewCollectionLiteralContext 

func NewCollectionLiteralContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CollectionLiteralContext

func NewEmptyCollectionLiteralContext 

func NewEmptyCollectionLiteralContext() *CollectionLiteralContext

func (*CollectionLiteralContext) EnterRule 

func (s *CollectionLiteralContext) EnterRule(listener antlr.ParseTreeListener)

func (*CollectionLiteralContext) ExitRule 

func (s *CollectionLiteralContext) ExitRule(listener antlr.ParseTreeListener)

func (*CollectionLiteralContext) GetParser 

func (s *CollectionLiteralContext) GetParser() antlr.Parser

func (*CollectionLiteralContext) GetRuleContext 

func (s *CollectionLiteralContext) GetRuleContext() antlr.RuleContext

func (*CollectionLiteralContext) IsCollectionLiteralContext 

func (*CollectionLiteralContext) IsCollectionLiteralContext()

func (*CollectionLiteralContext) ListLiteral 

func (s *CollectionLiteralContext) ListLiteral() IListLiteralContext

func (*CollectionLiteralContext) MapLiteral 

func (s *CollectionLiteralContext) MapLiteral() IMapLiteralContext

func (*CollectionLiteralContext) SetLiteral 

func (s *CollectionLiteralContext) SetLiteral() ISetLiteralContext

func (*CollectionLiteralContext) ToStringTree 

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

type CollectionTypeContext 

type CollectionTypeContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewCollectionTypeContext 

func NewCollectionTypeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CollectionTypeContext

func NewEmptyCollectionTypeContext 

func NewEmptyCollectionTypeContext() *CollectionTypeContext

func (*CollectionTypeContext) AllCqlType 

func (s *CollectionTypeContext) AllCqlType() []ICqlTypeContext

func (*CollectionTypeContext) CqlType 

func (s *CollectionTypeContext) CqlType(i int) ICqlTypeContext

func (*CollectionTypeContext) EnterRule 

func (s *CollectionTypeContext) EnterRule(listener antlr.ParseTreeListener)

func (*CollectionTypeContext) ExitRule 

func (s *CollectionTypeContext) ExitRule(listener antlr.ParseTreeListener)

func (*CollectionTypeContext) GetParser 

func (s *CollectionTypeContext) GetParser() antlr.Parser

func (*CollectionTypeContext) GetRuleContext 

func (s *CollectionTypeContext) GetRuleContext() antlr.RuleContext

func (*CollectionTypeContext) IsCollectionTypeContext 

func (*CollectionTypeContext) IsCollectionTypeContext()

func (*CollectionTypeContext) K_LIST 

func (s *CollectionTypeContext) K_LIST() antlr.TerminalNode

func (*CollectionTypeContext) K_MAP 

func (s *CollectionTypeContext) K_MAP() antlr.TerminalNode

func (*CollectionTypeContext) K_SET 

func (s *CollectionTypeContext) K_SET() antlr.TerminalNode

func (*CollectionTypeContext) ToStringTree 

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

type ConditionContext 

type ConditionContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewConditionContext 

func NewConditionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ConditionContext

func NewEmptyConditionContext 

func NewEmptyConditionContext() *ConditionContext

func (*ConditionContext) AllIdentifier 

func (s *ConditionContext) AllIdentifier() []IIdentifierContext

func (*ConditionContext) AllTerm 

func (s *ConditionContext) AllTerm() []ITermContext

func (*ConditionContext) BindMarker 

func (s *ConditionContext) BindMarker() IBindMarkerContext

func (*ConditionContext) EnterRule 

func (s *ConditionContext) EnterRule(listener antlr.ParseTreeListener)

func (*ConditionContext) ExitRule 

func (s *ConditionContext) ExitRule(listener antlr.ParseTreeListener)

func (*ConditionContext) GetParser 

func (s *ConditionContext) GetParser() antlr.Parser

func (*ConditionContext) GetRuleContext 

func (s *ConditionContext) GetRuleContext() antlr.RuleContext

func (*ConditionContext) Identifier 

func (s *ConditionContext) Identifier(i int) IIdentifierContext

func (*ConditionContext) IsConditionContext 

func (*ConditionContext) IsConditionContext()

func (*ConditionContext) K_IN 

func (s *ConditionContext) K_IN() antlr.TerminalNode

func (*ConditionContext) Operator 

func (s *ConditionContext) Operator() IOperatorContext

func (*ConditionContext) Term 

func (s *ConditionContext) Term(i int) ITermContext

func (*ConditionContext) Terms 

func (s *ConditionContext) Terms() ITermsContext

func (*ConditionContext) ToStringTree 

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

type ConditionsContext 

type ConditionsContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewConditionsContext 

func NewConditionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ConditionsContext

func NewEmptyConditionsContext 

func NewEmptyConditionsContext() *ConditionsContext

func (*ConditionsContext) AllCondition 

func (s *ConditionsContext) AllCondition() []IConditionContext

func (*ConditionsContext) AllK_AND 

func (s *ConditionsContext) AllK_AND() []antlr.TerminalNode

func (*ConditionsContext) Condition 

func (s *ConditionsContext) Condition(i int) IConditionContext

func (*ConditionsContext) EnterRule 

func (s *ConditionsContext) EnterRule(listener antlr.ParseTreeListener)

func (*ConditionsContext) ExitRule 

func (s *ConditionsContext) ExitRule(listener antlr.ParseTreeListener)

func (*ConditionsContext) GetParser 

func (s *ConditionsContext) GetParser() antlr.Parser

func (*ConditionsContext) GetRuleContext 

func (s *ConditionsContext) GetRuleContext() antlr.RuleContext

func (*ConditionsContext) IsConditionsContext 

func (*ConditionsContext) IsConditionsContext()

func (*ConditionsContext) K_AND 

func (s *ConditionsContext) K_AND(i int) antlr.TerminalNode

func (*ConditionsContext) ToStringTree 

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

type CqlStatementContext 

type CqlStatementContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewCqlStatementContext 

func NewCqlStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CqlStatementContext

func NewEmptyCqlStatementContext 

func NewEmptyCqlStatementContext() *CqlStatementContext

func (*CqlStatementContext) BatchStatement 

func (s *CqlStatementContext) BatchStatement() IBatchStatementContext

func (*CqlStatementContext) DeleteStatement 

func (s *CqlStatementContext) DeleteStatement() IDeleteStatementContext

func (*CqlStatementContext) EOS 

func (s *CqlStatementContext) EOS() antlr.TerminalNode

func (*CqlStatementContext) EnterRule 

func (s *CqlStatementContext) EnterRule(listener antlr.ParseTreeListener)

func (*CqlStatementContext) ExitRule 

func (s *CqlStatementContext) ExitRule(listener antlr.ParseTreeListener)

func (*CqlStatementContext) GetParser 

func (s *CqlStatementContext) GetParser() antlr.Parser

func (*CqlStatementContext) GetRuleContext 

func (s *CqlStatementContext) GetRuleContext() antlr.RuleContext

func (*CqlStatementContext) InsertStatement 

func (s *CqlStatementContext) InsertStatement() IInsertStatementContext

func (*CqlStatementContext) IsCqlStatementContext 

func (*CqlStatementContext) IsCqlStatementContext()

func (*CqlStatementContext) SelectStatement 

func (s *CqlStatementContext) SelectStatement() ISelectStatementContext

func (*CqlStatementContext) ToStringTree 

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

func (*CqlStatementContext) UnrecognizedStatement 

func (s *CqlStatementContext) UnrecognizedStatement() IUnrecognizedStatementContext

func (*CqlStatementContext) UpdateStatement 

func (s *CqlStatementContext) UpdateStatement() IUpdateStatementContext

func (*CqlStatementContext) UseStatement 

func (s *CqlStatementContext) UseStatement() IUseStatementContext

type CqlTypeContext 

type CqlTypeContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewCqlTypeContext 

func NewCqlTypeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CqlTypeContext

func NewEmptyCqlTypeContext 

func NewEmptyCqlTypeContext() *CqlTypeContext

func (*CqlTypeContext) CollectionType 

func (s *CqlTypeContext) CollectionType() ICollectionTypeContext

func (*CqlTypeContext) CqlType 

func (s *CqlTypeContext) CqlType() ICqlTypeContext

func (*CqlTypeContext) EnterRule 

func (s *CqlTypeContext) EnterRule(listener antlr.ParseTreeListener)

func (*CqlTypeContext) ExitRule 

func (s *CqlTypeContext) ExitRule(listener antlr.ParseTreeListener)

func (*CqlTypeContext) GetParser 

func (s *CqlTypeContext) GetParser() antlr.Parser

func (*CqlTypeContext) GetRuleContext 

func (s *CqlTypeContext) GetRuleContext() antlr.RuleContext

func (*CqlTypeContext) IsCqlTypeContext 

func (*CqlTypeContext) IsCqlTypeContext()

func (*CqlTypeContext) K_FROZEN 

func (s *CqlTypeContext) K_FROZEN() antlr.TerminalNode

func (*CqlTypeContext) PrimitiveType 

func (s *CqlTypeContext) PrimitiveType() IPrimitiveTypeContext

func (*CqlTypeContext) ToStringTree 

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

func (*CqlTypeContext) TupleType 

func (s *CqlTypeContext) TupleType() ITupleTypeContext

func (*CqlTypeContext) UserTypeName 

func (s *CqlTypeContext) UserTypeName() IUserTypeNameContext

type DeleteOperationContext 

type DeleteOperationContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewDeleteOperationContext 

func NewDeleteOperationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DeleteOperationContext

func NewEmptyDeleteOperationContext 

func NewEmptyDeleteOperationContext() *DeleteOperationContext

func (*DeleteOperationContext) AllIdentifier 

func (s *DeleteOperationContext) AllIdentifier() []IIdentifierContext

func (*DeleteOperationContext) EnterRule 

func (s *DeleteOperationContext) EnterRule(listener antlr.ParseTreeListener)

func (*DeleteOperationContext) ExitRule 

func (s *DeleteOperationContext) ExitRule(listener antlr.ParseTreeListener)

func (*DeleteOperationContext) GetParser 

func (s *DeleteOperationContext) GetParser() antlr.Parser

func (*DeleteOperationContext) GetRuleContext 

func (s *DeleteOperationContext) GetRuleContext() antlr.RuleContext

func (*DeleteOperationContext) Identifier 

func (s *DeleteOperationContext) Identifier(i int) IIdentifierContext

func (*DeleteOperationContext) IsDeleteOperationContext 

func (*DeleteOperationContext) IsDeleteOperationContext()

func (*DeleteOperationContext) Term 

func (s *DeleteOperationContext) Term() ITermContext

func (*DeleteOperationContext) ToStringTree 

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

type DeleteOperationsContext 

type DeleteOperationsContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewDeleteOperationsContext 

func NewDeleteOperationsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DeleteOperationsContext

func NewEmptyDeleteOperationsContext 

func NewEmptyDeleteOperationsContext() *DeleteOperationsContext

func (*DeleteOperationsContext) AllDeleteOperation 

func (s *DeleteOperationsContext) AllDeleteOperation() []IDeleteOperationContext

func (*DeleteOperationsContext) DeleteOperation 

func (s *DeleteOperationsContext) DeleteOperation(i int) IDeleteOperationContext

func (*DeleteOperationsContext) EnterRule 

func (s *DeleteOperationsContext) EnterRule(listener antlr.ParseTreeListener)

func (*DeleteOperationsContext) ExitRule 

func (s *DeleteOperationsContext) ExitRule(listener antlr.ParseTreeListener)

func (*DeleteOperationsContext) GetParser 

func (s *DeleteOperationsContext) GetParser() antlr.Parser

func (*DeleteOperationsContext) GetRuleContext 

func (s *DeleteOperationsContext) GetRuleContext() antlr.RuleContext

func (*DeleteOperationsContext) IsDeleteOperationsContext 

func (*DeleteOperationsContext) IsDeleteOperationsContext()

func (*DeleteOperationsContext) ToStringTree 

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

type DeleteStatementContext 

type DeleteStatementContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewDeleteStatementContext 

func NewDeleteStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DeleteStatementContext

func NewEmptyDeleteStatementContext 

func NewEmptyDeleteStatementContext() *DeleteStatementContext

func (*DeleteStatementContext) Conditions 

func (s *DeleteStatementContext) Conditions() IConditionsContext

func (*DeleteStatementContext) DeleteOperations 

func (s *DeleteStatementContext) DeleteOperations() IDeleteOperationsContext

func (*DeleteStatementContext) EnterRule 

func (s *DeleteStatementContext) EnterRule(listener antlr.ParseTreeListener)

func (*DeleteStatementContext) ExitRule 

func (s *DeleteStatementContext) ExitRule(listener antlr.ParseTreeListener)

func (*DeleteStatementContext) GetParser 

func (s *DeleteStatementContext) GetParser() antlr.Parser

func (*DeleteStatementContext) GetRuleContext 

func (s *DeleteStatementContext) GetRuleContext() antlr.RuleContext

func (*DeleteStatementContext) IsDeleteStatementContext 

func (*DeleteStatementContext) IsDeleteStatementContext()

func (*DeleteStatementContext) K_DELETE 

func (s *DeleteStatementContext) K_DELETE() antlr.TerminalNode

func (*DeleteStatementContext) K_EXISTS 

func (s *DeleteStatementContext) K_EXISTS() antlr.TerminalNode

func (*DeleteStatementContext) K_FROM 

func (s *DeleteStatementContext) K_FROM() antlr.TerminalNode

func (*DeleteStatementContext) K_IF 

func (s *DeleteStatementContext) K_IF() antlr.TerminalNode

func (*DeleteStatementContext) K_USING 

func (s *DeleteStatementContext) K_USING() antlr.TerminalNode

func (*DeleteStatementContext) TableName 

func (s *DeleteStatementContext) TableName() ITableNameContext

func (*DeleteStatementContext) Timestamp 

func (s *DeleteStatementContext) Timestamp() ITimestampContext

func (*DeleteStatementContext) ToStringTree 

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

func (*DeleteStatementContext) WhereClause 

func (s *DeleteStatementContext) WhereClause() IWhereClauseContext

type FieldLiteralContext 

type FieldLiteralContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyFieldLiteralContext 

func NewEmptyFieldLiteralContext() *FieldLiteralContext

func NewFieldLiteralContext 

func NewFieldLiteralContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FieldLiteralContext

func (*FieldLiteralContext) EnterRule 

func (s *FieldLiteralContext) EnterRule(listener antlr.ParseTreeListener)

func (*FieldLiteralContext) ExitRule 

func (s *FieldLiteralContext) ExitRule(listener antlr.ParseTreeListener)

func (*FieldLiteralContext) GetParser 

func (s *FieldLiteralContext) GetParser() antlr.Parser

func (*FieldLiteralContext) GetRuleContext 

func (s *FieldLiteralContext) GetRuleContext() antlr.RuleContext

func (*FieldLiteralContext) Identifier 

func (s *FieldLiteralContext) Identifier() IIdentifierContext

func (*FieldLiteralContext) IsFieldLiteralContext 

func (*FieldLiteralContext) IsFieldLiteralContext()

func (*FieldLiteralContext) Term 

func (s *FieldLiteralContext) Term() ITermContext

func (*FieldLiteralContext) ToStringTree 

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

type FieldLiteralsContext 

type FieldLiteralsContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyFieldLiteralsContext 

func NewEmptyFieldLiteralsContext() *FieldLiteralsContext

func NewFieldLiteralsContext 

func NewFieldLiteralsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FieldLiteralsContext

func (*FieldLiteralsContext) AllFieldLiteral 

func (s *FieldLiteralsContext) AllFieldLiteral() []IFieldLiteralContext

func (*FieldLiteralsContext) EnterRule 

func (s *FieldLiteralsContext) EnterRule(listener antlr.ParseTreeListener)

func (*FieldLiteralsContext) ExitRule 

func (s *FieldLiteralsContext) ExitRule(listener antlr.ParseTreeListener)

func (*FieldLiteralsContext) FieldLiteral 

func (s *FieldLiteralsContext) FieldLiteral(i int) IFieldLiteralContext

func (*FieldLiteralsContext) GetParser 

func (s *FieldLiteralsContext) GetParser() antlr.Parser

func (*FieldLiteralsContext) GetRuleContext 

func (s *FieldLiteralsContext) GetRuleContext() antlr.RuleContext

func (*FieldLiteralsContext) IsFieldLiteralsContext 

func (*FieldLiteralsContext) IsFieldLiteralsContext()

func (*FieldLiteralsContext) ToStringTree 

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

type FunctionArgContext 

type FunctionArgContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyFunctionArgContext 

func NewEmptyFunctionArgContext() *FunctionArgContext

func NewFunctionArgContext 

func NewFunctionArgContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FunctionArgContext

func (*FunctionArgContext) EnterRule 

func (s *FunctionArgContext) EnterRule(listener antlr.ParseTreeListener)

func (*FunctionArgContext) ExitRule 

func (s *FunctionArgContext) ExitRule(listener antlr.ParseTreeListener)

func (*FunctionArgContext) GetParser 

func (s *FunctionArgContext) GetParser() antlr.Parser

func (*FunctionArgContext) GetRuleContext 

func (s *FunctionArgContext) GetRuleContext() antlr.RuleContext

func (*FunctionArgContext) Identifier 

func (s *FunctionArgContext) Identifier() IIdentifierContext

func (*FunctionArgContext) IsFunctionArgContext 

func (*FunctionArgContext) IsFunctionArgContext()

func (*FunctionArgContext) Term 

func (s *FunctionArgContext) Term() ITermContext

func (*FunctionArgContext) ToStringTree 

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

type FunctionArgsContext 

type FunctionArgsContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyFunctionArgsContext 

func NewEmptyFunctionArgsContext() *FunctionArgsContext

func NewFunctionArgsContext 

func NewFunctionArgsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FunctionArgsContext

func (*FunctionArgsContext) AllFunctionArg 

func (s *FunctionArgsContext) AllFunctionArg() []IFunctionArgContext

func (*FunctionArgsContext) EnterRule 

func (s *FunctionArgsContext) EnterRule(listener antlr.ParseTreeListener)

func (*FunctionArgsContext) ExitRule 

func (s *FunctionArgsContext) ExitRule(listener antlr.ParseTreeListener)

func (*FunctionArgsContext) FunctionArg 

func (s *FunctionArgsContext) FunctionArg(i int) IFunctionArgContext

func (*FunctionArgsContext) GetParser 

func (s *FunctionArgsContext) GetParser() antlr.Parser

func (*FunctionArgsContext) GetRuleContext 

func (s *FunctionArgsContext) GetRuleContext() antlr.RuleContext

func (*FunctionArgsContext) IsFunctionArgsContext 

func (*FunctionArgsContext) IsFunctionArgsContext()

func (*FunctionArgsContext) ToStringTree 

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

type FunctionCallContext 

type FunctionCallContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyFunctionCallContext 

func NewEmptyFunctionCallContext() *FunctionCallContext

func NewFunctionCallContext 

func NewFunctionCallContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FunctionCallContext

func (*FunctionCallContext) EnterRule 

func (s *FunctionCallContext) EnterRule(listener antlr.ParseTreeListener)

func (*FunctionCallContext) ExitRule 

func (s *FunctionCallContext) ExitRule(listener antlr.ParseTreeListener)

func (*FunctionCallContext) FunctionArgs 

func (s *FunctionCallContext) FunctionArgs() IFunctionArgsContext

func (*FunctionCallContext) FunctionName 

func (s *FunctionCallContext) FunctionName() IFunctionNameContext

func (*FunctionCallContext) GetParser 

func (s *FunctionCallContext) GetParser() antlr.Parser

func (*FunctionCallContext) GetRuleContext 

func (s *FunctionCallContext) GetRuleContext() antlr.RuleContext

func (*FunctionCallContext) IsFunctionCallContext 

func (*FunctionCallContext) IsFunctionCallContext()

func (*FunctionCallContext) ToStringTree 

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

type FunctionNameContext 

type FunctionNameContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyFunctionNameContext 

func NewEmptyFunctionNameContext() *FunctionNameContext

func NewFunctionNameContext 

func NewFunctionNameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FunctionNameContext

func (*FunctionNameContext) EnterRule 

func (s *FunctionNameContext) EnterRule(listener antlr.ParseTreeListener)

func (*FunctionNameContext) ExitRule 

func (s *FunctionNameContext) ExitRule(listener antlr.ParseTreeListener)

func (*FunctionNameContext) GetParser 

func (s *FunctionNameContext) GetParser() antlr.Parser

func (*FunctionNameContext) GetRuleContext 

func (s *FunctionNameContext) GetRuleContext() antlr.RuleContext

func (*FunctionNameContext) IsFunctionNameContext 

func (*FunctionNameContext) IsFunctionNameContext()

func (*FunctionNameContext) QualifiedIdentifier 

func (s *FunctionNameContext) QualifiedIdentifier() IQualifiedIdentifierContext

func (*FunctionNameContext) ToStringTree 

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

type GroupByClauseContext 

type GroupByClauseContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyGroupByClauseContext 

func NewEmptyGroupByClauseContext() *GroupByClauseContext

func NewGroupByClauseContext 

func NewGroupByClauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *GroupByClauseContext

func (*GroupByClauseContext) EnterRule 

func (s *GroupByClauseContext) EnterRule(listener antlr.ParseTreeListener)

func (*GroupByClauseContext) ExitRule 

func (s *GroupByClauseContext) ExitRule(listener antlr.ParseTreeListener)

func (*GroupByClauseContext) GetParser 

func (s *GroupByClauseContext) GetParser() antlr.Parser

func (*GroupByClauseContext) GetRuleContext 

func (s *GroupByClauseContext) GetRuleContext() antlr.RuleContext

func (*GroupByClauseContext) Identifiers 

func (s *GroupByClauseContext) Identifiers() IIdentifiersContext

func (*GroupByClauseContext) IsGroupByClauseContext 

func (*GroupByClauseContext) IsGroupByClauseContext()

func (*GroupByClauseContext) K_BY 

func (s *GroupByClauseContext) K_BY() antlr.TerminalNode

func (*GroupByClauseContext) K_GROUP 

func (s *GroupByClauseContext) K_GROUP() antlr.TerminalNode

func (*GroupByClauseContext) ToStringTree 

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

type IBatchChildStatementContext 

type IBatchChildStatementContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsBatchChildStatementContext differentiates from other interfaces.
	IsBatchChildStatementContext()
}

IBatchChildStatementContext is an interface to support dynamic dispatch.

type IBatchStatementContext 

type IBatchStatementContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsBatchStatementContext differentiates from other interfaces.
	IsBatchStatementContext()
}

IBatchStatementContext is an interface to support dynamic dispatch.

type IBindMarkerContext 

type IBindMarkerContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsBindMarkerContext differentiates from other interfaces.
	IsBindMarkerContext()
}

IBindMarkerContext is an interface to support dynamic dispatch.

type IBindMarkersContext 

type IBindMarkersContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsBindMarkersContext differentiates from other interfaces.
	IsBindMarkersContext()
}

IBindMarkersContext is an interface to support dynamic dispatch.

type ICollectionLiteralContext 

type ICollectionLiteralContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsCollectionLiteralContext differentiates from other interfaces.
	IsCollectionLiteralContext()
}

ICollectionLiteralContext is an interface to support dynamic dispatch.

type ICollectionTypeContext 

type ICollectionTypeContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsCollectionTypeContext differentiates from other interfaces.
	IsCollectionTypeContext()
}

ICollectionTypeContext is an interface to support dynamic dispatch.

type IConditionContext 

type IConditionContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsConditionContext differentiates from other interfaces.
	IsConditionContext()
}

IConditionContext is an interface to support dynamic dispatch.

type IConditionsContext 

type IConditionsContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsConditionsContext differentiates from other interfaces.
	IsConditionsContext()
}

IConditionsContext is an interface to support dynamic dispatch.

type ICqlStatementContext 

type ICqlStatementContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsCqlStatementContext differentiates from other interfaces.
	IsCqlStatementContext()
}

ICqlStatementContext is an interface to support dynamic dispatch.

type ICqlTypeContext 

type ICqlTypeContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsCqlTypeContext differentiates from other interfaces.
	IsCqlTypeContext()
}

ICqlTypeContext is an interface to support dynamic dispatch.

type IDeleteOperationContext 

type IDeleteOperationContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsDeleteOperationContext differentiates from other interfaces.
	IsDeleteOperationContext()
}

IDeleteOperationContext is an interface to support dynamic dispatch.

type IDeleteOperationsContext 

type IDeleteOperationsContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsDeleteOperationsContext differentiates from other interfaces.
	IsDeleteOperationsContext()
}

IDeleteOperationsContext is an interface to support dynamic dispatch.

type IDeleteStatementContext 

type IDeleteStatementContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsDeleteStatementContext differentiates from other interfaces.
	IsDeleteStatementContext()
}

IDeleteStatementContext is an interface to support dynamic dispatch.

type IFieldLiteralContext 

type IFieldLiteralContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsFieldLiteralContext differentiates from other interfaces.
	IsFieldLiteralContext()
}

IFieldLiteralContext is an interface to support dynamic dispatch.

type IFieldLiteralsContext 

type IFieldLiteralsContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsFieldLiteralsContext differentiates from other interfaces.
	IsFieldLiteralsContext()
}

IFieldLiteralsContext is an interface to support dynamic dispatch.

type IFunctionArgContext 

type IFunctionArgContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsFunctionArgContext differentiates from other interfaces.
	IsFunctionArgContext()
}

IFunctionArgContext is an interface to support dynamic dispatch.

type IFunctionArgsContext 

type IFunctionArgsContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsFunctionArgsContext differentiates from other interfaces.
	IsFunctionArgsContext()
}

IFunctionArgsContext is an interface to support dynamic dispatch.

type IFunctionCallContext 

type IFunctionCallContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsFunctionCallContext differentiates from other interfaces.
	IsFunctionCallContext()
}

IFunctionCallContext is an interface to support dynamic dispatch.

type IFunctionNameContext 

type IFunctionNameContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsFunctionNameContext differentiates from other interfaces.
	IsFunctionNameContext()
}

IFunctionNameContext is an interface to support dynamic dispatch.

type IGroupByClauseContext 

type IGroupByClauseContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsGroupByClauseContext differentiates from other interfaces.
	IsGroupByClauseContext()
}

IGroupByClauseContext is an interface to support dynamic dispatch.

type IIdentifierContext 

type IIdentifierContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsIdentifierContext differentiates from other interfaces.
	IsIdentifierContext()
}

IIdentifierContext is an interface to support dynamic dispatch.

type IIdentifiersContext 

type IIdentifiersContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsIdentifiersContext differentiates from other interfaces.
	IsIdentifiersContext()
}

IIdentifiersContext is an interface to support dynamic dispatch.

type IInsertStatementContext 

type IInsertStatementContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsInsertStatementContext differentiates from other interfaces.
	IsInsertStatementContext()
}

IInsertStatementContext is an interface to support dynamic dispatch.

type IKeyspaceNameContext 

type IKeyspaceNameContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsKeyspaceNameContext differentiates from other interfaces.
	IsKeyspaceNameContext()
}

IKeyspaceNameContext is an interface to support dynamic dispatch.

type ILimitClauseContext 

type ILimitClauseContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsLimitClauseContext differentiates from other interfaces.
	IsLimitClauseContext()
}

ILimitClauseContext is an interface to support dynamic dispatch.

type IListLiteralContext 

type IListLiteralContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsListLiteralContext differentiates from other interfaces.
	IsListLiteralContext()
}

IListLiteralContext is an interface to support dynamic dispatch.

type ILiteralContext 

type ILiteralContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsLiteralContext differentiates from other interfaces.
	IsLiteralContext()
}

ILiteralContext is an interface to support dynamic dispatch.

type IMapEntriesContext 

type IMapEntriesContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsMapEntriesContext differentiates from other interfaces.
	IsMapEntriesContext()
}

IMapEntriesContext is an interface to support dynamic dispatch.

type IMapEntryContext 

type IMapEntryContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsMapEntryContext differentiates from other interfaces.
	IsMapEntryContext()
}

IMapEntryContext is an interface to support dynamic dispatch.

type IMapLiteralContext 

type IMapLiteralContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsMapLiteralContext differentiates from other interfaces.
	IsMapLiteralContext()
}

IMapLiteralContext is an interface to support dynamic dispatch.

type INamedBindMarkerContext 

type INamedBindMarkerContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsNamedBindMarkerContext differentiates from other interfaces.
	IsNamedBindMarkerContext()
}

INamedBindMarkerContext is an interface to support dynamic dispatch.

type IOperatorContext 

type IOperatorContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsOperatorContext differentiates from other interfaces.
	IsOperatorContext()
}

IOperatorContext is an interface to support dynamic dispatch.

type IOrderByClauseContext 

type IOrderByClauseContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsOrderByClauseContext differentiates from other interfaces.
	IsOrderByClauseContext()
}

IOrderByClauseContext is an interface to support dynamic dispatch.

type IOrderingContext 

type IOrderingContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsOrderingContext differentiates from other interfaces.
	IsOrderingContext()
}

IOrderingContext is an interface to support dynamic dispatch.

type IOrderingsContext 

type IOrderingsContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsOrderingsContext differentiates from other interfaces.
	IsOrderingsContext()
}

IOrderingsContext is an interface to support dynamic dispatch.

type IPerPartitionLimitClauseContext 

type IPerPartitionLimitClauseContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsPerPartitionLimitClauseContext differentiates from other interfaces.
	IsPerPartitionLimitClauseContext()
}

IPerPartitionLimitClauseContext is an interface to support dynamic dispatch.

type IPositionalBindMarkerContext 

type IPositionalBindMarkerContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsPositionalBindMarkerContext differentiates from other interfaces.
	IsPositionalBindMarkerContext()
}

IPositionalBindMarkerContext is an interface to support dynamic dispatch.

type IPrimitiveLiteralContext 

type IPrimitiveLiteralContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsPrimitiveLiteralContext differentiates from other interfaces.
	IsPrimitiveLiteralContext()
}

IPrimitiveLiteralContext is an interface to support dynamic dispatch.

type IPrimitiveTypeContext 

type IPrimitiveTypeContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsPrimitiveTypeContext differentiates from other interfaces.
	IsPrimitiveTypeContext()
}

IPrimitiveTypeContext is an interface to support dynamic dispatch.

type IQualifiedIdentifierContext 

type IQualifiedIdentifierContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsQualifiedIdentifierContext differentiates from other interfaces.
	IsQualifiedIdentifierContext()
}

IQualifiedIdentifierContext is an interface to support dynamic dispatch.

type IRelationContext 

type IRelationContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsRelationContext differentiates from other interfaces.
	IsRelationContext()
}

IRelationContext is an interface to support dynamic dispatch.

type ISelectClauseContext 

type ISelectClauseContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsSelectClauseContext differentiates from other interfaces.
	IsSelectClauseContext()
}

ISelectClauseContext is an interface to support dynamic dispatch.

type ISelectStatementContext 

type ISelectStatementContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsSelectStatementContext differentiates from other interfaces.
	IsSelectStatementContext()
}

ISelectStatementContext is an interface to support dynamic dispatch.

type ISelectorContext 

type ISelectorContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsSelectorContext differentiates from other interfaces.
	IsSelectorContext()
}

ISelectorContext is an interface to support dynamic dispatch.

type ISelectorsContext 

type ISelectorsContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsSelectorsContext differentiates from other interfaces.
	IsSelectorsContext()
}

ISelectorsContext is an interface to support dynamic dispatch.

type ISetLiteralContext 

type ISetLiteralContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsSetLiteralContext differentiates from other interfaces.
	IsSetLiteralContext()
}

ISetLiteralContext is an interface to support dynamic dispatch.

type ITableNameContext 

type ITableNameContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsTableNameContext differentiates from other interfaces.
	IsTableNameContext()
}

ITableNameContext is an interface to support dynamic dispatch.

type ITermContext 

type ITermContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsTermContext differentiates from other interfaces.
	IsTermContext()
}

ITermContext is an interface to support dynamic dispatch.

type ITermsContext 

type ITermsContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsTermsContext differentiates from other interfaces.
	IsTermsContext()
}

ITermsContext is an interface to support dynamic dispatch.

type ITimestampContext 

type ITimestampContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsTimestampContext differentiates from other interfaces.
	IsTimestampContext()
}

ITimestampContext is an interface to support dynamic dispatch.

type ITtlContext 

type ITtlContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsTtlContext differentiates from other interfaces.
	IsTtlContext()
}

ITtlContext is an interface to support dynamic dispatch.

type ITupleLiteralContext 

type ITupleLiteralContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsTupleLiteralContext differentiates from other interfaces.
	IsTupleLiteralContext()
}

ITupleLiteralContext is an interface to support dynamic dispatch.

type ITupleLiteralsContext 

type ITupleLiteralsContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsTupleLiteralsContext differentiates from other interfaces.
	IsTupleLiteralsContext()
}

ITupleLiteralsContext is an interface to support dynamic dispatch.

type ITupleTypeContext 

type ITupleTypeContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsTupleTypeContext differentiates from other interfaces.
	IsTupleTypeContext()
}

ITupleTypeContext is an interface to support dynamic dispatch.

type ITypeCastContext 

type ITypeCastContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsTypeCastContext differentiates from other interfaces.
	IsTypeCastContext()
}

ITypeCastContext is an interface to support dynamic dispatch.

type IUdtLiteralContext 

type IUdtLiteralContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsUdtLiteralContext differentiates from other interfaces.
	IsUdtLiteralContext()
}

IUdtLiteralContext is an interface to support dynamic dispatch.

type IUnaliasedSelectorContext 

type IUnaliasedSelectorContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsUnaliasedSelectorContext differentiates from other interfaces.
	IsUnaliasedSelectorContext()
}

IUnaliasedSelectorContext is an interface to support dynamic dispatch.

type IUnrecognizedStatementContext 

type IUnrecognizedStatementContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsUnrecognizedStatementContext differentiates from other interfaces.
	IsUnrecognizedStatementContext()
}

IUnrecognizedStatementContext is an interface to support dynamic dispatch.

type IUnrecognizedTokenContext 

type IUnrecognizedTokenContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsUnrecognizedTokenContext differentiates from other interfaces.
	IsUnrecognizedTokenContext()
}

IUnrecognizedTokenContext is an interface to support dynamic dispatch.

type IUnreservedKeywordContext 

type IUnreservedKeywordContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsUnreservedKeywordContext differentiates from other interfaces.
	IsUnreservedKeywordContext()
}

IUnreservedKeywordContext is an interface to support dynamic dispatch.

type IUpdateOperationContext 

type IUpdateOperationContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsUpdateOperationContext differentiates from other interfaces.
	IsUpdateOperationContext()
}

IUpdateOperationContext is an interface to support dynamic dispatch.

type IUpdateOperationsContext 

type IUpdateOperationsContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsUpdateOperationsContext differentiates from other interfaces.
	IsUpdateOperationsContext()
}

IUpdateOperationsContext is an interface to support dynamic dispatch.

type IUpdateStatementContext 

type IUpdateStatementContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsUpdateStatementContext differentiates from other interfaces.
	IsUpdateStatementContext()
}

IUpdateStatementContext is an interface to support dynamic dispatch.

type IUseStatementContext 

type IUseStatementContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsUseStatementContext differentiates from other interfaces.
	IsUseStatementContext()
}

IUseStatementContext is an interface to support dynamic dispatch.

type IUserTypeNameContext 

type IUserTypeNameContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsUserTypeNameContext differentiates from other interfaces.
	IsUserTypeNameContext()
}

IUserTypeNameContext is an interface to support dynamic dispatch.

type IUsingClauseContext 

type IUsingClauseContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsUsingClauseContext differentiates from other interfaces.
	IsUsingClauseContext()
}

IUsingClauseContext is an interface to support dynamic dispatch.

type IWhereClauseContext 

type IWhereClauseContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsWhereClauseContext differentiates from other interfaces.
	IsWhereClauseContext()
}

IWhereClauseContext is an interface to support dynamic dispatch.

type IdentifierContext 

type IdentifierContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyIdentifierContext 

func NewEmptyIdentifierContext() *IdentifierContext

func NewIdentifierContext 

func NewIdentifierContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *IdentifierContext

func (*IdentifierContext) EnterRule 

func (s *IdentifierContext) EnterRule(listener antlr.ParseTreeListener)

func (*IdentifierContext) ExitRule 

func (s *IdentifierContext) ExitRule(listener antlr.ParseTreeListener)

func (*IdentifierContext) GetParser 

func (s *IdentifierContext) GetParser() antlr.Parser

func (*IdentifierContext) GetRuleContext 

func (s *IdentifierContext) GetRuleContext() antlr.RuleContext

func (*IdentifierContext) IsIdentifierContext 

func (*IdentifierContext) IsIdentifierContext()

func (*IdentifierContext) QUOTED_IDENTIFIER 

func (s *IdentifierContext) QUOTED_IDENTIFIER() antlr.TerminalNode

func (*IdentifierContext) ToStringTree 

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

func (*IdentifierContext) UNQUOTED_IDENTIFIER 

func (s *IdentifierContext) UNQUOTED_IDENTIFIER() antlr.TerminalNode

func (*IdentifierContext) UnreservedKeyword 

func (s *IdentifierContext) UnreservedKeyword() IUnreservedKeywordContext

type IdentifiersContext 

type IdentifiersContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyIdentifiersContext 

func NewEmptyIdentifiersContext() *IdentifiersContext

func NewIdentifiersContext 

func NewIdentifiersContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *IdentifiersContext

func (*IdentifiersContext) AllIdentifier 

func (s *IdentifiersContext) AllIdentifier() []IIdentifierContext

func (*IdentifiersContext) EnterRule 

func (s *IdentifiersContext) EnterRule(listener antlr.ParseTreeListener)

func (*IdentifiersContext) ExitRule 

func (s *IdentifiersContext) ExitRule(listener antlr.ParseTreeListener)

func (*IdentifiersContext) GetParser 

func (s *IdentifiersContext) GetParser() antlr.Parser

func (*IdentifiersContext) GetRuleContext 

func (s *IdentifiersContext) GetRuleContext() antlr.RuleContext

func (*IdentifiersContext) Identifier 

func (s *IdentifiersContext) Identifier(i int) IIdentifierContext

func (*IdentifiersContext) IsIdentifiersContext 

func (*IdentifiersContext) IsIdentifiersContext()

func (*IdentifiersContext) ToStringTree 

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

type InsertStatementContext 

type InsertStatementContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyInsertStatementContext 

func NewEmptyInsertStatementContext() *InsertStatementContext

func NewInsertStatementContext 

func NewInsertStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *InsertStatementContext

func (*InsertStatementContext) EnterRule 

func (s *InsertStatementContext) EnterRule(listener antlr.ParseTreeListener)

func (*InsertStatementContext) ExitRule 

func (s *InsertStatementContext) ExitRule(listener antlr.ParseTreeListener)

func (*InsertStatementContext) GetParser 

func (s *InsertStatementContext) GetParser() antlr.Parser

func (*InsertStatementContext) GetRuleContext 

func (s *InsertStatementContext) GetRuleContext() antlr.RuleContext

func (*InsertStatementContext) Identifiers 

func (s *InsertStatementContext) Identifiers() IIdentifiersContext

func (*InsertStatementContext) IsInsertStatementContext 

func (*InsertStatementContext) IsInsertStatementContext()

func (*InsertStatementContext) K_EXISTS 

func (s *InsertStatementContext) K_EXISTS() antlr.TerminalNode

func (*InsertStatementContext) K_IF 

func (s *InsertStatementContext) K_IF() antlr.TerminalNode

func (*InsertStatementContext) K_INSERT 

func (s *InsertStatementContext) K_INSERT() antlr.TerminalNode

func (*InsertStatementContext) K_INTO 

func (s *InsertStatementContext) K_INTO() antlr.TerminalNode

func (*InsertStatementContext) K_NOT 

func (s *InsertStatementContext) K_NOT() antlr.TerminalNode

func (*InsertStatementContext) K_VALUES 

func (s *InsertStatementContext) K_VALUES() antlr.TerminalNode

func (*InsertStatementContext) TableName 

func (s *InsertStatementContext) TableName() ITableNameContext

func (*InsertStatementContext) Terms 

func (s *InsertStatementContext) Terms() ITermsContext

func (*InsertStatementContext) ToStringTree 

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

func (*InsertStatementContext) UsingClause 

func (s *InsertStatementContext) UsingClause() IUsingClauseContext

type KeyspaceNameContext 

type KeyspaceNameContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyKeyspaceNameContext 

func NewEmptyKeyspaceNameContext() *KeyspaceNameContext

func NewKeyspaceNameContext 

func NewKeyspaceNameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KeyspaceNameContext

func (*KeyspaceNameContext) EnterRule 

func (s *KeyspaceNameContext) EnterRule(listener antlr.ParseTreeListener)

func (*KeyspaceNameContext) ExitRule 

func (s *KeyspaceNameContext) ExitRule(listener antlr.ParseTreeListener)

func (*KeyspaceNameContext) GetParser 

func (s *KeyspaceNameContext) GetParser() antlr.Parser

func (*KeyspaceNameContext) GetRuleContext 

func (s *KeyspaceNameContext) GetRuleContext() antlr.RuleContext

func (*KeyspaceNameContext) Identifier 

func (s *KeyspaceNameContext) Identifier() IIdentifierContext

func (*KeyspaceNameContext) IsKeyspaceNameContext 

func (*KeyspaceNameContext) IsKeyspaceNameContext()

func (*KeyspaceNameContext) ToStringTree 

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

type LimitClauseContext 

type LimitClauseContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyLimitClauseContext 

func NewEmptyLimitClauseContext() *LimitClauseContext

func NewLimitClauseContext 

func NewLimitClauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *LimitClauseContext

func (*LimitClauseContext) BindMarker 

func (s *LimitClauseContext) BindMarker() IBindMarkerContext

func (*LimitClauseContext) EnterRule 

func (s *LimitClauseContext) EnterRule(listener antlr.ParseTreeListener)

func (*LimitClauseContext) ExitRule 

func (s *LimitClauseContext) ExitRule(listener antlr.ParseTreeListener)

func (*LimitClauseContext) GetParser 

func (s *LimitClauseContext) GetParser() antlr.Parser

func (*LimitClauseContext) GetRuleContext 

func (s *LimitClauseContext) GetRuleContext() antlr.RuleContext

func (*LimitClauseContext) INTEGER 

func (s *LimitClauseContext) INTEGER() antlr.TerminalNode

func (*LimitClauseContext) IsLimitClauseContext 

func (*LimitClauseContext) IsLimitClauseContext()

func (*LimitClauseContext) K_LIMIT 

func (s *LimitClauseContext) K_LIMIT() antlr.TerminalNode

func (*LimitClauseContext) ToStringTree 

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

type ListLiteralContext 

type ListLiteralContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyListLiteralContext 

func NewEmptyListLiteralContext() *ListLiteralContext

func NewListLiteralContext 

func NewListLiteralContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ListLiteralContext

func (*ListLiteralContext) EnterRule 

func (s *ListLiteralContext) EnterRule(listener antlr.ParseTreeListener)

func (*ListLiteralContext) ExitRule 

func (s *ListLiteralContext) ExitRule(listener antlr.ParseTreeListener)

func (*ListLiteralContext) GetParser 

func (s *ListLiteralContext) GetParser() antlr.Parser

func (*ListLiteralContext) GetRuleContext 

func (s *ListLiteralContext) GetRuleContext() antlr.RuleContext

func (*ListLiteralContext) IsListLiteralContext 

func (*ListLiteralContext) IsListLiteralContext()

func (*ListLiteralContext) Terms 

func (s *ListLiteralContext) Terms() ITermsContext

func (*ListLiteralContext) ToStringTree 

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

type LiteralContext 

type LiteralContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyLiteralContext 

func NewEmptyLiteralContext() *LiteralContext

func NewLiteralContext 

func NewLiteralContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *LiteralContext

func (*LiteralContext) CollectionLiteral 

func (s *LiteralContext) CollectionLiteral() ICollectionLiteralContext

func (*LiteralContext) EnterRule 

func (s *LiteralContext) EnterRule(listener antlr.ParseTreeListener)

func (*LiteralContext) ExitRule 

func (s *LiteralContext) ExitRule(listener antlr.ParseTreeListener)

func (*LiteralContext) GetParser 

func (s *LiteralContext) GetParser() antlr.Parser

func (*LiteralContext) GetRuleContext 

func (s *LiteralContext) GetRuleContext() antlr.RuleContext

func (*LiteralContext) IsLiteralContext 

func (*LiteralContext) IsLiteralContext()

func (*LiteralContext) K_NULL 

func (s *LiteralContext) K_NULL() antlr.TerminalNode

func (*LiteralContext) PrimitiveLiteral 

func (s *LiteralContext) PrimitiveLiteral() IPrimitiveLiteralContext

func (*LiteralContext) ToStringTree 

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

func (*LiteralContext) TupleLiteral 

func (s *LiteralContext) TupleLiteral() ITupleLiteralContext

func (*LiteralContext) UdtLiteral 

func (s *LiteralContext) UdtLiteral() IUdtLiteralContext

type MapEntriesContext 

type MapEntriesContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyMapEntriesContext 

func NewEmptyMapEntriesContext() *MapEntriesContext

func NewMapEntriesContext 

func NewMapEntriesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *MapEntriesContext

func (*MapEntriesContext) AllMapEntry 

func (s *MapEntriesContext) AllMapEntry() []IMapEntryContext

func (*MapEntriesContext) EnterRule 

func (s *MapEntriesContext) EnterRule(listener antlr.ParseTreeListener)

func (*MapEntriesContext) ExitRule 

func (s *MapEntriesContext) ExitRule(listener antlr.ParseTreeListener)

func (*MapEntriesContext) GetParser 

func (s *MapEntriesContext) GetParser() antlr.Parser

func (*MapEntriesContext) GetRuleContext 

func (s *MapEntriesContext) GetRuleContext() antlr.RuleContext

func (*MapEntriesContext) IsMapEntriesContext 

func (*MapEntriesContext) IsMapEntriesContext()

func (*MapEntriesContext) MapEntry 

func (s *MapEntriesContext) MapEntry(i int) IMapEntryContext

func (*MapEntriesContext) ToStringTree 

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

type MapEntryContext 

type MapEntryContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyMapEntryContext 

func NewEmptyMapEntryContext() *MapEntryContext

func NewMapEntryContext 

func NewMapEntryContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *MapEntryContext

func (*MapEntryContext) AllTerm 

func (s *MapEntryContext) AllTerm() []ITermContext

func (*MapEntryContext) EnterRule 

func (s *MapEntryContext) EnterRule(listener antlr.ParseTreeListener)

func (*MapEntryContext) ExitRule 

func (s *MapEntryContext) ExitRule(listener antlr.ParseTreeListener)

func (*MapEntryContext) GetParser 

func (s *MapEntryContext) GetParser() antlr.Parser

func (*MapEntryContext) GetRuleContext 

func (s *MapEntryContext) GetRuleContext() antlr.RuleContext

func (*MapEntryContext) IsMapEntryContext 

func (*MapEntryContext) IsMapEntryContext()

func (*MapEntryContext) Term 

func (s *MapEntryContext) Term(i int) ITermContext

func (*MapEntryContext) ToStringTree 

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

type MapLiteralContext 

type MapLiteralContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyMapLiteralContext 

func NewEmptyMapLiteralContext() *MapLiteralContext

func NewMapLiteralContext 

func NewMapLiteralContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *MapLiteralContext

func (*MapLiteralContext) EnterRule 

func (s *MapLiteralContext) EnterRule(listener antlr.ParseTreeListener)

func (*MapLiteralContext) ExitRule 

func (s *MapLiteralContext) ExitRule(listener antlr.ParseTreeListener)

func (*MapLiteralContext) GetParser 

func (s *MapLiteralContext) GetParser() antlr.Parser

func (*MapLiteralContext) GetRuleContext 

func (s *MapLiteralContext) GetRuleContext() antlr.RuleContext

func (*MapLiteralContext) IsMapLiteralContext 

func (*MapLiteralContext) IsMapLiteralContext()

func (*MapLiteralContext) MapEntries 

func (s *MapLiteralContext) MapEntries() IMapEntriesContext

func (*MapLiteralContext) ToStringTree 

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

type NamedBindMarkerContext 

type NamedBindMarkerContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyNamedBindMarkerContext 

func NewEmptyNamedBindMarkerContext() *NamedBindMarkerContext

func NewNamedBindMarkerContext 

func NewNamedBindMarkerContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *NamedBindMarkerContext

func (*NamedBindMarkerContext) EnterRule 

func (s *NamedBindMarkerContext) EnterRule(listener antlr.ParseTreeListener)

func (*NamedBindMarkerContext) ExitRule 

func (s *NamedBindMarkerContext) ExitRule(listener antlr.ParseTreeListener)

func (*NamedBindMarkerContext) GetParser 

func (s *NamedBindMarkerContext) GetParser() antlr.Parser

func (*NamedBindMarkerContext) GetRuleContext 

func (s *NamedBindMarkerContext) GetRuleContext() antlr.RuleContext

func (*NamedBindMarkerContext) Identifier 

func (s *NamedBindMarkerContext) Identifier() IIdentifierContext

func (*NamedBindMarkerContext) IsNamedBindMarkerContext 

func (*NamedBindMarkerContext) IsNamedBindMarkerContext()

func (*NamedBindMarkerContext) ToStringTree 

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

type OperatorContext 

type OperatorContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyOperatorContext 

func NewEmptyOperatorContext() *OperatorContext

func NewOperatorContext 

func NewOperatorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *OperatorContext

func (*OperatorContext) EnterRule 

func (s *OperatorContext) EnterRule(listener antlr.ParseTreeListener)

func (*OperatorContext) ExitRule 

func (s *OperatorContext) ExitRule(listener antlr.ParseTreeListener)

func (*OperatorContext) GetParser 

func (s *OperatorContext) GetParser() antlr.Parser

func (*OperatorContext) GetRuleContext 

func (s *OperatorContext) GetRuleContext() antlr.RuleContext

func (*OperatorContext) IsOperatorContext 

func (*OperatorContext) IsOperatorContext()

func (*OperatorContext) ToStringTree 

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

type OrderByClauseContext 

type OrderByClauseContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyOrderByClauseContext 

func NewEmptyOrderByClauseContext() *OrderByClauseContext

func NewOrderByClauseContext 

func NewOrderByClauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *OrderByClauseContext

func (*OrderByClauseContext) EnterRule 

func (s *OrderByClauseContext) EnterRule(listener antlr.ParseTreeListener)

func (*OrderByClauseContext) ExitRule 

func (s *OrderByClauseContext) ExitRule(listener antlr.ParseTreeListener)

func (*OrderByClauseContext) GetParser 

func (s *OrderByClauseContext) GetParser() antlr.Parser

func (*OrderByClauseContext) GetRuleContext 

func (s *OrderByClauseContext) GetRuleContext() antlr.RuleContext

func (*OrderByClauseContext) IsOrderByClauseContext 

func (*OrderByClauseContext) IsOrderByClauseContext()

func (*OrderByClauseContext) K_BY 

func (s *OrderByClauseContext) K_BY() antlr.TerminalNode

func (*OrderByClauseContext) K_ORDER 

func (s *OrderByClauseContext) K_ORDER() antlr.TerminalNode

func (*OrderByClauseContext) Orderings 

func (s *OrderByClauseContext) Orderings() IOrderingsContext

func (*OrderByClauseContext) ToStringTree 

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

type OrderingContext 

type OrderingContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyOrderingContext 

func NewEmptyOrderingContext() *OrderingContext

func NewOrderingContext 

func NewOrderingContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *OrderingContext

func (*OrderingContext) EnterRule 

func (s *OrderingContext) EnterRule(listener antlr.ParseTreeListener)

func (*OrderingContext) ExitRule 

func (s *OrderingContext) ExitRule(listener antlr.ParseTreeListener)

func (*OrderingContext) GetParser 

func (s *OrderingContext) GetParser() antlr.Parser

func (*OrderingContext) GetRuleContext 

func (s *OrderingContext) GetRuleContext() antlr.RuleContext

func (*OrderingContext) Identifier 

func (s *OrderingContext) Identifier() IIdentifierContext

func (*OrderingContext) IsOrderingContext 

func (*OrderingContext) IsOrderingContext()

func (*OrderingContext) K_ASC 

func (s *OrderingContext) K_ASC() antlr.TerminalNode

func (*OrderingContext) K_DESC 

func (s *OrderingContext) K_DESC() antlr.TerminalNode

func (*OrderingContext) ToStringTree 

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

type OrderingsContext 

type OrderingsContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyOrderingsContext 

func NewEmptyOrderingsContext() *OrderingsContext

func NewOrderingsContext 

func NewOrderingsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *OrderingsContext

func (*OrderingsContext) AllOrdering 

func (s *OrderingsContext) AllOrdering() []IOrderingContext

func (*OrderingsContext) EnterRule 

func (s *OrderingsContext) EnterRule(listener antlr.ParseTreeListener)

func (*OrderingsContext) ExitRule 

func (s *OrderingsContext) ExitRule(listener antlr.ParseTreeListener)

func (*OrderingsContext) GetParser 

func (s *OrderingsContext) GetParser() antlr.Parser

func (*OrderingsContext) GetRuleContext 

func (s *OrderingsContext) GetRuleContext() antlr.RuleContext

func (*OrderingsContext) IsOrderingsContext 

func (*OrderingsContext) IsOrderingsContext()

func (*OrderingsContext) Ordering 

func (s *OrderingsContext) Ordering(i int) IOrderingContext

func (*OrderingsContext) ToStringTree 

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

type PerPartitionLimitClauseContext 

type PerPartitionLimitClauseContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyPerPartitionLimitClauseContext 

func NewEmptyPerPartitionLimitClauseContext() *PerPartitionLimitClauseContext

func NewPerPartitionLimitClauseContext 

func NewPerPartitionLimitClauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PerPartitionLimitClauseContext

func (*PerPartitionLimitClauseContext) BindMarker 

func (s *PerPartitionLimitClauseContext) BindMarker() IBindMarkerContext

func (*PerPartitionLimitClauseContext) EnterRule 

func (s *PerPartitionLimitClauseContext) EnterRule(listener antlr.ParseTreeListener)

func (*PerPartitionLimitClauseContext) ExitRule 

func (s *PerPartitionLimitClauseContext) ExitRule(listener antlr.ParseTreeListener)

func (*PerPartitionLimitClauseContext) GetParser 

func (s *PerPartitionLimitClauseContext) GetParser() antlr.Parser

func (*PerPartitionLimitClauseContext) GetRuleContext 

func (s *PerPartitionLimitClauseContext) GetRuleContext() antlr.RuleContext

func (*PerPartitionLimitClauseContext) INTEGER 

func (s *PerPartitionLimitClauseContext) INTEGER() antlr.TerminalNode

func (*PerPartitionLimitClauseContext) IsPerPartitionLimitClauseContext 

func (*PerPartitionLimitClauseContext) IsPerPartitionLimitClauseContext()

func (*PerPartitionLimitClauseContext) K_LIMIT 

func (s *PerPartitionLimitClauseContext) K_LIMIT() antlr.TerminalNode

func (*PerPartitionLimitClauseContext) K_PARTITION 

func (s *PerPartitionLimitClauseContext) K_PARTITION() antlr.TerminalNode

func (*PerPartitionLimitClauseContext) K_PER 

func (s *PerPartitionLimitClauseContext) K_PER() antlr.TerminalNode

func (*PerPartitionLimitClauseContext) ToStringTree 

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

type PositionalBindMarkerContext 

type PositionalBindMarkerContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyPositionalBindMarkerContext 

func NewEmptyPositionalBindMarkerContext() *PositionalBindMarkerContext

func NewPositionalBindMarkerContext 

func NewPositionalBindMarkerContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PositionalBindMarkerContext

func (*PositionalBindMarkerContext) EnterRule 

func (s *PositionalBindMarkerContext) EnterRule(listener antlr.ParseTreeListener)

func (*PositionalBindMarkerContext) ExitRule 

func (s *PositionalBindMarkerContext) ExitRule(listener antlr.ParseTreeListener)

func (*PositionalBindMarkerContext) GetParser 

func (s *PositionalBindMarkerContext) GetParser() antlr.Parser

func (*PositionalBindMarkerContext) GetRuleContext 

func (s *PositionalBindMarkerContext) GetRuleContext() antlr.RuleContext

func (*PositionalBindMarkerContext) IsPositionalBindMarkerContext 

func (*PositionalBindMarkerContext) IsPositionalBindMarkerContext()

func (*PositionalBindMarkerContext) QMARK 

func (s *PositionalBindMarkerContext) QMARK() antlr.TerminalNode

func (*PositionalBindMarkerContext) ToStringTree 

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

type PrimitiveLiteralContext 

type PrimitiveLiteralContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyPrimitiveLiteralContext 

func NewEmptyPrimitiveLiteralContext() *PrimitiveLiteralContext

func NewPrimitiveLiteralContext 

func NewPrimitiveLiteralContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PrimitiveLiteralContext

func (*PrimitiveLiteralContext) BOOLEAN 

func (s *PrimitiveLiteralContext) BOOLEAN() antlr.TerminalNode

func (*PrimitiveLiteralContext) DURATION 

func (s *PrimitiveLiteralContext) DURATION() antlr.TerminalNode

func (*PrimitiveLiteralContext) EnterRule 

func (s *PrimitiveLiteralContext) EnterRule(listener antlr.ParseTreeListener)

func (*PrimitiveLiteralContext) ExitRule 

func (s *PrimitiveLiteralContext) ExitRule(listener antlr.ParseTreeListener)

func (*PrimitiveLiteralContext) FLOAT 

func (s *PrimitiveLiteralContext) FLOAT() antlr.TerminalNode

func (*PrimitiveLiteralContext) GetParser 

func (s *PrimitiveLiteralContext) GetParser() antlr.Parser

func (*PrimitiveLiteralContext) GetRuleContext 

func (s *PrimitiveLiteralContext) GetRuleContext() antlr.RuleContext

func (*PrimitiveLiteralContext) HEXNUMBER 

func (s *PrimitiveLiteralContext) HEXNUMBER() antlr.TerminalNode

func (*PrimitiveLiteralContext) INTEGER 

func (s *PrimitiveLiteralContext) INTEGER() antlr.TerminalNode

func (*PrimitiveLiteralContext) IsPrimitiveLiteralContext 

func (*PrimitiveLiteralContext) IsPrimitiveLiteralContext()

func (*PrimitiveLiteralContext) K_INFINITY 

func (s *PrimitiveLiteralContext) K_INFINITY() antlr.TerminalNode

func (*PrimitiveLiteralContext) K_NAN 

func (s *PrimitiveLiteralContext) K_NAN() antlr.TerminalNode

func (*PrimitiveLiteralContext) STRING_LITERAL 

func (s *PrimitiveLiteralContext) STRING_LITERAL() antlr.TerminalNode

func (*PrimitiveLiteralContext) ToStringTree 

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

func (*PrimitiveLiteralContext) UUID 

func (s *PrimitiveLiteralContext) UUID() antlr.TerminalNode

type PrimitiveTypeContext 

type PrimitiveTypeContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyPrimitiveTypeContext 

func NewEmptyPrimitiveTypeContext() *PrimitiveTypeContext

func NewPrimitiveTypeContext 

func NewPrimitiveTypeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PrimitiveTypeContext

func (*PrimitiveTypeContext) EnterRule 

func (s *PrimitiveTypeContext) EnterRule(listener antlr.ParseTreeListener)

func (*PrimitiveTypeContext) ExitRule 

func (s *PrimitiveTypeContext) ExitRule(listener antlr.ParseTreeListener)

func (*PrimitiveTypeContext) GetParser 

func (s *PrimitiveTypeContext) GetParser() antlr.Parser

func (*PrimitiveTypeContext) GetRuleContext 

func (s *PrimitiveTypeContext) GetRuleContext() antlr.RuleContext

func (*PrimitiveTypeContext) IsPrimitiveTypeContext 

func (*PrimitiveTypeContext) IsPrimitiveTypeContext()

func (*PrimitiveTypeContext) K_ASCII 

func (s *PrimitiveTypeContext) K_ASCII() antlr.TerminalNode

func (*PrimitiveTypeContext) K_BIGINT 

func (s *PrimitiveTypeContext) K_BIGINT() antlr.TerminalNode

func (*PrimitiveTypeContext) K_BLOB 

func (s *PrimitiveTypeContext) K_BLOB() antlr.TerminalNode

func (*PrimitiveTypeContext) K_BOOLEAN 

func (s *PrimitiveTypeContext) K_BOOLEAN() antlr.TerminalNode

func (*PrimitiveTypeContext) K_COUNTER 

func (s *PrimitiveTypeContext) K_COUNTER() antlr.TerminalNode

func (*PrimitiveTypeContext) K_DATE 

func (s *PrimitiveTypeContext) K_DATE() antlr.TerminalNode

func (*PrimitiveTypeContext) K_DECIMAL 

func (s *PrimitiveTypeContext) K_DECIMAL() antlr.TerminalNode

func (*PrimitiveTypeContext) K_DOUBLE 

func (s *PrimitiveTypeContext) K_DOUBLE() antlr.TerminalNode

func (*PrimitiveTypeContext) K_DURATION 

func (s *PrimitiveTypeContext) K_DURATION() antlr.TerminalNode

func (*PrimitiveTypeContext) K_FLOAT 

func (s *PrimitiveTypeContext) K_FLOAT() antlr.TerminalNode

func (*PrimitiveTypeContext) K_INET 

func (s *PrimitiveTypeContext) K_INET() antlr.TerminalNode

func (*PrimitiveTypeContext) K_INT 

func (s *PrimitiveTypeContext) K_INT() antlr.TerminalNode

func (*PrimitiveTypeContext) K_SMALLINT 

func (s *PrimitiveTypeContext) K_SMALLINT() antlr.TerminalNode

func (*PrimitiveTypeContext) K_TEXT 

func (s *PrimitiveTypeContext) K_TEXT() antlr.TerminalNode

func (*PrimitiveTypeContext) K_TIME 

func (s *PrimitiveTypeContext) K_TIME() antlr.TerminalNode

func (*PrimitiveTypeContext) K_TIMESTAMP 

func (s *PrimitiveTypeContext) K_TIMESTAMP() antlr.TerminalNode

func (*PrimitiveTypeContext) K_TIMEUUID 

func (s *PrimitiveTypeContext) K_TIMEUUID() antlr.TerminalNode

func (*PrimitiveTypeContext) K_TINYINT 

func (s *PrimitiveTypeContext) K_TINYINT() antlr.TerminalNode

func (*PrimitiveTypeContext) K_UUID 

func (s *PrimitiveTypeContext) K_UUID() antlr.TerminalNode

func (*PrimitiveTypeContext) K_VARCHAR 

func (s *PrimitiveTypeContext) K_VARCHAR() antlr.TerminalNode

func (*PrimitiveTypeContext) K_VARINT 

func (s *PrimitiveTypeContext) K_VARINT() antlr.TerminalNode

func (*PrimitiveTypeContext) ToStringTree 

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

type QualifiedIdentifierContext 

type QualifiedIdentifierContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyQualifiedIdentifierContext 

func NewEmptyQualifiedIdentifierContext() *QualifiedIdentifierContext

func NewQualifiedIdentifierContext 

func NewQualifiedIdentifierContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *QualifiedIdentifierContext

func (*QualifiedIdentifierContext) EnterRule 

func (s *QualifiedIdentifierContext) EnterRule(listener antlr.ParseTreeListener)

func (*QualifiedIdentifierContext) ExitRule 

func (s *QualifiedIdentifierContext) ExitRule(listener antlr.ParseTreeListener)

func (*QualifiedIdentifierContext) GetParser 

func (s *QualifiedIdentifierContext) GetParser() antlr.Parser

func (*QualifiedIdentifierContext) GetRuleContext 

func (s *QualifiedIdentifierContext) GetRuleContext() antlr.RuleContext

func (*QualifiedIdentifierContext) Identifier 

func (s *QualifiedIdentifierContext) Identifier() IIdentifierContext

func (*QualifiedIdentifierContext) IsQualifiedIdentifierContext 

func (*QualifiedIdentifierContext) IsQualifiedIdentifierContext()

func (*QualifiedIdentifierContext) KeyspaceName 

func (s *QualifiedIdentifierContext) KeyspaceName() IKeyspaceNameContext

func (*QualifiedIdentifierContext) ToStringTree 

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

type RelationContext 

type RelationContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyRelationContext 

func NewEmptyRelationContext() *RelationContext

func NewRelationContext 

func NewRelationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *RelationContext

func (*RelationContext) AllTerm 

func (s *RelationContext) AllTerm() []ITermContext

func (*RelationContext) BindMarker 

func (s *RelationContext) BindMarker() IBindMarkerContext

func (*RelationContext) BindMarkers 

func (s *RelationContext) BindMarkers() IBindMarkersContext

func (*RelationContext) EnterRule 

func (s *RelationContext) EnterRule(listener antlr.ParseTreeListener)

func (*RelationContext) ExitRule 

func (s *RelationContext) ExitRule(listener antlr.ParseTreeListener)

func (*RelationContext) GetParser 

func (s *RelationContext) GetParser() antlr.Parser

func (*RelationContext) GetRuleContext 

func (s *RelationContext) GetRuleContext() antlr.RuleContext

func (*RelationContext) Identifier 

func (s *RelationContext) Identifier() IIdentifierContext

func (*RelationContext) Identifiers 

func (s *RelationContext) Identifiers() IIdentifiersContext

func (*RelationContext) IsRelationContext 

func (*RelationContext) IsRelationContext()

func (*RelationContext) K_CONTAINS 

func (s *RelationContext) K_CONTAINS() antlr.TerminalNode

func (*RelationContext) K_IN 

func (s *RelationContext) K_IN() antlr.TerminalNode

func (*RelationContext) K_IS 

func (s *RelationContext) K_IS() antlr.TerminalNode

func (*RelationContext) K_KEY 

func (s *RelationContext) K_KEY() antlr.TerminalNode

func (*RelationContext) K_LIKE 

func (s *RelationContext) K_LIKE() antlr.TerminalNode

func (*RelationContext) K_NOT 

func (s *RelationContext) K_NOT() antlr.TerminalNode

func (*RelationContext) K_NULL 

func (s *RelationContext) K_NULL() antlr.TerminalNode

func (*RelationContext) K_TOKEN 

func (s *RelationContext) K_TOKEN() antlr.TerminalNode

func (*RelationContext) Operator 

func (s *RelationContext) Operator() IOperatorContext

func (*RelationContext) Relation 

func (s *RelationContext) Relation() IRelationContext

func (*RelationContext) Term 

func (s *RelationContext) Term(i int) ITermContext

func (*RelationContext) Terms 

func (s *RelationContext) Terms() ITermsContext

func (*RelationContext) ToStringTree 

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

func (*RelationContext) TupleLiteral 

func (s *RelationContext) TupleLiteral() ITupleLiteralContext

func (*RelationContext) TupleLiterals 

func (s *RelationContext) TupleLiterals() ITupleLiteralsContext

type SelectClauseContext 

type SelectClauseContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptySelectClauseContext 

func NewEmptySelectClauseContext() *SelectClauseContext

func NewSelectClauseContext 

func NewSelectClauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SelectClauseContext

func (*SelectClauseContext) EnterRule 

func (s *SelectClauseContext) EnterRule(listener antlr.ParseTreeListener)

func (*SelectClauseContext) ExitRule 

func (s *SelectClauseContext) ExitRule(listener antlr.ParseTreeListener)

func (*SelectClauseContext) GetParser 

func (s *SelectClauseContext) GetParser() antlr.Parser

func (*SelectClauseContext) GetRuleContext 

func (s *SelectClauseContext) GetRuleContext() antlr.RuleContext

func (*SelectClauseContext) IsSelectClauseContext 

func (*SelectClauseContext) IsSelectClauseContext()

func (*SelectClauseContext) Selectors 

func (s *SelectClauseContext) Selectors() ISelectorsContext

func (*SelectClauseContext) ToStringTree 

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

type SelectStatementContext 

type SelectStatementContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptySelectStatementContext 

func NewEmptySelectStatementContext() *SelectStatementContext

func NewSelectStatementContext 

func NewSelectStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SelectStatementContext

func (*SelectStatementContext) EnterRule 

func (s *SelectStatementContext) EnterRule(listener antlr.ParseTreeListener)

func (*SelectStatementContext) ExitRule 

func (s *SelectStatementContext) ExitRule(listener antlr.ParseTreeListener)

func (*SelectStatementContext) GetParser 

func (s *SelectStatementContext) GetParser() antlr.Parser

func (*SelectStatementContext) GetRuleContext 

func (s *SelectStatementContext) GetRuleContext() antlr.RuleContext

func (*SelectStatementContext) GroupByClause 

func (s *SelectStatementContext) GroupByClause() IGroupByClauseContext

func (*SelectStatementContext) IsSelectStatementContext 

func (*SelectStatementContext) IsSelectStatementContext()

func (*SelectStatementContext) K_ALLOW 

func (s *SelectStatementContext) K_ALLOW() antlr.TerminalNode

func (*SelectStatementContext) K_DISTINCT 

func (s *SelectStatementContext) K_DISTINCT() antlr.TerminalNode

func (*SelectStatementContext) K_FILTERING 

func (s *SelectStatementContext) K_FILTERING() antlr.TerminalNode

func (*SelectStatementContext) K_FROM 

func (s *SelectStatementContext) K_FROM() antlr.TerminalNode

func (*SelectStatementContext) K_JSON 

func (s *SelectStatementContext) K_JSON() antlr.TerminalNode

func (*SelectStatementContext) K_SELECT 

func (s *SelectStatementContext) K_SELECT() antlr.TerminalNode

func (*SelectStatementContext) LimitClause 

func (s *SelectStatementContext) LimitClause() ILimitClauseContext

func (*SelectStatementContext) OrderByClause 

func (s *SelectStatementContext) OrderByClause() IOrderByClauseContext

func (*SelectStatementContext) PerPartitionLimitClause 

func (s *SelectStatementContext) PerPartitionLimitClause() IPerPartitionLimitClauseContext

func (*SelectStatementContext) SelectClause 

func (s *SelectStatementContext) SelectClause() ISelectClauseContext

func (*SelectStatementContext) TableName 

func (s *SelectStatementContext) TableName() ITableNameContext

func (*SelectStatementContext) ToStringTree 

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

func (*SelectStatementContext) WhereClause 

func (s *SelectStatementContext) WhereClause() IWhereClauseContext

type SelectorContext 

type SelectorContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptySelectorContext 

func NewEmptySelectorContext() *SelectorContext

func NewSelectorContext 

func NewSelectorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SelectorContext

func (*SelectorContext) EnterRule 

func (s *SelectorContext) EnterRule(listener antlr.ParseTreeListener)

func (*SelectorContext) ExitRule 

func (s *SelectorContext) ExitRule(listener antlr.ParseTreeListener)

func (*SelectorContext) GetParser 

func (s *SelectorContext) GetParser() antlr.Parser

func (*SelectorContext) GetRuleContext 

func (s *SelectorContext) GetRuleContext() antlr.RuleContext

func (*SelectorContext) Identifier 

func (s *SelectorContext) Identifier() IIdentifierContext

func (*SelectorContext) IsSelectorContext 

func (*SelectorContext) IsSelectorContext()

func (*SelectorContext) K_AS 

func (s *SelectorContext) K_AS() antlr.TerminalNode

func (*SelectorContext) ToStringTree 

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

func (*SelectorContext) UnaliasedSelector 

func (s *SelectorContext) UnaliasedSelector() IUnaliasedSelectorContext

type SelectorsContext 

type SelectorsContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptySelectorsContext 

func NewEmptySelectorsContext() *SelectorsContext

func NewSelectorsContext 

func NewSelectorsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SelectorsContext

func (*SelectorsContext) AllSelector 

func (s *SelectorsContext) AllSelector() []ISelectorContext

func (*SelectorsContext) EnterRule 

func (s *SelectorsContext) EnterRule(listener antlr.ParseTreeListener)

func (*SelectorsContext) ExitRule 

func (s *SelectorsContext) ExitRule(listener antlr.ParseTreeListener)

func (*SelectorsContext) GetParser 

func (s *SelectorsContext) GetParser() antlr.Parser

func (*SelectorsContext) GetRuleContext 

func (s *SelectorsContext) GetRuleContext() antlr.RuleContext

func (*SelectorsContext) IsSelectorsContext 

func (*SelectorsContext) IsSelectorsContext()

func (*SelectorsContext) Selector 

func (s *SelectorsContext) Selector(i int) ISelectorContext

func (*SelectorsContext) ToStringTree 

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

type SetLiteralContext 

type SetLiteralContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptySetLiteralContext 

func NewEmptySetLiteralContext() *SetLiteralContext

func NewSetLiteralContext 

func NewSetLiteralContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SetLiteralContext

func (*SetLiteralContext) EnterRule 

func (s *SetLiteralContext) EnterRule(listener antlr.ParseTreeListener)

func (*SetLiteralContext) ExitRule 

func (s *SetLiteralContext) ExitRule(listener antlr.ParseTreeListener)

func (*SetLiteralContext) GetParser 

func (s *SetLiteralContext) GetParser() antlr.Parser

func (*SetLiteralContext) GetRuleContext 

func (s *SetLiteralContext) GetRuleContext() antlr.RuleContext

func (*SetLiteralContext) IsSetLiteralContext 

func (*SetLiteralContext) IsSetLiteralContext()

func (*SetLiteralContext) Terms 

func (s *SetLiteralContext) Terms() ITermsContext

func (*SetLiteralContext) ToStringTree 

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

type SimplifiedCqlLexer 

type SimplifiedCqlLexer struct {
	*antlr.BaseLexer
	// contains filtered or unexported fields
}

func NewSimplifiedCqlLexer 

func NewSimplifiedCqlLexer(input antlr.CharStream) *SimplifiedCqlLexer

type SimplifiedCqlListener 

type SimplifiedCqlListener interface {
	antlr.ParseTreeListener

	// EnterCqlStatement is called when entering the cqlStatement production.
	EnterCqlStatement(c *CqlStatementContext)

	// EnterInsertStatement is called when entering the insertStatement production.
	EnterInsertStatement(c *InsertStatementContext)

	// EnterUpdateStatement is called when entering the updateStatement production.
	EnterUpdateStatement(c *UpdateStatementContext)

	// EnterUpdateOperations is called when entering the updateOperations production.
	EnterUpdateOperations(c *UpdateOperationsContext)

	// EnterUpdateOperation is called when entering the updateOperation production.
	EnterUpdateOperation(c *UpdateOperationContext)

	// EnterDeleteStatement is called when entering the deleteStatement production.
	EnterDeleteStatement(c *DeleteStatementContext)

	// EnterDeleteOperations is called when entering the deleteOperations production.
	EnterDeleteOperations(c *DeleteOperationsContext)

	// EnterDeleteOperation is called when entering the deleteOperation production.
	EnterDeleteOperation(c *DeleteOperationContext)

	// EnterBatchStatement is called when entering the batchStatement production.
	EnterBatchStatement(c *BatchStatementContext)

	// EnterBatchChildStatement is called when entering the batchChildStatement production.
	EnterBatchChildStatement(c *BatchChildStatementContext)

	// EnterSelectStatement is called when entering the selectStatement production.
	EnterSelectStatement(c *SelectStatementContext)

	// EnterSelectClause is called when entering the selectClause production.
	EnterSelectClause(c *SelectClauseContext)

	// EnterSelectors is called when entering the selectors production.
	EnterSelectors(c *SelectorsContext)

	// EnterSelector is called when entering the selector production.
	EnterSelector(c *SelectorContext)

	// EnterUnaliasedSelector is called when entering the unaliasedSelector production.
	EnterUnaliasedSelector(c *UnaliasedSelectorContext)

	// EnterUseStatement is called when entering the useStatement production.
	EnterUseStatement(c *UseStatementContext)

	// EnterOrderByClause is called when entering the orderByClause production.
	EnterOrderByClause(c *OrderByClauseContext)

	// EnterOrderings is called when entering the orderings production.
	EnterOrderings(c *OrderingsContext)

	// EnterOrdering is called when entering the ordering production.
	EnterOrdering(c *OrderingContext)

	// EnterGroupByClause is called when entering the groupByClause production.
	EnterGroupByClause(c *GroupByClauseContext)

	// EnterPerPartitionLimitClause is called when entering the perPartitionLimitClause production.
	EnterPerPartitionLimitClause(c *PerPartitionLimitClauseContext)

	// EnterLimitClause is called when entering the limitClause production.
	EnterLimitClause(c *LimitClauseContext)

	// EnterUsingClause is called when entering the usingClause production.
	EnterUsingClause(c *UsingClauseContext)

	// EnterTimestamp is called when entering the timestamp production.
	EnterTimestamp(c *TimestampContext)

	// EnterTtl is called when entering the ttl production.
	EnterTtl(c *TtlContext)

	// EnterConditions is called when entering the conditions production.
	EnterConditions(c *ConditionsContext)

	// EnterCondition is called when entering the condition production.
	EnterCondition(c *ConditionContext)

	// EnterWhereClause is called when entering the whereClause production.
	EnterWhereClause(c *WhereClauseContext)

	// EnterRelation is called when entering the relation production.
	EnterRelation(c *RelationContext)

	// EnterOperator is called when entering the operator production.
	EnterOperator(c *OperatorContext)

	// EnterLiteral is called when entering the literal production.
	EnterLiteral(c *LiteralContext)

	// EnterPrimitiveLiteral is called when entering the primitiveLiteral production.
	EnterPrimitiveLiteral(c *PrimitiveLiteralContext)

	// EnterCollectionLiteral is called when entering the collectionLiteral production.
	EnterCollectionLiteral(c *CollectionLiteralContext)

	// EnterListLiteral is called when entering the listLiteral production.
	EnterListLiteral(c *ListLiteralContext)

	// EnterSetLiteral is called when entering the setLiteral production.
	EnterSetLiteral(c *SetLiteralContext)

	// EnterMapLiteral is called when entering the mapLiteral production.
	EnterMapLiteral(c *MapLiteralContext)

	// EnterMapEntries is called when entering the mapEntries production.
	EnterMapEntries(c *MapEntriesContext)

	// EnterMapEntry is called when entering the mapEntry production.
	EnterMapEntry(c *MapEntryContext)

	// EnterTupleLiterals is called when entering the tupleLiterals production.
	EnterTupleLiterals(c *TupleLiteralsContext)

	// EnterTupleLiteral is called when entering the tupleLiteral production.
	EnterTupleLiteral(c *TupleLiteralContext)

	// EnterUdtLiteral is called when entering the udtLiteral production.
	EnterUdtLiteral(c *UdtLiteralContext)

	// EnterFieldLiterals is called when entering the fieldLiterals production.
	EnterFieldLiterals(c *FieldLiteralsContext)

	// EnterFieldLiteral is called when entering the fieldLiteral production.
	EnterFieldLiteral(c *FieldLiteralContext)

	// EnterFunctionCall is called when entering the functionCall production.
	EnterFunctionCall(c *FunctionCallContext)

	// EnterFunctionArgs is called when entering the functionArgs production.
	EnterFunctionArgs(c *FunctionArgsContext)

	// EnterFunctionArg is called when entering the functionArg production.
	EnterFunctionArg(c *FunctionArgContext)

	// EnterBindMarkers is called when entering the bindMarkers production.
	EnterBindMarkers(c *BindMarkersContext)

	// EnterBindMarker is called when entering the bindMarker production.
	EnterBindMarker(c *BindMarkerContext)

	// EnterPositionalBindMarker is called when entering the positionalBindMarker production.
	EnterPositionalBindMarker(c *PositionalBindMarkerContext)

	// EnterNamedBindMarker is called when entering the namedBindMarker production.
	EnterNamedBindMarker(c *NamedBindMarkerContext)

	// EnterTerms is called when entering the terms production.
	EnterTerms(c *TermsContext)

	// EnterTerm is called when entering the term production.
	EnterTerm(c *TermContext)

	// EnterTypeCast is called when entering the typeCast production.
	EnterTypeCast(c *TypeCastContext)

	// EnterCqlType is called when entering the cqlType production.
	EnterCqlType(c *CqlTypeContext)

	// EnterPrimitiveType is called when entering the primitiveType production.
	EnterPrimitiveType(c *PrimitiveTypeContext)

	// EnterCollectionType is called when entering the collectionType production.
	EnterCollectionType(c *CollectionTypeContext)

	// EnterTupleType is called when entering the tupleType production.
	EnterTupleType(c *TupleTypeContext)

	// EnterTableName is called when entering the tableName production.
	EnterTableName(c *TableNameContext)

	// EnterFunctionName is called when entering the functionName production.
	EnterFunctionName(c *FunctionNameContext)

	// EnterUserTypeName is called when entering the userTypeName production.
	EnterUserTypeName(c *UserTypeNameContext)

	// EnterKeyspaceName is called when entering the keyspaceName production.
	EnterKeyspaceName(c *KeyspaceNameContext)

	// EnterQualifiedIdentifier is called when entering the qualifiedIdentifier production.
	EnterQualifiedIdentifier(c *QualifiedIdentifierContext)

	// EnterIdentifiers is called when entering the identifiers production.
	EnterIdentifiers(c *IdentifiersContext)

	// EnterIdentifier is called when entering the identifier production.
	EnterIdentifier(c *IdentifierContext)

	// EnterUnreservedKeyword is called when entering the unreservedKeyword production.
	EnterUnreservedKeyword(c *UnreservedKeywordContext)

	// EnterUnrecognizedStatement is called when entering the unrecognizedStatement production.
	EnterUnrecognizedStatement(c *UnrecognizedStatementContext)

	// EnterUnrecognizedToken is called when entering the unrecognizedToken production.
	EnterUnrecognizedToken(c *UnrecognizedTokenContext)

	// ExitCqlStatement is called when exiting the cqlStatement production.
	ExitCqlStatement(c *CqlStatementContext)

	// ExitInsertStatement is called when exiting the insertStatement production.
	ExitInsertStatement(c *InsertStatementContext)

	// ExitUpdateStatement is called when exiting the updateStatement production.
	ExitUpdateStatement(c *UpdateStatementContext)

	// ExitUpdateOperations is called when exiting the updateOperations production.
	ExitUpdateOperations(c *UpdateOperationsContext)

	// ExitUpdateOperation is called when exiting the updateOperation production.
	ExitUpdateOperation(c *UpdateOperationContext)

	// ExitDeleteStatement is called when exiting the deleteStatement production.
	ExitDeleteStatement(c *DeleteStatementContext)

	// ExitDeleteOperations is called when exiting the deleteOperations production.
	ExitDeleteOperations(c *DeleteOperationsContext)

	// ExitDeleteOperation is called when exiting the deleteOperation production.
	ExitDeleteOperation(c *DeleteOperationContext)

	// ExitBatchStatement is called when exiting the batchStatement production.
	ExitBatchStatement(c *BatchStatementContext)

	// ExitBatchChildStatement is called when exiting the batchChildStatement production.
	ExitBatchChildStatement(c *BatchChildStatementContext)

	// ExitSelectStatement is called when exiting the selectStatement production.
	ExitSelectStatement(c *SelectStatementContext)

	// ExitSelectClause is called when exiting the selectClause production.
	ExitSelectClause(c *SelectClauseContext)

	// ExitSelectors is called when exiting the selectors production.
	ExitSelectors(c *SelectorsContext)

	// ExitSelector is called when exiting the selector production.
	ExitSelector(c *SelectorContext)

	// ExitUnaliasedSelector is called when exiting the unaliasedSelector production.
	ExitUnaliasedSelector(c *UnaliasedSelectorContext)

	// ExitUseStatement is called when exiting the useStatement production.
	ExitUseStatement(c *UseStatementContext)

	// ExitOrderByClause is called when exiting the orderByClause production.
	ExitOrderByClause(c *OrderByClauseContext)

	// ExitOrderings is called when exiting the orderings production.
	ExitOrderings(c *OrderingsContext)

	// ExitOrdering is called when exiting the ordering production.
	ExitOrdering(c *OrderingContext)

	// ExitGroupByClause is called when exiting the groupByClause production.
	ExitGroupByClause(c *GroupByClauseContext)

	// ExitPerPartitionLimitClause is called when exiting the perPartitionLimitClause production.
	ExitPerPartitionLimitClause(c *PerPartitionLimitClauseContext)

	// ExitLimitClause is called when exiting the limitClause production.
	ExitLimitClause(c *LimitClauseContext)

	// ExitUsingClause is called when exiting the usingClause production.
	ExitUsingClause(c *UsingClauseContext)

	// ExitTimestamp is called when exiting the timestamp production.
	ExitTimestamp(c *TimestampContext)

	// ExitTtl is called when exiting the ttl production.
	ExitTtl(c *TtlContext)

	// ExitConditions is called when exiting the conditions production.
	ExitConditions(c *ConditionsContext)

	// ExitCondition is called when exiting the condition production.
	ExitCondition(c *ConditionContext)

	// ExitWhereClause is called when exiting the whereClause production.
	ExitWhereClause(c *WhereClauseContext)

	// ExitRelation is called when exiting the relation production.
	ExitRelation(c *RelationContext)

	// ExitOperator is called when exiting the operator production.
	ExitOperator(c *OperatorContext)

	// ExitLiteral is called when exiting the literal production.
	ExitLiteral(c *LiteralContext)

	// ExitPrimitiveLiteral is called when exiting the primitiveLiteral production.
	ExitPrimitiveLiteral(c *PrimitiveLiteralContext)

	// ExitCollectionLiteral is called when exiting the collectionLiteral production.
	ExitCollectionLiteral(c *CollectionLiteralContext)

	// ExitListLiteral is called when exiting the listLiteral production.
	ExitListLiteral(c *ListLiteralContext)

	// ExitSetLiteral is called when exiting the setLiteral production.
	ExitSetLiteral(c *SetLiteralContext)

	// ExitMapLiteral is called when exiting the mapLiteral production.
	ExitMapLiteral(c *MapLiteralContext)

	// ExitMapEntries is called when exiting the mapEntries production.
	ExitMapEntries(c *MapEntriesContext)

	// ExitMapEntry is called when exiting the mapEntry production.
	ExitMapEntry(c *MapEntryContext)

	// ExitTupleLiterals is called when exiting the tupleLiterals production.
	ExitTupleLiterals(c *TupleLiteralsContext)

	// ExitTupleLiteral is called when exiting the tupleLiteral production.
	ExitTupleLiteral(c *TupleLiteralContext)

	// ExitUdtLiteral is called when exiting the udtLiteral production.
	ExitUdtLiteral(c *UdtLiteralContext)

	// ExitFieldLiterals is called when exiting the fieldLiterals production.
	ExitFieldLiterals(c *FieldLiteralsContext)

	// ExitFieldLiteral is called when exiting the fieldLiteral production.
	ExitFieldLiteral(c *FieldLiteralContext)

	// ExitFunctionCall is called when exiting the functionCall production.
	ExitFunctionCall(c *FunctionCallContext)

	// ExitFunctionArgs is called when exiting the functionArgs production.
	ExitFunctionArgs(c *FunctionArgsContext)

	// ExitFunctionArg is called when exiting the functionArg production.
	ExitFunctionArg(c *FunctionArgContext)

	// ExitBindMarkers is called when exiting the bindMarkers production.
	ExitBindMarkers(c *BindMarkersContext)

	// ExitBindMarker is called when exiting the bindMarker production.
	ExitBindMarker(c *BindMarkerContext)

	// ExitPositionalBindMarker is called when exiting the positionalBindMarker production.
	ExitPositionalBindMarker(c *PositionalBindMarkerContext)

	// ExitNamedBindMarker is called when exiting the namedBindMarker production.
	ExitNamedBindMarker(c *NamedBindMarkerContext)

	// ExitTerms is called when exiting the terms production.
	ExitTerms(c *TermsContext)

	// ExitTerm is called when exiting the term production.
	ExitTerm(c *TermContext)

	// ExitTypeCast is called when exiting the typeCast production.
	ExitTypeCast(c *TypeCastContext)

	// ExitCqlType is called when exiting the cqlType production.
	ExitCqlType(c *CqlTypeContext)

	// ExitPrimitiveType is called when exiting the primitiveType production.
	ExitPrimitiveType(c *PrimitiveTypeContext)

	// ExitCollectionType is called when exiting the collectionType production.
	ExitCollectionType(c *CollectionTypeContext)

	// ExitTupleType is called when exiting the tupleType production.
	ExitTupleType(c *TupleTypeContext)

	// ExitTableName is called when exiting the tableName production.
	ExitTableName(c *TableNameContext)

	// ExitFunctionName is called when exiting the functionName production.
	ExitFunctionName(c *FunctionNameContext)

	// ExitUserTypeName is called when exiting the userTypeName production.
	ExitUserTypeName(c *UserTypeNameContext)

	// ExitKeyspaceName is called when exiting the keyspaceName production.
	ExitKeyspaceName(c *KeyspaceNameContext)

	// ExitQualifiedIdentifier is called when exiting the qualifiedIdentifier production.
	ExitQualifiedIdentifier(c *QualifiedIdentifierContext)

	// ExitIdentifiers is called when exiting the identifiers production.
	ExitIdentifiers(c *IdentifiersContext)

	// ExitIdentifier is called when exiting the identifier production.
	ExitIdentifier(c *IdentifierContext)

	// ExitUnreservedKeyword is called when exiting the unreservedKeyword production.
	ExitUnreservedKeyword(c *UnreservedKeywordContext)

	// ExitUnrecognizedStatement is called when exiting the unrecognizedStatement production.
	ExitUnrecognizedStatement(c *UnrecognizedStatementContext)

	// ExitUnrecognizedToken is called when exiting the unrecognizedToken production.
	ExitUnrecognizedToken(c *UnrecognizedTokenContext)
}

SimplifiedCqlListener is a complete listener for a parse tree produced by SimplifiedCqlParser.

type SimplifiedCqlParser 

type SimplifiedCqlParser struct {
	*antlr.BaseParser
}

func NewSimplifiedCqlParser 

func NewSimplifiedCqlParser(input antlr.TokenStream) *SimplifiedCqlParser

func (*SimplifiedCqlParser) BatchChildStatement 

func (p *SimplifiedCqlParser) BatchChildStatement() (localctx IBatchChildStatementContext)

func (*SimplifiedCqlParser) BatchStatement 

func (p *SimplifiedCqlParser) BatchStatement() (localctx IBatchStatementContext)

func (*SimplifiedCqlParser) BindMarker 

func (p *SimplifiedCqlParser) BindMarker() (localctx IBindMarkerContext)

func (*SimplifiedCqlParser) BindMarkers 

func (p *SimplifiedCqlParser) BindMarkers() (localctx IBindMarkersContext)

func (*SimplifiedCqlParser) CollectionLiteral 

func (p *SimplifiedCqlParser) CollectionLiteral() (localctx ICollectionLiteralContext)

func (*SimplifiedCqlParser) CollectionType 

func (p *SimplifiedCqlParser) CollectionType() (localctx ICollectionTypeContext)

func (*SimplifiedCqlParser) Condition 

func (p *SimplifiedCqlParser) Condition() (localctx IConditionContext)

func (*SimplifiedCqlParser) Conditions 

func (p *SimplifiedCqlParser) Conditions() (localctx IConditionsContext)

func (*SimplifiedCqlParser) CqlStatement 

func (p *SimplifiedCqlParser) CqlStatement() (localctx ICqlStatementContext)

func (*SimplifiedCqlParser) CqlType 

func (p *SimplifiedCqlParser) CqlType() (localctx ICqlTypeContext)

func (*SimplifiedCqlParser) DeleteOperation 

func (p *SimplifiedCqlParser) DeleteOperation() (localctx IDeleteOperationContext)

func (*SimplifiedCqlParser) DeleteOperations 

func (p *SimplifiedCqlParser) DeleteOperations() (localctx IDeleteOperationsContext)

func (*SimplifiedCqlParser) DeleteStatement 

func (p *SimplifiedCqlParser) DeleteStatement() (localctx IDeleteStatementContext)

func (*SimplifiedCqlParser) FieldLiteral 

func (p *SimplifiedCqlParser) FieldLiteral() (localctx IFieldLiteralContext)

func (*SimplifiedCqlParser) FieldLiterals 

func (p *SimplifiedCqlParser) FieldLiterals() (localctx IFieldLiteralsContext)

func (*SimplifiedCqlParser) FunctionArg 

func (p *SimplifiedCqlParser) FunctionArg() (localctx IFunctionArgContext)

func (*SimplifiedCqlParser) FunctionArgs 

func (p *SimplifiedCqlParser) FunctionArgs() (localctx IFunctionArgsContext)

func (*SimplifiedCqlParser) FunctionCall 

func (p *SimplifiedCqlParser) FunctionCall() (localctx IFunctionCallContext)

func (*SimplifiedCqlParser) FunctionName 

func (p *SimplifiedCqlParser) FunctionName() (localctx IFunctionNameContext)

func (*SimplifiedCqlParser) GroupByClause 

func (p *SimplifiedCqlParser) GroupByClause() (localctx IGroupByClauseContext)

func (*SimplifiedCqlParser) Identifier 

func (p *SimplifiedCqlParser) Identifier() (localctx IIdentifierContext)

func (*SimplifiedCqlParser) Identifiers 

func (p *SimplifiedCqlParser) Identifiers() (localctx IIdentifiersContext)

func (*SimplifiedCqlParser) InsertStatement 

func (p *SimplifiedCqlParser) InsertStatement() (localctx IInsertStatementContext)

func (*SimplifiedCqlParser) KeyspaceName 

func (p *SimplifiedCqlParser) KeyspaceName() (localctx IKeyspaceNameContext)

func (*SimplifiedCqlParser) LimitClause 

func (p *SimplifiedCqlParser) LimitClause() (localctx ILimitClauseContext)

func (*SimplifiedCqlParser) ListLiteral 

func (p *SimplifiedCqlParser) ListLiteral() (localctx IListLiteralContext)

func (*SimplifiedCqlParser) Literal 

func (p *SimplifiedCqlParser) Literal() (localctx ILiteralContext)

func (*SimplifiedCqlParser) MapEntries 

func (p *SimplifiedCqlParser) MapEntries() (localctx IMapEntriesContext)

func (*SimplifiedCqlParser) MapEntry 

func (p *SimplifiedCqlParser) MapEntry() (localctx IMapEntryContext)

func (*SimplifiedCqlParser) MapLiteral 

func (p *SimplifiedCqlParser) MapLiteral() (localctx IMapLiteralContext)

func (*SimplifiedCqlParser) NamedBindMarker 

func (p *SimplifiedCqlParser) NamedBindMarker() (localctx INamedBindMarkerContext)

func (*SimplifiedCqlParser) Operator 

func (p *SimplifiedCqlParser) Operator() (localctx IOperatorContext)

func (*SimplifiedCqlParser) OrderByClause 

func (p *SimplifiedCqlParser) OrderByClause() (localctx IOrderByClauseContext)

func (*SimplifiedCqlParser) Ordering 

func (p *SimplifiedCqlParser) Ordering() (localctx IOrderingContext)

func (*SimplifiedCqlParser) Orderings 

func (p *SimplifiedCqlParser) Orderings() (localctx IOrderingsContext)

func (*SimplifiedCqlParser) PerPartitionLimitClause 

func (p *SimplifiedCqlParser) PerPartitionLimitClause() (localctx IPerPartitionLimitClauseContext)

func (*SimplifiedCqlParser) PositionalBindMarker 

func (p *SimplifiedCqlParser) PositionalBindMarker() (localctx IPositionalBindMarkerContext)

func (*SimplifiedCqlParser) PrimitiveLiteral 

func (p *SimplifiedCqlParser) PrimitiveLiteral() (localctx IPrimitiveLiteralContext)

func (*SimplifiedCqlParser) PrimitiveType 

func (p *SimplifiedCqlParser) PrimitiveType() (localctx IPrimitiveTypeContext)

func (*SimplifiedCqlParser) QualifiedIdentifier 

func (p *SimplifiedCqlParser) QualifiedIdentifier() (localctx IQualifiedIdentifierContext)

func (*SimplifiedCqlParser) Relation 

func (p *SimplifiedCqlParser) Relation() (localctx IRelationContext)

func (*SimplifiedCqlParser) SelectClause 

func (p *SimplifiedCqlParser) SelectClause() (localctx ISelectClauseContext)

func (*SimplifiedCqlParser) SelectStatement 

func (p *SimplifiedCqlParser) SelectStatement() (localctx ISelectStatementContext)

func (*SimplifiedCqlParser) Selector 

func (p *SimplifiedCqlParser) Selector() (localctx ISelectorContext)

func (*SimplifiedCqlParser) Selectors 

func (p *SimplifiedCqlParser) Selectors() (localctx ISelectorsContext)

func (*SimplifiedCqlParser) SetLiteral 

func (p *SimplifiedCqlParser) SetLiteral() (localctx ISetLiteralContext)

func (*SimplifiedCqlParser) TableName 

func (p *SimplifiedCqlParser) TableName() (localctx ITableNameContext)

func (*SimplifiedCqlParser) Term 

func (p *SimplifiedCqlParser) Term() (localctx ITermContext)

func (*SimplifiedCqlParser) Terms 

func (p *SimplifiedCqlParser) Terms() (localctx ITermsContext)

func (*SimplifiedCqlParser) Timestamp 

func (p *SimplifiedCqlParser) Timestamp() (localctx ITimestampContext)

func (*SimplifiedCqlParser) Ttl 

func (p *SimplifiedCqlParser) Ttl() (localctx ITtlContext)

func (*SimplifiedCqlParser) TupleLiteral 

func (p *SimplifiedCqlParser) TupleLiteral() (localctx ITupleLiteralContext)

func (*SimplifiedCqlParser) TupleLiterals 

func (p *SimplifiedCqlParser) TupleLiterals() (localctx ITupleLiteralsContext)

func (*SimplifiedCqlParser) TupleType 

func (p *SimplifiedCqlParser) TupleType() (localctx ITupleTypeContext)

func (*SimplifiedCqlParser) TypeCast 

func (p *SimplifiedCqlParser) TypeCast() (localctx ITypeCastContext)

func (*SimplifiedCqlParser) UdtLiteral 

func (p *SimplifiedCqlParser) UdtLiteral() (localctx IUdtLiteralContext)

func (*SimplifiedCqlParser) UnaliasedSelector 

func (p *SimplifiedCqlParser) UnaliasedSelector() (localctx IUnaliasedSelectorContext)

func (*SimplifiedCqlParser) UnrecognizedStatement 

func (p *SimplifiedCqlParser) UnrecognizedStatement() (localctx IUnrecognizedStatementContext)

func (*SimplifiedCqlParser) UnrecognizedToken 

func (p *SimplifiedCqlParser) UnrecognizedToken() (localctx IUnrecognizedTokenContext)

func (*SimplifiedCqlParser) UnreservedKeyword 

func (p *SimplifiedCqlParser) UnreservedKeyword() (localctx IUnreservedKeywordContext)

func (*SimplifiedCqlParser) UpdateOperation 

func (p *SimplifiedCqlParser) UpdateOperation() (localctx IUpdateOperationContext)

func (*SimplifiedCqlParser) UpdateOperations 

func (p *SimplifiedCqlParser) UpdateOperations() (localctx IUpdateOperationsContext)

func (*SimplifiedCqlParser) UpdateStatement 

func (p *SimplifiedCqlParser) UpdateStatement() (localctx IUpdateStatementContext)

func (*SimplifiedCqlParser) UseStatement 

func (p *SimplifiedCqlParser) UseStatement() (localctx IUseStatementContext)

func (*SimplifiedCqlParser) UserTypeName 

func (p *SimplifiedCqlParser) UserTypeName() (localctx IUserTypeNameContext)

func (*SimplifiedCqlParser) UsingClause 

func (p *SimplifiedCqlParser) UsingClause() (localctx IUsingClauseContext)

func (*SimplifiedCqlParser) WhereClause 

func (p *SimplifiedCqlParser) WhereClause() (localctx IWhereClauseContext)

type TableNameContext 

type TableNameContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyTableNameContext 

func NewEmptyTableNameContext() *TableNameContext

func NewTableNameContext 

func NewTableNameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TableNameContext

func (*TableNameContext) EnterRule 

func (s *TableNameContext) EnterRule(listener antlr.ParseTreeListener)

func (*TableNameContext) ExitRule 

func (s *TableNameContext) ExitRule(listener antlr.ParseTreeListener)

func (*TableNameContext) GetParser 

func (s *TableNameContext) GetParser() antlr.Parser

func (*TableNameContext) GetRuleContext 

func (s *TableNameContext) GetRuleContext() antlr.RuleContext

func (*TableNameContext) IsTableNameContext 

func (*TableNameContext) IsTableNameContext()

func (*TableNameContext) QualifiedIdentifier 

func (s *TableNameContext) QualifiedIdentifier() IQualifiedIdentifierContext

func (*TableNameContext) ToStringTree 

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

type TermContext 

type TermContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyTermContext 

func NewEmptyTermContext() *TermContext

func NewTermContext 

func NewTermContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TermContext

func (*TermContext) BindMarker 

func (s *TermContext) BindMarker() IBindMarkerContext

func (*TermContext) EnterRule 

func (s *TermContext) EnterRule(listener antlr.ParseTreeListener)

func (*TermContext) ExitRule 

func (s *TermContext) ExitRule(listener antlr.ParseTreeListener)

func (*TermContext) FunctionCall 

func (s *TermContext) FunctionCall() IFunctionCallContext

func (*TermContext) GetParser 

func (s *TermContext) GetParser() antlr.Parser

func (*TermContext) GetRuleContext 

func (s *TermContext) GetRuleContext() antlr.RuleContext

func (*TermContext) IsTermContext 

func (*TermContext) IsTermContext()

func (*TermContext) Literal 

func (s *TermContext) Literal() ILiteralContext

func (*TermContext) ToStringTree 

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

func (*TermContext) TypeCast 

func (s *TermContext) TypeCast() ITypeCastContext

type TermsContext 

type TermsContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyTermsContext 

func NewEmptyTermsContext() *TermsContext

func NewTermsContext 

func NewTermsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TermsContext

func (*TermsContext) AllTerm 

func (s *TermsContext) AllTerm() []ITermContext

func (*TermsContext) EnterRule 

func (s *TermsContext) EnterRule(listener antlr.ParseTreeListener)

func (*TermsContext) ExitRule 

func (s *TermsContext) ExitRule(listener antlr.ParseTreeListener)

func (*TermsContext) GetParser 

func (s *TermsContext) GetParser() antlr.Parser

func (*TermsContext) GetRuleContext 

func (s *TermsContext) GetRuleContext() antlr.RuleContext

func (*TermsContext) IsTermsContext 

func (*TermsContext) IsTermsContext()

func (*TermsContext) Term 

func (s *TermsContext) Term(i int) ITermContext

func (*TermsContext) ToStringTree 

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

type TimestampContext 

type TimestampContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyTimestampContext 

func NewEmptyTimestampContext() *TimestampContext

func NewTimestampContext 

func NewTimestampContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TimestampContext

func (*TimestampContext) BindMarker 

func (s *TimestampContext) BindMarker() IBindMarkerContext

func (*TimestampContext) EnterRule 

func (s *TimestampContext) EnterRule(listener antlr.ParseTreeListener)

func (*TimestampContext) ExitRule 

func (s *TimestampContext) ExitRule(listener antlr.ParseTreeListener)

func (*TimestampContext) GetParser 

func (s *TimestampContext) GetParser() antlr.Parser

func (*TimestampContext) GetRuleContext 

func (s *TimestampContext) GetRuleContext() antlr.RuleContext

func (*TimestampContext) INTEGER 

func (s *TimestampContext) INTEGER() antlr.TerminalNode

func (*TimestampContext) IsTimestampContext 

func (*TimestampContext) IsTimestampContext()

func (*TimestampContext) K_TIMESTAMP 

func (s *TimestampContext) K_TIMESTAMP() antlr.TerminalNode

func (*TimestampContext) ToStringTree 

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

type TtlContext 

type TtlContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyTtlContext 

func NewEmptyTtlContext() *TtlContext

func NewTtlContext 

func NewTtlContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TtlContext

func (*TtlContext) BindMarker 

func (s *TtlContext) BindMarker() IBindMarkerContext

func (*TtlContext) EnterRule 

func (s *TtlContext) EnterRule(listener antlr.ParseTreeListener)

func (*TtlContext) ExitRule 

func (s *TtlContext) ExitRule(listener antlr.ParseTreeListener)

func (*TtlContext) GetParser 

func (s *TtlContext) GetParser() antlr.Parser

func (*TtlContext) GetRuleContext 

func (s *TtlContext) GetRuleContext() antlr.RuleContext

func (*TtlContext) INTEGER 

func (s *TtlContext) INTEGER() antlr.TerminalNode

func (*TtlContext) IsTtlContext 

func (*TtlContext) IsTtlContext()

func (*TtlContext) K_TTL 

func (s *TtlContext) K_TTL() antlr.TerminalNode

func (*TtlContext) ToStringTree 

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

type TupleLiteralContext 

type TupleLiteralContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyTupleLiteralContext 

func NewEmptyTupleLiteralContext() *TupleLiteralContext

func NewTupleLiteralContext 

func NewTupleLiteralContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TupleLiteralContext

func (*TupleLiteralContext) EnterRule 

func (s *TupleLiteralContext) EnterRule(listener antlr.ParseTreeListener)

func (*TupleLiteralContext) ExitRule 

func (s *TupleLiteralContext) ExitRule(listener antlr.ParseTreeListener)

func (*TupleLiteralContext) GetParser 

func (s *TupleLiteralContext) GetParser() antlr.Parser

func (*TupleLiteralContext) GetRuleContext 

func (s *TupleLiteralContext) GetRuleContext() antlr.RuleContext

func (*TupleLiteralContext) IsTupleLiteralContext 

func (*TupleLiteralContext) IsTupleLiteralContext()

func (*TupleLiteralContext) Terms 

func (s *TupleLiteralContext) Terms() ITermsContext

func (*TupleLiteralContext) ToStringTree 

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

type TupleLiteralsContext 

type TupleLiteralsContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyTupleLiteralsContext 

func NewEmptyTupleLiteralsContext() *TupleLiteralsContext

func NewTupleLiteralsContext 

func NewTupleLiteralsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TupleLiteralsContext

func (*TupleLiteralsContext) AllTupleLiteral 

func (s *TupleLiteralsContext) AllTupleLiteral() []ITupleLiteralContext

func (*TupleLiteralsContext) EnterRule 

func (s *TupleLiteralsContext) EnterRule(listener antlr.ParseTreeListener)

func (*TupleLiteralsContext) ExitRule 

func (s *TupleLiteralsContext) ExitRule(listener antlr.ParseTreeListener)

func (*TupleLiteralsContext) GetParser 

func (s *TupleLiteralsContext) GetParser() antlr.Parser

func (*TupleLiteralsContext) GetRuleContext 

func (s *TupleLiteralsContext) GetRuleContext() antlr.RuleContext

func (*TupleLiteralsContext) IsTupleLiteralsContext 

func (*TupleLiteralsContext) IsTupleLiteralsContext()

func (*TupleLiteralsContext) ToStringTree 

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

func (*TupleLiteralsContext) TupleLiteral 

func (s *TupleLiteralsContext) TupleLiteral(i int) ITupleLiteralContext

type TupleTypeContext 

type TupleTypeContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyTupleTypeContext 

func NewEmptyTupleTypeContext() *TupleTypeContext

func NewTupleTypeContext 

func NewTupleTypeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TupleTypeContext

func (*TupleTypeContext) AllCqlType 

func (s *TupleTypeContext) AllCqlType() []ICqlTypeContext

func (*TupleTypeContext) CqlType 

func (s *TupleTypeContext) CqlType(i int) ICqlTypeContext

func (*TupleTypeContext) EnterRule 

func (s *TupleTypeContext) EnterRule(listener antlr.ParseTreeListener)

func (*TupleTypeContext) ExitRule 

func (s *TupleTypeContext) ExitRule(listener antlr.ParseTreeListener)

func (*TupleTypeContext) GetParser 

func (s *TupleTypeContext) GetParser() antlr.Parser

func (*TupleTypeContext) GetRuleContext 

func (s *TupleTypeContext) GetRuleContext() antlr.RuleContext

func (*TupleTypeContext) IsTupleTypeContext 

func (*TupleTypeContext) IsTupleTypeContext()

func (*TupleTypeContext) K_TUPLE 

func (s *TupleTypeContext) K_TUPLE() antlr.TerminalNode

func (*TupleTypeContext) ToStringTree 

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

type TypeCastContext 

type TypeCastContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyTypeCastContext 

func NewEmptyTypeCastContext() *TypeCastContext

func NewTypeCastContext 

func NewTypeCastContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TypeCastContext

func (*TypeCastContext) CqlType 

func (s *TypeCastContext) CqlType() ICqlTypeContext

func (*TypeCastContext) EnterRule 

func (s *TypeCastContext) EnterRule(listener antlr.ParseTreeListener)

func (*TypeCastContext) ExitRule 

func (s *TypeCastContext) ExitRule(listener antlr.ParseTreeListener)

func (*TypeCastContext) GetParser 

func (s *TypeCastContext) GetParser() antlr.Parser

func (*TypeCastContext) GetRuleContext 

func (s *TypeCastContext) GetRuleContext() antlr.RuleContext

func (*TypeCastContext) IsTypeCastContext 

func (*TypeCastContext) IsTypeCastContext()

func (*TypeCastContext) Term 

func (s *TypeCastContext) Term() ITermContext

func (*TypeCastContext) ToStringTree 

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

type UdtLiteralContext 

type UdtLiteralContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyUdtLiteralContext 

func NewEmptyUdtLiteralContext() *UdtLiteralContext

func NewUdtLiteralContext 

func NewUdtLiteralContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *UdtLiteralContext

func (*UdtLiteralContext) EnterRule 

func (s *UdtLiteralContext) EnterRule(listener antlr.ParseTreeListener)

func (*UdtLiteralContext) ExitRule 

func (s *UdtLiteralContext) ExitRule(listener antlr.ParseTreeListener)

func (*UdtLiteralContext) FieldLiterals 

func (s *UdtLiteralContext) FieldLiterals() IFieldLiteralsContext

func (*UdtLiteralContext) GetParser 

func (s *UdtLiteralContext) GetParser() antlr.Parser

func (*UdtLiteralContext) GetRuleContext 

func (s *UdtLiteralContext) GetRuleContext() antlr.RuleContext

func (*UdtLiteralContext) IsUdtLiteralContext 

func (*UdtLiteralContext) IsUdtLiteralContext()

func (*UdtLiteralContext) ToStringTree 

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

type UnaliasedSelectorContext 

type UnaliasedSelectorContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyUnaliasedSelectorContext 

func NewEmptyUnaliasedSelectorContext() *UnaliasedSelectorContext

func NewUnaliasedSelectorContext 

func NewUnaliasedSelectorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *UnaliasedSelectorContext

func (*UnaliasedSelectorContext) EnterRule 

func (s *UnaliasedSelectorContext) EnterRule(listener antlr.ParseTreeListener)

func (*UnaliasedSelectorContext) ExitRule 

func (s *UnaliasedSelectorContext) ExitRule(listener antlr.ParseTreeListener)

func (*UnaliasedSelectorContext) GetParser 

func (s *UnaliasedSelectorContext) GetParser() antlr.Parser

func (*UnaliasedSelectorContext) GetRuleContext 

func (s *UnaliasedSelectorContext) GetRuleContext() antlr.RuleContext

func (*UnaliasedSelectorContext) Identifier 

func (s *UnaliasedSelectorContext) Identifier() IIdentifierContext

func (*UnaliasedSelectorContext) IsUnaliasedSelectorContext 

func (*UnaliasedSelectorContext) IsUnaliasedSelectorContext()

func (*UnaliasedSelectorContext) K_AS 

func (s *UnaliasedSelectorContext) K_AS() antlr.TerminalNode

func (*UnaliasedSelectorContext) K_CAST 

func (s *UnaliasedSelectorContext) K_CAST() antlr.TerminalNode

func (*UnaliasedSelectorContext) K_COUNT 

func (s *UnaliasedSelectorContext) K_COUNT() antlr.TerminalNode

func (*UnaliasedSelectorContext) PrimitiveType 

func (s *UnaliasedSelectorContext) PrimitiveType() IPrimitiveTypeContext

func (*UnaliasedSelectorContext) Term 

func (s *UnaliasedSelectorContext) Term() ITermContext

func (*UnaliasedSelectorContext) ToStringTree 

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

func (*UnaliasedSelectorContext) UnaliasedSelector 

func (s *UnaliasedSelectorContext) UnaliasedSelector() IUnaliasedSelectorContext

type UnrecognizedStatementContext 

type UnrecognizedStatementContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyUnrecognizedStatementContext 

func NewEmptyUnrecognizedStatementContext() *UnrecognizedStatementContext

func NewUnrecognizedStatementContext 

func NewUnrecognizedStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *UnrecognizedStatementContext

func (*UnrecognizedStatementContext) AllUnrecognizedToken 

func (s *UnrecognizedStatementContext) AllUnrecognizedToken() []IUnrecognizedTokenContext

func (*UnrecognizedStatementContext) EnterRule 

func (s *UnrecognizedStatementContext) EnterRule(listener antlr.ParseTreeListener)

func (*UnrecognizedStatementContext) ExitRule 

func (s *UnrecognizedStatementContext) ExitRule(listener antlr.ParseTreeListener)

func (*UnrecognizedStatementContext) GetParser 

func (s *UnrecognizedStatementContext) GetParser() antlr.Parser

func (*UnrecognizedStatementContext) GetRuleContext 

func (s *UnrecognizedStatementContext) GetRuleContext() antlr.RuleContext

func (*UnrecognizedStatementContext) IsUnrecognizedStatementContext 

func (*UnrecognizedStatementContext) IsUnrecognizedStatementContext()

func (*UnrecognizedStatementContext) ToStringTree 

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

func (*UnrecognizedStatementContext) UnrecognizedToken 

func (s *UnrecognizedStatementContext) UnrecognizedToken(i int) IUnrecognizedTokenContext

type UnrecognizedTokenContext 

type UnrecognizedTokenContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyUnrecognizedTokenContext 

func NewEmptyUnrecognizedTokenContext() *UnrecognizedTokenContext

func NewUnrecognizedTokenContext 

func NewUnrecognizedTokenContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *UnrecognizedTokenContext

func (*UnrecognizedTokenContext) EnterRule 

func (s *UnrecognizedTokenContext) EnterRule(listener antlr.ParseTreeListener)

func (*UnrecognizedTokenContext) ExitRule 

func (s *UnrecognizedTokenContext) ExitRule(listener antlr.ParseTreeListener)

func (*UnrecognizedTokenContext) GetParser 

func (s *UnrecognizedTokenContext) GetParser() antlr.Parser

func (*UnrecognizedTokenContext) GetRuleContext 

func (s *UnrecognizedTokenContext) GetRuleContext() antlr.RuleContext

func (*UnrecognizedTokenContext) IsUnrecognizedTokenContext 

func (*UnrecognizedTokenContext) IsUnrecognizedTokenContext()

func (*UnrecognizedTokenContext) ToStringTree 

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

type UnreservedKeywordContext 

type UnreservedKeywordContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyUnreservedKeywordContext 

func NewEmptyUnreservedKeywordContext() *UnreservedKeywordContext

func NewUnreservedKeywordContext 

func NewUnreservedKeywordContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *UnreservedKeywordContext

func (*UnreservedKeywordContext) EnterRule 

func (s *UnreservedKeywordContext) EnterRule(listener antlr.ParseTreeListener)

func (*UnreservedKeywordContext) ExitRule 

func (s *UnreservedKeywordContext) ExitRule(listener antlr.ParseTreeListener)

func (*UnreservedKeywordContext) GetParser 

func (s *UnreservedKeywordContext) GetParser() antlr.Parser

func (*UnreservedKeywordContext) GetRuleContext 

func (s *UnreservedKeywordContext) GetRuleContext() antlr.RuleContext

func (*UnreservedKeywordContext) IsUnreservedKeywordContext 

func (*UnreservedKeywordContext) IsUnreservedKeywordContext()

func (*UnreservedKeywordContext) K_AS 

func (s *UnreservedKeywordContext) K_AS() antlr.TerminalNode

func (*UnreservedKeywordContext) K_CAST 

func (s *UnreservedKeywordContext) K_CAST() antlr.TerminalNode

func (*UnreservedKeywordContext) K_CLUSTERING 

func (s *UnreservedKeywordContext) K_CLUSTERING() antlr.TerminalNode

func (*UnreservedKeywordContext) K_CONTAINS 

func (s *UnreservedKeywordContext) K_CONTAINS() antlr.TerminalNode

func (*UnreservedKeywordContext) K_COUNT 

func (s *UnreservedKeywordContext) K_COUNT() antlr.TerminalNode

func (*UnreservedKeywordContext) K_DISTINCT 

func (s *UnreservedKeywordContext) K_DISTINCT() antlr.TerminalNode

func (*UnreservedKeywordContext) K_EXISTS 

func (s *UnreservedKeywordContext) K_EXISTS() antlr.TerminalNode

func (*UnreservedKeywordContext) K_FILTERING 

func (s *UnreservedKeywordContext) K_FILTERING() antlr.TerminalNode

func (*UnreservedKeywordContext) K_FROZEN 

func (s *UnreservedKeywordContext) K_FROZEN() antlr.TerminalNode

func (*UnreservedKeywordContext) K_GROUP 

func (s *UnreservedKeywordContext) K_GROUP() antlr.TerminalNode

func (*UnreservedKeywordContext) K_JSON 

func (s *UnreservedKeywordContext) K_JSON() antlr.TerminalNode

func (*UnreservedKeywordContext) K_KEY 

func (s *UnreservedKeywordContext) K_KEY() antlr.TerminalNode

func (*UnreservedKeywordContext) K_LIKE 

func (s *UnreservedKeywordContext) K_LIKE() antlr.TerminalNode

func (*UnreservedKeywordContext) K_LIST 

func (s *UnreservedKeywordContext) K_LIST() antlr.TerminalNode

func (*UnreservedKeywordContext) K_MAP 

func (s *UnreservedKeywordContext) K_MAP() antlr.TerminalNode

func (*UnreservedKeywordContext) K_PARTITION 

func (s *UnreservedKeywordContext) K_PARTITION() antlr.TerminalNode

func (*UnreservedKeywordContext) K_PER 

func (s *UnreservedKeywordContext) K_PER() antlr.TerminalNode

func (*UnreservedKeywordContext) K_TTL 

func (s *UnreservedKeywordContext) K_TTL() antlr.TerminalNode

func (*UnreservedKeywordContext) K_TUPLE 

func (s *UnreservedKeywordContext) K_TUPLE() antlr.TerminalNode

func (*UnreservedKeywordContext) K_TYPE 

func (s *UnreservedKeywordContext) K_TYPE() antlr.TerminalNode

func (*UnreservedKeywordContext) K_VALUES 

func (s *UnreservedKeywordContext) K_VALUES() antlr.TerminalNode

func (*UnreservedKeywordContext) K_WRITETIME 

func (s *UnreservedKeywordContext) K_WRITETIME() antlr.TerminalNode

func (*UnreservedKeywordContext) PrimitiveType 

func (s *UnreservedKeywordContext) PrimitiveType() IPrimitiveTypeContext

func (*UnreservedKeywordContext) ToStringTree 

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

type UpdateOperationContext 

type UpdateOperationContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyUpdateOperationContext 

func NewEmptyUpdateOperationContext() *UpdateOperationContext

func NewUpdateOperationContext 

func NewUpdateOperationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *UpdateOperationContext

func (*UpdateOperationContext) AllIdentifier 

func (s *UpdateOperationContext) AllIdentifier() []IIdentifierContext

func (*UpdateOperationContext) AllTerm 

func (s *UpdateOperationContext) AllTerm() []ITermContext

func (*UpdateOperationContext) EnterRule 

func (s *UpdateOperationContext) EnterRule(listener antlr.ParseTreeListener)

func (*UpdateOperationContext) ExitRule 

func (s *UpdateOperationContext) ExitRule(listener antlr.ParseTreeListener)

func (*UpdateOperationContext) GetParser 

func (s *UpdateOperationContext) GetParser() antlr.Parser

func (*UpdateOperationContext) GetRuleContext 

func (s *UpdateOperationContext) GetRuleContext() antlr.RuleContext

func (*UpdateOperationContext) Identifier 

func (s *UpdateOperationContext) Identifier(i int) IIdentifierContext

func (*UpdateOperationContext) IsUpdateOperationContext 

func (*UpdateOperationContext) IsUpdateOperationContext()

func (*UpdateOperationContext) Term 

func (s *UpdateOperationContext) Term(i int) ITermContext

func (*UpdateOperationContext) ToStringTree 

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

type UpdateOperationsContext 

type UpdateOperationsContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyUpdateOperationsContext 

func NewEmptyUpdateOperationsContext() *UpdateOperationsContext

func NewUpdateOperationsContext 

func NewUpdateOperationsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *UpdateOperationsContext

func (*UpdateOperationsContext) AllUpdateOperation 

func (s *UpdateOperationsContext) AllUpdateOperation() []IUpdateOperationContext

func (*UpdateOperationsContext) EnterRule 

func (s *UpdateOperationsContext) EnterRule(listener antlr.ParseTreeListener)

func (*UpdateOperationsContext) ExitRule 

func (s *UpdateOperationsContext) ExitRule(listener antlr.ParseTreeListener)

func (*UpdateOperationsContext) GetParser 

func (s *UpdateOperationsContext) GetParser() antlr.Parser

func (*UpdateOperationsContext) GetRuleContext 

func (s *UpdateOperationsContext) GetRuleContext() antlr.RuleContext

func (*UpdateOperationsContext) IsUpdateOperationsContext 

func (*UpdateOperationsContext) IsUpdateOperationsContext()

func (*UpdateOperationsContext) ToStringTree 

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

func (*UpdateOperationsContext) UpdateOperation 

func (s *UpdateOperationsContext) UpdateOperation(i int) IUpdateOperationContext

type UpdateStatementContext 

type UpdateStatementContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyUpdateStatementContext 

func NewEmptyUpdateStatementContext() *UpdateStatementContext

func NewUpdateStatementContext 

func NewUpdateStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *UpdateStatementContext

func (*UpdateStatementContext) Conditions 

func (s *UpdateStatementContext) Conditions() IConditionsContext

func (*UpdateStatementContext) EnterRule 

func (s *UpdateStatementContext) EnterRule(listener antlr.ParseTreeListener)

func (*UpdateStatementContext) ExitRule 

func (s *UpdateStatementContext) ExitRule(listener antlr.ParseTreeListener)

func (*UpdateStatementContext) GetParser 

func (s *UpdateStatementContext) GetParser() antlr.Parser

func (*UpdateStatementContext) GetRuleContext 

func (s *UpdateStatementContext) GetRuleContext() antlr.RuleContext

func (*UpdateStatementContext) IsUpdateStatementContext 

func (*UpdateStatementContext) IsUpdateStatementContext()

func (*UpdateStatementContext) K_EXISTS 

func (s *UpdateStatementContext) K_EXISTS() antlr.TerminalNode

func (*UpdateStatementContext) K_IF 

func (s *UpdateStatementContext) K_IF() antlr.TerminalNode

func (*UpdateStatementContext) K_SET 

func (s *UpdateStatementContext) K_SET() antlr.TerminalNode

func (*UpdateStatementContext) K_UPDATE 

func (s *UpdateStatementContext) K_UPDATE() antlr.TerminalNode

func (*UpdateStatementContext) TableName 

func (s *UpdateStatementContext) TableName() ITableNameContext

func (*UpdateStatementContext) ToStringTree 

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

func (*UpdateStatementContext) UpdateOperations 

func (s *UpdateStatementContext) UpdateOperations() IUpdateOperationsContext

func (*UpdateStatementContext) UsingClause 

func (s *UpdateStatementContext) UsingClause() IUsingClauseContext

func (*UpdateStatementContext) WhereClause 

func (s *UpdateStatementContext) WhereClause() IWhereClauseContext

type UseStatementContext 

type UseStatementContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyUseStatementContext 

func NewEmptyUseStatementContext() *UseStatementContext

func NewUseStatementContext 

func NewUseStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *UseStatementContext

func (*UseStatementContext) EnterRule 

func (s *UseStatementContext) EnterRule(listener antlr.ParseTreeListener)

func (*UseStatementContext) ExitRule 

func (s *UseStatementContext) ExitRule(listener antlr.ParseTreeListener)

func (*UseStatementContext) GetParser 

func (s *UseStatementContext) GetParser() antlr.Parser

func (*UseStatementContext) GetRuleContext 

func (s *UseStatementContext) GetRuleContext() antlr.RuleContext

func (*UseStatementContext) IsUseStatementContext 

func (*UseStatementContext) IsUseStatementContext()

func (*UseStatementContext) K_USE 

func (s *UseStatementContext) K_USE() antlr.TerminalNode

func (*UseStatementContext) KeyspaceName 

func (s *UseStatementContext) KeyspaceName() IKeyspaceNameContext

func (*UseStatementContext) ToStringTree 

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

type UserTypeNameContext 

type UserTypeNameContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyUserTypeNameContext 

func NewEmptyUserTypeNameContext() *UserTypeNameContext

func NewUserTypeNameContext 

func NewUserTypeNameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *UserTypeNameContext

func (*UserTypeNameContext) EnterRule 

func (s *UserTypeNameContext) EnterRule(listener antlr.ParseTreeListener)

func (*UserTypeNameContext) ExitRule 

func (s *UserTypeNameContext) ExitRule(listener antlr.ParseTreeListener)

func (*UserTypeNameContext) GetParser 

func (s *UserTypeNameContext) GetParser() antlr.Parser

func (*UserTypeNameContext) GetRuleContext 

func (s *UserTypeNameContext) GetRuleContext() antlr.RuleContext

func (*UserTypeNameContext) IsUserTypeNameContext 

func (*UserTypeNameContext) IsUserTypeNameContext()

func (*UserTypeNameContext) QualifiedIdentifier 

func (s *UserTypeNameContext) QualifiedIdentifier() IQualifiedIdentifierContext

func (*UserTypeNameContext) ToStringTree 

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

type UsingClauseContext 

type UsingClauseContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyUsingClauseContext 

func NewEmptyUsingClauseContext() *UsingClauseContext

func NewUsingClauseContext 

func NewUsingClauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *UsingClauseContext

func (*UsingClauseContext) EnterRule 

func (s *UsingClauseContext) EnterRule(listener antlr.ParseTreeListener)

func (*UsingClauseContext) ExitRule 

func (s *UsingClauseContext) ExitRule(listener antlr.ParseTreeListener)

func (*UsingClauseContext) GetParser 

func (s *UsingClauseContext) GetParser() antlr.Parser

func (*UsingClauseContext) GetRuleContext 

func (s *UsingClauseContext) GetRuleContext() antlr.RuleContext

func (*UsingClauseContext) IsUsingClauseContext 

func (*UsingClauseContext) IsUsingClauseContext()

func (*UsingClauseContext) K_AND 

func (s *UsingClauseContext) K_AND() antlr.TerminalNode

func (*UsingClauseContext) K_USING 

func (s *UsingClauseContext) K_USING() antlr.TerminalNode

func (*UsingClauseContext) Timestamp 

func (s *UsingClauseContext) Timestamp() ITimestampContext

func (*UsingClauseContext) ToStringTree 

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

func (*UsingClauseContext) Ttl 

func (s *UsingClauseContext) Ttl() ITtlContext

type WhereClauseContext 

type WhereClauseContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyWhereClauseContext 

func NewEmptyWhereClauseContext() *WhereClauseContext

func NewWhereClauseContext 

func NewWhereClauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *WhereClauseContext

func (*WhereClauseContext) AllK_AND 

func (s *WhereClauseContext) AllK_AND() []antlr.TerminalNode

func (*WhereClauseContext) AllRelation 

func (s *WhereClauseContext) AllRelation() []IRelationContext

func (*WhereClauseContext) EnterRule 

func (s *WhereClauseContext) EnterRule(listener antlr.ParseTreeListener)

func (*WhereClauseContext) ExitRule 

func (s *WhereClauseContext) ExitRule(listener antlr.ParseTreeListener)

func (*WhereClauseContext) GetParser 

func (s *WhereClauseContext) GetParser() antlr.Parser

func (*WhereClauseContext) GetRuleContext 

func (s *WhereClauseContext) GetRuleContext() antlr.RuleContext

func (*WhereClauseContext) IsWhereClauseContext 

func (*WhereClauseContext) IsWhereClauseContext()

func (*WhereClauseContext) K_AND 

func (s *WhereClauseContext) K_AND(i int) antlr.TerminalNode

func (*WhereClauseContext) K_WHERE 

func (s *WhereClauseContext) K_WHERE() antlr.TerminalNode

func (*WhereClauseContext) Relation 

func (s *WhereClauseContext) Relation(i int) IRelationContext

func (*WhereClauseContext) ToStringTree 

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

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.