diff --git a/.github/workflows/tests.yml b/.github/workflows/tests.yml index 3accbe2..8408ea7 100644 --- a/.github/workflows/tests.yml +++ b/.github/workflows/tests.yml @@ -34,7 +34,7 @@ jobs: id: set-matrix run: | # List of all available parsers - ALL_PARSERS="redshift postgresql" + ALL_PARSERS="redshift postgresql cql" # Add more parsers here as they are added to the repository # ALL_PARSERS="redshift mysql postgresql" diff --git a/cql/CqlLexer.g4 b/cql/CqlLexer.g4 new file mode 100644 index 0000000..377fdbf --- /dev/null +++ b/cql/CqlLexer.g4 @@ -0,0 +1,217 @@ +// $antlr-format alignTrailingComments true, columnLimit 150, maxEmptyLinesToKeep 1, reflowComments false, useTab false +// $antlr-format allowShortRulesOnASingleLine true, allowShortBlocksOnASingleLine true, minEmptyLines 0, alignSemicolons ownLine +// $antlr-format alignColons trailing, singleLineOverrulesHangingColon true, alignLexerCommands true, alignLabels true, alignTrailers true + +lexer grammar CqlLexer; + +options { + caseInsensitive = true; +} + +// Operators and Punctuators + +LR_BRACKET : '('; +RR_BRACKET : ')'; +LC_BRACKET : '{'; +RC_BRACKET : '}'; +LS_BRACKET : '['; +RS_BRACKET : ']'; +COMMA : ','; +SEMI : ';'; +COLON : ':'; +DOT : '.'; +STAR : '*'; +DIVIDE : '/'; +MODULE : '%'; +PLUS : '+'; +MINUSMINUS : '--'; +MINUS : '-'; +DQUOTE : '"'; +SQUOTE : '\''; +OPERATOR_EQ : '='; +OPERATOR_LT : '<'; +OPERATOR_GT : '>'; +OPERATOR_LTE : '<='; +OPERATOR_GTE : '>='; + +// Keywords + +K_ADD : 'ADD'; +K_AGGREGATE : 'AGGREGATE'; +K_ALL : 'ALL'; +K_ALLOW : 'ALLOW'; +K_ALTER : 'ALTER'; +K_AND : 'AND'; +K_ANY : 'ANY'; +K_APPLY : 'APPLY'; +K_AS : 'AS'; +K_ASC : 'ASC'; +K_AUTHORIZE : 'AUTHORIZE'; +K_BATCH : 'BATCH'; +K_BEGIN : 'BEGIN'; +K_BY : 'BY'; +K_CALLED : 'CALLED'; +K_CLUSTERING : 'CLUSTERING'; +K_COLUMNFAMILY : 'COLUMNFAMILY'; +K_COMPACT : 'COMPACT'; +K_CONSISTENCY : 'CONSISTENCY'; +K_CONTAINS : 'CONTAINS'; +K_CREATE : 'CREATE'; +K_CUSTOM : 'CUSTOM'; +K_DELETE : 'DELETE'; +K_DESC : 'DESC'; +K_DESCRIBE : 'DESCRIBE'; +K_DISTINCT : 'DISTINCT'; +K_DROP : 'DROP'; +K_DURABLE_WRITES : 'DURABLE_WRITES'; +K_EACH_QUORUM : 'EACH_QUORUM'; +K_ENTRIES : 'ENTRIES'; +K_EXECUTE : 'EXECUTE'; +K_EXISTS : 'EXISTS'; +K_FALSE : 'FALSE'; +K_FILTERING : 'FILTERING'; +K_FINALFUNC : 'FINALFUNC'; +K_FROM : 'FROM'; +K_FULL : 'FULL'; +K_FUNCTION : 'FUNCTION'; +K_FUNCTIONS : 'FUNCTIONS'; +K_GRANT : 'GRANT'; +K_IF : 'IF'; +K_IN : 'IN'; +K_INDEX : 'INDEX'; +K_INFINITY : 'INFINITY'; +K_INITCOND : 'INITCOND'; +K_INPUT : 'INPUT'; +K_INSERT : 'INSERT'; +K_INTO : 'INTO'; +K_IS : 'IS'; +K_JSON : 'JSON'; +K_KEY : 'KEY'; +K_KEYS : 'KEYS'; +K_KEYSPACE : 'KEYSPACE'; +K_KEYSPACES : 'KEYSPACES'; +K_LANGUAGE : 'LANGUAGE'; +K_LEVEL : 'LEVEL'; +K_LIMIT : 'LIMIT'; +K_LOCAL_ONE : 'LOCAL_ONE'; +K_LOCAL_QUORUM : 'LOCAL_QUORUM'; +K_LOGGED : 'LOGGED'; +K_LOGIN : 'LOGIN'; +K_MATERIALIZED : 'MATERIALIZED'; +K_MODIFY : 'MODIFY'; +K_NAN : 'NAN'; +K_NORECURSIVE : 'NORECURSIVE'; +K_NOSUPERUSER : 'NOSUPERUSER'; +K_NOT : 'NOT'; +K_NULL : 'NULL'; +K_OF : 'OF'; +K_ON : 'ON'; +K_ONE : 'ONE'; +K_OPTIONS : 'OPTIONS'; +K_OR : 'OR'; +K_ORDER : 'ORDER'; +K_PARTITION : 'PARTITION'; +K_PASSWORD : 'PASSWORD'; +K_PER : 'PER'; +K_PERMISSION : 'PERMISSION'; +K_PERMISSIONS : 'PERMISSIONS'; +K_PRIMARY : 'PRIMARY'; +K_QUORUM : 'QUORUM'; +K_RENAME : 'RENAME'; +K_REPLACE : 'REPLACE'; +K_REPLICATION : 'REPLICATION'; +K_RETURNS : 'RETURNS'; +K_REVOKE : 'REVOKE'; +K_ROLE : 'ROLE'; +K_ROLES : 'ROLES'; +K_SCHEMA : 'SCHEMA'; +K_SELECT : 'SELECT'; +K_SET : 'SET'; +K_SFUNC : 'SFUNC'; +K_STATIC : 'STATIC'; +K_STORAGE : 'STORAGE'; +K_STYPE : 'STYPE'; +K_SUPERUSER : 'SUPERUSER'; +K_TABLE : 'TABLE'; +K_THREE : 'THREE'; +K_TIMESTAMP : 'TIMESTAMP'; +K_TO : 'TO'; +K_TOKEN : 'TOKEN'; +K_TRIGGER : 'TRIGGER'; +K_TRUE : 'TRUE'; +K_TRUNCATE : 'TRUNCATE'; +K_TTL : 'TTL'; +K_TWO : 'TWO'; +K_TYPE : 'TYPE'; +K_UNLOGGED : 'UNLOGGED'; +K_UPDATE : 'UPDATE'; +K_USE : 'USE'; +K_USER : 'USER'; +K_USING : 'USING'; +K_UUID : 'UUID'; +K_VALUES : 'VALUES'; +K_VIEW : 'VIEW'; +K_WHERE : 'WHERE'; +K_WITH : 'WITH'; +K_WRITETIME : 'WRITETIME'; +K_ASCII : 'ASCII'; +K_BIGINT : 'BIGINT'; +K_BLOB : 'BLOB'; +K_BOOLEAN : 'BOOLEAN'; +K_COUNTER : 'COUNTER'; +K_DATE : 'DATE'; +K_DECIMAL : 'DECIMAL'; +K_DOUBLE : 'DOUBLE'; +K_FLOAT : 'FLOAT'; +K_FROZEN : 'FROZEN'; +K_INET : 'INET'; +K_INT : 'INT'; +K_LIST : 'LIST'; +K_MAP : 'MAP'; +K_SMALLINT : 'SMALLINT'; +K_TEXT : 'TEXT'; +K_TIMEUUID : 'TIMEUUID'; +K_TIME : 'TIME'; +K_TINYINT : 'TINYINT'; +K_TUPLE : 'TUPLE'; +K_VARCHAR : 'VARCHAR'; +K_VARINT : 'VARINT'; + +// Literals + +CODE_BLOCK: '$$' (~ '$' | '$' ~'$')* '$$'; + +STRING_LITERAL: '\'' ('\\' . | '\'\'' | ~('\'' | '\\'))* '\''; + +DECIMAL_LITERAL: DEC_DIGIT+; + +FLOAT_LITERAL: MINUS? [0-9]+ (DOT [0-9]+)?; + +HEXADECIMAL_LITERAL: 'X' '\'' (HEX_DIGIT HEX_DIGIT)+ '\'' | '0X' HEX_DIGIT+; + +REAL_LITERAL: DEC_DIGIT+ '.'? EXPONENT_NUM_PART | DEC_DIGIT* '.' DEC_DIGIT+ EXPONENT_NUM_PART?; + +OBJECT_NAME: [A-Z] [A-Z0-9_$]* | '"' ~'"'+ '"'; + +UUID: + HEX_4DIGIT HEX_4DIGIT '-' HEX_4DIGIT '-' HEX_4DIGIT '-' HEX_4DIGIT '-' HEX_4DIGIT HEX_4DIGIT HEX_4DIGIT +; + +// Hidden + +SPACE : [ \t\r\n]+ -> channel (HIDDEN); +SPEC_MYSQL_COMMENT : '/*!' .+? '*/' -> channel (HIDDEN); +COMMENT_INPUT : '/*' .*? '*/' -> channel (HIDDEN); +LINE_COMMENT: + (('-- ' | '#' | '//') ~ [\r\n]* ('\r'? '\n' | EOF) | '--' ('\r'? '\n' | EOF)) -> channel (HIDDEN) +; + +// Fragments + +fragment HEX_4DIGIT: [0-9A-F] [0-9A-F] [0-9A-F] [0-9A-F]; + +fragment HEX_DIGIT: [0-9A-F]; + +fragment DEC_DIGIT: [0-9]; + +fragment EXPONENT_NUM_PART: 'E' '-'? DEC_DIGIT+; \ No newline at end of file diff --git a/cql/CqlParser.g4 b/cql/CqlParser.g4 new file mode 100644 index 0000000..66c8110 --- /dev/null +++ b/cql/CqlParser.g4 @@ -0,0 +1,1345 @@ +/* + * The MIT License (MIT) + * + * Copyright (c) 2014 by Domagoj Kovačević + * + * Permission is hereby granted, free of charge, to any person obtaining a copy of this software and + * associated documentation files (the "Software"), to deal in the Software without restriction, + * including without limitation the rights to use, copy, modify, merge, publish, distribute, + * sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all copies or + * substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT + * NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, + * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + * + * Project : cql-parser; an ANTLR4 grammar for Apache Cassandra CQL https://github.com/kdcro101cql-parser + */ + +// $antlr-format alignTrailingComments true, columnLimit 150, minEmptyLines 1, maxEmptyLinesToKeep 1, reflowComments false, useTab false +// $antlr-format allowShortRulesOnASingleLine false, allowShortBlocksOnASingleLine true, alignSemicolons hanging, alignColons hanging + +parser grammar CqlParser; + +options + { + tokenVocab = CqlLexer; +} + +root + : cqls? MINUSMINUS? EOF + ; + +cqls + : (cql MINUSMINUS? statementSeparator | empty_)* ( + cql (MINUSMINUS? statementSeparator)? + | empty_ + ) + ; + +statementSeparator + : SEMI + ; + +empty_ + : statementSeparator + ; + +cql + : alterKeyspace + | alterMaterializedView + | alterRole + | alterTable + | alterType + | alterUser + | applyBatch + | createAggregate + | createFunction + | createIndex + | createKeyspace + | createMaterializedView + | createRole + | createTable + | createTrigger + | createType + | createUser + | delete_ + | dropAggregate + | dropFunction + | dropIndex + | dropKeyspace + | dropMaterializedView + | dropRole + | dropTable + | dropTrigger + | dropType + | dropUser + | grant + | insert + | listPermissions + | listRoles + | revoke + | select_ + | truncate + | update + | use_ + ; + +revoke + : kwRevoke priviledge kwOn resource kwFrom role + ; + +listRoles + : kwList kwRoles (kwOf role)? kwNorecursive? + ; + +listPermissions + : kwList priviledge (kwOn resource)? (kwOf role)? + ; + +grant + : kwGrant priviledge kwOn resource kwTo role + ; + +priviledge + : (kwAll | kwAllPermissions) + | kwAlter + | kwAuthorize + | kwDescibe + | kwExecute + | kwCreate + | kwDrop + | kwModify + | kwSelect + ; + +resource + : kwAll kwFunctions + | kwAll kwFunctions kwIn kwKeyspace keyspace + | kwFunction (keyspace DOT)? function_ + | kwAll kwKeyspaces + | kwKeyspace keyspace + | (kwTable)? (keyspace DOT)? table + | kwAll kwRoles + | kwRole role + ; + +createUser + : kwCreate kwUser ifNotExist? user kwWith kwPassword stringLiteral ( + kwSuperuser + | kwNosuperuser + )? + ; + +createRole + : kwCreate kwRole ifNotExist? role roleWith? + ; + +createType + : kwCreate kwType ifNotExist? (keyspace DOT)? type_ syntaxBracketLr typeMemberColumnList syntaxBracketRr + ; + +typeMemberColumnList + : column dataType (syntaxComma column dataType)* + ; + +createTrigger + : kwCreate kwTrigger ifNotExist? (keyspace DOT)? trigger kwUsing triggerClass + ; + +createMaterializedView + : kwCreate kwMaterialized kwView ifNotExist? (keyspace DOT)? materializedView kwAs kwSelect columnList kwFrom ( + keyspace DOT + )? table materializedViewWhere kwPrimary kwKey syntaxBracketLr columnList syntaxBracketRr ( + kwWith materializedViewOptions + )? + ; + +materializedViewWhere + : kwWhere columnNotNullList (kwAnd relationElements)? + ; + +columnNotNullList + : columnNotNull (kwAnd columnNotNull)* + ; + +columnNotNull + : column kwIs kwNot kwNull + ; + +materializedViewOptions + : tableOptions + | tableOptions kwAnd clusteringOrder + | clusteringOrder + ; + +// CREATE MATERIALIZED VIEW [IF NOT EXISTS] [keyspace_name.] view_name +// AS SELECT column_list +// FROM [keyspace_name.] base_table_name +// WHERE column_name IS NOT NULL [AND column_name IS NOT NULL ...] +// [AND relation...] +// PRIMARY KEY ( column_list ) +// [WITH [table_properties] +// [AND CLUSTERING ORDER BY (cluster_column_name order_option )]] +createKeyspace + : kwCreate kwKeyspace ifNotExist? keyspace kwWith kwReplication OPERATOR_EQ syntaxBracketLc replicationList syntaxBracketRc ( + kwAnd durableWrites + )? + ; + +createFunction + : kwCreate orReplace? kwFunction ifNotExist? (keyspace DOT)? function_ syntaxBracketLr paramList? syntaxBracketRr returnMode kwReturns dataType + kwLanguage language kwAs codeBlock + ; + +codeBlock + : CODE_BLOCK + | STRING_LITERAL + ; + +paramList + : param (syntaxComma param)* + ; + +returnMode + : (kwCalled | kwReturns kwNull) kwOn kwNull kwInput + ; + +createAggregate + : kwCreate orReplace? kwAggregate ifNotExist? (keyspace DOT)? aggregate syntaxBracketLr dataType syntaxBracketRr kwSfunc function_ kwStype + dataType kwFinalfunc function_ kwInitcond initCondDefinition + ; + +// paramList +// : +initCondDefinition + : constant + | initCondList + | initCondListNested + | initCondHash + ; + +initCondHash + : syntaxBracketLc initCondHashItem (syntaxComma initCondHashItem)* syntaxBracketRc + ; + +initCondHashItem + : hashKey COLON initCondDefinition + ; + +initCondListNested + : syntaxBracketLr initCondList (syntaxComma constant | initCondList)* syntaxBracketRr + ; + +initCondList + : syntaxBracketLr constant (syntaxComma constant)* syntaxBracketRr + ; + +orReplace + : kwOr kwReplace + ; + +alterUser + : kwAlter kwUser user kwWith userPassword userSuperUser? + ; + +userPassword + : kwPassword stringLiteral + ; + +userSuperUser + : kwSuperuser + | kwNosuperuser + ; + +alterType + : kwAlter kwType (keyspace DOT)? type_ alterTypeOperation + ; + +alterTypeOperation + : alterTypeAlterType + | alterTypeAdd + | alterTypeRename + ; + +alterTypeRename + : kwRename alterTypeRenameList + ; + +alterTypeRenameList + : alterTypeRenameItem (kwAnd alterTypeRenameItem)* + ; + +alterTypeRenameItem + : column kwTo column + ; + +alterTypeAdd + : kwAdd column dataType (syntaxComma column dataType)* + ; + +alterTypeAlterType + : kwAlter column kwType dataType + ; + +alterTable + : kwAlter kwTable (keyspace DOT)? table alterTableOperation + ; + +alterTableOperation + : alterTableAdd + | alterTableDropColumns + | alterTableDropCompactStorage + | alterTableRename + | alterTableWith + ; + +alterTableWith + : kwWith tableOptions + ; + +alterTableRename + : kwRename column kwTo column + ; + +alterTableDropCompactStorage + : kwDrop kwCompact kwStorage + ; + +alterTableDropColumns + : kwDrop alterTableDropColumnList + ; + +alterTableDropColumnList + : column (syntaxComma column)* + ; + +alterTableAdd + : kwAdd alterTableColumnDefinition + ; + +alterTableColumnDefinition + : column dataType (syntaxComma column dataType)* + ; + +alterRole + : kwAlter kwRole role roleWith? + ; + +roleWith + : kwWith (roleWithOptions (kwAnd roleWithOptions)*) + ; + +roleWithOptions + : kwPassword OPERATOR_EQ stringLiteral + | kwLogin OPERATOR_EQ booleanLiteral + | kwSuperuser OPERATOR_EQ booleanLiteral + | kwOptions OPERATOR_EQ optionHash + ; + +alterMaterializedView + : kwAlter kwMaterialized kwView (keyspace DOT)? materializedView (kwWith tableOptions)? + ; + +dropUser + : kwDrop kwUser ifExist? user + ; + +dropType + : kwDrop kwType ifExist? (keyspace DOT)? type_ + ; + +dropMaterializedView + : kwDrop kwMaterialized kwView ifExist? (keyspace DOT)? materializedView + ; + +dropAggregate + : kwDrop kwAggregate ifExist? (keyspace DOT)? aggregate + ; + +dropFunction + : kwDrop kwFunction ifExist? (keyspace DOT)? function_ + ; + +dropTrigger + : kwDrop kwTrigger ifExist? trigger kwOn (keyspace DOT)? table + ; + +dropRole + : kwDrop kwRole ifExist? role + ; + +dropTable + : kwDrop kwTable ifExist? (keyspace DOT)? table + ; + +dropKeyspace + : kwDrop kwKeyspace ifExist? keyspace + ; + +dropIndex + : kwDrop kwIndex ifExist? (keyspace DOT)? indexName + ; + +createTable + : kwCreate kwTable ifNotExist? (keyspace DOT)? table syntaxBracketLr columnDefinitionList syntaxBracketRr withElement? + ; + +withElement + : kwWith tableOptions + ; + +tableOptions + : kwCompact kwStorage (kwAnd tableOptions)? + | clusteringOrder (kwAnd tableOptions)? + | tableOptionItem (kwAnd tableOptionItem)* + ; + +clusteringOrder + : kwClustering kwOrder kwBy syntaxBracketLr (column orderDirection?) (syntaxComma column orderDirection?)* syntaxBracketRr + ; + +tableOptionItem + : tableOptionName OPERATOR_EQ tableOptionValue + | tableOptionName OPERATOR_EQ optionHash + ; + +tableOptionName + : OBJECT_NAME + ; + +tableOptionValue + : stringLiteral + | floatLiteral + ; + +optionHash + : syntaxBracketLc optionHashItem (syntaxComma optionHashItem)* syntaxBracketRc + ; + +optionHashItem + : optionHashKey COLON optionHashValue + ; + +optionHashKey + : stringLiteral + ; + +optionHashValue + : stringLiteral + | floatLiteral + ; + +columnDefinitionList + : (columnDefinition) (syntaxComma columnDefinition)* (syntaxComma primaryKeyElement)? + ; + +// +columnDefinition + : column dataType primaryKeyColumn? + ; + +// +primaryKeyColumn + : kwPrimary kwKey + ; + +primaryKeyElement + : kwPrimary kwKey syntaxBracketLr primaryKeyDefinition syntaxBracketRr + ; + +primaryKeyDefinition + : singlePrimaryKey + | compoundKey + | compositeKey + ; + +singlePrimaryKey + : column + ; + +compoundKey + : partitionKey (syntaxComma clusteringKeyList) + ; + +compositeKey + : syntaxBracketLr partitionKeyList syntaxBracketRr (syntaxComma clusteringKeyList) + ; + +partitionKeyList + : (partitionKey) (syntaxComma partitionKey)* + ; + +clusteringKeyList + : (clusteringKey) (syntaxComma clusteringKey)* + ; + +partitionKey + : column + ; + +clusteringKey + : column + ; + +applyBatch + : kwApply kwBatch + ; + +beginBatch + : kwBegin batchType? kwBatch usingTimestampSpec? + ; + +batchType + : kwLogged + | kwUnlogged + ; + +alterKeyspace + : kwAlter kwKeyspace keyspace kwWith kwReplication OPERATOR_EQ syntaxBracketLc replicationList syntaxBracketRc ( + kwAnd durableWrites + )? + ; + +replicationList + : (replicationListItem) (syntaxComma replicationListItem)* + ; + +replicationListItem + : STRING_LITERAL COLON STRING_LITERAL + | STRING_LITERAL COLON DECIMAL_LITERAL + ; + +durableWrites + : kwDurableWrites OPERATOR_EQ booleanLiteral + ; + +use_ + : kwUse keyspace + ; + +truncate + : kwTruncate (kwTable)? (keyspace DOT)? table + ; + +createIndex + : kwCreate kwIndex ifNotExist? indexName? kwOn (keyspace DOT)? table syntaxBracketLr indexColumnSpec syntaxBracketRr + ; + +indexName + : OBJECT_NAME + | stringLiteral + ; + +indexColumnSpec + : column + | indexKeysSpec + | indexEntriesSSpec + | indexFullSpec + ; + +indexKeysSpec + : kwKeys syntaxBracketLr OBJECT_NAME syntaxBracketRr + ; + +indexEntriesSSpec + : kwEntries syntaxBracketLr OBJECT_NAME syntaxBracketRr + ; + +indexFullSpec + : kwFull syntaxBracketLr OBJECT_NAME syntaxBracketRr + ; + +delete_ + : beginBatch? kwDelete deleteColumnList? fromSpec usingTimestampSpec? whereSpec ( + ifExist + | ifSpec + )? + ; + +deleteColumnList + : (deleteColumnItem) (syntaxComma deleteColumnItem)* + ; + +deleteColumnItem + : OBJECT_NAME + | OBJECT_NAME LS_BRACKET (stringLiteral | decimalLiteral) RS_BRACKET + ; + +update + : beginBatch? kwUpdate (keyspace DOT)? table usingTtlTimestamp? kwSet assignments whereSpec ( + ifExist + | ifSpec + )? + ; + +ifSpec + : kwIf ifConditionList + ; + +ifConditionList + : (ifCondition) (kwAnd ifCondition)* + ; + +ifCondition + : OBJECT_NAME OPERATOR_EQ constant + ; + +assignments + : (assignmentElement) (syntaxComma assignmentElement)* + ; + +assignmentElement + : OBJECT_NAME OPERATOR_EQ (constant | assignmentMap | assignmentSet | assignmentList) + | OBJECT_NAME OPERATOR_EQ OBJECT_NAME (PLUS | MINUS) decimalLiteral + | OBJECT_NAME OPERATOR_EQ OBJECT_NAME (PLUS | MINUS) assignmentSet + | OBJECT_NAME OPERATOR_EQ assignmentSet (PLUS | MINUS) OBJECT_NAME + | OBJECT_NAME OPERATOR_EQ OBJECT_NAME (PLUS | MINUS) assignmentMap + | OBJECT_NAME OPERATOR_EQ assignmentMap (PLUS | MINUS) OBJECT_NAME + | OBJECT_NAME OPERATOR_EQ OBJECT_NAME (PLUS | MINUS) assignmentList + | OBJECT_NAME OPERATOR_EQ assignmentList (PLUS | MINUS) OBJECT_NAME + | OBJECT_NAME syntaxBracketLs decimalLiteral syntaxBracketRs OPERATOR_EQ constant + ; + +assignmentSet + : syntaxBracketLc (constant (syntaxComma constant)*)? syntaxBracketRc + ; + +assignmentMap + : syntaxBracketLc (constant syntaxColon constant) (syntaxComma constant syntaxColon constant)* syntaxBracketRc + ; + +assignmentList + : syntaxBracketLs constant (syntaxComma constant)* syntaxBracketRs + ; + +assignmentTuple + : syntaxBracketLr (expression (syntaxComma expression)*) syntaxBracketRr + ; + +insert + : beginBatch? kwInsert kwInto (keyspace DOT)? table insertColumnSpec? insertValuesSpec ifNotExist? usingTtlTimestamp? + ; + +usingTtlTimestamp + : kwUsing ttl + | kwUsing ttl kwAnd timestamp + | kwUsing timestamp + | kwUsing timestamp kwAnd ttl + ; + +timestamp + : kwTimestamp decimalLiteral + ; + +ttl + : kwTtl decimalLiteral + ; + +usingTimestampSpec + : kwUsing timestamp + ; + +ifNotExist + : kwIf kwNot kwExists + ; + +ifExist + : kwIf kwExists + ; + +insertValuesSpec + : kwValues '(' expressionList ')' + | kwJson constant + ; + +insertColumnSpec + : '(' columnList ')' + ; + +columnList + : column (syntaxComma column)* + ; + +expressionList + : expression (syntaxComma expression)* + ; + +expression + : constant + | functionCall + | assignmentMap + | assignmentSet + | assignmentList + | assignmentTuple + ; + +select_ + : kwSelect distinctSpec? kwJson? selectElements fromSpec whereSpec? orderSpec? limitSpec? allowFilteringSpec? + ; + +allowFilteringSpec + : kwAllow kwFiltering + ; + +limitSpec + : kwLimit decimalLiteral + ; + +fromSpec + : kwFrom fromSpecElement + ; + +fromSpecElement + : OBJECT_NAME + | OBJECT_NAME '.' OBJECT_NAME + ; + +orderSpec + : kwOrder kwBy orderSpecElement + ; + +orderSpecElement + : OBJECT_NAME (kwAsc | kwDesc)? + ; + +whereSpec + : kwWhere relationElements + ; + +distinctSpec + : kwDistinct + ; + +selectElements + : (star = '*' | selectElement) (syntaxComma selectElement)* + ; + +selectElement + : OBJECT_NAME '.' '*' + | OBJECT_NAME (kwAs OBJECT_NAME)? + | functionCall (kwAs OBJECT_NAME)? + ; + +relationElements + : (relationElement) (kwAnd relationElement)* + ; + +relationElement + : OBJECT_NAME (OPERATOR_EQ | OPERATOR_LT | OPERATOR_GT | OPERATOR_LTE | OPERATOR_GTE) constant + | OBJECT_NAME '.' OBJECT_NAME ( + OPERATOR_EQ + | OPERATOR_LT + | OPERATOR_GT + | OPERATOR_LTE + | OPERATOR_GTE + ) constant + | functionCall (OPERATOR_EQ | OPERATOR_LT | OPERATOR_GT | OPERATOR_LTE | OPERATOR_GTE) constant + | functionCall (OPERATOR_EQ | OPERATOR_LT | OPERATOR_GT | OPERATOR_LTE | OPERATOR_GTE) functionCall + | OBJECT_NAME kwIn '(' functionArgs? ')' + | '(' OBJECT_NAME (syntaxComma OBJECT_NAME)* ')' kwIn '(' assignmentTuple ( + syntaxComma assignmentTuple + )* ')' + | '(' OBJECT_NAME (syntaxComma OBJECT_NAME)* ')' ( + OPERATOR_EQ + | OPERATOR_LT + | OPERATOR_GT + | OPERATOR_LTE + | OPERATOR_GTE + ) (assignmentTuple (syntaxComma assignmentTuple)*) + | relalationContainsKey + | relalationContains + ; + +relalationContains + : OBJECT_NAME kwContains constant + ; + +relalationContainsKey + : OBJECT_NAME (kwContains kwKey) constant + ; + +functionCall + : OBJECT_NAME '(' STAR ')' + | OBJECT_NAME '(' functionArgs? ')' + | K_UUID '(' ')' + ; + +functionArgs + : (constant | OBJECT_NAME | functionCall) (syntaxComma (constant | OBJECT_NAME | functionCall))* + ; + +constant + : UUID + | stringLiteral + | decimalLiteral + | floatLiteral + | hexadecimalLiteral + | booleanLiteral + | codeBlock + | kwNull + ; + +decimalLiteral + : DECIMAL_LITERAL + ; + +floatLiteral + : DECIMAL_LITERAL + | FLOAT_LITERAL + ; + +stringLiteral + : STRING_LITERAL + ; + +booleanLiteral + : K_TRUE + | K_FALSE + ; + +hexadecimalLiteral + : HEXADECIMAL_LITERAL + ; + +keyspace + : OBJECT_NAME + | DQUOTE OBJECT_NAME DQUOTE + ; + +table + : OBJECT_NAME + | DQUOTE OBJECT_NAME DQUOTE + ; + +column + : OBJECT_NAME + | DQUOTE OBJECT_NAME DQUOTE + ; + +dataType + : dataTypeName dataTypeDefinition? + ; + +dataTypeName + : OBJECT_NAME + | K_TIMESTAMP + | K_SET + | K_ASCII + | K_BIGINT + | K_BLOB + | K_BOOLEAN + | K_COUNTER + | K_DATE + | K_DECIMAL + | K_DOUBLE + | K_FLOAT + | K_FROZEN + | K_INET + | K_INT + | K_LIST + | K_MAP + | K_SMALLINT + | K_TEXT + | K_TIME + | K_TIMEUUID + | K_TINYINT + | K_TUPLE + | K_VARCHAR + | K_VARINT + | K_TIMESTAMP + | K_UUID + ; + +dataTypeDefinition + : syntaxBracketLa dataTypeName (syntaxComma dataTypeName)* syntaxBracketRa + ; + +orderDirection + : kwAsc + | kwDesc + ; + +role + : OBJECT_NAME + ; + +trigger + : OBJECT_NAME + ; + +triggerClass + : stringLiteral + ; + +materializedView + : OBJECT_NAME + ; + +type_ + : OBJECT_NAME + ; + +aggregate + : OBJECT_NAME + ; + +function_ + : OBJECT_NAME + ; + +language + : OBJECT_NAME + ; + +user + : OBJECT_NAME + ; + +password + : stringLiteral + ; + +hashKey + : OBJECT_NAME + ; + +param + : paramName dataType + ; + +paramName + : OBJECT_NAME + | K_INPUT + ; + +kwAdd + : K_ADD + ; + +kwAggregate + : K_AGGREGATE + ; + +kwAll + : K_ALL + ; + +kwAllPermissions + : K_ALL K_PERMISSIONS + ; + +kwAllow + : K_ALLOW + ; + +kwAlter + : K_ALTER + ; + +kwAnd + : K_AND + ; + +kwApply + : K_APPLY + ; + +kwAs + : K_AS + ; + +kwAsc + : K_ASC + ; + +kwAuthorize + : K_AUTHORIZE + ; + +kwBatch + : K_BATCH + ; + +kwBegin + : K_BEGIN + ; + +kwBy + : K_BY + ; + +kwCalled + : K_CALLED + ; + +kwClustering + : K_CLUSTERING + ; + +kwCompact + : K_COMPACT + ; + +kwContains + : K_CONTAINS + ; + +kwCreate + : K_CREATE + ; + +kwDelete + : K_DELETE + ; + +kwDesc + : K_DESC + ; + +kwDescibe + : K_DESCRIBE + ; + +kwDistinct + : K_DISTINCT + ; + +kwDrop + : K_DROP + ; + +kwDurableWrites + : K_DURABLE_WRITES + ; + +kwEntries + : K_ENTRIES + ; + +kwExecute + : K_EXECUTE + ; + +kwExists + : K_EXISTS + ; + +kwFiltering + : K_FILTERING + ; + +kwFinalfunc + : K_FINALFUNC + ; + +kwFrom + : K_FROM + ; + +kwFull + : K_FULL + ; + +kwFunction + : K_FUNCTION + ; + +kwFunctions + : K_FUNCTIONS + ; + +kwGrant + : K_GRANT + ; + +kwIf + : K_IF + ; + +kwIn + : K_IN + ; + +kwIndex + : K_INDEX + ; + +kwInitcond + : K_INITCOND + ; + +kwInput + : K_INPUT + ; + +kwInsert + : K_INSERT + ; + +kwInto + : K_INTO + ; + +kwIs + : K_IS + ; + +kwJson + : K_JSON + ; + +kwKey + : K_KEY + ; + +kwKeys + : K_KEYS + ; + +kwKeyspace + : K_KEYSPACE + ; + +kwKeyspaces + : K_KEYSPACES + ; + +kwLanguage + : K_LANGUAGE + ; + +kwLimit + : K_LIMIT + ; + +kwList + : K_LIST + ; + +kwLogged + : K_LOGGED + ; + +kwLogin + : K_LOGIN + ; + +kwMaterialized + : K_MATERIALIZED + ; + +kwModify + : K_MODIFY + ; + +kwNosuperuser + : K_NOSUPERUSER + ; + +kwNorecursive + : K_NORECURSIVE + ; + +kwNot + : K_NOT + ; + +kwNull + : K_NULL + ; + +kwOf + : K_OF + ; + +kwOn + : K_ON + ; + +kwOptions + : K_OPTIONS + ; + +kwOr + : K_OR + ; + +kwOrder + : K_ORDER + ; + +kwPassword + : K_PASSWORD + ; + +kwPrimary + : K_PRIMARY + ; + +kwRename + : K_RENAME + ; + +kwReplace + : K_REPLACE + ; + +kwReplication + : K_REPLICATION + ; + +kwReturns + : K_RETURNS + ; + +kwRole + : K_ROLE + ; + +kwRoles + : K_ROLES + ; + +kwSelect + : K_SELECT + ; + +kwSet + : K_SET + ; + +kwSfunc + : K_SFUNC + ; + +kwStorage + : K_STORAGE + ; + +kwStype + : K_STYPE + ; + +kwSuperuser + : K_SUPERUSER + ; + +kwTable + : K_TABLE + ; + +kwTimestamp + : K_TIMESTAMP + ; + +kwTo + : K_TO + ; + +kwTrigger + : K_TRIGGER + ; + +kwTruncate + : K_TRUNCATE + ; + +kwTtl + : K_TTL + ; + +kwType + : K_TYPE + ; + +kwUnlogged + : K_UNLOGGED + ; + +kwUpdate + : K_UPDATE + ; + +kwUse + : K_USE + ; + +kwUser + : K_USER + ; + +kwUsing + : K_USING + ; + +kwValues + : K_VALUES + ; + +kwView + : K_VIEW + ; + +kwWhere + : K_WHERE + ; + +kwWith + : K_WITH + ; + +kwRevoke + : K_REVOKE + ; + +// BRACKETS +// L - left +// R - right +// a - angle +// c - curly +// r - rounded +syntaxBracketLr + : LR_BRACKET + ; + +syntaxBracketRr + : RR_BRACKET + ; + +syntaxBracketLc + : LC_BRACKET + ; + +syntaxBracketRc + : RC_BRACKET + ; + +syntaxBracketLa + : OPERATOR_LT + ; + +syntaxBracketRa + : OPERATOR_GT + ; + +syntaxBracketLs + : LS_BRACKET + ; + +syntaxBracketRs + : RS_BRACKET + ; + +syntaxComma + : COMMA + ; + +syntaxColon + : COLON + ; diff --git a/cql/Makefile b/cql/Makefile new file mode 100644 index 0000000..5f81b4e --- /dev/null +++ b/cql/Makefile @@ -0,0 +1,10 @@ +all: build test + +build: + antlr -Dlanguage=Go -package cql -visitor -o . CqlLexer.g4 CqlParser.g4 + +test: + go test -v -run TestCqlParser + +clean: + rm -f *.go *.tokens *.interp \ No newline at end of file diff --git a/cql/README.md b/cql/README.md new file mode 100644 index 0000000..19a753e --- /dev/null +++ b/cql/README.md @@ -0,0 +1,51 @@ +# CQL Parser + +ANTLR4-based parser for Cassandra Query Language (CQL). + +## Overview + +This parser supports CQL3 syntax as used by: +- Apache Cassandra +- ScyllaDB +- Amazon Keyspaces +- DataStax Astra + +## Usage + +```go +import "github.com/bytebase/parser/cql" + +// Parse a CQL statement +tree, err := cql.ParseCQL("SELECT * FROM users WHERE id = 123;") +if err != nil { + // Handle parsing error + log.Fatal(err) +} +``` + +## Grammar Source + +The grammar files are from the official ANTLR grammars repository: +- https://github.com/antlr/grammars-v4/tree/master/cql3 + +## Building + +```bash +make build # Generate Go files from ANTLR grammars +make test # Run tests +make clean # Clean generated files +``` + +## Testing + +The parser is tested against 38 official CQL example files covering: +- DDL statements (CREATE, ALTER, DROP for keyspaces, tables, indexes, etc.) +- DML statements (INSERT, UPDATE, DELETE, SELECT) +- DCL statements (GRANT, REVOKE, LIST PERMISSIONS) +- Batch operations +- User-defined types, functions, and aggregates +- Materialized views + +## Performance + +Average parsing time: ~14 microseconds per statement \ No newline at end of file diff --git a/cql/cql_lexer.go b/cql/cql_lexer.go new file mode 100644 index 0000000..ede8dcf --- /dev/null +++ b/cql/cql_lexer.go @@ -0,0 +1,1066 @@ +// Code generated from CqlLexer.g4 by ANTLR 4.13.2. DO NOT EDIT. + +package cql + +import ( + "fmt" + "github.com/antlr4-go/antlr/v4" + "sync" + "unicode" +) + +// Suppress unused import error +var _ = fmt.Printf +var _ = sync.Once{} +var _ = unicode.IsLetter + +type CqlLexer struct { + *antlr.BaseLexer + channelNames []string + modeNames []string + // TODO: EOF string +} + +var CqlLexerLexerStaticData struct { + once sync.Once + serializedATN []int32 + ChannelNames []string + ModeNames []string + LiteralNames []string + SymbolicNames []string + RuleNames []string + PredictionContextCache *antlr.PredictionContextCache + atn *antlr.ATN + decisionToDFA []*antlr.DFA +} + +func cqllexerLexerInit() { + staticData := &CqlLexerLexerStaticData + staticData.ChannelNames = []string{ + "DEFAULT_TOKEN_CHANNEL", "HIDDEN", + } + staticData.ModeNames = []string{ + "DEFAULT_MODE", + } + staticData.LiteralNames = []string{ + "", "'('", "')'", "'{'", "'}'", "'['", "']'", "','", "';'", "':'", "'.'", + "'*'", "'/'", "'%'", "'+'", "'--'", "'-'", "'\"'", "'''", "'='", "'<'", + "'>'", "'<='", "'>='", "'ADD'", "'AGGREGATE'", "'ALL'", "'ALLOW'", "'ALTER'", + "'AND'", "'ANY'", "'APPLY'", "'AS'", "'ASC'", "'AUTHORIZE'", "'BATCH'", + "'BEGIN'", "'BY'", "'CALLED'", "'CLUSTERING'", "'COLUMNFAMILY'", "'COMPACT'", + "'CONSISTENCY'", "'CONTAINS'", "'CREATE'", "'CUSTOM'", "'DELETE'", "'DESC'", + "'DESCRIBE'", "'DISTINCT'", "'DROP'", "'DURABLE_WRITES'", "'EACH_QUORUM'", + "'ENTRIES'", "'EXECUTE'", "'EXISTS'", "'FALSE'", "'FILTERING'", "'FINALFUNC'", + "'FROM'", "'FULL'", "'FUNCTION'", "'FUNCTIONS'", "'GRANT'", "'IF'", + "'IN'", "'INDEX'", "'INFINITY'", "'INITCOND'", "'INPUT'", "'INSERT'", + "'INTO'", "'IS'", "'JSON'", "'KEY'", "'KEYS'", "'KEYSPACE'", "'KEYSPACES'", + "'LANGUAGE'", "'LEVEL'", "'LIMIT'", "'LOCAL_ONE'", "'LOCAL_QUORUM'", + "'LOGGED'", "'LOGIN'", "'MATERIALIZED'", "'MODIFY'", "'NAN'", "'NORECURSIVE'", + "'NOSUPERUSER'", "'NOT'", "'NULL'", "'OF'", "'ON'", "'ONE'", "'OPTIONS'", + "'OR'", "'ORDER'", "'PARTITION'", "'PASSWORD'", "'PER'", "'PERMISSION'", + "'PERMISSIONS'", "'PRIMARY'", "'QUORUM'", "'RENAME'", "'REPLACE'", "'REPLICATION'", + "'RETURNS'", "'REVOKE'", "'ROLE'", "'ROLES'", "'SCHEMA'", "'SELECT'", + "'SET'", "'SFUNC'", "'STATIC'", "'STORAGE'", "'STYPE'", "'SUPERUSER'", + "'TABLE'", "'THREE'", "'TIMESTAMP'", "'TO'", "'TOKEN'", "'TRIGGER'", + "'TRUE'", "'TRUNCATE'", "'TTL'", "'TWO'", "'TYPE'", "'UNLOGGED'", "'UPDATE'", + "'USE'", "'USER'", "'USING'", "'UUID'", "'VALUES'", "'VIEW'", "'WHERE'", + "'WITH'", "'WRITETIME'", "'ASCII'", "'BIGINT'", "'BLOB'", "'BOOLEAN'", + "'COUNTER'", "'DATE'", "'DECIMAL'", "'DOUBLE'", "'FLOAT'", "'FROZEN'", + "'INET'", "'INT'", "'LIST'", "'MAP'", "'SMALLINT'", "'TEXT'", "'TIMEUUID'", + "'TIME'", "'TINYINT'", "'TUPLE'", "'VARCHAR'", "'VARINT'", + } + staticData.SymbolicNames = []string{ + "", "LR_BRACKET", "RR_BRACKET", "LC_BRACKET", "RC_BRACKET", "LS_BRACKET", + "RS_BRACKET", "COMMA", "SEMI", "COLON", "DOT", "STAR", "DIVIDE", "MODULE", + "PLUS", "MINUSMINUS", "MINUS", "DQUOTE", "SQUOTE", "OPERATOR_EQ", "OPERATOR_LT", + "OPERATOR_GT", "OPERATOR_LTE", "OPERATOR_GTE", "K_ADD", "K_AGGREGATE", + "K_ALL", "K_ALLOW", "K_ALTER", "K_AND", "K_ANY", "K_APPLY", "K_AS", + "K_ASC", "K_AUTHORIZE", "K_BATCH", "K_BEGIN", "K_BY", "K_CALLED", "K_CLUSTERING", + "K_COLUMNFAMILY", "K_COMPACT", "K_CONSISTENCY", "K_CONTAINS", "K_CREATE", + "K_CUSTOM", "K_DELETE", "K_DESC", "K_DESCRIBE", "K_DISTINCT", "K_DROP", + "K_DURABLE_WRITES", "K_EACH_QUORUM", "K_ENTRIES", "K_EXECUTE", "K_EXISTS", + "K_FALSE", "K_FILTERING", "K_FINALFUNC", "K_FROM", "K_FULL", "K_FUNCTION", + "K_FUNCTIONS", "K_GRANT", "K_IF", "K_IN", "K_INDEX", "K_INFINITY", "K_INITCOND", + "K_INPUT", "K_INSERT", "K_INTO", "K_IS", "K_JSON", "K_KEY", "K_KEYS", + "K_KEYSPACE", "K_KEYSPACES", "K_LANGUAGE", "K_LEVEL", "K_LIMIT", "K_LOCAL_ONE", + "K_LOCAL_QUORUM", "K_LOGGED", "K_LOGIN", "K_MATERIALIZED", "K_MODIFY", + "K_NAN", "K_NORECURSIVE", "K_NOSUPERUSER", "K_NOT", "K_NULL", "K_OF", + "K_ON", "K_ONE", "K_OPTIONS", "K_OR", "K_ORDER", "K_PARTITION", "K_PASSWORD", + "K_PER", "K_PERMISSION", "K_PERMISSIONS", "K_PRIMARY", "K_QUORUM", "K_RENAME", + "K_REPLACE", "K_REPLICATION", "K_RETURNS", "K_REVOKE", "K_ROLE", "K_ROLES", + "K_SCHEMA", "K_SELECT", "K_SET", "K_SFUNC", "K_STATIC", "K_STORAGE", + "K_STYPE", "K_SUPERUSER", "K_TABLE", "K_THREE", "K_TIMESTAMP", "K_TO", + "K_TOKEN", "K_TRIGGER", "K_TRUE", "K_TRUNCATE", "K_TTL", "K_TWO", "K_TYPE", + "K_UNLOGGED", "K_UPDATE", "K_USE", "K_USER", "K_USING", "K_UUID", "K_VALUES", + "K_VIEW", "K_WHERE", "K_WITH", "K_WRITETIME", "K_ASCII", "K_BIGINT", + "K_BLOB", "K_BOOLEAN", "K_COUNTER", "K_DATE", "K_DECIMAL", "K_DOUBLE", + "K_FLOAT", "K_FROZEN", "K_INET", "K_INT", "K_LIST", "K_MAP", "K_SMALLINT", + "K_TEXT", "K_TIMEUUID", "K_TIME", "K_TINYINT", "K_TUPLE", "K_VARCHAR", + "K_VARINT", "CODE_BLOCK", "STRING_LITERAL", "DECIMAL_LITERAL", "FLOAT_LITERAL", + "HEXADECIMAL_LITERAL", "REAL_LITERAL", "OBJECT_NAME", "UUID", "SPACE", + "SPEC_MYSQL_COMMENT", "COMMENT_INPUT", "LINE_COMMENT", + } + staticData.RuleNames = []string{ + "LR_BRACKET", "RR_BRACKET", "LC_BRACKET", "RC_BRACKET", "LS_BRACKET", + "RS_BRACKET", "COMMA", "SEMI", "COLON", "DOT", "STAR", "DIVIDE", "MODULE", + "PLUS", "MINUSMINUS", "MINUS", "DQUOTE", "SQUOTE", "OPERATOR_EQ", "OPERATOR_LT", + "OPERATOR_GT", "OPERATOR_LTE", "OPERATOR_GTE", "K_ADD", "K_AGGREGATE", + "K_ALL", "K_ALLOW", "K_ALTER", "K_AND", "K_ANY", "K_APPLY", "K_AS", + "K_ASC", "K_AUTHORIZE", "K_BATCH", "K_BEGIN", "K_BY", "K_CALLED", "K_CLUSTERING", + "K_COLUMNFAMILY", "K_COMPACT", "K_CONSISTENCY", "K_CONTAINS", "K_CREATE", + "K_CUSTOM", "K_DELETE", "K_DESC", "K_DESCRIBE", "K_DISTINCT", "K_DROP", + "K_DURABLE_WRITES", "K_EACH_QUORUM", "K_ENTRIES", "K_EXECUTE", "K_EXISTS", + "K_FALSE", "K_FILTERING", "K_FINALFUNC", "K_FROM", "K_FULL", "K_FUNCTION", + "K_FUNCTIONS", "K_GRANT", "K_IF", "K_IN", "K_INDEX", "K_INFINITY", "K_INITCOND", + "K_INPUT", "K_INSERT", "K_INTO", "K_IS", "K_JSON", "K_KEY", "K_KEYS", + "K_KEYSPACE", "K_KEYSPACES", "K_LANGUAGE", "K_LEVEL", "K_LIMIT", "K_LOCAL_ONE", + "K_LOCAL_QUORUM", "K_LOGGED", "K_LOGIN", "K_MATERIALIZED", "K_MODIFY", + "K_NAN", "K_NORECURSIVE", "K_NOSUPERUSER", "K_NOT", "K_NULL", "K_OF", + "K_ON", "K_ONE", "K_OPTIONS", "K_OR", "K_ORDER", "K_PARTITION", "K_PASSWORD", + "K_PER", "K_PERMISSION", "K_PERMISSIONS", "K_PRIMARY", "K_QUORUM", "K_RENAME", + "K_REPLACE", "K_REPLICATION", "K_RETURNS", "K_REVOKE", "K_ROLE", "K_ROLES", + "K_SCHEMA", "K_SELECT", "K_SET", "K_SFUNC", "K_STATIC", "K_STORAGE", + "K_STYPE", "K_SUPERUSER", "K_TABLE", "K_THREE", "K_TIMESTAMP", "K_TO", + "K_TOKEN", "K_TRIGGER", "K_TRUE", "K_TRUNCATE", "K_TTL", "K_TWO", "K_TYPE", + "K_UNLOGGED", "K_UPDATE", "K_USE", "K_USER", "K_USING", "K_UUID", "K_VALUES", + "K_VIEW", "K_WHERE", "K_WITH", "K_WRITETIME", "K_ASCII", "K_BIGINT", + "K_BLOB", "K_BOOLEAN", "K_COUNTER", "K_DATE", "K_DECIMAL", "K_DOUBLE", + "K_FLOAT", "K_FROZEN", "K_INET", "K_INT", "K_LIST", "K_MAP", "K_SMALLINT", + "K_TEXT", "K_TIMEUUID", "K_TIME", "K_TINYINT", "K_TUPLE", "K_VARCHAR", + "K_VARINT", "CODE_BLOCK", "STRING_LITERAL", "DECIMAL_LITERAL", "FLOAT_LITERAL", + "HEXADECIMAL_LITERAL", "REAL_LITERAL", "OBJECT_NAME", "UUID", "SPACE", + "SPEC_MYSQL_COMMENT", "COMMENT_INPUT", "LINE_COMMENT", "HEX_4DIGIT", + "HEX_DIGIT", "DEC_DIGIT", "EXPONENT_NUM_PART", + } + staticData.PredictionContextCache = antlr.NewPredictionContextCache() + staticData.serializedATN = []int32{ + 4, 0, 175, 1588, 6, -1, 2, 0, 7, 0, 2, 1, 7, 1, 2, 2, 7, 2, 2, 3, 7, 3, + 2, 4, 7, 4, 2, 5, 7, 5, 2, 6, 7, 6, 2, 7, 7, 7, 2, 8, 7, 8, 2, 9, 7, 9, + 2, 10, 7, 10, 2, 11, 7, 11, 2, 12, 7, 12, 2, 13, 7, 13, 2, 14, 7, 14, 2, + 15, 7, 15, 2, 16, 7, 16, 2, 17, 7, 17, 2, 18, 7, 18, 2, 19, 7, 19, 2, 20, + 7, 20, 2, 21, 7, 21, 2, 22, 7, 22, 2, 23, 7, 23, 2, 24, 7, 24, 2, 25, 7, + 25, 2, 26, 7, 26, 2, 27, 7, 27, 2, 28, 7, 28, 2, 29, 7, 29, 2, 30, 7, 30, + 2, 31, 7, 31, 2, 32, 7, 32, 2, 33, 7, 33, 2, 34, 7, 34, 2, 35, 7, 35, 2, + 36, 7, 36, 2, 37, 7, 37, 2, 38, 7, 38, 2, 39, 7, 39, 2, 40, 7, 40, 2, 41, + 7, 41, 2, 42, 7, 42, 2, 43, 7, 43, 2, 44, 7, 44, 2, 45, 7, 45, 2, 46, 7, + 46, 2, 47, 7, 47, 2, 48, 7, 48, 2, 49, 7, 49, 2, 50, 7, 50, 2, 51, 7, 51, + 2, 52, 7, 52, 2, 53, 7, 53, 2, 54, 7, 54, 2, 55, 7, 55, 2, 56, 7, 56, 2, + 57, 7, 57, 2, 58, 7, 58, 2, 59, 7, 59, 2, 60, 7, 60, 2, 61, 7, 61, 2, 62, + 7, 62, 2, 63, 7, 63, 2, 64, 7, 64, 2, 65, 7, 65, 2, 66, 7, 66, 2, 67, 7, + 67, 2, 68, 7, 68, 2, 69, 7, 69, 2, 70, 7, 70, 2, 71, 7, 71, 2, 72, 7, 72, + 2, 73, 7, 73, 2, 74, 7, 74, 2, 75, 7, 75, 2, 76, 7, 76, 2, 77, 7, 77, 2, + 78, 7, 78, 2, 79, 7, 79, 2, 80, 7, 80, 2, 81, 7, 81, 2, 82, 7, 82, 2, 83, + 7, 83, 2, 84, 7, 84, 2, 85, 7, 85, 2, 86, 7, 86, 2, 87, 7, 87, 2, 88, 7, + 88, 2, 89, 7, 89, 2, 90, 7, 90, 2, 91, 7, 91, 2, 92, 7, 92, 2, 93, 7, 93, + 2, 94, 7, 94, 2, 95, 7, 95, 2, 96, 7, 96, 2, 97, 7, 97, 2, 98, 7, 98, 2, + 99, 7, 99, 2, 100, 7, 100, 2, 101, 7, 101, 2, 102, 7, 102, 2, 103, 7, 103, + 2, 104, 7, 104, 2, 105, 7, 105, 2, 106, 7, 106, 2, 107, 7, 107, 2, 108, + 7, 108, 2, 109, 7, 109, 2, 110, 7, 110, 2, 111, 7, 111, 2, 112, 7, 112, + 2, 113, 7, 113, 2, 114, 7, 114, 2, 115, 7, 115, 2, 116, 7, 116, 2, 117, + 7, 117, 2, 118, 7, 118, 2, 119, 7, 119, 2, 120, 7, 120, 2, 121, 7, 121, + 2, 122, 7, 122, 2, 123, 7, 123, 2, 124, 7, 124, 2, 125, 7, 125, 2, 126, + 7, 126, 2, 127, 7, 127, 2, 128, 7, 128, 2, 129, 7, 129, 2, 130, 7, 130, + 2, 131, 7, 131, 2, 132, 7, 132, 2, 133, 7, 133, 2, 134, 7, 134, 2, 135, + 7, 135, 2, 136, 7, 136, 2, 137, 7, 137, 2, 138, 7, 138, 2, 139, 7, 139, + 2, 140, 7, 140, 2, 141, 7, 141, 2, 142, 7, 142, 2, 143, 7, 143, 2, 144, + 7, 144, 2, 145, 7, 145, 2, 146, 7, 146, 2, 147, 7, 147, 2, 148, 7, 148, + 2, 149, 7, 149, 2, 150, 7, 150, 2, 151, 7, 151, 2, 152, 7, 152, 2, 153, + 7, 153, 2, 154, 7, 154, 2, 155, 7, 155, 2, 156, 7, 156, 2, 157, 7, 157, + 2, 158, 7, 158, 2, 159, 7, 159, 2, 160, 7, 160, 2, 161, 7, 161, 2, 162, + 7, 162, 2, 163, 7, 163, 2, 164, 7, 164, 2, 165, 7, 165, 2, 166, 7, 166, + 2, 167, 7, 167, 2, 168, 7, 168, 2, 169, 7, 169, 2, 170, 7, 170, 2, 171, + 7, 171, 2, 172, 7, 172, 2, 173, 7, 173, 2, 174, 7, 174, 2, 175, 7, 175, + 2, 176, 7, 176, 2, 177, 7, 177, 2, 178, 7, 178, 1, 0, 1, 0, 1, 1, 1, 1, + 1, 2, 1, 2, 1, 3, 1, 3, 1, 4, 1, 4, 1, 5, 1, 5, 1, 6, 1, 6, 1, 7, 1, 7, + 1, 8, 1, 8, 1, 9, 1, 9, 1, 10, 1, 10, 1, 11, 1, 11, 1, 12, 1, 12, 1, 13, + 1, 13, 1, 14, 1, 14, 1, 14, 1, 15, 1, 15, 1, 16, 1, 16, 1, 17, 1, 17, 1, + 18, 1, 18, 1, 19, 1, 19, 1, 20, 1, 20, 1, 21, 1, 21, 1, 21, 1, 22, 1, 22, + 1, 22, 1, 23, 1, 23, 1, 23, 1, 23, 1, 24, 1, 24, 1, 24, 1, 24, 1, 24, 1, + 24, 1, 24, 1, 24, 1, 24, 1, 24, 1, 25, 1, 25, 1, 25, 1, 25, 1, 26, 1, 26, + 1, 26, 1, 26, 1, 26, 1, 26, 1, 27, 1, 27, 1, 27, 1, 27, 1, 27, 1, 27, 1, + 28, 1, 28, 1, 28, 1, 28, 1, 29, 1, 29, 1, 29, 1, 29, 1, 30, 1, 30, 1, 30, + 1, 30, 1, 30, 1, 30, 1, 31, 1, 31, 1, 31, 1, 32, 1, 32, 1, 32, 1, 32, 1, + 33, 1, 33, 1, 33, 1, 33, 1, 33, 1, 33, 1, 33, 1, 33, 1, 33, 1, 33, 1, 34, + 1, 34, 1, 34, 1, 34, 1, 34, 1, 34, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, + 35, 1, 36, 1, 36, 1, 36, 1, 37, 1, 37, 1, 37, 1, 37, 1, 37, 1, 37, 1, 37, + 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, + 38, 1, 39, 1, 39, 1, 39, 1, 39, 1, 39, 1, 39, 1, 39, 1, 39, 1, 39, 1, 39, + 1, 39, 1, 39, 1, 39, 1, 40, 1, 40, 1, 40, 1, 40, 1, 40, 1, 40, 1, 40, 1, + 40, 1, 41, 1, 41, 1, 41, 1, 41, 1, 41, 1, 41, 1, 41, 1, 41, 1, 41, 1, 41, + 1, 41, 1, 41, 1, 42, 1, 42, 1, 42, 1, 42, 1, 42, 1, 42, 1, 42, 1, 42, 1, + 42, 1, 43, 1, 43, 1, 43, 1, 43, 1, 43, 1, 43, 1, 43, 1, 44, 1, 44, 1, 44, + 1, 44, 1, 44, 1, 44, 1, 44, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, + 45, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, + 1, 47, 1, 47, 1, 47, 1, 47, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, + 48, 1, 48, 1, 48, 1, 49, 1, 49, 1, 49, 1, 49, 1, 49, 1, 50, 1, 50, 1, 50, + 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, + 50, 1, 50, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, + 1, 51, 1, 51, 1, 51, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, + 52, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 54, 1, 54, + 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, + 55, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, + 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 1, + 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 59, 1, 59, 1, 59, 1, 59, 1, 59, 1, 60, + 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 61, 1, 61, 1, + 61, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 1, 62, 1, 62, 1, 62, + 1, 62, 1, 62, 1, 62, 1, 63, 1, 63, 1, 63, 1, 64, 1, 64, 1, 64, 1, 65, 1, + 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, + 1, 66, 1, 66, 1, 66, 1, 67, 1, 67, 1, 67, 1, 67, 1, 67, 1, 67, 1, 67, 1, + 67, 1, 67, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 69, 1, 69, 1, 69, + 1, 69, 1, 69, 1, 69, 1, 69, 1, 70, 1, 70, 1, 70, 1, 70, 1, 70, 1, 71, 1, + 71, 1, 71, 1, 72, 1, 72, 1, 72, 1, 72, 1, 72, 1, 73, 1, 73, 1, 73, 1, 73, + 1, 74, 1, 74, 1, 74, 1, 74, 1, 74, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, + 75, 1, 75, 1, 75, 1, 75, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, + 1, 76, 1, 76, 1, 76, 1, 77, 1, 77, 1, 77, 1, 77, 1, 77, 1, 77, 1, 77, 1, + 77, 1, 77, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 79, 1, 79, 1, 79, + 1, 79, 1, 79, 1, 79, 1, 80, 1, 80, 1, 80, 1, 80, 1, 80, 1, 80, 1, 80, 1, + 80, 1, 80, 1, 80, 1, 81, 1, 81, 1, 81, 1, 81, 1, 81, 1, 81, 1, 81, 1, 81, + 1, 81, 1, 81, 1, 81, 1, 81, 1, 81, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, + 82, 1, 82, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 84, 1, 84, 1, 84, + 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, + 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 86, 1, 86, 1, 86, 1, 86, + 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, + 87, 1, 87, 1, 88, 1, 88, 1, 88, 1, 88, 1, 88, 1, 88, 1, 88, 1, 88, 1, 88, + 1, 88, 1, 88, 1, 88, 1, 89, 1, 89, 1, 89, 1, 89, 1, 90, 1, 90, 1, 90, 1, + 90, 1, 90, 1, 91, 1, 91, 1, 91, 1, 92, 1, 92, 1, 92, 1, 93, 1, 93, 1, 93, + 1, 93, 1, 94, 1, 94, 1, 94, 1, 94, 1, 94, 1, 94, 1, 94, 1, 94, 1, 95, 1, + 95, 1, 95, 1, 96, 1, 96, 1, 96, 1, 96, 1, 96, 1, 96, 1, 97, 1, 97, 1, 97, + 1, 97, 1, 97, 1, 97, 1, 97, 1, 97, 1, 97, 1, 97, 1, 98, 1, 98, 1, 98, 1, + 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 99, 1, 99, 1, 99, 1, 99, 1, 100, + 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, + 1, 100, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, + 1, 101, 1, 101, 1, 101, 1, 101, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, + 1, 102, 1, 102, 1, 102, 1, 103, 1, 103, 1, 103, 1, 103, 1, 103, 1, 103, + 1, 103, 1, 104, 1, 104, 1, 104, 1, 104, 1, 104, 1, 104, 1, 104, 1, 105, + 1, 105, 1, 105, 1, 105, 1, 105, 1, 105, 1, 105, 1, 105, 1, 106, 1, 106, + 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, + 1, 106, 1, 107, 1, 107, 1, 107, 1, 107, 1, 107, 1, 107, 1, 107, 1, 107, + 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 109, 1, 109, + 1, 109, 1, 109, 1, 109, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, + 1, 111, 1, 111, 1, 111, 1, 111, 1, 111, 1, 111, 1, 111, 1, 112, 1, 112, + 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 113, 1, 113, 1, 113, 1, 113, + 1, 114, 1, 114, 1, 114, 1, 114, 1, 114, 1, 114, 1, 115, 1, 115, 1, 115, + 1, 115, 1, 115, 1, 115, 1, 115, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, + 1, 116, 1, 116, 1, 116, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, + 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, + 1, 118, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 1, 120, 1, 120, + 1, 120, 1, 120, 1, 120, 1, 120, 1, 121, 1, 121, 1, 121, 1, 121, 1, 121, + 1, 121, 1, 121, 1, 121, 1, 121, 1, 121, 1, 122, 1, 122, 1, 122, 1, 123, + 1, 123, 1, 123, 1, 123, 1, 123, 1, 123, 1, 124, 1, 124, 1, 124, 1, 124, + 1, 124, 1, 124, 1, 124, 1, 124, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, + 1, 126, 1, 126, 1, 126, 1, 126, 1, 126, 1, 126, 1, 126, 1, 126, 1, 126, + 1, 127, 1, 127, 1, 127, 1, 127, 1, 128, 1, 128, 1, 128, 1, 128, 1, 129, + 1, 129, 1, 129, 1, 129, 1, 129, 1, 130, 1, 130, 1, 130, 1, 130, 1, 130, + 1, 130, 1, 130, 1, 130, 1, 130, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, + 1, 131, 1, 131, 1, 132, 1, 132, 1, 132, 1, 132, 1, 133, 1, 133, 1, 133, + 1, 133, 1, 133, 1, 134, 1, 134, 1, 134, 1, 134, 1, 134, 1, 134, 1, 135, + 1, 135, 1, 135, 1, 135, 1, 135, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, + 1, 136, 1, 136, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 138, 1, 138, + 1, 138, 1, 138, 1, 138, 1, 138, 1, 139, 1, 139, 1, 139, 1, 139, 1, 139, + 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, + 1, 140, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 142, 1, 142, + 1, 142, 1, 142, 1, 142, 1, 142, 1, 142, 1, 143, 1, 143, 1, 143, 1, 143, + 1, 143, 1, 144, 1, 144, 1, 144, 1, 144, 1, 144, 1, 144, 1, 144, 1, 144, + 1, 145, 1, 145, 1, 145, 1, 145, 1, 145, 1, 145, 1, 145, 1, 145, 1, 146, + 1, 146, 1, 146, 1, 146, 1, 146, 1, 147, 1, 147, 1, 147, 1, 147, 1, 147, + 1, 147, 1, 147, 1, 147, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, + 1, 148, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 150, 1, 150, + 1, 150, 1, 150, 1, 150, 1, 150, 1, 150, 1, 151, 1, 151, 1, 151, 1, 151, + 1, 151, 1, 152, 1, 152, 1, 152, 1, 152, 1, 153, 1, 153, 1, 153, 1, 153, + 1, 153, 1, 154, 1, 154, 1, 154, 1, 154, 1, 155, 1, 155, 1, 155, 1, 155, + 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 156, 1, 156, 1, 156, 1, 156, + 1, 156, 1, 157, 1, 157, 1, 157, 1, 157, 1, 157, 1, 157, 1, 157, 1, 157, + 1, 157, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 159, 1, 159, 1, 159, + 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 160, 1, 160, 1, 160, 1, 160, + 1, 160, 1, 160, 1, 161, 1, 161, 1, 161, 1, 161, 1, 161, 1, 161, 1, 161, + 1, 161, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 163, + 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 5, 163, 1382, 8, 163, 10, 163, + 12, 163, 1385, 9, 163, 1, 163, 1, 163, 1, 163, 1, 164, 1, 164, 1, 164, + 1, 164, 1, 164, 1, 164, 5, 164, 1396, 8, 164, 10, 164, 12, 164, 1399, 9, + 164, 1, 164, 1, 164, 1, 165, 4, 165, 1404, 8, 165, 11, 165, 12, 165, 1405, + 1, 166, 3, 166, 1409, 8, 166, 1, 166, 4, 166, 1412, 8, 166, 11, 166, 12, + 166, 1413, 1, 166, 1, 166, 4, 166, 1418, 8, 166, 11, 166, 12, 166, 1419, + 3, 166, 1422, 8, 166, 1, 167, 1, 167, 1, 167, 1, 167, 1, 167, 4, 167, 1429, + 8, 167, 11, 167, 12, 167, 1430, 1, 167, 1, 167, 1, 167, 1, 167, 1, 167, + 1, 167, 4, 167, 1439, 8, 167, 11, 167, 12, 167, 1440, 3, 167, 1443, 8, + 167, 1, 168, 4, 168, 1446, 8, 168, 11, 168, 12, 168, 1447, 1, 168, 3, 168, + 1451, 8, 168, 1, 168, 1, 168, 1, 168, 5, 168, 1456, 8, 168, 10, 168, 12, + 168, 1459, 9, 168, 1, 168, 1, 168, 4, 168, 1463, 8, 168, 11, 168, 12, 168, + 1464, 1, 168, 3, 168, 1468, 8, 168, 3, 168, 1470, 8, 168, 1, 169, 1, 169, + 5, 169, 1474, 8, 169, 10, 169, 12, 169, 1477, 9, 169, 1, 169, 1, 169, 4, + 169, 1481, 8, 169, 11, 169, 12, 169, 1482, 1, 169, 3, 169, 1486, 8, 169, + 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, + 1, 170, 1, 170, 1, 170, 1, 170, 1, 171, 4, 171, 1502, 8, 171, 11, 171, + 12, 171, 1503, 1, 171, 1, 171, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, + 4, 172, 1513, 8, 172, 11, 172, 12, 172, 1514, 1, 172, 1, 172, 1, 172, 1, + 172, 1, 172, 1, 173, 1, 173, 1, 173, 1, 173, 5, 173, 1526, 8, 173, 10, + 173, 12, 173, 1529, 9, 173, 1, 173, 1, 173, 1, 173, 1, 173, 1, 173, 1, + 174, 1, 174, 1, 174, 1, 174, 1, 174, 1, 174, 3, 174, 1542, 8, 174, 1, 174, + 5, 174, 1545, 8, 174, 10, 174, 12, 174, 1548, 9, 174, 1, 174, 3, 174, 1551, + 8, 174, 1, 174, 1, 174, 3, 174, 1555, 8, 174, 1, 174, 1, 174, 1, 174, 1, + 174, 3, 174, 1561, 8, 174, 1, 174, 1, 174, 3, 174, 1565, 8, 174, 3, 174, + 1567, 8, 174, 1, 174, 1, 174, 1, 175, 1, 175, 1, 175, 1, 175, 1, 175, 1, + 176, 1, 176, 1, 177, 1, 177, 1, 178, 1, 178, 3, 178, 1582, 8, 178, 1, 178, + 4, 178, 1585, 8, 178, 11, 178, 12, 178, 1586, 2, 1514, 1527, 0, 179, 1, + 1, 3, 2, 5, 3, 7, 4, 9, 5, 11, 6, 13, 7, 15, 8, 17, 9, 19, 10, 21, 11, + 23, 12, 25, 13, 27, 14, 29, 15, 31, 16, 33, 17, 35, 18, 37, 19, 39, 20, + 41, 21, 43, 22, 45, 23, 47, 24, 49, 25, 51, 26, 53, 27, 55, 28, 57, 29, + 59, 30, 61, 31, 63, 32, 65, 33, 67, 34, 69, 35, 71, 36, 73, 37, 75, 38, + 77, 39, 79, 40, 81, 41, 83, 42, 85, 43, 87, 44, 89, 45, 91, 46, 93, 47, + 95, 48, 97, 49, 99, 50, 101, 51, 103, 52, 105, 53, 107, 54, 109, 55, 111, + 56, 113, 57, 115, 58, 117, 59, 119, 60, 121, 61, 123, 62, 125, 63, 127, + 64, 129, 65, 131, 66, 133, 67, 135, 68, 137, 69, 139, 70, 141, 71, 143, + 72, 145, 73, 147, 74, 149, 75, 151, 76, 153, 77, 155, 78, 157, 79, 159, + 80, 161, 81, 163, 82, 165, 83, 167, 84, 169, 85, 171, 86, 173, 87, 175, + 88, 177, 89, 179, 90, 181, 91, 183, 92, 185, 93, 187, 94, 189, 95, 191, + 96, 193, 97, 195, 98, 197, 99, 199, 100, 201, 101, 203, 102, 205, 103, + 207, 104, 209, 105, 211, 106, 213, 107, 215, 108, 217, 109, 219, 110, 221, + 111, 223, 112, 225, 113, 227, 114, 229, 115, 231, 116, 233, 117, 235, 118, + 237, 119, 239, 120, 241, 121, 243, 122, 245, 123, 247, 124, 249, 125, 251, + 126, 253, 127, 255, 128, 257, 129, 259, 130, 261, 131, 263, 132, 265, 133, + 267, 134, 269, 135, 271, 136, 273, 137, 275, 138, 277, 139, 279, 140, 281, + 141, 283, 142, 285, 143, 287, 144, 289, 145, 291, 146, 293, 147, 295, 148, + 297, 149, 299, 150, 301, 151, 303, 152, 305, 153, 307, 154, 309, 155, 311, + 156, 313, 157, 315, 158, 317, 159, 319, 160, 321, 161, 323, 162, 325, 163, + 327, 164, 329, 165, 331, 166, 333, 167, 335, 168, 337, 169, 339, 170, 341, + 171, 343, 172, 345, 173, 347, 174, 349, 175, 351, 0, 353, 0, 355, 0, 357, + 0, 1, 0, 35, 2, 0, 65, 65, 97, 97, 2, 0, 68, 68, 100, 100, 2, 0, 71, 71, + 103, 103, 2, 0, 82, 82, 114, 114, 2, 0, 69, 69, 101, 101, 2, 0, 84, 84, + 116, 116, 2, 0, 76, 76, 108, 108, 2, 0, 79, 79, 111, 111, 2, 0, 87, 87, + 119, 119, 2, 0, 78, 78, 110, 110, 2, 0, 89, 89, 121, 121, 2, 0, 80, 80, + 112, 112, 2, 0, 83, 83, 115, 115, 2, 0, 67, 67, 99, 99, 2, 0, 85, 85, 117, + 117, 2, 0, 72, 72, 104, 104, 2, 0, 73, 73, 105, 105, 2, 0, 90, 90, 122, + 122, 2, 0, 66, 66, 98, 98, 2, 0, 77, 77, 109, 109, 2, 0, 70, 70, 102, 102, + 2, 0, 81, 81, 113, 113, 2, 0, 88, 88, 120, 120, 2, 0, 74, 74, 106, 106, + 2, 0, 75, 75, 107, 107, 2, 0, 86, 86, 118, 118, 1, 0, 36, 36, 2, 0, 39, + 39, 92, 92, 1, 0, 48, 57, 2, 0, 65, 90, 97, 122, 5, 0, 36, 36, 48, 57, + 65, 90, 95, 95, 97, 122, 1, 0, 34, 34, 3, 0, 9, 10, 13, 13, 32, 32, 2, + 0, 10, 10, 13, 13, 3, 0, 48, 57, 65, 70, 97, 102, 1618, 0, 1, 1, 0, 0, + 0, 0, 3, 1, 0, 0, 0, 0, 5, 1, 0, 0, 0, 0, 7, 1, 0, 0, 0, 0, 9, 1, 0, 0, + 0, 0, 11, 1, 0, 0, 0, 0, 13, 1, 0, 0, 0, 0, 15, 1, 0, 0, 0, 0, 17, 1, 0, + 0, 0, 0, 19, 1, 0, 0, 0, 0, 21, 1, 0, 0, 0, 0, 23, 1, 0, 0, 0, 0, 25, 1, + 0, 0, 0, 0, 27, 1, 0, 0, 0, 0, 29, 1, 0, 0, 0, 0, 31, 1, 0, 0, 0, 0, 33, + 1, 0, 0, 0, 0, 35, 1, 0, 0, 0, 0, 37, 1, 0, 0, 0, 0, 39, 1, 0, 0, 0, 0, + 41, 1, 0, 0, 0, 0, 43, 1, 0, 0, 0, 0, 45, 1, 0, 0, 0, 0, 47, 1, 0, 0, 0, + 0, 49, 1, 0, 0, 0, 0, 51, 1, 0, 0, 0, 0, 53, 1, 0, 0, 0, 0, 55, 1, 0, 0, + 0, 0, 57, 1, 0, 0, 0, 0, 59, 1, 0, 0, 0, 0, 61, 1, 0, 0, 0, 0, 63, 1, 0, + 0, 0, 0, 65, 1, 0, 0, 0, 0, 67, 1, 0, 0, 0, 0, 69, 1, 0, 0, 0, 0, 71, 1, + 0, 0, 0, 0, 73, 1, 0, 0, 0, 0, 75, 1, 0, 0, 0, 0, 77, 1, 0, 0, 0, 0, 79, + 1, 0, 0, 0, 0, 81, 1, 0, 0, 0, 0, 83, 1, 0, 0, 0, 0, 85, 1, 0, 0, 0, 0, + 87, 1, 0, 0, 0, 0, 89, 1, 0, 0, 0, 0, 91, 1, 0, 0, 0, 0, 93, 1, 0, 0, 0, + 0, 95, 1, 0, 0, 0, 0, 97, 1, 0, 0, 0, 0, 99, 1, 0, 0, 0, 0, 101, 1, 0, + 0, 0, 0, 103, 1, 0, 0, 0, 0, 105, 1, 0, 0, 0, 0, 107, 1, 0, 0, 0, 0, 109, + 1, 0, 0, 0, 0, 111, 1, 0, 0, 0, 0, 113, 1, 0, 0, 0, 0, 115, 1, 0, 0, 0, + 0, 117, 1, 0, 0, 0, 0, 119, 1, 0, 0, 0, 0, 121, 1, 0, 0, 0, 0, 123, 1, + 0, 0, 0, 0, 125, 1, 0, 0, 0, 0, 127, 1, 0, 0, 0, 0, 129, 1, 0, 0, 0, 0, + 131, 1, 0, 0, 0, 0, 133, 1, 0, 0, 0, 0, 135, 1, 0, 0, 0, 0, 137, 1, 0, + 0, 0, 0, 139, 1, 0, 0, 0, 0, 141, 1, 0, 0, 0, 0, 143, 1, 0, 0, 0, 0, 145, + 1, 0, 0, 0, 0, 147, 1, 0, 0, 0, 0, 149, 1, 0, 0, 0, 0, 151, 1, 0, 0, 0, + 0, 153, 1, 0, 0, 0, 0, 155, 1, 0, 0, 0, 0, 157, 1, 0, 0, 0, 0, 159, 1, + 0, 0, 0, 0, 161, 1, 0, 0, 0, 0, 163, 1, 0, 0, 0, 0, 165, 1, 0, 0, 0, 0, + 167, 1, 0, 0, 0, 0, 169, 1, 0, 0, 0, 0, 171, 1, 0, 0, 0, 0, 173, 1, 0, + 0, 0, 0, 175, 1, 0, 0, 0, 0, 177, 1, 0, 0, 0, 0, 179, 1, 0, 0, 0, 0, 181, + 1, 0, 0, 0, 0, 183, 1, 0, 0, 0, 0, 185, 1, 0, 0, 0, 0, 187, 1, 0, 0, 0, + 0, 189, 1, 0, 0, 0, 0, 191, 1, 0, 0, 0, 0, 193, 1, 0, 0, 0, 0, 195, 1, + 0, 0, 0, 0, 197, 1, 0, 0, 0, 0, 199, 1, 0, 0, 0, 0, 201, 1, 0, 0, 0, 0, + 203, 1, 0, 0, 0, 0, 205, 1, 0, 0, 0, 0, 207, 1, 0, 0, 0, 0, 209, 1, 0, + 0, 0, 0, 211, 1, 0, 0, 0, 0, 213, 1, 0, 0, 0, 0, 215, 1, 0, 0, 0, 0, 217, + 1, 0, 0, 0, 0, 219, 1, 0, 0, 0, 0, 221, 1, 0, 0, 0, 0, 223, 1, 0, 0, 0, + 0, 225, 1, 0, 0, 0, 0, 227, 1, 0, 0, 0, 0, 229, 1, 0, 0, 0, 0, 231, 1, + 0, 0, 0, 0, 233, 1, 0, 0, 0, 0, 235, 1, 0, 0, 0, 0, 237, 1, 0, 0, 0, 0, + 239, 1, 0, 0, 0, 0, 241, 1, 0, 0, 0, 0, 243, 1, 0, 0, 0, 0, 245, 1, 0, + 0, 0, 0, 247, 1, 0, 0, 0, 0, 249, 1, 0, 0, 0, 0, 251, 1, 0, 0, 0, 0, 253, + 1, 0, 0, 0, 0, 255, 1, 0, 0, 0, 0, 257, 1, 0, 0, 0, 0, 259, 1, 0, 0, 0, + 0, 261, 1, 0, 0, 0, 0, 263, 1, 0, 0, 0, 0, 265, 1, 0, 0, 0, 0, 267, 1, + 0, 0, 0, 0, 269, 1, 0, 0, 0, 0, 271, 1, 0, 0, 0, 0, 273, 1, 0, 0, 0, 0, + 275, 1, 0, 0, 0, 0, 277, 1, 0, 0, 0, 0, 279, 1, 0, 0, 0, 0, 281, 1, 0, + 0, 0, 0, 283, 1, 0, 0, 0, 0, 285, 1, 0, 0, 0, 0, 287, 1, 0, 0, 0, 0, 289, + 1, 0, 0, 0, 0, 291, 1, 0, 0, 0, 0, 293, 1, 0, 0, 0, 0, 295, 1, 0, 0, 0, + 0, 297, 1, 0, 0, 0, 0, 299, 1, 0, 0, 0, 0, 301, 1, 0, 0, 0, 0, 303, 1, + 0, 0, 0, 0, 305, 1, 0, 0, 0, 0, 307, 1, 0, 0, 0, 0, 309, 1, 0, 0, 0, 0, + 311, 1, 0, 0, 0, 0, 313, 1, 0, 0, 0, 0, 315, 1, 0, 0, 0, 0, 317, 1, 0, + 0, 0, 0, 319, 1, 0, 0, 0, 0, 321, 1, 0, 0, 0, 0, 323, 1, 0, 0, 0, 0, 325, + 1, 0, 0, 0, 0, 327, 1, 0, 0, 0, 0, 329, 1, 0, 0, 0, 0, 331, 1, 0, 0, 0, + 0, 333, 1, 0, 0, 0, 0, 335, 1, 0, 0, 0, 0, 337, 1, 0, 0, 0, 0, 339, 1, + 0, 0, 0, 0, 341, 1, 0, 0, 0, 0, 343, 1, 0, 0, 0, 0, 345, 1, 0, 0, 0, 0, + 347, 1, 0, 0, 0, 0, 349, 1, 0, 0, 0, 1, 359, 1, 0, 0, 0, 3, 361, 1, 0, + 0, 0, 5, 363, 1, 0, 0, 0, 7, 365, 1, 0, 0, 0, 9, 367, 1, 0, 0, 0, 11, 369, + 1, 0, 0, 0, 13, 371, 1, 0, 0, 0, 15, 373, 1, 0, 0, 0, 17, 375, 1, 0, 0, + 0, 19, 377, 1, 0, 0, 0, 21, 379, 1, 0, 0, 0, 23, 381, 1, 0, 0, 0, 25, 383, + 1, 0, 0, 0, 27, 385, 1, 0, 0, 0, 29, 387, 1, 0, 0, 0, 31, 390, 1, 0, 0, + 0, 33, 392, 1, 0, 0, 0, 35, 394, 1, 0, 0, 0, 37, 396, 1, 0, 0, 0, 39, 398, + 1, 0, 0, 0, 41, 400, 1, 0, 0, 0, 43, 402, 1, 0, 0, 0, 45, 405, 1, 0, 0, + 0, 47, 408, 1, 0, 0, 0, 49, 412, 1, 0, 0, 0, 51, 422, 1, 0, 0, 0, 53, 426, + 1, 0, 0, 0, 55, 432, 1, 0, 0, 0, 57, 438, 1, 0, 0, 0, 59, 442, 1, 0, 0, + 0, 61, 446, 1, 0, 0, 0, 63, 452, 1, 0, 0, 0, 65, 455, 1, 0, 0, 0, 67, 459, + 1, 0, 0, 0, 69, 469, 1, 0, 0, 0, 71, 475, 1, 0, 0, 0, 73, 481, 1, 0, 0, + 0, 75, 484, 1, 0, 0, 0, 77, 491, 1, 0, 0, 0, 79, 502, 1, 0, 0, 0, 81, 515, + 1, 0, 0, 0, 83, 523, 1, 0, 0, 0, 85, 535, 1, 0, 0, 0, 87, 544, 1, 0, 0, + 0, 89, 551, 1, 0, 0, 0, 91, 558, 1, 0, 0, 0, 93, 565, 1, 0, 0, 0, 95, 570, + 1, 0, 0, 0, 97, 579, 1, 0, 0, 0, 99, 588, 1, 0, 0, 0, 101, 593, 1, 0, 0, + 0, 103, 608, 1, 0, 0, 0, 105, 620, 1, 0, 0, 0, 107, 628, 1, 0, 0, 0, 109, + 636, 1, 0, 0, 0, 111, 643, 1, 0, 0, 0, 113, 649, 1, 0, 0, 0, 115, 659, + 1, 0, 0, 0, 117, 669, 1, 0, 0, 0, 119, 674, 1, 0, 0, 0, 121, 679, 1, 0, + 0, 0, 123, 688, 1, 0, 0, 0, 125, 698, 1, 0, 0, 0, 127, 704, 1, 0, 0, 0, + 129, 707, 1, 0, 0, 0, 131, 710, 1, 0, 0, 0, 133, 716, 1, 0, 0, 0, 135, + 725, 1, 0, 0, 0, 137, 734, 1, 0, 0, 0, 139, 740, 1, 0, 0, 0, 141, 747, + 1, 0, 0, 0, 143, 752, 1, 0, 0, 0, 145, 755, 1, 0, 0, 0, 147, 760, 1, 0, + 0, 0, 149, 764, 1, 0, 0, 0, 151, 769, 1, 0, 0, 0, 153, 778, 1, 0, 0, 0, + 155, 788, 1, 0, 0, 0, 157, 797, 1, 0, 0, 0, 159, 803, 1, 0, 0, 0, 161, + 809, 1, 0, 0, 0, 163, 819, 1, 0, 0, 0, 165, 832, 1, 0, 0, 0, 167, 839, + 1, 0, 0, 0, 169, 845, 1, 0, 0, 0, 171, 858, 1, 0, 0, 0, 173, 865, 1, 0, + 0, 0, 175, 869, 1, 0, 0, 0, 177, 881, 1, 0, 0, 0, 179, 893, 1, 0, 0, 0, + 181, 897, 1, 0, 0, 0, 183, 902, 1, 0, 0, 0, 185, 905, 1, 0, 0, 0, 187, + 908, 1, 0, 0, 0, 189, 912, 1, 0, 0, 0, 191, 920, 1, 0, 0, 0, 193, 923, + 1, 0, 0, 0, 195, 929, 1, 0, 0, 0, 197, 939, 1, 0, 0, 0, 199, 948, 1, 0, + 0, 0, 201, 952, 1, 0, 0, 0, 203, 963, 1, 0, 0, 0, 205, 975, 1, 0, 0, 0, + 207, 983, 1, 0, 0, 0, 209, 990, 1, 0, 0, 0, 211, 997, 1, 0, 0, 0, 213, + 1005, 1, 0, 0, 0, 215, 1017, 1, 0, 0, 0, 217, 1025, 1, 0, 0, 0, 219, 1032, + 1, 0, 0, 0, 221, 1037, 1, 0, 0, 0, 223, 1043, 1, 0, 0, 0, 225, 1050, 1, + 0, 0, 0, 227, 1057, 1, 0, 0, 0, 229, 1061, 1, 0, 0, 0, 231, 1067, 1, 0, + 0, 0, 233, 1074, 1, 0, 0, 0, 235, 1082, 1, 0, 0, 0, 237, 1088, 1, 0, 0, + 0, 239, 1098, 1, 0, 0, 0, 241, 1104, 1, 0, 0, 0, 243, 1110, 1, 0, 0, 0, + 245, 1120, 1, 0, 0, 0, 247, 1123, 1, 0, 0, 0, 249, 1129, 1, 0, 0, 0, 251, + 1137, 1, 0, 0, 0, 253, 1142, 1, 0, 0, 0, 255, 1151, 1, 0, 0, 0, 257, 1155, + 1, 0, 0, 0, 259, 1159, 1, 0, 0, 0, 261, 1164, 1, 0, 0, 0, 263, 1173, 1, + 0, 0, 0, 265, 1180, 1, 0, 0, 0, 267, 1184, 1, 0, 0, 0, 269, 1189, 1, 0, + 0, 0, 271, 1195, 1, 0, 0, 0, 273, 1200, 1, 0, 0, 0, 275, 1207, 1, 0, 0, + 0, 277, 1212, 1, 0, 0, 0, 279, 1218, 1, 0, 0, 0, 281, 1223, 1, 0, 0, 0, + 283, 1233, 1, 0, 0, 0, 285, 1239, 1, 0, 0, 0, 287, 1246, 1, 0, 0, 0, 289, + 1251, 1, 0, 0, 0, 291, 1259, 1, 0, 0, 0, 293, 1267, 1, 0, 0, 0, 295, 1272, + 1, 0, 0, 0, 297, 1280, 1, 0, 0, 0, 299, 1287, 1, 0, 0, 0, 301, 1293, 1, + 0, 0, 0, 303, 1300, 1, 0, 0, 0, 305, 1305, 1, 0, 0, 0, 307, 1309, 1, 0, + 0, 0, 309, 1314, 1, 0, 0, 0, 311, 1318, 1, 0, 0, 0, 313, 1327, 1, 0, 0, + 0, 315, 1332, 1, 0, 0, 0, 317, 1341, 1, 0, 0, 0, 319, 1346, 1, 0, 0, 0, + 321, 1354, 1, 0, 0, 0, 323, 1360, 1, 0, 0, 0, 325, 1368, 1, 0, 0, 0, 327, + 1375, 1, 0, 0, 0, 329, 1389, 1, 0, 0, 0, 331, 1403, 1, 0, 0, 0, 333, 1408, + 1, 0, 0, 0, 335, 1442, 1, 0, 0, 0, 337, 1469, 1, 0, 0, 0, 339, 1485, 1, + 0, 0, 0, 341, 1487, 1, 0, 0, 0, 343, 1501, 1, 0, 0, 0, 345, 1507, 1, 0, + 0, 0, 347, 1521, 1, 0, 0, 0, 349, 1566, 1, 0, 0, 0, 351, 1570, 1, 0, 0, + 0, 353, 1575, 1, 0, 0, 0, 355, 1577, 1, 0, 0, 0, 357, 1579, 1, 0, 0, 0, + 359, 360, 5, 40, 0, 0, 360, 2, 1, 0, 0, 0, 361, 362, 5, 41, 0, 0, 362, + 4, 1, 0, 0, 0, 363, 364, 5, 123, 0, 0, 364, 6, 1, 0, 0, 0, 365, 366, 5, + 125, 0, 0, 366, 8, 1, 0, 0, 0, 367, 368, 5, 91, 0, 0, 368, 10, 1, 0, 0, + 0, 369, 370, 5, 93, 0, 0, 370, 12, 1, 0, 0, 0, 371, 372, 5, 44, 0, 0, 372, + 14, 1, 0, 0, 0, 373, 374, 5, 59, 0, 0, 374, 16, 1, 0, 0, 0, 375, 376, 5, + 58, 0, 0, 376, 18, 1, 0, 0, 0, 377, 378, 5, 46, 0, 0, 378, 20, 1, 0, 0, + 0, 379, 380, 5, 42, 0, 0, 380, 22, 1, 0, 0, 0, 381, 382, 5, 47, 0, 0, 382, + 24, 1, 0, 0, 0, 383, 384, 5, 37, 0, 0, 384, 26, 1, 0, 0, 0, 385, 386, 5, + 43, 0, 0, 386, 28, 1, 0, 0, 0, 387, 388, 5, 45, 0, 0, 388, 389, 5, 45, + 0, 0, 389, 30, 1, 0, 0, 0, 390, 391, 5, 45, 0, 0, 391, 32, 1, 0, 0, 0, + 392, 393, 5, 34, 0, 0, 393, 34, 1, 0, 0, 0, 394, 395, 5, 39, 0, 0, 395, + 36, 1, 0, 0, 0, 396, 397, 5, 61, 0, 0, 397, 38, 1, 0, 0, 0, 398, 399, 5, + 60, 0, 0, 399, 40, 1, 0, 0, 0, 400, 401, 5, 62, 0, 0, 401, 42, 1, 0, 0, + 0, 402, 403, 5, 60, 0, 0, 403, 404, 5, 61, 0, 0, 404, 44, 1, 0, 0, 0, 405, + 406, 5, 62, 0, 0, 406, 407, 5, 61, 0, 0, 407, 46, 1, 0, 0, 0, 408, 409, + 7, 0, 0, 0, 409, 410, 7, 1, 0, 0, 410, 411, 7, 1, 0, 0, 411, 48, 1, 0, + 0, 0, 412, 413, 7, 0, 0, 0, 413, 414, 7, 2, 0, 0, 414, 415, 7, 2, 0, 0, + 415, 416, 7, 3, 0, 0, 416, 417, 7, 4, 0, 0, 417, 418, 7, 2, 0, 0, 418, + 419, 7, 0, 0, 0, 419, 420, 7, 5, 0, 0, 420, 421, 7, 4, 0, 0, 421, 50, 1, + 0, 0, 0, 422, 423, 7, 0, 0, 0, 423, 424, 7, 6, 0, 0, 424, 425, 7, 6, 0, + 0, 425, 52, 1, 0, 0, 0, 426, 427, 7, 0, 0, 0, 427, 428, 7, 6, 0, 0, 428, + 429, 7, 6, 0, 0, 429, 430, 7, 7, 0, 0, 430, 431, 7, 8, 0, 0, 431, 54, 1, + 0, 0, 0, 432, 433, 7, 0, 0, 0, 433, 434, 7, 6, 0, 0, 434, 435, 7, 5, 0, + 0, 435, 436, 7, 4, 0, 0, 436, 437, 7, 3, 0, 0, 437, 56, 1, 0, 0, 0, 438, + 439, 7, 0, 0, 0, 439, 440, 7, 9, 0, 0, 440, 441, 7, 1, 0, 0, 441, 58, 1, + 0, 0, 0, 442, 443, 7, 0, 0, 0, 443, 444, 7, 9, 0, 0, 444, 445, 7, 10, 0, + 0, 445, 60, 1, 0, 0, 0, 446, 447, 7, 0, 0, 0, 447, 448, 7, 11, 0, 0, 448, + 449, 7, 11, 0, 0, 449, 450, 7, 6, 0, 0, 450, 451, 7, 10, 0, 0, 451, 62, + 1, 0, 0, 0, 452, 453, 7, 0, 0, 0, 453, 454, 7, 12, 0, 0, 454, 64, 1, 0, + 0, 0, 455, 456, 7, 0, 0, 0, 456, 457, 7, 12, 0, 0, 457, 458, 7, 13, 0, + 0, 458, 66, 1, 0, 0, 0, 459, 460, 7, 0, 0, 0, 460, 461, 7, 14, 0, 0, 461, + 462, 7, 5, 0, 0, 462, 463, 7, 15, 0, 0, 463, 464, 7, 7, 0, 0, 464, 465, + 7, 3, 0, 0, 465, 466, 7, 16, 0, 0, 466, 467, 7, 17, 0, 0, 467, 468, 7, + 4, 0, 0, 468, 68, 1, 0, 0, 0, 469, 470, 7, 18, 0, 0, 470, 471, 7, 0, 0, + 0, 471, 472, 7, 5, 0, 0, 472, 473, 7, 13, 0, 0, 473, 474, 7, 15, 0, 0, + 474, 70, 1, 0, 0, 0, 475, 476, 7, 18, 0, 0, 476, 477, 7, 4, 0, 0, 477, + 478, 7, 2, 0, 0, 478, 479, 7, 16, 0, 0, 479, 480, 7, 9, 0, 0, 480, 72, + 1, 0, 0, 0, 481, 482, 7, 18, 0, 0, 482, 483, 7, 10, 0, 0, 483, 74, 1, 0, + 0, 0, 484, 485, 7, 13, 0, 0, 485, 486, 7, 0, 0, 0, 486, 487, 7, 6, 0, 0, + 487, 488, 7, 6, 0, 0, 488, 489, 7, 4, 0, 0, 489, 490, 7, 1, 0, 0, 490, + 76, 1, 0, 0, 0, 491, 492, 7, 13, 0, 0, 492, 493, 7, 6, 0, 0, 493, 494, + 7, 14, 0, 0, 494, 495, 7, 12, 0, 0, 495, 496, 7, 5, 0, 0, 496, 497, 7, + 4, 0, 0, 497, 498, 7, 3, 0, 0, 498, 499, 7, 16, 0, 0, 499, 500, 7, 9, 0, + 0, 500, 501, 7, 2, 0, 0, 501, 78, 1, 0, 0, 0, 502, 503, 7, 13, 0, 0, 503, + 504, 7, 7, 0, 0, 504, 505, 7, 6, 0, 0, 505, 506, 7, 14, 0, 0, 506, 507, + 7, 19, 0, 0, 507, 508, 7, 9, 0, 0, 508, 509, 7, 20, 0, 0, 509, 510, 7, + 0, 0, 0, 510, 511, 7, 19, 0, 0, 511, 512, 7, 16, 0, 0, 512, 513, 7, 6, + 0, 0, 513, 514, 7, 10, 0, 0, 514, 80, 1, 0, 0, 0, 515, 516, 7, 13, 0, 0, + 516, 517, 7, 7, 0, 0, 517, 518, 7, 19, 0, 0, 518, 519, 7, 11, 0, 0, 519, + 520, 7, 0, 0, 0, 520, 521, 7, 13, 0, 0, 521, 522, 7, 5, 0, 0, 522, 82, + 1, 0, 0, 0, 523, 524, 7, 13, 0, 0, 524, 525, 7, 7, 0, 0, 525, 526, 7, 9, + 0, 0, 526, 527, 7, 12, 0, 0, 527, 528, 7, 16, 0, 0, 528, 529, 7, 12, 0, + 0, 529, 530, 7, 5, 0, 0, 530, 531, 7, 4, 0, 0, 531, 532, 7, 9, 0, 0, 532, + 533, 7, 13, 0, 0, 533, 534, 7, 10, 0, 0, 534, 84, 1, 0, 0, 0, 535, 536, + 7, 13, 0, 0, 536, 537, 7, 7, 0, 0, 537, 538, 7, 9, 0, 0, 538, 539, 7, 5, + 0, 0, 539, 540, 7, 0, 0, 0, 540, 541, 7, 16, 0, 0, 541, 542, 7, 9, 0, 0, + 542, 543, 7, 12, 0, 0, 543, 86, 1, 0, 0, 0, 544, 545, 7, 13, 0, 0, 545, + 546, 7, 3, 0, 0, 546, 547, 7, 4, 0, 0, 547, 548, 7, 0, 0, 0, 548, 549, + 7, 5, 0, 0, 549, 550, 7, 4, 0, 0, 550, 88, 1, 0, 0, 0, 551, 552, 7, 13, + 0, 0, 552, 553, 7, 14, 0, 0, 553, 554, 7, 12, 0, 0, 554, 555, 7, 5, 0, + 0, 555, 556, 7, 7, 0, 0, 556, 557, 7, 19, 0, 0, 557, 90, 1, 0, 0, 0, 558, + 559, 7, 1, 0, 0, 559, 560, 7, 4, 0, 0, 560, 561, 7, 6, 0, 0, 561, 562, + 7, 4, 0, 0, 562, 563, 7, 5, 0, 0, 563, 564, 7, 4, 0, 0, 564, 92, 1, 0, + 0, 0, 565, 566, 7, 1, 0, 0, 566, 567, 7, 4, 0, 0, 567, 568, 7, 12, 0, 0, + 568, 569, 7, 13, 0, 0, 569, 94, 1, 0, 0, 0, 570, 571, 7, 1, 0, 0, 571, + 572, 7, 4, 0, 0, 572, 573, 7, 12, 0, 0, 573, 574, 7, 13, 0, 0, 574, 575, + 7, 3, 0, 0, 575, 576, 7, 16, 0, 0, 576, 577, 7, 18, 0, 0, 577, 578, 7, + 4, 0, 0, 578, 96, 1, 0, 0, 0, 579, 580, 7, 1, 0, 0, 580, 581, 7, 16, 0, + 0, 581, 582, 7, 12, 0, 0, 582, 583, 7, 5, 0, 0, 583, 584, 7, 16, 0, 0, + 584, 585, 7, 9, 0, 0, 585, 586, 7, 13, 0, 0, 586, 587, 7, 5, 0, 0, 587, + 98, 1, 0, 0, 0, 588, 589, 7, 1, 0, 0, 589, 590, 7, 3, 0, 0, 590, 591, 7, + 7, 0, 0, 591, 592, 7, 11, 0, 0, 592, 100, 1, 0, 0, 0, 593, 594, 7, 1, 0, + 0, 594, 595, 7, 14, 0, 0, 595, 596, 7, 3, 0, 0, 596, 597, 7, 0, 0, 0, 597, + 598, 7, 18, 0, 0, 598, 599, 7, 6, 0, 0, 599, 600, 7, 4, 0, 0, 600, 601, + 5, 95, 0, 0, 601, 602, 7, 8, 0, 0, 602, 603, 7, 3, 0, 0, 603, 604, 7, 16, + 0, 0, 604, 605, 7, 5, 0, 0, 605, 606, 7, 4, 0, 0, 606, 607, 7, 12, 0, 0, + 607, 102, 1, 0, 0, 0, 608, 609, 7, 4, 0, 0, 609, 610, 7, 0, 0, 0, 610, + 611, 7, 13, 0, 0, 611, 612, 7, 15, 0, 0, 612, 613, 5, 95, 0, 0, 613, 614, + 7, 21, 0, 0, 614, 615, 7, 14, 0, 0, 615, 616, 7, 7, 0, 0, 616, 617, 7, + 3, 0, 0, 617, 618, 7, 14, 0, 0, 618, 619, 7, 19, 0, 0, 619, 104, 1, 0, + 0, 0, 620, 621, 7, 4, 0, 0, 621, 622, 7, 9, 0, 0, 622, 623, 7, 5, 0, 0, + 623, 624, 7, 3, 0, 0, 624, 625, 7, 16, 0, 0, 625, 626, 7, 4, 0, 0, 626, + 627, 7, 12, 0, 0, 627, 106, 1, 0, 0, 0, 628, 629, 7, 4, 0, 0, 629, 630, + 7, 22, 0, 0, 630, 631, 7, 4, 0, 0, 631, 632, 7, 13, 0, 0, 632, 633, 7, + 14, 0, 0, 633, 634, 7, 5, 0, 0, 634, 635, 7, 4, 0, 0, 635, 108, 1, 0, 0, + 0, 636, 637, 7, 4, 0, 0, 637, 638, 7, 22, 0, 0, 638, 639, 7, 16, 0, 0, + 639, 640, 7, 12, 0, 0, 640, 641, 7, 5, 0, 0, 641, 642, 7, 12, 0, 0, 642, + 110, 1, 0, 0, 0, 643, 644, 7, 20, 0, 0, 644, 645, 7, 0, 0, 0, 645, 646, + 7, 6, 0, 0, 646, 647, 7, 12, 0, 0, 647, 648, 7, 4, 0, 0, 648, 112, 1, 0, + 0, 0, 649, 650, 7, 20, 0, 0, 650, 651, 7, 16, 0, 0, 651, 652, 7, 6, 0, + 0, 652, 653, 7, 5, 0, 0, 653, 654, 7, 4, 0, 0, 654, 655, 7, 3, 0, 0, 655, + 656, 7, 16, 0, 0, 656, 657, 7, 9, 0, 0, 657, 658, 7, 2, 0, 0, 658, 114, + 1, 0, 0, 0, 659, 660, 7, 20, 0, 0, 660, 661, 7, 16, 0, 0, 661, 662, 7, + 9, 0, 0, 662, 663, 7, 0, 0, 0, 663, 664, 7, 6, 0, 0, 664, 665, 7, 20, 0, + 0, 665, 666, 7, 14, 0, 0, 666, 667, 7, 9, 0, 0, 667, 668, 7, 13, 0, 0, + 668, 116, 1, 0, 0, 0, 669, 670, 7, 20, 0, 0, 670, 671, 7, 3, 0, 0, 671, + 672, 7, 7, 0, 0, 672, 673, 7, 19, 0, 0, 673, 118, 1, 0, 0, 0, 674, 675, + 7, 20, 0, 0, 675, 676, 7, 14, 0, 0, 676, 677, 7, 6, 0, 0, 677, 678, 7, + 6, 0, 0, 678, 120, 1, 0, 0, 0, 679, 680, 7, 20, 0, 0, 680, 681, 7, 14, + 0, 0, 681, 682, 7, 9, 0, 0, 682, 683, 7, 13, 0, 0, 683, 684, 7, 5, 0, 0, + 684, 685, 7, 16, 0, 0, 685, 686, 7, 7, 0, 0, 686, 687, 7, 9, 0, 0, 687, + 122, 1, 0, 0, 0, 688, 689, 7, 20, 0, 0, 689, 690, 7, 14, 0, 0, 690, 691, + 7, 9, 0, 0, 691, 692, 7, 13, 0, 0, 692, 693, 7, 5, 0, 0, 693, 694, 7, 16, + 0, 0, 694, 695, 7, 7, 0, 0, 695, 696, 7, 9, 0, 0, 696, 697, 7, 12, 0, 0, + 697, 124, 1, 0, 0, 0, 698, 699, 7, 2, 0, 0, 699, 700, 7, 3, 0, 0, 700, + 701, 7, 0, 0, 0, 701, 702, 7, 9, 0, 0, 702, 703, 7, 5, 0, 0, 703, 126, + 1, 0, 0, 0, 704, 705, 7, 16, 0, 0, 705, 706, 7, 20, 0, 0, 706, 128, 1, + 0, 0, 0, 707, 708, 7, 16, 0, 0, 708, 709, 7, 9, 0, 0, 709, 130, 1, 0, 0, + 0, 710, 711, 7, 16, 0, 0, 711, 712, 7, 9, 0, 0, 712, 713, 7, 1, 0, 0, 713, + 714, 7, 4, 0, 0, 714, 715, 7, 22, 0, 0, 715, 132, 1, 0, 0, 0, 716, 717, + 7, 16, 0, 0, 717, 718, 7, 9, 0, 0, 718, 719, 7, 20, 0, 0, 719, 720, 7, + 16, 0, 0, 720, 721, 7, 9, 0, 0, 721, 722, 7, 16, 0, 0, 722, 723, 7, 5, + 0, 0, 723, 724, 7, 10, 0, 0, 724, 134, 1, 0, 0, 0, 725, 726, 7, 16, 0, + 0, 726, 727, 7, 9, 0, 0, 727, 728, 7, 16, 0, 0, 728, 729, 7, 5, 0, 0, 729, + 730, 7, 13, 0, 0, 730, 731, 7, 7, 0, 0, 731, 732, 7, 9, 0, 0, 732, 733, + 7, 1, 0, 0, 733, 136, 1, 0, 0, 0, 734, 735, 7, 16, 0, 0, 735, 736, 7, 9, + 0, 0, 736, 737, 7, 11, 0, 0, 737, 738, 7, 14, 0, 0, 738, 739, 7, 5, 0, + 0, 739, 138, 1, 0, 0, 0, 740, 741, 7, 16, 0, 0, 741, 742, 7, 9, 0, 0, 742, + 743, 7, 12, 0, 0, 743, 744, 7, 4, 0, 0, 744, 745, 7, 3, 0, 0, 745, 746, + 7, 5, 0, 0, 746, 140, 1, 0, 0, 0, 747, 748, 7, 16, 0, 0, 748, 749, 7, 9, + 0, 0, 749, 750, 7, 5, 0, 0, 750, 751, 7, 7, 0, 0, 751, 142, 1, 0, 0, 0, + 752, 753, 7, 16, 0, 0, 753, 754, 7, 12, 0, 0, 754, 144, 1, 0, 0, 0, 755, + 756, 7, 23, 0, 0, 756, 757, 7, 12, 0, 0, 757, 758, 7, 7, 0, 0, 758, 759, + 7, 9, 0, 0, 759, 146, 1, 0, 0, 0, 760, 761, 7, 24, 0, 0, 761, 762, 7, 4, + 0, 0, 762, 763, 7, 10, 0, 0, 763, 148, 1, 0, 0, 0, 764, 765, 7, 24, 0, + 0, 765, 766, 7, 4, 0, 0, 766, 767, 7, 10, 0, 0, 767, 768, 7, 12, 0, 0, + 768, 150, 1, 0, 0, 0, 769, 770, 7, 24, 0, 0, 770, 771, 7, 4, 0, 0, 771, + 772, 7, 10, 0, 0, 772, 773, 7, 12, 0, 0, 773, 774, 7, 11, 0, 0, 774, 775, + 7, 0, 0, 0, 775, 776, 7, 13, 0, 0, 776, 777, 7, 4, 0, 0, 777, 152, 1, 0, + 0, 0, 778, 779, 7, 24, 0, 0, 779, 780, 7, 4, 0, 0, 780, 781, 7, 10, 0, + 0, 781, 782, 7, 12, 0, 0, 782, 783, 7, 11, 0, 0, 783, 784, 7, 0, 0, 0, + 784, 785, 7, 13, 0, 0, 785, 786, 7, 4, 0, 0, 786, 787, 7, 12, 0, 0, 787, + 154, 1, 0, 0, 0, 788, 789, 7, 6, 0, 0, 789, 790, 7, 0, 0, 0, 790, 791, + 7, 9, 0, 0, 791, 792, 7, 2, 0, 0, 792, 793, 7, 14, 0, 0, 793, 794, 7, 0, + 0, 0, 794, 795, 7, 2, 0, 0, 795, 796, 7, 4, 0, 0, 796, 156, 1, 0, 0, 0, + 797, 798, 7, 6, 0, 0, 798, 799, 7, 4, 0, 0, 799, 800, 7, 25, 0, 0, 800, + 801, 7, 4, 0, 0, 801, 802, 7, 6, 0, 0, 802, 158, 1, 0, 0, 0, 803, 804, + 7, 6, 0, 0, 804, 805, 7, 16, 0, 0, 805, 806, 7, 19, 0, 0, 806, 807, 7, + 16, 0, 0, 807, 808, 7, 5, 0, 0, 808, 160, 1, 0, 0, 0, 809, 810, 7, 6, 0, + 0, 810, 811, 7, 7, 0, 0, 811, 812, 7, 13, 0, 0, 812, 813, 7, 0, 0, 0, 813, + 814, 7, 6, 0, 0, 814, 815, 5, 95, 0, 0, 815, 816, 7, 7, 0, 0, 816, 817, + 7, 9, 0, 0, 817, 818, 7, 4, 0, 0, 818, 162, 1, 0, 0, 0, 819, 820, 7, 6, + 0, 0, 820, 821, 7, 7, 0, 0, 821, 822, 7, 13, 0, 0, 822, 823, 7, 0, 0, 0, + 823, 824, 7, 6, 0, 0, 824, 825, 5, 95, 0, 0, 825, 826, 7, 21, 0, 0, 826, + 827, 7, 14, 0, 0, 827, 828, 7, 7, 0, 0, 828, 829, 7, 3, 0, 0, 829, 830, + 7, 14, 0, 0, 830, 831, 7, 19, 0, 0, 831, 164, 1, 0, 0, 0, 832, 833, 7, + 6, 0, 0, 833, 834, 7, 7, 0, 0, 834, 835, 7, 2, 0, 0, 835, 836, 7, 2, 0, + 0, 836, 837, 7, 4, 0, 0, 837, 838, 7, 1, 0, 0, 838, 166, 1, 0, 0, 0, 839, + 840, 7, 6, 0, 0, 840, 841, 7, 7, 0, 0, 841, 842, 7, 2, 0, 0, 842, 843, + 7, 16, 0, 0, 843, 844, 7, 9, 0, 0, 844, 168, 1, 0, 0, 0, 845, 846, 7, 19, + 0, 0, 846, 847, 7, 0, 0, 0, 847, 848, 7, 5, 0, 0, 848, 849, 7, 4, 0, 0, + 849, 850, 7, 3, 0, 0, 850, 851, 7, 16, 0, 0, 851, 852, 7, 0, 0, 0, 852, + 853, 7, 6, 0, 0, 853, 854, 7, 16, 0, 0, 854, 855, 7, 17, 0, 0, 855, 856, + 7, 4, 0, 0, 856, 857, 7, 1, 0, 0, 857, 170, 1, 0, 0, 0, 858, 859, 7, 19, + 0, 0, 859, 860, 7, 7, 0, 0, 860, 861, 7, 1, 0, 0, 861, 862, 7, 16, 0, 0, + 862, 863, 7, 20, 0, 0, 863, 864, 7, 10, 0, 0, 864, 172, 1, 0, 0, 0, 865, + 866, 7, 9, 0, 0, 866, 867, 7, 0, 0, 0, 867, 868, 7, 9, 0, 0, 868, 174, + 1, 0, 0, 0, 869, 870, 7, 9, 0, 0, 870, 871, 7, 7, 0, 0, 871, 872, 7, 3, + 0, 0, 872, 873, 7, 4, 0, 0, 873, 874, 7, 13, 0, 0, 874, 875, 7, 14, 0, + 0, 875, 876, 7, 3, 0, 0, 876, 877, 7, 12, 0, 0, 877, 878, 7, 16, 0, 0, + 878, 879, 7, 25, 0, 0, 879, 880, 7, 4, 0, 0, 880, 176, 1, 0, 0, 0, 881, + 882, 7, 9, 0, 0, 882, 883, 7, 7, 0, 0, 883, 884, 7, 12, 0, 0, 884, 885, + 7, 14, 0, 0, 885, 886, 7, 11, 0, 0, 886, 887, 7, 4, 0, 0, 887, 888, 7, + 3, 0, 0, 888, 889, 7, 14, 0, 0, 889, 890, 7, 12, 0, 0, 890, 891, 7, 4, + 0, 0, 891, 892, 7, 3, 0, 0, 892, 178, 1, 0, 0, 0, 893, 894, 7, 9, 0, 0, + 894, 895, 7, 7, 0, 0, 895, 896, 7, 5, 0, 0, 896, 180, 1, 0, 0, 0, 897, + 898, 7, 9, 0, 0, 898, 899, 7, 14, 0, 0, 899, 900, 7, 6, 0, 0, 900, 901, + 7, 6, 0, 0, 901, 182, 1, 0, 0, 0, 902, 903, 7, 7, 0, 0, 903, 904, 7, 20, + 0, 0, 904, 184, 1, 0, 0, 0, 905, 906, 7, 7, 0, 0, 906, 907, 7, 9, 0, 0, + 907, 186, 1, 0, 0, 0, 908, 909, 7, 7, 0, 0, 909, 910, 7, 9, 0, 0, 910, + 911, 7, 4, 0, 0, 911, 188, 1, 0, 0, 0, 912, 913, 7, 7, 0, 0, 913, 914, + 7, 11, 0, 0, 914, 915, 7, 5, 0, 0, 915, 916, 7, 16, 0, 0, 916, 917, 7, + 7, 0, 0, 917, 918, 7, 9, 0, 0, 918, 919, 7, 12, 0, 0, 919, 190, 1, 0, 0, + 0, 920, 921, 7, 7, 0, 0, 921, 922, 7, 3, 0, 0, 922, 192, 1, 0, 0, 0, 923, + 924, 7, 7, 0, 0, 924, 925, 7, 3, 0, 0, 925, 926, 7, 1, 0, 0, 926, 927, + 7, 4, 0, 0, 927, 928, 7, 3, 0, 0, 928, 194, 1, 0, 0, 0, 929, 930, 7, 11, + 0, 0, 930, 931, 7, 0, 0, 0, 931, 932, 7, 3, 0, 0, 932, 933, 7, 5, 0, 0, + 933, 934, 7, 16, 0, 0, 934, 935, 7, 5, 0, 0, 935, 936, 7, 16, 0, 0, 936, + 937, 7, 7, 0, 0, 937, 938, 7, 9, 0, 0, 938, 196, 1, 0, 0, 0, 939, 940, + 7, 11, 0, 0, 940, 941, 7, 0, 0, 0, 941, 942, 7, 12, 0, 0, 942, 943, 7, + 12, 0, 0, 943, 944, 7, 8, 0, 0, 944, 945, 7, 7, 0, 0, 945, 946, 7, 3, 0, + 0, 946, 947, 7, 1, 0, 0, 947, 198, 1, 0, 0, 0, 948, 949, 7, 11, 0, 0, 949, + 950, 7, 4, 0, 0, 950, 951, 7, 3, 0, 0, 951, 200, 1, 0, 0, 0, 952, 953, + 7, 11, 0, 0, 953, 954, 7, 4, 0, 0, 954, 955, 7, 3, 0, 0, 955, 956, 7, 19, + 0, 0, 956, 957, 7, 16, 0, 0, 957, 958, 7, 12, 0, 0, 958, 959, 7, 12, 0, + 0, 959, 960, 7, 16, 0, 0, 960, 961, 7, 7, 0, 0, 961, 962, 7, 9, 0, 0, 962, + 202, 1, 0, 0, 0, 963, 964, 7, 11, 0, 0, 964, 965, 7, 4, 0, 0, 965, 966, + 7, 3, 0, 0, 966, 967, 7, 19, 0, 0, 967, 968, 7, 16, 0, 0, 968, 969, 7, + 12, 0, 0, 969, 970, 7, 12, 0, 0, 970, 971, 7, 16, 0, 0, 971, 972, 7, 7, + 0, 0, 972, 973, 7, 9, 0, 0, 973, 974, 7, 12, 0, 0, 974, 204, 1, 0, 0, 0, + 975, 976, 7, 11, 0, 0, 976, 977, 7, 3, 0, 0, 977, 978, 7, 16, 0, 0, 978, + 979, 7, 19, 0, 0, 979, 980, 7, 0, 0, 0, 980, 981, 7, 3, 0, 0, 981, 982, + 7, 10, 0, 0, 982, 206, 1, 0, 0, 0, 983, 984, 7, 21, 0, 0, 984, 985, 7, + 14, 0, 0, 985, 986, 7, 7, 0, 0, 986, 987, 7, 3, 0, 0, 987, 988, 7, 14, + 0, 0, 988, 989, 7, 19, 0, 0, 989, 208, 1, 0, 0, 0, 990, 991, 7, 3, 0, 0, + 991, 992, 7, 4, 0, 0, 992, 993, 7, 9, 0, 0, 993, 994, 7, 0, 0, 0, 994, + 995, 7, 19, 0, 0, 995, 996, 7, 4, 0, 0, 996, 210, 1, 0, 0, 0, 997, 998, + 7, 3, 0, 0, 998, 999, 7, 4, 0, 0, 999, 1000, 7, 11, 0, 0, 1000, 1001, 7, + 6, 0, 0, 1001, 1002, 7, 0, 0, 0, 1002, 1003, 7, 13, 0, 0, 1003, 1004, 7, + 4, 0, 0, 1004, 212, 1, 0, 0, 0, 1005, 1006, 7, 3, 0, 0, 1006, 1007, 7, + 4, 0, 0, 1007, 1008, 7, 11, 0, 0, 1008, 1009, 7, 6, 0, 0, 1009, 1010, 7, + 16, 0, 0, 1010, 1011, 7, 13, 0, 0, 1011, 1012, 7, 0, 0, 0, 1012, 1013, + 7, 5, 0, 0, 1013, 1014, 7, 16, 0, 0, 1014, 1015, 7, 7, 0, 0, 1015, 1016, + 7, 9, 0, 0, 1016, 214, 1, 0, 0, 0, 1017, 1018, 7, 3, 0, 0, 1018, 1019, + 7, 4, 0, 0, 1019, 1020, 7, 5, 0, 0, 1020, 1021, 7, 14, 0, 0, 1021, 1022, + 7, 3, 0, 0, 1022, 1023, 7, 9, 0, 0, 1023, 1024, 7, 12, 0, 0, 1024, 216, + 1, 0, 0, 0, 1025, 1026, 7, 3, 0, 0, 1026, 1027, 7, 4, 0, 0, 1027, 1028, + 7, 25, 0, 0, 1028, 1029, 7, 7, 0, 0, 1029, 1030, 7, 24, 0, 0, 1030, 1031, + 7, 4, 0, 0, 1031, 218, 1, 0, 0, 0, 1032, 1033, 7, 3, 0, 0, 1033, 1034, + 7, 7, 0, 0, 1034, 1035, 7, 6, 0, 0, 1035, 1036, 7, 4, 0, 0, 1036, 220, + 1, 0, 0, 0, 1037, 1038, 7, 3, 0, 0, 1038, 1039, 7, 7, 0, 0, 1039, 1040, + 7, 6, 0, 0, 1040, 1041, 7, 4, 0, 0, 1041, 1042, 7, 12, 0, 0, 1042, 222, + 1, 0, 0, 0, 1043, 1044, 7, 12, 0, 0, 1044, 1045, 7, 13, 0, 0, 1045, 1046, + 7, 15, 0, 0, 1046, 1047, 7, 4, 0, 0, 1047, 1048, 7, 19, 0, 0, 1048, 1049, + 7, 0, 0, 0, 1049, 224, 1, 0, 0, 0, 1050, 1051, 7, 12, 0, 0, 1051, 1052, + 7, 4, 0, 0, 1052, 1053, 7, 6, 0, 0, 1053, 1054, 7, 4, 0, 0, 1054, 1055, + 7, 13, 0, 0, 1055, 1056, 7, 5, 0, 0, 1056, 226, 1, 0, 0, 0, 1057, 1058, + 7, 12, 0, 0, 1058, 1059, 7, 4, 0, 0, 1059, 1060, 7, 5, 0, 0, 1060, 228, + 1, 0, 0, 0, 1061, 1062, 7, 12, 0, 0, 1062, 1063, 7, 20, 0, 0, 1063, 1064, + 7, 14, 0, 0, 1064, 1065, 7, 9, 0, 0, 1065, 1066, 7, 13, 0, 0, 1066, 230, + 1, 0, 0, 0, 1067, 1068, 7, 12, 0, 0, 1068, 1069, 7, 5, 0, 0, 1069, 1070, + 7, 0, 0, 0, 1070, 1071, 7, 5, 0, 0, 1071, 1072, 7, 16, 0, 0, 1072, 1073, + 7, 13, 0, 0, 1073, 232, 1, 0, 0, 0, 1074, 1075, 7, 12, 0, 0, 1075, 1076, + 7, 5, 0, 0, 1076, 1077, 7, 7, 0, 0, 1077, 1078, 7, 3, 0, 0, 1078, 1079, + 7, 0, 0, 0, 1079, 1080, 7, 2, 0, 0, 1080, 1081, 7, 4, 0, 0, 1081, 234, + 1, 0, 0, 0, 1082, 1083, 7, 12, 0, 0, 1083, 1084, 7, 5, 0, 0, 1084, 1085, + 7, 10, 0, 0, 1085, 1086, 7, 11, 0, 0, 1086, 1087, 7, 4, 0, 0, 1087, 236, + 1, 0, 0, 0, 1088, 1089, 7, 12, 0, 0, 1089, 1090, 7, 14, 0, 0, 1090, 1091, + 7, 11, 0, 0, 1091, 1092, 7, 4, 0, 0, 1092, 1093, 7, 3, 0, 0, 1093, 1094, + 7, 14, 0, 0, 1094, 1095, 7, 12, 0, 0, 1095, 1096, 7, 4, 0, 0, 1096, 1097, + 7, 3, 0, 0, 1097, 238, 1, 0, 0, 0, 1098, 1099, 7, 5, 0, 0, 1099, 1100, + 7, 0, 0, 0, 1100, 1101, 7, 18, 0, 0, 1101, 1102, 7, 6, 0, 0, 1102, 1103, + 7, 4, 0, 0, 1103, 240, 1, 0, 0, 0, 1104, 1105, 7, 5, 0, 0, 1105, 1106, + 7, 15, 0, 0, 1106, 1107, 7, 3, 0, 0, 1107, 1108, 7, 4, 0, 0, 1108, 1109, + 7, 4, 0, 0, 1109, 242, 1, 0, 0, 0, 1110, 1111, 7, 5, 0, 0, 1111, 1112, + 7, 16, 0, 0, 1112, 1113, 7, 19, 0, 0, 1113, 1114, 7, 4, 0, 0, 1114, 1115, + 7, 12, 0, 0, 1115, 1116, 7, 5, 0, 0, 1116, 1117, 7, 0, 0, 0, 1117, 1118, + 7, 19, 0, 0, 1118, 1119, 7, 11, 0, 0, 1119, 244, 1, 0, 0, 0, 1120, 1121, + 7, 5, 0, 0, 1121, 1122, 7, 7, 0, 0, 1122, 246, 1, 0, 0, 0, 1123, 1124, + 7, 5, 0, 0, 1124, 1125, 7, 7, 0, 0, 1125, 1126, 7, 24, 0, 0, 1126, 1127, + 7, 4, 0, 0, 1127, 1128, 7, 9, 0, 0, 1128, 248, 1, 0, 0, 0, 1129, 1130, + 7, 5, 0, 0, 1130, 1131, 7, 3, 0, 0, 1131, 1132, 7, 16, 0, 0, 1132, 1133, + 7, 2, 0, 0, 1133, 1134, 7, 2, 0, 0, 1134, 1135, 7, 4, 0, 0, 1135, 1136, + 7, 3, 0, 0, 1136, 250, 1, 0, 0, 0, 1137, 1138, 7, 5, 0, 0, 1138, 1139, + 7, 3, 0, 0, 1139, 1140, 7, 14, 0, 0, 1140, 1141, 7, 4, 0, 0, 1141, 252, + 1, 0, 0, 0, 1142, 1143, 7, 5, 0, 0, 1143, 1144, 7, 3, 0, 0, 1144, 1145, + 7, 14, 0, 0, 1145, 1146, 7, 9, 0, 0, 1146, 1147, 7, 13, 0, 0, 1147, 1148, + 7, 0, 0, 0, 1148, 1149, 7, 5, 0, 0, 1149, 1150, 7, 4, 0, 0, 1150, 254, + 1, 0, 0, 0, 1151, 1152, 7, 5, 0, 0, 1152, 1153, 7, 5, 0, 0, 1153, 1154, + 7, 6, 0, 0, 1154, 256, 1, 0, 0, 0, 1155, 1156, 7, 5, 0, 0, 1156, 1157, + 7, 8, 0, 0, 1157, 1158, 7, 7, 0, 0, 1158, 258, 1, 0, 0, 0, 1159, 1160, + 7, 5, 0, 0, 1160, 1161, 7, 10, 0, 0, 1161, 1162, 7, 11, 0, 0, 1162, 1163, + 7, 4, 0, 0, 1163, 260, 1, 0, 0, 0, 1164, 1165, 7, 14, 0, 0, 1165, 1166, + 7, 9, 0, 0, 1166, 1167, 7, 6, 0, 0, 1167, 1168, 7, 7, 0, 0, 1168, 1169, + 7, 2, 0, 0, 1169, 1170, 7, 2, 0, 0, 1170, 1171, 7, 4, 0, 0, 1171, 1172, + 7, 1, 0, 0, 1172, 262, 1, 0, 0, 0, 1173, 1174, 7, 14, 0, 0, 1174, 1175, + 7, 11, 0, 0, 1175, 1176, 7, 1, 0, 0, 1176, 1177, 7, 0, 0, 0, 1177, 1178, + 7, 5, 0, 0, 1178, 1179, 7, 4, 0, 0, 1179, 264, 1, 0, 0, 0, 1180, 1181, + 7, 14, 0, 0, 1181, 1182, 7, 12, 0, 0, 1182, 1183, 7, 4, 0, 0, 1183, 266, + 1, 0, 0, 0, 1184, 1185, 7, 14, 0, 0, 1185, 1186, 7, 12, 0, 0, 1186, 1187, + 7, 4, 0, 0, 1187, 1188, 7, 3, 0, 0, 1188, 268, 1, 0, 0, 0, 1189, 1190, + 7, 14, 0, 0, 1190, 1191, 7, 12, 0, 0, 1191, 1192, 7, 16, 0, 0, 1192, 1193, + 7, 9, 0, 0, 1193, 1194, 7, 2, 0, 0, 1194, 270, 1, 0, 0, 0, 1195, 1196, + 7, 14, 0, 0, 1196, 1197, 7, 14, 0, 0, 1197, 1198, 7, 16, 0, 0, 1198, 1199, + 7, 1, 0, 0, 1199, 272, 1, 0, 0, 0, 1200, 1201, 7, 25, 0, 0, 1201, 1202, + 7, 0, 0, 0, 1202, 1203, 7, 6, 0, 0, 1203, 1204, 7, 14, 0, 0, 1204, 1205, + 7, 4, 0, 0, 1205, 1206, 7, 12, 0, 0, 1206, 274, 1, 0, 0, 0, 1207, 1208, + 7, 25, 0, 0, 1208, 1209, 7, 16, 0, 0, 1209, 1210, 7, 4, 0, 0, 1210, 1211, + 7, 8, 0, 0, 1211, 276, 1, 0, 0, 0, 1212, 1213, 7, 8, 0, 0, 1213, 1214, + 7, 15, 0, 0, 1214, 1215, 7, 4, 0, 0, 1215, 1216, 7, 3, 0, 0, 1216, 1217, + 7, 4, 0, 0, 1217, 278, 1, 0, 0, 0, 1218, 1219, 7, 8, 0, 0, 1219, 1220, + 7, 16, 0, 0, 1220, 1221, 7, 5, 0, 0, 1221, 1222, 7, 15, 0, 0, 1222, 280, + 1, 0, 0, 0, 1223, 1224, 7, 8, 0, 0, 1224, 1225, 7, 3, 0, 0, 1225, 1226, + 7, 16, 0, 0, 1226, 1227, 7, 5, 0, 0, 1227, 1228, 7, 4, 0, 0, 1228, 1229, + 7, 5, 0, 0, 1229, 1230, 7, 16, 0, 0, 1230, 1231, 7, 19, 0, 0, 1231, 1232, + 7, 4, 0, 0, 1232, 282, 1, 0, 0, 0, 1233, 1234, 7, 0, 0, 0, 1234, 1235, + 7, 12, 0, 0, 1235, 1236, 7, 13, 0, 0, 1236, 1237, 7, 16, 0, 0, 1237, 1238, + 7, 16, 0, 0, 1238, 284, 1, 0, 0, 0, 1239, 1240, 7, 18, 0, 0, 1240, 1241, + 7, 16, 0, 0, 1241, 1242, 7, 2, 0, 0, 1242, 1243, 7, 16, 0, 0, 1243, 1244, + 7, 9, 0, 0, 1244, 1245, 7, 5, 0, 0, 1245, 286, 1, 0, 0, 0, 1246, 1247, + 7, 18, 0, 0, 1247, 1248, 7, 6, 0, 0, 1248, 1249, 7, 7, 0, 0, 1249, 1250, + 7, 18, 0, 0, 1250, 288, 1, 0, 0, 0, 1251, 1252, 7, 18, 0, 0, 1252, 1253, + 7, 7, 0, 0, 1253, 1254, 7, 7, 0, 0, 1254, 1255, 7, 6, 0, 0, 1255, 1256, + 7, 4, 0, 0, 1256, 1257, 7, 0, 0, 0, 1257, 1258, 7, 9, 0, 0, 1258, 290, + 1, 0, 0, 0, 1259, 1260, 7, 13, 0, 0, 1260, 1261, 7, 7, 0, 0, 1261, 1262, + 7, 14, 0, 0, 1262, 1263, 7, 9, 0, 0, 1263, 1264, 7, 5, 0, 0, 1264, 1265, + 7, 4, 0, 0, 1265, 1266, 7, 3, 0, 0, 1266, 292, 1, 0, 0, 0, 1267, 1268, + 7, 1, 0, 0, 1268, 1269, 7, 0, 0, 0, 1269, 1270, 7, 5, 0, 0, 1270, 1271, + 7, 4, 0, 0, 1271, 294, 1, 0, 0, 0, 1272, 1273, 7, 1, 0, 0, 1273, 1274, + 7, 4, 0, 0, 1274, 1275, 7, 13, 0, 0, 1275, 1276, 7, 16, 0, 0, 1276, 1277, + 7, 19, 0, 0, 1277, 1278, 7, 0, 0, 0, 1278, 1279, 7, 6, 0, 0, 1279, 296, + 1, 0, 0, 0, 1280, 1281, 7, 1, 0, 0, 1281, 1282, 7, 7, 0, 0, 1282, 1283, + 7, 14, 0, 0, 1283, 1284, 7, 18, 0, 0, 1284, 1285, 7, 6, 0, 0, 1285, 1286, + 7, 4, 0, 0, 1286, 298, 1, 0, 0, 0, 1287, 1288, 7, 20, 0, 0, 1288, 1289, + 7, 6, 0, 0, 1289, 1290, 7, 7, 0, 0, 1290, 1291, 7, 0, 0, 0, 1291, 1292, + 7, 5, 0, 0, 1292, 300, 1, 0, 0, 0, 1293, 1294, 7, 20, 0, 0, 1294, 1295, + 7, 3, 0, 0, 1295, 1296, 7, 7, 0, 0, 1296, 1297, 7, 17, 0, 0, 1297, 1298, + 7, 4, 0, 0, 1298, 1299, 7, 9, 0, 0, 1299, 302, 1, 0, 0, 0, 1300, 1301, + 7, 16, 0, 0, 1301, 1302, 7, 9, 0, 0, 1302, 1303, 7, 4, 0, 0, 1303, 1304, + 7, 5, 0, 0, 1304, 304, 1, 0, 0, 0, 1305, 1306, 7, 16, 0, 0, 1306, 1307, + 7, 9, 0, 0, 1307, 1308, 7, 5, 0, 0, 1308, 306, 1, 0, 0, 0, 1309, 1310, + 7, 6, 0, 0, 1310, 1311, 7, 16, 0, 0, 1311, 1312, 7, 12, 0, 0, 1312, 1313, + 7, 5, 0, 0, 1313, 308, 1, 0, 0, 0, 1314, 1315, 7, 19, 0, 0, 1315, 1316, + 7, 0, 0, 0, 1316, 1317, 7, 11, 0, 0, 1317, 310, 1, 0, 0, 0, 1318, 1319, + 7, 12, 0, 0, 1319, 1320, 7, 19, 0, 0, 1320, 1321, 7, 0, 0, 0, 1321, 1322, + 7, 6, 0, 0, 1322, 1323, 7, 6, 0, 0, 1323, 1324, 7, 16, 0, 0, 1324, 1325, + 7, 9, 0, 0, 1325, 1326, 7, 5, 0, 0, 1326, 312, 1, 0, 0, 0, 1327, 1328, + 7, 5, 0, 0, 1328, 1329, 7, 4, 0, 0, 1329, 1330, 7, 22, 0, 0, 1330, 1331, + 7, 5, 0, 0, 1331, 314, 1, 0, 0, 0, 1332, 1333, 7, 5, 0, 0, 1333, 1334, + 7, 16, 0, 0, 1334, 1335, 7, 19, 0, 0, 1335, 1336, 7, 4, 0, 0, 1336, 1337, + 7, 14, 0, 0, 1337, 1338, 7, 14, 0, 0, 1338, 1339, 7, 16, 0, 0, 1339, 1340, + 7, 1, 0, 0, 1340, 316, 1, 0, 0, 0, 1341, 1342, 7, 5, 0, 0, 1342, 1343, + 7, 16, 0, 0, 1343, 1344, 7, 19, 0, 0, 1344, 1345, 7, 4, 0, 0, 1345, 318, + 1, 0, 0, 0, 1346, 1347, 7, 5, 0, 0, 1347, 1348, 7, 16, 0, 0, 1348, 1349, + 7, 9, 0, 0, 1349, 1350, 7, 10, 0, 0, 1350, 1351, 7, 16, 0, 0, 1351, 1352, + 7, 9, 0, 0, 1352, 1353, 7, 5, 0, 0, 1353, 320, 1, 0, 0, 0, 1354, 1355, + 7, 5, 0, 0, 1355, 1356, 7, 14, 0, 0, 1356, 1357, 7, 11, 0, 0, 1357, 1358, + 7, 6, 0, 0, 1358, 1359, 7, 4, 0, 0, 1359, 322, 1, 0, 0, 0, 1360, 1361, + 7, 25, 0, 0, 1361, 1362, 7, 0, 0, 0, 1362, 1363, 7, 3, 0, 0, 1363, 1364, + 7, 13, 0, 0, 1364, 1365, 7, 15, 0, 0, 1365, 1366, 7, 0, 0, 0, 1366, 1367, + 7, 3, 0, 0, 1367, 324, 1, 0, 0, 0, 1368, 1369, 7, 25, 0, 0, 1369, 1370, + 7, 0, 0, 0, 1370, 1371, 7, 3, 0, 0, 1371, 1372, 7, 16, 0, 0, 1372, 1373, + 7, 9, 0, 0, 1373, 1374, 7, 5, 0, 0, 1374, 326, 1, 0, 0, 0, 1375, 1376, + 5, 36, 0, 0, 1376, 1377, 5, 36, 0, 0, 1377, 1383, 1, 0, 0, 0, 1378, 1382, + 8, 26, 0, 0, 1379, 1380, 5, 36, 0, 0, 1380, 1382, 8, 26, 0, 0, 1381, 1378, + 1, 0, 0, 0, 1381, 1379, 1, 0, 0, 0, 1382, 1385, 1, 0, 0, 0, 1383, 1381, + 1, 0, 0, 0, 1383, 1384, 1, 0, 0, 0, 1384, 1386, 1, 0, 0, 0, 1385, 1383, + 1, 0, 0, 0, 1386, 1387, 5, 36, 0, 0, 1387, 1388, 5, 36, 0, 0, 1388, 328, + 1, 0, 0, 0, 1389, 1397, 5, 39, 0, 0, 1390, 1391, 5, 92, 0, 0, 1391, 1396, + 9, 0, 0, 0, 1392, 1393, 5, 39, 0, 0, 1393, 1396, 5, 39, 0, 0, 1394, 1396, + 8, 27, 0, 0, 1395, 1390, 1, 0, 0, 0, 1395, 1392, 1, 0, 0, 0, 1395, 1394, + 1, 0, 0, 0, 1396, 1399, 1, 0, 0, 0, 1397, 1395, 1, 0, 0, 0, 1397, 1398, + 1, 0, 0, 0, 1398, 1400, 1, 0, 0, 0, 1399, 1397, 1, 0, 0, 0, 1400, 1401, + 5, 39, 0, 0, 1401, 330, 1, 0, 0, 0, 1402, 1404, 3, 355, 177, 0, 1403, 1402, + 1, 0, 0, 0, 1404, 1405, 1, 0, 0, 0, 1405, 1403, 1, 0, 0, 0, 1405, 1406, + 1, 0, 0, 0, 1406, 332, 1, 0, 0, 0, 1407, 1409, 3, 31, 15, 0, 1408, 1407, + 1, 0, 0, 0, 1408, 1409, 1, 0, 0, 0, 1409, 1411, 1, 0, 0, 0, 1410, 1412, + 7, 28, 0, 0, 1411, 1410, 1, 0, 0, 0, 1412, 1413, 1, 0, 0, 0, 1413, 1411, + 1, 0, 0, 0, 1413, 1414, 1, 0, 0, 0, 1414, 1421, 1, 0, 0, 0, 1415, 1417, + 3, 19, 9, 0, 1416, 1418, 7, 28, 0, 0, 1417, 1416, 1, 0, 0, 0, 1418, 1419, + 1, 0, 0, 0, 1419, 1417, 1, 0, 0, 0, 1419, 1420, 1, 0, 0, 0, 1420, 1422, + 1, 0, 0, 0, 1421, 1415, 1, 0, 0, 0, 1421, 1422, 1, 0, 0, 0, 1422, 334, + 1, 0, 0, 0, 1423, 1424, 7, 22, 0, 0, 1424, 1428, 5, 39, 0, 0, 1425, 1426, + 3, 353, 176, 0, 1426, 1427, 3, 353, 176, 0, 1427, 1429, 1, 0, 0, 0, 1428, + 1425, 1, 0, 0, 0, 1429, 1430, 1, 0, 0, 0, 1430, 1428, 1, 0, 0, 0, 1430, + 1431, 1, 0, 0, 0, 1431, 1432, 1, 0, 0, 0, 1432, 1433, 5, 39, 0, 0, 1433, + 1443, 1, 0, 0, 0, 1434, 1435, 5, 48, 0, 0, 1435, 1436, 7, 22, 0, 0, 1436, + 1438, 1, 0, 0, 0, 1437, 1439, 3, 353, 176, 0, 1438, 1437, 1, 0, 0, 0, 1439, + 1440, 1, 0, 0, 0, 1440, 1438, 1, 0, 0, 0, 1440, 1441, 1, 0, 0, 0, 1441, + 1443, 1, 0, 0, 0, 1442, 1423, 1, 0, 0, 0, 1442, 1434, 1, 0, 0, 0, 1443, + 336, 1, 0, 0, 0, 1444, 1446, 3, 355, 177, 0, 1445, 1444, 1, 0, 0, 0, 1446, + 1447, 1, 0, 0, 0, 1447, 1445, 1, 0, 0, 0, 1447, 1448, 1, 0, 0, 0, 1448, + 1450, 1, 0, 0, 0, 1449, 1451, 5, 46, 0, 0, 1450, 1449, 1, 0, 0, 0, 1450, + 1451, 1, 0, 0, 0, 1451, 1452, 1, 0, 0, 0, 1452, 1453, 3, 357, 178, 0, 1453, + 1470, 1, 0, 0, 0, 1454, 1456, 3, 355, 177, 0, 1455, 1454, 1, 0, 0, 0, 1456, + 1459, 1, 0, 0, 0, 1457, 1455, 1, 0, 0, 0, 1457, 1458, 1, 0, 0, 0, 1458, + 1460, 1, 0, 0, 0, 1459, 1457, 1, 0, 0, 0, 1460, 1462, 5, 46, 0, 0, 1461, + 1463, 3, 355, 177, 0, 1462, 1461, 1, 0, 0, 0, 1463, 1464, 1, 0, 0, 0, 1464, + 1462, 1, 0, 0, 0, 1464, 1465, 1, 0, 0, 0, 1465, 1467, 1, 0, 0, 0, 1466, + 1468, 3, 357, 178, 0, 1467, 1466, 1, 0, 0, 0, 1467, 1468, 1, 0, 0, 0, 1468, + 1470, 1, 0, 0, 0, 1469, 1445, 1, 0, 0, 0, 1469, 1457, 1, 0, 0, 0, 1470, + 338, 1, 0, 0, 0, 1471, 1475, 7, 29, 0, 0, 1472, 1474, 7, 30, 0, 0, 1473, + 1472, 1, 0, 0, 0, 1474, 1477, 1, 0, 0, 0, 1475, 1473, 1, 0, 0, 0, 1475, + 1476, 1, 0, 0, 0, 1476, 1486, 1, 0, 0, 0, 1477, 1475, 1, 0, 0, 0, 1478, + 1480, 5, 34, 0, 0, 1479, 1481, 8, 31, 0, 0, 1480, 1479, 1, 0, 0, 0, 1481, + 1482, 1, 0, 0, 0, 1482, 1480, 1, 0, 0, 0, 1482, 1483, 1, 0, 0, 0, 1483, + 1484, 1, 0, 0, 0, 1484, 1486, 5, 34, 0, 0, 1485, 1471, 1, 0, 0, 0, 1485, + 1478, 1, 0, 0, 0, 1486, 340, 1, 0, 0, 0, 1487, 1488, 3, 351, 175, 0, 1488, + 1489, 3, 351, 175, 0, 1489, 1490, 5, 45, 0, 0, 1490, 1491, 3, 351, 175, + 0, 1491, 1492, 5, 45, 0, 0, 1492, 1493, 3, 351, 175, 0, 1493, 1494, 5, + 45, 0, 0, 1494, 1495, 3, 351, 175, 0, 1495, 1496, 5, 45, 0, 0, 1496, 1497, + 3, 351, 175, 0, 1497, 1498, 3, 351, 175, 0, 1498, 1499, 3, 351, 175, 0, + 1499, 342, 1, 0, 0, 0, 1500, 1502, 7, 32, 0, 0, 1501, 1500, 1, 0, 0, 0, + 1502, 1503, 1, 0, 0, 0, 1503, 1501, 1, 0, 0, 0, 1503, 1504, 1, 0, 0, 0, + 1504, 1505, 1, 0, 0, 0, 1505, 1506, 6, 171, 0, 0, 1506, 344, 1, 0, 0, 0, + 1507, 1508, 5, 47, 0, 0, 1508, 1509, 5, 42, 0, 0, 1509, 1510, 5, 33, 0, + 0, 1510, 1512, 1, 0, 0, 0, 1511, 1513, 9, 0, 0, 0, 1512, 1511, 1, 0, 0, + 0, 1513, 1514, 1, 0, 0, 0, 1514, 1515, 1, 0, 0, 0, 1514, 1512, 1, 0, 0, + 0, 1515, 1516, 1, 0, 0, 0, 1516, 1517, 5, 42, 0, 0, 1517, 1518, 5, 47, + 0, 0, 1518, 1519, 1, 0, 0, 0, 1519, 1520, 6, 172, 0, 0, 1520, 346, 1, 0, + 0, 0, 1521, 1522, 5, 47, 0, 0, 1522, 1523, 5, 42, 0, 0, 1523, 1527, 1, + 0, 0, 0, 1524, 1526, 9, 0, 0, 0, 1525, 1524, 1, 0, 0, 0, 1526, 1529, 1, + 0, 0, 0, 1527, 1528, 1, 0, 0, 0, 1527, 1525, 1, 0, 0, 0, 1528, 1530, 1, + 0, 0, 0, 1529, 1527, 1, 0, 0, 0, 1530, 1531, 5, 42, 0, 0, 1531, 1532, 5, + 47, 0, 0, 1532, 1533, 1, 0, 0, 0, 1533, 1534, 6, 173, 0, 0, 1534, 348, + 1, 0, 0, 0, 1535, 1536, 5, 45, 0, 0, 1536, 1537, 5, 45, 0, 0, 1537, 1542, + 5, 32, 0, 0, 1538, 1542, 5, 35, 0, 0, 1539, 1540, 5, 47, 0, 0, 1540, 1542, + 5, 47, 0, 0, 1541, 1535, 1, 0, 0, 0, 1541, 1538, 1, 0, 0, 0, 1541, 1539, + 1, 0, 0, 0, 1542, 1546, 1, 0, 0, 0, 1543, 1545, 8, 33, 0, 0, 1544, 1543, + 1, 0, 0, 0, 1545, 1548, 1, 0, 0, 0, 1546, 1544, 1, 0, 0, 0, 1546, 1547, + 1, 0, 0, 0, 1547, 1554, 1, 0, 0, 0, 1548, 1546, 1, 0, 0, 0, 1549, 1551, + 5, 13, 0, 0, 1550, 1549, 1, 0, 0, 0, 1550, 1551, 1, 0, 0, 0, 1551, 1552, + 1, 0, 0, 0, 1552, 1555, 5, 10, 0, 0, 1553, 1555, 5, 0, 0, 1, 1554, 1550, + 1, 0, 0, 0, 1554, 1553, 1, 0, 0, 0, 1555, 1567, 1, 0, 0, 0, 1556, 1557, + 5, 45, 0, 0, 1557, 1558, 5, 45, 0, 0, 1558, 1564, 1, 0, 0, 0, 1559, 1561, + 5, 13, 0, 0, 1560, 1559, 1, 0, 0, 0, 1560, 1561, 1, 0, 0, 0, 1561, 1562, + 1, 0, 0, 0, 1562, 1565, 5, 10, 0, 0, 1563, 1565, 5, 0, 0, 1, 1564, 1560, + 1, 0, 0, 0, 1564, 1563, 1, 0, 0, 0, 1565, 1567, 1, 0, 0, 0, 1566, 1541, + 1, 0, 0, 0, 1566, 1556, 1, 0, 0, 0, 1567, 1568, 1, 0, 0, 0, 1568, 1569, + 6, 174, 0, 0, 1569, 350, 1, 0, 0, 0, 1570, 1571, 7, 34, 0, 0, 1571, 1572, + 7, 34, 0, 0, 1572, 1573, 7, 34, 0, 0, 1573, 1574, 7, 34, 0, 0, 1574, 352, + 1, 0, 0, 0, 1575, 1576, 7, 34, 0, 0, 1576, 354, 1, 0, 0, 0, 1577, 1578, + 7, 28, 0, 0, 1578, 356, 1, 0, 0, 0, 1579, 1581, 7, 4, 0, 0, 1580, 1582, + 5, 45, 0, 0, 1581, 1580, 1, 0, 0, 0, 1581, 1582, 1, 0, 0, 0, 1582, 1584, + 1, 0, 0, 0, 1583, 1585, 3, 355, 177, 0, 1584, 1583, 1, 0, 0, 0, 1585, 1586, + 1, 0, 0, 0, 1586, 1584, 1, 0, 0, 0, 1586, 1587, 1, 0, 0, 0, 1587, 358, + 1, 0, 0, 0, 34, 0, 1381, 1383, 1395, 1397, 1405, 1408, 1413, 1419, 1421, + 1430, 1440, 1442, 1447, 1450, 1457, 1464, 1467, 1469, 1475, 1482, 1485, + 1503, 1514, 1527, 1541, 1546, 1550, 1554, 1560, 1564, 1566, 1581, 1586, + 1, 0, 1, 0, + } + deserializer := antlr.NewATNDeserializer(nil) + staticData.atn = deserializer.Deserialize(staticData.serializedATN) + atn := staticData.atn + staticData.decisionToDFA = make([]*antlr.DFA, len(atn.DecisionToState)) + decisionToDFA := staticData.decisionToDFA + for index, state := range atn.DecisionToState { + decisionToDFA[index] = antlr.NewDFA(state, index) + } +} + +// CqlLexerInit initializes any static state used to implement CqlLexer. By default the +// static state used to implement the lexer is lazily initialized during the first call to +// NewCqlLexer(). You can call this function if you wish to initialize the static state ahead +// of time. +func CqlLexerInit() { + staticData := &CqlLexerLexerStaticData + staticData.once.Do(cqllexerLexerInit) +} + +// NewCqlLexer produces a new lexer instance for the optional input antlr.CharStream. +func NewCqlLexer(input antlr.CharStream) *CqlLexer { + CqlLexerInit() + l := new(CqlLexer) + l.BaseLexer = antlr.NewBaseLexer(input) + staticData := &CqlLexerLexerStaticData + l.Interpreter = antlr.NewLexerATNSimulator(l, staticData.atn, staticData.decisionToDFA, staticData.PredictionContextCache) + l.channelNames = staticData.ChannelNames + l.modeNames = staticData.ModeNames + l.RuleNames = staticData.RuleNames + l.LiteralNames = staticData.LiteralNames + l.SymbolicNames = staticData.SymbolicNames + l.GrammarFileName = "CqlLexer.g4" + // TODO: l.EOF = antlr.TokenEOF + + return l +} + +// CqlLexer tokens. +const ( + CqlLexerLR_BRACKET = 1 + CqlLexerRR_BRACKET = 2 + CqlLexerLC_BRACKET = 3 + CqlLexerRC_BRACKET = 4 + CqlLexerLS_BRACKET = 5 + CqlLexerRS_BRACKET = 6 + CqlLexerCOMMA = 7 + CqlLexerSEMI = 8 + CqlLexerCOLON = 9 + CqlLexerDOT = 10 + CqlLexerSTAR = 11 + CqlLexerDIVIDE = 12 + CqlLexerMODULE = 13 + CqlLexerPLUS = 14 + CqlLexerMINUSMINUS = 15 + CqlLexerMINUS = 16 + CqlLexerDQUOTE = 17 + CqlLexerSQUOTE = 18 + CqlLexerOPERATOR_EQ = 19 + CqlLexerOPERATOR_LT = 20 + CqlLexerOPERATOR_GT = 21 + CqlLexerOPERATOR_LTE = 22 + CqlLexerOPERATOR_GTE = 23 + CqlLexerK_ADD = 24 + CqlLexerK_AGGREGATE = 25 + CqlLexerK_ALL = 26 + CqlLexerK_ALLOW = 27 + CqlLexerK_ALTER = 28 + CqlLexerK_AND = 29 + CqlLexerK_ANY = 30 + CqlLexerK_APPLY = 31 + CqlLexerK_AS = 32 + CqlLexerK_ASC = 33 + CqlLexerK_AUTHORIZE = 34 + CqlLexerK_BATCH = 35 + CqlLexerK_BEGIN = 36 + CqlLexerK_BY = 37 + CqlLexerK_CALLED = 38 + CqlLexerK_CLUSTERING = 39 + CqlLexerK_COLUMNFAMILY = 40 + CqlLexerK_COMPACT = 41 + CqlLexerK_CONSISTENCY = 42 + CqlLexerK_CONTAINS = 43 + CqlLexerK_CREATE = 44 + CqlLexerK_CUSTOM = 45 + CqlLexerK_DELETE = 46 + CqlLexerK_DESC = 47 + CqlLexerK_DESCRIBE = 48 + CqlLexerK_DISTINCT = 49 + CqlLexerK_DROP = 50 + CqlLexerK_DURABLE_WRITES = 51 + CqlLexerK_EACH_QUORUM = 52 + CqlLexerK_ENTRIES = 53 + CqlLexerK_EXECUTE = 54 + CqlLexerK_EXISTS = 55 + CqlLexerK_FALSE = 56 + CqlLexerK_FILTERING = 57 + CqlLexerK_FINALFUNC = 58 + CqlLexerK_FROM = 59 + CqlLexerK_FULL = 60 + CqlLexerK_FUNCTION = 61 + CqlLexerK_FUNCTIONS = 62 + CqlLexerK_GRANT = 63 + CqlLexerK_IF = 64 + CqlLexerK_IN = 65 + CqlLexerK_INDEX = 66 + CqlLexerK_INFINITY = 67 + CqlLexerK_INITCOND = 68 + CqlLexerK_INPUT = 69 + CqlLexerK_INSERT = 70 + CqlLexerK_INTO = 71 + CqlLexerK_IS = 72 + CqlLexerK_JSON = 73 + CqlLexerK_KEY = 74 + CqlLexerK_KEYS = 75 + CqlLexerK_KEYSPACE = 76 + CqlLexerK_KEYSPACES = 77 + CqlLexerK_LANGUAGE = 78 + CqlLexerK_LEVEL = 79 + CqlLexerK_LIMIT = 80 + CqlLexerK_LOCAL_ONE = 81 + CqlLexerK_LOCAL_QUORUM = 82 + CqlLexerK_LOGGED = 83 + CqlLexerK_LOGIN = 84 + CqlLexerK_MATERIALIZED = 85 + CqlLexerK_MODIFY = 86 + CqlLexerK_NAN = 87 + CqlLexerK_NORECURSIVE = 88 + CqlLexerK_NOSUPERUSER = 89 + CqlLexerK_NOT = 90 + CqlLexerK_NULL = 91 + CqlLexerK_OF = 92 + CqlLexerK_ON = 93 + CqlLexerK_ONE = 94 + CqlLexerK_OPTIONS = 95 + CqlLexerK_OR = 96 + CqlLexerK_ORDER = 97 + CqlLexerK_PARTITION = 98 + CqlLexerK_PASSWORD = 99 + CqlLexerK_PER = 100 + CqlLexerK_PERMISSION = 101 + CqlLexerK_PERMISSIONS = 102 + CqlLexerK_PRIMARY = 103 + CqlLexerK_QUORUM = 104 + CqlLexerK_RENAME = 105 + CqlLexerK_REPLACE = 106 + CqlLexerK_REPLICATION = 107 + CqlLexerK_RETURNS = 108 + CqlLexerK_REVOKE = 109 + CqlLexerK_ROLE = 110 + CqlLexerK_ROLES = 111 + CqlLexerK_SCHEMA = 112 + CqlLexerK_SELECT = 113 + CqlLexerK_SET = 114 + CqlLexerK_SFUNC = 115 + CqlLexerK_STATIC = 116 + CqlLexerK_STORAGE = 117 + CqlLexerK_STYPE = 118 + CqlLexerK_SUPERUSER = 119 + CqlLexerK_TABLE = 120 + CqlLexerK_THREE = 121 + CqlLexerK_TIMESTAMP = 122 + CqlLexerK_TO = 123 + CqlLexerK_TOKEN = 124 + CqlLexerK_TRIGGER = 125 + CqlLexerK_TRUE = 126 + CqlLexerK_TRUNCATE = 127 + CqlLexerK_TTL = 128 + CqlLexerK_TWO = 129 + CqlLexerK_TYPE = 130 + CqlLexerK_UNLOGGED = 131 + CqlLexerK_UPDATE = 132 + CqlLexerK_USE = 133 + CqlLexerK_USER = 134 + CqlLexerK_USING = 135 + CqlLexerK_UUID = 136 + CqlLexerK_VALUES = 137 + CqlLexerK_VIEW = 138 + CqlLexerK_WHERE = 139 + CqlLexerK_WITH = 140 + CqlLexerK_WRITETIME = 141 + CqlLexerK_ASCII = 142 + CqlLexerK_BIGINT = 143 + CqlLexerK_BLOB = 144 + CqlLexerK_BOOLEAN = 145 + CqlLexerK_COUNTER = 146 + CqlLexerK_DATE = 147 + CqlLexerK_DECIMAL = 148 + CqlLexerK_DOUBLE = 149 + CqlLexerK_FLOAT = 150 + CqlLexerK_FROZEN = 151 + CqlLexerK_INET = 152 + CqlLexerK_INT = 153 + CqlLexerK_LIST = 154 + CqlLexerK_MAP = 155 + CqlLexerK_SMALLINT = 156 + CqlLexerK_TEXT = 157 + CqlLexerK_TIMEUUID = 158 + CqlLexerK_TIME = 159 + CqlLexerK_TINYINT = 160 + CqlLexerK_TUPLE = 161 + CqlLexerK_VARCHAR = 162 + CqlLexerK_VARINT = 163 + CqlLexerCODE_BLOCK = 164 + CqlLexerSTRING_LITERAL = 165 + CqlLexerDECIMAL_LITERAL = 166 + CqlLexerFLOAT_LITERAL = 167 + CqlLexerHEXADECIMAL_LITERAL = 168 + CqlLexerREAL_LITERAL = 169 + CqlLexerOBJECT_NAME = 170 + CqlLexerUUID = 171 + CqlLexerSPACE = 172 + CqlLexerSPEC_MYSQL_COMMENT = 173 + CqlLexerCOMMENT_INPUT = 174 + CqlLexerLINE_COMMENT = 175 +) diff --git a/cql/cql_parser.go b/cql/cql_parser.go new file mode 100644 index 0000000..57ea1c5 --- /dev/null +++ b/cql/cql_parser.go @@ -0,0 +1,49391 @@ +// Code generated from CqlParser.g4 by ANTLR 4.13.2. DO NOT EDIT. + +package cql // CqlParser +import ( + "fmt" + "strconv" + "sync" + + "github.com/antlr4-go/antlr/v4" +) + +// Suppress unused import errors +var _ = fmt.Printf +var _ = strconv.Itoa +var _ = sync.Once{} + +type CqlParser struct { + *antlr.BaseParser +} + +var CqlParserParserStaticData struct { + once sync.Once + serializedATN []int32 + LiteralNames []string + SymbolicNames []string + RuleNames []string + PredictionContextCache *antlr.PredictionContextCache + atn *antlr.ATN + decisionToDFA []*antlr.DFA +} + +func cqlparserParserInit() { + staticData := &CqlParserParserStaticData + staticData.LiteralNames = []string{ + "", "'('", "')'", "'{'", "'}'", "'['", "']'", "','", "';'", "':'", "'.'", + "'*'", "'/'", "'%'", "'+'", "'--'", "'-'", "'\"'", "'''", "'='", "'<'", + "'>'", "'<='", "'>='", "'ADD'", "'AGGREGATE'", "'ALL'", "'ALLOW'", "'ALTER'", + "'AND'", "'ANY'", "'APPLY'", "'AS'", "'ASC'", "'AUTHORIZE'", "'BATCH'", + "'BEGIN'", "'BY'", "'CALLED'", "'CLUSTERING'", "'COLUMNFAMILY'", "'COMPACT'", + "'CONSISTENCY'", "'CONTAINS'", "'CREATE'", "'CUSTOM'", "'DELETE'", "'DESC'", + "'DESCRIBE'", "'DISTINCT'", "'DROP'", "'DURABLE_WRITES'", "'EACH_QUORUM'", + "'ENTRIES'", "'EXECUTE'", "'EXISTS'", "'FALSE'", "'FILTERING'", "'FINALFUNC'", + "'FROM'", "'FULL'", "'FUNCTION'", "'FUNCTIONS'", "'GRANT'", "'IF'", + "'IN'", "'INDEX'", "'INFINITY'", "'INITCOND'", "'INPUT'", "'INSERT'", + "'INTO'", "'IS'", "'JSON'", "'KEY'", "'KEYS'", "'KEYSPACE'", "'KEYSPACES'", + "'LANGUAGE'", "'LEVEL'", "'LIMIT'", "'LOCAL_ONE'", "'LOCAL_QUORUM'", + "'LOGGED'", "'LOGIN'", "'MATERIALIZED'", "'MODIFY'", "'NAN'", "'NORECURSIVE'", + "'NOSUPERUSER'", "'NOT'", "'NULL'", "'OF'", "'ON'", "'ONE'", "'OPTIONS'", + "'OR'", "'ORDER'", "'PARTITION'", "'PASSWORD'", "'PER'", "'PERMISSION'", + "'PERMISSIONS'", "'PRIMARY'", "'QUORUM'", "'RENAME'", "'REPLACE'", "'REPLICATION'", + "'RETURNS'", "'REVOKE'", "'ROLE'", "'ROLES'", "'SCHEMA'", "'SELECT'", + "'SET'", "'SFUNC'", "'STATIC'", "'STORAGE'", "'STYPE'", "'SUPERUSER'", + "'TABLE'", "'THREE'", "'TIMESTAMP'", "'TO'", "'TOKEN'", "'TRIGGER'", + "'TRUE'", "'TRUNCATE'", "'TTL'", "'TWO'", "'TYPE'", "'UNLOGGED'", "'UPDATE'", + "'USE'", "'USER'", "'USING'", "'UUID'", "'VALUES'", "'VIEW'", "'WHERE'", + "'WITH'", "'WRITETIME'", "'ASCII'", "'BIGINT'", "'BLOB'", "'BOOLEAN'", + "'COUNTER'", "'DATE'", "'DECIMAL'", "'DOUBLE'", "'FLOAT'", "'FROZEN'", + "'INET'", "'INT'", "'LIST'", "'MAP'", "'SMALLINT'", "'TEXT'", "'TIMEUUID'", + "'TIME'", "'TINYINT'", "'TUPLE'", "'VARCHAR'", "'VARINT'", + } + staticData.SymbolicNames = []string{ + "", "LR_BRACKET", "RR_BRACKET", "LC_BRACKET", "RC_BRACKET", "LS_BRACKET", + "RS_BRACKET", "COMMA", "SEMI", "COLON", "DOT", "STAR", "DIVIDE", "MODULE", + "PLUS", "MINUSMINUS", "MINUS", "DQUOTE", "SQUOTE", "OPERATOR_EQ", "OPERATOR_LT", + "OPERATOR_GT", "OPERATOR_LTE", "OPERATOR_GTE", "K_ADD", "K_AGGREGATE", + "K_ALL", "K_ALLOW", "K_ALTER", "K_AND", "K_ANY", "K_APPLY", "K_AS", + "K_ASC", "K_AUTHORIZE", "K_BATCH", "K_BEGIN", "K_BY", "K_CALLED", "K_CLUSTERING", + "K_COLUMNFAMILY", "K_COMPACT", "K_CONSISTENCY", "K_CONTAINS", "K_CREATE", + "K_CUSTOM", "K_DELETE", "K_DESC", "K_DESCRIBE", "K_DISTINCT", "K_DROP", + "K_DURABLE_WRITES", "K_EACH_QUORUM", "K_ENTRIES", "K_EXECUTE", "K_EXISTS", + "K_FALSE", "K_FILTERING", "K_FINALFUNC", "K_FROM", "K_FULL", "K_FUNCTION", + "K_FUNCTIONS", "K_GRANT", "K_IF", "K_IN", "K_INDEX", "K_INFINITY", "K_INITCOND", + "K_INPUT", "K_INSERT", "K_INTO", "K_IS", "K_JSON", "K_KEY", "K_KEYS", + "K_KEYSPACE", "K_KEYSPACES", "K_LANGUAGE", "K_LEVEL", "K_LIMIT", "K_LOCAL_ONE", + "K_LOCAL_QUORUM", "K_LOGGED", "K_LOGIN", "K_MATERIALIZED", "K_MODIFY", + "K_NAN", "K_NORECURSIVE", "K_NOSUPERUSER", "K_NOT", "K_NULL", "K_OF", + "K_ON", "K_ONE", "K_OPTIONS", "K_OR", "K_ORDER", "K_PARTITION", "K_PASSWORD", + "K_PER", "K_PERMISSION", "K_PERMISSIONS", "K_PRIMARY", "K_QUORUM", "K_RENAME", + "K_REPLACE", "K_REPLICATION", "K_RETURNS", "K_REVOKE", "K_ROLE", "K_ROLES", + "K_SCHEMA", "K_SELECT", "K_SET", "K_SFUNC", "K_STATIC", "K_STORAGE", + "K_STYPE", "K_SUPERUSER", "K_TABLE", "K_THREE", "K_TIMESTAMP", "K_TO", + "K_TOKEN", "K_TRIGGER", "K_TRUE", "K_TRUNCATE", "K_TTL", "K_TWO", "K_TYPE", + "K_UNLOGGED", "K_UPDATE", "K_USE", "K_USER", "K_USING", "K_UUID", "K_VALUES", + "K_VIEW", "K_WHERE", "K_WITH", "K_WRITETIME", "K_ASCII", "K_BIGINT", + "K_BLOB", "K_BOOLEAN", "K_COUNTER", "K_DATE", "K_DECIMAL", "K_DOUBLE", + "K_FLOAT", "K_FROZEN", "K_INET", "K_INT", "K_LIST", "K_MAP", "K_SMALLINT", + "K_TEXT", "K_TIMEUUID", "K_TIME", "K_TINYINT", "K_TUPLE", "K_VARCHAR", + "K_VARINT", "CODE_BLOCK", "STRING_LITERAL", "DECIMAL_LITERAL", "FLOAT_LITERAL", + "HEXADECIMAL_LITERAL", "REAL_LITERAL", "OBJECT_NAME", "UUID", "SPACE", + "SPEC_MYSQL_COMMENT", "COMMENT_INPUT", "LINE_COMMENT", + } + staticData.RuleNames = []string{ + "root", "cqls", "statementSeparator", "empty_", "cql", "revoke", "listRoles", + "listPermissions", "grant", "priviledge", "resource", "createUser", + "createRole", "createType", "typeMemberColumnList", "createTrigger", + "createMaterializedView", "materializedViewWhere", "columnNotNullList", + "columnNotNull", "materializedViewOptions", "createKeyspace", "createFunction", + "codeBlock", "paramList", "returnMode", "createAggregate", "initCondDefinition", + "initCondHash", "initCondHashItem", "initCondListNested", "initCondList", + "orReplace", "alterUser", "userPassword", "userSuperUser", "alterType", + "alterTypeOperation", "alterTypeRename", "alterTypeRenameList", "alterTypeRenameItem", + "alterTypeAdd", "alterTypeAlterType", "alterTable", "alterTableOperation", + "alterTableWith", "alterTableRename", "alterTableDropCompactStorage", + "alterTableDropColumns", "alterTableDropColumnList", "alterTableAdd", + "alterTableColumnDefinition", "alterRole", "roleWith", "roleWithOptions", + "alterMaterializedView", "dropUser", "dropType", "dropMaterializedView", + "dropAggregate", "dropFunction", "dropTrigger", "dropRole", "dropTable", + "dropKeyspace", "dropIndex", "createTable", "withElement", "tableOptions", + "clusteringOrder", "tableOptionItem", "tableOptionName", "tableOptionValue", + "optionHash", "optionHashItem", "optionHashKey", "optionHashValue", + "columnDefinitionList", "columnDefinition", "primaryKeyColumn", "primaryKeyElement", + "primaryKeyDefinition", "singlePrimaryKey", "compoundKey", "compositeKey", + "partitionKeyList", "clusteringKeyList", "partitionKey", "clusteringKey", + "applyBatch", "beginBatch", "batchType", "alterKeyspace", "replicationList", + "replicationListItem", "durableWrites", "use_", "truncate", "createIndex", + "indexName", "indexColumnSpec", "indexKeysSpec", "indexEntriesSSpec", + "indexFullSpec", "delete_", "deleteColumnList", "deleteColumnItem", + "update", "ifSpec", "ifConditionList", "ifCondition", "assignments", + "assignmentElement", "assignmentSet", "assignmentMap", "assignmentList", + "assignmentTuple", "insert", "usingTtlTimestamp", "timestamp", "ttl", + "usingTimestampSpec", "ifNotExist", "ifExist", "insertValuesSpec", "insertColumnSpec", + "columnList", "expressionList", "expression", "select_", "allowFilteringSpec", + "limitSpec", "fromSpec", "fromSpecElement", "orderSpec", "orderSpecElement", + "whereSpec", "distinctSpec", "selectElements", "selectElement", "relationElements", + "relationElement", "relalationContains", "relalationContainsKey", "functionCall", + "functionArgs", "constant", "decimalLiteral", "floatLiteral", "stringLiteral", + "booleanLiteral", "hexadecimalLiteral", "keyspace", "table", "column", + "dataType", "dataTypeName", "dataTypeDefinition", "orderDirection", + "role", "trigger", "triggerClass", "materializedView", "type_", "aggregate", + "function_", "language", "user", "password", "hashKey", "param", "paramName", + "kwAdd", "kwAggregate", "kwAll", "kwAllPermissions", "kwAllow", "kwAlter", + "kwAnd", "kwApply", "kwAs", "kwAsc", "kwAuthorize", "kwBatch", "kwBegin", + "kwBy", "kwCalled", "kwClustering", "kwCompact", "kwContains", "kwCreate", + "kwDelete", "kwDesc", "kwDescibe", "kwDistinct", "kwDrop", "kwDurableWrites", + "kwEntries", "kwExecute", "kwExists", "kwFiltering", "kwFinalfunc", + "kwFrom", "kwFull", "kwFunction", "kwFunctions", "kwGrant", "kwIf", + "kwIn", "kwIndex", "kwInitcond", "kwInput", "kwInsert", "kwInto", "kwIs", + "kwJson", "kwKey", "kwKeys", "kwKeyspace", "kwKeyspaces", "kwLanguage", + "kwLimit", "kwList", "kwLogged", "kwLogin", "kwMaterialized", "kwModify", + "kwNosuperuser", "kwNorecursive", "kwNot", "kwNull", "kwOf", "kwOn", + "kwOptions", "kwOr", "kwOrder", "kwPassword", "kwPrimary", "kwRename", + "kwReplace", "kwReplication", "kwReturns", "kwRole", "kwRoles", "kwSelect", + "kwSet", "kwSfunc", "kwStorage", "kwStype", "kwSuperuser", "kwTable", + "kwTimestamp", "kwTo", "kwTrigger", "kwTruncate", "kwTtl", "kwType", + "kwUnlogged", "kwUpdate", "kwUse", "kwUser", "kwUsing", "kwValues", + "kwView", "kwWhere", "kwWith", "kwRevoke", "syntaxBracketLr", "syntaxBracketRr", + "syntaxBracketLc", "syntaxBracketRc", "syntaxBracketLa", "syntaxBracketRa", + "syntaxBracketLs", "syntaxBracketRs", "syntaxComma", "syntaxColon", + } + staticData.PredictionContextCache = antlr.NewPredictionContextCache() + staticData.serializedATN = []int32{ + 4, 1, 175, 2320, 2, 0, 7, 0, 2, 1, 7, 1, 2, 2, 7, 2, 2, 3, 7, 3, 2, 4, + 7, 4, 2, 5, 7, 5, 2, 6, 7, 6, 2, 7, 7, 7, 2, 8, 7, 8, 2, 9, 7, 9, 2, 10, + 7, 10, 2, 11, 7, 11, 2, 12, 7, 12, 2, 13, 7, 13, 2, 14, 7, 14, 2, 15, 7, + 15, 2, 16, 7, 16, 2, 17, 7, 17, 2, 18, 7, 18, 2, 19, 7, 19, 2, 20, 7, 20, + 2, 21, 7, 21, 2, 22, 7, 22, 2, 23, 7, 23, 2, 24, 7, 24, 2, 25, 7, 25, 2, + 26, 7, 26, 2, 27, 7, 27, 2, 28, 7, 28, 2, 29, 7, 29, 2, 30, 7, 30, 2, 31, + 7, 31, 2, 32, 7, 32, 2, 33, 7, 33, 2, 34, 7, 34, 2, 35, 7, 35, 2, 36, 7, + 36, 2, 37, 7, 37, 2, 38, 7, 38, 2, 39, 7, 39, 2, 40, 7, 40, 2, 41, 7, 41, + 2, 42, 7, 42, 2, 43, 7, 43, 2, 44, 7, 44, 2, 45, 7, 45, 2, 46, 7, 46, 2, + 47, 7, 47, 2, 48, 7, 48, 2, 49, 7, 49, 2, 50, 7, 50, 2, 51, 7, 51, 2, 52, + 7, 52, 2, 53, 7, 53, 2, 54, 7, 54, 2, 55, 7, 55, 2, 56, 7, 56, 2, 57, 7, + 57, 2, 58, 7, 58, 2, 59, 7, 59, 2, 60, 7, 60, 2, 61, 7, 61, 2, 62, 7, 62, + 2, 63, 7, 63, 2, 64, 7, 64, 2, 65, 7, 65, 2, 66, 7, 66, 2, 67, 7, 67, 2, + 68, 7, 68, 2, 69, 7, 69, 2, 70, 7, 70, 2, 71, 7, 71, 2, 72, 7, 72, 2, 73, + 7, 73, 2, 74, 7, 74, 2, 75, 7, 75, 2, 76, 7, 76, 2, 77, 7, 77, 2, 78, 7, + 78, 2, 79, 7, 79, 2, 80, 7, 80, 2, 81, 7, 81, 2, 82, 7, 82, 2, 83, 7, 83, + 2, 84, 7, 84, 2, 85, 7, 85, 2, 86, 7, 86, 2, 87, 7, 87, 2, 88, 7, 88, 2, + 89, 7, 89, 2, 90, 7, 90, 2, 91, 7, 91, 2, 92, 7, 92, 2, 93, 7, 93, 2, 94, + 7, 94, 2, 95, 7, 95, 2, 96, 7, 96, 2, 97, 7, 97, 2, 98, 7, 98, 2, 99, 7, + 99, 2, 100, 7, 100, 2, 101, 7, 101, 2, 102, 7, 102, 2, 103, 7, 103, 2, + 104, 7, 104, 2, 105, 7, 105, 2, 106, 7, 106, 2, 107, 7, 107, 2, 108, 7, + 108, 2, 109, 7, 109, 2, 110, 7, 110, 2, 111, 7, 111, 2, 112, 7, 112, 2, + 113, 7, 113, 2, 114, 7, 114, 2, 115, 7, 115, 2, 116, 7, 116, 2, 117, 7, + 117, 2, 118, 7, 118, 2, 119, 7, 119, 2, 120, 7, 120, 2, 121, 7, 121, 2, + 122, 7, 122, 2, 123, 7, 123, 2, 124, 7, 124, 2, 125, 7, 125, 2, 126, 7, + 126, 2, 127, 7, 127, 2, 128, 7, 128, 2, 129, 7, 129, 2, 130, 7, 130, 2, + 131, 7, 131, 2, 132, 7, 132, 2, 133, 7, 133, 2, 134, 7, 134, 2, 135, 7, + 135, 2, 136, 7, 136, 2, 137, 7, 137, 2, 138, 7, 138, 2, 139, 7, 139, 2, + 140, 7, 140, 2, 141, 7, 141, 2, 142, 7, 142, 2, 143, 7, 143, 2, 144, 7, + 144, 2, 145, 7, 145, 2, 146, 7, 146, 2, 147, 7, 147, 2, 148, 7, 148, 2, + 149, 7, 149, 2, 150, 7, 150, 2, 151, 7, 151, 2, 152, 7, 152, 2, 153, 7, + 153, 2, 154, 7, 154, 2, 155, 7, 155, 2, 156, 7, 156, 2, 157, 7, 157, 2, + 158, 7, 158, 2, 159, 7, 159, 2, 160, 7, 160, 2, 161, 7, 161, 2, 162, 7, + 162, 2, 163, 7, 163, 2, 164, 7, 164, 2, 165, 7, 165, 2, 166, 7, 166, 2, + 167, 7, 167, 2, 168, 7, 168, 2, 169, 7, 169, 2, 170, 7, 170, 2, 171, 7, + 171, 2, 172, 7, 172, 2, 173, 7, 173, 2, 174, 7, 174, 2, 175, 7, 175, 2, + 176, 7, 176, 2, 177, 7, 177, 2, 178, 7, 178, 2, 179, 7, 179, 2, 180, 7, + 180, 2, 181, 7, 181, 2, 182, 7, 182, 2, 183, 7, 183, 2, 184, 7, 184, 2, + 185, 7, 185, 2, 186, 7, 186, 2, 187, 7, 187, 2, 188, 7, 188, 2, 189, 7, + 189, 2, 190, 7, 190, 2, 191, 7, 191, 2, 192, 7, 192, 2, 193, 7, 193, 2, + 194, 7, 194, 2, 195, 7, 195, 2, 196, 7, 196, 2, 197, 7, 197, 2, 198, 7, + 198, 2, 199, 7, 199, 2, 200, 7, 200, 2, 201, 7, 201, 2, 202, 7, 202, 2, + 203, 7, 203, 2, 204, 7, 204, 2, 205, 7, 205, 2, 206, 7, 206, 2, 207, 7, + 207, 2, 208, 7, 208, 2, 209, 7, 209, 2, 210, 7, 210, 2, 211, 7, 211, 2, + 212, 7, 212, 2, 213, 7, 213, 2, 214, 7, 214, 2, 215, 7, 215, 2, 216, 7, + 216, 2, 217, 7, 217, 2, 218, 7, 218, 2, 219, 7, 219, 2, 220, 7, 220, 2, + 221, 7, 221, 2, 222, 7, 222, 2, 223, 7, 223, 2, 224, 7, 224, 2, 225, 7, + 225, 2, 226, 7, 226, 2, 227, 7, 227, 2, 228, 7, 228, 2, 229, 7, 229, 2, + 230, 7, 230, 2, 231, 7, 231, 2, 232, 7, 232, 2, 233, 7, 233, 2, 234, 7, + 234, 2, 235, 7, 235, 2, 236, 7, 236, 2, 237, 7, 237, 2, 238, 7, 238, 2, + 239, 7, 239, 2, 240, 7, 240, 2, 241, 7, 241, 2, 242, 7, 242, 2, 243, 7, + 243, 2, 244, 7, 244, 2, 245, 7, 245, 2, 246, 7, 246, 2, 247, 7, 247, 2, + 248, 7, 248, 2, 249, 7, 249, 2, 250, 7, 250, 2, 251, 7, 251, 2, 252, 7, + 252, 2, 253, 7, 253, 2, 254, 7, 254, 2, 255, 7, 255, 2, 256, 7, 256, 2, + 257, 7, 257, 2, 258, 7, 258, 2, 259, 7, 259, 2, 260, 7, 260, 2, 261, 7, + 261, 2, 262, 7, 262, 2, 263, 7, 263, 2, 264, 7, 264, 2, 265, 7, 265, 2, + 266, 7, 266, 2, 267, 7, 267, 2, 268, 7, 268, 2, 269, 7, 269, 2, 270, 7, + 270, 2, 271, 7, 271, 2, 272, 7, 272, 2, 273, 7, 273, 2, 274, 7, 274, 2, + 275, 7, 275, 2, 276, 7, 276, 1, 0, 3, 0, 556, 8, 0, 1, 0, 3, 0, 559, 8, + 0, 1, 0, 1, 0, 1, 1, 1, 1, 3, 1, 565, 8, 1, 1, 1, 1, 1, 1, 1, 5, 1, 570, + 8, 1, 10, 1, 12, 1, 573, 9, 1, 1, 1, 1, 1, 3, 1, 577, 8, 1, 1, 1, 3, 1, + 580, 8, 1, 1, 1, 3, 1, 583, 8, 1, 1, 2, 1, 2, 1, 3, 1, 3, 1, 4, 1, 4, 1, + 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, + 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, + 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 3, 4, 626, + 8, 4, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 6, 1, 6, 1, 6, 1, 6, + 1, 6, 3, 6, 640, 8, 6, 1, 6, 3, 6, 643, 8, 6, 1, 7, 1, 7, 1, 7, 1, 7, 1, + 7, 3, 7, 650, 8, 7, 1, 7, 1, 7, 1, 7, 3, 7, 655, 8, 7, 1, 8, 1, 8, 1, 8, + 1, 8, 1, 8, 1, 8, 1, 8, 1, 9, 1, 9, 3, 9, 666, 8, 9, 1, 9, 1, 9, 1, 9, + 1, 9, 1, 9, 1, 9, 1, 9, 1, 9, 3, 9, 676, 8, 9, 1, 10, 1, 10, 1, 10, 1, + 10, 1, 10, 1, 10, 1, 10, 1, 10, 1, 10, 1, 10, 1, 10, 1, 10, 1, 10, 3, 10, + 691, 8, 10, 1, 10, 1, 10, 1, 10, 1, 10, 1, 10, 1, 10, 1, 10, 1, 10, 1, + 10, 3, 10, 702, 8, 10, 1, 10, 1, 10, 1, 10, 3, 10, 707, 8, 10, 1, 10, 1, + 10, 1, 10, 1, 10, 1, 10, 1, 10, 1, 10, 3, 10, 716, 8, 10, 1, 11, 1, 11, + 1, 11, 3, 11, 721, 8, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 3, + 11, 729, 8, 11, 1, 12, 1, 12, 1, 12, 3, 12, 734, 8, 12, 1, 12, 1, 12, 3, + 12, 738, 8, 12, 1, 13, 1, 13, 1, 13, 3, 13, 743, 8, 13, 1, 13, 1, 13, 1, + 13, 3, 13, 748, 8, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 14, 1, 14, + 1, 14, 1, 14, 1, 14, 1, 14, 5, 14, 761, 8, 14, 10, 14, 12, 14, 764, 9, + 14, 1, 15, 1, 15, 1, 15, 3, 15, 769, 8, 15, 1, 15, 1, 15, 1, 15, 3, 15, + 774, 8, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 16, 1, 16, 1, 16, 1, 16, 3, + 16, 784, 8, 16, 1, 16, 1, 16, 1, 16, 3, 16, 789, 8, 16, 1, 16, 1, 16, 1, + 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 3, 16, 799, 8, 16, 1, 16, 1, 16, + 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 3, 16, 811, 8, + 16, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 3, 17, 818, 8, 17, 1, 18, 1, 18, + 1, 18, 1, 18, 5, 18, 824, 8, 18, 10, 18, 12, 18, 827, 9, 18, 1, 19, 1, + 19, 1, 19, 1, 19, 1, 19, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 3, 20, + 840, 8, 20, 1, 21, 1, 21, 1, 21, 3, 21, 845, 8, 21, 1, 21, 1, 21, 1, 21, + 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 3, 21, 857, 8, 21, 1, + 22, 1, 22, 3, 22, 861, 8, 22, 1, 22, 1, 22, 3, 22, 865, 8, 22, 1, 22, 1, + 22, 1, 22, 3, 22, 870, 8, 22, 1, 22, 1, 22, 1, 22, 3, 22, 875, 8, 22, 1, + 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 23, 1, 23, + 1, 24, 1, 24, 1, 24, 1, 24, 5, 24, 892, 8, 24, 10, 24, 12, 24, 895, 9, + 24, 1, 25, 1, 25, 1, 25, 1, 25, 3, 25, 901, 8, 25, 1, 25, 1, 25, 1, 25, + 1, 25, 1, 26, 1, 26, 3, 26, 909, 8, 26, 1, 26, 1, 26, 3, 26, 913, 8, 26, + 1, 26, 1, 26, 1, 26, 3, 26, 918, 8, 26, 1, 26, 1, 26, 1, 26, 1, 26, 1, + 26, 1, 26, 1, 26, 1, 26, 1, 26, 1, 26, 1, 26, 1, 26, 1, 26, 1, 27, 1, 27, + 1, 27, 1, 27, 3, 27, 937, 8, 27, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 5, + 28, 944, 8, 28, 10, 28, 12, 28, 947, 9, 28, 1, 28, 1, 28, 1, 29, 1, 29, + 1, 29, 1, 29, 1, 30, 1, 30, 1, 30, 1, 30, 1, 30, 1, 30, 5, 30, 961, 8, + 30, 10, 30, 12, 30, 964, 9, 30, 1, 30, 1, 30, 1, 31, 1, 31, 1, 31, 1, 31, + 1, 31, 5, 31, 973, 8, 31, 10, 31, 12, 31, 976, 9, 31, 1, 31, 1, 31, 1, + 32, 1, 32, 1, 32, 1, 33, 1, 33, 1, 33, 1, 33, 1, 33, 1, 33, 3, 33, 989, + 8, 33, 1, 34, 1, 34, 1, 34, 1, 35, 1, 35, 3, 35, 996, 8, 35, 1, 36, 1, + 36, 1, 36, 1, 36, 1, 36, 3, 36, 1003, 8, 36, 1, 36, 1, 36, 1, 36, 1, 37, + 1, 37, 1, 37, 3, 37, 1011, 8, 37, 1, 38, 1, 38, 1, 38, 1, 39, 1, 39, 1, + 39, 1, 39, 5, 39, 1020, 8, 39, 10, 39, 12, 39, 1023, 9, 39, 1, 40, 1, 40, + 1, 40, 1, 40, 1, 41, 1, 41, 1, 41, 1, 41, 1, 41, 1, 41, 1, 41, 5, 41, 1036, + 8, 41, 10, 41, 12, 41, 1039, 9, 41, 1, 42, 1, 42, 1, 42, 1, 42, 1, 42, + 1, 43, 1, 43, 1, 43, 1, 43, 1, 43, 3, 43, 1051, 8, 43, 1, 43, 1, 43, 1, + 43, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 3, 44, 1061, 8, 44, 1, 45, 1, 45, + 1, 45, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 47, 1, 47, 1, 47, 1, 47, 1, + 48, 1, 48, 1, 48, 1, 49, 1, 49, 1, 49, 1, 49, 5, 49, 1082, 8, 49, 10, 49, + 12, 49, 1085, 9, 49, 1, 50, 1, 50, 1, 50, 1, 51, 1, 51, 1, 51, 1, 51, 1, + 51, 1, 51, 5, 51, 1096, 8, 51, 10, 51, 12, 51, 1099, 9, 51, 1, 52, 1, 52, + 1, 52, 1, 52, 3, 52, 1105, 8, 52, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 5, + 53, 1112, 8, 53, 10, 53, 12, 53, 1115, 9, 53, 1, 54, 1, 54, 1, 54, 1, 54, + 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, + 54, 1, 54, 3, 54, 1133, 8, 54, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, + 3, 55, 1141, 8, 55, 1, 55, 1, 55, 1, 55, 1, 55, 3, 55, 1147, 8, 55, 1, + 56, 1, 56, 1, 56, 3, 56, 1152, 8, 56, 1, 56, 1, 56, 1, 57, 1, 57, 1, 57, + 3, 57, 1159, 8, 57, 1, 57, 1, 57, 1, 57, 3, 57, 1164, 8, 57, 1, 57, 1, + 57, 1, 58, 1, 58, 1, 58, 1, 58, 3, 58, 1172, 8, 58, 1, 58, 1, 58, 1, 58, + 3, 58, 1177, 8, 58, 1, 58, 1, 58, 1, 59, 1, 59, 1, 59, 3, 59, 1184, 8, + 59, 1, 59, 1, 59, 1, 59, 3, 59, 1189, 8, 59, 1, 59, 1, 59, 1, 60, 1, 60, + 1, 60, 3, 60, 1196, 8, 60, 1, 60, 1, 60, 1, 60, 3, 60, 1201, 8, 60, 1, + 60, 1, 60, 1, 61, 1, 61, 1, 61, 3, 61, 1208, 8, 61, 1, 61, 1, 61, 1, 61, + 1, 61, 1, 61, 3, 61, 1215, 8, 61, 1, 61, 1, 61, 1, 62, 1, 62, 1, 62, 3, + 62, 1222, 8, 62, 1, 62, 1, 62, 1, 63, 1, 63, 1, 63, 3, 63, 1229, 8, 63, + 1, 63, 1, 63, 1, 63, 3, 63, 1234, 8, 63, 1, 63, 1, 63, 1, 64, 1, 64, 1, + 64, 3, 64, 1241, 8, 64, 1, 64, 1, 64, 1, 65, 1, 65, 1, 65, 3, 65, 1248, + 8, 65, 1, 65, 1, 65, 1, 65, 3, 65, 1253, 8, 65, 1, 65, 1, 65, 1, 66, 1, + 66, 1, 66, 3, 66, 1260, 8, 66, 1, 66, 1, 66, 1, 66, 3, 66, 1265, 8, 66, + 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 3, 66, 1272, 8, 66, 1, 67, 1, 67, 1, + 67, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 3, 68, 1282, 8, 68, 1, 68, 1, 68, + 1, 68, 1, 68, 3, 68, 1288, 8, 68, 1, 68, 1, 68, 1, 68, 1, 68, 5, 68, 1294, + 8, 68, 10, 68, 12, 68, 1297, 9, 68, 3, 68, 1299, 8, 68, 1, 69, 1, 69, 1, + 69, 1, 69, 1, 69, 1, 69, 3, 69, 1307, 8, 69, 1, 69, 1, 69, 1, 69, 3, 69, + 1312, 8, 69, 5, 69, 1314, 8, 69, 10, 69, 12, 69, 1317, 9, 69, 1, 69, 1, + 69, 1, 70, 1, 70, 1, 70, 1, 70, 1, 70, 1, 70, 1, 70, 1, 70, 3, 70, 1329, + 8, 70, 1, 71, 1, 71, 1, 72, 1, 72, 3, 72, 1335, 8, 72, 1, 73, 1, 73, 1, + 73, 1, 73, 1, 73, 5, 73, 1342, 8, 73, 10, 73, 12, 73, 1345, 9, 73, 1, 73, + 1, 73, 1, 74, 1, 74, 1, 74, 1, 74, 1, 75, 1, 75, 1, 76, 1, 76, 3, 76, 1357, + 8, 76, 1, 77, 1, 77, 1, 77, 1, 77, 5, 77, 1363, 8, 77, 10, 77, 12, 77, + 1366, 9, 77, 1, 77, 1, 77, 1, 77, 3, 77, 1371, 8, 77, 1, 78, 1, 78, 1, + 78, 3, 78, 1376, 8, 78, 1, 79, 1, 79, 1, 79, 1, 80, 1, 80, 1, 80, 1, 80, + 1, 80, 1, 80, 1, 81, 1, 81, 1, 81, 3, 81, 1390, 8, 81, 1, 82, 1, 82, 1, + 83, 1, 83, 1, 83, 1, 83, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 85, + 1, 85, 1, 85, 1, 85, 5, 85, 1408, 8, 85, 10, 85, 12, 85, 1411, 9, 85, 1, + 86, 1, 86, 1, 86, 1, 86, 5, 86, 1417, 8, 86, 10, 86, 12, 86, 1420, 9, 86, + 1, 87, 1, 87, 1, 88, 1, 88, 1, 89, 1, 89, 1, 89, 1, 90, 1, 90, 3, 90, 1431, + 8, 90, 1, 90, 1, 90, 3, 90, 1435, 8, 90, 1, 91, 1, 91, 3, 91, 1439, 8, + 91, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, + 1, 92, 1, 92, 3, 92, 1453, 8, 92, 1, 93, 1, 93, 1, 93, 1, 93, 5, 93, 1459, + 8, 93, 10, 93, 12, 93, 1462, 9, 93, 1, 94, 1, 94, 1, 94, 1, 94, 1, 94, + 1, 94, 3, 94, 1470, 8, 94, 1, 95, 1, 95, 1, 95, 1, 95, 1, 96, 1, 96, 1, + 96, 1, 97, 1, 97, 3, 97, 1481, 8, 97, 1, 97, 1, 97, 1, 97, 3, 97, 1486, + 8, 97, 1, 97, 1, 97, 1, 98, 1, 98, 1, 98, 3, 98, 1493, 8, 98, 1, 98, 3, + 98, 1496, 8, 98, 1, 98, 1, 98, 1, 98, 1, 98, 3, 98, 1502, 8, 98, 1, 98, + 1, 98, 1, 98, 1, 98, 1, 98, 1, 99, 1, 99, 3, 99, 1511, 8, 99, 1, 100, 1, + 100, 1, 100, 1, 100, 3, 100, 1517, 8, 100, 1, 101, 1, 101, 1, 101, 1, 101, + 1, 101, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 1, 103, 1, 103, 1, 103, + 1, 103, 1, 103, 1, 104, 3, 104, 1535, 8, 104, 1, 104, 1, 104, 3, 104, 1539, + 8, 104, 1, 104, 1, 104, 3, 104, 1543, 8, 104, 1, 104, 1, 104, 1, 104, 3, + 104, 1548, 8, 104, 1, 105, 1, 105, 1, 105, 1, 105, 5, 105, 1554, 8, 105, + 10, 105, 12, 105, 1557, 9, 105, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, + 3, 106, 1564, 8, 106, 1, 106, 1, 106, 3, 106, 1568, 8, 106, 1, 107, 3, + 107, 1571, 8, 107, 1, 107, 1, 107, 1, 107, 1, 107, 3, 107, 1577, 8, 107, + 1, 107, 1, 107, 3, 107, 1581, 8, 107, 1, 107, 1, 107, 1, 107, 1, 107, 1, + 107, 3, 107, 1588, 8, 107, 1, 108, 1, 108, 1, 108, 1, 109, 1, 109, 1, 109, + 1, 109, 5, 109, 1597, 8, 109, 10, 109, 12, 109, 1600, 9, 109, 1, 110, 1, + 110, 1, 110, 1, 110, 1, 111, 1, 111, 1, 111, 1, 111, 5, 111, 1610, 8, 111, + 10, 111, 12, 111, 1613, 9, 111, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, + 1, 112, 3, 112, 1621, 8, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, + 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, + 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, + 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, + 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, + 112, 1, 112, 1, 112, 1, 112, 3, 112, 1668, 8, 112, 1, 113, 1, 113, 1, 113, + 1, 113, 1, 113, 5, 113, 1675, 8, 113, 10, 113, 12, 113, 1678, 9, 113, 3, + 113, 1680, 8, 113, 1, 113, 1, 113, 1, 114, 1, 114, 1, 114, 1, 114, 1, 114, + 1, 114, 1, 114, 1, 114, 1, 114, 1, 114, 5, 114, 1694, 8, 114, 10, 114, + 12, 114, 1697, 9, 114, 1, 114, 1, 114, 1, 115, 1, 115, 1, 115, 1, 115, + 1, 115, 5, 115, 1706, 8, 115, 10, 115, 12, 115, 1709, 9, 115, 1, 115, 1, + 115, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 5, 116, 1718, 8, 116, 10, + 116, 12, 116, 1721, 9, 116, 1, 116, 1, 116, 1, 117, 3, 117, 1726, 8, 117, + 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 3, 117, 1733, 8, 117, 1, 117, 1, + 117, 3, 117, 1737, 8, 117, 1, 117, 1, 117, 3, 117, 1741, 8, 117, 1, 117, + 3, 117, 1744, 8, 117, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, + 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, + 118, 3, 118, 1762, 8, 118, 1, 119, 1, 119, 1, 119, 1, 120, 1, 120, 1, 120, + 1, 121, 1, 121, 1, 121, 1, 122, 1, 122, 1, 122, 1, 122, 1, 123, 1, 123, + 1, 123, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, + 3, 124, 1788, 8, 124, 1, 125, 1, 125, 1, 125, 1, 125, 1, 126, 1, 126, 1, + 126, 1, 126, 5, 126, 1798, 8, 126, 10, 126, 12, 126, 1801, 9, 126, 1, 127, + 1, 127, 1, 127, 1, 127, 5, 127, 1807, 8, 127, 10, 127, 12, 127, 1810, 9, + 127, 1, 128, 1, 128, 1, 128, 1, 128, 1, 128, 1, 128, 3, 128, 1818, 8, 128, + 1, 129, 1, 129, 3, 129, 1822, 8, 129, 1, 129, 3, 129, 1825, 8, 129, 1, + 129, 1, 129, 1, 129, 3, 129, 1830, 8, 129, 1, 129, 3, 129, 1833, 8, 129, + 1, 129, 3, 129, 1836, 8, 129, 1, 129, 3, 129, 1839, 8, 129, 1, 130, 1, + 130, 1, 130, 1, 131, 1, 131, 1, 131, 1, 132, 1, 132, 1, 132, 1, 133, 1, + 133, 1, 133, 1, 133, 3, 133, 1854, 8, 133, 1, 134, 1, 134, 1, 134, 1, 134, + 1, 135, 1, 135, 1, 135, 3, 135, 1863, 8, 135, 1, 136, 1, 136, 1, 136, 1, + 137, 1, 137, 1, 138, 1, 138, 3, 138, 1872, 8, 138, 1, 138, 1, 138, 1, 138, + 5, 138, 1877, 8, 138, 10, 138, 12, 138, 1880, 9, 138, 1, 139, 1, 139, 1, + 139, 1, 139, 1, 139, 1, 139, 1, 139, 3, 139, 1889, 8, 139, 1, 139, 1, 139, + 1, 139, 1, 139, 3, 139, 1895, 8, 139, 3, 139, 1897, 8, 139, 1, 140, 1, + 140, 1, 140, 1, 140, 5, 140, 1903, 8, 140, 10, 140, 12, 140, 1906, 9, 140, + 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, + 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, + 1, 141, 1, 141, 3, 141, 1928, 8, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, + 141, 1, 141, 1, 141, 5, 141, 1937, 8, 141, 10, 141, 12, 141, 1940, 9, 141, + 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 5, 141, 1949, 8, + 141, 10, 141, 12, 141, 1952, 9, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, + 141, 1, 141, 1, 141, 5, 141, 1961, 8, 141, 10, 141, 12, 141, 1964, 9, 141, + 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 5, 141, 1972, 8, 141, 10, + 141, 12, 141, 1975, 9, 141, 1, 141, 1, 141, 3, 141, 1979, 8, 141, 1, 142, + 1, 142, 1, 142, 1, 142, 1, 143, 1, 143, 1, 143, 1, 143, 1, 143, 1, 143, + 1, 144, 1, 144, 1, 144, 1, 144, 1, 144, 1, 144, 1, 144, 3, 144, 1998, 8, + 144, 1, 144, 1, 144, 1, 144, 1, 144, 3, 144, 2004, 8, 144, 1, 145, 1, 145, + 1, 145, 3, 145, 2009, 8, 145, 1, 145, 1, 145, 1, 145, 1, 145, 3, 145, 2015, + 8, 145, 5, 145, 2017, 8, 145, 10, 145, 12, 145, 2020, 9, 145, 1, 146, 1, + 146, 1, 146, 1, 146, 1, 146, 1, 146, 1, 146, 1, 146, 3, 146, 2030, 8, 146, + 1, 147, 1, 147, 1, 148, 1, 148, 1, 149, 1, 149, 1, 150, 1, 150, 1, 151, + 1, 151, 1, 152, 1, 152, 1, 152, 1, 152, 3, 152, 2046, 8, 152, 1, 153, 1, + 153, 1, 153, 1, 153, 3, 153, 2052, 8, 153, 1, 154, 1, 154, 1, 154, 1, 154, + 3, 154, 2058, 8, 154, 1, 155, 1, 155, 3, 155, 2062, 8, 155, 1, 156, 1, + 156, 1, 157, 1, 157, 1, 157, 1, 157, 1, 157, 5, 157, 2071, 8, 157, 10, + 157, 12, 157, 2074, 9, 157, 1, 157, 1, 157, 1, 158, 1, 158, 3, 158, 2080, + 8, 158, 1, 159, 1, 159, 1, 160, 1, 160, 1, 161, 1, 161, 1, 162, 1, 162, + 1, 163, 1, 163, 1, 164, 1, 164, 1, 165, 1, 165, 1, 166, 1, 166, 1, 167, + 1, 167, 1, 168, 1, 168, 1, 169, 1, 169, 1, 170, 1, 170, 1, 170, 1, 171, + 1, 171, 1, 172, 1, 172, 1, 173, 1, 173, 1, 174, 1, 174, 1, 175, 1, 175, + 1, 175, 1, 176, 1, 176, 1, 177, 1, 177, 1, 178, 1, 178, 1, 179, 1, 179, + 1, 180, 1, 180, 1, 181, 1, 181, 1, 182, 1, 182, 1, 183, 1, 183, 1, 184, + 1, 184, 1, 185, 1, 185, 1, 186, 1, 186, 1, 187, 1, 187, 1, 188, 1, 188, + 1, 189, 1, 189, 1, 190, 1, 190, 1, 191, 1, 191, 1, 192, 1, 192, 1, 193, + 1, 193, 1, 194, 1, 194, 1, 195, 1, 195, 1, 196, 1, 196, 1, 197, 1, 197, + 1, 198, 1, 198, 1, 199, 1, 199, 1, 200, 1, 200, 1, 201, 1, 201, 1, 202, + 1, 202, 1, 203, 1, 203, 1, 204, 1, 204, 1, 205, 1, 205, 1, 206, 1, 206, + 1, 207, 1, 207, 1, 208, 1, 208, 1, 209, 1, 209, 1, 210, 1, 210, 1, 211, + 1, 211, 1, 212, 1, 212, 1, 213, 1, 213, 1, 214, 1, 214, 1, 215, 1, 215, + 1, 216, 1, 216, 1, 217, 1, 217, 1, 218, 1, 218, 1, 219, 1, 219, 1, 220, + 1, 220, 1, 221, 1, 221, 1, 222, 1, 222, 1, 223, 1, 223, 1, 224, 1, 224, + 1, 225, 1, 225, 1, 226, 1, 226, 1, 227, 1, 227, 1, 228, 1, 228, 1, 229, + 1, 229, 1, 230, 1, 230, 1, 231, 1, 231, 1, 232, 1, 232, 1, 233, 1, 233, + 1, 234, 1, 234, 1, 235, 1, 235, 1, 236, 1, 236, 1, 237, 1, 237, 1, 238, + 1, 238, 1, 239, 1, 239, 1, 240, 1, 240, 1, 241, 1, 241, 1, 242, 1, 242, + 1, 243, 1, 243, 1, 244, 1, 244, 1, 245, 1, 245, 1, 246, 1, 246, 1, 247, + 1, 247, 1, 248, 1, 248, 1, 249, 1, 249, 1, 250, 1, 250, 1, 251, 1, 251, + 1, 252, 1, 252, 1, 253, 1, 253, 1, 254, 1, 254, 1, 255, 1, 255, 1, 256, + 1, 256, 1, 257, 1, 257, 1, 258, 1, 258, 1, 259, 1, 259, 1, 260, 1, 260, + 1, 261, 1, 261, 1, 262, 1, 262, 1, 263, 1, 263, 1, 264, 1, 264, 1, 265, + 1, 265, 1, 266, 1, 266, 1, 267, 1, 267, 1, 268, 1, 268, 1, 269, 1, 269, + 1, 270, 1, 270, 1, 271, 1, 271, 1, 272, 1, 272, 1, 273, 1, 273, 1, 274, + 1, 274, 1, 275, 1, 275, 1, 276, 1, 276, 1, 276, 0, 0, 277, 0, 2, 4, 6, + 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38, 40, 42, + 44, 46, 48, 50, 52, 54, 56, 58, 60, 62, 64, 66, 68, 70, 72, 74, 76, 78, + 80, 82, 84, 86, 88, 90, 92, 94, 96, 98, 100, 102, 104, 106, 108, 110, 112, + 114, 116, 118, 120, 122, 124, 126, 128, 130, 132, 134, 136, 138, 140, 142, + 144, 146, 148, 150, 152, 154, 156, 158, 160, 162, 164, 166, 168, 170, 172, + 174, 176, 178, 180, 182, 184, 186, 188, 190, 192, 194, 196, 198, 200, 202, + 204, 206, 208, 210, 212, 214, 216, 218, 220, 222, 224, 226, 228, 230, 232, + 234, 236, 238, 240, 242, 244, 246, 248, 250, 252, 254, 256, 258, 260, 262, + 264, 266, 268, 270, 272, 274, 276, 278, 280, 282, 284, 286, 288, 290, 292, + 294, 296, 298, 300, 302, 304, 306, 308, 310, 312, 314, 316, 318, 320, 322, + 324, 326, 328, 330, 332, 334, 336, 338, 340, 342, 344, 346, 348, 350, 352, + 354, 356, 358, 360, 362, 364, 366, 368, 370, 372, 374, 376, 378, 380, 382, + 384, 386, 388, 390, 392, 394, 396, 398, 400, 402, 404, 406, 408, 410, 412, + 414, 416, 418, 420, 422, 424, 426, 428, 430, 432, 434, 436, 438, 440, 442, + 444, 446, 448, 450, 452, 454, 456, 458, 460, 462, 464, 466, 468, 470, 472, + 474, 476, 478, 480, 482, 484, 486, 488, 490, 492, 494, 496, 498, 500, 502, + 504, 506, 508, 510, 512, 514, 516, 518, 520, 522, 524, 526, 528, 530, 532, + 534, 536, 538, 540, 542, 544, 546, 548, 550, 552, 0, 7, 1, 0, 164, 165, + 2, 0, 14, 14, 16, 16, 1, 0, 19, 23, 1, 0, 166, 167, 2, 0, 56, 56, 126, + 126, 5, 0, 114, 114, 122, 122, 136, 136, 142, 163, 170, 170, 2, 0, 69, + 69, 170, 170, 2317, 0, 555, 1, 0, 0, 0, 2, 571, 1, 0, 0, 0, 4, 584, 1, + 0, 0, 0, 6, 586, 1, 0, 0, 0, 8, 625, 1, 0, 0, 0, 10, 627, 1, 0, 0, 0, 12, + 634, 1, 0, 0, 0, 14, 644, 1, 0, 0, 0, 16, 656, 1, 0, 0, 0, 18, 675, 1, + 0, 0, 0, 20, 715, 1, 0, 0, 0, 22, 717, 1, 0, 0, 0, 24, 730, 1, 0, 0, 0, + 26, 739, 1, 0, 0, 0, 28, 754, 1, 0, 0, 0, 30, 765, 1, 0, 0, 0, 32, 779, + 1, 0, 0, 0, 34, 812, 1, 0, 0, 0, 36, 819, 1, 0, 0, 0, 38, 828, 1, 0, 0, + 0, 40, 839, 1, 0, 0, 0, 42, 841, 1, 0, 0, 0, 44, 858, 1, 0, 0, 0, 46, 885, + 1, 0, 0, 0, 48, 887, 1, 0, 0, 0, 50, 900, 1, 0, 0, 0, 52, 906, 1, 0, 0, + 0, 54, 936, 1, 0, 0, 0, 56, 938, 1, 0, 0, 0, 58, 950, 1, 0, 0, 0, 60, 954, + 1, 0, 0, 0, 62, 967, 1, 0, 0, 0, 64, 979, 1, 0, 0, 0, 66, 982, 1, 0, 0, + 0, 68, 990, 1, 0, 0, 0, 70, 995, 1, 0, 0, 0, 72, 997, 1, 0, 0, 0, 74, 1010, + 1, 0, 0, 0, 76, 1012, 1, 0, 0, 0, 78, 1015, 1, 0, 0, 0, 80, 1024, 1, 0, + 0, 0, 82, 1028, 1, 0, 0, 0, 84, 1040, 1, 0, 0, 0, 86, 1045, 1, 0, 0, 0, + 88, 1060, 1, 0, 0, 0, 90, 1062, 1, 0, 0, 0, 92, 1065, 1, 0, 0, 0, 94, 1070, + 1, 0, 0, 0, 96, 1074, 1, 0, 0, 0, 98, 1077, 1, 0, 0, 0, 100, 1086, 1, 0, + 0, 0, 102, 1089, 1, 0, 0, 0, 104, 1100, 1, 0, 0, 0, 106, 1106, 1, 0, 0, + 0, 108, 1132, 1, 0, 0, 0, 110, 1134, 1, 0, 0, 0, 112, 1148, 1, 0, 0, 0, + 114, 1155, 1, 0, 0, 0, 116, 1167, 1, 0, 0, 0, 118, 1180, 1, 0, 0, 0, 120, + 1192, 1, 0, 0, 0, 122, 1204, 1, 0, 0, 0, 124, 1218, 1, 0, 0, 0, 126, 1225, + 1, 0, 0, 0, 128, 1237, 1, 0, 0, 0, 130, 1244, 1, 0, 0, 0, 132, 1256, 1, + 0, 0, 0, 134, 1273, 1, 0, 0, 0, 136, 1298, 1, 0, 0, 0, 138, 1300, 1, 0, + 0, 0, 140, 1328, 1, 0, 0, 0, 142, 1330, 1, 0, 0, 0, 144, 1334, 1, 0, 0, + 0, 146, 1336, 1, 0, 0, 0, 148, 1348, 1, 0, 0, 0, 150, 1352, 1, 0, 0, 0, + 152, 1356, 1, 0, 0, 0, 154, 1358, 1, 0, 0, 0, 156, 1372, 1, 0, 0, 0, 158, + 1377, 1, 0, 0, 0, 160, 1380, 1, 0, 0, 0, 162, 1389, 1, 0, 0, 0, 164, 1391, + 1, 0, 0, 0, 166, 1393, 1, 0, 0, 0, 168, 1397, 1, 0, 0, 0, 170, 1403, 1, + 0, 0, 0, 172, 1412, 1, 0, 0, 0, 174, 1421, 1, 0, 0, 0, 176, 1423, 1, 0, + 0, 0, 178, 1425, 1, 0, 0, 0, 180, 1428, 1, 0, 0, 0, 182, 1438, 1, 0, 0, + 0, 184, 1440, 1, 0, 0, 0, 186, 1454, 1, 0, 0, 0, 188, 1469, 1, 0, 0, 0, + 190, 1471, 1, 0, 0, 0, 192, 1475, 1, 0, 0, 0, 194, 1478, 1, 0, 0, 0, 196, + 1489, 1, 0, 0, 0, 198, 1510, 1, 0, 0, 0, 200, 1516, 1, 0, 0, 0, 202, 1518, + 1, 0, 0, 0, 204, 1523, 1, 0, 0, 0, 206, 1528, 1, 0, 0, 0, 208, 1534, 1, + 0, 0, 0, 210, 1549, 1, 0, 0, 0, 212, 1567, 1, 0, 0, 0, 214, 1570, 1, 0, + 0, 0, 216, 1589, 1, 0, 0, 0, 218, 1592, 1, 0, 0, 0, 220, 1601, 1, 0, 0, + 0, 222, 1605, 1, 0, 0, 0, 224, 1667, 1, 0, 0, 0, 226, 1669, 1, 0, 0, 0, + 228, 1683, 1, 0, 0, 0, 230, 1700, 1, 0, 0, 0, 232, 1712, 1, 0, 0, 0, 234, + 1725, 1, 0, 0, 0, 236, 1761, 1, 0, 0, 0, 238, 1763, 1, 0, 0, 0, 240, 1766, + 1, 0, 0, 0, 242, 1769, 1, 0, 0, 0, 244, 1772, 1, 0, 0, 0, 246, 1776, 1, + 0, 0, 0, 248, 1787, 1, 0, 0, 0, 250, 1789, 1, 0, 0, 0, 252, 1793, 1, 0, + 0, 0, 254, 1802, 1, 0, 0, 0, 256, 1817, 1, 0, 0, 0, 258, 1819, 1, 0, 0, + 0, 260, 1840, 1, 0, 0, 0, 262, 1843, 1, 0, 0, 0, 264, 1846, 1, 0, 0, 0, + 266, 1853, 1, 0, 0, 0, 268, 1855, 1, 0, 0, 0, 270, 1859, 1, 0, 0, 0, 272, + 1864, 1, 0, 0, 0, 274, 1867, 1, 0, 0, 0, 276, 1871, 1, 0, 0, 0, 278, 1896, + 1, 0, 0, 0, 280, 1898, 1, 0, 0, 0, 282, 1978, 1, 0, 0, 0, 284, 1980, 1, + 0, 0, 0, 286, 1984, 1, 0, 0, 0, 288, 2003, 1, 0, 0, 0, 290, 2008, 1, 0, + 0, 0, 292, 2029, 1, 0, 0, 0, 294, 2031, 1, 0, 0, 0, 296, 2033, 1, 0, 0, + 0, 298, 2035, 1, 0, 0, 0, 300, 2037, 1, 0, 0, 0, 302, 2039, 1, 0, 0, 0, + 304, 2045, 1, 0, 0, 0, 306, 2051, 1, 0, 0, 0, 308, 2057, 1, 0, 0, 0, 310, + 2059, 1, 0, 0, 0, 312, 2063, 1, 0, 0, 0, 314, 2065, 1, 0, 0, 0, 316, 2079, + 1, 0, 0, 0, 318, 2081, 1, 0, 0, 0, 320, 2083, 1, 0, 0, 0, 322, 2085, 1, + 0, 0, 0, 324, 2087, 1, 0, 0, 0, 326, 2089, 1, 0, 0, 0, 328, 2091, 1, 0, + 0, 0, 330, 2093, 1, 0, 0, 0, 332, 2095, 1, 0, 0, 0, 334, 2097, 1, 0, 0, + 0, 336, 2099, 1, 0, 0, 0, 338, 2101, 1, 0, 0, 0, 340, 2103, 1, 0, 0, 0, + 342, 2106, 1, 0, 0, 0, 344, 2108, 1, 0, 0, 0, 346, 2110, 1, 0, 0, 0, 348, + 2112, 1, 0, 0, 0, 350, 2114, 1, 0, 0, 0, 352, 2117, 1, 0, 0, 0, 354, 2119, + 1, 0, 0, 0, 356, 2121, 1, 0, 0, 0, 358, 2123, 1, 0, 0, 0, 360, 2125, 1, + 0, 0, 0, 362, 2127, 1, 0, 0, 0, 364, 2129, 1, 0, 0, 0, 366, 2131, 1, 0, + 0, 0, 368, 2133, 1, 0, 0, 0, 370, 2135, 1, 0, 0, 0, 372, 2137, 1, 0, 0, + 0, 374, 2139, 1, 0, 0, 0, 376, 2141, 1, 0, 0, 0, 378, 2143, 1, 0, 0, 0, + 380, 2145, 1, 0, 0, 0, 382, 2147, 1, 0, 0, 0, 384, 2149, 1, 0, 0, 0, 386, + 2151, 1, 0, 0, 0, 388, 2153, 1, 0, 0, 0, 390, 2155, 1, 0, 0, 0, 392, 2157, + 1, 0, 0, 0, 394, 2159, 1, 0, 0, 0, 396, 2161, 1, 0, 0, 0, 398, 2163, 1, + 0, 0, 0, 400, 2165, 1, 0, 0, 0, 402, 2167, 1, 0, 0, 0, 404, 2169, 1, 0, + 0, 0, 406, 2171, 1, 0, 0, 0, 408, 2173, 1, 0, 0, 0, 410, 2175, 1, 0, 0, + 0, 412, 2177, 1, 0, 0, 0, 414, 2179, 1, 0, 0, 0, 416, 2181, 1, 0, 0, 0, + 418, 2183, 1, 0, 0, 0, 420, 2185, 1, 0, 0, 0, 422, 2187, 1, 0, 0, 0, 424, + 2189, 1, 0, 0, 0, 426, 2191, 1, 0, 0, 0, 428, 2193, 1, 0, 0, 0, 430, 2195, + 1, 0, 0, 0, 432, 2197, 1, 0, 0, 0, 434, 2199, 1, 0, 0, 0, 436, 2201, 1, + 0, 0, 0, 438, 2203, 1, 0, 0, 0, 440, 2205, 1, 0, 0, 0, 442, 2207, 1, 0, + 0, 0, 444, 2209, 1, 0, 0, 0, 446, 2211, 1, 0, 0, 0, 448, 2213, 1, 0, 0, + 0, 450, 2215, 1, 0, 0, 0, 452, 2217, 1, 0, 0, 0, 454, 2219, 1, 0, 0, 0, + 456, 2221, 1, 0, 0, 0, 458, 2223, 1, 0, 0, 0, 460, 2225, 1, 0, 0, 0, 462, + 2227, 1, 0, 0, 0, 464, 2229, 1, 0, 0, 0, 466, 2231, 1, 0, 0, 0, 468, 2233, + 1, 0, 0, 0, 470, 2235, 1, 0, 0, 0, 472, 2237, 1, 0, 0, 0, 474, 2239, 1, + 0, 0, 0, 476, 2241, 1, 0, 0, 0, 478, 2243, 1, 0, 0, 0, 480, 2245, 1, 0, + 0, 0, 482, 2247, 1, 0, 0, 0, 484, 2249, 1, 0, 0, 0, 486, 2251, 1, 0, 0, + 0, 488, 2253, 1, 0, 0, 0, 490, 2255, 1, 0, 0, 0, 492, 2257, 1, 0, 0, 0, + 494, 2259, 1, 0, 0, 0, 496, 2261, 1, 0, 0, 0, 498, 2263, 1, 0, 0, 0, 500, + 2265, 1, 0, 0, 0, 502, 2267, 1, 0, 0, 0, 504, 2269, 1, 0, 0, 0, 506, 2271, + 1, 0, 0, 0, 508, 2273, 1, 0, 0, 0, 510, 2275, 1, 0, 0, 0, 512, 2277, 1, + 0, 0, 0, 514, 2279, 1, 0, 0, 0, 516, 2281, 1, 0, 0, 0, 518, 2283, 1, 0, + 0, 0, 520, 2285, 1, 0, 0, 0, 522, 2287, 1, 0, 0, 0, 524, 2289, 1, 0, 0, + 0, 526, 2291, 1, 0, 0, 0, 528, 2293, 1, 0, 0, 0, 530, 2295, 1, 0, 0, 0, + 532, 2297, 1, 0, 0, 0, 534, 2299, 1, 0, 0, 0, 536, 2301, 1, 0, 0, 0, 538, + 2303, 1, 0, 0, 0, 540, 2305, 1, 0, 0, 0, 542, 2307, 1, 0, 0, 0, 544, 2309, + 1, 0, 0, 0, 546, 2311, 1, 0, 0, 0, 548, 2313, 1, 0, 0, 0, 550, 2315, 1, + 0, 0, 0, 552, 2317, 1, 0, 0, 0, 554, 556, 3, 2, 1, 0, 555, 554, 1, 0, 0, + 0, 555, 556, 1, 0, 0, 0, 556, 558, 1, 0, 0, 0, 557, 559, 5, 15, 0, 0, 558, + 557, 1, 0, 0, 0, 558, 559, 1, 0, 0, 0, 559, 560, 1, 0, 0, 0, 560, 561, + 5, 0, 0, 1, 561, 1, 1, 0, 0, 0, 562, 564, 3, 8, 4, 0, 563, 565, 5, 15, + 0, 0, 564, 563, 1, 0, 0, 0, 564, 565, 1, 0, 0, 0, 565, 566, 1, 0, 0, 0, + 566, 567, 3, 4, 2, 0, 567, 570, 1, 0, 0, 0, 568, 570, 3, 6, 3, 0, 569, + 562, 1, 0, 0, 0, 569, 568, 1, 0, 0, 0, 570, 573, 1, 0, 0, 0, 571, 569, + 1, 0, 0, 0, 571, 572, 1, 0, 0, 0, 572, 582, 1, 0, 0, 0, 573, 571, 1, 0, + 0, 0, 574, 579, 3, 8, 4, 0, 575, 577, 5, 15, 0, 0, 576, 575, 1, 0, 0, 0, + 576, 577, 1, 0, 0, 0, 577, 578, 1, 0, 0, 0, 578, 580, 3, 4, 2, 0, 579, + 576, 1, 0, 0, 0, 579, 580, 1, 0, 0, 0, 580, 583, 1, 0, 0, 0, 581, 583, + 3, 6, 3, 0, 582, 574, 1, 0, 0, 0, 582, 581, 1, 0, 0, 0, 583, 3, 1, 0, 0, + 0, 584, 585, 5, 8, 0, 0, 585, 5, 1, 0, 0, 0, 586, 587, 3, 4, 2, 0, 587, + 7, 1, 0, 0, 0, 588, 626, 3, 184, 92, 0, 589, 626, 3, 110, 55, 0, 590, 626, + 3, 104, 52, 0, 591, 626, 3, 86, 43, 0, 592, 626, 3, 72, 36, 0, 593, 626, + 3, 66, 33, 0, 594, 626, 3, 178, 89, 0, 595, 626, 3, 52, 26, 0, 596, 626, + 3, 44, 22, 0, 597, 626, 3, 196, 98, 0, 598, 626, 3, 42, 21, 0, 599, 626, + 3, 32, 16, 0, 600, 626, 3, 24, 12, 0, 601, 626, 3, 132, 66, 0, 602, 626, + 3, 30, 15, 0, 603, 626, 3, 26, 13, 0, 604, 626, 3, 22, 11, 0, 605, 626, + 3, 208, 104, 0, 606, 626, 3, 118, 59, 0, 607, 626, 3, 120, 60, 0, 608, + 626, 3, 130, 65, 0, 609, 626, 3, 128, 64, 0, 610, 626, 3, 116, 58, 0, 611, + 626, 3, 124, 62, 0, 612, 626, 3, 126, 63, 0, 613, 626, 3, 122, 61, 0, 614, + 626, 3, 114, 57, 0, 615, 626, 3, 112, 56, 0, 616, 626, 3, 16, 8, 0, 617, + 626, 3, 234, 117, 0, 618, 626, 3, 14, 7, 0, 619, 626, 3, 12, 6, 0, 620, + 626, 3, 10, 5, 0, 621, 626, 3, 258, 129, 0, 622, 626, 3, 194, 97, 0, 623, + 626, 3, 214, 107, 0, 624, 626, 3, 192, 96, 0, 625, 588, 1, 0, 0, 0, 625, + 589, 1, 0, 0, 0, 625, 590, 1, 0, 0, 0, 625, 591, 1, 0, 0, 0, 625, 592, + 1, 0, 0, 0, 625, 593, 1, 0, 0, 0, 625, 594, 1, 0, 0, 0, 625, 595, 1, 0, + 0, 0, 625, 596, 1, 0, 0, 0, 625, 597, 1, 0, 0, 0, 625, 598, 1, 0, 0, 0, + 625, 599, 1, 0, 0, 0, 625, 600, 1, 0, 0, 0, 625, 601, 1, 0, 0, 0, 625, + 602, 1, 0, 0, 0, 625, 603, 1, 0, 0, 0, 625, 604, 1, 0, 0, 0, 625, 605, + 1, 0, 0, 0, 625, 606, 1, 0, 0, 0, 625, 607, 1, 0, 0, 0, 625, 608, 1, 0, + 0, 0, 625, 609, 1, 0, 0, 0, 625, 610, 1, 0, 0, 0, 625, 611, 1, 0, 0, 0, + 625, 612, 1, 0, 0, 0, 625, 613, 1, 0, 0, 0, 625, 614, 1, 0, 0, 0, 625, + 615, 1, 0, 0, 0, 625, 616, 1, 0, 0, 0, 625, 617, 1, 0, 0, 0, 625, 618, + 1, 0, 0, 0, 625, 619, 1, 0, 0, 0, 625, 620, 1, 0, 0, 0, 625, 621, 1, 0, + 0, 0, 625, 622, 1, 0, 0, 0, 625, 623, 1, 0, 0, 0, 625, 624, 1, 0, 0, 0, + 626, 9, 1, 0, 0, 0, 627, 628, 3, 532, 266, 0, 628, 629, 3, 18, 9, 0, 629, + 630, 3, 464, 232, 0, 630, 631, 3, 20, 10, 0, 631, 632, 3, 404, 202, 0, + 632, 633, 3, 318, 159, 0, 633, 11, 1, 0, 0, 0, 634, 635, 3, 444, 222, 0, + 635, 639, 3, 486, 243, 0, 636, 637, 3, 462, 231, 0, 637, 638, 3, 318, 159, + 0, 638, 640, 1, 0, 0, 0, 639, 636, 1, 0, 0, 0, 639, 640, 1, 0, 0, 0, 640, + 642, 1, 0, 0, 0, 641, 643, 3, 456, 228, 0, 642, 641, 1, 0, 0, 0, 642, 643, + 1, 0, 0, 0, 643, 13, 1, 0, 0, 0, 644, 645, 3, 444, 222, 0, 645, 649, 3, + 18, 9, 0, 646, 647, 3, 464, 232, 0, 647, 648, 3, 20, 10, 0, 648, 650, 1, + 0, 0, 0, 649, 646, 1, 0, 0, 0, 649, 650, 1, 0, 0, 0, 650, 654, 1, 0, 0, + 0, 651, 652, 3, 462, 231, 0, 652, 653, 3, 318, 159, 0, 653, 655, 1, 0, + 0, 0, 654, 651, 1, 0, 0, 0, 654, 655, 1, 0, 0, 0, 655, 15, 1, 0, 0, 0, + 656, 657, 3, 412, 206, 0, 657, 658, 3, 18, 9, 0, 658, 659, 3, 464, 232, + 0, 659, 660, 3, 20, 10, 0, 660, 661, 3, 504, 252, 0, 661, 662, 3, 318, + 159, 0, 662, 17, 1, 0, 0, 0, 663, 666, 3, 348, 174, 0, 664, 666, 3, 350, + 175, 0, 665, 663, 1, 0, 0, 0, 665, 664, 1, 0, 0, 0, 666, 676, 1, 0, 0, + 0, 667, 676, 3, 354, 177, 0, 668, 676, 3, 364, 182, 0, 669, 676, 3, 386, + 193, 0, 670, 676, 3, 396, 198, 0, 671, 676, 3, 380, 190, 0, 672, 676, 3, + 390, 195, 0, 673, 676, 3, 452, 226, 0, 674, 676, 3, 488, 244, 0, 675, 665, + 1, 0, 0, 0, 675, 667, 1, 0, 0, 0, 675, 668, 1, 0, 0, 0, 675, 669, 1, 0, + 0, 0, 675, 670, 1, 0, 0, 0, 675, 671, 1, 0, 0, 0, 675, 672, 1, 0, 0, 0, + 675, 673, 1, 0, 0, 0, 675, 674, 1, 0, 0, 0, 676, 19, 1, 0, 0, 0, 677, 678, + 3, 348, 174, 0, 678, 679, 3, 410, 205, 0, 679, 716, 1, 0, 0, 0, 680, 681, + 3, 348, 174, 0, 681, 682, 3, 410, 205, 0, 682, 683, 3, 416, 208, 0, 683, + 684, 3, 436, 218, 0, 684, 685, 3, 304, 152, 0, 685, 716, 1, 0, 0, 0, 686, + 690, 3, 408, 204, 0, 687, 688, 3, 304, 152, 0, 688, 689, 5, 10, 0, 0, 689, + 691, 1, 0, 0, 0, 690, 687, 1, 0, 0, 0, 690, 691, 1, 0, 0, 0, 691, 692, + 1, 0, 0, 0, 692, 693, 3, 330, 165, 0, 693, 716, 1, 0, 0, 0, 694, 695, 3, + 348, 174, 0, 695, 696, 3, 438, 219, 0, 696, 716, 1, 0, 0, 0, 697, 698, + 3, 436, 218, 0, 698, 699, 3, 304, 152, 0, 699, 716, 1, 0, 0, 0, 700, 702, + 3, 500, 250, 0, 701, 700, 1, 0, 0, 0, 701, 702, 1, 0, 0, 0, 702, 706, 1, + 0, 0, 0, 703, 704, 3, 304, 152, 0, 704, 705, 5, 10, 0, 0, 705, 707, 1, + 0, 0, 0, 706, 703, 1, 0, 0, 0, 706, 707, 1, 0, 0, 0, 707, 708, 1, 0, 0, + 0, 708, 716, 3, 306, 153, 0, 709, 710, 3, 348, 174, 0, 710, 711, 3, 486, + 243, 0, 711, 716, 1, 0, 0, 0, 712, 713, 3, 484, 242, 0, 713, 714, 3, 318, + 159, 0, 714, 716, 1, 0, 0, 0, 715, 677, 1, 0, 0, 0, 715, 680, 1, 0, 0, + 0, 715, 686, 1, 0, 0, 0, 715, 694, 1, 0, 0, 0, 715, 697, 1, 0, 0, 0, 715, + 701, 1, 0, 0, 0, 715, 709, 1, 0, 0, 0, 715, 712, 1, 0, 0, 0, 716, 21, 1, + 0, 0, 0, 717, 718, 3, 380, 190, 0, 718, 720, 3, 520, 260, 0, 719, 721, + 3, 244, 122, 0, 720, 719, 1, 0, 0, 0, 720, 721, 1, 0, 0, 0, 721, 722, 1, + 0, 0, 0, 722, 723, 3, 334, 167, 0, 723, 724, 3, 530, 265, 0, 724, 725, + 3, 472, 236, 0, 725, 728, 3, 298, 149, 0, 726, 729, 3, 498, 249, 0, 727, + 729, 3, 454, 227, 0, 728, 726, 1, 0, 0, 0, 728, 727, 1, 0, 0, 0, 728, 729, + 1, 0, 0, 0, 729, 23, 1, 0, 0, 0, 730, 731, 3, 380, 190, 0, 731, 733, 3, + 484, 242, 0, 732, 734, 3, 244, 122, 0, 733, 732, 1, 0, 0, 0, 733, 734, + 1, 0, 0, 0, 734, 735, 1, 0, 0, 0, 735, 737, 3, 318, 159, 0, 736, 738, 3, + 106, 53, 0, 737, 736, 1, 0, 0, 0, 737, 738, 1, 0, 0, 0, 738, 25, 1, 0, + 0, 0, 739, 740, 3, 380, 190, 0, 740, 742, 3, 512, 256, 0, 741, 743, 3, + 244, 122, 0, 742, 741, 1, 0, 0, 0, 742, 743, 1, 0, 0, 0, 743, 747, 1, 0, + 0, 0, 744, 745, 3, 304, 152, 0, 745, 746, 5, 10, 0, 0, 746, 748, 1, 0, + 0, 0, 747, 744, 1, 0, 0, 0, 747, 748, 1, 0, 0, 0, 748, 749, 1, 0, 0, 0, + 749, 750, 3, 326, 163, 0, 750, 751, 3, 534, 267, 0, 751, 752, 3, 28, 14, + 0, 752, 753, 3, 536, 268, 0, 753, 27, 1, 0, 0, 0, 754, 755, 3, 308, 154, + 0, 755, 762, 3, 310, 155, 0, 756, 757, 3, 550, 275, 0, 757, 758, 3, 308, + 154, 0, 758, 759, 3, 310, 155, 0, 759, 761, 1, 0, 0, 0, 760, 756, 1, 0, + 0, 0, 761, 764, 1, 0, 0, 0, 762, 760, 1, 0, 0, 0, 762, 763, 1, 0, 0, 0, + 763, 29, 1, 0, 0, 0, 764, 762, 1, 0, 0, 0, 765, 766, 3, 380, 190, 0, 766, + 768, 3, 506, 253, 0, 767, 769, 3, 244, 122, 0, 768, 767, 1, 0, 0, 0, 768, + 769, 1, 0, 0, 0, 769, 773, 1, 0, 0, 0, 770, 771, 3, 304, 152, 0, 771, 772, + 5, 10, 0, 0, 772, 774, 1, 0, 0, 0, 773, 770, 1, 0, 0, 0, 773, 774, 1, 0, + 0, 0, 774, 775, 1, 0, 0, 0, 775, 776, 3, 320, 160, 0, 776, 777, 3, 522, + 261, 0, 777, 778, 3, 322, 161, 0, 778, 31, 1, 0, 0, 0, 779, 780, 3, 380, + 190, 0, 780, 781, 3, 450, 225, 0, 781, 783, 3, 526, 263, 0, 782, 784, 3, + 244, 122, 0, 783, 782, 1, 0, 0, 0, 783, 784, 1, 0, 0, 0, 784, 788, 1, 0, + 0, 0, 785, 786, 3, 304, 152, 0, 786, 787, 5, 10, 0, 0, 787, 789, 1, 0, + 0, 0, 788, 785, 1, 0, 0, 0, 788, 789, 1, 0, 0, 0, 789, 790, 1, 0, 0, 0, + 790, 791, 3, 324, 162, 0, 791, 792, 3, 360, 180, 0, 792, 793, 3, 488, 244, + 0, 793, 794, 3, 252, 126, 0, 794, 798, 3, 404, 202, 0, 795, 796, 3, 304, + 152, 0, 796, 797, 5, 10, 0, 0, 797, 799, 1, 0, 0, 0, 798, 795, 1, 0, 0, + 0, 798, 799, 1, 0, 0, 0, 799, 800, 1, 0, 0, 0, 800, 801, 3, 306, 153, 0, + 801, 802, 3, 34, 17, 0, 802, 803, 3, 474, 237, 0, 803, 804, 3, 432, 216, + 0, 804, 805, 3, 534, 267, 0, 805, 806, 3, 252, 126, 0, 806, 810, 3, 536, + 268, 0, 807, 808, 3, 530, 265, 0, 808, 809, 3, 40, 20, 0, 809, 811, 1, + 0, 0, 0, 810, 807, 1, 0, 0, 0, 810, 811, 1, 0, 0, 0, 811, 33, 1, 0, 0, + 0, 812, 813, 3, 528, 264, 0, 813, 817, 3, 36, 18, 0, 814, 815, 3, 356, + 178, 0, 815, 816, 3, 280, 140, 0, 816, 818, 1, 0, 0, 0, 817, 814, 1, 0, + 0, 0, 817, 818, 1, 0, 0, 0, 818, 35, 1, 0, 0, 0, 819, 825, 3, 38, 19, 0, + 820, 821, 3, 356, 178, 0, 821, 822, 3, 38, 19, 0, 822, 824, 1, 0, 0, 0, + 823, 820, 1, 0, 0, 0, 824, 827, 1, 0, 0, 0, 825, 823, 1, 0, 0, 0, 825, + 826, 1, 0, 0, 0, 826, 37, 1, 0, 0, 0, 827, 825, 1, 0, 0, 0, 828, 829, 3, + 308, 154, 0, 829, 830, 3, 428, 214, 0, 830, 831, 3, 458, 229, 0, 831, 832, + 3, 460, 230, 0, 832, 39, 1, 0, 0, 0, 833, 840, 3, 136, 68, 0, 834, 835, + 3, 136, 68, 0, 835, 836, 3, 356, 178, 0, 836, 837, 3, 138, 69, 0, 837, + 840, 1, 0, 0, 0, 838, 840, 3, 138, 69, 0, 839, 833, 1, 0, 0, 0, 839, 834, + 1, 0, 0, 0, 839, 838, 1, 0, 0, 0, 840, 41, 1, 0, 0, 0, 841, 842, 3, 380, + 190, 0, 842, 844, 3, 436, 218, 0, 843, 845, 3, 244, 122, 0, 844, 843, 1, + 0, 0, 0, 844, 845, 1, 0, 0, 0, 845, 846, 1, 0, 0, 0, 846, 847, 3, 304, + 152, 0, 847, 848, 3, 530, 265, 0, 848, 849, 3, 480, 240, 0, 849, 850, 5, + 19, 0, 0, 850, 851, 3, 538, 269, 0, 851, 852, 3, 186, 93, 0, 852, 856, + 3, 540, 270, 0, 853, 854, 3, 356, 178, 0, 854, 855, 3, 190, 95, 0, 855, + 857, 1, 0, 0, 0, 856, 853, 1, 0, 0, 0, 856, 857, 1, 0, 0, 0, 857, 43, 1, + 0, 0, 0, 858, 860, 3, 380, 190, 0, 859, 861, 3, 64, 32, 0, 860, 859, 1, + 0, 0, 0, 860, 861, 1, 0, 0, 0, 861, 862, 1, 0, 0, 0, 862, 864, 3, 408, + 204, 0, 863, 865, 3, 244, 122, 0, 864, 863, 1, 0, 0, 0, 864, 865, 1, 0, + 0, 0, 865, 869, 1, 0, 0, 0, 866, 867, 3, 304, 152, 0, 867, 868, 5, 10, + 0, 0, 868, 870, 1, 0, 0, 0, 869, 866, 1, 0, 0, 0, 869, 870, 1, 0, 0, 0, + 870, 871, 1, 0, 0, 0, 871, 872, 3, 330, 165, 0, 872, 874, 3, 534, 267, + 0, 873, 875, 3, 48, 24, 0, 874, 873, 1, 0, 0, 0, 874, 875, 1, 0, 0, 0, + 875, 876, 1, 0, 0, 0, 876, 877, 3, 536, 268, 0, 877, 878, 3, 50, 25, 0, + 878, 879, 3, 482, 241, 0, 879, 880, 3, 310, 155, 0, 880, 881, 3, 440, 220, + 0, 881, 882, 3, 332, 166, 0, 882, 883, 3, 360, 180, 0, 883, 884, 3, 46, + 23, 0, 884, 45, 1, 0, 0, 0, 885, 886, 7, 0, 0, 0, 886, 47, 1, 0, 0, 0, + 887, 893, 3, 340, 170, 0, 888, 889, 3, 550, 275, 0, 889, 890, 3, 340, 170, + 0, 890, 892, 1, 0, 0, 0, 891, 888, 1, 0, 0, 0, 892, 895, 1, 0, 0, 0, 893, + 891, 1, 0, 0, 0, 893, 894, 1, 0, 0, 0, 894, 49, 1, 0, 0, 0, 895, 893, 1, + 0, 0, 0, 896, 901, 3, 372, 186, 0, 897, 898, 3, 482, 241, 0, 898, 899, + 3, 460, 230, 0, 899, 901, 1, 0, 0, 0, 900, 896, 1, 0, 0, 0, 900, 897, 1, + 0, 0, 0, 901, 902, 1, 0, 0, 0, 902, 903, 3, 464, 232, 0, 903, 904, 3, 460, + 230, 0, 904, 905, 3, 422, 211, 0, 905, 51, 1, 0, 0, 0, 906, 908, 3, 380, + 190, 0, 907, 909, 3, 64, 32, 0, 908, 907, 1, 0, 0, 0, 908, 909, 1, 0, 0, + 0, 909, 910, 1, 0, 0, 0, 910, 912, 3, 346, 173, 0, 911, 913, 3, 244, 122, + 0, 912, 911, 1, 0, 0, 0, 912, 913, 1, 0, 0, 0, 913, 917, 1, 0, 0, 0, 914, + 915, 3, 304, 152, 0, 915, 916, 5, 10, 0, 0, 916, 918, 1, 0, 0, 0, 917, + 914, 1, 0, 0, 0, 917, 918, 1, 0, 0, 0, 918, 919, 1, 0, 0, 0, 919, 920, + 3, 328, 164, 0, 920, 921, 3, 534, 267, 0, 921, 922, 3, 310, 155, 0, 922, + 923, 3, 536, 268, 0, 923, 924, 3, 492, 246, 0, 924, 925, 3, 330, 165, 0, + 925, 926, 3, 496, 248, 0, 926, 927, 3, 310, 155, 0, 927, 928, 3, 402, 201, + 0, 928, 929, 3, 330, 165, 0, 929, 930, 3, 420, 210, 0, 930, 931, 3, 54, + 27, 0, 931, 53, 1, 0, 0, 0, 932, 937, 3, 292, 146, 0, 933, 937, 3, 62, + 31, 0, 934, 937, 3, 60, 30, 0, 935, 937, 3, 56, 28, 0, 936, 932, 1, 0, + 0, 0, 936, 933, 1, 0, 0, 0, 936, 934, 1, 0, 0, 0, 936, 935, 1, 0, 0, 0, + 937, 55, 1, 0, 0, 0, 938, 939, 3, 538, 269, 0, 939, 945, 3, 58, 29, 0, + 940, 941, 3, 550, 275, 0, 941, 942, 3, 58, 29, 0, 942, 944, 1, 0, 0, 0, + 943, 940, 1, 0, 0, 0, 944, 947, 1, 0, 0, 0, 945, 943, 1, 0, 0, 0, 945, + 946, 1, 0, 0, 0, 946, 948, 1, 0, 0, 0, 947, 945, 1, 0, 0, 0, 948, 949, + 3, 540, 270, 0, 949, 57, 1, 0, 0, 0, 950, 951, 3, 338, 169, 0, 951, 952, + 5, 9, 0, 0, 952, 953, 3, 54, 27, 0, 953, 59, 1, 0, 0, 0, 954, 955, 3, 534, + 267, 0, 955, 962, 3, 62, 31, 0, 956, 957, 3, 550, 275, 0, 957, 958, 3, + 292, 146, 0, 958, 961, 1, 0, 0, 0, 959, 961, 3, 62, 31, 0, 960, 956, 1, + 0, 0, 0, 960, 959, 1, 0, 0, 0, 961, 964, 1, 0, 0, 0, 962, 960, 1, 0, 0, + 0, 962, 963, 1, 0, 0, 0, 963, 965, 1, 0, 0, 0, 964, 962, 1, 0, 0, 0, 965, + 966, 3, 536, 268, 0, 966, 61, 1, 0, 0, 0, 967, 968, 3, 534, 267, 0, 968, + 974, 3, 292, 146, 0, 969, 970, 3, 550, 275, 0, 970, 971, 3, 292, 146, 0, + 971, 973, 1, 0, 0, 0, 972, 969, 1, 0, 0, 0, 973, 976, 1, 0, 0, 0, 974, + 972, 1, 0, 0, 0, 974, 975, 1, 0, 0, 0, 975, 977, 1, 0, 0, 0, 976, 974, + 1, 0, 0, 0, 977, 978, 3, 536, 268, 0, 978, 63, 1, 0, 0, 0, 979, 980, 3, + 468, 234, 0, 980, 981, 3, 478, 239, 0, 981, 65, 1, 0, 0, 0, 982, 983, 3, + 354, 177, 0, 983, 984, 3, 520, 260, 0, 984, 985, 3, 334, 167, 0, 985, 986, + 3, 530, 265, 0, 986, 988, 3, 68, 34, 0, 987, 989, 3, 70, 35, 0, 988, 987, + 1, 0, 0, 0, 988, 989, 1, 0, 0, 0, 989, 67, 1, 0, 0, 0, 990, 991, 3, 472, + 236, 0, 991, 992, 3, 298, 149, 0, 992, 69, 1, 0, 0, 0, 993, 996, 3, 498, + 249, 0, 994, 996, 3, 454, 227, 0, 995, 993, 1, 0, 0, 0, 995, 994, 1, 0, + 0, 0, 996, 71, 1, 0, 0, 0, 997, 998, 3, 354, 177, 0, 998, 1002, 3, 512, + 256, 0, 999, 1000, 3, 304, 152, 0, 1000, 1001, 5, 10, 0, 0, 1001, 1003, + 1, 0, 0, 0, 1002, 999, 1, 0, 0, 0, 1002, 1003, 1, 0, 0, 0, 1003, 1004, + 1, 0, 0, 0, 1004, 1005, 3, 326, 163, 0, 1005, 1006, 3, 74, 37, 0, 1006, + 73, 1, 0, 0, 0, 1007, 1011, 3, 84, 42, 0, 1008, 1011, 3, 82, 41, 0, 1009, + 1011, 3, 76, 38, 0, 1010, 1007, 1, 0, 0, 0, 1010, 1008, 1, 0, 0, 0, 1010, + 1009, 1, 0, 0, 0, 1011, 75, 1, 0, 0, 0, 1012, 1013, 3, 476, 238, 0, 1013, + 1014, 3, 78, 39, 0, 1014, 77, 1, 0, 0, 0, 1015, 1021, 3, 80, 40, 0, 1016, + 1017, 3, 356, 178, 0, 1017, 1018, 3, 80, 40, 0, 1018, 1020, 1, 0, 0, 0, + 1019, 1016, 1, 0, 0, 0, 1020, 1023, 1, 0, 0, 0, 1021, 1019, 1, 0, 0, 0, + 1021, 1022, 1, 0, 0, 0, 1022, 79, 1, 0, 0, 0, 1023, 1021, 1, 0, 0, 0, 1024, + 1025, 3, 308, 154, 0, 1025, 1026, 3, 504, 252, 0, 1026, 1027, 3, 308, 154, + 0, 1027, 81, 1, 0, 0, 0, 1028, 1029, 3, 344, 172, 0, 1029, 1030, 3, 308, + 154, 0, 1030, 1037, 3, 310, 155, 0, 1031, 1032, 3, 550, 275, 0, 1032, 1033, + 3, 308, 154, 0, 1033, 1034, 3, 310, 155, 0, 1034, 1036, 1, 0, 0, 0, 1035, + 1031, 1, 0, 0, 0, 1036, 1039, 1, 0, 0, 0, 1037, 1035, 1, 0, 0, 0, 1037, + 1038, 1, 0, 0, 0, 1038, 83, 1, 0, 0, 0, 1039, 1037, 1, 0, 0, 0, 1040, 1041, + 3, 354, 177, 0, 1041, 1042, 3, 308, 154, 0, 1042, 1043, 3, 512, 256, 0, + 1043, 1044, 3, 310, 155, 0, 1044, 85, 1, 0, 0, 0, 1045, 1046, 3, 354, 177, + 0, 1046, 1050, 3, 500, 250, 0, 1047, 1048, 3, 304, 152, 0, 1048, 1049, + 5, 10, 0, 0, 1049, 1051, 1, 0, 0, 0, 1050, 1047, 1, 0, 0, 0, 1050, 1051, + 1, 0, 0, 0, 1051, 1052, 1, 0, 0, 0, 1052, 1053, 3, 306, 153, 0, 1053, 1054, + 3, 88, 44, 0, 1054, 87, 1, 0, 0, 0, 1055, 1061, 3, 100, 50, 0, 1056, 1061, + 3, 96, 48, 0, 1057, 1061, 3, 94, 47, 0, 1058, 1061, 3, 92, 46, 0, 1059, + 1061, 3, 90, 45, 0, 1060, 1055, 1, 0, 0, 0, 1060, 1056, 1, 0, 0, 0, 1060, + 1057, 1, 0, 0, 0, 1060, 1058, 1, 0, 0, 0, 1060, 1059, 1, 0, 0, 0, 1061, + 89, 1, 0, 0, 0, 1062, 1063, 3, 530, 265, 0, 1063, 1064, 3, 136, 68, 0, + 1064, 91, 1, 0, 0, 0, 1065, 1066, 3, 476, 238, 0, 1066, 1067, 3, 308, 154, + 0, 1067, 1068, 3, 504, 252, 0, 1068, 1069, 3, 308, 154, 0, 1069, 93, 1, + 0, 0, 0, 1070, 1071, 3, 390, 195, 0, 1071, 1072, 3, 376, 188, 0, 1072, + 1073, 3, 494, 247, 0, 1073, 95, 1, 0, 0, 0, 1074, 1075, 3, 390, 195, 0, + 1075, 1076, 3, 98, 49, 0, 1076, 97, 1, 0, 0, 0, 1077, 1083, 3, 308, 154, + 0, 1078, 1079, 3, 550, 275, 0, 1079, 1080, 3, 308, 154, 0, 1080, 1082, + 1, 0, 0, 0, 1081, 1078, 1, 0, 0, 0, 1082, 1085, 1, 0, 0, 0, 1083, 1081, + 1, 0, 0, 0, 1083, 1084, 1, 0, 0, 0, 1084, 99, 1, 0, 0, 0, 1085, 1083, 1, + 0, 0, 0, 1086, 1087, 3, 344, 172, 0, 1087, 1088, 3, 102, 51, 0, 1088, 101, + 1, 0, 0, 0, 1089, 1090, 3, 308, 154, 0, 1090, 1097, 3, 310, 155, 0, 1091, + 1092, 3, 550, 275, 0, 1092, 1093, 3, 308, 154, 0, 1093, 1094, 3, 310, 155, + 0, 1094, 1096, 1, 0, 0, 0, 1095, 1091, 1, 0, 0, 0, 1096, 1099, 1, 0, 0, + 0, 1097, 1095, 1, 0, 0, 0, 1097, 1098, 1, 0, 0, 0, 1098, 103, 1, 0, 0, + 0, 1099, 1097, 1, 0, 0, 0, 1100, 1101, 3, 354, 177, 0, 1101, 1102, 3, 484, + 242, 0, 1102, 1104, 3, 318, 159, 0, 1103, 1105, 3, 106, 53, 0, 1104, 1103, + 1, 0, 0, 0, 1104, 1105, 1, 0, 0, 0, 1105, 105, 1, 0, 0, 0, 1106, 1107, + 3, 530, 265, 0, 1107, 1113, 3, 108, 54, 0, 1108, 1109, 3, 356, 178, 0, + 1109, 1110, 3, 108, 54, 0, 1110, 1112, 1, 0, 0, 0, 1111, 1108, 1, 0, 0, + 0, 1112, 1115, 1, 0, 0, 0, 1113, 1111, 1, 0, 0, 0, 1113, 1114, 1, 0, 0, + 0, 1114, 107, 1, 0, 0, 0, 1115, 1113, 1, 0, 0, 0, 1116, 1117, 3, 472, 236, + 0, 1117, 1118, 5, 19, 0, 0, 1118, 1119, 3, 298, 149, 0, 1119, 1133, 1, + 0, 0, 0, 1120, 1121, 3, 448, 224, 0, 1121, 1122, 5, 19, 0, 0, 1122, 1123, + 3, 300, 150, 0, 1123, 1133, 1, 0, 0, 0, 1124, 1125, 3, 498, 249, 0, 1125, + 1126, 5, 19, 0, 0, 1126, 1127, 3, 300, 150, 0, 1127, 1133, 1, 0, 0, 0, + 1128, 1129, 3, 466, 233, 0, 1129, 1130, 5, 19, 0, 0, 1130, 1131, 3, 146, + 73, 0, 1131, 1133, 1, 0, 0, 0, 1132, 1116, 1, 0, 0, 0, 1132, 1120, 1, 0, + 0, 0, 1132, 1124, 1, 0, 0, 0, 1132, 1128, 1, 0, 0, 0, 1133, 109, 1, 0, + 0, 0, 1134, 1135, 3, 354, 177, 0, 1135, 1136, 3, 450, 225, 0, 1136, 1140, + 3, 526, 263, 0, 1137, 1138, 3, 304, 152, 0, 1138, 1139, 5, 10, 0, 0, 1139, + 1141, 1, 0, 0, 0, 1140, 1137, 1, 0, 0, 0, 1140, 1141, 1, 0, 0, 0, 1141, + 1142, 1, 0, 0, 0, 1142, 1146, 3, 324, 162, 0, 1143, 1144, 3, 530, 265, + 0, 1144, 1145, 3, 136, 68, 0, 1145, 1147, 1, 0, 0, 0, 1146, 1143, 1, 0, + 0, 0, 1146, 1147, 1, 0, 0, 0, 1147, 111, 1, 0, 0, 0, 1148, 1149, 3, 390, + 195, 0, 1149, 1151, 3, 520, 260, 0, 1150, 1152, 3, 246, 123, 0, 1151, 1150, + 1, 0, 0, 0, 1151, 1152, 1, 0, 0, 0, 1152, 1153, 1, 0, 0, 0, 1153, 1154, + 3, 334, 167, 0, 1154, 113, 1, 0, 0, 0, 1155, 1156, 3, 390, 195, 0, 1156, + 1158, 3, 512, 256, 0, 1157, 1159, 3, 246, 123, 0, 1158, 1157, 1, 0, 0, + 0, 1158, 1159, 1, 0, 0, 0, 1159, 1163, 1, 0, 0, 0, 1160, 1161, 3, 304, + 152, 0, 1161, 1162, 5, 10, 0, 0, 1162, 1164, 1, 0, 0, 0, 1163, 1160, 1, + 0, 0, 0, 1163, 1164, 1, 0, 0, 0, 1164, 1165, 1, 0, 0, 0, 1165, 1166, 3, + 326, 163, 0, 1166, 115, 1, 0, 0, 0, 1167, 1168, 3, 390, 195, 0, 1168, 1169, + 3, 450, 225, 0, 1169, 1171, 3, 526, 263, 0, 1170, 1172, 3, 246, 123, 0, + 1171, 1170, 1, 0, 0, 0, 1171, 1172, 1, 0, 0, 0, 1172, 1176, 1, 0, 0, 0, + 1173, 1174, 3, 304, 152, 0, 1174, 1175, 5, 10, 0, 0, 1175, 1177, 1, 0, + 0, 0, 1176, 1173, 1, 0, 0, 0, 1176, 1177, 1, 0, 0, 0, 1177, 1178, 1, 0, + 0, 0, 1178, 1179, 3, 324, 162, 0, 1179, 117, 1, 0, 0, 0, 1180, 1181, 3, + 390, 195, 0, 1181, 1183, 3, 346, 173, 0, 1182, 1184, 3, 246, 123, 0, 1183, + 1182, 1, 0, 0, 0, 1183, 1184, 1, 0, 0, 0, 1184, 1188, 1, 0, 0, 0, 1185, + 1186, 3, 304, 152, 0, 1186, 1187, 5, 10, 0, 0, 1187, 1189, 1, 0, 0, 0, + 1188, 1185, 1, 0, 0, 0, 1188, 1189, 1, 0, 0, 0, 1189, 1190, 1, 0, 0, 0, + 1190, 1191, 3, 328, 164, 0, 1191, 119, 1, 0, 0, 0, 1192, 1193, 3, 390, + 195, 0, 1193, 1195, 3, 408, 204, 0, 1194, 1196, 3, 246, 123, 0, 1195, 1194, + 1, 0, 0, 0, 1195, 1196, 1, 0, 0, 0, 1196, 1200, 1, 0, 0, 0, 1197, 1198, + 3, 304, 152, 0, 1198, 1199, 5, 10, 0, 0, 1199, 1201, 1, 0, 0, 0, 1200, + 1197, 1, 0, 0, 0, 1200, 1201, 1, 0, 0, 0, 1201, 1202, 1, 0, 0, 0, 1202, + 1203, 3, 330, 165, 0, 1203, 121, 1, 0, 0, 0, 1204, 1205, 3, 390, 195, 0, + 1205, 1207, 3, 506, 253, 0, 1206, 1208, 3, 246, 123, 0, 1207, 1206, 1, + 0, 0, 0, 1207, 1208, 1, 0, 0, 0, 1208, 1209, 1, 0, 0, 0, 1209, 1210, 3, + 320, 160, 0, 1210, 1214, 3, 464, 232, 0, 1211, 1212, 3, 304, 152, 0, 1212, + 1213, 5, 10, 0, 0, 1213, 1215, 1, 0, 0, 0, 1214, 1211, 1, 0, 0, 0, 1214, + 1215, 1, 0, 0, 0, 1215, 1216, 1, 0, 0, 0, 1216, 1217, 3, 306, 153, 0, 1217, + 123, 1, 0, 0, 0, 1218, 1219, 3, 390, 195, 0, 1219, 1221, 3, 484, 242, 0, + 1220, 1222, 3, 246, 123, 0, 1221, 1220, 1, 0, 0, 0, 1221, 1222, 1, 0, 0, + 0, 1222, 1223, 1, 0, 0, 0, 1223, 1224, 3, 318, 159, 0, 1224, 125, 1, 0, + 0, 0, 1225, 1226, 3, 390, 195, 0, 1226, 1228, 3, 500, 250, 0, 1227, 1229, + 3, 246, 123, 0, 1228, 1227, 1, 0, 0, 0, 1228, 1229, 1, 0, 0, 0, 1229, 1233, + 1, 0, 0, 0, 1230, 1231, 3, 304, 152, 0, 1231, 1232, 5, 10, 0, 0, 1232, + 1234, 1, 0, 0, 0, 1233, 1230, 1, 0, 0, 0, 1233, 1234, 1, 0, 0, 0, 1234, + 1235, 1, 0, 0, 0, 1235, 1236, 3, 306, 153, 0, 1236, 127, 1, 0, 0, 0, 1237, + 1238, 3, 390, 195, 0, 1238, 1240, 3, 436, 218, 0, 1239, 1241, 3, 246, 123, + 0, 1240, 1239, 1, 0, 0, 0, 1240, 1241, 1, 0, 0, 0, 1241, 1242, 1, 0, 0, + 0, 1242, 1243, 3, 304, 152, 0, 1243, 129, 1, 0, 0, 0, 1244, 1245, 3, 390, + 195, 0, 1245, 1247, 3, 418, 209, 0, 1246, 1248, 3, 246, 123, 0, 1247, 1246, + 1, 0, 0, 0, 1247, 1248, 1, 0, 0, 0, 1248, 1252, 1, 0, 0, 0, 1249, 1250, + 3, 304, 152, 0, 1250, 1251, 5, 10, 0, 0, 1251, 1253, 1, 0, 0, 0, 1252, + 1249, 1, 0, 0, 0, 1252, 1253, 1, 0, 0, 0, 1253, 1254, 1, 0, 0, 0, 1254, + 1255, 3, 198, 99, 0, 1255, 131, 1, 0, 0, 0, 1256, 1257, 3, 380, 190, 0, + 1257, 1259, 3, 500, 250, 0, 1258, 1260, 3, 244, 122, 0, 1259, 1258, 1, + 0, 0, 0, 1259, 1260, 1, 0, 0, 0, 1260, 1264, 1, 0, 0, 0, 1261, 1262, 3, + 304, 152, 0, 1262, 1263, 5, 10, 0, 0, 1263, 1265, 1, 0, 0, 0, 1264, 1261, + 1, 0, 0, 0, 1264, 1265, 1, 0, 0, 0, 1265, 1266, 1, 0, 0, 0, 1266, 1267, + 3, 306, 153, 0, 1267, 1268, 3, 534, 267, 0, 1268, 1269, 3, 154, 77, 0, + 1269, 1271, 3, 536, 268, 0, 1270, 1272, 3, 134, 67, 0, 1271, 1270, 1, 0, + 0, 0, 1271, 1272, 1, 0, 0, 0, 1272, 133, 1, 0, 0, 0, 1273, 1274, 3, 530, + 265, 0, 1274, 1275, 3, 136, 68, 0, 1275, 135, 1, 0, 0, 0, 1276, 1277, 3, + 376, 188, 0, 1277, 1281, 3, 494, 247, 0, 1278, 1279, 3, 356, 178, 0, 1279, + 1280, 3, 136, 68, 0, 1280, 1282, 1, 0, 0, 0, 1281, 1278, 1, 0, 0, 0, 1281, + 1282, 1, 0, 0, 0, 1282, 1299, 1, 0, 0, 0, 1283, 1287, 3, 138, 69, 0, 1284, + 1285, 3, 356, 178, 0, 1285, 1286, 3, 136, 68, 0, 1286, 1288, 1, 0, 0, 0, + 1287, 1284, 1, 0, 0, 0, 1287, 1288, 1, 0, 0, 0, 1288, 1299, 1, 0, 0, 0, + 1289, 1295, 3, 140, 70, 0, 1290, 1291, 3, 356, 178, 0, 1291, 1292, 3, 140, + 70, 0, 1292, 1294, 1, 0, 0, 0, 1293, 1290, 1, 0, 0, 0, 1294, 1297, 1, 0, + 0, 0, 1295, 1293, 1, 0, 0, 0, 1295, 1296, 1, 0, 0, 0, 1296, 1299, 1, 0, + 0, 0, 1297, 1295, 1, 0, 0, 0, 1298, 1276, 1, 0, 0, 0, 1298, 1283, 1, 0, + 0, 0, 1298, 1289, 1, 0, 0, 0, 1299, 137, 1, 0, 0, 0, 1300, 1301, 3, 374, + 187, 0, 1301, 1302, 3, 470, 235, 0, 1302, 1303, 3, 370, 185, 0, 1303, 1304, + 3, 534, 267, 0, 1304, 1306, 3, 308, 154, 0, 1305, 1307, 3, 316, 158, 0, + 1306, 1305, 1, 0, 0, 0, 1306, 1307, 1, 0, 0, 0, 1307, 1315, 1, 0, 0, 0, + 1308, 1309, 3, 550, 275, 0, 1309, 1311, 3, 308, 154, 0, 1310, 1312, 3, + 316, 158, 0, 1311, 1310, 1, 0, 0, 0, 1311, 1312, 1, 0, 0, 0, 1312, 1314, + 1, 0, 0, 0, 1313, 1308, 1, 0, 0, 0, 1314, 1317, 1, 0, 0, 0, 1315, 1313, + 1, 0, 0, 0, 1315, 1316, 1, 0, 0, 0, 1316, 1318, 1, 0, 0, 0, 1317, 1315, + 1, 0, 0, 0, 1318, 1319, 3, 536, 268, 0, 1319, 139, 1, 0, 0, 0, 1320, 1321, + 3, 142, 71, 0, 1321, 1322, 5, 19, 0, 0, 1322, 1323, 3, 144, 72, 0, 1323, + 1329, 1, 0, 0, 0, 1324, 1325, 3, 142, 71, 0, 1325, 1326, 5, 19, 0, 0, 1326, + 1327, 3, 146, 73, 0, 1327, 1329, 1, 0, 0, 0, 1328, 1320, 1, 0, 0, 0, 1328, + 1324, 1, 0, 0, 0, 1329, 141, 1, 0, 0, 0, 1330, 1331, 5, 170, 0, 0, 1331, + 143, 1, 0, 0, 0, 1332, 1335, 3, 298, 149, 0, 1333, 1335, 3, 296, 148, 0, + 1334, 1332, 1, 0, 0, 0, 1334, 1333, 1, 0, 0, 0, 1335, 145, 1, 0, 0, 0, + 1336, 1337, 3, 538, 269, 0, 1337, 1343, 3, 148, 74, 0, 1338, 1339, 3, 550, + 275, 0, 1339, 1340, 3, 148, 74, 0, 1340, 1342, 1, 0, 0, 0, 1341, 1338, + 1, 0, 0, 0, 1342, 1345, 1, 0, 0, 0, 1343, 1341, 1, 0, 0, 0, 1343, 1344, + 1, 0, 0, 0, 1344, 1346, 1, 0, 0, 0, 1345, 1343, 1, 0, 0, 0, 1346, 1347, + 3, 540, 270, 0, 1347, 147, 1, 0, 0, 0, 1348, 1349, 3, 150, 75, 0, 1349, + 1350, 5, 9, 0, 0, 1350, 1351, 3, 152, 76, 0, 1351, 149, 1, 0, 0, 0, 1352, + 1353, 3, 298, 149, 0, 1353, 151, 1, 0, 0, 0, 1354, 1357, 3, 298, 149, 0, + 1355, 1357, 3, 296, 148, 0, 1356, 1354, 1, 0, 0, 0, 1356, 1355, 1, 0, 0, + 0, 1357, 153, 1, 0, 0, 0, 1358, 1364, 3, 156, 78, 0, 1359, 1360, 3, 550, + 275, 0, 1360, 1361, 3, 156, 78, 0, 1361, 1363, 1, 0, 0, 0, 1362, 1359, + 1, 0, 0, 0, 1363, 1366, 1, 0, 0, 0, 1364, 1362, 1, 0, 0, 0, 1364, 1365, + 1, 0, 0, 0, 1365, 1370, 1, 0, 0, 0, 1366, 1364, 1, 0, 0, 0, 1367, 1368, + 3, 550, 275, 0, 1368, 1369, 3, 160, 80, 0, 1369, 1371, 1, 0, 0, 0, 1370, + 1367, 1, 0, 0, 0, 1370, 1371, 1, 0, 0, 0, 1371, 155, 1, 0, 0, 0, 1372, + 1373, 3, 308, 154, 0, 1373, 1375, 3, 310, 155, 0, 1374, 1376, 3, 158, 79, + 0, 1375, 1374, 1, 0, 0, 0, 1375, 1376, 1, 0, 0, 0, 1376, 157, 1, 0, 0, + 0, 1377, 1378, 3, 474, 237, 0, 1378, 1379, 3, 432, 216, 0, 1379, 159, 1, + 0, 0, 0, 1380, 1381, 3, 474, 237, 0, 1381, 1382, 3, 432, 216, 0, 1382, + 1383, 3, 534, 267, 0, 1383, 1384, 3, 162, 81, 0, 1384, 1385, 3, 536, 268, + 0, 1385, 161, 1, 0, 0, 0, 1386, 1390, 3, 164, 82, 0, 1387, 1390, 3, 166, + 83, 0, 1388, 1390, 3, 168, 84, 0, 1389, 1386, 1, 0, 0, 0, 1389, 1387, 1, + 0, 0, 0, 1389, 1388, 1, 0, 0, 0, 1390, 163, 1, 0, 0, 0, 1391, 1392, 3, + 308, 154, 0, 1392, 165, 1, 0, 0, 0, 1393, 1394, 3, 174, 87, 0, 1394, 1395, + 3, 550, 275, 0, 1395, 1396, 3, 172, 86, 0, 1396, 167, 1, 0, 0, 0, 1397, + 1398, 3, 534, 267, 0, 1398, 1399, 3, 170, 85, 0, 1399, 1400, 3, 536, 268, + 0, 1400, 1401, 3, 550, 275, 0, 1401, 1402, 3, 172, 86, 0, 1402, 169, 1, + 0, 0, 0, 1403, 1409, 3, 174, 87, 0, 1404, 1405, 3, 550, 275, 0, 1405, 1406, + 3, 174, 87, 0, 1406, 1408, 1, 0, 0, 0, 1407, 1404, 1, 0, 0, 0, 1408, 1411, + 1, 0, 0, 0, 1409, 1407, 1, 0, 0, 0, 1409, 1410, 1, 0, 0, 0, 1410, 171, + 1, 0, 0, 0, 1411, 1409, 1, 0, 0, 0, 1412, 1418, 3, 176, 88, 0, 1413, 1414, + 3, 550, 275, 0, 1414, 1415, 3, 176, 88, 0, 1415, 1417, 1, 0, 0, 0, 1416, + 1413, 1, 0, 0, 0, 1417, 1420, 1, 0, 0, 0, 1418, 1416, 1, 0, 0, 0, 1418, + 1419, 1, 0, 0, 0, 1419, 173, 1, 0, 0, 0, 1420, 1418, 1, 0, 0, 0, 1421, + 1422, 3, 308, 154, 0, 1422, 175, 1, 0, 0, 0, 1423, 1424, 3, 308, 154, 0, + 1424, 177, 1, 0, 0, 0, 1425, 1426, 3, 358, 179, 0, 1426, 1427, 3, 366, + 183, 0, 1427, 179, 1, 0, 0, 0, 1428, 1430, 3, 368, 184, 0, 1429, 1431, + 3, 182, 91, 0, 1430, 1429, 1, 0, 0, 0, 1430, 1431, 1, 0, 0, 0, 1431, 1432, + 1, 0, 0, 0, 1432, 1434, 3, 366, 183, 0, 1433, 1435, 3, 242, 121, 0, 1434, + 1433, 1, 0, 0, 0, 1434, 1435, 1, 0, 0, 0, 1435, 181, 1, 0, 0, 0, 1436, + 1439, 3, 446, 223, 0, 1437, 1439, 3, 514, 257, 0, 1438, 1436, 1, 0, 0, + 0, 1438, 1437, 1, 0, 0, 0, 1439, 183, 1, 0, 0, 0, 1440, 1441, 3, 354, 177, + 0, 1441, 1442, 3, 436, 218, 0, 1442, 1443, 3, 304, 152, 0, 1443, 1444, + 3, 530, 265, 0, 1444, 1445, 3, 480, 240, 0, 1445, 1446, 5, 19, 0, 0, 1446, + 1447, 3, 538, 269, 0, 1447, 1448, 3, 186, 93, 0, 1448, 1452, 3, 540, 270, + 0, 1449, 1450, 3, 356, 178, 0, 1450, 1451, 3, 190, 95, 0, 1451, 1453, 1, + 0, 0, 0, 1452, 1449, 1, 0, 0, 0, 1452, 1453, 1, 0, 0, 0, 1453, 185, 1, + 0, 0, 0, 1454, 1460, 3, 188, 94, 0, 1455, 1456, 3, 550, 275, 0, 1456, 1457, + 3, 188, 94, 0, 1457, 1459, 1, 0, 0, 0, 1458, 1455, 1, 0, 0, 0, 1459, 1462, + 1, 0, 0, 0, 1460, 1458, 1, 0, 0, 0, 1460, 1461, 1, 0, 0, 0, 1461, 187, + 1, 0, 0, 0, 1462, 1460, 1, 0, 0, 0, 1463, 1464, 5, 165, 0, 0, 1464, 1465, + 5, 9, 0, 0, 1465, 1470, 5, 165, 0, 0, 1466, 1467, 5, 165, 0, 0, 1467, 1468, + 5, 9, 0, 0, 1468, 1470, 5, 166, 0, 0, 1469, 1463, 1, 0, 0, 0, 1469, 1466, + 1, 0, 0, 0, 1470, 189, 1, 0, 0, 0, 1471, 1472, 3, 392, 196, 0, 1472, 1473, + 5, 19, 0, 0, 1473, 1474, 3, 300, 150, 0, 1474, 191, 1, 0, 0, 0, 1475, 1476, + 3, 518, 259, 0, 1476, 1477, 3, 304, 152, 0, 1477, 193, 1, 0, 0, 0, 1478, + 1480, 3, 508, 254, 0, 1479, 1481, 3, 500, 250, 0, 1480, 1479, 1, 0, 0, + 0, 1480, 1481, 1, 0, 0, 0, 1481, 1485, 1, 0, 0, 0, 1482, 1483, 3, 304, + 152, 0, 1483, 1484, 5, 10, 0, 0, 1484, 1486, 1, 0, 0, 0, 1485, 1482, 1, + 0, 0, 0, 1485, 1486, 1, 0, 0, 0, 1486, 1487, 1, 0, 0, 0, 1487, 1488, 3, + 306, 153, 0, 1488, 195, 1, 0, 0, 0, 1489, 1490, 3, 380, 190, 0, 1490, 1492, + 3, 418, 209, 0, 1491, 1493, 3, 244, 122, 0, 1492, 1491, 1, 0, 0, 0, 1492, + 1493, 1, 0, 0, 0, 1493, 1495, 1, 0, 0, 0, 1494, 1496, 3, 198, 99, 0, 1495, + 1494, 1, 0, 0, 0, 1495, 1496, 1, 0, 0, 0, 1496, 1497, 1, 0, 0, 0, 1497, + 1501, 3, 464, 232, 0, 1498, 1499, 3, 304, 152, 0, 1499, 1500, 5, 10, 0, + 0, 1500, 1502, 1, 0, 0, 0, 1501, 1498, 1, 0, 0, 0, 1501, 1502, 1, 0, 0, + 0, 1502, 1503, 1, 0, 0, 0, 1503, 1504, 3, 306, 153, 0, 1504, 1505, 3, 534, + 267, 0, 1505, 1506, 3, 200, 100, 0, 1506, 1507, 3, 536, 268, 0, 1507, 197, + 1, 0, 0, 0, 1508, 1511, 5, 170, 0, 0, 1509, 1511, 3, 298, 149, 0, 1510, + 1508, 1, 0, 0, 0, 1510, 1509, 1, 0, 0, 0, 1511, 199, 1, 0, 0, 0, 1512, + 1517, 3, 308, 154, 0, 1513, 1517, 3, 202, 101, 0, 1514, 1517, 3, 204, 102, + 0, 1515, 1517, 3, 206, 103, 0, 1516, 1512, 1, 0, 0, 0, 1516, 1513, 1, 0, + 0, 0, 1516, 1514, 1, 0, 0, 0, 1516, 1515, 1, 0, 0, 0, 1517, 201, 1, 0, + 0, 0, 1518, 1519, 3, 434, 217, 0, 1519, 1520, 3, 534, 267, 0, 1520, 1521, + 5, 170, 0, 0, 1521, 1522, 3, 536, 268, 0, 1522, 203, 1, 0, 0, 0, 1523, + 1524, 3, 394, 197, 0, 1524, 1525, 3, 534, 267, 0, 1525, 1526, 5, 170, 0, + 0, 1526, 1527, 3, 536, 268, 0, 1527, 205, 1, 0, 0, 0, 1528, 1529, 3, 406, + 203, 0, 1529, 1530, 3, 534, 267, 0, 1530, 1531, 5, 170, 0, 0, 1531, 1532, + 3, 536, 268, 0, 1532, 207, 1, 0, 0, 0, 1533, 1535, 3, 180, 90, 0, 1534, + 1533, 1, 0, 0, 0, 1534, 1535, 1, 0, 0, 0, 1535, 1536, 1, 0, 0, 0, 1536, + 1538, 3, 382, 191, 0, 1537, 1539, 3, 210, 105, 0, 1538, 1537, 1, 0, 0, + 0, 1538, 1539, 1, 0, 0, 0, 1539, 1540, 1, 0, 0, 0, 1540, 1542, 3, 264, + 132, 0, 1541, 1543, 3, 242, 121, 0, 1542, 1541, 1, 0, 0, 0, 1542, 1543, + 1, 0, 0, 0, 1543, 1544, 1, 0, 0, 0, 1544, 1547, 3, 272, 136, 0, 1545, 1548, + 3, 246, 123, 0, 1546, 1548, 3, 216, 108, 0, 1547, 1545, 1, 0, 0, 0, 1547, + 1546, 1, 0, 0, 0, 1547, 1548, 1, 0, 0, 0, 1548, 209, 1, 0, 0, 0, 1549, + 1555, 3, 212, 106, 0, 1550, 1551, 3, 550, 275, 0, 1551, 1552, 3, 212, 106, + 0, 1552, 1554, 1, 0, 0, 0, 1553, 1550, 1, 0, 0, 0, 1554, 1557, 1, 0, 0, + 0, 1555, 1553, 1, 0, 0, 0, 1555, 1556, 1, 0, 0, 0, 1556, 211, 1, 0, 0, + 0, 1557, 1555, 1, 0, 0, 0, 1558, 1568, 5, 170, 0, 0, 1559, 1560, 5, 170, + 0, 0, 1560, 1563, 5, 5, 0, 0, 1561, 1564, 3, 298, 149, 0, 1562, 1564, 3, + 294, 147, 0, 1563, 1561, 1, 0, 0, 0, 1563, 1562, 1, 0, 0, 0, 1564, 1565, + 1, 0, 0, 0, 1565, 1566, 5, 6, 0, 0, 1566, 1568, 1, 0, 0, 0, 1567, 1558, + 1, 0, 0, 0, 1567, 1559, 1, 0, 0, 0, 1568, 213, 1, 0, 0, 0, 1569, 1571, + 3, 180, 90, 0, 1570, 1569, 1, 0, 0, 0, 1570, 1571, 1, 0, 0, 0, 1571, 1572, + 1, 0, 0, 0, 1572, 1576, 3, 516, 258, 0, 1573, 1574, 3, 304, 152, 0, 1574, + 1575, 5, 10, 0, 0, 1575, 1577, 1, 0, 0, 0, 1576, 1573, 1, 0, 0, 0, 1576, + 1577, 1, 0, 0, 0, 1577, 1578, 1, 0, 0, 0, 1578, 1580, 3, 306, 153, 0, 1579, + 1581, 3, 236, 118, 0, 1580, 1579, 1, 0, 0, 0, 1580, 1581, 1, 0, 0, 0, 1581, + 1582, 1, 0, 0, 0, 1582, 1583, 3, 490, 245, 0, 1583, 1584, 3, 222, 111, + 0, 1584, 1587, 3, 272, 136, 0, 1585, 1588, 3, 246, 123, 0, 1586, 1588, + 3, 216, 108, 0, 1587, 1585, 1, 0, 0, 0, 1587, 1586, 1, 0, 0, 0, 1587, 1588, + 1, 0, 0, 0, 1588, 215, 1, 0, 0, 0, 1589, 1590, 3, 414, 207, 0, 1590, 1591, + 3, 218, 109, 0, 1591, 217, 1, 0, 0, 0, 1592, 1598, 3, 220, 110, 0, 1593, + 1594, 3, 356, 178, 0, 1594, 1595, 3, 220, 110, 0, 1595, 1597, 1, 0, 0, + 0, 1596, 1593, 1, 0, 0, 0, 1597, 1600, 1, 0, 0, 0, 1598, 1596, 1, 0, 0, + 0, 1598, 1599, 1, 0, 0, 0, 1599, 219, 1, 0, 0, 0, 1600, 1598, 1, 0, 0, + 0, 1601, 1602, 5, 170, 0, 0, 1602, 1603, 5, 19, 0, 0, 1603, 1604, 3, 292, + 146, 0, 1604, 221, 1, 0, 0, 0, 1605, 1611, 3, 224, 112, 0, 1606, 1607, + 3, 550, 275, 0, 1607, 1608, 3, 224, 112, 0, 1608, 1610, 1, 0, 0, 0, 1609, + 1606, 1, 0, 0, 0, 1610, 1613, 1, 0, 0, 0, 1611, 1609, 1, 0, 0, 0, 1611, + 1612, 1, 0, 0, 0, 1612, 223, 1, 0, 0, 0, 1613, 1611, 1, 0, 0, 0, 1614, + 1615, 5, 170, 0, 0, 1615, 1620, 5, 19, 0, 0, 1616, 1621, 3, 292, 146, 0, + 1617, 1621, 3, 228, 114, 0, 1618, 1621, 3, 226, 113, 0, 1619, 1621, 3, + 230, 115, 0, 1620, 1616, 1, 0, 0, 0, 1620, 1617, 1, 0, 0, 0, 1620, 1618, + 1, 0, 0, 0, 1620, 1619, 1, 0, 0, 0, 1621, 1668, 1, 0, 0, 0, 1622, 1623, + 5, 170, 0, 0, 1623, 1624, 5, 19, 0, 0, 1624, 1625, 5, 170, 0, 0, 1625, + 1626, 7, 1, 0, 0, 1626, 1668, 3, 294, 147, 0, 1627, 1628, 5, 170, 0, 0, + 1628, 1629, 5, 19, 0, 0, 1629, 1630, 5, 170, 0, 0, 1630, 1631, 7, 1, 0, + 0, 1631, 1668, 3, 226, 113, 0, 1632, 1633, 5, 170, 0, 0, 1633, 1634, 5, + 19, 0, 0, 1634, 1635, 3, 226, 113, 0, 1635, 1636, 7, 1, 0, 0, 1636, 1637, + 5, 170, 0, 0, 1637, 1668, 1, 0, 0, 0, 1638, 1639, 5, 170, 0, 0, 1639, 1640, + 5, 19, 0, 0, 1640, 1641, 5, 170, 0, 0, 1641, 1642, 7, 1, 0, 0, 1642, 1668, + 3, 228, 114, 0, 1643, 1644, 5, 170, 0, 0, 1644, 1645, 5, 19, 0, 0, 1645, + 1646, 3, 228, 114, 0, 1646, 1647, 7, 1, 0, 0, 1647, 1648, 5, 170, 0, 0, + 1648, 1668, 1, 0, 0, 0, 1649, 1650, 5, 170, 0, 0, 1650, 1651, 5, 19, 0, + 0, 1651, 1652, 5, 170, 0, 0, 1652, 1653, 7, 1, 0, 0, 1653, 1668, 3, 230, + 115, 0, 1654, 1655, 5, 170, 0, 0, 1655, 1656, 5, 19, 0, 0, 1656, 1657, + 3, 230, 115, 0, 1657, 1658, 7, 1, 0, 0, 1658, 1659, 5, 170, 0, 0, 1659, + 1668, 1, 0, 0, 0, 1660, 1661, 5, 170, 0, 0, 1661, 1662, 3, 546, 273, 0, + 1662, 1663, 3, 294, 147, 0, 1663, 1664, 3, 548, 274, 0, 1664, 1665, 5, + 19, 0, 0, 1665, 1666, 3, 292, 146, 0, 1666, 1668, 1, 0, 0, 0, 1667, 1614, + 1, 0, 0, 0, 1667, 1622, 1, 0, 0, 0, 1667, 1627, 1, 0, 0, 0, 1667, 1632, + 1, 0, 0, 0, 1667, 1638, 1, 0, 0, 0, 1667, 1643, 1, 0, 0, 0, 1667, 1649, + 1, 0, 0, 0, 1667, 1654, 1, 0, 0, 0, 1667, 1660, 1, 0, 0, 0, 1668, 225, + 1, 0, 0, 0, 1669, 1679, 3, 538, 269, 0, 1670, 1676, 3, 292, 146, 0, 1671, + 1672, 3, 550, 275, 0, 1672, 1673, 3, 292, 146, 0, 1673, 1675, 1, 0, 0, + 0, 1674, 1671, 1, 0, 0, 0, 1675, 1678, 1, 0, 0, 0, 1676, 1674, 1, 0, 0, + 0, 1676, 1677, 1, 0, 0, 0, 1677, 1680, 1, 0, 0, 0, 1678, 1676, 1, 0, 0, + 0, 1679, 1670, 1, 0, 0, 0, 1679, 1680, 1, 0, 0, 0, 1680, 1681, 1, 0, 0, + 0, 1681, 1682, 3, 540, 270, 0, 1682, 227, 1, 0, 0, 0, 1683, 1684, 3, 538, + 269, 0, 1684, 1685, 3, 292, 146, 0, 1685, 1686, 3, 552, 276, 0, 1686, 1687, + 3, 292, 146, 0, 1687, 1695, 1, 0, 0, 0, 1688, 1689, 3, 550, 275, 0, 1689, + 1690, 3, 292, 146, 0, 1690, 1691, 3, 552, 276, 0, 1691, 1692, 3, 292, 146, + 0, 1692, 1694, 1, 0, 0, 0, 1693, 1688, 1, 0, 0, 0, 1694, 1697, 1, 0, 0, + 0, 1695, 1693, 1, 0, 0, 0, 1695, 1696, 1, 0, 0, 0, 1696, 1698, 1, 0, 0, + 0, 1697, 1695, 1, 0, 0, 0, 1698, 1699, 3, 540, 270, 0, 1699, 229, 1, 0, + 0, 0, 1700, 1701, 3, 546, 273, 0, 1701, 1707, 3, 292, 146, 0, 1702, 1703, + 3, 550, 275, 0, 1703, 1704, 3, 292, 146, 0, 1704, 1706, 1, 0, 0, 0, 1705, + 1702, 1, 0, 0, 0, 1706, 1709, 1, 0, 0, 0, 1707, 1705, 1, 0, 0, 0, 1707, + 1708, 1, 0, 0, 0, 1708, 1710, 1, 0, 0, 0, 1709, 1707, 1, 0, 0, 0, 1710, + 1711, 3, 548, 274, 0, 1711, 231, 1, 0, 0, 0, 1712, 1713, 3, 534, 267, 0, + 1713, 1719, 3, 256, 128, 0, 1714, 1715, 3, 550, 275, 0, 1715, 1716, 3, + 256, 128, 0, 1716, 1718, 1, 0, 0, 0, 1717, 1714, 1, 0, 0, 0, 1718, 1721, + 1, 0, 0, 0, 1719, 1717, 1, 0, 0, 0, 1719, 1720, 1, 0, 0, 0, 1720, 1722, + 1, 0, 0, 0, 1721, 1719, 1, 0, 0, 0, 1722, 1723, 3, 536, 268, 0, 1723, 233, + 1, 0, 0, 0, 1724, 1726, 3, 180, 90, 0, 1725, 1724, 1, 0, 0, 0, 1725, 1726, + 1, 0, 0, 0, 1726, 1727, 1, 0, 0, 0, 1727, 1728, 3, 424, 212, 0, 1728, 1732, + 3, 426, 213, 0, 1729, 1730, 3, 304, 152, 0, 1730, 1731, 5, 10, 0, 0, 1731, + 1733, 1, 0, 0, 0, 1732, 1729, 1, 0, 0, 0, 1732, 1733, 1, 0, 0, 0, 1733, + 1734, 1, 0, 0, 0, 1734, 1736, 3, 306, 153, 0, 1735, 1737, 3, 250, 125, + 0, 1736, 1735, 1, 0, 0, 0, 1736, 1737, 1, 0, 0, 0, 1737, 1738, 1, 0, 0, + 0, 1738, 1740, 3, 248, 124, 0, 1739, 1741, 3, 244, 122, 0, 1740, 1739, + 1, 0, 0, 0, 1740, 1741, 1, 0, 0, 0, 1741, 1743, 1, 0, 0, 0, 1742, 1744, + 3, 236, 118, 0, 1743, 1742, 1, 0, 0, 0, 1743, 1744, 1, 0, 0, 0, 1744, 235, + 1, 0, 0, 0, 1745, 1746, 3, 522, 261, 0, 1746, 1747, 3, 240, 120, 0, 1747, + 1762, 1, 0, 0, 0, 1748, 1749, 3, 522, 261, 0, 1749, 1750, 3, 240, 120, + 0, 1750, 1751, 3, 356, 178, 0, 1751, 1752, 3, 238, 119, 0, 1752, 1762, + 1, 0, 0, 0, 1753, 1754, 3, 522, 261, 0, 1754, 1755, 3, 238, 119, 0, 1755, + 1762, 1, 0, 0, 0, 1756, 1757, 3, 522, 261, 0, 1757, 1758, 3, 238, 119, + 0, 1758, 1759, 3, 356, 178, 0, 1759, 1760, 3, 240, 120, 0, 1760, 1762, + 1, 0, 0, 0, 1761, 1745, 1, 0, 0, 0, 1761, 1748, 1, 0, 0, 0, 1761, 1753, + 1, 0, 0, 0, 1761, 1756, 1, 0, 0, 0, 1762, 237, 1, 0, 0, 0, 1763, 1764, + 3, 502, 251, 0, 1764, 1765, 3, 294, 147, 0, 1765, 239, 1, 0, 0, 0, 1766, + 1767, 3, 510, 255, 0, 1767, 1768, 3, 294, 147, 0, 1768, 241, 1, 0, 0, 0, + 1769, 1770, 3, 522, 261, 0, 1770, 1771, 3, 238, 119, 0, 1771, 243, 1, 0, + 0, 0, 1772, 1773, 3, 414, 207, 0, 1773, 1774, 3, 458, 229, 0, 1774, 1775, + 3, 398, 199, 0, 1775, 245, 1, 0, 0, 0, 1776, 1777, 3, 414, 207, 0, 1777, + 1778, 3, 398, 199, 0, 1778, 247, 1, 0, 0, 0, 1779, 1780, 3, 524, 262, 0, + 1780, 1781, 5, 1, 0, 0, 1781, 1782, 3, 254, 127, 0, 1782, 1783, 5, 2, 0, + 0, 1783, 1788, 1, 0, 0, 0, 1784, 1785, 3, 430, 215, 0, 1785, 1786, 3, 292, + 146, 0, 1786, 1788, 1, 0, 0, 0, 1787, 1779, 1, 0, 0, 0, 1787, 1784, 1, + 0, 0, 0, 1788, 249, 1, 0, 0, 0, 1789, 1790, 5, 1, 0, 0, 1790, 1791, 3, + 252, 126, 0, 1791, 1792, 5, 2, 0, 0, 1792, 251, 1, 0, 0, 0, 1793, 1799, + 3, 308, 154, 0, 1794, 1795, 3, 550, 275, 0, 1795, 1796, 3, 308, 154, 0, + 1796, 1798, 1, 0, 0, 0, 1797, 1794, 1, 0, 0, 0, 1798, 1801, 1, 0, 0, 0, + 1799, 1797, 1, 0, 0, 0, 1799, 1800, 1, 0, 0, 0, 1800, 253, 1, 0, 0, 0, + 1801, 1799, 1, 0, 0, 0, 1802, 1808, 3, 256, 128, 0, 1803, 1804, 3, 550, + 275, 0, 1804, 1805, 3, 256, 128, 0, 1805, 1807, 1, 0, 0, 0, 1806, 1803, + 1, 0, 0, 0, 1807, 1810, 1, 0, 0, 0, 1808, 1806, 1, 0, 0, 0, 1808, 1809, + 1, 0, 0, 0, 1809, 255, 1, 0, 0, 0, 1810, 1808, 1, 0, 0, 0, 1811, 1818, + 3, 292, 146, 0, 1812, 1818, 3, 288, 144, 0, 1813, 1818, 3, 228, 114, 0, + 1814, 1818, 3, 226, 113, 0, 1815, 1818, 3, 230, 115, 0, 1816, 1818, 3, + 232, 116, 0, 1817, 1811, 1, 0, 0, 0, 1817, 1812, 1, 0, 0, 0, 1817, 1813, + 1, 0, 0, 0, 1817, 1814, 1, 0, 0, 0, 1817, 1815, 1, 0, 0, 0, 1817, 1816, + 1, 0, 0, 0, 1818, 257, 1, 0, 0, 0, 1819, 1821, 3, 488, 244, 0, 1820, 1822, + 3, 274, 137, 0, 1821, 1820, 1, 0, 0, 0, 1821, 1822, 1, 0, 0, 0, 1822, 1824, + 1, 0, 0, 0, 1823, 1825, 3, 430, 215, 0, 1824, 1823, 1, 0, 0, 0, 1824, 1825, + 1, 0, 0, 0, 1825, 1826, 1, 0, 0, 0, 1826, 1827, 3, 276, 138, 0, 1827, 1829, + 3, 264, 132, 0, 1828, 1830, 3, 272, 136, 0, 1829, 1828, 1, 0, 0, 0, 1829, + 1830, 1, 0, 0, 0, 1830, 1832, 1, 0, 0, 0, 1831, 1833, 3, 268, 134, 0, 1832, + 1831, 1, 0, 0, 0, 1832, 1833, 1, 0, 0, 0, 1833, 1835, 1, 0, 0, 0, 1834, + 1836, 3, 262, 131, 0, 1835, 1834, 1, 0, 0, 0, 1835, 1836, 1, 0, 0, 0, 1836, + 1838, 1, 0, 0, 0, 1837, 1839, 3, 260, 130, 0, 1838, 1837, 1, 0, 0, 0, 1838, + 1839, 1, 0, 0, 0, 1839, 259, 1, 0, 0, 0, 1840, 1841, 3, 352, 176, 0, 1841, + 1842, 3, 400, 200, 0, 1842, 261, 1, 0, 0, 0, 1843, 1844, 3, 442, 221, 0, + 1844, 1845, 3, 294, 147, 0, 1845, 263, 1, 0, 0, 0, 1846, 1847, 3, 404, + 202, 0, 1847, 1848, 3, 266, 133, 0, 1848, 265, 1, 0, 0, 0, 1849, 1854, + 5, 170, 0, 0, 1850, 1851, 5, 170, 0, 0, 1851, 1852, 5, 10, 0, 0, 1852, + 1854, 5, 170, 0, 0, 1853, 1849, 1, 0, 0, 0, 1853, 1850, 1, 0, 0, 0, 1854, + 267, 1, 0, 0, 0, 1855, 1856, 3, 470, 235, 0, 1856, 1857, 3, 370, 185, 0, + 1857, 1858, 3, 270, 135, 0, 1858, 269, 1, 0, 0, 0, 1859, 1862, 5, 170, + 0, 0, 1860, 1863, 3, 362, 181, 0, 1861, 1863, 3, 384, 192, 0, 1862, 1860, + 1, 0, 0, 0, 1862, 1861, 1, 0, 0, 0, 1862, 1863, 1, 0, 0, 0, 1863, 271, + 1, 0, 0, 0, 1864, 1865, 3, 528, 264, 0, 1865, 1866, 3, 280, 140, 0, 1866, + 273, 1, 0, 0, 0, 1867, 1868, 3, 388, 194, 0, 1868, 275, 1, 0, 0, 0, 1869, + 1872, 5, 11, 0, 0, 1870, 1872, 3, 278, 139, 0, 1871, 1869, 1, 0, 0, 0, + 1871, 1870, 1, 0, 0, 0, 1872, 1878, 1, 0, 0, 0, 1873, 1874, 3, 550, 275, + 0, 1874, 1875, 3, 278, 139, 0, 1875, 1877, 1, 0, 0, 0, 1876, 1873, 1, 0, + 0, 0, 1877, 1880, 1, 0, 0, 0, 1878, 1876, 1, 0, 0, 0, 1878, 1879, 1, 0, + 0, 0, 1879, 277, 1, 0, 0, 0, 1880, 1878, 1, 0, 0, 0, 1881, 1882, 5, 170, + 0, 0, 1882, 1883, 5, 10, 0, 0, 1883, 1897, 5, 11, 0, 0, 1884, 1888, 5, + 170, 0, 0, 1885, 1886, 3, 360, 180, 0, 1886, 1887, 5, 170, 0, 0, 1887, + 1889, 1, 0, 0, 0, 1888, 1885, 1, 0, 0, 0, 1888, 1889, 1, 0, 0, 0, 1889, + 1897, 1, 0, 0, 0, 1890, 1894, 3, 288, 144, 0, 1891, 1892, 3, 360, 180, + 0, 1892, 1893, 5, 170, 0, 0, 1893, 1895, 1, 0, 0, 0, 1894, 1891, 1, 0, + 0, 0, 1894, 1895, 1, 0, 0, 0, 1895, 1897, 1, 0, 0, 0, 1896, 1881, 1, 0, + 0, 0, 1896, 1884, 1, 0, 0, 0, 1896, 1890, 1, 0, 0, 0, 1897, 279, 1, 0, + 0, 0, 1898, 1904, 3, 282, 141, 0, 1899, 1900, 3, 356, 178, 0, 1900, 1901, + 3, 282, 141, 0, 1901, 1903, 1, 0, 0, 0, 1902, 1899, 1, 0, 0, 0, 1903, 1906, + 1, 0, 0, 0, 1904, 1902, 1, 0, 0, 0, 1904, 1905, 1, 0, 0, 0, 1905, 281, + 1, 0, 0, 0, 1906, 1904, 1, 0, 0, 0, 1907, 1908, 5, 170, 0, 0, 1908, 1909, + 7, 2, 0, 0, 1909, 1979, 3, 292, 146, 0, 1910, 1911, 5, 170, 0, 0, 1911, + 1912, 5, 10, 0, 0, 1912, 1913, 5, 170, 0, 0, 1913, 1914, 7, 2, 0, 0, 1914, + 1979, 3, 292, 146, 0, 1915, 1916, 3, 288, 144, 0, 1916, 1917, 7, 2, 0, + 0, 1917, 1918, 3, 292, 146, 0, 1918, 1979, 1, 0, 0, 0, 1919, 1920, 3, 288, + 144, 0, 1920, 1921, 7, 2, 0, 0, 1921, 1922, 3, 288, 144, 0, 1922, 1979, + 1, 0, 0, 0, 1923, 1924, 5, 170, 0, 0, 1924, 1925, 3, 416, 208, 0, 1925, + 1927, 5, 1, 0, 0, 1926, 1928, 3, 290, 145, 0, 1927, 1926, 1, 0, 0, 0, 1927, + 1928, 1, 0, 0, 0, 1928, 1929, 1, 0, 0, 0, 1929, 1930, 5, 2, 0, 0, 1930, + 1979, 1, 0, 0, 0, 1931, 1932, 5, 1, 0, 0, 1932, 1938, 5, 170, 0, 0, 1933, + 1934, 3, 550, 275, 0, 1934, 1935, 5, 170, 0, 0, 1935, 1937, 1, 0, 0, 0, + 1936, 1933, 1, 0, 0, 0, 1937, 1940, 1, 0, 0, 0, 1938, 1936, 1, 0, 0, 0, + 1938, 1939, 1, 0, 0, 0, 1939, 1941, 1, 0, 0, 0, 1940, 1938, 1, 0, 0, 0, + 1941, 1942, 5, 2, 0, 0, 1942, 1943, 3, 416, 208, 0, 1943, 1944, 5, 1, 0, + 0, 1944, 1950, 3, 232, 116, 0, 1945, 1946, 3, 550, 275, 0, 1946, 1947, + 3, 232, 116, 0, 1947, 1949, 1, 0, 0, 0, 1948, 1945, 1, 0, 0, 0, 1949, 1952, + 1, 0, 0, 0, 1950, 1948, 1, 0, 0, 0, 1950, 1951, 1, 0, 0, 0, 1951, 1953, + 1, 0, 0, 0, 1952, 1950, 1, 0, 0, 0, 1953, 1954, 5, 2, 0, 0, 1954, 1979, + 1, 0, 0, 0, 1955, 1956, 5, 1, 0, 0, 1956, 1962, 5, 170, 0, 0, 1957, 1958, + 3, 550, 275, 0, 1958, 1959, 5, 170, 0, 0, 1959, 1961, 1, 0, 0, 0, 1960, + 1957, 1, 0, 0, 0, 1961, 1964, 1, 0, 0, 0, 1962, 1960, 1, 0, 0, 0, 1962, + 1963, 1, 0, 0, 0, 1963, 1965, 1, 0, 0, 0, 1964, 1962, 1, 0, 0, 0, 1965, + 1966, 5, 2, 0, 0, 1966, 1967, 7, 2, 0, 0, 1967, 1973, 3, 232, 116, 0, 1968, + 1969, 3, 550, 275, 0, 1969, 1970, 3, 232, 116, 0, 1970, 1972, 1, 0, 0, + 0, 1971, 1968, 1, 0, 0, 0, 1972, 1975, 1, 0, 0, 0, 1973, 1971, 1, 0, 0, + 0, 1973, 1974, 1, 0, 0, 0, 1974, 1979, 1, 0, 0, 0, 1975, 1973, 1, 0, 0, + 0, 1976, 1979, 3, 286, 143, 0, 1977, 1979, 3, 284, 142, 0, 1978, 1907, + 1, 0, 0, 0, 1978, 1910, 1, 0, 0, 0, 1978, 1915, 1, 0, 0, 0, 1978, 1919, + 1, 0, 0, 0, 1978, 1923, 1, 0, 0, 0, 1978, 1931, 1, 0, 0, 0, 1978, 1955, + 1, 0, 0, 0, 1978, 1976, 1, 0, 0, 0, 1978, 1977, 1, 0, 0, 0, 1979, 283, + 1, 0, 0, 0, 1980, 1981, 5, 170, 0, 0, 1981, 1982, 3, 378, 189, 0, 1982, + 1983, 3, 292, 146, 0, 1983, 285, 1, 0, 0, 0, 1984, 1985, 5, 170, 0, 0, + 1985, 1986, 3, 378, 189, 0, 1986, 1987, 3, 432, 216, 0, 1987, 1988, 1, + 0, 0, 0, 1988, 1989, 3, 292, 146, 0, 1989, 287, 1, 0, 0, 0, 1990, 1991, + 5, 170, 0, 0, 1991, 1992, 5, 1, 0, 0, 1992, 1993, 5, 11, 0, 0, 1993, 2004, + 5, 2, 0, 0, 1994, 1995, 5, 170, 0, 0, 1995, 1997, 5, 1, 0, 0, 1996, 1998, + 3, 290, 145, 0, 1997, 1996, 1, 0, 0, 0, 1997, 1998, 1, 0, 0, 0, 1998, 1999, + 1, 0, 0, 0, 1999, 2004, 5, 2, 0, 0, 2000, 2001, 5, 136, 0, 0, 2001, 2002, + 5, 1, 0, 0, 2002, 2004, 5, 2, 0, 0, 2003, 1990, 1, 0, 0, 0, 2003, 1994, + 1, 0, 0, 0, 2003, 2000, 1, 0, 0, 0, 2004, 289, 1, 0, 0, 0, 2005, 2009, + 3, 292, 146, 0, 2006, 2009, 5, 170, 0, 0, 2007, 2009, 3, 288, 144, 0, 2008, + 2005, 1, 0, 0, 0, 2008, 2006, 1, 0, 0, 0, 2008, 2007, 1, 0, 0, 0, 2009, + 2018, 1, 0, 0, 0, 2010, 2014, 3, 550, 275, 0, 2011, 2015, 3, 292, 146, + 0, 2012, 2015, 5, 170, 0, 0, 2013, 2015, 3, 288, 144, 0, 2014, 2011, 1, + 0, 0, 0, 2014, 2012, 1, 0, 0, 0, 2014, 2013, 1, 0, 0, 0, 2015, 2017, 1, + 0, 0, 0, 2016, 2010, 1, 0, 0, 0, 2017, 2020, 1, 0, 0, 0, 2018, 2016, 1, + 0, 0, 0, 2018, 2019, 1, 0, 0, 0, 2019, 291, 1, 0, 0, 0, 2020, 2018, 1, + 0, 0, 0, 2021, 2030, 5, 171, 0, 0, 2022, 2030, 3, 298, 149, 0, 2023, 2030, + 3, 294, 147, 0, 2024, 2030, 3, 296, 148, 0, 2025, 2030, 3, 302, 151, 0, + 2026, 2030, 3, 300, 150, 0, 2027, 2030, 3, 46, 23, 0, 2028, 2030, 3, 460, + 230, 0, 2029, 2021, 1, 0, 0, 0, 2029, 2022, 1, 0, 0, 0, 2029, 2023, 1, + 0, 0, 0, 2029, 2024, 1, 0, 0, 0, 2029, 2025, 1, 0, 0, 0, 2029, 2026, 1, + 0, 0, 0, 2029, 2027, 1, 0, 0, 0, 2029, 2028, 1, 0, 0, 0, 2030, 293, 1, + 0, 0, 0, 2031, 2032, 5, 166, 0, 0, 2032, 295, 1, 0, 0, 0, 2033, 2034, 7, + 3, 0, 0, 2034, 297, 1, 0, 0, 0, 2035, 2036, 5, 165, 0, 0, 2036, 299, 1, + 0, 0, 0, 2037, 2038, 7, 4, 0, 0, 2038, 301, 1, 0, 0, 0, 2039, 2040, 5, + 168, 0, 0, 2040, 303, 1, 0, 0, 0, 2041, 2046, 5, 170, 0, 0, 2042, 2043, + 5, 17, 0, 0, 2043, 2044, 5, 170, 0, 0, 2044, 2046, 5, 17, 0, 0, 2045, 2041, + 1, 0, 0, 0, 2045, 2042, 1, 0, 0, 0, 2046, 305, 1, 0, 0, 0, 2047, 2052, + 5, 170, 0, 0, 2048, 2049, 5, 17, 0, 0, 2049, 2050, 5, 170, 0, 0, 2050, + 2052, 5, 17, 0, 0, 2051, 2047, 1, 0, 0, 0, 2051, 2048, 1, 0, 0, 0, 2052, + 307, 1, 0, 0, 0, 2053, 2058, 5, 170, 0, 0, 2054, 2055, 5, 17, 0, 0, 2055, + 2056, 5, 170, 0, 0, 2056, 2058, 5, 17, 0, 0, 2057, 2053, 1, 0, 0, 0, 2057, + 2054, 1, 0, 0, 0, 2058, 309, 1, 0, 0, 0, 2059, 2061, 3, 312, 156, 0, 2060, + 2062, 3, 314, 157, 0, 2061, 2060, 1, 0, 0, 0, 2061, 2062, 1, 0, 0, 0, 2062, + 311, 1, 0, 0, 0, 2063, 2064, 7, 5, 0, 0, 2064, 313, 1, 0, 0, 0, 2065, 2066, + 3, 542, 271, 0, 2066, 2072, 3, 312, 156, 0, 2067, 2068, 3, 550, 275, 0, + 2068, 2069, 3, 312, 156, 0, 2069, 2071, 1, 0, 0, 0, 2070, 2067, 1, 0, 0, + 0, 2071, 2074, 1, 0, 0, 0, 2072, 2070, 1, 0, 0, 0, 2072, 2073, 1, 0, 0, + 0, 2073, 2075, 1, 0, 0, 0, 2074, 2072, 1, 0, 0, 0, 2075, 2076, 3, 544, + 272, 0, 2076, 315, 1, 0, 0, 0, 2077, 2080, 3, 362, 181, 0, 2078, 2080, + 3, 384, 192, 0, 2079, 2077, 1, 0, 0, 0, 2079, 2078, 1, 0, 0, 0, 2080, 317, + 1, 0, 0, 0, 2081, 2082, 5, 170, 0, 0, 2082, 319, 1, 0, 0, 0, 2083, 2084, + 5, 170, 0, 0, 2084, 321, 1, 0, 0, 0, 2085, 2086, 3, 298, 149, 0, 2086, + 323, 1, 0, 0, 0, 2087, 2088, 5, 170, 0, 0, 2088, 325, 1, 0, 0, 0, 2089, + 2090, 5, 170, 0, 0, 2090, 327, 1, 0, 0, 0, 2091, 2092, 5, 170, 0, 0, 2092, + 329, 1, 0, 0, 0, 2093, 2094, 5, 170, 0, 0, 2094, 331, 1, 0, 0, 0, 2095, + 2096, 5, 170, 0, 0, 2096, 333, 1, 0, 0, 0, 2097, 2098, 5, 170, 0, 0, 2098, + 335, 1, 0, 0, 0, 2099, 2100, 3, 298, 149, 0, 2100, 337, 1, 0, 0, 0, 2101, + 2102, 5, 170, 0, 0, 2102, 339, 1, 0, 0, 0, 2103, 2104, 3, 342, 171, 0, + 2104, 2105, 3, 310, 155, 0, 2105, 341, 1, 0, 0, 0, 2106, 2107, 7, 6, 0, + 0, 2107, 343, 1, 0, 0, 0, 2108, 2109, 5, 24, 0, 0, 2109, 345, 1, 0, 0, + 0, 2110, 2111, 5, 25, 0, 0, 2111, 347, 1, 0, 0, 0, 2112, 2113, 5, 26, 0, + 0, 2113, 349, 1, 0, 0, 0, 2114, 2115, 5, 26, 0, 0, 2115, 2116, 5, 102, + 0, 0, 2116, 351, 1, 0, 0, 0, 2117, 2118, 5, 27, 0, 0, 2118, 353, 1, 0, + 0, 0, 2119, 2120, 5, 28, 0, 0, 2120, 355, 1, 0, 0, 0, 2121, 2122, 5, 29, + 0, 0, 2122, 357, 1, 0, 0, 0, 2123, 2124, 5, 31, 0, 0, 2124, 359, 1, 0, + 0, 0, 2125, 2126, 5, 32, 0, 0, 2126, 361, 1, 0, 0, 0, 2127, 2128, 5, 33, + 0, 0, 2128, 363, 1, 0, 0, 0, 2129, 2130, 5, 34, 0, 0, 2130, 365, 1, 0, + 0, 0, 2131, 2132, 5, 35, 0, 0, 2132, 367, 1, 0, 0, 0, 2133, 2134, 5, 36, + 0, 0, 2134, 369, 1, 0, 0, 0, 2135, 2136, 5, 37, 0, 0, 2136, 371, 1, 0, + 0, 0, 2137, 2138, 5, 38, 0, 0, 2138, 373, 1, 0, 0, 0, 2139, 2140, 5, 39, + 0, 0, 2140, 375, 1, 0, 0, 0, 2141, 2142, 5, 41, 0, 0, 2142, 377, 1, 0, + 0, 0, 2143, 2144, 5, 43, 0, 0, 2144, 379, 1, 0, 0, 0, 2145, 2146, 5, 44, + 0, 0, 2146, 381, 1, 0, 0, 0, 2147, 2148, 5, 46, 0, 0, 2148, 383, 1, 0, + 0, 0, 2149, 2150, 5, 47, 0, 0, 2150, 385, 1, 0, 0, 0, 2151, 2152, 5, 48, + 0, 0, 2152, 387, 1, 0, 0, 0, 2153, 2154, 5, 49, 0, 0, 2154, 389, 1, 0, + 0, 0, 2155, 2156, 5, 50, 0, 0, 2156, 391, 1, 0, 0, 0, 2157, 2158, 5, 51, + 0, 0, 2158, 393, 1, 0, 0, 0, 2159, 2160, 5, 53, 0, 0, 2160, 395, 1, 0, + 0, 0, 2161, 2162, 5, 54, 0, 0, 2162, 397, 1, 0, 0, 0, 2163, 2164, 5, 55, + 0, 0, 2164, 399, 1, 0, 0, 0, 2165, 2166, 5, 57, 0, 0, 2166, 401, 1, 0, + 0, 0, 2167, 2168, 5, 58, 0, 0, 2168, 403, 1, 0, 0, 0, 2169, 2170, 5, 59, + 0, 0, 2170, 405, 1, 0, 0, 0, 2171, 2172, 5, 60, 0, 0, 2172, 407, 1, 0, + 0, 0, 2173, 2174, 5, 61, 0, 0, 2174, 409, 1, 0, 0, 0, 2175, 2176, 5, 62, + 0, 0, 2176, 411, 1, 0, 0, 0, 2177, 2178, 5, 63, 0, 0, 2178, 413, 1, 0, + 0, 0, 2179, 2180, 5, 64, 0, 0, 2180, 415, 1, 0, 0, 0, 2181, 2182, 5, 65, + 0, 0, 2182, 417, 1, 0, 0, 0, 2183, 2184, 5, 66, 0, 0, 2184, 419, 1, 0, + 0, 0, 2185, 2186, 5, 68, 0, 0, 2186, 421, 1, 0, 0, 0, 2187, 2188, 5, 69, + 0, 0, 2188, 423, 1, 0, 0, 0, 2189, 2190, 5, 70, 0, 0, 2190, 425, 1, 0, + 0, 0, 2191, 2192, 5, 71, 0, 0, 2192, 427, 1, 0, 0, 0, 2193, 2194, 5, 72, + 0, 0, 2194, 429, 1, 0, 0, 0, 2195, 2196, 5, 73, 0, 0, 2196, 431, 1, 0, + 0, 0, 2197, 2198, 5, 74, 0, 0, 2198, 433, 1, 0, 0, 0, 2199, 2200, 5, 75, + 0, 0, 2200, 435, 1, 0, 0, 0, 2201, 2202, 5, 76, 0, 0, 2202, 437, 1, 0, + 0, 0, 2203, 2204, 5, 77, 0, 0, 2204, 439, 1, 0, 0, 0, 2205, 2206, 5, 78, + 0, 0, 2206, 441, 1, 0, 0, 0, 2207, 2208, 5, 80, 0, 0, 2208, 443, 1, 0, + 0, 0, 2209, 2210, 5, 154, 0, 0, 2210, 445, 1, 0, 0, 0, 2211, 2212, 5, 83, + 0, 0, 2212, 447, 1, 0, 0, 0, 2213, 2214, 5, 84, 0, 0, 2214, 449, 1, 0, + 0, 0, 2215, 2216, 5, 85, 0, 0, 2216, 451, 1, 0, 0, 0, 2217, 2218, 5, 86, + 0, 0, 2218, 453, 1, 0, 0, 0, 2219, 2220, 5, 89, 0, 0, 2220, 455, 1, 0, + 0, 0, 2221, 2222, 5, 88, 0, 0, 2222, 457, 1, 0, 0, 0, 2223, 2224, 5, 90, + 0, 0, 2224, 459, 1, 0, 0, 0, 2225, 2226, 5, 91, 0, 0, 2226, 461, 1, 0, + 0, 0, 2227, 2228, 5, 92, 0, 0, 2228, 463, 1, 0, 0, 0, 2229, 2230, 5, 93, + 0, 0, 2230, 465, 1, 0, 0, 0, 2231, 2232, 5, 95, 0, 0, 2232, 467, 1, 0, + 0, 0, 2233, 2234, 5, 96, 0, 0, 2234, 469, 1, 0, 0, 0, 2235, 2236, 5, 97, + 0, 0, 2236, 471, 1, 0, 0, 0, 2237, 2238, 5, 99, 0, 0, 2238, 473, 1, 0, + 0, 0, 2239, 2240, 5, 103, 0, 0, 2240, 475, 1, 0, 0, 0, 2241, 2242, 5, 105, + 0, 0, 2242, 477, 1, 0, 0, 0, 2243, 2244, 5, 106, 0, 0, 2244, 479, 1, 0, + 0, 0, 2245, 2246, 5, 107, 0, 0, 2246, 481, 1, 0, 0, 0, 2247, 2248, 5, 108, + 0, 0, 2248, 483, 1, 0, 0, 0, 2249, 2250, 5, 110, 0, 0, 2250, 485, 1, 0, + 0, 0, 2251, 2252, 5, 111, 0, 0, 2252, 487, 1, 0, 0, 0, 2253, 2254, 5, 113, + 0, 0, 2254, 489, 1, 0, 0, 0, 2255, 2256, 5, 114, 0, 0, 2256, 491, 1, 0, + 0, 0, 2257, 2258, 5, 115, 0, 0, 2258, 493, 1, 0, 0, 0, 2259, 2260, 5, 117, + 0, 0, 2260, 495, 1, 0, 0, 0, 2261, 2262, 5, 118, 0, 0, 2262, 497, 1, 0, + 0, 0, 2263, 2264, 5, 119, 0, 0, 2264, 499, 1, 0, 0, 0, 2265, 2266, 5, 120, + 0, 0, 2266, 501, 1, 0, 0, 0, 2267, 2268, 5, 122, 0, 0, 2268, 503, 1, 0, + 0, 0, 2269, 2270, 5, 123, 0, 0, 2270, 505, 1, 0, 0, 0, 2271, 2272, 5, 125, + 0, 0, 2272, 507, 1, 0, 0, 0, 2273, 2274, 5, 127, 0, 0, 2274, 509, 1, 0, + 0, 0, 2275, 2276, 5, 128, 0, 0, 2276, 511, 1, 0, 0, 0, 2277, 2278, 5, 130, + 0, 0, 2278, 513, 1, 0, 0, 0, 2279, 2280, 5, 131, 0, 0, 2280, 515, 1, 0, + 0, 0, 2281, 2282, 5, 132, 0, 0, 2282, 517, 1, 0, 0, 0, 2283, 2284, 5, 133, + 0, 0, 2284, 519, 1, 0, 0, 0, 2285, 2286, 5, 134, 0, 0, 2286, 521, 1, 0, + 0, 0, 2287, 2288, 5, 135, 0, 0, 2288, 523, 1, 0, 0, 0, 2289, 2290, 5, 137, + 0, 0, 2290, 525, 1, 0, 0, 0, 2291, 2292, 5, 138, 0, 0, 2292, 527, 1, 0, + 0, 0, 2293, 2294, 5, 139, 0, 0, 2294, 529, 1, 0, 0, 0, 2295, 2296, 5, 140, + 0, 0, 2296, 531, 1, 0, 0, 0, 2297, 2298, 5, 109, 0, 0, 2298, 533, 1, 0, + 0, 0, 2299, 2300, 5, 1, 0, 0, 2300, 535, 1, 0, 0, 0, 2301, 2302, 5, 2, + 0, 0, 2302, 537, 1, 0, 0, 0, 2303, 2304, 5, 3, 0, 0, 2304, 539, 1, 0, 0, + 0, 2305, 2306, 5, 4, 0, 0, 2306, 541, 1, 0, 0, 0, 2307, 2308, 5, 20, 0, + 0, 2308, 543, 1, 0, 0, 0, 2309, 2310, 5, 21, 0, 0, 2310, 545, 1, 0, 0, + 0, 2311, 2312, 5, 5, 0, 0, 2312, 547, 1, 0, 0, 0, 2313, 2314, 5, 6, 0, + 0, 2314, 549, 1, 0, 0, 0, 2315, 2316, 5, 7, 0, 0, 2316, 551, 1, 0, 0, 0, + 2317, 2318, 5, 9, 0, 0, 2318, 553, 1, 0, 0, 0, 178, 555, 558, 564, 569, + 571, 576, 579, 582, 625, 639, 642, 649, 654, 665, 675, 690, 701, 706, 715, + 720, 728, 733, 737, 742, 747, 762, 768, 773, 783, 788, 798, 810, 817, 825, + 839, 844, 856, 860, 864, 869, 874, 893, 900, 908, 912, 917, 936, 945, 960, + 962, 974, 988, 995, 1002, 1010, 1021, 1037, 1050, 1060, 1083, 1097, 1104, + 1113, 1132, 1140, 1146, 1151, 1158, 1163, 1171, 1176, 1183, 1188, 1195, + 1200, 1207, 1214, 1221, 1228, 1233, 1240, 1247, 1252, 1259, 1264, 1271, + 1281, 1287, 1295, 1298, 1306, 1311, 1315, 1328, 1334, 1343, 1356, 1364, + 1370, 1375, 1389, 1409, 1418, 1430, 1434, 1438, 1452, 1460, 1469, 1480, + 1485, 1492, 1495, 1501, 1510, 1516, 1534, 1538, 1542, 1547, 1555, 1563, + 1567, 1570, 1576, 1580, 1587, 1598, 1611, 1620, 1667, 1676, 1679, 1695, + 1707, 1719, 1725, 1732, 1736, 1740, 1743, 1761, 1787, 1799, 1808, 1817, + 1821, 1824, 1829, 1832, 1835, 1838, 1853, 1862, 1871, 1878, 1888, 1894, + 1896, 1904, 1927, 1938, 1950, 1962, 1973, 1978, 1997, 2003, 2008, 2014, + 2018, 2029, 2045, 2051, 2057, 2061, 2072, 2079, + } + deserializer := antlr.NewATNDeserializer(nil) + staticData.atn = deserializer.Deserialize(staticData.serializedATN) + atn := staticData.atn + staticData.decisionToDFA = make([]*antlr.DFA, len(atn.DecisionToState)) + decisionToDFA := staticData.decisionToDFA + for index, state := range atn.DecisionToState { + decisionToDFA[index] = antlr.NewDFA(state, index) + } +} + +// CqlParserInit initializes any static state used to implement CqlParser. By default the +// static state used to implement the parser is lazily initialized during the first call to +// NewCqlParser(). You can call this function if you wish to initialize the static state ahead +// of time. +func CqlParserInit() { + staticData := &CqlParserParserStaticData + staticData.once.Do(cqlparserParserInit) +} + +// NewCqlParser produces a new parser instance for the optional input antlr.TokenStream. +func NewCqlParser(input antlr.TokenStream) *CqlParser { + CqlParserInit() + this := new(CqlParser) + this.BaseParser = antlr.NewBaseParser(input) + staticData := &CqlParserParserStaticData + this.Interpreter = antlr.NewParserATNSimulator(this, staticData.atn, staticData.decisionToDFA, staticData.PredictionContextCache) + this.RuleNames = staticData.RuleNames + this.LiteralNames = staticData.LiteralNames + this.SymbolicNames = staticData.SymbolicNames + this.GrammarFileName = "CqlParser.g4" + + return this +} + +// CqlParser tokens. +const ( + CqlParserEOF = antlr.TokenEOF + CqlParserLR_BRACKET = 1 + CqlParserRR_BRACKET = 2 + CqlParserLC_BRACKET = 3 + CqlParserRC_BRACKET = 4 + CqlParserLS_BRACKET = 5 + CqlParserRS_BRACKET = 6 + CqlParserCOMMA = 7 + CqlParserSEMI = 8 + CqlParserCOLON = 9 + CqlParserDOT = 10 + CqlParserSTAR = 11 + CqlParserDIVIDE = 12 + CqlParserMODULE = 13 + CqlParserPLUS = 14 + CqlParserMINUSMINUS = 15 + CqlParserMINUS = 16 + CqlParserDQUOTE = 17 + CqlParserSQUOTE = 18 + CqlParserOPERATOR_EQ = 19 + CqlParserOPERATOR_LT = 20 + CqlParserOPERATOR_GT = 21 + CqlParserOPERATOR_LTE = 22 + CqlParserOPERATOR_GTE = 23 + CqlParserK_ADD = 24 + CqlParserK_AGGREGATE = 25 + CqlParserK_ALL = 26 + CqlParserK_ALLOW = 27 + CqlParserK_ALTER = 28 + CqlParserK_AND = 29 + CqlParserK_ANY = 30 + CqlParserK_APPLY = 31 + CqlParserK_AS = 32 + CqlParserK_ASC = 33 + CqlParserK_AUTHORIZE = 34 + CqlParserK_BATCH = 35 + CqlParserK_BEGIN = 36 + CqlParserK_BY = 37 + CqlParserK_CALLED = 38 + CqlParserK_CLUSTERING = 39 + CqlParserK_COLUMNFAMILY = 40 + CqlParserK_COMPACT = 41 + CqlParserK_CONSISTENCY = 42 + CqlParserK_CONTAINS = 43 + CqlParserK_CREATE = 44 + CqlParserK_CUSTOM = 45 + CqlParserK_DELETE = 46 + CqlParserK_DESC = 47 + CqlParserK_DESCRIBE = 48 + CqlParserK_DISTINCT = 49 + CqlParserK_DROP = 50 + CqlParserK_DURABLE_WRITES = 51 + CqlParserK_EACH_QUORUM = 52 + CqlParserK_ENTRIES = 53 + CqlParserK_EXECUTE = 54 + CqlParserK_EXISTS = 55 + CqlParserK_FALSE = 56 + CqlParserK_FILTERING = 57 + CqlParserK_FINALFUNC = 58 + CqlParserK_FROM = 59 + CqlParserK_FULL = 60 + CqlParserK_FUNCTION = 61 + CqlParserK_FUNCTIONS = 62 + CqlParserK_GRANT = 63 + CqlParserK_IF = 64 + CqlParserK_IN = 65 + CqlParserK_INDEX = 66 + CqlParserK_INFINITY = 67 + CqlParserK_INITCOND = 68 + CqlParserK_INPUT = 69 + CqlParserK_INSERT = 70 + CqlParserK_INTO = 71 + CqlParserK_IS = 72 + CqlParserK_JSON = 73 + CqlParserK_KEY = 74 + CqlParserK_KEYS = 75 + CqlParserK_KEYSPACE = 76 + CqlParserK_KEYSPACES = 77 + CqlParserK_LANGUAGE = 78 + CqlParserK_LEVEL = 79 + CqlParserK_LIMIT = 80 + CqlParserK_LOCAL_ONE = 81 + CqlParserK_LOCAL_QUORUM = 82 + CqlParserK_LOGGED = 83 + CqlParserK_LOGIN = 84 + CqlParserK_MATERIALIZED = 85 + CqlParserK_MODIFY = 86 + CqlParserK_NAN = 87 + CqlParserK_NORECURSIVE = 88 + CqlParserK_NOSUPERUSER = 89 + CqlParserK_NOT = 90 + CqlParserK_NULL = 91 + CqlParserK_OF = 92 + CqlParserK_ON = 93 + CqlParserK_ONE = 94 + CqlParserK_OPTIONS = 95 + CqlParserK_OR = 96 + CqlParserK_ORDER = 97 + CqlParserK_PARTITION = 98 + CqlParserK_PASSWORD = 99 + CqlParserK_PER = 100 + CqlParserK_PERMISSION = 101 + CqlParserK_PERMISSIONS = 102 + CqlParserK_PRIMARY = 103 + CqlParserK_QUORUM = 104 + CqlParserK_RENAME = 105 + CqlParserK_REPLACE = 106 + CqlParserK_REPLICATION = 107 + CqlParserK_RETURNS = 108 + CqlParserK_REVOKE = 109 + CqlParserK_ROLE = 110 + CqlParserK_ROLES = 111 + CqlParserK_SCHEMA = 112 + CqlParserK_SELECT = 113 + CqlParserK_SET = 114 + CqlParserK_SFUNC = 115 + CqlParserK_STATIC = 116 + CqlParserK_STORAGE = 117 + CqlParserK_STYPE = 118 + CqlParserK_SUPERUSER = 119 + CqlParserK_TABLE = 120 + CqlParserK_THREE = 121 + CqlParserK_TIMESTAMP = 122 + CqlParserK_TO = 123 + CqlParserK_TOKEN = 124 + CqlParserK_TRIGGER = 125 + CqlParserK_TRUE = 126 + CqlParserK_TRUNCATE = 127 + CqlParserK_TTL = 128 + CqlParserK_TWO = 129 + CqlParserK_TYPE = 130 + CqlParserK_UNLOGGED = 131 + CqlParserK_UPDATE = 132 + CqlParserK_USE = 133 + CqlParserK_USER = 134 + CqlParserK_USING = 135 + CqlParserK_UUID = 136 + CqlParserK_VALUES = 137 + CqlParserK_VIEW = 138 + CqlParserK_WHERE = 139 + CqlParserK_WITH = 140 + CqlParserK_WRITETIME = 141 + CqlParserK_ASCII = 142 + CqlParserK_BIGINT = 143 + CqlParserK_BLOB = 144 + CqlParserK_BOOLEAN = 145 + CqlParserK_COUNTER = 146 + CqlParserK_DATE = 147 + CqlParserK_DECIMAL = 148 + CqlParserK_DOUBLE = 149 + CqlParserK_FLOAT = 150 + CqlParserK_FROZEN = 151 + CqlParserK_INET = 152 + CqlParserK_INT = 153 + CqlParserK_LIST = 154 + CqlParserK_MAP = 155 + CqlParserK_SMALLINT = 156 + CqlParserK_TEXT = 157 + CqlParserK_TIMEUUID = 158 + CqlParserK_TIME = 159 + CqlParserK_TINYINT = 160 + CqlParserK_TUPLE = 161 + CqlParserK_VARCHAR = 162 + CqlParserK_VARINT = 163 + CqlParserCODE_BLOCK = 164 + CqlParserSTRING_LITERAL = 165 + CqlParserDECIMAL_LITERAL = 166 + CqlParserFLOAT_LITERAL = 167 + CqlParserHEXADECIMAL_LITERAL = 168 + CqlParserREAL_LITERAL = 169 + CqlParserOBJECT_NAME = 170 + CqlParserUUID = 171 + CqlParserSPACE = 172 + CqlParserSPEC_MYSQL_COMMENT = 173 + CqlParserCOMMENT_INPUT = 174 + CqlParserLINE_COMMENT = 175 +) + +// CqlParser rules. +const ( + CqlParserRULE_root = 0 + CqlParserRULE_cqls = 1 + CqlParserRULE_statementSeparator = 2 + CqlParserRULE_empty_ = 3 + CqlParserRULE_cql = 4 + CqlParserRULE_revoke = 5 + CqlParserRULE_listRoles = 6 + CqlParserRULE_listPermissions = 7 + CqlParserRULE_grant = 8 + CqlParserRULE_priviledge = 9 + CqlParserRULE_resource = 10 + CqlParserRULE_createUser = 11 + CqlParserRULE_createRole = 12 + CqlParserRULE_createType = 13 + CqlParserRULE_typeMemberColumnList = 14 + CqlParserRULE_createTrigger = 15 + CqlParserRULE_createMaterializedView = 16 + CqlParserRULE_materializedViewWhere = 17 + CqlParserRULE_columnNotNullList = 18 + CqlParserRULE_columnNotNull = 19 + CqlParserRULE_materializedViewOptions = 20 + CqlParserRULE_createKeyspace = 21 + CqlParserRULE_createFunction = 22 + CqlParserRULE_codeBlock = 23 + CqlParserRULE_paramList = 24 + CqlParserRULE_returnMode = 25 + CqlParserRULE_createAggregate = 26 + CqlParserRULE_initCondDefinition = 27 + CqlParserRULE_initCondHash = 28 + CqlParserRULE_initCondHashItem = 29 + CqlParserRULE_initCondListNested = 30 + CqlParserRULE_initCondList = 31 + CqlParserRULE_orReplace = 32 + CqlParserRULE_alterUser = 33 + CqlParserRULE_userPassword = 34 + CqlParserRULE_userSuperUser = 35 + CqlParserRULE_alterType = 36 + CqlParserRULE_alterTypeOperation = 37 + CqlParserRULE_alterTypeRename = 38 + CqlParserRULE_alterTypeRenameList = 39 + CqlParserRULE_alterTypeRenameItem = 40 + CqlParserRULE_alterTypeAdd = 41 + CqlParserRULE_alterTypeAlterType = 42 + CqlParserRULE_alterTable = 43 + CqlParserRULE_alterTableOperation = 44 + CqlParserRULE_alterTableWith = 45 + CqlParserRULE_alterTableRename = 46 + CqlParserRULE_alterTableDropCompactStorage = 47 + CqlParserRULE_alterTableDropColumns = 48 + CqlParserRULE_alterTableDropColumnList = 49 + CqlParserRULE_alterTableAdd = 50 + CqlParserRULE_alterTableColumnDefinition = 51 + CqlParserRULE_alterRole = 52 + CqlParserRULE_roleWith = 53 + CqlParserRULE_roleWithOptions = 54 + CqlParserRULE_alterMaterializedView = 55 + CqlParserRULE_dropUser = 56 + CqlParserRULE_dropType = 57 + CqlParserRULE_dropMaterializedView = 58 + CqlParserRULE_dropAggregate = 59 + CqlParserRULE_dropFunction = 60 + CqlParserRULE_dropTrigger = 61 + CqlParserRULE_dropRole = 62 + CqlParserRULE_dropTable = 63 + CqlParserRULE_dropKeyspace = 64 + CqlParserRULE_dropIndex = 65 + CqlParserRULE_createTable = 66 + CqlParserRULE_withElement = 67 + CqlParserRULE_tableOptions = 68 + CqlParserRULE_clusteringOrder = 69 + CqlParserRULE_tableOptionItem = 70 + CqlParserRULE_tableOptionName = 71 + CqlParserRULE_tableOptionValue = 72 + CqlParserRULE_optionHash = 73 + CqlParserRULE_optionHashItem = 74 + CqlParserRULE_optionHashKey = 75 + CqlParserRULE_optionHashValue = 76 + CqlParserRULE_columnDefinitionList = 77 + CqlParserRULE_columnDefinition = 78 + CqlParserRULE_primaryKeyColumn = 79 + CqlParserRULE_primaryKeyElement = 80 + CqlParserRULE_primaryKeyDefinition = 81 + CqlParserRULE_singlePrimaryKey = 82 + CqlParserRULE_compoundKey = 83 + CqlParserRULE_compositeKey = 84 + CqlParserRULE_partitionKeyList = 85 + CqlParserRULE_clusteringKeyList = 86 + CqlParserRULE_partitionKey = 87 + CqlParserRULE_clusteringKey = 88 + CqlParserRULE_applyBatch = 89 + CqlParserRULE_beginBatch = 90 + CqlParserRULE_batchType = 91 + CqlParserRULE_alterKeyspace = 92 + CqlParserRULE_replicationList = 93 + CqlParserRULE_replicationListItem = 94 + CqlParserRULE_durableWrites = 95 + CqlParserRULE_use_ = 96 + CqlParserRULE_truncate = 97 + CqlParserRULE_createIndex = 98 + CqlParserRULE_indexName = 99 + CqlParserRULE_indexColumnSpec = 100 + CqlParserRULE_indexKeysSpec = 101 + CqlParserRULE_indexEntriesSSpec = 102 + CqlParserRULE_indexFullSpec = 103 + CqlParserRULE_delete_ = 104 + CqlParserRULE_deleteColumnList = 105 + CqlParserRULE_deleteColumnItem = 106 + CqlParserRULE_update = 107 + CqlParserRULE_ifSpec = 108 + CqlParserRULE_ifConditionList = 109 + CqlParserRULE_ifCondition = 110 + CqlParserRULE_assignments = 111 + CqlParserRULE_assignmentElement = 112 + CqlParserRULE_assignmentSet = 113 + CqlParserRULE_assignmentMap = 114 + CqlParserRULE_assignmentList = 115 + CqlParserRULE_assignmentTuple = 116 + CqlParserRULE_insert = 117 + CqlParserRULE_usingTtlTimestamp = 118 + CqlParserRULE_timestamp = 119 + CqlParserRULE_ttl = 120 + CqlParserRULE_usingTimestampSpec = 121 + CqlParserRULE_ifNotExist = 122 + CqlParserRULE_ifExist = 123 + CqlParserRULE_insertValuesSpec = 124 + CqlParserRULE_insertColumnSpec = 125 + CqlParserRULE_columnList = 126 + CqlParserRULE_expressionList = 127 + CqlParserRULE_expression = 128 + CqlParserRULE_select_ = 129 + CqlParserRULE_allowFilteringSpec = 130 + CqlParserRULE_limitSpec = 131 + CqlParserRULE_fromSpec = 132 + CqlParserRULE_fromSpecElement = 133 + CqlParserRULE_orderSpec = 134 + CqlParserRULE_orderSpecElement = 135 + CqlParserRULE_whereSpec = 136 + CqlParserRULE_distinctSpec = 137 + CqlParserRULE_selectElements = 138 + CqlParserRULE_selectElement = 139 + CqlParserRULE_relationElements = 140 + CqlParserRULE_relationElement = 141 + CqlParserRULE_relalationContains = 142 + CqlParserRULE_relalationContainsKey = 143 + CqlParserRULE_functionCall = 144 + CqlParserRULE_functionArgs = 145 + CqlParserRULE_constant = 146 + CqlParserRULE_decimalLiteral = 147 + CqlParserRULE_floatLiteral = 148 + CqlParserRULE_stringLiteral = 149 + CqlParserRULE_booleanLiteral = 150 + CqlParserRULE_hexadecimalLiteral = 151 + CqlParserRULE_keyspace = 152 + CqlParserRULE_table = 153 + CqlParserRULE_column = 154 + CqlParserRULE_dataType = 155 + CqlParserRULE_dataTypeName = 156 + CqlParserRULE_dataTypeDefinition = 157 + CqlParserRULE_orderDirection = 158 + CqlParserRULE_role = 159 + CqlParserRULE_trigger = 160 + CqlParserRULE_triggerClass = 161 + CqlParserRULE_materializedView = 162 + CqlParserRULE_type_ = 163 + CqlParserRULE_aggregate = 164 + CqlParserRULE_function_ = 165 + CqlParserRULE_language = 166 + CqlParserRULE_user = 167 + CqlParserRULE_password = 168 + CqlParserRULE_hashKey = 169 + CqlParserRULE_param = 170 + CqlParserRULE_paramName = 171 + CqlParserRULE_kwAdd = 172 + CqlParserRULE_kwAggregate = 173 + CqlParserRULE_kwAll = 174 + CqlParserRULE_kwAllPermissions = 175 + CqlParserRULE_kwAllow = 176 + CqlParserRULE_kwAlter = 177 + CqlParserRULE_kwAnd = 178 + CqlParserRULE_kwApply = 179 + CqlParserRULE_kwAs = 180 + CqlParserRULE_kwAsc = 181 + CqlParserRULE_kwAuthorize = 182 + CqlParserRULE_kwBatch = 183 + CqlParserRULE_kwBegin = 184 + CqlParserRULE_kwBy = 185 + CqlParserRULE_kwCalled = 186 + CqlParserRULE_kwClustering = 187 + CqlParserRULE_kwCompact = 188 + CqlParserRULE_kwContains = 189 + CqlParserRULE_kwCreate = 190 + CqlParserRULE_kwDelete = 191 + CqlParserRULE_kwDesc = 192 + CqlParserRULE_kwDescibe = 193 + CqlParserRULE_kwDistinct = 194 + CqlParserRULE_kwDrop = 195 + CqlParserRULE_kwDurableWrites = 196 + CqlParserRULE_kwEntries = 197 + CqlParserRULE_kwExecute = 198 + CqlParserRULE_kwExists = 199 + CqlParserRULE_kwFiltering = 200 + CqlParserRULE_kwFinalfunc = 201 + CqlParserRULE_kwFrom = 202 + CqlParserRULE_kwFull = 203 + CqlParserRULE_kwFunction = 204 + CqlParserRULE_kwFunctions = 205 + CqlParserRULE_kwGrant = 206 + CqlParserRULE_kwIf = 207 + CqlParserRULE_kwIn = 208 + CqlParserRULE_kwIndex = 209 + CqlParserRULE_kwInitcond = 210 + CqlParserRULE_kwInput = 211 + CqlParserRULE_kwInsert = 212 + CqlParserRULE_kwInto = 213 + CqlParserRULE_kwIs = 214 + CqlParserRULE_kwJson = 215 + CqlParserRULE_kwKey = 216 + CqlParserRULE_kwKeys = 217 + CqlParserRULE_kwKeyspace = 218 + CqlParserRULE_kwKeyspaces = 219 + CqlParserRULE_kwLanguage = 220 + CqlParserRULE_kwLimit = 221 + CqlParserRULE_kwList = 222 + CqlParserRULE_kwLogged = 223 + CqlParserRULE_kwLogin = 224 + CqlParserRULE_kwMaterialized = 225 + CqlParserRULE_kwModify = 226 + CqlParserRULE_kwNosuperuser = 227 + CqlParserRULE_kwNorecursive = 228 + CqlParserRULE_kwNot = 229 + CqlParserRULE_kwNull = 230 + CqlParserRULE_kwOf = 231 + CqlParserRULE_kwOn = 232 + CqlParserRULE_kwOptions = 233 + CqlParserRULE_kwOr = 234 + CqlParserRULE_kwOrder = 235 + CqlParserRULE_kwPassword = 236 + CqlParserRULE_kwPrimary = 237 + CqlParserRULE_kwRename = 238 + CqlParserRULE_kwReplace = 239 + CqlParserRULE_kwReplication = 240 + CqlParserRULE_kwReturns = 241 + CqlParserRULE_kwRole = 242 + CqlParserRULE_kwRoles = 243 + CqlParserRULE_kwSelect = 244 + CqlParserRULE_kwSet = 245 + CqlParserRULE_kwSfunc = 246 + CqlParserRULE_kwStorage = 247 + CqlParserRULE_kwStype = 248 + CqlParserRULE_kwSuperuser = 249 + CqlParserRULE_kwTable = 250 + CqlParserRULE_kwTimestamp = 251 + CqlParserRULE_kwTo = 252 + CqlParserRULE_kwTrigger = 253 + CqlParserRULE_kwTruncate = 254 + CqlParserRULE_kwTtl = 255 + CqlParserRULE_kwType = 256 + CqlParserRULE_kwUnlogged = 257 + CqlParserRULE_kwUpdate = 258 + CqlParserRULE_kwUse = 259 + CqlParserRULE_kwUser = 260 + CqlParserRULE_kwUsing = 261 + CqlParserRULE_kwValues = 262 + CqlParserRULE_kwView = 263 + CqlParserRULE_kwWhere = 264 + CqlParserRULE_kwWith = 265 + CqlParserRULE_kwRevoke = 266 + CqlParserRULE_syntaxBracketLr = 267 + CqlParserRULE_syntaxBracketRr = 268 + CqlParserRULE_syntaxBracketLc = 269 + CqlParserRULE_syntaxBracketRc = 270 + CqlParserRULE_syntaxBracketLa = 271 + CqlParserRULE_syntaxBracketRa = 272 + CqlParserRULE_syntaxBracketLs = 273 + CqlParserRULE_syntaxBracketRs = 274 + CqlParserRULE_syntaxComma = 275 + CqlParserRULE_syntaxColon = 276 +) + +// IRootContext is an interface to support dynamic dispatch. +type IRootContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + EOF() antlr.TerminalNode + Cqls() ICqlsContext + MINUSMINUS() antlr.TerminalNode + + // IsRootContext differentiates from other interfaces. + IsRootContext() +} + +type RootContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRootContext() *RootContext { + var p = new(RootContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_root + return p +} + +func InitEmptyRootContext(p *RootContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_root +} + +func (*RootContext) IsRootContext() {} + +func NewRootContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *RootContext { + var p = new(RootContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_root + + return p +} + +func (s *RootContext) GetParser() antlr.Parser { return s.parser } + +func (s *RootContext) EOF() antlr.TerminalNode { + return s.GetToken(CqlParserEOF, 0) +} + +func (s *RootContext) Cqls() ICqlsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICqlsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICqlsContext) +} + +func (s *RootContext) MINUSMINUS() antlr.TerminalNode { + return s.GetToken(CqlParserMINUSMINUS, 0) +} + +func (s *RootContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *RootContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *RootContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterRoot(s) + } +} + +func (s *RootContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitRoot(s) + } +} + +func (s *RootContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitRoot(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) Root() (localctx IRootContext) { + localctx = NewRootContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 0, CqlParserRULE_root) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(555) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64((_la-8)) & ^0x3f) == 0 && ((int64(1)<<(_la-8))&4647719557368119297) != 0) || ((int64((_la-109)) & ^0x3f) == 0 && ((int64(1)<<(_la-109))&35184397516817) != 0) { + { + p.SetState(554) + p.Cqls() + } + + } + p.SetState(558) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == CqlParserMINUSMINUS { + { + p.SetState(557) + p.Match(CqlParserMINUSMINUS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(560) + p.Match(CqlParserEOF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICqlsContext is an interface to support dynamic dispatch. +type ICqlsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllCql() []ICqlContext + Cql(i int) ICqlContext + AllEmpty_() []IEmpty_Context + Empty_(i int) IEmpty_Context + AllStatementSeparator() []IStatementSeparatorContext + StatementSeparator(i int) IStatementSeparatorContext + AllMINUSMINUS() []antlr.TerminalNode + MINUSMINUS(i int) antlr.TerminalNode + + // IsCqlsContext differentiates from other interfaces. + IsCqlsContext() +} + +type CqlsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCqlsContext() *CqlsContext { + var p = new(CqlsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_cqls + return p +} + +func InitEmptyCqlsContext(p *CqlsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_cqls +} + +func (*CqlsContext) IsCqlsContext() {} + +func NewCqlsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CqlsContext { + var p = new(CqlsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_cqls + + return p +} + +func (s *CqlsContext) GetParser() antlr.Parser { return s.parser } + +func (s *CqlsContext) AllCql() []ICqlContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ICqlContext); ok { + len++ + } + } + + tst := make([]ICqlContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ICqlContext); ok { + tst[i] = t.(ICqlContext) + i++ + } + } + + return tst +} + +func (s *CqlsContext) Cql(i int) ICqlContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICqlContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ICqlContext) +} + +func (s *CqlsContext) AllEmpty_() []IEmpty_Context { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IEmpty_Context); ok { + len++ + } + } + + tst := make([]IEmpty_Context, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IEmpty_Context); ok { + tst[i] = t.(IEmpty_Context) + i++ + } + } + + return tst +} + +func (s *CqlsContext) Empty_(i int) IEmpty_Context { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IEmpty_Context); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IEmpty_Context) +} + +func (s *CqlsContext) AllStatementSeparator() []IStatementSeparatorContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IStatementSeparatorContext); ok { + len++ + } + } + + tst := make([]IStatementSeparatorContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IStatementSeparatorContext); ok { + tst[i] = t.(IStatementSeparatorContext) + i++ + } + } + + return tst +} + +func (s *CqlsContext) StatementSeparator(i int) IStatementSeparatorContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStatementSeparatorContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IStatementSeparatorContext) +} + +func (s *CqlsContext) AllMINUSMINUS() []antlr.TerminalNode { + return s.GetTokens(CqlParserMINUSMINUS) +} + +func (s *CqlsContext) MINUSMINUS(i int) antlr.TerminalNode { + return s.GetToken(CqlParserMINUSMINUS, i) +} + +func (s *CqlsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CqlsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *CqlsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterCqls(s) + } +} + +func (s *CqlsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitCqls(s) + } +} + +func (s *CqlsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitCqls(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) Cqls() (localctx ICqlsContext) { + localctx = NewCqlsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2, CqlParserRULE_cqls) + var _la int + + var _alt int + + p.EnterOuterAlt(localctx, 1) + p.SetState(571) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 4, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + p.SetState(569) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case CqlParserK_ALTER, CqlParserK_APPLY, CqlParserK_BEGIN, CqlParserK_CREATE, CqlParserK_DELETE, CqlParserK_DROP, CqlParserK_GRANT, CqlParserK_INSERT, CqlParserK_REVOKE, CqlParserK_SELECT, CqlParserK_TRUNCATE, CqlParserK_UPDATE, CqlParserK_USE, CqlParserK_LIST: + { + p.SetState(562) + p.Cql() + } + p.SetState(564) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == CqlParserMINUSMINUS { + { + p.SetState(563) + p.Match(CqlParserMINUSMINUS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(566) + p.StatementSeparator() + } + + case CqlParserSEMI: + { + p.SetState(568) + p.Empty_() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + } + p.SetState(573) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 4, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + p.SetState(582) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case CqlParserK_ALTER, CqlParserK_APPLY, CqlParserK_BEGIN, CqlParserK_CREATE, CqlParserK_DELETE, CqlParserK_DROP, CqlParserK_GRANT, CqlParserK_INSERT, CqlParserK_REVOKE, CqlParserK_SELECT, CqlParserK_TRUNCATE, CqlParserK_UPDATE, CqlParserK_USE, CqlParserK_LIST: + { + p.SetState(574) + p.Cql() + } + p.SetState(579) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 6, p.GetParserRuleContext()) == 1 { + p.SetState(576) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == CqlParserMINUSMINUS { + { + p.SetState(575) + p.Match(CqlParserMINUSMINUS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(578) + p.StatementSeparator() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case CqlParserSEMI: + { + p.SetState(581) + p.Empty_() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IStatementSeparatorContext is an interface to support dynamic dispatch. +type IStatementSeparatorContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SEMI() antlr.TerminalNode + + // IsStatementSeparatorContext differentiates from other interfaces. + IsStatementSeparatorContext() +} + +type StatementSeparatorContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyStatementSeparatorContext() *StatementSeparatorContext { + var p = new(StatementSeparatorContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_statementSeparator + return p +} + +func InitEmptyStatementSeparatorContext(p *StatementSeparatorContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_statementSeparator +} + +func (*StatementSeparatorContext) IsStatementSeparatorContext() {} + +func NewStatementSeparatorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *StatementSeparatorContext { + var p = new(StatementSeparatorContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_statementSeparator + + return p +} + +func (s *StatementSeparatorContext) GetParser() antlr.Parser { return s.parser } + +func (s *StatementSeparatorContext) SEMI() antlr.TerminalNode { + return s.GetToken(CqlParserSEMI, 0) +} + +func (s *StatementSeparatorContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *StatementSeparatorContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *StatementSeparatorContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterStatementSeparator(s) + } +} + +func (s *StatementSeparatorContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitStatementSeparator(s) + } +} + +func (s *StatementSeparatorContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitStatementSeparator(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) StatementSeparator() (localctx IStatementSeparatorContext) { + localctx = NewStatementSeparatorContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 4, CqlParserRULE_statementSeparator) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(584) + p.Match(CqlParserSEMI) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IEmpty_Context is an interface to support dynamic dispatch. +type IEmpty_Context interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + StatementSeparator() IStatementSeparatorContext + + // IsEmpty_Context differentiates from other interfaces. + IsEmpty_Context() +} + +type Empty_Context struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyEmpty_Context() *Empty_Context { + var p = new(Empty_Context) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_empty_ + return p +} + +func InitEmptyEmpty_Context(p *Empty_Context) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_empty_ +} + +func (*Empty_Context) IsEmpty_Context() {} + +func NewEmpty_Context(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Empty_Context { + var p = new(Empty_Context) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_empty_ + + return p +} + +func (s *Empty_Context) GetParser() antlr.Parser { return s.parser } + +func (s *Empty_Context) StatementSeparator() IStatementSeparatorContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStatementSeparatorContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStatementSeparatorContext) +} + +func (s *Empty_Context) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Empty_Context) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Empty_Context) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterEmpty_(s) + } +} + +func (s *Empty_Context) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitEmpty_(s) + } +} + +func (s *Empty_Context) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitEmpty_(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) Empty_() (localctx IEmpty_Context) { + localctx = NewEmpty_Context(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 6, CqlParserRULE_empty_) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(586) + p.StatementSeparator() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICqlContext is an interface to support dynamic dispatch. +type ICqlContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AlterKeyspace() IAlterKeyspaceContext + AlterMaterializedView() IAlterMaterializedViewContext + AlterRole() IAlterRoleContext + AlterTable() IAlterTableContext + AlterType() IAlterTypeContext + AlterUser() IAlterUserContext + ApplyBatch() IApplyBatchContext + CreateAggregate() ICreateAggregateContext + CreateFunction() ICreateFunctionContext + CreateIndex() ICreateIndexContext + CreateKeyspace() ICreateKeyspaceContext + CreateMaterializedView() ICreateMaterializedViewContext + CreateRole() ICreateRoleContext + CreateTable() ICreateTableContext + CreateTrigger() ICreateTriggerContext + CreateType() ICreateTypeContext + CreateUser() ICreateUserContext + Delete_() IDelete_Context + DropAggregate() IDropAggregateContext + DropFunction() IDropFunctionContext + DropIndex() IDropIndexContext + DropKeyspace() IDropKeyspaceContext + DropMaterializedView() IDropMaterializedViewContext + DropRole() IDropRoleContext + DropTable() IDropTableContext + DropTrigger() IDropTriggerContext + DropType() IDropTypeContext + DropUser() IDropUserContext + Grant() IGrantContext + Insert() IInsertContext + ListPermissions() IListPermissionsContext + ListRoles() IListRolesContext + Revoke() IRevokeContext + Select_() ISelect_Context + Truncate() ITruncateContext + Update() IUpdateContext + Use_() IUse_Context + + // IsCqlContext differentiates from other interfaces. + IsCqlContext() +} + +type CqlContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCqlContext() *CqlContext { + var p = new(CqlContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_cql + return p +} + +func InitEmptyCqlContext(p *CqlContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_cql +} + +func (*CqlContext) IsCqlContext() {} + +func NewCqlContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CqlContext { + var p = new(CqlContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_cql + + return p +} + +func (s *CqlContext) GetParser() antlr.Parser { return s.parser } + +func (s *CqlContext) AlterKeyspace() IAlterKeyspaceContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlterKeyspaceContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlterKeyspaceContext) +} + +func (s *CqlContext) AlterMaterializedView() IAlterMaterializedViewContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlterMaterializedViewContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlterMaterializedViewContext) +} + +func (s *CqlContext) AlterRole() IAlterRoleContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlterRoleContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlterRoleContext) +} + +func (s *CqlContext) AlterTable() IAlterTableContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlterTableContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlterTableContext) +} + +func (s *CqlContext) AlterType() IAlterTypeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlterTypeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlterTypeContext) +} + +func (s *CqlContext) AlterUser() IAlterUserContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlterUserContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlterUserContext) +} + +func (s *CqlContext) ApplyBatch() IApplyBatchContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IApplyBatchContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IApplyBatchContext) +} + +func (s *CqlContext) CreateAggregate() ICreateAggregateContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreateAggregateContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreateAggregateContext) +} + +func (s *CqlContext) CreateFunction() ICreateFunctionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreateFunctionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreateFunctionContext) +} + +func (s *CqlContext) CreateIndex() ICreateIndexContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreateIndexContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreateIndexContext) +} + +func (s *CqlContext) CreateKeyspace() ICreateKeyspaceContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreateKeyspaceContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreateKeyspaceContext) +} + +func (s *CqlContext) CreateMaterializedView() ICreateMaterializedViewContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreateMaterializedViewContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreateMaterializedViewContext) +} + +func (s *CqlContext) CreateRole() ICreateRoleContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreateRoleContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreateRoleContext) +} + +func (s *CqlContext) CreateTable() ICreateTableContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreateTableContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreateTableContext) +} + +func (s *CqlContext) CreateTrigger() ICreateTriggerContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreateTriggerContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreateTriggerContext) +} + +func (s *CqlContext) CreateType() ICreateTypeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreateTypeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreateTypeContext) +} + +func (s *CqlContext) CreateUser() ICreateUserContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreateUserContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreateUserContext) +} + +func (s *CqlContext) Delete_() IDelete_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDelete_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDelete_Context) +} + +func (s *CqlContext) DropAggregate() IDropAggregateContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDropAggregateContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDropAggregateContext) +} + +func (s *CqlContext) DropFunction() IDropFunctionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDropFunctionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDropFunctionContext) +} + +func (s *CqlContext) DropIndex() IDropIndexContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDropIndexContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDropIndexContext) +} + +func (s *CqlContext) DropKeyspace() IDropKeyspaceContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDropKeyspaceContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDropKeyspaceContext) +} + +func (s *CqlContext) DropMaterializedView() IDropMaterializedViewContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDropMaterializedViewContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDropMaterializedViewContext) +} + +func (s *CqlContext) DropRole() IDropRoleContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDropRoleContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDropRoleContext) +} + +func (s *CqlContext) DropTable() IDropTableContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDropTableContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDropTableContext) +} + +func (s *CqlContext) DropTrigger() IDropTriggerContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDropTriggerContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDropTriggerContext) +} + +func (s *CqlContext) DropType() IDropTypeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDropTypeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDropTypeContext) +} + +func (s *CqlContext) DropUser() IDropUserContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDropUserContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDropUserContext) +} + +func (s *CqlContext) Grant() IGrantContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGrantContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGrantContext) +} + +func (s *CqlContext) Insert() IInsertContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IInsertContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IInsertContext) +} + +func (s *CqlContext) ListPermissions() IListPermissionsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IListPermissionsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IListPermissionsContext) +} + +func (s *CqlContext) ListRoles() IListRolesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IListRolesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IListRolesContext) +} + +func (s *CqlContext) Revoke() IRevokeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRevokeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRevokeContext) +} + +func (s *CqlContext) Select_() ISelect_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISelect_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISelect_Context) +} + +func (s *CqlContext) Truncate() ITruncateContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITruncateContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITruncateContext) +} + +func (s *CqlContext) Update() IUpdateContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUpdateContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUpdateContext) +} + +func (s *CqlContext) Use_() IUse_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUse_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUse_Context) +} + +func (s *CqlContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CqlContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *CqlContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterCql(s) + } +} + +func (s *CqlContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitCql(s) + } +} + +func (s *CqlContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitCql(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) Cql() (localctx ICqlContext) { + localctx = NewCqlContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 8, CqlParserRULE_cql) + p.SetState(625) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 8, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(588) + p.AlterKeyspace() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(589) + p.AlterMaterializedView() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(590) + p.AlterRole() + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(591) + p.AlterTable() + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(592) + p.AlterType() + } + + case 6: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(593) + p.AlterUser() + } + + case 7: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(594) + p.ApplyBatch() + } + + case 8: + p.EnterOuterAlt(localctx, 8) + { + p.SetState(595) + p.CreateAggregate() + } + + case 9: + p.EnterOuterAlt(localctx, 9) + { + p.SetState(596) + p.CreateFunction() + } + + case 10: + p.EnterOuterAlt(localctx, 10) + { + p.SetState(597) + p.CreateIndex() + } + + case 11: + p.EnterOuterAlt(localctx, 11) + { + p.SetState(598) + p.CreateKeyspace() + } + + case 12: + p.EnterOuterAlt(localctx, 12) + { + p.SetState(599) + p.CreateMaterializedView() + } + + case 13: + p.EnterOuterAlt(localctx, 13) + { + p.SetState(600) + p.CreateRole() + } + + case 14: + p.EnterOuterAlt(localctx, 14) + { + p.SetState(601) + p.CreateTable() + } + + case 15: + p.EnterOuterAlt(localctx, 15) + { + p.SetState(602) + p.CreateTrigger() + } + + case 16: + p.EnterOuterAlt(localctx, 16) + { + p.SetState(603) + p.CreateType() + } + + case 17: + p.EnterOuterAlt(localctx, 17) + { + p.SetState(604) + p.CreateUser() + } + + case 18: + p.EnterOuterAlt(localctx, 18) + { + p.SetState(605) + p.Delete_() + } + + case 19: + p.EnterOuterAlt(localctx, 19) + { + p.SetState(606) + p.DropAggregate() + } + + case 20: + p.EnterOuterAlt(localctx, 20) + { + p.SetState(607) + p.DropFunction() + } + + case 21: + p.EnterOuterAlt(localctx, 21) + { + p.SetState(608) + p.DropIndex() + } + + case 22: + p.EnterOuterAlt(localctx, 22) + { + p.SetState(609) + p.DropKeyspace() + } + + case 23: + p.EnterOuterAlt(localctx, 23) + { + p.SetState(610) + p.DropMaterializedView() + } + + case 24: + p.EnterOuterAlt(localctx, 24) + { + p.SetState(611) + p.DropRole() + } + + case 25: + p.EnterOuterAlt(localctx, 25) + { + p.SetState(612) + p.DropTable() + } + + case 26: + p.EnterOuterAlt(localctx, 26) + { + p.SetState(613) + p.DropTrigger() + } + + case 27: + p.EnterOuterAlt(localctx, 27) + { + p.SetState(614) + p.DropType() + } + + case 28: + p.EnterOuterAlt(localctx, 28) + { + p.SetState(615) + p.DropUser() + } + + case 29: + p.EnterOuterAlt(localctx, 29) + { + p.SetState(616) + p.Grant() + } + + case 30: + p.EnterOuterAlt(localctx, 30) + { + p.SetState(617) + p.Insert() + } + + case 31: + p.EnterOuterAlt(localctx, 31) + { + p.SetState(618) + p.ListPermissions() + } + + case 32: + p.EnterOuterAlt(localctx, 32) + { + p.SetState(619) + p.ListRoles() + } + + case 33: + p.EnterOuterAlt(localctx, 33) + { + p.SetState(620) + p.Revoke() + } + + case 34: + p.EnterOuterAlt(localctx, 34) + { + p.SetState(621) + p.Select_() + } + + case 35: + p.EnterOuterAlt(localctx, 35) + { + p.SetState(622) + p.Truncate() + } + + case 36: + p.EnterOuterAlt(localctx, 36) + { + p.SetState(623) + p.Update() + } + + case 37: + p.EnterOuterAlt(localctx, 37) + { + p.SetState(624) + p.Use_() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IRevokeContext is an interface to support dynamic dispatch. +type IRevokeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + KwRevoke() IKwRevokeContext + Priviledge() IPriviledgeContext + KwOn() IKwOnContext + Resource() IResourceContext + KwFrom() IKwFromContext + Role() IRoleContext + + // IsRevokeContext differentiates from other interfaces. + IsRevokeContext() +} + +type RevokeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRevokeContext() *RevokeContext { + var p = new(RevokeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_revoke + return p +} + +func InitEmptyRevokeContext(p *RevokeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_revoke +} + +func (*RevokeContext) IsRevokeContext() {} + +func NewRevokeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *RevokeContext { + var p = new(RevokeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_revoke + + return p +} + +func (s *RevokeContext) GetParser() antlr.Parser { return s.parser } + +func (s *RevokeContext) KwRevoke() IKwRevokeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwRevokeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwRevokeContext) +} + +func (s *RevokeContext) Priviledge() IPriviledgeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPriviledgeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPriviledgeContext) +} + +func (s *RevokeContext) KwOn() IKwOnContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwOnContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwOnContext) +} + +func (s *RevokeContext) Resource() IResourceContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IResourceContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IResourceContext) +} + +func (s *RevokeContext) KwFrom() IKwFromContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwFromContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwFromContext) +} + +func (s *RevokeContext) Role() IRoleContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRoleContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRoleContext) +} + +func (s *RevokeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *RevokeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *RevokeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterRevoke(s) + } +} + +func (s *RevokeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitRevoke(s) + } +} + +func (s *RevokeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitRevoke(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) Revoke() (localctx IRevokeContext) { + localctx = NewRevokeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 10, CqlParserRULE_revoke) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(627) + p.KwRevoke() + } + { + p.SetState(628) + p.Priviledge() + } + { + p.SetState(629) + p.KwOn() + } + { + p.SetState(630) + p.Resource() + } + { + p.SetState(631) + p.KwFrom() + } + { + p.SetState(632) + p.Role() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IListRolesContext is an interface to support dynamic dispatch. +type IListRolesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + KwList() IKwListContext + KwRoles() IKwRolesContext + KwOf() IKwOfContext + Role() IRoleContext + KwNorecursive() IKwNorecursiveContext + + // IsListRolesContext differentiates from other interfaces. + IsListRolesContext() +} + +type ListRolesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyListRolesContext() *ListRolesContext { + var p = new(ListRolesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_listRoles + return p +} + +func InitEmptyListRolesContext(p *ListRolesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_listRoles +} + +func (*ListRolesContext) IsListRolesContext() {} + +func NewListRolesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ListRolesContext { + var p = new(ListRolesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_listRoles + + return p +} + +func (s *ListRolesContext) GetParser() antlr.Parser { return s.parser } + +func (s *ListRolesContext) KwList() IKwListContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwListContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwListContext) +} + +func (s *ListRolesContext) KwRoles() IKwRolesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwRolesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwRolesContext) +} + +func (s *ListRolesContext) KwOf() IKwOfContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwOfContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwOfContext) +} + +func (s *ListRolesContext) Role() IRoleContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRoleContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRoleContext) +} + +func (s *ListRolesContext) KwNorecursive() IKwNorecursiveContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwNorecursiveContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwNorecursiveContext) +} + +func (s *ListRolesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ListRolesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ListRolesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterListRoles(s) + } +} + +func (s *ListRolesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitListRoles(s) + } +} + +func (s *ListRolesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitListRoles(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) ListRoles() (localctx IListRolesContext) { + localctx = NewListRolesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 12, CqlParserRULE_listRoles) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(634) + p.KwList() + } + { + p.SetState(635) + p.KwRoles() + } + p.SetState(639) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == CqlParserK_OF { + { + p.SetState(636) + p.KwOf() + } + { + p.SetState(637) + p.Role() + } + + } + p.SetState(642) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == CqlParserK_NORECURSIVE { + { + p.SetState(641) + p.KwNorecursive() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IListPermissionsContext is an interface to support dynamic dispatch. +type IListPermissionsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + KwList() IKwListContext + Priviledge() IPriviledgeContext + KwOn() IKwOnContext + Resource() IResourceContext + KwOf() IKwOfContext + Role() IRoleContext + + // IsListPermissionsContext differentiates from other interfaces. + IsListPermissionsContext() +} + +type ListPermissionsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyListPermissionsContext() *ListPermissionsContext { + var p = new(ListPermissionsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_listPermissions + return p +} + +func InitEmptyListPermissionsContext(p *ListPermissionsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_listPermissions +} + +func (*ListPermissionsContext) IsListPermissionsContext() {} + +func NewListPermissionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ListPermissionsContext { + var p = new(ListPermissionsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_listPermissions + + return p +} + +func (s *ListPermissionsContext) GetParser() antlr.Parser { return s.parser } + +func (s *ListPermissionsContext) KwList() IKwListContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwListContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwListContext) +} + +func (s *ListPermissionsContext) Priviledge() IPriviledgeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPriviledgeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPriviledgeContext) +} + +func (s *ListPermissionsContext) KwOn() IKwOnContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwOnContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwOnContext) +} + +func (s *ListPermissionsContext) Resource() IResourceContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IResourceContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IResourceContext) +} + +func (s *ListPermissionsContext) KwOf() IKwOfContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwOfContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwOfContext) +} + +func (s *ListPermissionsContext) Role() IRoleContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRoleContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRoleContext) +} + +func (s *ListPermissionsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ListPermissionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ListPermissionsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterListPermissions(s) + } +} + +func (s *ListPermissionsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitListPermissions(s) + } +} + +func (s *ListPermissionsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitListPermissions(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) ListPermissions() (localctx IListPermissionsContext) { + localctx = NewListPermissionsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 14, CqlParserRULE_listPermissions) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(644) + p.KwList() + } + { + p.SetState(645) + p.Priviledge() + } + p.SetState(649) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == CqlParserK_ON { + { + p.SetState(646) + p.KwOn() + } + { + p.SetState(647) + p.Resource() + } + + } + p.SetState(654) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == CqlParserK_OF { + { + p.SetState(651) + p.KwOf() + } + { + p.SetState(652) + p.Role() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IGrantContext is an interface to support dynamic dispatch. +type IGrantContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + KwGrant() IKwGrantContext + Priviledge() IPriviledgeContext + KwOn() IKwOnContext + Resource() IResourceContext + KwTo() IKwToContext + Role() IRoleContext + + // IsGrantContext differentiates from other interfaces. + IsGrantContext() +} + +type GrantContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyGrantContext() *GrantContext { + var p = new(GrantContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_grant + return p +} + +func InitEmptyGrantContext(p *GrantContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_grant +} + +func (*GrantContext) IsGrantContext() {} + +func NewGrantContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *GrantContext { + var p = new(GrantContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_grant + + return p +} + +func (s *GrantContext) GetParser() antlr.Parser { return s.parser } + +func (s *GrantContext) KwGrant() IKwGrantContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwGrantContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwGrantContext) +} + +func (s *GrantContext) Priviledge() IPriviledgeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPriviledgeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPriviledgeContext) +} + +func (s *GrantContext) KwOn() IKwOnContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwOnContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwOnContext) +} + +func (s *GrantContext) Resource() IResourceContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IResourceContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IResourceContext) +} + +func (s *GrantContext) KwTo() IKwToContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwToContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwToContext) +} + +func (s *GrantContext) Role() IRoleContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRoleContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRoleContext) +} + +func (s *GrantContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *GrantContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *GrantContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterGrant(s) + } +} + +func (s *GrantContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitGrant(s) + } +} + +func (s *GrantContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitGrant(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) Grant() (localctx IGrantContext) { + localctx = NewGrantContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 16, CqlParserRULE_grant) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(656) + p.KwGrant() + } + { + p.SetState(657) + p.Priviledge() + } + { + p.SetState(658) + p.KwOn() + } + { + p.SetState(659) + p.Resource() + } + { + p.SetState(660) + p.KwTo() + } + { + p.SetState(661) + p.Role() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IPriviledgeContext is an interface to support dynamic dispatch. +type IPriviledgeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + KwAll() IKwAllContext + KwAllPermissions() IKwAllPermissionsContext + KwAlter() IKwAlterContext + KwAuthorize() IKwAuthorizeContext + KwDescibe() IKwDescibeContext + KwExecute() IKwExecuteContext + KwCreate() IKwCreateContext + KwDrop() IKwDropContext + KwModify() IKwModifyContext + KwSelect() IKwSelectContext + + // IsPriviledgeContext differentiates from other interfaces. + IsPriviledgeContext() +} + +type PriviledgeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPriviledgeContext() *PriviledgeContext { + var p = new(PriviledgeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_priviledge + return p +} + +func InitEmptyPriviledgeContext(p *PriviledgeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_priviledge +} + +func (*PriviledgeContext) IsPriviledgeContext() {} + +func NewPriviledgeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PriviledgeContext { + var p = new(PriviledgeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_priviledge + + return p +} + +func (s *PriviledgeContext) GetParser() antlr.Parser { return s.parser } + +func (s *PriviledgeContext) KwAll() IKwAllContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwAllContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwAllContext) +} + +func (s *PriviledgeContext) KwAllPermissions() IKwAllPermissionsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwAllPermissionsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwAllPermissionsContext) +} + +func (s *PriviledgeContext) KwAlter() IKwAlterContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwAlterContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwAlterContext) +} + +func (s *PriviledgeContext) KwAuthorize() IKwAuthorizeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwAuthorizeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwAuthorizeContext) +} + +func (s *PriviledgeContext) KwDescibe() IKwDescibeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwDescibeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwDescibeContext) +} + +func (s *PriviledgeContext) KwExecute() IKwExecuteContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwExecuteContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwExecuteContext) +} + +func (s *PriviledgeContext) KwCreate() IKwCreateContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwCreateContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwCreateContext) +} + +func (s *PriviledgeContext) KwDrop() IKwDropContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwDropContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwDropContext) +} + +func (s *PriviledgeContext) KwModify() IKwModifyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwModifyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwModifyContext) +} + +func (s *PriviledgeContext) KwSelect() IKwSelectContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwSelectContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwSelectContext) +} + +func (s *PriviledgeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *PriviledgeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *PriviledgeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterPriviledge(s) + } +} + +func (s *PriviledgeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitPriviledge(s) + } +} + +func (s *PriviledgeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitPriviledge(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) Priviledge() (localctx IPriviledgeContext) { + localctx = NewPriviledgeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 18, CqlParserRULE_priviledge) + p.SetState(675) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case CqlParserK_ALL: + p.EnterOuterAlt(localctx, 1) + p.SetState(665) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 13, p.GetParserRuleContext()) { + case 1: + { + p.SetState(663) + p.KwAll() + } + + case 2: + { + p.SetState(664) + p.KwAllPermissions() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + case CqlParserK_ALTER: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(667) + p.KwAlter() + } + + case CqlParserK_AUTHORIZE: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(668) + p.KwAuthorize() + } + + case CqlParserK_DESCRIBE: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(669) + p.KwDescibe() + } + + case CqlParserK_EXECUTE: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(670) + p.KwExecute() + } + + case CqlParserK_CREATE: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(671) + p.KwCreate() + } + + case CqlParserK_DROP: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(672) + p.KwDrop() + } + + case CqlParserK_MODIFY: + p.EnterOuterAlt(localctx, 8) + { + p.SetState(673) + p.KwModify() + } + + case CqlParserK_SELECT: + p.EnterOuterAlt(localctx, 9) + { + p.SetState(674) + p.KwSelect() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IResourceContext is an interface to support dynamic dispatch. +type IResourceContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + KwAll() IKwAllContext + KwFunctions() IKwFunctionsContext + KwIn() IKwInContext + KwKeyspace() IKwKeyspaceContext + Keyspace() IKeyspaceContext + KwFunction() IKwFunctionContext + Function_() IFunction_Context + DOT() antlr.TerminalNode + KwKeyspaces() IKwKeyspacesContext + Table() ITableContext + KwTable() IKwTableContext + KwRoles() IKwRolesContext + KwRole() IKwRoleContext + Role() IRoleContext + + // IsResourceContext differentiates from other interfaces. + IsResourceContext() +} + +type ResourceContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyResourceContext() *ResourceContext { + var p = new(ResourceContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_resource + return p +} + +func InitEmptyResourceContext(p *ResourceContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_resource +} + +func (*ResourceContext) IsResourceContext() {} + +func NewResourceContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ResourceContext { + var p = new(ResourceContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_resource + + return p +} + +func (s *ResourceContext) GetParser() antlr.Parser { return s.parser } + +func (s *ResourceContext) KwAll() IKwAllContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwAllContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwAllContext) +} + +func (s *ResourceContext) KwFunctions() IKwFunctionsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwFunctionsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwFunctionsContext) +} + +func (s *ResourceContext) KwIn() IKwInContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwInContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwInContext) +} + +func (s *ResourceContext) KwKeyspace() IKwKeyspaceContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwKeyspaceContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwKeyspaceContext) +} + +func (s *ResourceContext) Keyspace() IKeyspaceContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKeyspaceContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKeyspaceContext) +} + +func (s *ResourceContext) KwFunction() IKwFunctionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwFunctionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwFunctionContext) +} + +func (s *ResourceContext) Function_() IFunction_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunction_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFunction_Context) +} + +func (s *ResourceContext) DOT() antlr.TerminalNode { + return s.GetToken(CqlParserDOT, 0) +} + +func (s *ResourceContext) KwKeyspaces() IKwKeyspacesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwKeyspacesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwKeyspacesContext) +} + +func (s *ResourceContext) Table() ITableContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITableContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITableContext) +} + +func (s *ResourceContext) KwTable() IKwTableContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwTableContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwTableContext) +} + +func (s *ResourceContext) KwRoles() IKwRolesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwRolesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwRolesContext) +} + +func (s *ResourceContext) KwRole() IKwRoleContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwRoleContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwRoleContext) +} + +func (s *ResourceContext) Role() IRoleContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRoleContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRoleContext) +} + +func (s *ResourceContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ResourceContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ResourceContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterResource(s) + } +} + +func (s *ResourceContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitResource(s) + } +} + +func (s *ResourceContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitResource(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) Resource() (localctx IResourceContext) { + localctx = NewResourceContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 20, CqlParserRULE_resource) + var _la int + + p.SetState(715) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 18, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(677) + p.KwAll() + } + { + p.SetState(678) + p.KwFunctions() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(680) + p.KwAll() + } + { + p.SetState(681) + p.KwFunctions() + } + { + p.SetState(682) + p.KwIn() + } + { + p.SetState(683) + p.KwKeyspace() + } + { + p.SetState(684) + p.Keyspace() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(686) + p.KwFunction() + } + p.SetState(690) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 15, p.GetParserRuleContext()) == 1 { + { + p.SetState(687) + p.Keyspace() + } + { + p.SetState(688) + p.Match(CqlParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(692) + p.Function_() + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(694) + p.KwAll() + } + { + p.SetState(695) + p.KwKeyspaces() + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(697) + p.KwKeyspace() + } + { + p.SetState(698) + p.Keyspace() + } + + case 6: + p.EnterOuterAlt(localctx, 6) + p.SetState(701) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == CqlParserK_TABLE { + { + p.SetState(700) + p.KwTable() + } + + } + p.SetState(706) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 17, p.GetParserRuleContext()) == 1 { + { + p.SetState(703) + p.Keyspace() + } + { + p.SetState(704) + p.Match(CqlParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(708) + p.Table() + } + + case 7: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(709) + p.KwAll() + } + { + p.SetState(710) + p.KwRoles() + } + + case 8: + p.EnterOuterAlt(localctx, 8) + { + p.SetState(712) + p.KwRole() + } + { + p.SetState(713) + p.Role() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreateUserContext is an interface to support dynamic dispatch. +type ICreateUserContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + KwCreate() IKwCreateContext + KwUser() IKwUserContext + User() IUserContext + KwWith() IKwWithContext + KwPassword() IKwPasswordContext + StringLiteral() IStringLiteralContext + IfNotExist() IIfNotExistContext + KwSuperuser() IKwSuperuserContext + KwNosuperuser() IKwNosuperuserContext + + // IsCreateUserContext differentiates from other interfaces. + IsCreateUserContext() +} + +type CreateUserContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreateUserContext() *CreateUserContext { + var p = new(CreateUserContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_createUser + return p +} + +func InitEmptyCreateUserContext(p *CreateUserContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_createUser +} + +func (*CreateUserContext) IsCreateUserContext() {} + +func NewCreateUserContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CreateUserContext { + var p = new(CreateUserContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_createUser + + return p +} + +func (s *CreateUserContext) GetParser() antlr.Parser { return s.parser } + +func (s *CreateUserContext) KwCreate() IKwCreateContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwCreateContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwCreateContext) +} + +func (s *CreateUserContext) KwUser() IKwUserContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwUserContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwUserContext) +} + +func (s *CreateUserContext) User() IUserContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUserContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUserContext) +} + +func (s *CreateUserContext) KwWith() IKwWithContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwWithContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwWithContext) +} + +func (s *CreateUserContext) KwPassword() IKwPasswordContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwPasswordContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwPasswordContext) +} + +func (s *CreateUserContext) StringLiteral() IStringLiteralContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStringLiteralContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStringLiteralContext) +} + +func (s *CreateUserContext) IfNotExist() IIfNotExistContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIfNotExistContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIfNotExistContext) +} + +func (s *CreateUserContext) KwSuperuser() IKwSuperuserContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwSuperuserContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwSuperuserContext) +} + +func (s *CreateUserContext) KwNosuperuser() IKwNosuperuserContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwNosuperuserContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwNosuperuserContext) +} + +func (s *CreateUserContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CreateUserContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *CreateUserContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterCreateUser(s) + } +} + +func (s *CreateUserContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitCreateUser(s) + } +} + +func (s *CreateUserContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitCreateUser(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) CreateUser() (localctx ICreateUserContext) { + localctx = NewCreateUserContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 22, CqlParserRULE_createUser) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(717) + p.KwCreate() + } + { + p.SetState(718) + p.KwUser() + } + p.SetState(720) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == CqlParserK_IF { + { + p.SetState(719) + p.IfNotExist() + } + + } + { + p.SetState(722) + p.User() + } + { + p.SetState(723) + p.KwWith() + } + { + p.SetState(724) + p.KwPassword() + } + { + p.SetState(725) + p.StringLiteral() + } + p.SetState(728) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + switch p.GetTokenStream().LA(1) { + case CqlParserK_SUPERUSER: + { + p.SetState(726) + p.KwSuperuser() + } + + case CqlParserK_NOSUPERUSER: + { + p.SetState(727) + p.KwNosuperuser() + } + + case CqlParserEOF, CqlParserSEMI, CqlParserMINUSMINUS: + + default: + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreateRoleContext is an interface to support dynamic dispatch. +type ICreateRoleContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + KwCreate() IKwCreateContext + KwRole() IKwRoleContext + Role() IRoleContext + IfNotExist() IIfNotExistContext + RoleWith() IRoleWithContext + + // IsCreateRoleContext differentiates from other interfaces. + IsCreateRoleContext() +} + +type CreateRoleContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreateRoleContext() *CreateRoleContext { + var p = new(CreateRoleContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_createRole + return p +} + +func InitEmptyCreateRoleContext(p *CreateRoleContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_createRole +} + +func (*CreateRoleContext) IsCreateRoleContext() {} + +func NewCreateRoleContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CreateRoleContext { + var p = new(CreateRoleContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_createRole + + return p +} + +func (s *CreateRoleContext) GetParser() antlr.Parser { return s.parser } + +func (s *CreateRoleContext) KwCreate() IKwCreateContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwCreateContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwCreateContext) +} + +func (s *CreateRoleContext) KwRole() IKwRoleContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwRoleContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwRoleContext) +} + +func (s *CreateRoleContext) Role() IRoleContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRoleContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRoleContext) +} + +func (s *CreateRoleContext) IfNotExist() IIfNotExistContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIfNotExistContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIfNotExistContext) +} + +func (s *CreateRoleContext) RoleWith() IRoleWithContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRoleWithContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRoleWithContext) +} + +func (s *CreateRoleContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CreateRoleContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *CreateRoleContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterCreateRole(s) + } +} + +func (s *CreateRoleContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitCreateRole(s) + } +} + +func (s *CreateRoleContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitCreateRole(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) CreateRole() (localctx ICreateRoleContext) { + localctx = NewCreateRoleContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 24, CqlParserRULE_createRole) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(730) + p.KwCreate() + } + { + p.SetState(731) + p.KwRole() + } + p.SetState(733) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == CqlParserK_IF { + { + p.SetState(732) + p.IfNotExist() + } + + } + { + p.SetState(735) + p.Role() + } + p.SetState(737) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == CqlParserK_WITH { + { + p.SetState(736) + p.RoleWith() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreateTypeContext is an interface to support dynamic dispatch. +type ICreateTypeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + KwCreate() IKwCreateContext + KwType() IKwTypeContext + Type_() IType_Context + SyntaxBracketLr() ISyntaxBracketLrContext + TypeMemberColumnList() ITypeMemberColumnListContext + SyntaxBracketRr() ISyntaxBracketRrContext + IfNotExist() IIfNotExistContext + Keyspace() IKeyspaceContext + DOT() antlr.TerminalNode + + // IsCreateTypeContext differentiates from other interfaces. + IsCreateTypeContext() +} + +type CreateTypeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreateTypeContext() *CreateTypeContext { + var p = new(CreateTypeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_createType + return p +} + +func InitEmptyCreateTypeContext(p *CreateTypeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_createType +} + +func (*CreateTypeContext) IsCreateTypeContext() {} + +func NewCreateTypeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CreateTypeContext { + var p = new(CreateTypeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_createType + + return p +} + +func (s *CreateTypeContext) GetParser() antlr.Parser { return s.parser } + +func (s *CreateTypeContext) KwCreate() IKwCreateContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwCreateContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwCreateContext) +} + +func (s *CreateTypeContext) KwType() IKwTypeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwTypeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwTypeContext) +} + +func (s *CreateTypeContext) Type_() IType_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IType_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IType_Context) +} + +func (s *CreateTypeContext) SyntaxBracketLr() ISyntaxBracketLrContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISyntaxBracketLrContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISyntaxBracketLrContext) +} + +func (s *CreateTypeContext) TypeMemberColumnList() ITypeMemberColumnListContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITypeMemberColumnListContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITypeMemberColumnListContext) +} + +func (s *CreateTypeContext) SyntaxBracketRr() ISyntaxBracketRrContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISyntaxBracketRrContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISyntaxBracketRrContext) +} + +func (s *CreateTypeContext) IfNotExist() IIfNotExistContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIfNotExistContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIfNotExistContext) +} + +func (s *CreateTypeContext) Keyspace() IKeyspaceContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKeyspaceContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKeyspaceContext) +} + +func (s *CreateTypeContext) DOT() antlr.TerminalNode { + return s.GetToken(CqlParserDOT, 0) +} + +func (s *CreateTypeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CreateTypeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *CreateTypeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterCreateType(s) + } +} + +func (s *CreateTypeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitCreateType(s) + } +} + +func (s *CreateTypeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitCreateType(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) CreateType() (localctx ICreateTypeContext) { + localctx = NewCreateTypeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 26, CqlParserRULE_createType) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(739) + p.KwCreate() + } + { + p.SetState(740) + p.KwType() + } + p.SetState(742) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == CqlParserK_IF { + { + p.SetState(741) + p.IfNotExist() + } + + } + p.SetState(747) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 24, p.GetParserRuleContext()) == 1 { + { + p.SetState(744) + p.Keyspace() + } + { + p.SetState(745) + p.Match(CqlParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(749) + p.Type_() + } + { + p.SetState(750) + p.SyntaxBracketLr() + } + { + p.SetState(751) + p.TypeMemberColumnList() + } + { + p.SetState(752) + p.SyntaxBracketRr() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ITypeMemberColumnListContext is an interface to support dynamic dispatch. +type ITypeMemberColumnListContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllColumn() []IColumnContext + Column(i int) IColumnContext + AllDataType() []IDataTypeContext + DataType(i int) IDataTypeContext + AllSyntaxComma() []ISyntaxCommaContext + SyntaxComma(i int) ISyntaxCommaContext + + // IsTypeMemberColumnListContext differentiates from other interfaces. + IsTypeMemberColumnListContext() +} + +type TypeMemberColumnListContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTypeMemberColumnListContext() *TypeMemberColumnListContext { + var p = new(TypeMemberColumnListContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_typeMemberColumnList + return p +} + +func InitEmptyTypeMemberColumnListContext(p *TypeMemberColumnListContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_typeMemberColumnList +} + +func (*TypeMemberColumnListContext) IsTypeMemberColumnListContext() {} + +func NewTypeMemberColumnListContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TypeMemberColumnListContext { + var p = new(TypeMemberColumnListContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_typeMemberColumnList + + return p +} + +func (s *TypeMemberColumnListContext) GetParser() antlr.Parser { return s.parser } + +func (s *TypeMemberColumnListContext) AllColumn() []IColumnContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IColumnContext); ok { + len++ + } + } + + tst := make([]IColumnContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IColumnContext); ok { + tst[i] = t.(IColumnContext) + i++ + } + } + + return tst +} + +func (s *TypeMemberColumnListContext) Column(i int) IColumnContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumnContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IColumnContext) +} + +func (s *TypeMemberColumnListContext) AllDataType() []IDataTypeContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IDataTypeContext); ok { + len++ + } + } + + tst := make([]IDataTypeContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IDataTypeContext); ok { + tst[i] = t.(IDataTypeContext) + i++ + } + } + + return tst +} + +func (s *TypeMemberColumnListContext) DataType(i int) IDataTypeContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDataTypeContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IDataTypeContext) +} + +func (s *TypeMemberColumnListContext) AllSyntaxComma() []ISyntaxCommaContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISyntaxCommaContext); ok { + len++ + } + } + + tst := make([]ISyntaxCommaContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISyntaxCommaContext); ok { + tst[i] = t.(ISyntaxCommaContext) + i++ + } + } + + return tst +} + +func (s *TypeMemberColumnListContext) SyntaxComma(i int) ISyntaxCommaContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISyntaxCommaContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISyntaxCommaContext) +} + +func (s *TypeMemberColumnListContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *TypeMemberColumnListContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *TypeMemberColumnListContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterTypeMemberColumnList(s) + } +} + +func (s *TypeMemberColumnListContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitTypeMemberColumnList(s) + } +} + +func (s *TypeMemberColumnListContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitTypeMemberColumnList(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) TypeMemberColumnList() (localctx ITypeMemberColumnListContext) { + localctx = NewTypeMemberColumnListContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 28, CqlParserRULE_typeMemberColumnList) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(754) + p.Column() + } + { + p.SetState(755) + p.DataType() + } + p.SetState(762) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == CqlParserCOMMA { + { + p.SetState(756) + p.SyntaxComma() + } + { + p.SetState(757) + p.Column() + } + { + p.SetState(758) + p.DataType() + } + + p.SetState(764) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreateTriggerContext is an interface to support dynamic dispatch. +type ICreateTriggerContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + KwCreate() IKwCreateContext + KwTrigger() IKwTriggerContext + Trigger() ITriggerContext + KwUsing() IKwUsingContext + TriggerClass() ITriggerClassContext + IfNotExist() IIfNotExistContext + Keyspace() IKeyspaceContext + DOT() antlr.TerminalNode + + // IsCreateTriggerContext differentiates from other interfaces. + IsCreateTriggerContext() +} + +type CreateTriggerContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreateTriggerContext() *CreateTriggerContext { + var p = new(CreateTriggerContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_createTrigger + return p +} + +func InitEmptyCreateTriggerContext(p *CreateTriggerContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_createTrigger +} + +func (*CreateTriggerContext) IsCreateTriggerContext() {} + +func NewCreateTriggerContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CreateTriggerContext { + var p = new(CreateTriggerContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_createTrigger + + return p +} + +func (s *CreateTriggerContext) GetParser() antlr.Parser { return s.parser } + +func (s *CreateTriggerContext) KwCreate() IKwCreateContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwCreateContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwCreateContext) +} + +func (s *CreateTriggerContext) KwTrigger() IKwTriggerContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwTriggerContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwTriggerContext) +} + +func (s *CreateTriggerContext) Trigger() ITriggerContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITriggerContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITriggerContext) +} + +func (s *CreateTriggerContext) KwUsing() IKwUsingContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwUsingContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwUsingContext) +} + +func (s *CreateTriggerContext) TriggerClass() ITriggerClassContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITriggerClassContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITriggerClassContext) +} + +func (s *CreateTriggerContext) IfNotExist() IIfNotExistContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIfNotExistContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIfNotExistContext) +} + +func (s *CreateTriggerContext) Keyspace() IKeyspaceContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKeyspaceContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKeyspaceContext) +} + +func (s *CreateTriggerContext) DOT() antlr.TerminalNode { + return s.GetToken(CqlParserDOT, 0) +} + +func (s *CreateTriggerContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CreateTriggerContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *CreateTriggerContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterCreateTrigger(s) + } +} + +func (s *CreateTriggerContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitCreateTrigger(s) + } +} + +func (s *CreateTriggerContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitCreateTrigger(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) CreateTrigger() (localctx ICreateTriggerContext) { + localctx = NewCreateTriggerContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 30, CqlParserRULE_createTrigger) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(765) + p.KwCreate() + } + { + p.SetState(766) + p.KwTrigger() + } + p.SetState(768) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == CqlParserK_IF { + { + p.SetState(767) + p.IfNotExist() + } + + } + p.SetState(773) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 27, p.GetParserRuleContext()) == 1 { + { + p.SetState(770) + p.Keyspace() + } + { + p.SetState(771) + p.Match(CqlParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(775) + p.Trigger() + } + { + p.SetState(776) + p.KwUsing() + } + { + p.SetState(777) + p.TriggerClass() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreateMaterializedViewContext is an interface to support dynamic dispatch. +type ICreateMaterializedViewContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + KwCreate() IKwCreateContext + KwMaterialized() IKwMaterializedContext + KwView() IKwViewContext + MaterializedView() IMaterializedViewContext + KwAs() IKwAsContext + KwSelect() IKwSelectContext + AllColumnList() []IColumnListContext + ColumnList(i int) IColumnListContext + KwFrom() IKwFromContext + Table() ITableContext + MaterializedViewWhere() IMaterializedViewWhereContext + KwPrimary() IKwPrimaryContext + KwKey() IKwKeyContext + SyntaxBracketLr() ISyntaxBracketLrContext + SyntaxBracketRr() ISyntaxBracketRrContext + IfNotExist() IIfNotExistContext + AllKeyspace() []IKeyspaceContext + Keyspace(i int) IKeyspaceContext + AllDOT() []antlr.TerminalNode + DOT(i int) antlr.TerminalNode + KwWith() IKwWithContext + MaterializedViewOptions() IMaterializedViewOptionsContext + + // IsCreateMaterializedViewContext differentiates from other interfaces. + IsCreateMaterializedViewContext() +} + +type CreateMaterializedViewContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreateMaterializedViewContext() *CreateMaterializedViewContext { + var p = new(CreateMaterializedViewContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_createMaterializedView + return p +} + +func InitEmptyCreateMaterializedViewContext(p *CreateMaterializedViewContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_createMaterializedView +} + +func (*CreateMaterializedViewContext) IsCreateMaterializedViewContext() {} + +func NewCreateMaterializedViewContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CreateMaterializedViewContext { + var p = new(CreateMaterializedViewContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_createMaterializedView + + return p +} + +func (s *CreateMaterializedViewContext) GetParser() antlr.Parser { return s.parser } + +func (s *CreateMaterializedViewContext) KwCreate() IKwCreateContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwCreateContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwCreateContext) +} + +func (s *CreateMaterializedViewContext) KwMaterialized() IKwMaterializedContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwMaterializedContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwMaterializedContext) +} + +func (s *CreateMaterializedViewContext) KwView() IKwViewContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwViewContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwViewContext) +} + +func (s *CreateMaterializedViewContext) MaterializedView() IMaterializedViewContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMaterializedViewContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMaterializedViewContext) +} + +func (s *CreateMaterializedViewContext) KwAs() IKwAsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwAsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwAsContext) +} + +func (s *CreateMaterializedViewContext) KwSelect() IKwSelectContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwSelectContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwSelectContext) +} + +func (s *CreateMaterializedViewContext) AllColumnList() []IColumnListContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IColumnListContext); ok { + len++ + } + } + + tst := make([]IColumnListContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IColumnListContext); ok { + tst[i] = t.(IColumnListContext) + i++ + } + } + + return tst +} + +func (s *CreateMaterializedViewContext) ColumnList(i int) IColumnListContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumnListContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IColumnListContext) +} + +func (s *CreateMaterializedViewContext) KwFrom() IKwFromContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwFromContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwFromContext) +} + +func (s *CreateMaterializedViewContext) Table() ITableContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITableContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITableContext) +} + +func (s *CreateMaterializedViewContext) MaterializedViewWhere() IMaterializedViewWhereContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMaterializedViewWhereContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMaterializedViewWhereContext) +} + +func (s *CreateMaterializedViewContext) KwPrimary() IKwPrimaryContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwPrimaryContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwPrimaryContext) +} + +func (s *CreateMaterializedViewContext) KwKey() IKwKeyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwKeyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwKeyContext) +} + +func (s *CreateMaterializedViewContext) SyntaxBracketLr() ISyntaxBracketLrContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISyntaxBracketLrContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISyntaxBracketLrContext) +} + +func (s *CreateMaterializedViewContext) SyntaxBracketRr() ISyntaxBracketRrContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISyntaxBracketRrContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISyntaxBracketRrContext) +} + +func (s *CreateMaterializedViewContext) IfNotExist() IIfNotExistContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIfNotExistContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIfNotExistContext) +} + +func (s *CreateMaterializedViewContext) AllKeyspace() []IKeyspaceContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IKeyspaceContext); ok { + len++ + } + } + + tst := make([]IKeyspaceContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IKeyspaceContext); ok { + tst[i] = t.(IKeyspaceContext) + i++ + } + } + + return tst +} + +func (s *CreateMaterializedViewContext) Keyspace(i int) IKeyspaceContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKeyspaceContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IKeyspaceContext) +} + +func (s *CreateMaterializedViewContext) AllDOT() []antlr.TerminalNode { + return s.GetTokens(CqlParserDOT) +} + +func (s *CreateMaterializedViewContext) DOT(i int) antlr.TerminalNode { + return s.GetToken(CqlParserDOT, i) +} + +func (s *CreateMaterializedViewContext) KwWith() IKwWithContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwWithContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwWithContext) +} + +func (s *CreateMaterializedViewContext) MaterializedViewOptions() IMaterializedViewOptionsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMaterializedViewOptionsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMaterializedViewOptionsContext) +} + +func (s *CreateMaterializedViewContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CreateMaterializedViewContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *CreateMaterializedViewContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterCreateMaterializedView(s) + } +} + +func (s *CreateMaterializedViewContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitCreateMaterializedView(s) + } +} + +func (s *CreateMaterializedViewContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitCreateMaterializedView(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) CreateMaterializedView() (localctx ICreateMaterializedViewContext) { + localctx = NewCreateMaterializedViewContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 32, CqlParserRULE_createMaterializedView) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(779) + p.KwCreate() + } + { + p.SetState(780) + p.KwMaterialized() + } + { + p.SetState(781) + p.KwView() + } + p.SetState(783) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == CqlParserK_IF { + { + p.SetState(782) + p.IfNotExist() + } + + } + p.SetState(788) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 29, p.GetParserRuleContext()) == 1 { + { + p.SetState(785) + p.Keyspace() + } + { + p.SetState(786) + p.Match(CqlParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(790) + p.MaterializedView() + } + { + p.SetState(791) + p.KwAs() + } + { + p.SetState(792) + p.KwSelect() + } + { + p.SetState(793) + p.ColumnList() + } + { + p.SetState(794) + p.KwFrom() + } + p.SetState(798) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 30, p.GetParserRuleContext()) == 1 { + { + p.SetState(795) + p.Keyspace() + } + { + p.SetState(796) + p.Match(CqlParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(800) + p.Table() + } + { + p.SetState(801) + p.MaterializedViewWhere() + } + { + p.SetState(802) + p.KwPrimary() + } + { + p.SetState(803) + p.KwKey() + } + { + p.SetState(804) + p.SyntaxBracketLr() + } + { + p.SetState(805) + p.ColumnList() + } + { + p.SetState(806) + p.SyntaxBracketRr() + } + p.SetState(810) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == CqlParserK_WITH { + { + p.SetState(807) + p.KwWith() + } + { + p.SetState(808) + p.MaterializedViewOptions() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IMaterializedViewWhereContext is an interface to support dynamic dispatch. +type IMaterializedViewWhereContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + KwWhere() IKwWhereContext + ColumnNotNullList() IColumnNotNullListContext + KwAnd() IKwAndContext + RelationElements() IRelationElementsContext + + // IsMaterializedViewWhereContext differentiates from other interfaces. + IsMaterializedViewWhereContext() +} + +type MaterializedViewWhereContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyMaterializedViewWhereContext() *MaterializedViewWhereContext { + var p = new(MaterializedViewWhereContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_materializedViewWhere + return p +} + +func InitEmptyMaterializedViewWhereContext(p *MaterializedViewWhereContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_materializedViewWhere +} + +func (*MaterializedViewWhereContext) IsMaterializedViewWhereContext() {} + +func NewMaterializedViewWhereContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *MaterializedViewWhereContext { + var p = new(MaterializedViewWhereContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_materializedViewWhere + + return p +} + +func (s *MaterializedViewWhereContext) GetParser() antlr.Parser { return s.parser } + +func (s *MaterializedViewWhereContext) KwWhere() IKwWhereContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwWhereContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwWhereContext) +} + +func (s *MaterializedViewWhereContext) ColumnNotNullList() IColumnNotNullListContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumnNotNullListContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumnNotNullListContext) +} + +func (s *MaterializedViewWhereContext) KwAnd() IKwAndContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwAndContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwAndContext) +} + +func (s *MaterializedViewWhereContext) RelationElements() IRelationElementsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRelationElementsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRelationElementsContext) +} + +func (s *MaterializedViewWhereContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *MaterializedViewWhereContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *MaterializedViewWhereContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterMaterializedViewWhere(s) + } +} + +func (s *MaterializedViewWhereContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitMaterializedViewWhere(s) + } +} + +func (s *MaterializedViewWhereContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitMaterializedViewWhere(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) MaterializedViewWhere() (localctx IMaterializedViewWhereContext) { + localctx = NewMaterializedViewWhereContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 34, CqlParserRULE_materializedViewWhere) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(812) + p.KwWhere() + } + { + p.SetState(813) + p.ColumnNotNullList() + } + p.SetState(817) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == CqlParserK_AND { + { + p.SetState(814) + p.KwAnd() + } + { + p.SetState(815) + p.RelationElements() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IColumnNotNullListContext is an interface to support dynamic dispatch. +type IColumnNotNullListContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllColumnNotNull() []IColumnNotNullContext + ColumnNotNull(i int) IColumnNotNullContext + AllKwAnd() []IKwAndContext + KwAnd(i int) IKwAndContext + + // IsColumnNotNullListContext differentiates from other interfaces. + IsColumnNotNullListContext() +} + +type ColumnNotNullListContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyColumnNotNullListContext() *ColumnNotNullListContext { + var p = new(ColumnNotNullListContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_columnNotNullList + return p +} + +func InitEmptyColumnNotNullListContext(p *ColumnNotNullListContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_columnNotNullList +} + +func (*ColumnNotNullListContext) IsColumnNotNullListContext() {} + +func NewColumnNotNullListContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ColumnNotNullListContext { + var p = new(ColumnNotNullListContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_columnNotNullList + + return p +} + +func (s *ColumnNotNullListContext) GetParser() antlr.Parser { return s.parser } + +func (s *ColumnNotNullListContext) AllColumnNotNull() []IColumnNotNullContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IColumnNotNullContext); ok { + len++ + } + } + + tst := make([]IColumnNotNullContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IColumnNotNullContext); ok { + tst[i] = t.(IColumnNotNullContext) + i++ + } + } + + return tst +} + +func (s *ColumnNotNullListContext) ColumnNotNull(i int) IColumnNotNullContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumnNotNullContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IColumnNotNullContext) +} + +func (s *ColumnNotNullListContext) AllKwAnd() []IKwAndContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IKwAndContext); ok { + len++ + } + } + + tst := make([]IKwAndContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IKwAndContext); ok { + tst[i] = t.(IKwAndContext) + i++ + } + } + + return tst +} + +func (s *ColumnNotNullListContext) KwAnd(i int) IKwAndContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwAndContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IKwAndContext) +} + +func (s *ColumnNotNullListContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ColumnNotNullListContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ColumnNotNullListContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterColumnNotNullList(s) + } +} + +func (s *ColumnNotNullListContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitColumnNotNullList(s) + } +} + +func (s *ColumnNotNullListContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitColumnNotNullList(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) ColumnNotNullList() (localctx IColumnNotNullListContext) { + localctx = NewColumnNotNullListContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 36, CqlParserRULE_columnNotNullList) + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(819) + p.ColumnNotNull() + } + p.SetState(825) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 33, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(820) + p.KwAnd() + } + { + p.SetState(821) + p.ColumnNotNull() + } + + } + p.SetState(827) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 33, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IColumnNotNullContext is an interface to support dynamic dispatch. +type IColumnNotNullContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Column() IColumnContext + KwIs() IKwIsContext + KwNot() IKwNotContext + KwNull() IKwNullContext + + // IsColumnNotNullContext differentiates from other interfaces. + IsColumnNotNullContext() +} + +type ColumnNotNullContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyColumnNotNullContext() *ColumnNotNullContext { + var p = new(ColumnNotNullContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_columnNotNull + return p +} + +func InitEmptyColumnNotNullContext(p *ColumnNotNullContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_columnNotNull +} + +func (*ColumnNotNullContext) IsColumnNotNullContext() {} + +func NewColumnNotNullContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ColumnNotNullContext { + var p = new(ColumnNotNullContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_columnNotNull + + return p +} + +func (s *ColumnNotNullContext) GetParser() antlr.Parser { return s.parser } + +func (s *ColumnNotNullContext) Column() IColumnContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumnContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumnContext) +} + +func (s *ColumnNotNullContext) KwIs() IKwIsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwIsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwIsContext) +} + +func (s *ColumnNotNullContext) KwNot() IKwNotContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwNotContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwNotContext) +} + +func (s *ColumnNotNullContext) KwNull() IKwNullContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwNullContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwNullContext) +} + +func (s *ColumnNotNullContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ColumnNotNullContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ColumnNotNullContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterColumnNotNull(s) + } +} + +func (s *ColumnNotNullContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitColumnNotNull(s) + } +} + +func (s *ColumnNotNullContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitColumnNotNull(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) ColumnNotNull() (localctx IColumnNotNullContext) { + localctx = NewColumnNotNullContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 38, CqlParserRULE_columnNotNull) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(828) + p.Column() + } + { + p.SetState(829) + p.KwIs() + } + { + p.SetState(830) + p.KwNot() + } + { + p.SetState(831) + p.KwNull() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IMaterializedViewOptionsContext is an interface to support dynamic dispatch. +type IMaterializedViewOptionsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + TableOptions() ITableOptionsContext + KwAnd() IKwAndContext + ClusteringOrder() IClusteringOrderContext + + // IsMaterializedViewOptionsContext differentiates from other interfaces. + IsMaterializedViewOptionsContext() +} + +type MaterializedViewOptionsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyMaterializedViewOptionsContext() *MaterializedViewOptionsContext { + var p = new(MaterializedViewOptionsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_materializedViewOptions + return p +} + +func InitEmptyMaterializedViewOptionsContext(p *MaterializedViewOptionsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_materializedViewOptions +} + +func (*MaterializedViewOptionsContext) IsMaterializedViewOptionsContext() {} + +func NewMaterializedViewOptionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *MaterializedViewOptionsContext { + var p = new(MaterializedViewOptionsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_materializedViewOptions + + return p +} + +func (s *MaterializedViewOptionsContext) GetParser() antlr.Parser { return s.parser } + +func (s *MaterializedViewOptionsContext) TableOptions() ITableOptionsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITableOptionsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITableOptionsContext) +} + +func (s *MaterializedViewOptionsContext) KwAnd() IKwAndContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwAndContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwAndContext) +} + +func (s *MaterializedViewOptionsContext) ClusteringOrder() IClusteringOrderContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IClusteringOrderContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IClusteringOrderContext) +} + +func (s *MaterializedViewOptionsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *MaterializedViewOptionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *MaterializedViewOptionsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterMaterializedViewOptions(s) + } +} + +func (s *MaterializedViewOptionsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitMaterializedViewOptions(s) + } +} + +func (s *MaterializedViewOptionsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitMaterializedViewOptions(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) MaterializedViewOptions() (localctx IMaterializedViewOptionsContext) { + localctx = NewMaterializedViewOptionsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 40, CqlParserRULE_materializedViewOptions) + p.SetState(839) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 34, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(833) + p.TableOptions() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(834) + p.TableOptions() + } + { + p.SetState(835) + p.KwAnd() + } + { + p.SetState(836) + p.ClusteringOrder() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(838) + p.ClusteringOrder() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreateKeyspaceContext is an interface to support dynamic dispatch. +type ICreateKeyspaceContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + KwCreate() IKwCreateContext + KwKeyspace() IKwKeyspaceContext + Keyspace() IKeyspaceContext + KwWith() IKwWithContext + KwReplication() IKwReplicationContext + OPERATOR_EQ() antlr.TerminalNode + SyntaxBracketLc() ISyntaxBracketLcContext + ReplicationList() IReplicationListContext + SyntaxBracketRc() ISyntaxBracketRcContext + IfNotExist() IIfNotExistContext + KwAnd() IKwAndContext + DurableWrites() IDurableWritesContext + + // IsCreateKeyspaceContext differentiates from other interfaces. + IsCreateKeyspaceContext() +} + +type CreateKeyspaceContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreateKeyspaceContext() *CreateKeyspaceContext { + var p = new(CreateKeyspaceContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_createKeyspace + return p +} + +func InitEmptyCreateKeyspaceContext(p *CreateKeyspaceContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_createKeyspace +} + +func (*CreateKeyspaceContext) IsCreateKeyspaceContext() {} + +func NewCreateKeyspaceContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CreateKeyspaceContext { + var p = new(CreateKeyspaceContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_createKeyspace + + return p +} + +func (s *CreateKeyspaceContext) GetParser() antlr.Parser { return s.parser } + +func (s *CreateKeyspaceContext) KwCreate() IKwCreateContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwCreateContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwCreateContext) +} + +func (s *CreateKeyspaceContext) KwKeyspace() IKwKeyspaceContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwKeyspaceContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwKeyspaceContext) +} + +func (s *CreateKeyspaceContext) Keyspace() IKeyspaceContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKeyspaceContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKeyspaceContext) +} + +func (s *CreateKeyspaceContext) KwWith() IKwWithContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwWithContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwWithContext) +} + +func (s *CreateKeyspaceContext) KwReplication() IKwReplicationContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwReplicationContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwReplicationContext) +} + +func (s *CreateKeyspaceContext) OPERATOR_EQ() antlr.TerminalNode { + return s.GetToken(CqlParserOPERATOR_EQ, 0) +} + +func (s *CreateKeyspaceContext) SyntaxBracketLc() ISyntaxBracketLcContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISyntaxBracketLcContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISyntaxBracketLcContext) +} + +func (s *CreateKeyspaceContext) ReplicationList() IReplicationListContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IReplicationListContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IReplicationListContext) +} + +func (s *CreateKeyspaceContext) SyntaxBracketRc() ISyntaxBracketRcContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISyntaxBracketRcContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISyntaxBracketRcContext) +} + +func (s *CreateKeyspaceContext) IfNotExist() IIfNotExistContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIfNotExistContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIfNotExistContext) +} + +func (s *CreateKeyspaceContext) KwAnd() IKwAndContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwAndContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwAndContext) +} + +func (s *CreateKeyspaceContext) DurableWrites() IDurableWritesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDurableWritesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDurableWritesContext) +} + +func (s *CreateKeyspaceContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CreateKeyspaceContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *CreateKeyspaceContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterCreateKeyspace(s) + } +} + +func (s *CreateKeyspaceContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitCreateKeyspace(s) + } +} + +func (s *CreateKeyspaceContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitCreateKeyspace(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) CreateKeyspace() (localctx ICreateKeyspaceContext) { + localctx = NewCreateKeyspaceContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 42, CqlParserRULE_createKeyspace) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(841) + p.KwCreate() + } + { + p.SetState(842) + p.KwKeyspace() + } + p.SetState(844) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == CqlParserK_IF { + { + p.SetState(843) + p.IfNotExist() + } + + } + { + p.SetState(846) + p.Keyspace() + } + { + p.SetState(847) + p.KwWith() + } + { + p.SetState(848) + p.KwReplication() + } + { + p.SetState(849) + p.Match(CqlParserOPERATOR_EQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(850) + p.SyntaxBracketLc() + } + { + p.SetState(851) + p.ReplicationList() + } + { + p.SetState(852) + p.SyntaxBracketRc() + } + p.SetState(856) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == CqlParserK_AND { + { + p.SetState(853) + p.KwAnd() + } + { + p.SetState(854) + p.DurableWrites() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreateFunctionContext is an interface to support dynamic dispatch. +type ICreateFunctionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + KwCreate() IKwCreateContext + KwFunction() IKwFunctionContext + Function_() IFunction_Context + SyntaxBracketLr() ISyntaxBracketLrContext + SyntaxBracketRr() ISyntaxBracketRrContext + ReturnMode() IReturnModeContext + KwReturns() IKwReturnsContext + DataType() IDataTypeContext + KwLanguage() IKwLanguageContext + Language() ILanguageContext + KwAs() IKwAsContext + CodeBlock() ICodeBlockContext + OrReplace() IOrReplaceContext + IfNotExist() IIfNotExistContext + Keyspace() IKeyspaceContext + DOT() antlr.TerminalNode + ParamList() IParamListContext + + // IsCreateFunctionContext differentiates from other interfaces. + IsCreateFunctionContext() +} + +type CreateFunctionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreateFunctionContext() *CreateFunctionContext { + var p = new(CreateFunctionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_createFunction + return p +} + +func InitEmptyCreateFunctionContext(p *CreateFunctionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_createFunction +} + +func (*CreateFunctionContext) IsCreateFunctionContext() {} + +func NewCreateFunctionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CreateFunctionContext { + var p = new(CreateFunctionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_createFunction + + return p +} + +func (s *CreateFunctionContext) GetParser() antlr.Parser { return s.parser } + +func (s *CreateFunctionContext) KwCreate() IKwCreateContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwCreateContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwCreateContext) +} + +func (s *CreateFunctionContext) KwFunction() IKwFunctionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwFunctionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwFunctionContext) +} + +func (s *CreateFunctionContext) Function_() IFunction_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunction_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFunction_Context) +} + +func (s *CreateFunctionContext) SyntaxBracketLr() ISyntaxBracketLrContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISyntaxBracketLrContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISyntaxBracketLrContext) +} + +func (s *CreateFunctionContext) SyntaxBracketRr() ISyntaxBracketRrContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISyntaxBracketRrContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISyntaxBracketRrContext) +} + +func (s *CreateFunctionContext) ReturnMode() IReturnModeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IReturnModeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IReturnModeContext) +} + +func (s *CreateFunctionContext) KwReturns() IKwReturnsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwReturnsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwReturnsContext) +} + +func (s *CreateFunctionContext) DataType() IDataTypeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDataTypeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDataTypeContext) +} + +func (s *CreateFunctionContext) KwLanguage() IKwLanguageContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwLanguageContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwLanguageContext) +} + +func (s *CreateFunctionContext) Language() ILanguageContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILanguageContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILanguageContext) +} + +func (s *CreateFunctionContext) KwAs() IKwAsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwAsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwAsContext) +} + +func (s *CreateFunctionContext) CodeBlock() ICodeBlockContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICodeBlockContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICodeBlockContext) +} + +func (s *CreateFunctionContext) OrReplace() IOrReplaceContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOrReplaceContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOrReplaceContext) +} + +func (s *CreateFunctionContext) IfNotExist() IIfNotExistContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIfNotExistContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIfNotExistContext) +} + +func (s *CreateFunctionContext) Keyspace() IKeyspaceContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKeyspaceContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKeyspaceContext) +} + +func (s *CreateFunctionContext) DOT() antlr.TerminalNode { + return s.GetToken(CqlParserDOT, 0) +} + +func (s *CreateFunctionContext) ParamList() IParamListContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IParamListContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IParamListContext) +} + +func (s *CreateFunctionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CreateFunctionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *CreateFunctionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterCreateFunction(s) + } +} + +func (s *CreateFunctionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitCreateFunction(s) + } +} + +func (s *CreateFunctionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitCreateFunction(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) CreateFunction() (localctx ICreateFunctionContext) { + localctx = NewCreateFunctionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 44, CqlParserRULE_createFunction) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(858) + p.KwCreate() + } + p.SetState(860) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == CqlParserK_OR { + { + p.SetState(859) + p.OrReplace() + } + + } + { + p.SetState(862) + p.KwFunction() + } + p.SetState(864) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == CqlParserK_IF { + { + p.SetState(863) + p.IfNotExist() + } + + } + p.SetState(869) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 39, p.GetParserRuleContext()) == 1 { + { + p.SetState(866) + p.Keyspace() + } + { + p.SetState(867) + p.Match(CqlParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(871) + p.Function_() + } + { + p.SetState(872) + p.SyntaxBracketLr() + } + p.SetState(874) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == CqlParserK_INPUT || _la == CqlParserOBJECT_NAME { + { + p.SetState(873) + p.ParamList() + } + + } + { + p.SetState(876) + p.SyntaxBracketRr() + } + { + p.SetState(877) + p.ReturnMode() + } + { + p.SetState(878) + p.KwReturns() + } + { + p.SetState(879) + p.DataType() + } + { + p.SetState(880) + p.KwLanguage() + } + { + p.SetState(881) + p.Language() + } + { + p.SetState(882) + p.KwAs() + } + { + p.SetState(883) + p.CodeBlock() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICodeBlockContext is an interface to support dynamic dispatch. +type ICodeBlockContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CODE_BLOCK() antlr.TerminalNode + STRING_LITERAL() antlr.TerminalNode + + // IsCodeBlockContext differentiates from other interfaces. + IsCodeBlockContext() +} + +type CodeBlockContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCodeBlockContext() *CodeBlockContext { + var p = new(CodeBlockContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_codeBlock + return p +} + +func InitEmptyCodeBlockContext(p *CodeBlockContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_codeBlock +} + +func (*CodeBlockContext) IsCodeBlockContext() {} + +func NewCodeBlockContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CodeBlockContext { + var p = new(CodeBlockContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_codeBlock + + return p +} + +func (s *CodeBlockContext) GetParser() antlr.Parser { return s.parser } + +func (s *CodeBlockContext) CODE_BLOCK() antlr.TerminalNode { + return s.GetToken(CqlParserCODE_BLOCK, 0) +} + +func (s *CodeBlockContext) STRING_LITERAL() antlr.TerminalNode { + return s.GetToken(CqlParserSTRING_LITERAL, 0) +} + +func (s *CodeBlockContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CodeBlockContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *CodeBlockContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterCodeBlock(s) + } +} + +func (s *CodeBlockContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitCodeBlock(s) + } +} + +func (s *CodeBlockContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitCodeBlock(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) CodeBlock() (localctx ICodeBlockContext) { + localctx = NewCodeBlockContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 46, CqlParserRULE_codeBlock) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(885) + _la = p.GetTokenStream().LA(1) + + if !(_la == CqlParserCODE_BLOCK || _la == CqlParserSTRING_LITERAL) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IParamListContext is an interface to support dynamic dispatch. +type IParamListContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllParam() []IParamContext + Param(i int) IParamContext + AllSyntaxComma() []ISyntaxCommaContext + SyntaxComma(i int) ISyntaxCommaContext + + // IsParamListContext differentiates from other interfaces. + IsParamListContext() +} + +type ParamListContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyParamListContext() *ParamListContext { + var p = new(ParamListContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_paramList + return p +} + +func InitEmptyParamListContext(p *ParamListContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_paramList +} + +func (*ParamListContext) IsParamListContext() {} + +func NewParamListContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ParamListContext { + var p = new(ParamListContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_paramList + + return p +} + +func (s *ParamListContext) GetParser() antlr.Parser { return s.parser } + +func (s *ParamListContext) AllParam() []IParamContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IParamContext); ok { + len++ + } + } + + tst := make([]IParamContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IParamContext); ok { + tst[i] = t.(IParamContext) + i++ + } + } + + return tst +} + +func (s *ParamListContext) Param(i int) IParamContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IParamContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IParamContext) +} + +func (s *ParamListContext) AllSyntaxComma() []ISyntaxCommaContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISyntaxCommaContext); ok { + len++ + } + } + + tst := make([]ISyntaxCommaContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISyntaxCommaContext); ok { + tst[i] = t.(ISyntaxCommaContext) + i++ + } + } + + return tst +} + +func (s *ParamListContext) SyntaxComma(i int) ISyntaxCommaContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISyntaxCommaContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISyntaxCommaContext) +} + +func (s *ParamListContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ParamListContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ParamListContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterParamList(s) + } +} + +func (s *ParamListContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitParamList(s) + } +} + +func (s *ParamListContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitParamList(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) ParamList() (localctx IParamListContext) { + localctx = NewParamListContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 48, CqlParserRULE_paramList) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(887) + p.Param() + } + p.SetState(893) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == CqlParserCOMMA { + { + p.SetState(888) + p.SyntaxComma() + } + { + p.SetState(889) + p.Param() + } + + p.SetState(895) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IReturnModeContext is an interface to support dynamic dispatch. +type IReturnModeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + KwOn() IKwOnContext + AllKwNull() []IKwNullContext + KwNull(i int) IKwNullContext + KwInput() IKwInputContext + KwCalled() IKwCalledContext + KwReturns() IKwReturnsContext + + // IsReturnModeContext differentiates from other interfaces. + IsReturnModeContext() +} + +type ReturnModeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyReturnModeContext() *ReturnModeContext { + var p = new(ReturnModeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_returnMode + return p +} + +func InitEmptyReturnModeContext(p *ReturnModeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_returnMode +} + +func (*ReturnModeContext) IsReturnModeContext() {} + +func NewReturnModeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ReturnModeContext { + var p = new(ReturnModeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_returnMode + + return p +} + +func (s *ReturnModeContext) GetParser() antlr.Parser { return s.parser } + +func (s *ReturnModeContext) KwOn() IKwOnContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwOnContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwOnContext) +} + +func (s *ReturnModeContext) AllKwNull() []IKwNullContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IKwNullContext); ok { + len++ + } + } + + tst := make([]IKwNullContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IKwNullContext); ok { + tst[i] = t.(IKwNullContext) + i++ + } + } + + return tst +} + +func (s *ReturnModeContext) KwNull(i int) IKwNullContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwNullContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IKwNullContext) +} + +func (s *ReturnModeContext) KwInput() IKwInputContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwInputContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwInputContext) +} + +func (s *ReturnModeContext) KwCalled() IKwCalledContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwCalledContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwCalledContext) +} + +func (s *ReturnModeContext) KwReturns() IKwReturnsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwReturnsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwReturnsContext) +} + +func (s *ReturnModeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ReturnModeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ReturnModeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterReturnMode(s) + } +} + +func (s *ReturnModeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitReturnMode(s) + } +} + +func (s *ReturnModeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitReturnMode(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) ReturnMode() (localctx IReturnModeContext) { + localctx = NewReturnModeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 50, CqlParserRULE_returnMode) + p.EnterOuterAlt(localctx, 1) + p.SetState(900) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case CqlParserK_CALLED: + { + p.SetState(896) + p.KwCalled() + } + + case CqlParserK_RETURNS: + { + p.SetState(897) + p.KwReturns() + } + { + p.SetState(898) + p.KwNull() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + { + p.SetState(902) + p.KwOn() + } + { + p.SetState(903) + p.KwNull() + } + { + p.SetState(904) + p.KwInput() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreateAggregateContext is an interface to support dynamic dispatch. +type ICreateAggregateContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + KwCreate() IKwCreateContext + KwAggregate() IKwAggregateContext + Aggregate() IAggregateContext + SyntaxBracketLr() ISyntaxBracketLrContext + AllDataType() []IDataTypeContext + DataType(i int) IDataTypeContext + SyntaxBracketRr() ISyntaxBracketRrContext + KwSfunc() IKwSfuncContext + AllFunction_() []IFunction_Context + Function_(i int) IFunction_Context + KwStype() IKwStypeContext + KwFinalfunc() IKwFinalfuncContext + KwInitcond() IKwInitcondContext + InitCondDefinition() IInitCondDefinitionContext + OrReplace() IOrReplaceContext + IfNotExist() IIfNotExistContext + Keyspace() IKeyspaceContext + DOT() antlr.TerminalNode + + // IsCreateAggregateContext differentiates from other interfaces. + IsCreateAggregateContext() +} + +type CreateAggregateContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreateAggregateContext() *CreateAggregateContext { + var p = new(CreateAggregateContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_createAggregate + return p +} + +func InitEmptyCreateAggregateContext(p *CreateAggregateContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_createAggregate +} + +func (*CreateAggregateContext) IsCreateAggregateContext() {} + +func NewCreateAggregateContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CreateAggregateContext { + var p = new(CreateAggregateContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_createAggregate + + return p +} + +func (s *CreateAggregateContext) GetParser() antlr.Parser { return s.parser } + +func (s *CreateAggregateContext) KwCreate() IKwCreateContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwCreateContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwCreateContext) +} + +func (s *CreateAggregateContext) KwAggregate() IKwAggregateContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwAggregateContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwAggregateContext) +} + +func (s *CreateAggregateContext) Aggregate() IAggregateContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAggregateContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAggregateContext) +} + +func (s *CreateAggregateContext) SyntaxBracketLr() ISyntaxBracketLrContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISyntaxBracketLrContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISyntaxBracketLrContext) +} + +func (s *CreateAggregateContext) AllDataType() []IDataTypeContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IDataTypeContext); ok { + len++ + } + } + + tst := make([]IDataTypeContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IDataTypeContext); ok { + tst[i] = t.(IDataTypeContext) + i++ + } + } + + return tst +} + +func (s *CreateAggregateContext) DataType(i int) IDataTypeContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDataTypeContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IDataTypeContext) +} + +func (s *CreateAggregateContext) SyntaxBracketRr() ISyntaxBracketRrContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISyntaxBracketRrContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISyntaxBracketRrContext) +} + +func (s *CreateAggregateContext) KwSfunc() IKwSfuncContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwSfuncContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwSfuncContext) +} + +func (s *CreateAggregateContext) AllFunction_() []IFunction_Context { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IFunction_Context); ok { + len++ + } + } + + tst := make([]IFunction_Context, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IFunction_Context); ok { + tst[i] = t.(IFunction_Context) + i++ + } + } + + return tst +} + +func (s *CreateAggregateContext) Function_(i int) IFunction_Context { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunction_Context); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IFunction_Context) +} + +func (s *CreateAggregateContext) KwStype() IKwStypeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwStypeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwStypeContext) +} + +func (s *CreateAggregateContext) KwFinalfunc() IKwFinalfuncContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwFinalfuncContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwFinalfuncContext) +} + +func (s *CreateAggregateContext) KwInitcond() IKwInitcondContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwInitcondContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwInitcondContext) +} + +func (s *CreateAggregateContext) InitCondDefinition() IInitCondDefinitionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IInitCondDefinitionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IInitCondDefinitionContext) +} + +func (s *CreateAggregateContext) OrReplace() IOrReplaceContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOrReplaceContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOrReplaceContext) +} + +func (s *CreateAggregateContext) IfNotExist() IIfNotExistContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIfNotExistContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIfNotExistContext) +} + +func (s *CreateAggregateContext) Keyspace() IKeyspaceContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKeyspaceContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKeyspaceContext) +} + +func (s *CreateAggregateContext) DOT() antlr.TerminalNode { + return s.GetToken(CqlParserDOT, 0) +} + +func (s *CreateAggregateContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CreateAggregateContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *CreateAggregateContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterCreateAggregate(s) + } +} + +func (s *CreateAggregateContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitCreateAggregate(s) + } +} + +func (s *CreateAggregateContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitCreateAggregate(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) CreateAggregate() (localctx ICreateAggregateContext) { + localctx = NewCreateAggregateContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 52, CqlParserRULE_createAggregate) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(906) + p.KwCreate() + } + p.SetState(908) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == CqlParserK_OR { + { + p.SetState(907) + p.OrReplace() + } + + } + { + p.SetState(910) + p.KwAggregate() + } + p.SetState(912) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == CqlParserK_IF { + { + p.SetState(911) + p.IfNotExist() + } + + } + p.SetState(917) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 45, p.GetParserRuleContext()) == 1 { + { + p.SetState(914) + p.Keyspace() + } + { + p.SetState(915) + p.Match(CqlParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(919) + p.Aggregate() + } + { + p.SetState(920) + p.SyntaxBracketLr() + } + { + p.SetState(921) + p.DataType() + } + { + p.SetState(922) + p.SyntaxBracketRr() + } + { + p.SetState(923) + p.KwSfunc() + } + { + p.SetState(924) + p.Function_() + } + { + p.SetState(925) + p.KwStype() + } + { + p.SetState(926) + p.DataType() + } + { + p.SetState(927) + p.KwFinalfunc() + } + { + p.SetState(928) + p.Function_() + } + { + p.SetState(929) + p.KwInitcond() + } + { + p.SetState(930) + p.InitCondDefinition() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IInitCondDefinitionContext is an interface to support dynamic dispatch. +type IInitCondDefinitionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Constant() IConstantContext + InitCondList() IInitCondListContext + InitCondListNested() IInitCondListNestedContext + InitCondHash() IInitCondHashContext + + // IsInitCondDefinitionContext differentiates from other interfaces. + IsInitCondDefinitionContext() +} + +type InitCondDefinitionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyInitCondDefinitionContext() *InitCondDefinitionContext { + var p = new(InitCondDefinitionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_initCondDefinition + return p +} + +func InitEmptyInitCondDefinitionContext(p *InitCondDefinitionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_initCondDefinition +} + +func (*InitCondDefinitionContext) IsInitCondDefinitionContext() {} + +func NewInitCondDefinitionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *InitCondDefinitionContext { + var p = new(InitCondDefinitionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_initCondDefinition + + return p +} + +func (s *InitCondDefinitionContext) GetParser() antlr.Parser { return s.parser } + +func (s *InitCondDefinitionContext) Constant() IConstantContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConstantContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IConstantContext) +} + +func (s *InitCondDefinitionContext) InitCondList() IInitCondListContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IInitCondListContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IInitCondListContext) +} + +func (s *InitCondDefinitionContext) InitCondListNested() IInitCondListNestedContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IInitCondListNestedContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IInitCondListNestedContext) +} + +func (s *InitCondDefinitionContext) InitCondHash() IInitCondHashContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IInitCondHashContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IInitCondHashContext) +} + +func (s *InitCondDefinitionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *InitCondDefinitionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *InitCondDefinitionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterInitCondDefinition(s) + } +} + +func (s *InitCondDefinitionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitInitCondDefinition(s) + } +} + +func (s *InitCondDefinitionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitInitCondDefinition(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) InitCondDefinition() (localctx IInitCondDefinitionContext) { + localctx = NewInitCondDefinitionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 54, CqlParserRULE_initCondDefinition) + p.SetState(936) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 46, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(932) + p.Constant() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(933) + p.InitCondList() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(934) + p.InitCondListNested() + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(935) + p.InitCondHash() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IInitCondHashContext is an interface to support dynamic dispatch. +type IInitCondHashContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SyntaxBracketLc() ISyntaxBracketLcContext + AllInitCondHashItem() []IInitCondHashItemContext + InitCondHashItem(i int) IInitCondHashItemContext + SyntaxBracketRc() ISyntaxBracketRcContext + AllSyntaxComma() []ISyntaxCommaContext + SyntaxComma(i int) ISyntaxCommaContext + + // IsInitCondHashContext differentiates from other interfaces. + IsInitCondHashContext() +} + +type InitCondHashContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyInitCondHashContext() *InitCondHashContext { + var p = new(InitCondHashContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_initCondHash + return p +} + +func InitEmptyInitCondHashContext(p *InitCondHashContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_initCondHash +} + +func (*InitCondHashContext) IsInitCondHashContext() {} + +func NewInitCondHashContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *InitCondHashContext { + var p = new(InitCondHashContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_initCondHash + + return p +} + +func (s *InitCondHashContext) GetParser() antlr.Parser { return s.parser } + +func (s *InitCondHashContext) SyntaxBracketLc() ISyntaxBracketLcContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISyntaxBracketLcContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISyntaxBracketLcContext) +} + +func (s *InitCondHashContext) AllInitCondHashItem() []IInitCondHashItemContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IInitCondHashItemContext); ok { + len++ + } + } + + tst := make([]IInitCondHashItemContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IInitCondHashItemContext); ok { + tst[i] = t.(IInitCondHashItemContext) + i++ + } + } + + return tst +} + +func (s *InitCondHashContext) InitCondHashItem(i int) IInitCondHashItemContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IInitCondHashItemContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IInitCondHashItemContext) +} + +func (s *InitCondHashContext) SyntaxBracketRc() ISyntaxBracketRcContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISyntaxBracketRcContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISyntaxBracketRcContext) +} + +func (s *InitCondHashContext) AllSyntaxComma() []ISyntaxCommaContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISyntaxCommaContext); ok { + len++ + } + } + + tst := make([]ISyntaxCommaContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISyntaxCommaContext); ok { + tst[i] = t.(ISyntaxCommaContext) + i++ + } + } + + return tst +} + +func (s *InitCondHashContext) SyntaxComma(i int) ISyntaxCommaContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISyntaxCommaContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISyntaxCommaContext) +} + +func (s *InitCondHashContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *InitCondHashContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *InitCondHashContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterInitCondHash(s) + } +} + +func (s *InitCondHashContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitInitCondHash(s) + } +} + +func (s *InitCondHashContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitInitCondHash(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) InitCondHash() (localctx IInitCondHashContext) { + localctx = NewInitCondHashContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 56, CqlParserRULE_initCondHash) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(938) + p.SyntaxBracketLc() + } + { + p.SetState(939) + p.InitCondHashItem() + } + p.SetState(945) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == CqlParserCOMMA { + { + p.SetState(940) + p.SyntaxComma() + } + { + p.SetState(941) + p.InitCondHashItem() + } + + p.SetState(947) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(948) + p.SyntaxBracketRc() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IInitCondHashItemContext is an interface to support dynamic dispatch. +type IInitCondHashItemContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + HashKey() IHashKeyContext + COLON() antlr.TerminalNode + InitCondDefinition() IInitCondDefinitionContext + + // IsInitCondHashItemContext differentiates from other interfaces. + IsInitCondHashItemContext() +} + +type InitCondHashItemContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyInitCondHashItemContext() *InitCondHashItemContext { + var p = new(InitCondHashItemContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_initCondHashItem + return p +} + +func InitEmptyInitCondHashItemContext(p *InitCondHashItemContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_initCondHashItem +} + +func (*InitCondHashItemContext) IsInitCondHashItemContext() {} + +func NewInitCondHashItemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *InitCondHashItemContext { + var p = new(InitCondHashItemContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_initCondHashItem + + return p +} + +func (s *InitCondHashItemContext) GetParser() antlr.Parser { return s.parser } + +func (s *InitCondHashItemContext) HashKey() IHashKeyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IHashKeyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IHashKeyContext) +} + +func (s *InitCondHashItemContext) COLON() antlr.TerminalNode { + return s.GetToken(CqlParserCOLON, 0) +} + +func (s *InitCondHashItemContext) InitCondDefinition() IInitCondDefinitionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IInitCondDefinitionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IInitCondDefinitionContext) +} + +func (s *InitCondHashItemContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *InitCondHashItemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *InitCondHashItemContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterInitCondHashItem(s) + } +} + +func (s *InitCondHashItemContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitInitCondHashItem(s) + } +} + +func (s *InitCondHashItemContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitInitCondHashItem(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) InitCondHashItem() (localctx IInitCondHashItemContext) { + localctx = NewInitCondHashItemContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 58, CqlParserRULE_initCondHashItem) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(950) + p.HashKey() + } + { + p.SetState(951) + p.Match(CqlParserCOLON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(952) + p.InitCondDefinition() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IInitCondListNestedContext is an interface to support dynamic dispatch. +type IInitCondListNestedContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SyntaxBracketLr() ISyntaxBracketLrContext + AllInitCondList() []IInitCondListContext + InitCondList(i int) IInitCondListContext + SyntaxBracketRr() ISyntaxBracketRrContext + AllSyntaxComma() []ISyntaxCommaContext + SyntaxComma(i int) ISyntaxCommaContext + AllConstant() []IConstantContext + Constant(i int) IConstantContext + + // IsInitCondListNestedContext differentiates from other interfaces. + IsInitCondListNestedContext() +} + +type InitCondListNestedContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyInitCondListNestedContext() *InitCondListNestedContext { + var p = new(InitCondListNestedContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_initCondListNested + return p +} + +func InitEmptyInitCondListNestedContext(p *InitCondListNestedContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_initCondListNested +} + +func (*InitCondListNestedContext) IsInitCondListNestedContext() {} + +func NewInitCondListNestedContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *InitCondListNestedContext { + var p = new(InitCondListNestedContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_initCondListNested + + return p +} + +func (s *InitCondListNestedContext) GetParser() antlr.Parser { return s.parser } + +func (s *InitCondListNestedContext) SyntaxBracketLr() ISyntaxBracketLrContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISyntaxBracketLrContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISyntaxBracketLrContext) +} + +func (s *InitCondListNestedContext) AllInitCondList() []IInitCondListContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IInitCondListContext); ok { + len++ + } + } + + tst := make([]IInitCondListContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IInitCondListContext); ok { + tst[i] = t.(IInitCondListContext) + i++ + } + } + + return tst +} + +func (s *InitCondListNestedContext) InitCondList(i int) IInitCondListContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IInitCondListContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IInitCondListContext) +} + +func (s *InitCondListNestedContext) SyntaxBracketRr() ISyntaxBracketRrContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISyntaxBracketRrContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISyntaxBracketRrContext) +} + +func (s *InitCondListNestedContext) AllSyntaxComma() []ISyntaxCommaContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISyntaxCommaContext); ok { + len++ + } + } + + tst := make([]ISyntaxCommaContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISyntaxCommaContext); ok { + tst[i] = t.(ISyntaxCommaContext) + i++ + } + } + + return tst +} + +func (s *InitCondListNestedContext) SyntaxComma(i int) ISyntaxCommaContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISyntaxCommaContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISyntaxCommaContext) +} + +func (s *InitCondListNestedContext) AllConstant() []IConstantContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IConstantContext); ok { + len++ + } + } + + tst := make([]IConstantContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IConstantContext); ok { + tst[i] = t.(IConstantContext) + i++ + } + } + + return tst +} + +func (s *InitCondListNestedContext) Constant(i int) IConstantContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConstantContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IConstantContext) +} + +func (s *InitCondListNestedContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *InitCondListNestedContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *InitCondListNestedContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterInitCondListNested(s) + } +} + +func (s *InitCondListNestedContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitInitCondListNested(s) + } +} + +func (s *InitCondListNestedContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitInitCondListNested(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) InitCondListNested() (localctx IInitCondListNestedContext) { + localctx = NewInitCondListNestedContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 60, CqlParserRULE_initCondListNested) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(954) + p.SyntaxBracketLr() + } + { + p.SetState(955) + p.InitCondList() + } + p.SetState(962) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == CqlParserLR_BRACKET || _la == CqlParserCOMMA { + p.SetState(960) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case CqlParserCOMMA: + { + p.SetState(956) + p.SyntaxComma() + } + { + p.SetState(957) + p.Constant() + } + + case CqlParserLR_BRACKET: + { + p.SetState(959) + p.InitCondList() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(964) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(965) + p.SyntaxBracketRr() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IInitCondListContext is an interface to support dynamic dispatch. +type IInitCondListContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SyntaxBracketLr() ISyntaxBracketLrContext + AllConstant() []IConstantContext + Constant(i int) IConstantContext + SyntaxBracketRr() ISyntaxBracketRrContext + AllSyntaxComma() []ISyntaxCommaContext + SyntaxComma(i int) ISyntaxCommaContext + + // IsInitCondListContext differentiates from other interfaces. + IsInitCondListContext() +} + +type InitCondListContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyInitCondListContext() *InitCondListContext { + var p = new(InitCondListContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_initCondList + return p +} + +func InitEmptyInitCondListContext(p *InitCondListContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_initCondList +} + +func (*InitCondListContext) IsInitCondListContext() {} + +func NewInitCondListContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *InitCondListContext { + var p = new(InitCondListContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_initCondList + + return p +} + +func (s *InitCondListContext) GetParser() antlr.Parser { return s.parser } + +func (s *InitCondListContext) SyntaxBracketLr() ISyntaxBracketLrContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISyntaxBracketLrContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISyntaxBracketLrContext) +} + +func (s *InitCondListContext) AllConstant() []IConstantContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IConstantContext); ok { + len++ + } + } + + tst := make([]IConstantContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IConstantContext); ok { + tst[i] = t.(IConstantContext) + i++ + } + } + + return tst +} + +func (s *InitCondListContext) Constant(i int) IConstantContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConstantContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IConstantContext) +} + +func (s *InitCondListContext) SyntaxBracketRr() ISyntaxBracketRrContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISyntaxBracketRrContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISyntaxBracketRrContext) +} + +func (s *InitCondListContext) AllSyntaxComma() []ISyntaxCommaContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISyntaxCommaContext); ok { + len++ + } + } + + tst := make([]ISyntaxCommaContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISyntaxCommaContext); ok { + tst[i] = t.(ISyntaxCommaContext) + i++ + } + } + + return tst +} + +func (s *InitCondListContext) SyntaxComma(i int) ISyntaxCommaContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISyntaxCommaContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISyntaxCommaContext) +} + +func (s *InitCondListContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *InitCondListContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *InitCondListContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterInitCondList(s) + } +} + +func (s *InitCondListContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitInitCondList(s) + } +} + +func (s *InitCondListContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitInitCondList(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) InitCondList() (localctx IInitCondListContext) { + localctx = NewInitCondListContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 62, CqlParserRULE_initCondList) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(967) + p.SyntaxBracketLr() + } + { + p.SetState(968) + p.Constant() + } + p.SetState(974) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == CqlParserCOMMA { + { + p.SetState(969) + p.SyntaxComma() + } + { + p.SetState(970) + p.Constant() + } + + p.SetState(976) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(977) + p.SyntaxBracketRr() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOrReplaceContext is an interface to support dynamic dispatch. +type IOrReplaceContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + KwOr() IKwOrContext + KwReplace() IKwReplaceContext + + // IsOrReplaceContext differentiates from other interfaces. + IsOrReplaceContext() +} + +type OrReplaceContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOrReplaceContext() *OrReplaceContext { + var p = new(OrReplaceContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_orReplace + return p +} + +func InitEmptyOrReplaceContext(p *OrReplaceContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_orReplace +} + +func (*OrReplaceContext) IsOrReplaceContext() {} + +func NewOrReplaceContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *OrReplaceContext { + var p = new(OrReplaceContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_orReplace + + return p +} + +func (s *OrReplaceContext) GetParser() antlr.Parser { return s.parser } + +func (s *OrReplaceContext) KwOr() IKwOrContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwOrContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwOrContext) +} + +func (s *OrReplaceContext) KwReplace() IKwReplaceContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwReplaceContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwReplaceContext) +} + +func (s *OrReplaceContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *OrReplaceContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *OrReplaceContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterOrReplace(s) + } +} + +func (s *OrReplaceContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitOrReplace(s) + } +} + +func (s *OrReplaceContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitOrReplace(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) OrReplace() (localctx IOrReplaceContext) { + localctx = NewOrReplaceContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 64, CqlParserRULE_orReplace) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(979) + p.KwOr() + } + { + p.SetState(980) + p.KwReplace() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlterUserContext is an interface to support dynamic dispatch. +type IAlterUserContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + KwAlter() IKwAlterContext + KwUser() IKwUserContext + User() IUserContext + KwWith() IKwWithContext + UserPassword() IUserPasswordContext + UserSuperUser() IUserSuperUserContext + + // IsAlterUserContext differentiates from other interfaces. + IsAlterUserContext() +} + +type AlterUserContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlterUserContext() *AlterUserContext { + var p = new(AlterUserContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_alterUser + return p +} + +func InitEmptyAlterUserContext(p *AlterUserContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_alterUser +} + +func (*AlterUserContext) IsAlterUserContext() {} + +func NewAlterUserContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AlterUserContext { + var p = new(AlterUserContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_alterUser + + return p +} + +func (s *AlterUserContext) GetParser() antlr.Parser { return s.parser } + +func (s *AlterUserContext) KwAlter() IKwAlterContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwAlterContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwAlterContext) +} + +func (s *AlterUserContext) KwUser() IKwUserContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwUserContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwUserContext) +} + +func (s *AlterUserContext) User() IUserContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUserContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUserContext) +} + +func (s *AlterUserContext) KwWith() IKwWithContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwWithContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwWithContext) +} + +func (s *AlterUserContext) UserPassword() IUserPasswordContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUserPasswordContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUserPasswordContext) +} + +func (s *AlterUserContext) UserSuperUser() IUserSuperUserContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUserSuperUserContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUserSuperUserContext) +} + +func (s *AlterUserContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AlterUserContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *AlterUserContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterAlterUser(s) + } +} + +func (s *AlterUserContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitAlterUser(s) + } +} + +func (s *AlterUserContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitAlterUser(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) AlterUser() (localctx IAlterUserContext) { + localctx = NewAlterUserContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 66, CqlParserRULE_alterUser) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(982) + p.KwAlter() + } + { + p.SetState(983) + p.KwUser() + } + { + p.SetState(984) + p.User() + } + { + p.SetState(985) + p.KwWith() + } + { + p.SetState(986) + p.UserPassword() + } + p.SetState(988) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == CqlParserK_NOSUPERUSER || _la == CqlParserK_SUPERUSER { + { + p.SetState(987) + p.UserSuperUser() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IUserPasswordContext is an interface to support dynamic dispatch. +type IUserPasswordContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + KwPassword() IKwPasswordContext + StringLiteral() IStringLiteralContext + + // IsUserPasswordContext differentiates from other interfaces. + IsUserPasswordContext() +} + +type UserPasswordContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyUserPasswordContext() *UserPasswordContext { + var p = new(UserPasswordContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_userPassword + return p +} + +func InitEmptyUserPasswordContext(p *UserPasswordContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_userPassword +} + +func (*UserPasswordContext) IsUserPasswordContext() {} + +func NewUserPasswordContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *UserPasswordContext { + var p = new(UserPasswordContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_userPassword + + return p +} + +func (s *UserPasswordContext) GetParser() antlr.Parser { return s.parser } + +func (s *UserPasswordContext) KwPassword() IKwPasswordContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwPasswordContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwPasswordContext) +} + +func (s *UserPasswordContext) StringLiteral() IStringLiteralContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStringLiteralContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStringLiteralContext) +} + +func (s *UserPasswordContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *UserPasswordContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *UserPasswordContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterUserPassword(s) + } +} + +func (s *UserPasswordContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitUserPassword(s) + } +} + +func (s *UserPasswordContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitUserPassword(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) UserPassword() (localctx IUserPasswordContext) { + localctx = NewUserPasswordContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 68, CqlParserRULE_userPassword) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(990) + p.KwPassword() + } + { + p.SetState(991) + p.StringLiteral() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IUserSuperUserContext is an interface to support dynamic dispatch. +type IUserSuperUserContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + KwSuperuser() IKwSuperuserContext + KwNosuperuser() IKwNosuperuserContext + + // IsUserSuperUserContext differentiates from other interfaces. + IsUserSuperUserContext() +} + +type UserSuperUserContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyUserSuperUserContext() *UserSuperUserContext { + var p = new(UserSuperUserContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_userSuperUser + return p +} + +func InitEmptyUserSuperUserContext(p *UserSuperUserContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_userSuperUser +} + +func (*UserSuperUserContext) IsUserSuperUserContext() {} + +func NewUserSuperUserContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *UserSuperUserContext { + var p = new(UserSuperUserContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_userSuperUser + + return p +} + +func (s *UserSuperUserContext) GetParser() antlr.Parser { return s.parser } + +func (s *UserSuperUserContext) KwSuperuser() IKwSuperuserContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwSuperuserContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwSuperuserContext) +} + +func (s *UserSuperUserContext) KwNosuperuser() IKwNosuperuserContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwNosuperuserContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwNosuperuserContext) +} + +func (s *UserSuperUserContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *UserSuperUserContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *UserSuperUserContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterUserSuperUser(s) + } +} + +func (s *UserSuperUserContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitUserSuperUser(s) + } +} + +func (s *UserSuperUserContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitUserSuperUser(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) UserSuperUser() (localctx IUserSuperUserContext) { + localctx = NewUserSuperUserContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 70, CqlParserRULE_userSuperUser) + p.SetState(995) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case CqlParserK_SUPERUSER: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(993) + p.KwSuperuser() + } + + case CqlParserK_NOSUPERUSER: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(994) + p.KwNosuperuser() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlterTypeContext is an interface to support dynamic dispatch. +type IAlterTypeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + KwAlter() IKwAlterContext + KwType() IKwTypeContext + Type_() IType_Context + AlterTypeOperation() IAlterTypeOperationContext + Keyspace() IKeyspaceContext + DOT() antlr.TerminalNode + + // IsAlterTypeContext differentiates from other interfaces. + IsAlterTypeContext() +} + +type AlterTypeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlterTypeContext() *AlterTypeContext { + var p = new(AlterTypeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_alterType + return p +} + +func InitEmptyAlterTypeContext(p *AlterTypeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_alterType +} + +func (*AlterTypeContext) IsAlterTypeContext() {} + +func NewAlterTypeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AlterTypeContext { + var p = new(AlterTypeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_alterType + + return p +} + +func (s *AlterTypeContext) GetParser() antlr.Parser { return s.parser } + +func (s *AlterTypeContext) KwAlter() IKwAlterContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwAlterContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwAlterContext) +} + +func (s *AlterTypeContext) KwType() IKwTypeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwTypeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwTypeContext) +} + +func (s *AlterTypeContext) Type_() IType_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IType_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IType_Context) +} + +func (s *AlterTypeContext) AlterTypeOperation() IAlterTypeOperationContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlterTypeOperationContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlterTypeOperationContext) +} + +func (s *AlterTypeContext) Keyspace() IKeyspaceContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKeyspaceContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKeyspaceContext) +} + +func (s *AlterTypeContext) DOT() antlr.TerminalNode { + return s.GetToken(CqlParserDOT, 0) +} + +func (s *AlterTypeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AlterTypeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *AlterTypeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterAlterType(s) + } +} + +func (s *AlterTypeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitAlterType(s) + } +} + +func (s *AlterTypeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitAlterType(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) AlterType() (localctx IAlterTypeContext) { + localctx = NewAlterTypeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 72, CqlParserRULE_alterType) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(997) + p.KwAlter() + } + { + p.SetState(998) + p.KwType() + } + p.SetState(1002) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 53, p.GetParserRuleContext()) == 1 { + { + p.SetState(999) + p.Keyspace() + } + { + p.SetState(1000) + p.Match(CqlParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(1004) + p.Type_() + } + { + p.SetState(1005) + p.AlterTypeOperation() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlterTypeOperationContext is an interface to support dynamic dispatch. +type IAlterTypeOperationContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AlterTypeAlterType() IAlterTypeAlterTypeContext + AlterTypeAdd() IAlterTypeAddContext + AlterTypeRename() IAlterTypeRenameContext + + // IsAlterTypeOperationContext differentiates from other interfaces. + IsAlterTypeOperationContext() +} + +type AlterTypeOperationContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlterTypeOperationContext() *AlterTypeOperationContext { + var p = new(AlterTypeOperationContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_alterTypeOperation + return p +} + +func InitEmptyAlterTypeOperationContext(p *AlterTypeOperationContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_alterTypeOperation +} + +func (*AlterTypeOperationContext) IsAlterTypeOperationContext() {} + +func NewAlterTypeOperationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AlterTypeOperationContext { + var p = new(AlterTypeOperationContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_alterTypeOperation + + return p +} + +func (s *AlterTypeOperationContext) GetParser() antlr.Parser { return s.parser } + +func (s *AlterTypeOperationContext) AlterTypeAlterType() IAlterTypeAlterTypeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlterTypeAlterTypeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlterTypeAlterTypeContext) +} + +func (s *AlterTypeOperationContext) AlterTypeAdd() IAlterTypeAddContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlterTypeAddContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlterTypeAddContext) +} + +func (s *AlterTypeOperationContext) AlterTypeRename() IAlterTypeRenameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlterTypeRenameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlterTypeRenameContext) +} + +func (s *AlterTypeOperationContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AlterTypeOperationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *AlterTypeOperationContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterAlterTypeOperation(s) + } +} + +func (s *AlterTypeOperationContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitAlterTypeOperation(s) + } +} + +func (s *AlterTypeOperationContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitAlterTypeOperation(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) AlterTypeOperation() (localctx IAlterTypeOperationContext) { + localctx = NewAlterTypeOperationContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 74, CqlParserRULE_alterTypeOperation) + p.SetState(1010) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case CqlParserK_ALTER: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1007) + p.AlterTypeAlterType() + } + + case CqlParserK_ADD: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(1008) + p.AlterTypeAdd() + } + + case CqlParserK_RENAME: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(1009) + p.AlterTypeRename() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlterTypeRenameContext is an interface to support dynamic dispatch. +type IAlterTypeRenameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + KwRename() IKwRenameContext + AlterTypeRenameList() IAlterTypeRenameListContext + + // IsAlterTypeRenameContext differentiates from other interfaces. + IsAlterTypeRenameContext() +} + +type AlterTypeRenameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlterTypeRenameContext() *AlterTypeRenameContext { + var p = new(AlterTypeRenameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_alterTypeRename + return p +} + +func InitEmptyAlterTypeRenameContext(p *AlterTypeRenameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_alterTypeRename +} + +func (*AlterTypeRenameContext) IsAlterTypeRenameContext() {} + +func NewAlterTypeRenameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AlterTypeRenameContext { + var p = new(AlterTypeRenameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_alterTypeRename + + return p +} + +func (s *AlterTypeRenameContext) GetParser() antlr.Parser { return s.parser } + +func (s *AlterTypeRenameContext) KwRename() IKwRenameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwRenameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwRenameContext) +} + +func (s *AlterTypeRenameContext) AlterTypeRenameList() IAlterTypeRenameListContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlterTypeRenameListContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlterTypeRenameListContext) +} + +func (s *AlterTypeRenameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AlterTypeRenameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *AlterTypeRenameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterAlterTypeRename(s) + } +} + +func (s *AlterTypeRenameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitAlterTypeRename(s) + } +} + +func (s *AlterTypeRenameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitAlterTypeRename(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) AlterTypeRename() (localctx IAlterTypeRenameContext) { + localctx = NewAlterTypeRenameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 76, CqlParserRULE_alterTypeRename) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1012) + p.KwRename() + } + { + p.SetState(1013) + p.AlterTypeRenameList() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlterTypeRenameListContext is an interface to support dynamic dispatch. +type IAlterTypeRenameListContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllAlterTypeRenameItem() []IAlterTypeRenameItemContext + AlterTypeRenameItem(i int) IAlterTypeRenameItemContext + AllKwAnd() []IKwAndContext + KwAnd(i int) IKwAndContext + + // IsAlterTypeRenameListContext differentiates from other interfaces. + IsAlterTypeRenameListContext() +} + +type AlterTypeRenameListContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlterTypeRenameListContext() *AlterTypeRenameListContext { + var p = new(AlterTypeRenameListContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_alterTypeRenameList + return p +} + +func InitEmptyAlterTypeRenameListContext(p *AlterTypeRenameListContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_alterTypeRenameList +} + +func (*AlterTypeRenameListContext) IsAlterTypeRenameListContext() {} + +func NewAlterTypeRenameListContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AlterTypeRenameListContext { + var p = new(AlterTypeRenameListContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_alterTypeRenameList + + return p +} + +func (s *AlterTypeRenameListContext) GetParser() antlr.Parser { return s.parser } + +func (s *AlterTypeRenameListContext) AllAlterTypeRenameItem() []IAlterTypeRenameItemContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IAlterTypeRenameItemContext); ok { + len++ + } + } + + tst := make([]IAlterTypeRenameItemContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IAlterTypeRenameItemContext); ok { + tst[i] = t.(IAlterTypeRenameItemContext) + i++ + } + } + + return tst +} + +func (s *AlterTypeRenameListContext) AlterTypeRenameItem(i int) IAlterTypeRenameItemContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlterTypeRenameItemContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IAlterTypeRenameItemContext) +} + +func (s *AlterTypeRenameListContext) AllKwAnd() []IKwAndContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IKwAndContext); ok { + len++ + } + } + + tst := make([]IKwAndContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IKwAndContext); ok { + tst[i] = t.(IKwAndContext) + i++ + } + } + + return tst +} + +func (s *AlterTypeRenameListContext) KwAnd(i int) IKwAndContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwAndContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IKwAndContext) +} + +func (s *AlterTypeRenameListContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AlterTypeRenameListContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *AlterTypeRenameListContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterAlterTypeRenameList(s) + } +} + +func (s *AlterTypeRenameListContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitAlterTypeRenameList(s) + } +} + +func (s *AlterTypeRenameListContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitAlterTypeRenameList(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) AlterTypeRenameList() (localctx IAlterTypeRenameListContext) { + localctx = NewAlterTypeRenameListContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 78, CqlParserRULE_alterTypeRenameList) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1015) + p.AlterTypeRenameItem() + } + p.SetState(1021) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == CqlParserK_AND { + { + p.SetState(1016) + p.KwAnd() + } + { + p.SetState(1017) + p.AlterTypeRenameItem() + } + + p.SetState(1023) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlterTypeRenameItemContext is an interface to support dynamic dispatch. +type IAlterTypeRenameItemContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllColumn() []IColumnContext + Column(i int) IColumnContext + KwTo() IKwToContext + + // IsAlterTypeRenameItemContext differentiates from other interfaces. + IsAlterTypeRenameItemContext() +} + +type AlterTypeRenameItemContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlterTypeRenameItemContext() *AlterTypeRenameItemContext { + var p = new(AlterTypeRenameItemContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_alterTypeRenameItem + return p +} + +func InitEmptyAlterTypeRenameItemContext(p *AlterTypeRenameItemContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_alterTypeRenameItem +} + +func (*AlterTypeRenameItemContext) IsAlterTypeRenameItemContext() {} + +func NewAlterTypeRenameItemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AlterTypeRenameItemContext { + var p = new(AlterTypeRenameItemContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_alterTypeRenameItem + + return p +} + +func (s *AlterTypeRenameItemContext) GetParser() antlr.Parser { return s.parser } + +func (s *AlterTypeRenameItemContext) AllColumn() []IColumnContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IColumnContext); ok { + len++ + } + } + + tst := make([]IColumnContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IColumnContext); ok { + tst[i] = t.(IColumnContext) + i++ + } + } + + return tst +} + +func (s *AlterTypeRenameItemContext) Column(i int) IColumnContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumnContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IColumnContext) +} + +func (s *AlterTypeRenameItemContext) KwTo() IKwToContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwToContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwToContext) +} + +func (s *AlterTypeRenameItemContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AlterTypeRenameItemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *AlterTypeRenameItemContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterAlterTypeRenameItem(s) + } +} + +func (s *AlterTypeRenameItemContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitAlterTypeRenameItem(s) + } +} + +func (s *AlterTypeRenameItemContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitAlterTypeRenameItem(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) AlterTypeRenameItem() (localctx IAlterTypeRenameItemContext) { + localctx = NewAlterTypeRenameItemContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 80, CqlParserRULE_alterTypeRenameItem) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1024) + p.Column() + } + { + p.SetState(1025) + p.KwTo() + } + { + p.SetState(1026) + p.Column() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlterTypeAddContext is an interface to support dynamic dispatch. +type IAlterTypeAddContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + KwAdd() IKwAddContext + AllColumn() []IColumnContext + Column(i int) IColumnContext + AllDataType() []IDataTypeContext + DataType(i int) IDataTypeContext + AllSyntaxComma() []ISyntaxCommaContext + SyntaxComma(i int) ISyntaxCommaContext + + // IsAlterTypeAddContext differentiates from other interfaces. + IsAlterTypeAddContext() +} + +type AlterTypeAddContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlterTypeAddContext() *AlterTypeAddContext { + var p = new(AlterTypeAddContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_alterTypeAdd + return p +} + +func InitEmptyAlterTypeAddContext(p *AlterTypeAddContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_alterTypeAdd +} + +func (*AlterTypeAddContext) IsAlterTypeAddContext() {} + +func NewAlterTypeAddContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AlterTypeAddContext { + var p = new(AlterTypeAddContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_alterTypeAdd + + return p +} + +func (s *AlterTypeAddContext) GetParser() antlr.Parser { return s.parser } + +func (s *AlterTypeAddContext) KwAdd() IKwAddContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwAddContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwAddContext) +} + +func (s *AlterTypeAddContext) AllColumn() []IColumnContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IColumnContext); ok { + len++ + } + } + + tst := make([]IColumnContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IColumnContext); ok { + tst[i] = t.(IColumnContext) + i++ + } + } + + return tst +} + +func (s *AlterTypeAddContext) Column(i int) IColumnContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumnContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IColumnContext) +} + +func (s *AlterTypeAddContext) AllDataType() []IDataTypeContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IDataTypeContext); ok { + len++ + } + } + + tst := make([]IDataTypeContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IDataTypeContext); ok { + tst[i] = t.(IDataTypeContext) + i++ + } + } + + return tst +} + +func (s *AlterTypeAddContext) DataType(i int) IDataTypeContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDataTypeContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IDataTypeContext) +} + +func (s *AlterTypeAddContext) AllSyntaxComma() []ISyntaxCommaContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISyntaxCommaContext); ok { + len++ + } + } + + tst := make([]ISyntaxCommaContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISyntaxCommaContext); ok { + tst[i] = t.(ISyntaxCommaContext) + i++ + } + } + + return tst +} + +func (s *AlterTypeAddContext) SyntaxComma(i int) ISyntaxCommaContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISyntaxCommaContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISyntaxCommaContext) +} + +func (s *AlterTypeAddContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AlterTypeAddContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *AlterTypeAddContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterAlterTypeAdd(s) + } +} + +func (s *AlterTypeAddContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitAlterTypeAdd(s) + } +} + +func (s *AlterTypeAddContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitAlterTypeAdd(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) AlterTypeAdd() (localctx IAlterTypeAddContext) { + localctx = NewAlterTypeAddContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 82, CqlParserRULE_alterTypeAdd) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1028) + p.KwAdd() + } + { + p.SetState(1029) + p.Column() + } + { + p.SetState(1030) + p.DataType() + } + p.SetState(1037) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == CqlParserCOMMA { + { + p.SetState(1031) + p.SyntaxComma() + } + { + p.SetState(1032) + p.Column() + } + { + p.SetState(1033) + p.DataType() + } + + p.SetState(1039) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlterTypeAlterTypeContext is an interface to support dynamic dispatch. +type IAlterTypeAlterTypeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + KwAlter() IKwAlterContext + Column() IColumnContext + KwType() IKwTypeContext + DataType() IDataTypeContext + + // IsAlterTypeAlterTypeContext differentiates from other interfaces. + IsAlterTypeAlterTypeContext() +} + +type AlterTypeAlterTypeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlterTypeAlterTypeContext() *AlterTypeAlterTypeContext { + var p = new(AlterTypeAlterTypeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_alterTypeAlterType + return p +} + +func InitEmptyAlterTypeAlterTypeContext(p *AlterTypeAlterTypeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_alterTypeAlterType +} + +func (*AlterTypeAlterTypeContext) IsAlterTypeAlterTypeContext() {} + +func NewAlterTypeAlterTypeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AlterTypeAlterTypeContext { + var p = new(AlterTypeAlterTypeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_alterTypeAlterType + + return p +} + +func (s *AlterTypeAlterTypeContext) GetParser() antlr.Parser { return s.parser } + +func (s *AlterTypeAlterTypeContext) KwAlter() IKwAlterContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwAlterContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwAlterContext) +} + +func (s *AlterTypeAlterTypeContext) Column() IColumnContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumnContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumnContext) +} + +func (s *AlterTypeAlterTypeContext) KwType() IKwTypeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwTypeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwTypeContext) +} + +func (s *AlterTypeAlterTypeContext) DataType() IDataTypeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDataTypeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDataTypeContext) +} + +func (s *AlterTypeAlterTypeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AlterTypeAlterTypeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *AlterTypeAlterTypeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterAlterTypeAlterType(s) + } +} + +func (s *AlterTypeAlterTypeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitAlterTypeAlterType(s) + } +} + +func (s *AlterTypeAlterTypeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitAlterTypeAlterType(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) AlterTypeAlterType() (localctx IAlterTypeAlterTypeContext) { + localctx = NewAlterTypeAlterTypeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 84, CqlParserRULE_alterTypeAlterType) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1040) + p.KwAlter() + } + { + p.SetState(1041) + p.Column() + } + { + p.SetState(1042) + p.KwType() + } + { + p.SetState(1043) + p.DataType() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlterTableContext is an interface to support dynamic dispatch. +type IAlterTableContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + KwAlter() IKwAlterContext + KwTable() IKwTableContext + Table() ITableContext + AlterTableOperation() IAlterTableOperationContext + Keyspace() IKeyspaceContext + DOT() antlr.TerminalNode + + // IsAlterTableContext differentiates from other interfaces. + IsAlterTableContext() +} + +type AlterTableContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlterTableContext() *AlterTableContext { + var p = new(AlterTableContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_alterTable + return p +} + +func InitEmptyAlterTableContext(p *AlterTableContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_alterTable +} + +func (*AlterTableContext) IsAlterTableContext() {} + +func NewAlterTableContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AlterTableContext { + var p = new(AlterTableContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_alterTable + + return p +} + +func (s *AlterTableContext) GetParser() antlr.Parser { return s.parser } + +func (s *AlterTableContext) KwAlter() IKwAlterContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwAlterContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwAlterContext) +} + +func (s *AlterTableContext) KwTable() IKwTableContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwTableContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwTableContext) +} + +func (s *AlterTableContext) Table() ITableContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITableContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITableContext) +} + +func (s *AlterTableContext) AlterTableOperation() IAlterTableOperationContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlterTableOperationContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlterTableOperationContext) +} + +func (s *AlterTableContext) Keyspace() IKeyspaceContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKeyspaceContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKeyspaceContext) +} + +func (s *AlterTableContext) DOT() antlr.TerminalNode { + return s.GetToken(CqlParserDOT, 0) +} + +func (s *AlterTableContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AlterTableContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *AlterTableContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterAlterTable(s) + } +} + +func (s *AlterTableContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitAlterTable(s) + } +} + +func (s *AlterTableContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitAlterTable(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) AlterTable() (localctx IAlterTableContext) { + localctx = NewAlterTableContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 86, CqlParserRULE_alterTable) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1045) + p.KwAlter() + } + { + p.SetState(1046) + p.KwTable() + } + p.SetState(1050) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 57, p.GetParserRuleContext()) == 1 { + { + p.SetState(1047) + p.Keyspace() + } + { + p.SetState(1048) + p.Match(CqlParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(1052) + p.Table() + } + { + p.SetState(1053) + p.AlterTableOperation() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlterTableOperationContext is an interface to support dynamic dispatch. +type IAlterTableOperationContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AlterTableAdd() IAlterTableAddContext + AlterTableDropColumns() IAlterTableDropColumnsContext + AlterTableDropCompactStorage() IAlterTableDropCompactStorageContext + AlterTableRename() IAlterTableRenameContext + AlterTableWith() IAlterTableWithContext + + // IsAlterTableOperationContext differentiates from other interfaces. + IsAlterTableOperationContext() +} + +type AlterTableOperationContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlterTableOperationContext() *AlterTableOperationContext { + var p = new(AlterTableOperationContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_alterTableOperation + return p +} + +func InitEmptyAlterTableOperationContext(p *AlterTableOperationContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_alterTableOperation +} + +func (*AlterTableOperationContext) IsAlterTableOperationContext() {} + +func NewAlterTableOperationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AlterTableOperationContext { + var p = new(AlterTableOperationContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_alterTableOperation + + return p +} + +func (s *AlterTableOperationContext) GetParser() antlr.Parser { return s.parser } + +func (s *AlterTableOperationContext) AlterTableAdd() IAlterTableAddContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlterTableAddContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlterTableAddContext) +} + +func (s *AlterTableOperationContext) AlterTableDropColumns() IAlterTableDropColumnsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlterTableDropColumnsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlterTableDropColumnsContext) +} + +func (s *AlterTableOperationContext) AlterTableDropCompactStorage() IAlterTableDropCompactStorageContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlterTableDropCompactStorageContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlterTableDropCompactStorageContext) +} + +func (s *AlterTableOperationContext) AlterTableRename() IAlterTableRenameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlterTableRenameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlterTableRenameContext) +} + +func (s *AlterTableOperationContext) AlterTableWith() IAlterTableWithContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlterTableWithContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlterTableWithContext) +} + +func (s *AlterTableOperationContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AlterTableOperationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *AlterTableOperationContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterAlterTableOperation(s) + } +} + +func (s *AlterTableOperationContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitAlterTableOperation(s) + } +} + +func (s *AlterTableOperationContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitAlterTableOperation(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) AlterTableOperation() (localctx IAlterTableOperationContext) { + localctx = NewAlterTableOperationContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 88, CqlParserRULE_alterTableOperation) + p.SetState(1060) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 58, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1055) + p.AlterTableAdd() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(1056) + p.AlterTableDropColumns() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(1057) + p.AlterTableDropCompactStorage() + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(1058) + p.AlterTableRename() + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(1059) + p.AlterTableWith() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlterTableWithContext is an interface to support dynamic dispatch. +type IAlterTableWithContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + KwWith() IKwWithContext + TableOptions() ITableOptionsContext + + // IsAlterTableWithContext differentiates from other interfaces. + IsAlterTableWithContext() +} + +type AlterTableWithContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlterTableWithContext() *AlterTableWithContext { + var p = new(AlterTableWithContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_alterTableWith + return p +} + +func InitEmptyAlterTableWithContext(p *AlterTableWithContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_alterTableWith +} + +func (*AlterTableWithContext) IsAlterTableWithContext() {} + +func NewAlterTableWithContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AlterTableWithContext { + var p = new(AlterTableWithContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_alterTableWith + + return p +} + +func (s *AlterTableWithContext) GetParser() antlr.Parser { return s.parser } + +func (s *AlterTableWithContext) KwWith() IKwWithContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwWithContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwWithContext) +} + +func (s *AlterTableWithContext) TableOptions() ITableOptionsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITableOptionsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITableOptionsContext) +} + +func (s *AlterTableWithContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AlterTableWithContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *AlterTableWithContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterAlterTableWith(s) + } +} + +func (s *AlterTableWithContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitAlterTableWith(s) + } +} + +func (s *AlterTableWithContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitAlterTableWith(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) AlterTableWith() (localctx IAlterTableWithContext) { + localctx = NewAlterTableWithContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 90, CqlParserRULE_alterTableWith) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1062) + p.KwWith() + } + { + p.SetState(1063) + p.TableOptions() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlterTableRenameContext is an interface to support dynamic dispatch. +type IAlterTableRenameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + KwRename() IKwRenameContext + AllColumn() []IColumnContext + Column(i int) IColumnContext + KwTo() IKwToContext + + // IsAlterTableRenameContext differentiates from other interfaces. + IsAlterTableRenameContext() +} + +type AlterTableRenameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlterTableRenameContext() *AlterTableRenameContext { + var p = new(AlterTableRenameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_alterTableRename + return p +} + +func InitEmptyAlterTableRenameContext(p *AlterTableRenameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_alterTableRename +} + +func (*AlterTableRenameContext) IsAlterTableRenameContext() {} + +func NewAlterTableRenameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AlterTableRenameContext { + var p = new(AlterTableRenameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_alterTableRename + + return p +} + +func (s *AlterTableRenameContext) GetParser() antlr.Parser { return s.parser } + +func (s *AlterTableRenameContext) KwRename() IKwRenameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwRenameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwRenameContext) +} + +func (s *AlterTableRenameContext) AllColumn() []IColumnContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IColumnContext); ok { + len++ + } + } + + tst := make([]IColumnContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IColumnContext); ok { + tst[i] = t.(IColumnContext) + i++ + } + } + + return tst +} + +func (s *AlterTableRenameContext) Column(i int) IColumnContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumnContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IColumnContext) +} + +func (s *AlterTableRenameContext) KwTo() IKwToContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwToContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwToContext) +} + +func (s *AlterTableRenameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AlterTableRenameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *AlterTableRenameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterAlterTableRename(s) + } +} + +func (s *AlterTableRenameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitAlterTableRename(s) + } +} + +func (s *AlterTableRenameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitAlterTableRename(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) AlterTableRename() (localctx IAlterTableRenameContext) { + localctx = NewAlterTableRenameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 92, CqlParserRULE_alterTableRename) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1065) + p.KwRename() + } + { + p.SetState(1066) + p.Column() + } + { + p.SetState(1067) + p.KwTo() + } + { + p.SetState(1068) + p.Column() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlterTableDropCompactStorageContext is an interface to support dynamic dispatch. +type IAlterTableDropCompactStorageContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + KwDrop() IKwDropContext + KwCompact() IKwCompactContext + KwStorage() IKwStorageContext + + // IsAlterTableDropCompactStorageContext differentiates from other interfaces. + IsAlterTableDropCompactStorageContext() +} + +type AlterTableDropCompactStorageContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlterTableDropCompactStorageContext() *AlterTableDropCompactStorageContext { + var p = new(AlterTableDropCompactStorageContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_alterTableDropCompactStorage + return p +} + +func InitEmptyAlterTableDropCompactStorageContext(p *AlterTableDropCompactStorageContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_alterTableDropCompactStorage +} + +func (*AlterTableDropCompactStorageContext) IsAlterTableDropCompactStorageContext() {} + +func NewAlterTableDropCompactStorageContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AlterTableDropCompactStorageContext { + var p = new(AlterTableDropCompactStorageContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_alterTableDropCompactStorage + + return p +} + +func (s *AlterTableDropCompactStorageContext) GetParser() antlr.Parser { return s.parser } + +func (s *AlterTableDropCompactStorageContext) KwDrop() IKwDropContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwDropContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwDropContext) +} + +func (s *AlterTableDropCompactStorageContext) KwCompact() IKwCompactContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwCompactContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwCompactContext) +} + +func (s *AlterTableDropCompactStorageContext) KwStorage() IKwStorageContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwStorageContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwStorageContext) +} + +func (s *AlterTableDropCompactStorageContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AlterTableDropCompactStorageContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *AlterTableDropCompactStorageContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterAlterTableDropCompactStorage(s) + } +} + +func (s *AlterTableDropCompactStorageContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitAlterTableDropCompactStorage(s) + } +} + +func (s *AlterTableDropCompactStorageContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitAlterTableDropCompactStorage(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) AlterTableDropCompactStorage() (localctx IAlterTableDropCompactStorageContext) { + localctx = NewAlterTableDropCompactStorageContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 94, CqlParserRULE_alterTableDropCompactStorage) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1070) + p.KwDrop() + } + { + p.SetState(1071) + p.KwCompact() + } + { + p.SetState(1072) + p.KwStorage() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlterTableDropColumnsContext is an interface to support dynamic dispatch. +type IAlterTableDropColumnsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + KwDrop() IKwDropContext + AlterTableDropColumnList() IAlterTableDropColumnListContext + + // IsAlterTableDropColumnsContext differentiates from other interfaces. + IsAlterTableDropColumnsContext() +} + +type AlterTableDropColumnsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlterTableDropColumnsContext() *AlterTableDropColumnsContext { + var p = new(AlterTableDropColumnsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_alterTableDropColumns + return p +} + +func InitEmptyAlterTableDropColumnsContext(p *AlterTableDropColumnsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_alterTableDropColumns +} + +func (*AlterTableDropColumnsContext) IsAlterTableDropColumnsContext() {} + +func NewAlterTableDropColumnsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AlterTableDropColumnsContext { + var p = new(AlterTableDropColumnsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_alterTableDropColumns + + return p +} + +func (s *AlterTableDropColumnsContext) GetParser() antlr.Parser { return s.parser } + +func (s *AlterTableDropColumnsContext) KwDrop() IKwDropContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwDropContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwDropContext) +} + +func (s *AlterTableDropColumnsContext) AlterTableDropColumnList() IAlterTableDropColumnListContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlterTableDropColumnListContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlterTableDropColumnListContext) +} + +func (s *AlterTableDropColumnsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AlterTableDropColumnsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *AlterTableDropColumnsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterAlterTableDropColumns(s) + } +} + +func (s *AlterTableDropColumnsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitAlterTableDropColumns(s) + } +} + +func (s *AlterTableDropColumnsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitAlterTableDropColumns(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) AlterTableDropColumns() (localctx IAlterTableDropColumnsContext) { + localctx = NewAlterTableDropColumnsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 96, CqlParserRULE_alterTableDropColumns) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1074) + p.KwDrop() + } + { + p.SetState(1075) + p.AlterTableDropColumnList() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlterTableDropColumnListContext is an interface to support dynamic dispatch. +type IAlterTableDropColumnListContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllColumn() []IColumnContext + Column(i int) IColumnContext + AllSyntaxComma() []ISyntaxCommaContext + SyntaxComma(i int) ISyntaxCommaContext + + // IsAlterTableDropColumnListContext differentiates from other interfaces. + IsAlterTableDropColumnListContext() +} + +type AlterTableDropColumnListContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlterTableDropColumnListContext() *AlterTableDropColumnListContext { + var p = new(AlterTableDropColumnListContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_alterTableDropColumnList + return p +} + +func InitEmptyAlterTableDropColumnListContext(p *AlterTableDropColumnListContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_alterTableDropColumnList +} + +func (*AlterTableDropColumnListContext) IsAlterTableDropColumnListContext() {} + +func NewAlterTableDropColumnListContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AlterTableDropColumnListContext { + var p = new(AlterTableDropColumnListContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_alterTableDropColumnList + + return p +} + +func (s *AlterTableDropColumnListContext) GetParser() antlr.Parser { return s.parser } + +func (s *AlterTableDropColumnListContext) AllColumn() []IColumnContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IColumnContext); ok { + len++ + } + } + + tst := make([]IColumnContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IColumnContext); ok { + tst[i] = t.(IColumnContext) + i++ + } + } + + return tst +} + +func (s *AlterTableDropColumnListContext) Column(i int) IColumnContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumnContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IColumnContext) +} + +func (s *AlterTableDropColumnListContext) AllSyntaxComma() []ISyntaxCommaContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISyntaxCommaContext); ok { + len++ + } + } + + tst := make([]ISyntaxCommaContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISyntaxCommaContext); ok { + tst[i] = t.(ISyntaxCommaContext) + i++ + } + } + + return tst +} + +func (s *AlterTableDropColumnListContext) SyntaxComma(i int) ISyntaxCommaContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISyntaxCommaContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISyntaxCommaContext) +} + +func (s *AlterTableDropColumnListContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AlterTableDropColumnListContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *AlterTableDropColumnListContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterAlterTableDropColumnList(s) + } +} + +func (s *AlterTableDropColumnListContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitAlterTableDropColumnList(s) + } +} + +func (s *AlterTableDropColumnListContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitAlterTableDropColumnList(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) AlterTableDropColumnList() (localctx IAlterTableDropColumnListContext) { + localctx = NewAlterTableDropColumnListContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 98, CqlParserRULE_alterTableDropColumnList) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1077) + p.Column() + } + p.SetState(1083) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == CqlParserCOMMA { + { + p.SetState(1078) + p.SyntaxComma() + } + { + p.SetState(1079) + p.Column() + } + + p.SetState(1085) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlterTableAddContext is an interface to support dynamic dispatch. +type IAlterTableAddContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + KwAdd() IKwAddContext + AlterTableColumnDefinition() IAlterTableColumnDefinitionContext + + // IsAlterTableAddContext differentiates from other interfaces. + IsAlterTableAddContext() +} + +type AlterTableAddContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlterTableAddContext() *AlterTableAddContext { + var p = new(AlterTableAddContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_alterTableAdd + return p +} + +func InitEmptyAlterTableAddContext(p *AlterTableAddContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_alterTableAdd +} + +func (*AlterTableAddContext) IsAlterTableAddContext() {} + +func NewAlterTableAddContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AlterTableAddContext { + var p = new(AlterTableAddContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_alterTableAdd + + return p +} + +func (s *AlterTableAddContext) GetParser() antlr.Parser { return s.parser } + +func (s *AlterTableAddContext) KwAdd() IKwAddContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwAddContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwAddContext) +} + +func (s *AlterTableAddContext) AlterTableColumnDefinition() IAlterTableColumnDefinitionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlterTableColumnDefinitionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlterTableColumnDefinitionContext) +} + +func (s *AlterTableAddContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AlterTableAddContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *AlterTableAddContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterAlterTableAdd(s) + } +} + +func (s *AlterTableAddContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitAlterTableAdd(s) + } +} + +func (s *AlterTableAddContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitAlterTableAdd(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) AlterTableAdd() (localctx IAlterTableAddContext) { + localctx = NewAlterTableAddContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 100, CqlParserRULE_alterTableAdd) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1086) + p.KwAdd() + } + { + p.SetState(1087) + p.AlterTableColumnDefinition() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlterTableColumnDefinitionContext is an interface to support dynamic dispatch. +type IAlterTableColumnDefinitionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllColumn() []IColumnContext + Column(i int) IColumnContext + AllDataType() []IDataTypeContext + DataType(i int) IDataTypeContext + AllSyntaxComma() []ISyntaxCommaContext + SyntaxComma(i int) ISyntaxCommaContext + + // IsAlterTableColumnDefinitionContext differentiates from other interfaces. + IsAlterTableColumnDefinitionContext() +} + +type AlterTableColumnDefinitionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlterTableColumnDefinitionContext() *AlterTableColumnDefinitionContext { + var p = new(AlterTableColumnDefinitionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_alterTableColumnDefinition + return p +} + +func InitEmptyAlterTableColumnDefinitionContext(p *AlterTableColumnDefinitionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_alterTableColumnDefinition +} + +func (*AlterTableColumnDefinitionContext) IsAlterTableColumnDefinitionContext() {} + +func NewAlterTableColumnDefinitionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AlterTableColumnDefinitionContext { + var p = new(AlterTableColumnDefinitionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_alterTableColumnDefinition + + return p +} + +func (s *AlterTableColumnDefinitionContext) GetParser() antlr.Parser { return s.parser } + +func (s *AlterTableColumnDefinitionContext) AllColumn() []IColumnContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IColumnContext); ok { + len++ + } + } + + tst := make([]IColumnContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IColumnContext); ok { + tst[i] = t.(IColumnContext) + i++ + } + } + + return tst +} + +func (s *AlterTableColumnDefinitionContext) Column(i int) IColumnContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumnContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IColumnContext) +} + +func (s *AlterTableColumnDefinitionContext) AllDataType() []IDataTypeContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IDataTypeContext); ok { + len++ + } + } + + tst := make([]IDataTypeContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IDataTypeContext); ok { + tst[i] = t.(IDataTypeContext) + i++ + } + } + + return tst +} + +func (s *AlterTableColumnDefinitionContext) DataType(i int) IDataTypeContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDataTypeContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IDataTypeContext) +} + +func (s *AlterTableColumnDefinitionContext) AllSyntaxComma() []ISyntaxCommaContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISyntaxCommaContext); ok { + len++ + } + } + + tst := make([]ISyntaxCommaContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISyntaxCommaContext); ok { + tst[i] = t.(ISyntaxCommaContext) + i++ + } + } + + return tst +} + +func (s *AlterTableColumnDefinitionContext) SyntaxComma(i int) ISyntaxCommaContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISyntaxCommaContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISyntaxCommaContext) +} + +func (s *AlterTableColumnDefinitionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AlterTableColumnDefinitionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *AlterTableColumnDefinitionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterAlterTableColumnDefinition(s) + } +} + +func (s *AlterTableColumnDefinitionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitAlterTableColumnDefinition(s) + } +} + +func (s *AlterTableColumnDefinitionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitAlterTableColumnDefinition(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) AlterTableColumnDefinition() (localctx IAlterTableColumnDefinitionContext) { + localctx = NewAlterTableColumnDefinitionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 102, CqlParserRULE_alterTableColumnDefinition) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1089) + p.Column() + } + { + p.SetState(1090) + p.DataType() + } + p.SetState(1097) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == CqlParserCOMMA { + { + p.SetState(1091) + p.SyntaxComma() + } + { + p.SetState(1092) + p.Column() + } + { + p.SetState(1093) + p.DataType() + } + + p.SetState(1099) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlterRoleContext is an interface to support dynamic dispatch. +type IAlterRoleContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + KwAlter() IKwAlterContext + KwRole() IKwRoleContext + Role() IRoleContext + RoleWith() IRoleWithContext + + // IsAlterRoleContext differentiates from other interfaces. + IsAlterRoleContext() +} + +type AlterRoleContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlterRoleContext() *AlterRoleContext { + var p = new(AlterRoleContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_alterRole + return p +} + +func InitEmptyAlterRoleContext(p *AlterRoleContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_alterRole +} + +func (*AlterRoleContext) IsAlterRoleContext() {} + +func NewAlterRoleContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AlterRoleContext { + var p = new(AlterRoleContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_alterRole + + return p +} + +func (s *AlterRoleContext) GetParser() antlr.Parser { return s.parser } + +func (s *AlterRoleContext) KwAlter() IKwAlterContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwAlterContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwAlterContext) +} + +func (s *AlterRoleContext) KwRole() IKwRoleContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwRoleContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwRoleContext) +} + +func (s *AlterRoleContext) Role() IRoleContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRoleContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRoleContext) +} + +func (s *AlterRoleContext) RoleWith() IRoleWithContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRoleWithContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRoleWithContext) +} + +func (s *AlterRoleContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AlterRoleContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *AlterRoleContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterAlterRole(s) + } +} + +func (s *AlterRoleContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitAlterRole(s) + } +} + +func (s *AlterRoleContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitAlterRole(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) AlterRole() (localctx IAlterRoleContext) { + localctx = NewAlterRoleContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 104, CqlParserRULE_alterRole) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1100) + p.KwAlter() + } + { + p.SetState(1101) + p.KwRole() + } + { + p.SetState(1102) + p.Role() + } + p.SetState(1104) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == CqlParserK_WITH { + { + p.SetState(1103) + p.RoleWith() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IRoleWithContext is an interface to support dynamic dispatch. +type IRoleWithContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + KwWith() IKwWithContext + AllRoleWithOptions() []IRoleWithOptionsContext + RoleWithOptions(i int) IRoleWithOptionsContext + AllKwAnd() []IKwAndContext + KwAnd(i int) IKwAndContext + + // IsRoleWithContext differentiates from other interfaces. + IsRoleWithContext() +} + +type RoleWithContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRoleWithContext() *RoleWithContext { + var p = new(RoleWithContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_roleWith + return p +} + +func InitEmptyRoleWithContext(p *RoleWithContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_roleWith +} + +func (*RoleWithContext) IsRoleWithContext() {} + +func NewRoleWithContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *RoleWithContext { + var p = new(RoleWithContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_roleWith + + return p +} + +func (s *RoleWithContext) GetParser() antlr.Parser { return s.parser } + +func (s *RoleWithContext) KwWith() IKwWithContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwWithContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwWithContext) +} + +func (s *RoleWithContext) AllRoleWithOptions() []IRoleWithOptionsContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IRoleWithOptionsContext); ok { + len++ + } + } + + tst := make([]IRoleWithOptionsContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IRoleWithOptionsContext); ok { + tst[i] = t.(IRoleWithOptionsContext) + i++ + } + } + + return tst +} + +func (s *RoleWithContext) RoleWithOptions(i int) IRoleWithOptionsContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRoleWithOptionsContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IRoleWithOptionsContext) +} + +func (s *RoleWithContext) AllKwAnd() []IKwAndContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IKwAndContext); ok { + len++ + } + } + + tst := make([]IKwAndContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IKwAndContext); ok { + tst[i] = t.(IKwAndContext) + i++ + } + } + + return tst +} + +func (s *RoleWithContext) KwAnd(i int) IKwAndContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwAndContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IKwAndContext) +} + +func (s *RoleWithContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *RoleWithContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *RoleWithContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterRoleWith(s) + } +} + +func (s *RoleWithContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitRoleWith(s) + } +} + +func (s *RoleWithContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitRoleWith(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) RoleWith() (localctx IRoleWithContext) { + localctx = NewRoleWithContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 106, CqlParserRULE_roleWith) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1106) + p.KwWith() + } + + { + p.SetState(1107) + p.RoleWithOptions() + } + p.SetState(1113) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == CqlParserK_AND { + { + p.SetState(1108) + p.KwAnd() + } + { + p.SetState(1109) + p.RoleWithOptions() + } + + p.SetState(1115) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IRoleWithOptionsContext is an interface to support dynamic dispatch. +type IRoleWithOptionsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + KwPassword() IKwPasswordContext + OPERATOR_EQ() antlr.TerminalNode + StringLiteral() IStringLiteralContext + KwLogin() IKwLoginContext + BooleanLiteral() IBooleanLiteralContext + KwSuperuser() IKwSuperuserContext + KwOptions() IKwOptionsContext + OptionHash() IOptionHashContext + + // IsRoleWithOptionsContext differentiates from other interfaces. + IsRoleWithOptionsContext() +} + +type RoleWithOptionsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRoleWithOptionsContext() *RoleWithOptionsContext { + var p = new(RoleWithOptionsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_roleWithOptions + return p +} + +func InitEmptyRoleWithOptionsContext(p *RoleWithOptionsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_roleWithOptions +} + +func (*RoleWithOptionsContext) IsRoleWithOptionsContext() {} + +func NewRoleWithOptionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *RoleWithOptionsContext { + var p = new(RoleWithOptionsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_roleWithOptions + + return p +} + +func (s *RoleWithOptionsContext) GetParser() antlr.Parser { return s.parser } + +func (s *RoleWithOptionsContext) KwPassword() IKwPasswordContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwPasswordContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwPasswordContext) +} + +func (s *RoleWithOptionsContext) OPERATOR_EQ() antlr.TerminalNode { + return s.GetToken(CqlParserOPERATOR_EQ, 0) +} + +func (s *RoleWithOptionsContext) StringLiteral() IStringLiteralContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStringLiteralContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStringLiteralContext) +} + +func (s *RoleWithOptionsContext) KwLogin() IKwLoginContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwLoginContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwLoginContext) +} + +func (s *RoleWithOptionsContext) BooleanLiteral() IBooleanLiteralContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IBooleanLiteralContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IBooleanLiteralContext) +} + +func (s *RoleWithOptionsContext) KwSuperuser() IKwSuperuserContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwSuperuserContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwSuperuserContext) +} + +func (s *RoleWithOptionsContext) KwOptions() IKwOptionsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwOptionsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwOptionsContext) +} + +func (s *RoleWithOptionsContext) OptionHash() IOptionHashContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOptionHashContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOptionHashContext) +} + +func (s *RoleWithOptionsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *RoleWithOptionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *RoleWithOptionsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterRoleWithOptions(s) + } +} + +func (s *RoleWithOptionsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitRoleWithOptions(s) + } +} + +func (s *RoleWithOptionsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitRoleWithOptions(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) RoleWithOptions() (localctx IRoleWithOptionsContext) { + localctx = NewRoleWithOptionsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 108, CqlParserRULE_roleWithOptions) + p.SetState(1132) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case CqlParserK_PASSWORD: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1116) + p.KwPassword() + } + { + p.SetState(1117) + p.Match(CqlParserOPERATOR_EQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1118) + p.StringLiteral() + } + + case CqlParserK_LOGIN: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(1120) + p.KwLogin() + } + { + p.SetState(1121) + p.Match(CqlParserOPERATOR_EQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1122) + p.BooleanLiteral() + } + + case CqlParserK_SUPERUSER: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(1124) + p.KwSuperuser() + } + { + p.SetState(1125) + p.Match(CqlParserOPERATOR_EQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1126) + p.BooleanLiteral() + } + + case CqlParserK_OPTIONS: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(1128) + p.KwOptions() + } + { + p.SetState(1129) + p.Match(CqlParserOPERATOR_EQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1130) + p.OptionHash() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlterMaterializedViewContext is an interface to support dynamic dispatch. +type IAlterMaterializedViewContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + KwAlter() IKwAlterContext + KwMaterialized() IKwMaterializedContext + KwView() IKwViewContext + MaterializedView() IMaterializedViewContext + Keyspace() IKeyspaceContext + DOT() antlr.TerminalNode + KwWith() IKwWithContext + TableOptions() ITableOptionsContext + + // IsAlterMaterializedViewContext differentiates from other interfaces. + IsAlterMaterializedViewContext() +} + +type AlterMaterializedViewContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlterMaterializedViewContext() *AlterMaterializedViewContext { + var p = new(AlterMaterializedViewContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_alterMaterializedView + return p +} + +func InitEmptyAlterMaterializedViewContext(p *AlterMaterializedViewContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_alterMaterializedView +} + +func (*AlterMaterializedViewContext) IsAlterMaterializedViewContext() {} + +func NewAlterMaterializedViewContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AlterMaterializedViewContext { + var p = new(AlterMaterializedViewContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_alterMaterializedView + + return p +} + +func (s *AlterMaterializedViewContext) GetParser() antlr.Parser { return s.parser } + +func (s *AlterMaterializedViewContext) KwAlter() IKwAlterContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwAlterContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwAlterContext) +} + +func (s *AlterMaterializedViewContext) KwMaterialized() IKwMaterializedContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwMaterializedContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwMaterializedContext) +} + +func (s *AlterMaterializedViewContext) KwView() IKwViewContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwViewContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwViewContext) +} + +func (s *AlterMaterializedViewContext) MaterializedView() IMaterializedViewContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMaterializedViewContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMaterializedViewContext) +} + +func (s *AlterMaterializedViewContext) Keyspace() IKeyspaceContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKeyspaceContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKeyspaceContext) +} + +func (s *AlterMaterializedViewContext) DOT() antlr.TerminalNode { + return s.GetToken(CqlParserDOT, 0) +} + +func (s *AlterMaterializedViewContext) KwWith() IKwWithContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwWithContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwWithContext) +} + +func (s *AlterMaterializedViewContext) TableOptions() ITableOptionsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITableOptionsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITableOptionsContext) +} + +func (s *AlterMaterializedViewContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AlterMaterializedViewContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *AlterMaterializedViewContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterAlterMaterializedView(s) + } +} + +func (s *AlterMaterializedViewContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitAlterMaterializedView(s) + } +} + +func (s *AlterMaterializedViewContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitAlterMaterializedView(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) AlterMaterializedView() (localctx IAlterMaterializedViewContext) { + localctx = NewAlterMaterializedViewContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 110, CqlParserRULE_alterMaterializedView) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1134) + p.KwAlter() + } + { + p.SetState(1135) + p.KwMaterialized() + } + { + p.SetState(1136) + p.KwView() + } + p.SetState(1140) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 64, p.GetParserRuleContext()) == 1 { + { + p.SetState(1137) + p.Keyspace() + } + { + p.SetState(1138) + p.Match(CqlParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(1142) + p.MaterializedView() + } + p.SetState(1146) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == CqlParserK_WITH { + { + p.SetState(1143) + p.KwWith() + } + { + p.SetState(1144) + p.TableOptions() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDropUserContext is an interface to support dynamic dispatch. +type IDropUserContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + KwDrop() IKwDropContext + KwUser() IKwUserContext + User() IUserContext + IfExist() IIfExistContext + + // IsDropUserContext differentiates from other interfaces. + IsDropUserContext() +} + +type DropUserContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDropUserContext() *DropUserContext { + var p = new(DropUserContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_dropUser + return p +} + +func InitEmptyDropUserContext(p *DropUserContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_dropUser +} + +func (*DropUserContext) IsDropUserContext() {} + +func NewDropUserContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DropUserContext { + var p = new(DropUserContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_dropUser + + return p +} + +func (s *DropUserContext) GetParser() antlr.Parser { return s.parser } + +func (s *DropUserContext) KwDrop() IKwDropContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwDropContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwDropContext) +} + +func (s *DropUserContext) KwUser() IKwUserContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwUserContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwUserContext) +} + +func (s *DropUserContext) User() IUserContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUserContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUserContext) +} + +func (s *DropUserContext) IfExist() IIfExistContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIfExistContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIfExistContext) +} + +func (s *DropUserContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *DropUserContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *DropUserContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterDropUser(s) + } +} + +func (s *DropUserContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitDropUser(s) + } +} + +func (s *DropUserContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitDropUser(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) DropUser() (localctx IDropUserContext) { + localctx = NewDropUserContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 112, CqlParserRULE_dropUser) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1148) + p.KwDrop() + } + { + p.SetState(1149) + p.KwUser() + } + p.SetState(1151) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == CqlParserK_IF { + { + p.SetState(1150) + p.IfExist() + } + + } + { + p.SetState(1153) + p.User() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDropTypeContext is an interface to support dynamic dispatch. +type IDropTypeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + KwDrop() IKwDropContext + KwType() IKwTypeContext + Type_() IType_Context + IfExist() IIfExistContext + Keyspace() IKeyspaceContext + DOT() antlr.TerminalNode + + // IsDropTypeContext differentiates from other interfaces. + IsDropTypeContext() +} + +type DropTypeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDropTypeContext() *DropTypeContext { + var p = new(DropTypeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_dropType + return p +} + +func InitEmptyDropTypeContext(p *DropTypeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_dropType +} + +func (*DropTypeContext) IsDropTypeContext() {} + +func NewDropTypeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DropTypeContext { + var p = new(DropTypeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_dropType + + return p +} + +func (s *DropTypeContext) GetParser() antlr.Parser { return s.parser } + +func (s *DropTypeContext) KwDrop() IKwDropContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwDropContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwDropContext) +} + +func (s *DropTypeContext) KwType() IKwTypeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwTypeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwTypeContext) +} + +func (s *DropTypeContext) Type_() IType_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IType_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IType_Context) +} + +func (s *DropTypeContext) IfExist() IIfExistContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIfExistContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIfExistContext) +} + +func (s *DropTypeContext) Keyspace() IKeyspaceContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKeyspaceContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKeyspaceContext) +} + +func (s *DropTypeContext) DOT() antlr.TerminalNode { + return s.GetToken(CqlParserDOT, 0) +} + +func (s *DropTypeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *DropTypeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *DropTypeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterDropType(s) + } +} + +func (s *DropTypeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitDropType(s) + } +} + +func (s *DropTypeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitDropType(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) DropType() (localctx IDropTypeContext) { + localctx = NewDropTypeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 114, CqlParserRULE_dropType) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1155) + p.KwDrop() + } + { + p.SetState(1156) + p.KwType() + } + p.SetState(1158) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == CqlParserK_IF { + { + p.SetState(1157) + p.IfExist() + } + + } + p.SetState(1163) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 68, p.GetParserRuleContext()) == 1 { + { + p.SetState(1160) + p.Keyspace() + } + { + p.SetState(1161) + p.Match(CqlParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(1165) + p.Type_() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDropMaterializedViewContext is an interface to support dynamic dispatch. +type IDropMaterializedViewContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + KwDrop() IKwDropContext + KwMaterialized() IKwMaterializedContext + KwView() IKwViewContext + MaterializedView() IMaterializedViewContext + IfExist() IIfExistContext + Keyspace() IKeyspaceContext + DOT() antlr.TerminalNode + + // IsDropMaterializedViewContext differentiates from other interfaces. + IsDropMaterializedViewContext() +} + +type DropMaterializedViewContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDropMaterializedViewContext() *DropMaterializedViewContext { + var p = new(DropMaterializedViewContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_dropMaterializedView + return p +} + +func InitEmptyDropMaterializedViewContext(p *DropMaterializedViewContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_dropMaterializedView +} + +func (*DropMaterializedViewContext) IsDropMaterializedViewContext() {} + +func NewDropMaterializedViewContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DropMaterializedViewContext { + var p = new(DropMaterializedViewContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_dropMaterializedView + + return p +} + +func (s *DropMaterializedViewContext) GetParser() antlr.Parser { return s.parser } + +func (s *DropMaterializedViewContext) KwDrop() IKwDropContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwDropContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwDropContext) +} + +func (s *DropMaterializedViewContext) KwMaterialized() IKwMaterializedContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwMaterializedContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwMaterializedContext) +} + +func (s *DropMaterializedViewContext) KwView() IKwViewContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwViewContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwViewContext) +} + +func (s *DropMaterializedViewContext) MaterializedView() IMaterializedViewContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMaterializedViewContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMaterializedViewContext) +} + +func (s *DropMaterializedViewContext) IfExist() IIfExistContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIfExistContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIfExistContext) +} + +func (s *DropMaterializedViewContext) Keyspace() IKeyspaceContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKeyspaceContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKeyspaceContext) +} + +func (s *DropMaterializedViewContext) DOT() antlr.TerminalNode { + return s.GetToken(CqlParserDOT, 0) +} + +func (s *DropMaterializedViewContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *DropMaterializedViewContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *DropMaterializedViewContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterDropMaterializedView(s) + } +} + +func (s *DropMaterializedViewContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitDropMaterializedView(s) + } +} + +func (s *DropMaterializedViewContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitDropMaterializedView(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) DropMaterializedView() (localctx IDropMaterializedViewContext) { + localctx = NewDropMaterializedViewContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 116, CqlParserRULE_dropMaterializedView) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1167) + p.KwDrop() + } + { + p.SetState(1168) + p.KwMaterialized() + } + { + p.SetState(1169) + p.KwView() + } + p.SetState(1171) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == CqlParserK_IF { + { + p.SetState(1170) + p.IfExist() + } + + } + p.SetState(1176) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 70, p.GetParserRuleContext()) == 1 { + { + p.SetState(1173) + p.Keyspace() + } + { + p.SetState(1174) + p.Match(CqlParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(1178) + p.MaterializedView() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDropAggregateContext is an interface to support dynamic dispatch. +type IDropAggregateContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + KwDrop() IKwDropContext + KwAggregate() IKwAggregateContext + Aggregate() IAggregateContext + IfExist() IIfExistContext + Keyspace() IKeyspaceContext + DOT() antlr.TerminalNode + + // IsDropAggregateContext differentiates from other interfaces. + IsDropAggregateContext() +} + +type DropAggregateContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDropAggregateContext() *DropAggregateContext { + var p = new(DropAggregateContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_dropAggregate + return p +} + +func InitEmptyDropAggregateContext(p *DropAggregateContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_dropAggregate +} + +func (*DropAggregateContext) IsDropAggregateContext() {} + +func NewDropAggregateContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DropAggregateContext { + var p = new(DropAggregateContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_dropAggregate + + return p +} + +func (s *DropAggregateContext) GetParser() antlr.Parser { return s.parser } + +func (s *DropAggregateContext) KwDrop() IKwDropContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwDropContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwDropContext) +} + +func (s *DropAggregateContext) KwAggregate() IKwAggregateContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwAggregateContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwAggregateContext) +} + +func (s *DropAggregateContext) Aggregate() IAggregateContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAggregateContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAggregateContext) +} + +func (s *DropAggregateContext) IfExist() IIfExistContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIfExistContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIfExistContext) +} + +func (s *DropAggregateContext) Keyspace() IKeyspaceContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKeyspaceContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKeyspaceContext) +} + +func (s *DropAggregateContext) DOT() antlr.TerminalNode { + return s.GetToken(CqlParserDOT, 0) +} + +func (s *DropAggregateContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *DropAggregateContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *DropAggregateContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterDropAggregate(s) + } +} + +func (s *DropAggregateContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitDropAggregate(s) + } +} + +func (s *DropAggregateContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitDropAggregate(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) DropAggregate() (localctx IDropAggregateContext) { + localctx = NewDropAggregateContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 118, CqlParserRULE_dropAggregate) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1180) + p.KwDrop() + } + { + p.SetState(1181) + p.KwAggregate() + } + p.SetState(1183) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == CqlParserK_IF { + { + p.SetState(1182) + p.IfExist() + } + + } + p.SetState(1188) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 72, p.GetParserRuleContext()) == 1 { + { + p.SetState(1185) + p.Keyspace() + } + { + p.SetState(1186) + p.Match(CqlParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(1190) + p.Aggregate() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDropFunctionContext is an interface to support dynamic dispatch. +type IDropFunctionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + KwDrop() IKwDropContext + KwFunction() IKwFunctionContext + Function_() IFunction_Context + IfExist() IIfExistContext + Keyspace() IKeyspaceContext + DOT() antlr.TerminalNode + + // IsDropFunctionContext differentiates from other interfaces. + IsDropFunctionContext() +} + +type DropFunctionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDropFunctionContext() *DropFunctionContext { + var p = new(DropFunctionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_dropFunction + return p +} + +func InitEmptyDropFunctionContext(p *DropFunctionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_dropFunction +} + +func (*DropFunctionContext) IsDropFunctionContext() {} + +func NewDropFunctionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DropFunctionContext { + var p = new(DropFunctionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_dropFunction + + return p +} + +func (s *DropFunctionContext) GetParser() antlr.Parser { return s.parser } + +func (s *DropFunctionContext) KwDrop() IKwDropContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwDropContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwDropContext) +} + +func (s *DropFunctionContext) KwFunction() IKwFunctionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwFunctionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwFunctionContext) +} + +func (s *DropFunctionContext) Function_() IFunction_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunction_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFunction_Context) +} + +func (s *DropFunctionContext) IfExist() IIfExistContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIfExistContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIfExistContext) +} + +func (s *DropFunctionContext) Keyspace() IKeyspaceContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKeyspaceContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKeyspaceContext) +} + +func (s *DropFunctionContext) DOT() antlr.TerminalNode { + return s.GetToken(CqlParserDOT, 0) +} + +func (s *DropFunctionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *DropFunctionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *DropFunctionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterDropFunction(s) + } +} + +func (s *DropFunctionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitDropFunction(s) + } +} + +func (s *DropFunctionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitDropFunction(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) DropFunction() (localctx IDropFunctionContext) { + localctx = NewDropFunctionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 120, CqlParserRULE_dropFunction) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1192) + p.KwDrop() + } + { + p.SetState(1193) + p.KwFunction() + } + p.SetState(1195) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == CqlParserK_IF { + { + p.SetState(1194) + p.IfExist() + } + + } + p.SetState(1200) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 74, p.GetParserRuleContext()) == 1 { + { + p.SetState(1197) + p.Keyspace() + } + { + p.SetState(1198) + p.Match(CqlParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(1202) + p.Function_() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDropTriggerContext is an interface to support dynamic dispatch. +type IDropTriggerContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + KwDrop() IKwDropContext + KwTrigger() IKwTriggerContext + Trigger() ITriggerContext + KwOn() IKwOnContext + Table() ITableContext + IfExist() IIfExistContext + Keyspace() IKeyspaceContext + DOT() antlr.TerminalNode + + // IsDropTriggerContext differentiates from other interfaces. + IsDropTriggerContext() +} + +type DropTriggerContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDropTriggerContext() *DropTriggerContext { + var p = new(DropTriggerContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_dropTrigger + return p +} + +func InitEmptyDropTriggerContext(p *DropTriggerContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_dropTrigger +} + +func (*DropTriggerContext) IsDropTriggerContext() {} + +func NewDropTriggerContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DropTriggerContext { + var p = new(DropTriggerContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_dropTrigger + + return p +} + +func (s *DropTriggerContext) GetParser() antlr.Parser { return s.parser } + +func (s *DropTriggerContext) KwDrop() IKwDropContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwDropContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwDropContext) +} + +func (s *DropTriggerContext) KwTrigger() IKwTriggerContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwTriggerContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwTriggerContext) +} + +func (s *DropTriggerContext) Trigger() ITriggerContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITriggerContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITriggerContext) +} + +func (s *DropTriggerContext) KwOn() IKwOnContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwOnContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwOnContext) +} + +func (s *DropTriggerContext) Table() ITableContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITableContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITableContext) +} + +func (s *DropTriggerContext) IfExist() IIfExistContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIfExistContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIfExistContext) +} + +func (s *DropTriggerContext) Keyspace() IKeyspaceContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKeyspaceContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKeyspaceContext) +} + +func (s *DropTriggerContext) DOT() antlr.TerminalNode { + return s.GetToken(CqlParserDOT, 0) +} + +func (s *DropTriggerContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *DropTriggerContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *DropTriggerContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterDropTrigger(s) + } +} + +func (s *DropTriggerContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitDropTrigger(s) + } +} + +func (s *DropTriggerContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitDropTrigger(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) DropTrigger() (localctx IDropTriggerContext) { + localctx = NewDropTriggerContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 122, CqlParserRULE_dropTrigger) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1204) + p.KwDrop() + } + { + p.SetState(1205) + p.KwTrigger() + } + p.SetState(1207) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == CqlParserK_IF { + { + p.SetState(1206) + p.IfExist() + } + + } + { + p.SetState(1209) + p.Trigger() + } + { + p.SetState(1210) + p.KwOn() + } + p.SetState(1214) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 76, p.GetParserRuleContext()) == 1 { + { + p.SetState(1211) + p.Keyspace() + } + { + p.SetState(1212) + p.Match(CqlParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(1216) + p.Table() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDropRoleContext is an interface to support dynamic dispatch. +type IDropRoleContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + KwDrop() IKwDropContext + KwRole() IKwRoleContext + Role() IRoleContext + IfExist() IIfExistContext + + // IsDropRoleContext differentiates from other interfaces. + IsDropRoleContext() +} + +type DropRoleContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDropRoleContext() *DropRoleContext { + var p = new(DropRoleContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_dropRole + return p +} + +func InitEmptyDropRoleContext(p *DropRoleContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_dropRole +} + +func (*DropRoleContext) IsDropRoleContext() {} + +func NewDropRoleContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DropRoleContext { + var p = new(DropRoleContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_dropRole + + return p +} + +func (s *DropRoleContext) GetParser() antlr.Parser { return s.parser } + +func (s *DropRoleContext) KwDrop() IKwDropContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwDropContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwDropContext) +} + +func (s *DropRoleContext) KwRole() IKwRoleContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwRoleContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwRoleContext) +} + +func (s *DropRoleContext) Role() IRoleContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRoleContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRoleContext) +} + +func (s *DropRoleContext) IfExist() IIfExistContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIfExistContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIfExistContext) +} + +func (s *DropRoleContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *DropRoleContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *DropRoleContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterDropRole(s) + } +} + +func (s *DropRoleContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitDropRole(s) + } +} + +func (s *DropRoleContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitDropRole(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) DropRole() (localctx IDropRoleContext) { + localctx = NewDropRoleContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 124, CqlParserRULE_dropRole) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1218) + p.KwDrop() + } + { + p.SetState(1219) + p.KwRole() + } + p.SetState(1221) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == CqlParserK_IF { + { + p.SetState(1220) + p.IfExist() + } + + } + { + p.SetState(1223) + p.Role() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDropTableContext is an interface to support dynamic dispatch. +type IDropTableContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + KwDrop() IKwDropContext + KwTable() IKwTableContext + Table() ITableContext + IfExist() IIfExistContext + Keyspace() IKeyspaceContext + DOT() antlr.TerminalNode + + // IsDropTableContext differentiates from other interfaces. + IsDropTableContext() +} + +type DropTableContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDropTableContext() *DropTableContext { + var p = new(DropTableContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_dropTable + return p +} + +func InitEmptyDropTableContext(p *DropTableContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_dropTable +} + +func (*DropTableContext) IsDropTableContext() {} + +func NewDropTableContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DropTableContext { + var p = new(DropTableContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_dropTable + + return p +} + +func (s *DropTableContext) GetParser() antlr.Parser { return s.parser } + +func (s *DropTableContext) KwDrop() IKwDropContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwDropContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwDropContext) +} + +func (s *DropTableContext) KwTable() IKwTableContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwTableContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwTableContext) +} + +func (s *DropTableContext) Table() ITableContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITableContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITableContext) +} + +func (s *DropTableContext) IfExist() IIfExistContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIfExistContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIfExistContext) +} + +func (s *DropTableContext) Keyspace() IKeyspaceContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKeyspaceContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKeyspaceContext) +} + +func (s *DropTableContext) DOT() antlr.TerminalNode { + return s.GetToken(CqlParserDOT, 0) +} + +func (s *DropTableContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *DropTableContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *DropTableContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterDropTable(s) + } +} + +func (s *DropTableContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitDropTable(s) + } +} + +func (s *DropTableContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitDropTable(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) DropTable() (localctx IDropTableContext) { + localctx = NewDropTableContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 126, CqlParserRULE_dropTable) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1225) + p.KwDrop() + } + { + p.SetState(1226) + p.KwTable() + } + p.SetState(1228) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == CqlParserK_IF { + { + p.SetState(1227) + p.IfExist() + } + + } + p.SetState(1233) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 79, p.GetParserRuleContext()) == 1 { + { + p.SetState(1230) + p.Keyspace() + } + { + p.SetState(1231) + p.Match(CqlParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(1235) + p.Table() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDropKeyspaceContext is an interface to support dynamic dispatch. +type IDropKeyspaceContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + KwDrop() IKwDropContext + KwKeyspace() IKwKeyspaceContext + Keyspace() IKeyspaceContext + IfExist() IIfExistContext + + // IsDropKeyspaceContext differentiates from other interfaces. + IsDropKeyspaceContext() +} + +type DropKeyspaceContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDropKeyspaceContext() *DropKeyspaceContext { + var p = new(DropKeyspaceContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_dropKeyspace + return p +} + +func InitEmptyDropKeyspaceContext(p *DropKeyspaceContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_dropKeyspace +} + +func (*DropKeyspaceContext) IsDropKeyspaceContext() {} + +func NewDropKeyspaceContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DropKeyspaceContext { + var p = new(DropKeyspaceContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_dropKeyspace + + return p +} + +func (s *DropKeyspaceContext) GetParser() antlr.Parser { return s.parser } + +func (s *DropKeyspaceContext) KwDrop() IKwDropContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwDropContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwDropContext) +} + +func (s *DropKeyspaceContext) KwKeyspace() IKwKeyspaceContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwKeyspaceContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwKeyspaceContext) +} + +func (s *DropKeyspaceContext) Keyspace() IKeyspaceContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKeyspaceContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKeyspaceContext) +} + +func (s *DropKeyspaceContext) IfExist() IIfExistContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIfExistContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIfExistContext) +} + +func (s *DropKeyspaceContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *DropKeyspaceContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *DropKeyspaceContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterDropKeyspace(s) + } +} + +func (s *DropKeyspaceContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitDropKeyspace(s) + } +} + +func (s *DropKeyspaceContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitDropKeyspace(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) DropKeyspace() (localctx IDropKeyspaceContext) { + localctx = NewDropKeyspaceContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 128, CqlParserRULE_dropKeyspace) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1237) + p.KwDrop() + } + { + p.SetState(1238) + p.KwKeyspace() + } + p.SetState(1240) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == CqlParserK_IF { + { + p.SetState(1239) + p.IfExist() + } + + } + { + p.SetState(1242) + p.Keyspace() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDropIndexContext is an interface to support dynamic dispatch. +type IDropIndexContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + KwDrop() IKwDropContext + KwIndex() IKwIndexContext + IndexName() IIndexNameContext + IfExist() IIfExistContext + Keyspace() IKeyspaceContext + DOT() antlr.TerminalNode + + // IsDropIndexContext differentiates from other interfaces. + IsDropIndexContext() +} + +type DropIndexContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDropIndexContext() *DropIndexContext { + var p = new(DropIndexContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_dropIndex + return p +} + +func InitEmptyDropIndexContext(p *DropIndexContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_dropIndex +} + +func (*DropIndexContext) IsDropIndexContext() {} + +func NewDropIndexContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DropIndexContext { + var p = new(DropIndexContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_dropIndex + + return p +} + +func (s *DropIndexContext) GetParser() antlr.Parser { return s.parser } + +func (s *DropIndexContext) KwDrop() IKwDropContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwDropContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwDropContext) +} + +func (s *DropIndexContext) KwIndex() IKwIndexContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwIndexContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwIndexContext) +} + +func (s *DropIndexContext) IndexName() IIndexNameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIndexNameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIndexNameContext) +} + +func (s *DropIndexContext) IfExist() IIfExistContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIfExistContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIfExistContext) +} + +func (s *DropIndexContext) Keyspace() IKeyspaceContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKeyspaceContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKeyspaceContext) +} + +func (s *DropIndexContext) DOT() antlr.TerminalNode { + return s.GetToken(CqlParserDOT, 0) +} + +func (s *DropIndexContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *DropIndexContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *DropIndexContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterDropIndex(s) + } +} + +func (s *DropIndexContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitDropIndex(s) + } +} + +func (s *DropIndexContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitDropIndex(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) DropIndex() (localctx IDropIndexContext) { + localctx = NewDropIndexContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 130, CqlParserRULE_dropIndex) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1244) + p.KwDrop() + } + { + p.SetState(1245) + p.KwIndex() + } + p.SetState(1247) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == CqlParserK_IF { + { + p.SetState(1246) + p.IfExist() + } + + } + p.SetState(1252) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 82, p.GetParserRuleContext()) == 1 { + { + p.SetState(1249) + p.Keyspace() + } + { + p.SetState(1250) + p.Match(CqlParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(1254) + p.IndexName() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreateTableContext is an interface to support dynamic dispatch. +type ICreateTableContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + KwCreate() IKwCreateContext + KwTable() IKwTableContext + Table() ITableContext + SyntaxBracketLr() ISyntaxBracketLrContext + ColumnDefinitionList() IColumnDefinitionListContext + SyntaxBracketRr() ISyntaxBracketRrContext + IfNotExist() IIfNotExistContext + Keyspace() IKeyspaceContext + DOT() antlr.TerminalNode + WithElement() IWithElementContext + + // IsCreateTableContext differentiates from other interfaces. + IsCreateTableContext() +} + +type CreateTableContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreateTableContext() *CreateTableContext { + var p = new(CreateTableContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_createTable + return p +} + +func InitEmptyCreateTableContext(p *CreateTableContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_createTable +} + +func (*CreateTableContext) IsCreateTableContext() {} + +func NewCreateTableContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CreateTableContext { + var p = new(CreateTableContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_createTable + + return p +} + +func (s *CreateTableContext) GetParser() antlr.Parser { return s.parser } + +func (s *CreateTableContext) KwCreate() IKwCreateContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwCreateContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwCreateContext) +} + +func (s *CreateTableContext) KwTable() IKwTableContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwTableContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwTableContext) +} + +func (s *CreateTableContext) Table() ITableContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITableContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITableContext) +} + +func (s *CreateTableContext) SyntaxBracketLr() ISyntaxBracketLrContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISyntaxBracketLrContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISyntaxBracketLrContext) +} + +func (s *CreateTableContext) ColumnDefinitionList() IColumnDefinitionListContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumnDefinitionListContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumnDefinitionListContext) +} + +func (s *CreateTableContext) SyntaxBracketRr() ISyntaxBracketRrContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISyntaxBracketRrContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISyntaxBracketRrContext) +} + +func (s *CreateTableContext) IfNotExist() IIfNotExistContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIfNotExistContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIfNotExistContext) +} + +func (s *CreateTableContext) Keyspace() IKeyspaceContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKeyspaceContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKeyspaceContext) +} + +func (s *CreateTableContext) DOT() antlr.TerminalNode { + return s.GetToken(CqlParserDOT, 0) +} + +func (s *CreateTableContext) WithElement() IWithElementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWithElementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWithElementContext) +} + +func (s *CreateTableContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CreateTableContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *CreateTableContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterCreateTable(s) + } +} + +func (s *CreateTableContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitCreateTable(s) + } +} + +func (s *CreateTableContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitCreateTable(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) CreateTable() (localctx ICreateTableContext) { + localctx = NewCreateTableContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 132, CqlParserRULE_createTable) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1256) + p.KwCreate() + } + { + p.SetState(1257) + p.KwTable() + } + p.SetState(1259) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == CqlParserK_IF { + { + p.SetState(1258) + p.IfNotExist() + } + + } + p.SetState(1264) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 84, p.GetParserRuleContext()) == 1 { + { + p.SetState(1261) + p.Keyspace() + } + { + p.SetState(1262) + p.Match(CqlParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(1266) + p.Table() + } + { + p.SetState(1267) + p.SyntaxBracketLr() + } + { + p.SetState(1268) + p.ColumnDefinitionList() + } + { + p.SetState(1269) + p.SyntaxBracketRr() + } + p.SetState(1271) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == CqlParserK_WITH { + { + p.SetState(1270) + p.WithElement() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IWithElementContext is an interface to support dynamic dispatch. +type IWithElementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + KwWith() IKwWithContext + TableOptions() ITableOptionsContext + + // IsWithElementContext differentiates from other interfaces. + IsWithElementContext() +} + +type WithElementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyWithElementContext() *WithElementContext { + var p = new(WithElementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_withElement + return p +} + +func InitEmptyWithElementContext(p *WithElementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_withElement +} + +func (*WithElementContext) IsWithElementContext() {} + +func NewWithElementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *WithElementContext { + var p = new(WithElementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_withElement + + return p +} + +func (s *WithElementContext) GetParser() antlr.Parser { return s.parser } + +func (s *WithElementContext) KwWith() IKwWithContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwWithContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwWithContext) +} + +func (s *WithElementContext) TableOptions() ITableOptionsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITableOptionsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITableOptionsContext) +} + +func (s *WithElementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *WithElementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *WithElementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterWithElement(s) + } +} + +func (s *WithElementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitWithElement(s) + } +} + +func (s *WithElementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitWithElement(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) WithElement() (localctx IWithElementContext) { + localctx = NewWithElementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 134, CqlParserRULE_withElement) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1273) + p.KwWith() + } + { + p.SetState(1274) + p.TableOptions() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ITableOptionsContext is an interface to support dynamic dispatch. +type ITableOptionsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + KwCompact() IKwCompactContext + KwStorage() IKwStorageContext + AllKwAnd() []IKwAndContext + KwAnd(i int) IKwAndContext + TableOptions() ITableOptionsContext + ClusteringOrder() IClusteringOrderContext + AllTableOptionItem() []ITableOptionItemContext + TableOptionItem(i int) ITableOptionItemContext + + // IsTableOptionsContext differentiates from other interfaces. + IsTableOptionsContext() +} + +type TableOptionsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTableOptionsContext() *TableOptionsContext { + var p = new(TableOptionsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_tableOptions + return p +} + +func InitEmptyTableOptionsContext(p *TableOptionsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_tableOptions +} + +func (*TableOptionsContext) IsTableOptionsContext() {} + +func NewTableOptionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TableOptionsContext { + var p = new(TableOptionsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_tableOptions + + return p +} + +func (s *TableOptionsContext) GetParser() antlr.Parser { return s.parser } + +func (s *TableOptionsContext) KwCompact() IKwCompactContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwCompactContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwCompactContext) +} + +func (s *TableOptionsContext) KwStorage() IKwStorageContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwStorageContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwStorageContext) +} + +func (s *TableOptionsContext) AllKwAnd() []IKwAndContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IKwAndContext); ok { + len++ + } + } + + tst := make([]IKwAndContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IKwAndContext); ok { + tst[i] = t.(IKwAndContext) + i++ + } + } + + return tst +} + +func (s *TableOptionsContext) KwAnd(i int) IKwAndContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwAndContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IKwAndContext) +} + +func (s *TableOptionsContext) TableOptions() ITableOptionsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITableOptionsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITableOptionsContext) +} + +func (s *TableOptionsContext) ClusteringOrder() IClusteringOrderContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IClusteringOrderContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IClusteringOrderContext) +} + +func (s *TableOptionsContext) AllTableOptionItem() []ITableOptionItemContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ITableOptionItemContext); ok { + len++ + } + } + + tst := make([]ITableOptionItemContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ITableOptionItemContext); ok { + tst[i] = t.(ITableOptionItemContext) + i++ + } + } + + return tst +} + +func (s *TableOptionsContext) TableOptionItem(i int) ITableOptionItemContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITableOptionItemContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ITableOptionItemContext) +} + +func (s *TableOptionsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *TableOptionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *TableOptionsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterTableOptions(s) + } +} + +func (s *TableOptionsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitTableOptions(s) + } +} + +func (s *TableOptionsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitTableOptions(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) TableOptions() (localctx ITableOptionsContext) { + localctx = NewTableOptionsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 136, CqlParserRULE_tableOptions) + var _alt int + + p.SetState(1298) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case CqlParserK_COMPACT: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1276) + p.KwCompact() + } + { + p.SetState(1277) + p.KwStorage() + } + p.SetState(1281) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 86, p.GetParserRuleContext()) == 1 { + { + p.SetState(1278) + p.KwAnd() + } + { + p.SetState(1279) + p.TableOptions() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case CqlParserK_CLUSTERING: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(1283) + p.ClusteringOrder() + } + p.SetState(1287) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 87, p.GetParserRuleContext()) == 1 { + { + p.SetState(1284) + p.KwAnd() + } + { + p.SetState(1285) + p.TableOptions() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case CqlParserOBJECT_NAME: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(1289) + p.TableOptionItem() + } + p.SetState(1295) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 88, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(1290) + p.KwAnd() + } + { + p.SetState(1291) + p.TableOptionItem() + } + + } + p.SetState(1297) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 88, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IClusteringOrderContext is an interface to support dynamic dispatch. +type IClusteringOrderContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + KwClustering() IKwClusteringContext + KwOrder() IKwOrderContext + KwBy() IKwByContext + SyntaxBracketLr() ISyntaxBracketLrContext + SyntaxBracketRr() ISyntaxBracketRrContext + AllColumn() []IColumnContext + Column(i int) IColumnContext + AllSyntaxComma() []ISyntaxCommaContext + SyntaxComma(i int) ISyntaxCommaContext + AllOrderDirection() []IOrderDirectionContext + OrderDirection(i int) IOrderDirectionContext + + // IsClusteringOrderContext differentiates from other interfaces. + IsClusteringOrderContext() +} + +type ClusteringOrderContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyClusteringOrderContext() *ClusteringOrderContext { + var p = new(ClusteringOrderContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_clusteringOrder + return p +} + +func InitEmptyClusteringOrderContext(p *ClusteringOrderContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_clusteringOrder +} + +func (*ClusteringOrderContext) IsClusteringOrderContext() {} + +func NewClusteringOrderContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ClusteringOrderContext { + var p = new(ClusteringOrderContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_clusteringOrder + + return p +} + +func (s *ClusteringOrderContext) GetParser() antlr.Parser { return s.parser } + +func (s *ClusteringOrderContext) KwClustering() IKwClusteringContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwClusteringContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwClusteringContext) +} + +func (s *ClusteringOrderContext) KwOrder() IKwOrderContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwOrderContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwOrderContext) +} + +func (s *ClusteringOrderContext) KwBy() IKwByContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwByContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwByContext) +} + +func (s *ClusteringOrderContext) SyntaxBracketLr() ISyntaxBracketLrContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISyntaxBracketLrContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISyntaxBracketLrContext) +} + +func (s *ClusteringOrderContext) SyntaxBracketRr() ISyntaxBracketRrContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISyntaxBracketRrContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISyntaxBracketRrContext) +} + +func (s *ClusteringOrderContext) AllColumn() []IColumnContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IColumnContext); ok { + len++ + } + } + + tst := make([]IColumnContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IColumnContext); ok { + tst[i] = t.(IColumnContext) + i++ + } + } + + return tst +} + +func (s *ClusteringOrderContext) Column(i int) IColumnContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumnContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IColumnContext) +} + +func (s *ClusteringOrderContext) AllSyntaxComma() []ISyntaxCommaContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISyntaxCommaContext); ok { + len++ + } + } + + tst := make([]ISyntaxCommaContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISyntaxCommaContext); ok { + tst[i] = t.(ISyntaxCommaContext) + i++ + } + } + + return tst +} + +func (s *ClusteringOrderContext) SyntaxComma(i int) ISyntaxCommaContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISyntaxCommaContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISyntaxCommaContext) +} + +func (s *ClusteringOrderContext) AllOrderDirection() []IOrderDirectionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IOrderDirectionContext); ok { + len++ + } + } + + tst := make([]IOrderDirectionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IOrderDirectionContext); ok { + tst[i] = t.(IOrderDirectionContext) + i++ + } + } + + return tst +} + +func (s *ClusteringOrderContext) OrderDirection(i int) IOrderDirectionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOrderDirectionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IOrderDirectionContext) +} + +func (s *ClusteringOrderContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ClusteringOrderContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ClusteringOrderContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterClusteringOrder(s) + } +} + +func (s *ClusteringOrderContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitClusteringOrder(s) + } +} + +func (s *ClusteringOrderContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitClusteringOrder(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) ClusteringOrder() (localctx IClusteringOrderContext) { + localctx = NewClusteringOrderContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 138, CqlParserRULE_clusteringOrder) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1300) + p.KwClustering() + } + { + p.SetState(1301) + p.KwOrder() + } + { + p.SetState(1302) + p.KwBy() + } + { + p.SetState(1303) + p.SyntaxBracketLr() + } + + { + p.SetState(1304) + p.Column() + } + p.SetState(1306) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == CqlParserK_ASC || _la == CqlParserK_DESC { + { + p.SetState(1305) + p.OrderDirection() + } + + } + + p.SetState(1315) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == CqlParserCOMMA { + { + p.SetState(1308) + p.SyntaxComma() + } + { + p.SetState(1309) + p.Column() + } + p.SetState(1311) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == CqlParserK_ASC || _la == CqlParserK_DESC { + { + p.SetState(1310) + p.OrderDirection() + } + + } + + p.SetState(1317) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(1318) + p.SyntaxBracketRr() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ITableOptionItemContext is an interface to support dynamic dispatch. +type ITableOptionItemContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + TableOptionName() ITableOptionNameContext + OPERATOR_EQ() antlr.TerminalNode + TableOptionValue() ITableOptionValueContext + OptionHash() IOptionHashContext + + // IsTableOptionItemContext differentiates from other interfaces. + IsTableOptionItemContext() +} + +type TableOptionItemContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTableOptionItemContext() *TableOptionItemContext { + var p = new(TableOptionItemContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_tableOptionItem + return p +} + +func InitEmptyTableOptionItemContext(p *TableOptionItemContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_tableOptionItem +} + +func (*TableOptionItemContext) IsTableOptionItemContext() {} + +func NewTableOptionItemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TableOptionItemContext { + var p = new(TableOptionItemContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_tableOptionItem + + return p +} + +func (s *TableOptionItemContext) GetParser() antlr.Parser { return s.parser } + +func (s *TableOptionItemContext) TableOptionName() ITableOptionNameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITableOptionNameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITableOptionNameContext) +} + +func (s *TableOptionItemContext) OPERATOR_EQ() antlr.TerminalNode { + return s.GetToken(CqlParserOPERATOR_EQ, 0) +} + +func (s *TableOptionItemContext) TableOptionValue() ITableOptionValueContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITableOptionValueContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITableOptionValueContext) +} + +func (s *TableOptionItemContext) OptionHash() IOptionHashContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOptionHashContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOptionHashContext) +} + +func (s *TableOptionItemContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *TableOptionItemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *TableOptionItemContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterTableOptionItem(s) + } +} + +func (s *TableOptionItemContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitTableOptionItem(s) + } +} + +func (s *TableOptionItemContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitTableOptionItem(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) TableOptionItem() (localctx ITableOptionItemContext) { + localctx = NewTableOptionItemContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 140, CqlParserRULE_tableOptionItem) + p.SetState(1328) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 93, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1320) + p.TableOptionName() + } + { + p.SetState(1321) + p.Match(CqlParserOPERATOR_EQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1322) + p.TableOptionValue() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(1324) + p.TableOptionName() + } + { + p.SetState(1325) + p.Match(CqlParserOPERATOR_EQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1326) + p.OptionHash() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ITableOptionNameContext is an interface to support dynamic dispatch. +type ITableOptionNameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + OBJECT_NAME() antlr.TerminalNode + + // IsTableOptionNameContext differentiates from other interfaces. + IsTableOptionNameContext() +} + +type TableOptionNameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTableOptionNameContext() *TableOptionNameContext { + var p = new(TableOptionNameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_tableOptionName + return p +} + +func InitEmptyTableOptionNameContext(p *TableOptionNameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_tableOptionName +} + +func (*TableOptionNameContext) IsTableOptionNameContext() {} + +func NewTableOptionNameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TableOptionNameContext { + var p = new(TableOptionNameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_tableOptionName + + return p +} + +func (s *TableOptionNameContext) GetParser() antlr.Parser { return s.parser } + +func (s *TableOptionNameContext) OBJECT_NAME() antlr.TerminalNode { + return s.GetToken(CqlParserOBJECT_NAME, 0) +} + +func (s *TableOptionNameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *TableOptionNameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *TableOptionNameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterTableOptionName(s) + } +} + +func (s *TableOptionNameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitTableOptionName(s) + } +} + +func (s *TableOptionNameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitTableOptionName(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) TableOptionName() (localctx ITableOptionNameContext) { + localctx = NewTableOptionNameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 142, CqlParserRULE_tableOptionName) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1330) + p.Match(CqlParserOBJECT_NAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ITableOptionValueContext is an interface to support dynamic dispatch. +type ITableOptionValueContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + StringLiteral() IStringLiteralContext + FloatLiteral() IFloatLiteralContext + + // IsTableOptionValueContext differentiates from other interfaces. + IsTableOptionValueContext() +} + +type TableOptionValueContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTableOptionValueContext() *TableOptionValueContext { + var p = new(TableOptionValueContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_tableOptionValue + return p +} + +func InitEmptyTableOptionValueContext(p *TableOptionValueContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_tableOptionValue +} + +func (*TableOptionValueContext) IsTableOptionValueContext() {} + +func NewTableOptionValueContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TableOptionValueContext { + var p = new(TableOptionValueContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_tableOptionValue + + return p +} + +func (s *TableOptionValueContext) GetParser() antlr.Parser { return s.parser } + +func (s *TableOptionValueContext) StringLiteral() IStringLiteralContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStringLiteralContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStringLiteralContext) +} + +func (s *TableOptionValueContext) FloatLiteral() IFloatLiteralContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFloatLiteralContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFloatLiteralContext) +} + +func (s *TableOptionValueContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *TableOptionValueContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *TableOptionValueContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterTableOptionValue(s) + } +} + +func (s *TableOptionValueContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitTableOptionValue(s) + } +} + +func (s *TableOptionValueContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitTableOptionValue(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) TableOptionValue() (localctx ITableOptionValueContext) { + localctx = NewTableOptionValueContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 144, CqlParserRULE_tableOptionValue) + p.SetState(1334) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case CqlParserSTRING_LITERAL: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1332) + p.StringLiteral() + } + + case CqlParserDECIMAL_LITERAL, CqlParserFLOAT_LITERAL: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(1333) + p.FloatLiteral() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOptionHashContext is an interface to support dynamic dispatch. +type IOptionHashContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SyntaxBracketLc() ISyntaxBracketLcContext + AllOptionHashItem() []IOptionHashItemContext + OptionHashItem(i int) IOptionHashItemContext + SyntaxBracketRc() ISyntaxBracketRcContext + AllSyntaxComma() []ISyntaxCommaContext + SyntaxComma(i int) ISyntaxCommaContext + + // IsOptionHashContext differentiates from other interfaces. + IsOptionHashContext() +} + +type OptionHashContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOptionHashContext() *OptionHashContext { + var p = new(OptionHashContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_optionHash + return p +} + +func InitEmptyOptionHashContext(p *OptionHashContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_optionHash +} + +func (*OptionHashContext) IsOptionHashContext() {} + +func NewOptionHashContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *OptionHashContext { + var p = new(OptionHashContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_optionHash + + return p +} + +func (s *OptionHashContext) GetParser() antlr.Parser { return s.parser } + +func (s *OptionHashContext) SyntaxBracketLc() ISyntaxBracketLcContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISyntaxBracketLcContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISyntaxBracketLcContext) +} + +func (s *OptionHashContext) AllOptionHashItem() []IOptionHashItemContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IOptionHashItemContext); ok { + len++ + } + } + + tst := make([]IOptionHashItemContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IOptionHashItemContext); ok { + tst[i] = t.(IOptionHashItemContext) + i++ + } + } + + return tst +} + +func (s *OptionHashContext) OptionHashItem(i int) IOptionHashItemContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOptionHashItemContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IOptionHashItemContext) +} + +func (s *OptionHashContext) SyntaxBracketRc() ISyntaxBracketRcContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISyntaxBracketRcContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISyntaxBracketRcContext) +} + +func (s *OptionHashContext) AllSyntaxComma() []ISyntaxCommaContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISyntaxCommaContext); ok { + len++ + } + } + + tst := make([]ISyntaxCommaContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISyntaxCommaContext); ok { + tst[i] = t.(ISyntaxCommaContext) + i++ + } + } + + return tst +} + +func (s *OptionHashContext) SyntaxComma(i int) ISyntaxCommaContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISyntaxCommaContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISyntaxCommaContext) +} + +func (s *OptionHashContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *OptionHashContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *OptionHashContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterOptionHash(s) + } +} + +func (s *OptionHashContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitOptionHash(s) + } +} + +func (s *OptionHashContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitOptionHash(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) OptionHash() (localctx IOptionHashContext) { + localctx = NewOptionHashContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 146, CqlParserRULE_optionHash) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1336) + p.SyntaxBracketLc() + } + { + p.SetState(1337) + p.OptionHashItem() + } + p.SetState(1343) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == CqlParserCOMMA { + { + p.SetState(1338) + p.SyntaxComma() + } + { + p.SetState(1339) + p.OptionHashItem() + } + + p.SetState(1345) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(1346) + p.SyntaxBracketRc() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOptionHashItemContext is an interface to support dynamic dispatch. +type IOptionHashItemContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + OptionHashKey() IOptionHashKeyContext + COLON() antlr.TerminalNode + OptionHashValue() IOptionHashValueContext + + // IsOptionHashItemContext differentiates from other interfaces. + IsOptionHashItemContext() +} + +type OptionHashItemContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOptionHashItemContext() *OptionHashItemContext { + var p = new(OptionHashItemContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_optionHashItem + return p +} + +func InitEmptyOptionHashItemContext(p *OptionHashItemContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_optionHashItem +} + +func (*OptionHashItemContext) IsOptionHashItemContext() {} + +func NewOptionHashItemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *OptionHashItemContext { + var p = new(OptionHashItemContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_optionHashItem + + return p +} + +func (s *OptionHashItemContext) GetParser() antlr.Parser { return s.parser } + +func (s *OptionHashItemContext) OptionHashKey() IOptionHashKeyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOptionHashKeyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOptionHashKeyContext) +} + +func (s *OptionHashItemContext) COLON() antlr.TerminalNode { + return s.GetToken(CqlParserCOLON, 0) +} + +func (s *OptionHashItemContext) OptionHashValue() IOptionHashValueContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOptionHashValueContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOptionHashValueContext) +} + +func (s *OptionHashItemContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *OptionHashItemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *OptionHashItemContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterOptionHashItem(s) + } +} + +func (s *OptionHashItemContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitOptionHashItem(s) + } +} + +func (s *OptionHashItemContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitOptionHashItem(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) OptionHashItem() (localctx IOptionHashItemContext) { + localctx = NewOptionHashItemContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 148, CqlParserRULE_optionHashItem) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1348) + p.OptionHashKey() + } + { + p.SetState(1349) + p.Match(CqlParserCOLON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1350) + p.OptionHashValue() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOptionHashKeyContext is an interface to support dynamic dispatch. +type IOptionHashKeyContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + StringLiteral() IStringLiteralContext + + // IsOptionHashKeyContext differentiates from other interfaces. + IsOptionHashKeyContext() +} + +type OptionHashKeyContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOptionHashKeyContext() *OptionHashKeyContext { + var p = new(OptionHashKeyContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_optionHashKey + return p +} + +func InitEmptyOptionHashKeyContext(p *OptionHashKeyContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_optionHashKey +} + +func (*OptionHashKeyContext) IsOptionHashKeyContext() {} + +func NewOptionHashKeyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *OptionHashKeyContext { + var p = new(OptionHashKeyContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_optionHashKey + + return p +} + +func (s *OptionHashKeyContext) GetParser() antlr.Parser { return s.parser } + +func (s *OptionHashKeyContext) StringLiteral() IStringLiteralContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStringLiteralContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStringLiteralContext) +} + +func (s *OptionHashKeyContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *OptionHashKeyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *OptionHashKeyContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterOptionHashKey(s) + } +} + +func (s *OptionHashKeyContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitOptionHashKey(s) + } +} + +func (s *OptionHashKeyContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitOptionHashKey(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) OptionHashKey() (localctx IOptionHashKeyContext) { + localctx = NewOptionHashKeyContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 150, CqlParserRULE_optionHashKey) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1352) + p.StringLiteral() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOptionHashValueContext is an interface to support dynamic dispatch. +type IOptionHashValueContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + StringLiteral() IStringLiteralContext + FloatLiteral() IFloatLiteralContext + + // IsOptionHashValueContext differentiates from other interfaces. + IsOptionHashValueContext() +} + +type OptionHashValueContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOptionHashValueContext() *OptionHashValueContext { + var p = new(OptionHashValueContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_optionHashValue + return p +} + +func InitEmptyOptionHashValueContext(p *OptionHashValueContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_optionHashValue +} + +func (*OptionHashValueContext) IsOptionHashValueContext() {} + +func NewOptionHashValueContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *OptionHashValueContext { + var p = new(OptionHashValueContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_optionHashValue + + return p +} + +func (s *OptionHashValueContext) GetParser() antlr.Parser { return s.parser } + +func (s *OptionHashValueContext) StringLiteral() IStringLiteralContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStringLiteralContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStringLiteralContext) +} + +func (s *OptionHashValueContext) FloatLiteral() IFloatLiteralContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFloatLiteralContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFloatLiteralContext) +} + +func (s *OptionHashValueContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *OptionHashValueContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *OptionHashValueContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterOptionHashValue(s) + } +} + +func (s *OptionHashValueContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitOptionHashValue(s) + } +} + +func (s *OptionHashValueContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitOptionHashValue(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) OptionHashValue() (localctx IOptionHashValueContext) { + localctx = NewOptionHashValueContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 152, CqlParserRULE_optionHashValue) + p.SetState(1356) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case CqlParserSTRING_LITERAL: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1354) + p.StringLiteral() + } + + case CqlParserDECIMAL_LITERAL, CqlParserFLOAT_LITERAL: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(1355) + p.FloatLiteral() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IColumnDefinitionListContext is an interface to support dynamic dispatch. +type IColumnDefinitionListContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllColumnDefinition() []IColumnDefinitionContext + ColumnDefinition(i int) IColumnDefinitionContext + AllSyntaxComma() []ISyntaxCommaContext + SyntaxComma(i int) ISyntaxCommaContext + PrimaryKeyElement() IPrimaryKeyElementContext + + // IsColumnDefinitionListContext differentiates from other interfaces. + IsColumnDefinitionListContext() +} + +type ColumnDefinitionListContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyColumnDefinitionListContext() *ColumnDefinitionListContext { + var p = new(ColumnDefinitionListContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_columnDefinitionList + return p +} + +func InitEmptyColumnDefinitionListContext(p *ColumnDefinitionListContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_columnDefinitionList +} + +func (*ColumnDefinitionListContext) IsColumnDefinitionListContext() {} + +func NewColumnDefinitionListContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ColumnDefinitionListContext { + var p = new(ColumnDefinitionListContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_columnDefinitionList + + return p +} + +func (s *ColumnDefinitionListContext) GetParser() antlr.Parser { return s.parser } + +func (s *ColumnDefinitionListContext) AllColumnDefinition() []IColumnDefinitionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IColumnDefinitionContext); ok { + len++ + } + } + + tst := make([]IColumnDefinitionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IColumnDefinitionContext); ok { + tst[i] = t.(IColumnDefinitionContext) + i++ + } + } + + return tst +} + +func (s *ColumnDefinitionListContext) ColumnDefinition(i int) IColumnDefinitionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumnDefinitionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IColumnDefinitionContext) +} + +func (s *ColumnDefinitionListContext) AllSyntaxComma() []ISyntaxCommaContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISyntaxCommaContext); ok { + len++ + } + } + + tst := make([]ISyntaxCommaContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISyntaxCommaContext); ok { + tst[i] = t.(ISyntaxCommaContext) + i++ + } + } + + return tst +} + +func (s *ColumnDefinitionListContext) SyntaxComma(i int) ISyntaxCommaContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISyntaxCommaContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISyntaxCommaContext) +} + +func (s *ColumnDefinitionListContext) PrimaryKeyElement() IPrimaryKeyElementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPrimaryKeyElementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPrimaryKeyElementContext) +} + +func (s *ColumnDefinitionListContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ColumnDefinitionListContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ColumnDefinitionListContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterColumnDefinitionList(s) + } +} + +func (s *ColumnDefinitionListContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitColumnDefinitionList(s) + } +} + +func (s *ColumnDefinitionListContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitColumnDefinitionList(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) ColumnDefinitionList() (localctx IColumnDefinitionListContext) { + localctx = NewColumnDefinitionListContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 154, CqlParserRULE_columnDefinitionList) + var _la int + + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1358) + p.ColumnDefinition() + } + + p.SetState(1364) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 97, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(1359) + p.SyntaxComma() + } + { + p.SetState(1360) + p.ColumnDefinition() + } + + } + p.SetState(1366) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 97, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + p.SetState(1370) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == CqlParserCOMMA { + { + p.SetState(1367) + p.SyntaxComma() + } + { + p.SetState(1368) + p.PrimaryKeyElement() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IColumnDefinitionContext is an interface to support dynamic dispatch. +type IColumnDefinitionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Column() IColumnContext + DataType() IDataTypeContext + PrimaryKeyColumn() IPrimaryKeyColumnContext + + // IsColumnDefinitionContext differentiates from other interfaces. + IsColumnDefinitionContext() +} + +type ColumnDefinitionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyColumnDefinitionContext() *ColumnDefinitionContext { + var p = new(ColumnDefinitionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_columnDefinition + return p +} + +func InitEmptyColumnDefinitionContext(p *ColumnDefinitionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_columnDefinition +} + +func (*ColumnDefinitionContext) IsColumnDefinitionContext() {} + +func NewColumnDefinitionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ColumnDefinitionContext { + var p = new(ColumnDefinitionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_columnDefinition + + return p +} + +func (s *ColumnDefinitionContext) GetParser() antlr.Parser { return s.parser } + +func (s *ColumnDefinitionContext) Column() IColumnContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumnContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumnContext) +} + +func (s *ColumnDefinitionContext) DataType() IDataTypeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDataTypeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDataTypeContext) +} + +func (s *ColumnDefinitionContext) PrimaryKeyColumn() IPrimaryKeyColumnContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPrimaryKeyColumnContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPrimaryKeyColumnContext) +} + +func (s *ColumnDefinitionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ColumnDefinitionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ColumnDefinitionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterColumnDefinition(s) + } +} + +func (s *ColumnDefinitionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitColumnDefinition(s) + } +} + +func (s *ColumnDefinitionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitColumnDefinition(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) ColumnDefinition() (localctx IColumnDefinitionContext) { + localctx = NewColumnDefinitionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 156, CqlParserRULE_columnDefinition) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1372) + p.Column() + } + { + p.SetState(1373) + p.DataType() + } + p.SetState(1375) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == CqlParserK_PRIMARY { + { + p.SetState(1374) + p.PrimaryKeyColumn() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IPrimaryKeyColumnContext is an interface to support dynamic dispatch. +type IPrimaryKeyColumnContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + KwPrimary() IKwPrimaryContext + KwKey() IKwKeyContext + + // IsPrimaryKeyColumnContext differentiates from other interfaces. + IsPrimaryKeyColumnContext() +} + +type PrimaryKeyColumnContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPrimaryKeyColumnContext() *PrimaryKeyColumnContext { + var p = new(PrimaryKeyColumnContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_primaryKeyColumn + return p +} + +func InitEmptyPrimaryKeyColumnContext(p *PrimaryKeyColumnContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_primaryKeyColumn +} + +func (*PrimaryKeyColumnContext) IsPrimaryKeyColumnContext() {} + +func NewPrimaryKeyColumnContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PrimaryKeyColumnContext { + var p = new(PrimaryKeyColumnContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_primaryKeyColumn + + return p +} + +func (s *PrimaryKeyColumnContext) GetParser() antlr.Parser { return s.parser } + +func (s *PrimaryKeyColumnContext) KwPrimary() IKwPrimaryContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwPrimaryContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwPrimaryContext) +} + +func (s *PrimaryKeyColumnContext) KwKey() IKwKeyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwKeyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwKeyContext) +} + +func (s *PrimaryKeyColumnContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *PrimaryKeyColumnContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *PrimaryKeyColumnContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterPrimaryKeyColumn(s) + } +} + +func (s *PrimaryKeyColumnContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitPrimaryKeyColumn(s) + } +} + +func (s *PrimaryKeyColumnContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitPrimaryKeyColumn(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) PrimaryKeyColumn() (localctx IPrimaryKeyColumnContext) { + localctx = NewPrimaryKeyColumnContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 158, CqlParserRULE_primaryKeyColumn) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1377) + p.KwPrimary() + } + { + p.SetState(1378) + p.KwKey() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IPrimaryKeyElementContext is an interface to support dynamic dispatch. +type IPrimaryKeyElementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + KwPrimary() IKwPrimaryContext + KwKey() IKwKeyContext + SyntaxBracketLr() ISyntaxBracketLrContext + PrimaryKeyDefinition() IPrimaryKeyDefinitionContext + SyntaxBracketRr() ISyntaxBracketRrContext + + // IsPrimaryKeyElementContext differentiates from other interfaces. + IsPrimaryKeyElementContext() +} + +type PrimaryKeyElementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPrimaryKeyElementContext() *PrimaryKeyElementContext { + var p = new(PrimaryKeyElementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_primaryKeyElement + return p +} + +func InitEmptyPrimaryKeyElementContext(p *PrimaryKeyElementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_primaryKeyElement +} + +func (*PrimaryKeyElementContext) IsPrimaryKeyElementContext() {} + +func NewPrimaryKeyElementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PrimaryKeyElementContext { + var p = new(PrimaryKeyElementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_primaryKeyElement + + return p +} + +func (s *PrimaryKeyElementContext) GetParser() antlr.Parser { return s.parser } + +func (s *PrimaryKeyElementContext) KwPrimary() IKwPrimaryContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwPrimaryContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwPrimaryContext) +} + +func (s *PrimaryKeyElementContext) KwKey() IKwKeyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwKeyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwKeyContext) +} + +func (s *PrimaryKeyElementContext) SyntaxBracketLr() ISyntaxBracketLrContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISyntaxBracketLrContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISyntaxBracketLrContext) +} + +func (s *PrimaryKeyElementContext) PrimaryKeyDefinition() IPrimaryKeyDefinitionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPrimaryKeyDefinitionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPrimaryKeyDefinitionContext) +} + +func (s *PrimaryKeyElementContext) SyntaxBracketRr() ISyntaxBracketRrContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISyntaxBracketRrContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISyntaxBracketRrContext) +} + +func (s *PrimaryKeyElementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *PrimaryKeyElementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *PrimaryKeyElementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterPrimaryKeyElement(s) + } +} + +func (s *PrimaryKeyElementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitPrimaryKeyElement(s) + } +} + +func (s *PrimaryKeyElementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitPrimaryKeyElement(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) PrimaryKeyElement() (localctx IPrimaryKeyElementContext) { + localctx = NewPrimaryKeyElementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 160, CqlParserRULE_primaryKeyElement) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1380) + p.KwPrimary() + } + { + p.SetState(1381) + p.KwKey() + } + { + p.SetState(1382) + p.SyntaxBracketLr() + } + { + p.SetState(1383) + p.PrimaryKeyDefinition() + } + { + p.SetState(1384) + p.SyntaxBracketRr() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IPrimaryKeyDefinitionContext is an interface to support dynamic dispatch. +type IPrimaryKeyDefinitionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SinglePrimaryKey() ISinglePrimaryKeyContext + CompoundKey() ICompoundKeyContext + CompositeKey() ICompositeKeyContext + + // IsPrimaryKeyDefinitionContext differentiates from other interfaces. + IsPrimaryKeyDefinitionContext() +} + +type PrimaryKeyDefinitionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPrimaryKeyDefinitionContext() *PrimaryKeyDefinitionContext { + var p = new(PrimaryKeyDefinitionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_primaryKeyDefinition + return p +} + +func InitEmptyPrimaryKeyDefinitionContext(p *PrimaryKeyDefinitionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_primaryKeyDefinition +} + +func (*PrimaryKeyDefinitionContext) IsPrimaryKeyDefinitionContext() {} + +func NewPrimaryKeyDefinitionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PrimaryKeyDefinitionContext { + var p = new(PrimaryKeyDefinitionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_primaryKeyDefinition + + return p +} + +func (s *PrimaryKeyDefinitionContext) GetParser() antlr.Parser { return s.parser } + +func (s *PrimaryKeyDefinitionContext) SinglePrimaryKey() ISinglePrimaryKeyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISinglePrimaryKeyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISinglePrimaryKeyContext) +} + +func (s *PrimaryKeyDefinitionContext) CompoundKey() ICompoundKeyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICompoundKeyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICompoundKeyContext) +} + +func (s *PrimaryKeyDefinitionContext) CompositeKey() ICompositeKeyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICompositeKeyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICompositeKeyContext) +} + +func (s *PrimaryKeyDefinitionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *PrimaryKeyDefinitionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *PrimaryKeyDefinitionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterPrimaryKeyDefinition(s) + } +} + +func (s *PrimaryKeyDefinitionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitPrimaryKeyDefinition(s) + } +} + +func (s *PrimaryKeyDefinitionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitPrimaryKeyDefinition(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) PrimaryKeyDefinition() (localctx IPrimaryKeyDefinitionContext) { + localctx = NewPrimaryKeyDefinitionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 162, CqlParserRULE_primaryKeyDefinition) + p.SetState(1389) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 100, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1386) + p.SinglePrimaryKey() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(1387) + p.CompoundKey() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(1388) + p.CompositeKey() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISinglePrimaryKeyContext is an interface to support dynamic dispatch. +type ISinglePrimaryKeyContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Column() IColumnContext + + // IsSinglePrimaryKeyContext differentiates from other interfaces. + IsSinglePrimaryKeyContext() +} + +type SinglePrimaryKeyContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySinglePrimaryKeyContext() *SinglePrimaryKeyContext { + var p = new(SinglePrimaryKeyContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_singlePrimaryKey + return p +} + +func InitEmptySinglePrimaryKeyContext(p *SinglePrimaryKeyContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_singlePrimaryKey +} + +func (*SinglePrimaryKeyContext) IsSinglePrimaryKeyContext() {} + +func NewSinglePrimaryKeyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SinglePrimaryKeyContext { + var p = new(SinglePrimaryKeyContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_singlePrimaryKey + + return p +} + +func (s *SinglePrimaryKeyContext) GetParser() antlr.Parser { return s.parser } + +func (s *SinglePrimaryKeyContext) Column() IColumnContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumnContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumnContext) +} + +func (s *SinglePrimaryKeyContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SinglePrimaryKeyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *SinglePrimaryKeyContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterSinglePrimaryKey(s) + } +} + +func (s *SinglePrimaryKeyContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitSinglePrimaryKey(s) + } +} + +func (s *SinglePrimaryKeyContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitSinglePrimaryKey(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) SinglePrimaryKey() (localctx ISinglePrimaryKeyContext) { + localctx = NewSinglePrimaryKeyContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 164, CqlParserRULE_singlePrimaryKey) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1391) + p.Column() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICompoundKeyContext is an interface to support dynamic dispatch. +type ICompoundKeyContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + PartitionKey() IPartitionKeyContext + SyntaxComma() ISyntaxCommaContext + ClusteringKeyList() IClusteringKeyListContext + + // IsCompoundKeyContext differentiates from other interfaces. + IsCompoundKeyContext() +} + +type CompoundKeyContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCompoundKeyContext() *CompoundKeyContext { + var p = new(CompoundKeyContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_compoundKey + return p +} + +func InitEmptyCompoundKeyContext(p *CompoundKeyContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_compoundKey +} + +func (*CompoundKeyContext) IsCompoundKeyContext() {} + +func NewCompoundKeyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CompoundKeyContext { + var p = new(CompoundKeyContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_compoundKey + + return p +} + +func (s *CompoundKeyContext) GetParser() antlr.Parser { return s.parser } + +func (s *CompoundKeyContext) PartitionKey() IPartitionKeyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPartitionKeyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPartitionKeyContext) +} + +func (s *CompoundKeyContext) SyntaxComma() ISyntaxCommaContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISyntaxCommaContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISyntaxCommaContext) +} + +func (s *CompoundKeyContext) ClusteringKeyList() IClusteringKeyListContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IClusteringKeyListContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IClusteringKeyListContext) +} + +func (s *CompoundKeyContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CompoundKeyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *CompoundKeyContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterCompoundKey(s) + } +} + +func (s *CompoundKeyContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitCompoundKey(s) + } +} + +func (s *CompoundKeyContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitCompoundKey(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) CompoundKey() (localctx ICompoundKeyContext) { + localctx = NewCompoundKeyContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 166, CqlParserRULE_compoundKey) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1393) + p.PartitionKey() + } + + { + p.SetState(1394) + p.SyntaxComma() + } + { + p.SetState(1395) + p.ClusteringKeyList() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICompositeKeyContext is an interface to support dynamic dispatch. +type ICompositeKeyContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SyntaxBracketLr() ISyntaxBracketLrContext + PartitionKeyList() IPartitionKeyListContext + SyntaxBracketRr() ISyntaxBracketRrContext + SyntaxComma() ISyntaxCommaContext + ClusteringKeyList() IClusteringKeyListContext + + // IsCompositeKeyContext differentiates from other interfaces. + IsCompositeKeyContext() +} + +type CompositeKeyContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCompositeKeyContext() *CompositeKeyContext { + var p = new(CompositeKeyContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_compositeKey + return p +} + +func InitEmptyCompositeKeyContext(p *CompositeKeyContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_compositeKey +} + +func (*CompositeKeyContext) IsCompositeKeyContext() {} + +func NewCompositeKeyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CompositeKeyContext { + var p = new(CompositeKeyContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_compositeKey + + return p +} + +func (s *CompositeKeyContext) GetParser() antlr.Parser { return s.parser } + +func (s *CompositeKeyContext) SyntaxBracketLr() ISyntaxBracketLrContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISyntaxBracketLrContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISyntaxBracketLrContext) +} + +func (s *CompositeKeyContext) PartitionKeyList() IPartitionKeyListContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPartitionKeyListContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPartitionKeyListContext) +} + +func (s *CompositeKeyContext) SyntaxBracketRr() ISyntaxBracketRrContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISyntaxBracketRrContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISyntaxBracketRrContext) +} + +func (s *CompositeKeyContext) SyntaxComma() ISyntaxCommaContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISyntaxCommaContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISyntaxCommaContext) +} + +func (s *CompositeKeyContext) ClusteringKeyList() IClusteringKeyListContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IClusteringKeyListContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IClusteringKeyListContext) +} + +func (s *CompositeKeyContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CompositeKeyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *CompositeKeyContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterCompositeKey(s) + } +} + +func (s *CompositeKeyContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitCompositeKey(s) + } +} + +func (s *CompositeKeyContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitCompositeKey(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) CompositeKey() (localctx ICompositeKeyContext) { + localctx = NewCompositeKeyContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 168, CqlParserRULE_compositeKey) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1397) + p.SyntaxBracketLr() + } + { + p.SetState(1398) + p.PartitionKeyList() + } + { + p.SetState(1399) + p.SyntaxBracketRr() + } + + { + p.SetState(1400) + p.SyntaxComma() + } + { + p.SetState(1401) + p.ClusteringKeyList() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IPartitionKeyListContext is an interface to support dynamic dispatch. +type IPartitionKeyListContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllPartitionKey() []IPartitionKeyContext + PartitionKey(i int) IPartitionKeyContext + AllSyntaxComma() []ISyntaxCommaContext + SyntaxComma(i int) ISyntaxCommaContext + + // IsPartitionKeyListContext differentiates from other interfaces. + IsPartitionKeyListContext() +} + +type PartitionKeyListContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPartitionKeyListContext() *PartitionKeyListContext { + var p = new(PartitionKeyListContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_partitionKeyList + return p +} + +func InitEmptyPartitionKeyListContext(p *PartitionKeyListContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_partitionKeyList +} + +func (*PartitionKeyListContext) IsPartitionKeyListContext() {} + +func NewPartitionKeyListContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PartitionKeyListContext { + var p = new(PartitionKeyListContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_partitionKeyList + + return p +} + +func (s *PartitionKeyListContext) GetParser() antlr.Parser { return s.parser } + +func (s *PartitionKeyListContext) AllPartitionKey() []IPartitionKeyContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IPartitionKeyContext); ok { + len++ + } + } + + tst := make([]IPartitionKeyContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IPartitionKeyContext); ok { + tst[i] = t.(IPartitionKeyContext) + i++ + } + } + + return tst +} + +func (s *PartitionKeyListContext) PartitionKey(i int) IPartitionKeyContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPartitionKeyContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IPartitionKeyContext) +} + +func (s *PartitionKeyListContext) AllSyntaxComma() []ISyntaxCommaContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISyntaxCommaContext); ok { + len++ + } + } + + tst := make([]ISyntaxCommaContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISyntaxCommaContext); ok { + tst[i] = t.(ISyntaxCommaContext) + i++ + } + } + + return tst +} + +func (s *PartitionKeyListContext) SyntaxComma(i int) ISyntaxCommaContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISyntaxCommaContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISyntaxCommaContext) +} + +func (s *PartitionKeyListContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *PartitionKeyListContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *PartitionKeyListContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterPartitionKeyList(s) + } +} + +func (s *PartitionKeyListContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitPartitionKeyList(s) + } +} + +func (s *PartitionKeyListContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitPartitionKeyList(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) PartitionKeyList() (localctx IPartitionKeyListContext) { + localctx = NewPartitionKeyListContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 170, CqlParserRULE_partitionKeyList) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1403) + p.PartitionKey() + } + + p.SetState(1409) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == CqlParserCOMMA { + { + p.SetState(1404) + p.SyntaxComma() + } + { + p.SetState(1405) + p.PartitionKey() + } + + p.SetState(1411) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IClusteringKeyListContext is an interface to support dynamic dispatch. +type IClusteringKeyListContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllClusteringKey() []IClusteringKeyContext + ClusteringKey(i int) IClusteringKeyContext + AllSyntaxComma() []ISyntaxCommaContext + SyntaxComma(i int) ISyntaxCommaContext + + // IsClusteringKeyListContext differentiates from other interfaces. + IsClusteringKeyListContext() +} + +type ClusteringKeyListContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyClusteringKeyListContext() *ClusteringKeyListContext { + var p = new(ClusteringKeyListContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_clusteringKeyList + return p +} + +func InitEmptyClusteringKeyListContext(p *ClusteringKeyListContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_clusteringKeyList +} + +func (*ClusteringKeyListContext) IsClusteringKeyListContext() {} + +func NewClusteringKeyListContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ClusteringKeyListContext { + var p = new(ClusteringKeyListContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_clusteringKeyList + + return p +} + +func (s *ClusteringKeyListContext) GetParser() antlr.Parser { return s.parser } + +func (s *ClusteringKeyListContext) AllClusteringKey() []IClusteringKeyContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IClusteringKeyContext); ok { + len++ + } + } + + tst := make([]IClusteringKeyContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IClusteringKeyContext); ok { + tst[i] = t.(IClusteringKeyContext) + i++ + } + } + + return tst +} + +func (s *ClusteringKeyListContext) ClusteringKey(i int) IClusteringKeyContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IClusteringKeyContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IClusteringKeyContext) +} + +func (s *ClusteringKeyListContext) AllSyntaxComma() []ISyntaxCommaContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISyntaxCommaContext); ok { + len++ + } + } + + tst := make([]ISyntaxCommaContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISyntaxCommaContext); ok { + tst[i] = t.(ISyntaxCommaContext) + i++ + } + } + + return tst +} + +func (s *ClusteringKeyListContext) SyntaxComma(i int) ISyntaxCommaContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISyntaxCommaContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISyntaxCommaContext) +} + +func (s *ClusteringKeyListContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ClusteringKeyListContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ClusteringKeyListContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterClusteringKeyList(s) + } +} + +func (s *ClusteringKeyListContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitClusteringKeyList(s) + } +} + +func (s *ClusteringKeyListContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitClusteringKeyList(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) ClusteringKeyList() (localctx IClusteringKeyListContext) { + localctx = NewClusteringKeyListContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 172, CqlParserRULE_clusteringKeyList) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1412) + p.ClusteringKey() + } + + p.SetState(1418) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == CqlParserCOMMA { + { + p.SetState(1413) + p.SyntaxComma() + } + { + p.SetState(1414) + p.ClusteringKey() + } + + p.SetState(1420) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IPartitionKeyContext is an interface to support dynamic dispatch. +type IPartitionKeyContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Column() IColumnContext + + // IsPartitionKeyContext differentiates from other interfaces. + IsPartitionKeyContext() +} + +type PartitionKeyContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPartitionKeyContext() *PartitionKeyContext { + var p = new(PartitionKeyContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_partitionKey + return p +} + +func InitEmptyPartitionKeyContext(p *PartitionKeyContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_partitionKey +} + +func (*PartitionKeyContext) IsPartitionKeyContext() {} + +func NewPartitionKeyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PartitionKeyContext { + var p = new(PartitionKeyContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_partitionKey + + return p +} + +func (s *PartitionKeyContext) GetParser() antlr.Parser { return s.parser } + +func (s *PartitionKeyContext) Column() IColumnContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumnContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumnContext) +} + +func (s *PartitionKeyContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *PartitionKeyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *PartitionKeyContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterPartitionKey(s) + } +} + +func (s *PartitionKeyContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitPartitionKey(s) + } +} + +func (s *PartitionKeyContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitPartitionKey(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) PartitionKey() (localctx IPartitionKeyContext) { + localctx = NewPartitionKeyContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 174, CqlParserRULE_partitionKey) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1421) + p.Column() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IClusteringKeyContext is an interface to support dynamic dispatch. +type IClusteringKeyContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Column() IColumnContext + + // IsClusteringKeyContext differentiates from other interfaces. + IsClusteringKeyContext() +} + +type ClusteringKeyContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyClusteringKeyContext() *ClusteringKeyContext { + var p = new(ClusteringKeyContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_clusteringKey + return p +} + +func InitEmptyClusteringKeyContext(p *ClusteringKeyContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_clusteringKey +} + +func (*ClusteringKeyContext) IsClusteringKeyContext() {} + +func NewClusteringKeyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ClusteringKeyContext { + var p = new(ClusteringKeyContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_clusteringKey + + return p +} + +func (s *ClusteringKeyContext) GetParser() antlr.Parser { return s.parser } + +func (s *ClusteringKeyContext) Column() IColumnContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumnContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumnContext) +} + +func (s *ClusteringKeyContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ClusteringKeyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ClusteringKeyContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterClusteringKey(s) + } +} + +func (s *ClusteringKeyContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitClusteringKey(s) + } +} + +func (s *ClusteringKeyContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitClusteringKey(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) ClusteringKey() (localctx IClusteringKeyContext) { + localctx = NewClusteringKeyContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 176, CqlParserRULE_clusteringKey) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1423) + p.Column() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IApplyBatchContext is an interface to support dynamic dispatch. +type IApplyBatchContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + KwApply() IKwApplyContext + KwBatch() IKwBatchContext + + // IsApplyBatchContext differentiates from other interfaces. + IsApplyBatchContext() +} + +type ApplyBatchContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyApplyBatchContext() *ApplyBatchContext { + var p = new(ApplyBatchContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_applyBatch + return p +} + +func InitEmptyApplyBatchContext(p *ApplyBatchContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_applyBatch +} + +func (*ApplyBatchContext) IsApplyBatchContext() {} + +func NewApplyBatchContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ApplyBatchContext { + var p = new(ApplyBatchContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_applyBatch + + return p +} + +func (s *ApplyBatchContext) GetParser() antlr.Parser { return s.parser } + +func (s *ApplyBatchContext) KwApply() IKwApplyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwApplyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwApplyContext) +} + +func (s *ApplyBatchContext) KwBatch() IKwBatchContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwBatchContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwBatchContext) +} + +func (s *ApplyBatchContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ApplyBatchContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ApplyBatchContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterApplyBatch(s) + } +} + +func (s *ApplyBatchContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitApplyBatch(s) + } +} + +func (s *ApplyBatchContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitApplyBatch(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) ApplyBatch() (localctx IApplyBatchContext) { + localctx = NewApplyBatchContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 178, CqlParserRULE_applyBatch) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1425) + p.KwApply() + } + { + p.SetState(1426) + p.KwBatch() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IBeginBatchContext is an interface to support dynamic dispatch. +type IBeginBatchContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + KwBegin() IKwBeginContext + KwBatch() IKwBatchContext + BatchType() IBatchTypeContext + UsingTimestampSpec() IUsingTimestampSpecContext + + // IsBeginBatchContext differentiates from other interfaces. + IsBeginBatchContext() +} + +type BeginBatchContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyBeginBatchContext() *BeginBatchContext { + var p = new(BeginBatchContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_beginBatch + return p +} + +func InitEmptyBeginBatchContext(p *BeginBatchContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_beginBatch +} + +func (*BeginBatchContext) IsBeginBatchContext() {} + +func NewBeginBatchContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *BeginBatchContext { + var p = new(BeginBatchContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_beginBatch + + return p +} + +func (s *BeginBatchContext) GetParser() antlr.Parser { return s.parser } + +func (s *BeginBatchContext) KwBegin() IKwBeginContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwBeginContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwBeginContext) +} + +func (s *BeginBatchContext) KwBatch() IKwBatchContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwBatchContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwBatchContext) +} + +func (s *BeginBatchContext) BatchType() IBatchTypeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IBatchTypeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IBatchTypeContext) +} + +func (s *BeginBatchContext) UsingTimestampSpec() IUsingTimestampSpecContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUsingTimestampSpecContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUsingTimestampSpecContext) +} + +func (s *BeginBatchContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *BeginBatchContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *BeginBatchContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterBeginBatch(s) + } +} + +func (s *BeginBatchContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitBeginBatch(s) + } +} + +func (s *BeginBatchContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitBeginBatch(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) BeginBatch() (localctx IBeginBatchContext) { + localctx = NewBeginBatchContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 180, CqlParserRULE_beginBatch) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1428) + p.KwBegin() + } + p.SetState(1430) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == CqlParserK_LOGGED || _la == CqlParserK_UNLOGGED { + { + p.SetState(1429) + p.BatchType() + } + + } + { + p.SetState(1432) + p.KwBatch() + } + p.SetState(1434) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == CqlParserK_USING { + { + p.SetState(1433) + p.UsingTimestampSpec() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IBatchTypeContext is an interface to support dynamic dispatch. +type IBatchTypeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + KwLogged() IKwLoggedContext + KwUnlogged() IKwUnloggedContext + + // IsBatchTypeContext differentiates from other interfaces. + IsBatchTypeContext() +} + +type BatchTypeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyBatchTypeContext() *BatchTypeContext { + var p = new(BatchTypeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_batchType + return p +} + +func InitEmptyBatchTypeContext(p *BatchTypeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_batchType +} + +func (*BatchTypeContext) IsBatchTypeContext() {} + +func NewBatchTypeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *BatchTypeContext { + var p = new(BatchTypeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_batchType + + return p +} + +func (s *BatchTypeContext) GetParser() antlr.Parser { return s.parser } + +func (s *BatchTypeContext) KwLogged() IKwLoggedContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwLoggedContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwLoggedContext) +} + +func (s *BatchTypeContext) KwUnlogged() IKwUnloggedContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwUnloggedContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwUnloggedContext) +} + +func (s *BatchTypeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *BatchTypeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *BatchTypeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterBatchType(s) + } +} + +func (s *BatchTypeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitBatchType(s) + } +} + +func (s *BatchTypeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitBatchType(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) BatchType() (localctx IBatchTypeContext) { + localctx = NewBatchTypeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 182, CqlParserRULE_batchType) + p.SetState(1438) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case CqlParserK_LOGGED: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1436) + p.KwLogged() + } + + case CqlParserK_UNLOGGED: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(1437) + p.KwUnlogged() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlterKeyspaceContext is an interface to support dynamic dispatch. +type IAlterKeyspaceContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + KwAlter() IKwAlterContext + KwKeyspace() IKwKeyspaceContext + Keyspace() IKeyspaceContext + KwWith() IKwWithContext + KwReplication() IKwReplicationContext + OPERATOR_EQ() antlr.TerminalNode + SyntaxBracketLc() ISyntaxBracketLcContext + ReplicationList() IReplicationListContext + SyntaxBracketRc() ISyntaxBracketRcContext + KwAnd() IKwAndContext + DurableWrites() IDurableWritesContext + + // IsAlterKeyspaceContext differentiates from other interfaces. + IsAlterKeyspaceContext() +} + +type AlterKeyspaceContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlterKeyspaceContext() *AlterKeyspaceContext { + var p = new(AlterKeyspaceContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_alterKeyspace + return p +} + +func InitEmptyAlterKeyspaceContext(p *AlterKeyspaceContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_alterKeyspace +} + +func (*AlterKeyspaceContext) IsAlterKeyspaceContext() {} + +func NewAlterKeyspaceContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AlterKeyspaceContext { + var p = new(AlterKeyspaceContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_alterKeyspace + + return p +} + +func (s *AlterKeyspaceContext) GetParser() antlr.Parser { return s.parser } + +func (s *AlterKeyspaceContext) KwAlter() IKwAlterContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwAlterContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwAlterContext) +} + +func (s *AlterKeyspaceContext) KwKeyspace() IKwKeyspaceContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwKeyspaceContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwKeyspaceContext) +} + +func (s *AlterKeyspaceContext) Keyspace() IKeyspaceContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKeyspaceContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKeyspaceContext) +} + +func (s *AlterKeyspaceContext) KwWith() IKwWithContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwWithContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwWithContext) +} + +func (s *AlterKeyspaceContext) KwReplication() IKwReplicationContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwReplicationContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwReplicationContext) +} + +func (s *AlterKeyspaceContext) OPERATOR_EQ() antlr.TerminalNode { + return s.GetToken(CqlParserOPERATOR_EQ, 0) +} + +func (s *AlterKeyspaceContext) SyntaxBracketLc() ISyntaxBracketLcContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISyntaxBracketLcContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISyntaxBracketLcContext) +} + +func (s *AlterKeyspaceContext) ReplicationList() IReplicationListContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IReplicationListContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IReplicationListContext) +} + +func (s *AlterKeyspaceContext) SyntaxBracketRc() ISyntaxBracketRcContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISyntaxBracketRcContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISyntaxBracketRcContext) +} + +func (s *AlterKeyspaceContext) KwAnd() IKwAndContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwAndContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwAndContext) +} + +func (s *AlterKeyspaceContext) DurableWrites() IDurableWritesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDurableWritesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDurableWritesContext) +} + +func (s *AlterKeyspaceContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AlterKeyspaceContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *AlterKeyspaceContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterAlterKeyspace(s) + } +} + +func (s *AlterKeyspaceContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitAlterKeyspace(s) + } +} + +func (s *AlterKeyspaceContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitAlterKeyspace(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) AlterKeyspace() (localctx IAlterKeyspaceContext) { + localctx = NewAlterKeyspaceContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 184, CqlParserRULE_alterKeyspace) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1440) + p.KwAlter() + } + { + p.SetState(1441) + p.KwKeyspace() + } + { + p.SetState(1442) + p.Keyspace() + } + { + p.SetState(1443) + p.KwWith() + } + { + p.SetState(1444) + p.KwReplication() + } + { + p.SetState(1445) + p.Match(CqlParserOPERATOR_EQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1446) + p.SyntaxBracketLc() + } + { + p.SetState(1447) + p.ReplicationList() + } + { + p.SetState(1448) + p.SyntaxBracketRc() + } + p.SetState(1452) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == CqlParserK_AND { + { + p.SetState(1449) + p.KwAnd() + } + { + p.SetState(1450) + p.DurableWrites() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IReplicationListContext is an interface to support dynamic dispatch. +type IReplicationListContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllReplicationListItem() []IReplicationListItemContext + ReplicationListItem(i int) IReplicationListItemContext + AllSyntaxComma() []ISyntaxCommaContext + SyntaxComma(i int) ISyntaxCommaContext + + // IsReplicationListContext differentiates from other interfaces. + IsReplicationListContext() +} + +type ReplicationListContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyReplicationListContext() *ReplicationListContext { + var p = new(ReplicationListContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_replicationList + return p +} + +func InitEmptyReplicationListContext(p *ReplicationListContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_replicationList +} + +func (*ReplicationListContext) IsReplicationListContext() {} + +func NewReplicationListContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ReplicationListContext { + var p = new(ReplicationListContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_replicationList + + return p +} + +func (s *ReplicationListContext) GetParser() antlr.Parser { return s.parser } + +func (s *ReplicationListContext) AllReplicationListItem() []IReplicationListItemContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IReplicationListItemContext); ok { + len++ + } + } + + tst := make([]IReplicationListItemContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IReplicationListItemContext); ok { + tst[i] = t.(IReplicationListItemContext) + i++ + } + } + + return tst +} + +func (s *ReplicationListContext) ReplicationListItem(i int) IReplicationListItemContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IReplicationListItemContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IReplicationListItemContext) +} + +func (s *ReplicationListContext) AllSyntaxComma() []ISyntaxCommaContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISyntaxCommaContext); ok { + len++ + } + } + + tst := make([]ISyntaxCommaContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISyntaxCommaContext); ok { + tst[i] = t.(ISyntaxCommaContext) + i++ + } + } + + return tst +} + +func (s *ReplicationListContext) SyntaxComma(i int) ISyntaxCommaContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISyntaxCommaContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISyntaxCommaContext) +} + +func (s *ReplicationListContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ReplicationListContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ReplicationListContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterReplicationList(s) + } +} + +func (s *ReplicationListContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitReplicationList(s) + } +} + +func (s *ReplicationListContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitReplicationList(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) ReplicationList() (localctx IReplicationListContext) { + localctx = NewReplicationListContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 186, CqlParserRULE_replicationList) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1454) + p.ReplicationListItem() + } + + p.SetState(1460) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == CqlParserCOMMA { + { + p.SetState(1455) + p.SyntaxComma() + } + { + p.SetState(1456) + p.ReplicationListItem() + } + + p.SetState(1462) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IReplicationListItemContext is an interface to support dynamic dispatch. +type IReplicationListItemContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllSTRING_LITERAL() []antlr.TerminalNode + STRING_LITERAL(i int) antlr.TerminalNode + COLON() antlr.TerminalNode + DECIMAL_LITERAL() antlr.TerminalNode + + // IsReplicationListItemContext differentiates from other interfaces. + IsReplicationListItemContext() +} + +type ReplicationListItemContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyReplicationListItemContext() *ReplicationListItemContext { + var p = new(ReplicationListItemContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_replicationListItem + return p +} + +func InitEmptyReplicationListItemContext(p *ReplicationListItemContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_replicationListItem +} + +func (*ReplicationListItemContext) IsReplicationListItemContext() {} + +func NewReplicationListItemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ReplicationListItemContext { + var p = new(ReplicationListItemContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_replicationListItem + + return p +} + +func (s *ReplicationListItemContext) GetParser() antlr.Parser { return s.parser } + +func (s *ReplicationListItemContext) AllSTRING_LITERAL() []antlr.TerminalNode { + return s.GetTokens(CqlParserSTRING_LITERAL) +} + +func (s *ReplicationListItemContext) STRING_LITERAL(i int) antlr.TerminalNode { + return s.GetToken(CqlParserSTRING_LITERAL, i) +} + +func (s *ReplicationListItemContext) COLON() antlr.TerminalNode { + return s.GetToken(CqlParserCOLON, 0) +} + +func (s *ReplicationListItemContext) DECIMAL_LITERAL() antlr.TerminalNode { + return s.GetToken(CqlParserDECIMAL_LITERAL, 0) +} + +func (s *ReplicationListItemContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ReplicationListItemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ReplicationListItemContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterReplicationListItem(s) + } +} + +func (s *ReplicationListItemContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitReplicationListItem(s) + } +} + +func (s *ReplicationListItemContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitReplicationListItem(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) ReplicationListItem() (localctx IReplicationListItemContext) { + localctx = NewReplicationListItemContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 188, CqlParserRULE_replicationListItem) + p.SetState(1469) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 108, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1463) + p.Match(CqlParserSTRING_LITERAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1464) + p.Match(CqlParserCOLON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1465) + p.Match(CqlParserSTRING_LITERAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(1466) + p.Match(CqlParserSTRING_LITERAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1467) + p.Match(CqlParserCOLON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1468) + p.Match(CqlParserDECIMAL_LITERAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDurableWritesContext is an interface to support dynamic dispatch. +type IDurableWritesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + KwDurableWrites() IKwDurableWritesContext + OPERATOR_EQ() antlr.TerminalNode + BooleanLiteral() IBooleanLiteralContext + + // IsDurableWritesContext differentiates from other interfaces. + IsDurableWritesContext() +} + +type DurableWritesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDurableWritesContext() *DurableWritesContext { + var p = new(DurableWritesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_durableWrites + return p +} + +func InitEmptyDurableWritesContext(p *DurableWritesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_durableWrites +} + +func (*DurableWritesContext) IsDurableWritesContext() {} + +func NewDurableWritesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DurableWritesContext { + var p = new(DurableWritesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_durableWrites + + return p +} + +func (s *DurableWritesContext) GetParser() antlr.Parser { return s.parser } + +func (s *DurableWritesContext) KwDurableWrites() IKwDurableWritesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwDurableWritesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwDurableWritesContext) +} + +func (s *DurableWritesContext) OPERATOR_EQ() antlr.TerminalNode { + return s.GetToken(CqlParserOPERATOR_EQ, 0) +} + +func (s *DurableWritesContext) BooleanLiteral() IBooleanLiteralContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IBooleanLiteralContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IBooleanLiteralContext) +} + +func (s *DurableWritesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *DurableWritesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *DurableWritesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterDurableWrites(s) + } +} + +func (s *DurableWritesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitDurableWrites(s) + } +} + +func (s *DurableWritesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitDurableWrites(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) DurableWrites() (localctx IDurableWritesContext) { + localctx = NewDurableWritesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 190, CqlParserRULE_durableWrites) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1471) + p.KwDurableWrites() + } + { + p.SetState(1472) + p.Match(CqlParserOPERATOR_EQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1473) + p.BooleanLiteral() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IUse_Context is an interface to support dynamic dispatch. +type IUse_Context interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + KwUse() IKwUseContext + Keyspace() IKeyspaceContext + + // IsUse_Context differentiates from other interfaces. + IsUse_Context() +} + +type Use_Context struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyUse_Context() *Use_Context { + var p = new(Use_Context) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_use_ + return p +} + +func InitEmptyUse_Context(p *Use_Context) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_use_ +} + +func (*Use_Context) IsUse_Context() {} + +func NewUse_Context(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Use_Context { + var p = new(Use_Context) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_use_ + + return p +} + +func (s *Use_Context) GetParser() antlr.Parser { return s.parser } + +func (s *Use_Context) KwUse() IKwUseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwUseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwUseContext) +} + +func (s *Use_Context) Keyspace() IKeyspaceContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKeyspaceContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKeyspaceContext) +} + +func (s *Use_Context) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Use_Context) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Use_Context) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterUse_(s) + } +} + +func (s *Use_Context) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitUse_(s) + } +} + +func (s *Use_Context) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitUse_(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) Use_() (localctx IUse_Context) { + localctx = NewUse_Context(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 192, CqlParserRULE_use_) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1475) + p.KwUse() + } + { + p.SetState(1476) + p.Keyspace() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ITruncateContext is an interface to support dynamic dispatch. +type ITruncateContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + KwTruncate() IKwTruncateContext + Table() ITableContext + KwTable() IKwTableContext + Keyspace() IKeyspaceContext + DOT() antlr.TerminalNode + + // IsTruncateContext differentiates from other interfaces. + IsTruncateContext() +} + +type TruncateContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTruncateContext() *TruncateContext { + var p = new(TruncateContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_truncate + return p +} + +func InitEmptyTruncateContext(p *TruncateContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_truncate +} + +func (*TruncateContext) IsTruncateContext() {} + +func NewTruncateContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TruncateContext { + var p = new(TruncateContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_truncate + + return p +} + +func (s *TruncateContext) GetParser() antlr.Parser { return s.parser } + +func (s *TruncateContext) KwTruncate() IKwTruncateContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwTruncateContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwTruncateContext) +} + +func (s *TruncateContext) Table() ITableContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITableContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITableContext) +} + +func (s *TruncateContext) KwTable() IKwTableContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwTableContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwTableContext) +} + +func (s *TruncateContext) Keyspace() IKeyspaceContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKeyspaceContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKeyspaceContext) +} + +func (s *TruncateContext) DOT() antlr.TerminalNode { + return s.GetToken(CqlParserDOT, 0) +} + +func (s *TruncateContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *TruncateContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *TruncateContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterTruncate(s) + } +} + +func (s *TruncateContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitTruncate(s) + } +} + +func (s *TruncateContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitTruncate(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) Truncate() (localctx ITruncateContext) { + localctx = NewTruncateContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 194, CqlParserRULE_truncate) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1478) + p.KwTruncate() + } + p.SetState(1480) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == CqlParserK_TABLE { + { + p.SetState(1479) + p.KwTable() + } + + } + p.SetState(1485) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 110, p.GetParserRuleContext()) == 1 { + { + p.SetState(1482) + p.Keyspace() + } + { + p.SetState(1483) + p.Match(CqlParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(1487) + p.Table() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreateIndexContext is an interface to support dynamic dispatch. +type ICreateIndexContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + KwCreate() IKwCreateContext + KwIndex() IKwIndexContext + KwOn() IKwOnContext + Table() ITableContext + SyntaxBracketLr() ISyntaxBracketLrContext + IndexColumnSpec() IIndexColumnSpecContext + SyntaxBracketRr() ISyntaxBracketRrContext + IfNotExist() IIfNotExistContext + IndexName() IIndexNameContext + Keyspace() IKeyspaceContext + DOT() antlr.TerminalNode + + // IsCreateIndexContext differentiates from other interfaces. + IsCreateIndexContext() +} + +type CreateIndexContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreateIndexContext() *CreateIndexContext { + var p = new(CreateIndexContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_createIndex + return p +} + +func InitEmptyCreateIndexContext(p *CreateIndexContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_createIndex +} + +func (*CreateIndexContext) IsCreateIndexContext() {} + +func NewCreateIndexContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CreateIndexContext { + var p = new(CreateIndexContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_createIndex + + return p +} + +func (s *CreateIndexContext) GetParser() antlr.Parser { return s.parser } + +func (s *CreateIndexContext) KwCreate() IKwCreateContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwCreateContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwCreateContext) +} + +func (s *CreateIndexContext) KwIndex() IKwIndexContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwIndexContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwIndexContext) +} + +func (s *CreateIndexContext) KwOn() IKwOnContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwOnContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwOnContext) +} + +func (s *CreateIndexContext) Table() ITableContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITableContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITableContext) +} + +func (s *CreateIndexContext) SyntaxBracketLr() ISyntaxBracketLrContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISyntaxBracketLrContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISyntaxBracketLrContext) +} + +func (s *CreateIndexContext) IndexColumnSpec() IIndexColumnSpecContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIndexColumnSpecContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIndexColumnSpecContext) +} + +func (s *CreateIndexContext) SyntaxBracketRr() ISyntaxBracketRrContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISyntaxBracketRrContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISyntaxBracketRrContext) +} + +func (s *CreateIndexContext) IfNotExist() IIfNotExistContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIfNotExistContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIfNotExistContext) +} + +func (s *CreateIndexContext) IndexName() IIndexNameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIndexNameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIndexNameContext) +} + +func (s *CreateIndexContext) Keyspace() IKeyspaceContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKeyspaceContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKeyspaceContext) +} + +func (s *CreateIndexContext) DOT() antlr.TerminalNode { + return s.GetToken(CqlParserDOT, 0) +} + +func (s *CreateIndexContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CreateIndexContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *CreateIndexContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterCreateIndex(s) + } +} + +func (s *CreateIndexContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitCreateIndex(s) + } +} + +func (s *CreateIndexContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitCreateIndex(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) CreateIndex() (localctx ICreateIndexContext) { + localctx = NewCreateIndexContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 196, CqlParserRULE_createIndex) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1489) + p.KwCreate() + } + { + p.SetState(1490) + p.KwIndex() + } + p.SetState(1492) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == CqlParserK_IF { + { + p.SetState(1491) + p.IfNotExist() + } + + } + p.SetState(1495) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == CqlParserSTRING_LITERAL || _la == CqlParserOBJECT_NAME { + { + p.SetState(1494) + p.IndexName() + } + + } + { + p.SetState(1497) + p.KwOn() + } + p.SetState(1501) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 113, p.GetParserRuleContext()) == 1 { + { + p.SetState(1498) + p.Keyspace() + } + { + p.SetState(1499) + p.Match(CqlParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(1503) + p.Table() + } + { + p.SetState(1504) + p.SyntaxBracketLr() + } + { + p.SetState(1505) + p.IndexColumnSpec() + } + { + p.SetState(1506) + p.SyntaxBracketRr() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IIndexNameContext is an interface to support dynamic dispatch. +type IIndexNameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + OBJECT_NAME() antlr.TerminalNode + StringLiteral() IStringLiteralContext + + // IsIndexNameContext differentiates from other interfaces. + IsIndexNameContext() +} + +type IndexNameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyIndexNameContext() *IndexNameContext { + var p = new(IndexNameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_indexName + return p +} + +func InitEmptyIndexNameContext(p *IndexNameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_indexName +} + +func (*IndexNameContext) IsIndexNameContext() {} + +func NewIndexNameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *IndexNameContext { + var p = new(IndexNameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_indexName + + return p +} + +func (s *IndexNameContext) GetParser() antlr.Parser { return s.parser } + +func (s *IndexNameContext) OBJECT_NAME() antlr.TerminalNode { + return s.GetToken(CqlParserOBJECT_NAME, 0) +} + +func (s *IndexNameContext) StringLiteral() IStringLiteralContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStringLiteralContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStringLiteralContext) +} + +func (s *IndexNameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *IndexNameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *IndexNameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterIndexName(s) + } +} + +func (s *IndexNameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitIndexName(s) + } +} + +func (s *IndexNameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitIndexName(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) IndexName() (localctx IIndexNameContext) { + localctx = NewIndexNameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 198, CqlParserRULE_indexName) + p.SetState(1510) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case CqlParserOBJECT_NAME: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1508) + p.Match(CqlParserOBJECT_NAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case CqlParserSTRING_LITERAL: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(1509) + p.StringLiteral() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IIndexColumnSpecContext is an interface to support dynamic dispatch. +type IIndexColumnSpecContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Column() IColumnContext + IndexKeysSpec() IIndexKeysSpecContext + IndexEntriesSSpec() IIndexEntriesSSpecContext + IndexFullSpec() IIndexFullSpecContext + + // IsIndexColumnSpecContext differentiates from other interfaces. + IsIndexColumnSpecContext() +} + +type IndexColumnSpecContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyIndexColumnSpecContext() *IndexColumnSpecContext { + var p = new(IndexColumnSpecContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_indexColumnSpec + return p +} + +func InitEmptyIndexColumnSpecContext(p *IndexColumnSpecContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_indexColumnSpec +} + +func (*IndexColumnSpecContext) IsIndexColumnSpecContext() {} + +func NewIndexColumnSpecContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *IndexColumnSpecContext { + var p = new(IndexColumnSpecContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_indexColumnSpec + + return p +} + +func (s *IndexColumnSpecContext) GetParser() antlr.Parser { return s.parser } + +func (s *IndexColumnSpecContext) Column() IColumnContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumnContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumnContext) +} + +func (s *IndexColumnSpecContext) IndexKeysSpec() IIndexKeysSpecContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIndexKeysSpecContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIndexKeysSpecContext) +} + +func (s *IndexColumnSpecContext) IndexEntriesSSpec() IIndexEntriesSSpecContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIndexEntriesSSpecContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIndexEntriesSSpecContext) +} + +func (s *IndexColumnSpecContext) IndexFullSpec() IIndexFullSpecContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIndexFullSpecContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIndexFullSpecContext) +} + +func (s *IndexColumnSpecContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *IndexColumnSpecContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *IndexColumnSpecContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterIndexColumnSpec(s) + } +} + +func (s *IndexColumnSpecContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitIndexColumnSpec(s) + } +} + +func (s *IndexColumnSpecContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitIndexColumnSpec(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) IndexColumnSpec() (localctx IIndexColumnSpecContext) { + localctx = NewIndexColumnSpecContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 200, CqlParserRULE_indexColumnSpec) + p.SetState(1516) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case CqlParserDQUOTE, CqlParserOBJECT_NAME: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1512) + p.Column() + } + + case CqlParserK_KEYS: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(1513) + p.IndexKeysSpec() + } + + case CqlParserK_ENTRIES: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(1514) + p.IndexEntriesSSpec() + } + + case CqlParserK_FULL: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(1515) + p.IndexFullSpec() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IIndexKeysSpecContext is an interface to support dynamic dispatch. +type IIndexKeysSpecContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + KwKeys() IKwKeysContext + SyntaxBracketLr() ISyntaxBracketLrContext + OBJECT_NAME() antlr.TerminalNode + SyntaxBracketRr() ISyntaxBracketRrContext + + // IsIndexKeysSpecContext differentiates from other interfaces. + IsIndexKeysSpecContext() +} + +type IndexKeysSpecContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyIndexKeysSpecContext() *IndexKeysSpecContext { + var p = new(IndexKeysSpecContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_indexKeysSpec + return p +} + +func InitEmptyIndexKeysSpecContext(p *IndexKeysSpecContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_indexKeysSpec +} + +func (*IndexKeysSpecContext) IsIndexKeysSpecContext() {} + +func NewIndexKeysSpecContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *IndexKeysSpecContext { + var p = new(IndexKeysSpecContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_indexKeysSpec + + return p +} + +func (s *IndexKeysSpecContext) GetParser() antlr.Parser { return s.parser } + +func (s *IndexKeysSpecContext) KwKeys() IKwKeysContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwKeysContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwKeysContext) +} + +func (s *IndexKeysSpecContext) SyntaxBracketLr() ISyntaxBracketLrContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISyntaxBracketLrContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISyntaxBracketLrContext) +} + +func (s *IndexKeysSpecContext) OBJECT_NAME() antlr.TerminalNode { + return s.GetToken(CqlParserOBJECT_NAME, 0) +} + +func (s *IndexKeysSpecContext) SyntaxBracketRr() ISyntaxBracketRrContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISyntaxBracketRrContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISyntaxBracketRrContext) +} + +func (s *IndexKeysSpecContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *IndexKeysSpecContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *IndexKeysSpecContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterIndexKeysSpec(s) + } +} + +func (s *IndexKeysSpecContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitIndexKeysSpec(s) + } +} + +func (s *IndexKeysSpecContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitIndexKeysSpec(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) IndexKeysSpec() (localctx IIndexKeysSpecContext) { + localctx = NewIndexKeysSpecContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 202, CqlParserRULE_indexKeysSpec) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1518) + p.KwKeys() + } + { + p.SetState(1519) + p.SyntaxBracketLr() + } + { + p.SetState(1520) + p.Match(CqlParserOBJECT_NAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1521) + p.SyntaxBracketRr() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IIndexEntriesSSpecContext is an interface to support dynamic dispatch. +type IIndexEntriesSSpecContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + KwEntries() IKwEntriesContext + SyntaxBracketLr() ISyntaxBracketLrContext + OBJECT_NAME() antlr.TerminalNode + SyntaxBracketRr() ISyntaxBracketRrContext + + // IsIndexEntriesSSpecContext differentiates from other interfaces. + IsIndexEntriesSSpecContext() +} + +type IndexEntriesSSpecContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyIndexEntriesSSpecContext() *IndexEntriesSSpecContext { + var p = new(IndexEntriesSSpecContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_indexEntriesSSpec + return p +} + +func InitEmptyIndexEntriesSSpecContext(p *IndexEntriesSSpecContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_indexEntriesSSpec +} + +func (*IndexEntriesSSpecContext) IsIndexEntriesSSpecContext() {} + +func NewIndexEntriesSSpecContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *IndexEntriesSSpecContext { + var p = new(IndexEntriesSSpecContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_indexEntriesSSpec + + return p +} + +func (s *IndexEntriesSSpecContext) GetParser() antlr.Parser { return s.parser } + +func (s *IndexEntriesSSpecContext) KwEntries() IKwEntriesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwEntriesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwEntriesContext) +} + +func (s *IndexEntriesSSpecContext) SyntaxBracketLr() ISyntaxBracketLrContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISyntaxBracketLrContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISyntaxBracketLrContext) +} + +func (s *IndexEntriesSSpecContext) OBJECT_NAME() antlr.TerminalNode { + return s.GetToken(CqlParserOBJECT_NAME, 0) +} + +func (s *IndexEntriesSSpecContext) SyntaxBracketRr() ISyntaxBracketRrContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISyntaxBracketRrContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISyntaxBracketRrContext) +} + +func (s *IndexEntriesSSpecContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *IndexEntriesSSpecContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *IndexEntriesSSpecContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterIndexEntriesSSpec(s) + } +} + +func (s *IndexEntriesSSpecContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitIndexEntriesSSpec(s) + } +} + +func (s *IndexEntriesSSpecContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitIndexEntriesSSpec(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) IndexEntriesSSpec() (localctx IIndexEntriesSSpecContext) { + localctx = NewIndexEntriesSSpecContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 204, CqlParserRULE_indexEntriesSSpec) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1523) + p.KwEntries() + } + { + p.SetState(1524) + p.SyntaxBracketLr() + } + { + p.SetState(1525) + p.Match(CqlParserOBJECT_NAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1526) + p.SyntaxBracketRr() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IIndexFullSpecContext is an interface to support dynamic dispatch. +type IIndexFullSpecContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + KwFull() IKwFullContext + SyntaxBracketLr() ISyntaxBracketLrContext + OBJECT_NAME() antlr.TerminalNode + SyntaxBracketRr() ISyntaxBracketRrContext + + // IsIndexFullSpecContext differentiates from other interfaces. + IsIndexFullSpecContext() +} + +type IndexFullSpecContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyIndexFullSpecContext() *IndexFullSpecContext { + var p = new(IndexFullSpecContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_indexFullSpec + return p +} + +func InitEmptyIndexFullSpecContext(p *IndexFullSpecContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_indexFullSpec +} + +func (*IndexFullSpecContext) IsIndexFullSpecContext() {} + +func NewIndexFullSpecContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *IndexFullSpecContext { + var p = new(IndexFullSpecContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_indexFullSpec + + return p +} + +func (s *IndexFullSpecContext) GetParser() antlr.Parser { return s.parser } + +func (s *IndexFullSpecContext) KwFull() IKwFullContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwFullContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwFullContext) +} + +func (s *IndexFullSpecContext) SyntaxBracketLr() ISyntaxBracketLrContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISyntaxBracketLrContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISyntaxBracketLrContext) +} + +func (s *IndexFullSpecContext) OBJECT_NAME() antlr.TerminalNode { + return s.GetToken(CqlParserOBJECT_NAME, 0) +} + +func (s *IndexFullSpecContext) SyntaxBracketRr() ISyntaxBracketRrContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISyntaxBracketRrContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISyntaxBracketRrContext) +} + +func (s *IndexFullSpecContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *IndexFullSpecContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *IndexFullSpecContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterIndexFullSpec(s) + } +} + +func (s *IndexFullSpecContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitIndexFullSpec(s) + } +} + +func (s *IndexFullSpecContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitIndexFullSpec(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) IndexFullSpec() (localctx IIndexFullSpecContext) { + localctx = NewIndexFullSpecContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 206, CqlParserRULE_indexFullSpec) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1528) + p.KwFull() + } + { + p.SetState(1529) + p.SyntaxBracketLr() + } + { + p.SetState(1530) + p.Match(CqlParserOBJECT_NAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1531) + p.SyntaxBracketRr() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDelete_Context is an interface to support dynamic dispatch. +type IDelete_Context interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + KwDelete() IKwDeleteContext + FromSpec() IFromSpecContext + WhereSpec() IWhereSpecContext + BeginBatch() IBeginBatchContext + DeleteColumnList() IDeleteColumnListContext + UsingTimestampSpec() IUsingTimestampSpecContext + IfExist() IIfExistContext + IfSpec() IIfSpecContext + + // IsDelete_Context differentiates from other interfaces. + IsDelete_Context() +} + +type Delete_Context struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDelete_Context() *Delete_Context { + var p = new(Delete_Context) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_delete_ + return p +} + +func InitEmptyDelete_Context(p *Delete_Context) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_delete_ +} + +func (*Delete_Context) IsDelete_Context() {} + +func NewDelete_Context(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Delete_Context { + var p = new(Delete_Context) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_delete_ + + return p +} + +func (s *Delete_Context) GetParser() antlr.Parser { return s.parser } + +func (s *Delete_Context) KwDelete() IKwDeleteContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwDeleteContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwDeleteContext) +} + +func (s *Delete_Context) FromSpec() IFromSpecContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFromSpecContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFromSpecContext) +} + +func (s *Delete_Context) WhereSpec() IWhereSpecContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWhereSpecContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWhereSpecContext) +} + +func (s *Delete_Context) BeginBatch() IBeginBatchContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IBeginBatchContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IBeginBatchContext) +} + +func (s *Delete_Context) DeleteColumnList() IDeleteColumnListContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDeleteColumnListContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDeleteColumnListContext) +} + +func (s *Delete_Context) UsingTimestampSpec() IUsingTimestampSpecContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUsingTimestampSpecContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUsingTimestampSpecContext) +} + +func (s *Delete_Context) IfExist() IIfExistContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIfExistContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIfExistContext) +} + +func (s *Delete_Context) IfSpec() IIfSpecContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIfSpecContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIfSpecContext) +} + +func (s *Delete_Context) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Delete_Context) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Delete_Context) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterDelete_(s) + } +} + +func (s *Delete_Context) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitDelete_(s) + } +} + +func (s *Delete_Context) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitDelete_(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) Delete_() (localctx IDelete_Context) { + localctx = NewDelete_Context(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 208, CqlParserRULE_delete_) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(1534) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == CqlParserK_BEGIN { + { + p.SetState(1533) + p.BeginBatch() + } + + } + { + p.SetState(1536) + p.KwDelete() + } + p.SetState(1538) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == CqlParserOBJECT_NAME { + { + p.SetState(1537) + p.DeleteColumnList() + } + + } + { + p.SetState(1540) + p.FromSpec() + } + p.SetState(1542) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == CqlParserK_USING { + { + p.SetState(1541) + p.UsingTimestampSpec() + } + + } + { + p.SetState(1544) + p.WhereSpec() + } + p.SetState(1547) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 119, p.GetParserRuleContext()) == 1 { + { + p.SetState(1545) + p.IfExist() + } + + } else if p.HasError() { // JIM + goto errorExit + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 119, p.GetParserRuleContext()) == 2 { + { + p.SetState(1546) + p.IfSpec() + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDeleteColumnListContext is an interface to support dynamic dispatch. +type IDeleteColumnListContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllDeleteColumnItem() []IDeleteColumnItemContext + DeleteColumnItem(i int) IDeleteColumnItemContext + AllSyntaxComma() []ISyntaxCommaContext + SyntaxComma(i int) ISyntaxCommaContext + + // IsDeleteColumnListContext differentiates from other interfaces. + IsDeleteColumnListContext() +} + +type DeleteColumnListContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDeleteColumnListContext() *DeleteColumnListContext { + var p = new(DeleteColumnListContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_deleteColumnList + return p +} + +func InitEmptyDeleteColumnListContext(p *DeleteColumnListContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_deleteColumnList +} + +func (*DeleteColumnListContext) IsDeleteColumnListContext() {} + +func NewDeleteColumnListContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DeleteColumnListContext { + var p = new(DeleteColumnListContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_deleteColumnList + + return p +} + +func (s *DeleteColumnListContext) GetParser() antlr.Parser { return s.parser } + +func (s *DeleteColumnListContext) AllDeleteColumnItem() []IDeleteColumnItemContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IDeleteColumnItemContext); ok { + len++ + } + } + + tst := make([]IDeleteColumnItemContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IDeleteColumnItemContext); ok { + tst[i] = t.(IDeleteColumnItemContext) + i++ + } + } + + return tst +} + +func (s *DeleteColumnListContext) DeleteColumnItem(i int) IDeleteColumnItemContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDeleteColumnItemContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IDeleteColumnItemContext) +} + +func (s *DeleteColumnListContext) AllSyntaxComma() []ISyntaxCommaContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISyntaxCommaContext); ok { + len++ + } + } + + tst := make([]ISyntaxCommaContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISyntaxCommaContext); ok { + tst[i] = t.(ISyntaxCommaContext) + i++ + } + } + + return tst +} + +func (s *DeleteColumnListContext) SyntaxComma(i int) ISyntaxCommaContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISyntaxCommaContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISyntaxCommaContext) +} + +func (s *DeleteColumnListContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *DeleteColumnListContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *DeleteColumnListContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterDeleteColumnList(s) + } +} + +func (s *DeleteColumnListContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitDeleteColumnList(s) + } +} + +func (s *DeleteColumnListContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitDeleteColumnList(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) DeleteColumnList() (localctx IDeleteColumnListContext) { + localctx = NewDeleteColumnListContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 210, CqlParserRULE_deleteColumnList) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1549) + p.DeleteColumnItem() + } + + p.SetState(1555) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == CqlParserCOMMA { + { + p.SetState(1550) + p.SyntaxComma() + } + { + p.SetState(1551) + p.DeleteColumnItem() + } + + p.SetState(1557) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDeleteColumnItemContext is an interface to support dynamic dispatch. +type IDeleteColumnItemContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + OBJECT_NAME() antlr.TerminalNode + LS_BRACKET() antlr.TerminalNode + RS_BRACKET() antlr.TerminalNode + StringLiteral() IStringLiteralContext + DecimalLiteral() IDecimalLiteralContext + + // IsDeleteColumnItemContext differentiates from other interfaces. + IsDeleteColumnItemContext() +} + +type DeleteColumnItemContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDeleteColumnItemContext() *DeleteColumnItemContext { + var p = new(DeleteColumnItemContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_deleteColumnItem + return p +} + +func InitEmptyDeleteColumnItemContext(p *DeleteColumnItemContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_deleteColumnItem +} + +func (*DeleteColumnItemContext) IsDeleteColumnItemContext() {} + +func NewDeleteColumnItemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DeleteColumnItemContext { + var p = new(DeleteColumnItemContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_deleteColumnItem + + return p +} + +func (s *DeleteColumnItemContext) GetParser() antlr.Parser { return s.parser } + +func (s *DeleteColumnItemContext) OBJECT_NAME() antlr.TerminalNode { + return s.GetToken(CqlParserOBJECT_NAME, 0) +} + +func (s *DeleteColumnItemContext) LS_BRACKET() antlr.TerminalNode { + return s.GetToken(CqlParserLS_BRACKET, 0) +} + +func (s *DeleteColumnItemContext) RS_BRACKET() antlr.TerminalNode { + return s.GetToken(CqlParserRS_BRACKET, 0) +} + +func (s *DeleteColumnItemContext) StringLiteral() IStringLiteralContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStringLiteralContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStringLiteralContext) +} + +func (s *DeleteColumnItemContext) DecimalLiteral() IDecimalLiteralContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDecimalLiteralContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDecimalLiteralContext) +} + +func (s *DeleteColumnItemContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *DeleteColumnItemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *DeleteColumnItemContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterDeleteColumnItem(s) + } +} + +func (s *DeleteColumnItemContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitDeleteColumnItem(s) + } +} + +func (s *DeleteColumnItemContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitDeleteColumnItem(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) DeleteColumnItem() (localctx IDeleteColumnItemContext) { + localctx = NewDeleteColumnItemContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 212, CqlParserRULE_deleteColumnItem) + p.SetState(1567) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 122, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1558) + p.Match(CqlParserOBJECT_NAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(1559) + p.Match(CqlParserOBJECT_NAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1560) + p.Match(CqlParserLS_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1563) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case CqlParserSTRING_LITERAL: + { + p.SetState(1561) + p.StringLiteral() + } + + case CqlParserDECIMAL_LITERAL: + { + p.SetState(1562) + p.DecimalLiteral() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + { + p.SetState(1565) + p.Match(CqlParserRS_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IUpdateContext is an interface to support dynamic dispatch. +type IUpdateContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + KwUpdate() IKwUpdateContext + Table() ITableContext + KwSet() IKwSetContext + Assignments() IAssignmentsContext + WhereSpec() IWhereSpecContext + BeginBatch() IBeginBatchContext + Keyspace() IKeyspaceContext + DOT() antlr.TerminalNode + UsingTtlTimestamp() IUsingTtlTimestampContext + IfExist() IIfExistContext + IfSpec() IIfSpecContext + + // IsUpdateContext differentiates from other interfaces. + IsUpdateContext() +} + +type UpdateContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyUpdateContext() *UpdateContext { + var p = new(UpdateContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_update + return p +} + +func InitEmptyUpdateContext(p *UpdateContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_update +} + +func (*UpdateContext) IsUpdateContext() {} + +func NewUpdateContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *UpdateContext { + var p = new(UpdateContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_update + + return p +} + +func (s *UpdateContext) GetParser() antlr.Parser { return s.parser } + +func (s *UpdateContext) KwUpdate() IKwUpdateContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwUpdateContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwUpdateContext) +} + +func (s *UpdateContext) Table() ITableContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITableContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITableContext) +} + +func (s *UpdateContext) KwSet() IKwSetContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwSetContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwSetContext) +} + +func (s *UpdateContext) Assignments() IAssignmentsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAssignmentsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAssignmentsContext) +} + +func (s *UpdateContext) WhereSpec() IWhereSpecContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWhereSpecContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWhereSpecContext) +} + +func (s *UpdateContext) BeginBatch() IBeginBatchContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IBeginBatchContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IBeginBatchContext) +} + +func (s *UpdateContext) Keyspace() IKeyspaceContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKeyspaceContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKeyspaceContext) +} + +func (s *UpdateContext) DOT() antlr.TerminalNode { + return s.GetToken(CqlParserDOT, 0) +} + +func (s *UpdateContext) UsingTtlTimestamp() IUsingTtlTimestampContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUsingTtlTimestampContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUsingTtlTimestampContext) +} + +func (s *UpdateContext) IfExist() IIfExistContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIfExistContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIfExistContext) +} + +func (s *UpdateContext) IfSpec() IIfSpecContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIfSpecContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIfSpecContext) +} + +func (s *UpdateContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *UpdateContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *UpdateContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterUpdate(s) + } +} + +func (s *UpdateContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitUpdate(s) + } +} + +func (s *UpdateContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitUpdate(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) Update() (localctx IUpdateContext) { + localctx = NewUpdateContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 214, CqlParserRULE_update) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(1570) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == CqlParserK_BEGIN { + { + p.SetState(1569) + p.BeginBatch() + } + + } + { + p.SetState(1572) + p.KwUpdate() + } + p.SetState(1576) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 124, p.GetParserRuleContext()) == 1 { + { + p.SetState(1573) + p.Keyspace() + } + { + p.SetState(1574) + p.Match(CqlParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(1578) + p.Table() + } + p.SetState(1580) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == CqlParserK_USING { + { + p.SetState(1579) + p.UsingTtlTimestamp() + } + + } + { + p.SetState(1582) + p.KwSet() + } + { + p.SetState(1583) + p.Assignments() + } + { + p.SetState(1584) + p.WhereSpec() + } + p.SetState(1587) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 126, p.GetParserRuleContext()) == 1 { + { + p.SetState(1585) + p.IfExist() + } + + } else if p.HasError() { // JIM + goto errorExit + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 126, p.GetParserRuleContext()) == 2 { + { + p.SetState(1586) + p.IfSpec() + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IIfSpecContext is an interface to support dynamic dispatch. +type IIfSpecContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + KwIf() IKwIfContext + IfConditionList() IIfConditionListContext + + // IsIfSpecContext differentiates from other interfaces. + IsIfSpecContext() +} + +type IfSpecContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyIfSpecContext() *IfSpecContext { + var p = new(IfSpecContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_ifSpec + return p +} + +func InitEmptyIfSpecContext(p *IfSpecContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_ifSpec +} + +func (*IfSpecContext) IsIfSpecContext() {} + +func NewIfSpecContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *IfSpecContext { + var p = new(IfSpecContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_ifSpec + + return p +} + +func (s *IfSpecContext) GetParser() antlr.Parser { return s.parser } + +func (s *IfSpecContext) KwIf() IKwIfContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwIfContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwIfContext) +} + +func (s *IfSpecContext) IfConditionList() IIfConditionListContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIfConditionListContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIfConditionListContext) +} + +func (s *IfSpecContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *IfSpecContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *IfSpecContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterIfSpec(s) + } +} + +func (s *IfSpecContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitIfSpec(s) + } +} + +func (s *IfSpecContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitIfSpec(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) IfSpec() (localctx IIfSpecContext) { + localctx = NewIfSpecContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 216, CqlParserRULE_ifSpec) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1589) + p.KwIf() + } + { + p.SetState(1590) + p.IfConditionList() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IIfConditionListContext is an interface to support dynamic dispatch. +type IIfConditionListContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllIfCondition() []IIfConditionContext + IfCondition(i int) IIfConditionContext + AllKwAnd() []IKwAndContext + KwAnd(i int) IKwAndContext + + // IsIfConditionListContext differentiates from other interfaces. + IsIfConditionListContext() +} + +type IfConditionListContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyIfConditionListContext() *IfConditionListContext { + var p = new(IfConditionListContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_ifConditionList + return p +} + +func InitEmptyIfConditionListContext(p *IfConditionListContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_ifConditionList +} + +func (*IfConditionListContext) IsIfConditionListContext() {} + +func NewIfConditionListContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *IfConditionListContext { + var p = new(IfConditionListContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_ifConditionList + + return p +} + +func (s *IfConditionListContext) GetParser() antlr.Parser { return s.parser } + +func (s *IfConditionListContext) AllIfCondition() []IIfConditionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IIfConditionContext); ok { + len++ + } + } + + tst := make([]IIfConditionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IIfConditionContext); ok { + tst[i] = t.(IIfConditionContext) + i++ + } + } + + return tst +} + +func (s *IfConditionListContext) IfCondition(i int) IIfConditionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIfConditionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IIfConditionContext) +} + +func (s *IfConditionListContext) AllKwAnd() []IKwAndContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IKwAndContext); ok { + len++ + } + } + + tst := make([]IKwAndContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IKwAndContext); ok { + tst[i] = t.(IKwAndContext) + i++ + } + } + + return tst +} + +func (s *IfConditionListContext) KwAnd(i int) IKwAndContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwAndContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IKwAndContext) +} + +func (s *IfConditionListContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *IfConditionListContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *IfConditionListContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterIfConditionList(s) + } +} + +func (s *IfConditionListContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitIfConditionList(s) + } +} + +func (s *IfConditionListContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitIfConditionList(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) IfConditionList() (localctx IIfConditionListContext) { + localctx = NewIfConditionListContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 218, CqlParserRULE_ifConditionList) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1592) + p.IfCondition() + } + + p.SetState(1598) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == CqlParserK_AND { + { + p.SetState(1593) + p.KwAnd() + } + { + p.SetState(1594) + p.IfCondition() + } + + p.SetState(1600) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IIfConditionContext is an interface to support dynamic dispatch. +type IIfConditionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + OBJECT_NAME() antlr.TerminalNode + OPERATOR_EQ() antlr.TerminalNode + Constant() IConstantContext + + // IsIfConditionContext differentiates from other interfaces. + IsIfConditionContext() +} + +type IfConditionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyIfConditionContext() *IfConditionContext { + var p = new(IfConditionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_ifCondition + return p +} + +func InitEmptyIfConditionContext(p *IfConditionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_ifCondition +} + +func (*IfConditionContext) IsIfConditionContext() {} + +func NewIfConditionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *IfConditionContext { + var p = new(IfConditionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_ifCondition + + return p +} + +func (s *IfConditionContext) GetParser() antlr.Parser { return s.parser } + +func (s *IfConditionContext) OBJECT_NAME() antlr.TerminalNode { + return s.GetToken(CqlParserOBJECT_NAME, 0) +} + +func (s *IfConditionContext) OPERATOR_EQ() antlr.TerminalNode { + return s.GetToken(CqlParserOPERATOR_EQ, 0) +} + +func (s *IfConditionContext) Constant() IConstantContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConstantContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IConstantContext) +} + +func (s *IfConditionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *IfConditionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *IfConditionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterIfCondition(s) + } +} + +func (s *IfConditionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitIfCondition(s) + } +} + +func (s *IfConditionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitIfCondition(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) IfCondition() (localctx IIfConditionContext) { + localctx = NewIfConditionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 220, CqlParserRULE_ifCondition) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1601) + p.Match(CqlParserOBJECT_NAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1602) + p.Match(CqlParserOPERATOR_EQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1603) + p.Constant() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAssignmentsContext is an interface to support dynamic dispatch. +type IAssignmentsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllAssignmentElement() []IAssignmentElementContext + AssignmentElement(i int) IAssignmentElementContext + AllSyntaxComma() []ISyntaxCommaContext + SyntaxComma(i int) ISyntaxCommaContext + + // IsAssignmentsContext differentiates from other interfaces. + IsAssignmentsContext() +} + +type AssignmentsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAssignmentsContext() *AssignmentsContext { + var p = new(AssignmentsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_assignments + return p +} + +func InitEmptyAssignmentsContext(p *AssignmentsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_assignments +} + +func (*AssignmentsContext) IsAssignmentsContext() {} + +func NewAssignmentsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AssignmentsContext { + var p = new(AssignmentsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_assignments + + return p +} + +func (s *AssignmentsContext) GetParser() antlr.Parser { return s.parser } + +func (s *AssignmentsContext) AllAssignmentElement() []IAssignmentElementContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IAssignmentElementContext); ok { + len++ + } + } + + tst := make([]IAssignmentElementContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IAssignmentElementContext); ok { + tst[i] = t.(IAssignmentElementContext) + i++ + } + } + + return tst +} + +func (s *AssignmentsContext) AssignmentElement(i int) IAssignmentElementContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAssignmentElementContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IAssignmentElementContext) +} + +func (s *AssignmentsContext) AllSyntaxComma() []ISyntaxCommaContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISyntaxCommaContext); ok { + len++ + } + } + + tst := make([]ISyntaxCommaContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISyntaxCommaContext); ok { + tst[i] = t.(ISyntaxCommaContext) + i++ + } + } + + return tst +} + +func (s *AssignmentsContext) SyntaxComma(i int) ISyntaxCommaContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISyntaxCommaContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISyntaxCommaContext) +} + +func (s *AssignmentsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AssignmentsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *AssignmentsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterAssignments(s) + } +} + +func (s *AssignmentsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitAssignments(s) + } +} + +func (s *AssignmentsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitAssignments(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) Assignments() (localctx IAssignmentsContext) { + localctx = NewAssignmentsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 222, CqlParserRULE_assignments) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1605) + p.AssignmentElement() + } + + p.SetState(1611) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == CqlParserCOMMA { + { + p.SetState(1606) + p.SyntaxComma() + } + { + p.SetState(1607) + p.AssignmentElement() + } + + p.SetState(1613) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAssignmentElementContext is an interface to support dynamic dispatch. +type IAssignmentElementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllOBJECT_NAME() []antlr.TerminalNode + OBJECT_NAME(i int) antlr.TerminalNode + OPERATOR_EQ() antlr.TerminalNode + Constant() IConstantContext + AssignmentMap() IAssignmentMapContext + AssignmentSet() IAssignmentSetContext + AssignmentList() IAssignmentListContext + DecimalLiteral() IDecimalLiteralContext + PLUS() antlr.TerminalNode + MINUS() antlr.TerminalNode + SyntaxBracketLs() ISyntaxBracketLsContext + SyntaxBracketRs() ISyntaxBracketRsContext + + // IsAssignmentElementContext differentiates from other interfaces. + IsAssignmentElementContext() +} + +type AssignmentElementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAssignmentElementContext() *AssignmentElementContext { + var p = new(AssignmentElementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_assignmentElement + return p +} + +func InitEmptyAssignmentElementContext(p *AssignmentElementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_assignmentElement +} + +func (*AssignmentElementContext) IsAssignmentElementContext() {} + +func NewAssignmentElementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AssignmentElementContext { + var p = new(AssignmentElementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_assignmentElement + + return p +} + +func (s *AssignmentElementContext) GetParser() antlr.Parser { return s.parser } + +func (s *AssignmentElementContext) AllOBJECT_NAME() []antlr.TerminalNode { + return s.GetTokens(CqlParserOBJECT_NAME) +} + +func (s *AssignmentElementContext) OBJECT_NAME(i int) antlr.TerminalNode { + return s.GetToken(CqlParserOBJECT_NAME, i) +} + +func (s *AssignmentElementContext) OPERATOR_EQ() antlr.TerminalNode { + return s.GetToken(CqlParserOPERATOR_EQ, 0) +} + +func (s *AssignmentElementContext) Constant() IConstantContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConstantContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IConstantContext) +} + +func (s *AssignmentElementContext) AssignmentMap() IAssignmentMapContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAssignmentMapContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAssignmentMapContext) +} + +func (s *AssignmentElementContext) AssignmentSet() IAssignmentSetContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAssignmentSetContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAssignmentSetContext) +} + +func (s *AssignmentElementContext) AssignmentList() IAssignmentListContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAssignmentListContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAssignmentListContext) +} + +func (s *AssignmentElementContext) DecimalLiteral() IDecimalLiteralContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDecimalLiteralContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDecimalLiteralContext) +} + +func (s *AssignmentElementContext) PLUS() antlr.TerminalNode { + return s.GetToken(CqlParserPLUS, 0) +} + +func (s *AssignmentElementContext) MINUS() antlr.TerminalNode { + return s.GetToken(CqlParserMINUS, 0) +} + +func (s *AssignmentElementContext) SyntaxBracketLs() ISyntaxBracketLsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISyntaxBracketLsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISyntaxBracketLsContext) +} + +func (s *AssignmentElementContext) SyntaxBracketRs() ISyntaxBracketRsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISyntaxBracketRsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISyntaxBracketRsContext) +} + +func (s *AssignmentElementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AssignmentElementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *AssignmentElementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterAssignmentElement(s) + } +} + +func (s *AssignmentElementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitAssignmentElement(s) + } +} + +func (s *AssignmentElementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitAssignmentElement(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) AssignmentElement() (localctx IAssignmentElementContext) { + localctx = NewAssignmentElementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 224, CqlParserRULE_assignmentElement) + var _la int + + p.SetState(1667) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 130, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1614) + p.Match(CqlParserOBJECT_NAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1615) + p.Match(CqlParserOPERATOR_EQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1620) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 129, p.GetParserRuleContext()) { + case 1: + { + p.SetState(1616) + p.Constant() + } + + case 2: + { + p.SetState(1617) + p.AssignmentMap() + } + + case 3: + { + p.SetState(1618) + p.AssignmentSet() + } + + case 4: + { + p.SetState(1619) + p.AssignmentList() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(1622) + p.Match(CqlParserOBJECT_NAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1623) + p.Match(CqlParserOPERATOR_EQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1624) + p.Match(CqlParserOBJECT_NAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1625) + _la = p.GetTokenStream().LA(1) + + if !(_la == CqlParserPLUS || _la == CqlParserMINUS) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(1626) + p.DecimalLiteral() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(1627) + p.Match(CqlParserOBJECT_NAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1628) + p.Match(CqlParserOPERATOR_EQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1629) + p.Match(CqlParserOBJECT_NAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1630) + _la = p.GetTokenStream().LA(1) + + if !(_la == CqlParserPLUS || _la == CqlParserMINUS) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(1631) + p.AssignmentSet() + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(1632) + p.Match(CqlParserOBJECT_NAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1633) + p.Match(CqlParserOPERATOR_EQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1634) + p.AssignmentSet() + } + { + p.SetState(1635) + _la = p.GetTokenStream().LA(1) + + if !(_la == CqlParserPLUS || _la == CqlParserMINUS) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(1636) + p.Match(CqlParserOBJECT_NAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(1638) + p.Match(CqlParserOBJECT_NAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1639) + p.Match(CqlParserOPERATOR_EQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1640) + p.Match(CqlParserOBJECT_NAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1641) + _la = p.GetTokenStream().LA(1) + + if !(_la == CqlParserPLUS || _la == CqlParserMINUS) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(1642) + p.AssignmentMap() + } + + case 6: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(1643) + p.Match(CqlParserOBJECT_NAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1644) + p.Match(CqlParserOPERATOR_EQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1645) + p.AssignmentMap() + } + { + p.SetState(1646) + _la = p.GetTokenStream().LA(1) + + if !(_la == CqlParserPLUS || _la == CqlParserMINUS) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(1647) + p.Match(CqlParserOBJECT_NAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 7: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(1649) + p.Match(CqlParserOBJECT_NAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1650) + p.Match(CqlParserOPERATOR_EQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1651) + p.Match(CqlParserOBJECT_NAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1652) + _la = p.GetTokenStream().LA(1) + + if !(_la == CqlParserPLUS || _la == CqlParserMINUS) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(1653) + p.AssignmentList() + } + + case 8: + p.EnterOuterAlt(localctx, 8) + { + p.SetState(1654) + p.Match(CqlParserOBJECT_NAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1655) + p.Match(CqlParserOPERATOR_EQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1656) + p.AssignmentList() + } + { + p.SetState(1657) + _la = p.GetTokenStream().LA(1) + + if !(_la == CqlParserPLUS || _la == CqlParserMINUS) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(1658) + p.Match(CqlParserOBJECT_NAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 9: + p.EnterOuterAlt(localctx, 9) + { + p.SetState(1660) + p.Match(CqlParserOBJECT_NAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1661) + p.SyntaxBracketLs() + } + { + p.SetState(1662) + p.DecimalLiteral() + } + { + p.SetState(1663) + p.SyntaxBracketRs() + } + { + p.SetState(1664) + p.Match(CqlParserOPERATOR_EQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1665) + p.Constant() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAssignmentSetContext is an interface to support dynamic dispatch. +type IAssignmentSetContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SyntaxBracketLc() ISyntaxBracketLcContext + SyntaxBracketRc() ISyntaxBracketRcContext + AllConstant() []IConstantContext + Constant(i int) IConstantContext + AllSyntaxComma() []ISyntaxCommaContext + SyntaxComma(i int) ISyntaxCommaContext + + // IsAssignmentSetContext differentiates from other interfaces. + IsAssignmentSetContext() +} + +type AssignmentSetContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAssignmentSetContext() *AssignmentSetContext { + var p = new(AssignmentSetContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_assignmentSet + return p +} + +func InitEmptyAssignmentSetContext(p *AssignmentSetContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_assignmentSet +} + +func (*AssignmentSetContext) IsAssignmentSetContext() {} + +func NewAssignmentSetContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AssignmentSetContext { + var p = new(AssignmentSetContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_assignmentSet + + return p +} + +func (s *AssignmentSetContext) GetParser() antlr.Parser { return s.parser } + +func (s *AssignmentSetContext) SyntaxBracketLc() ISyntaxBracketLcContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISyntaxBracketLcContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISyntaxBracketLcContext) +} + +func (s *AssignmentSetContext) SyntaxBracketRc() ISyntaxBracketRcContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISyntaxBracketRcContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISyntaxBracketRcContext) +} + +func (s *AssignmentSetContext) AllConstant() []IConstantContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IConstantContext); ok { + len++ + } + } + + tst := make([]IConstantContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IConstantContext); ok { + tst[i] = t.(IConstantContext) + i++ + } + } + + return tst +} + +func (s *AssignmentSetContext) Constant(i int) IConstantContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConstantContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IConstantContext) +} + +func (s *AssignmentSetContext) AllSyntaxComma() []ISyntaxCommaContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISyntaxCommaContext); ok { + len++ + } + } + + tst := make([]ISyntaxCommaContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISyntaxCommaContext); ok { + tst[i] = t.(ISyntaxCommaContext) + i++ + } + } + + return tst +} + +func (s *AssignmentSetContext) SyntaxComma(i int) ISyntaxCommaContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISyntaxCommaContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISyntaxCommaContext) +} + +func (s *AssignmentSetContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AssignmentSetContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *AssignmentSetContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterAssignmentSet(s) + } +} + +func (s *AssignmentSetContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitAssignmentSet(s) + } +} + +func (s *AssignmentSetContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitAssignmentSet(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) AssignmentSet() (localctx IAssignmentSetContext) { + localctx = NewAssignmentSetContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 226, CqlParserRULE_assignmentSet) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1669) + p.SyntaxBracketLc() + } + p.SetState(1679) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == CqlParserK_FALSE || _la == CqlParserK_NULL || ((int64((_la-126)) & ^0x3f) == 0 && ((int64(1)<<(_la-126))&43705587204097) != 0) { + { + p.SetState(1670) + p.Constant() + } + p.SetState(1676) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == CqlParserCOMMA { + { + p.SetState(1671) + p.SyntaxComma() + } + { + p.SetState(1672) + p.Constant() + } + + p.SetState(1678) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + } + { + p.SetState(1681) + p.SyntaxBracketRc() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAssignmentMapContext is an interface to support dynamic dispatch. +type IAssignmentMapContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SyntaxBracketLc() ISyntaxBracketLcContext + SyntaxBracketRc() ISyntaxBracketRcContext + AllConstant() []IConstantContext + Constant(i int) IConstantContext + AllSyntaxColon() []ISyntaxColonContext + SyntaxColon(i int) ISyntaxColonContext + AllSyntaxComma() []ISyntaxCommaContext + SyntaxComma(i int) ISyntaxCommaContext + + // IsAssignmentMapContext differentiates from other interfaces. + IsAssignmentMapContext() +} + +type AssignmentMapContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAssignmentMapContext() *AssignmentMapContext { + var p = new(AssignmentMapContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_assignmentMap + return p +} + +func InitEmptyAssignmentMapContext(p *AssignmentMapContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_assignmentMap +} + +func (*AssignmentMapContext) IsAssignmentMapContext() {} + +func NewAssignmentMapContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AssignmentMapContext { + var p = new(AssignmentMapContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_assignmentMap + + return p +} + +func (s *AssignmentMapContext) GetParser() antlr.Parser { return s.parser } + +func (s *AssignmentMapContext) SyntaxBracketLc() ISyntaxBracketLcContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISyntaxBracketLcContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISyntaxBracketLcContext) +} + +func (s *AssignmentMapContext) SyntaxBracketRc() ISyntaxBracketRcContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISyntaxBracketRcContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISyntaxBracketRcContext) +} + +func (s *AssignmentMapContext) AllConstant() []IConstantContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IConstantContext); ok { + len++ + } + } + + tst := make([]IConstantContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IConstantContext); ok { + tst[i] = t.(IConstantContext) + i++ + } + } + + return tst +} + +func (s *AssignmentMapContext) Constant(i int) IConstantContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConstantContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IConstantContext) +} + +func (s *AssignmentMapContext) AllSyntaxColon() []ISyntaxColonContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISyntaxColonContext); ok { + len++ + } + } + + tst := make([]ISyntaxColonContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISyntaxColonContext); ok { + tst[i] = t.(ISyntaxColonContext) + i++ + } + } + + return tst +} + +func (s *AssignmentMapContext) SyntaxColon(i int) ISyntaxColonContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISyntaxColonContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISyntaxColonContext) +} + +func (s *AssignmentMapContext) AllSyntaxComma() []ISyntaxCommaContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISyntaxCommaContext); ok { + len++ + } + } + + tst := make([]ISyntaxCommaContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISyntaxCommaContext); ok { + tst[i] = t.(ISyntaxCommaContext) + i++ + } + } + + return tst +} + +func (s *AssignmentMapContext) SyntaxComma(i int) ISyntaxCommaContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISyntaxCommaContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISyntaxCommaContext) +} + +func (s *AssignmentMapContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AssignmentMapContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *AssignmentMapContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterAssignmentMap(s) + } +} + +func (s *AssignmentMapContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitAssignmentMap(s) + } +} + +func (s *AssignmentMapContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitAssignmentMap(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) AssignmentMap() (localctx IAssignmentMapContext) { + localctx = NewAssignmentMapContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 228, CqlParserRULE_assignmentMap) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1683) + p.SyntaxBracketLc() + } + + { + p.SetState(1684) + p.Constant() + } + { + p.SetState(1685) + p.SyntaxColon() + } + { + p.SetState(1686) + p.Constant() + } + + p.SetState(1695) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == CqlParserCOMMA { + { + p.SetState(1688) + p.SyntaxComma() + } + { + p.SetState(1689) + p.Constant() + } + { + p.SetState(1690) + p.SyntaxColon() + } + { + p.SetState(1691) + p.Constant() + } + + p.SetState(1697) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(1698) + p.SyntaxBracketRc() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAssignmentListContext is an interface to support dynamic dispatch. +type IAssignmentListContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SyntaxBracketLs() ISyntaxBracketLsContext + AllConstant() []IConstantContext + Constant(i int) IConstantContext + SyntaxBracketRs() ISyntaxBracketRsContext + AllSyntaxComma() []ISyntaxCommaContext + SyntaxComma(i int) ISyntaxCommaContext + + // IsAssignmentListContext differentiates from other interfaces. + IsAssignmentListContext() +} + +type AssignmentListContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAssignmentListContext() *AssignmentListContext { + var p = new(AssignmentListContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_assignmentList + return p +} + +func InitEmptyAssignmentListContext(p *AssignmentListContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_assignmentList +} + +func (*AssignmentListContext) IsAssignmentListContext() {} + +func NewAssignmentListContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AssignmentListContext { + var p = new(AssignmentListContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_assignmentList + + return p +} + +func (s *AssignmentListContext) GetParser() antlr.Parser { return s.parser } + +func (s *AssignmentListContext) SyntaxBracketLs() ISyntaxBracketLsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISyntaxBracketLsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISyntaxBracketLsContext) +} + +func (s *AssignmentListContext) AllConstant() []IConstantContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IConstantContext); ok { + len++ + } + } + + tst := make([]IConstantContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IConstantContext); ok { + tst[i] = t.(IConstantContext) + i++ + } + } + + return tst +} + +func (s *AssignmentListContext) Constant(i int) IConstantContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConstantContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IConstantContext) +} + +func (s *AssignmentListContext) SyntaxBracketRs() ISyntaxBracketRsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISyntaxBracketRsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISyntaxBracketRsContext) +} + +func (s *AssignmentListContext) AllSyntaxComma() []ISyntaxCommaContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISyntaxCommaContext); ok { + len++ + } + } + + tst := make([]ISyntaxCommaContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISyntaxCommaContext); ok { + tst[i] = t.(ISyntaxCommaContext) + i++ + } + } + + return tst +} + +func (s *AssignmentListContext) SyntaxComma(i int) ISyntaxCommaContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISyntaxCommaContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISyntaxCommaContext) +} + +func (s *AssignmentListContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AssignmentListContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *AssignmentListContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterAssignmentList(s) + } +} + +func (s *AssignmentListContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitAssignmentList(s) + } +} + +func (s *AssignmentListContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitAssignmentList(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) AssignmentList() (localctx IAssignmentListContext) { + localctx = NewAssignmentListContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 230, CqlParserRULE_assignmentList) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1700) + p.SyntaxBracketLs() + } + { + p.SetState(1701) + p.Constant() + } + p.SetState(1707) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == CqlParserCOMMA { + { + p.SetState(1702) + p.SyntaxComma() + } + { + p.SetState(1703) + p.Constant() + } + + p.SetState(1709) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(1710) + p.SyntaxBracketRs() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAssignmentTupleContext is an interface to support dynamic dispatch. +type IAssignmentTupleContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SyntaxBracketLr() ISyntaxBracketLrContext + SyntaxBracketRr() ISyntaxBracketRrContext + AllExpression() []IExpressionContext + Expression(i int) IExpressionContext + AllSyntaxComma() []ISyntaxCommaContext + SyntaxComma(i int) ISyntaxCommaContext + + // IsAssignmentTupleContext differentiates from other interfaces. + IsAssignmentTupleContext() +} + +type AssignmentTupleContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAssignmentTupleContext() *AssignmentTupleContext { + var p = new(AssignmentTupleContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_assignmentTuple + return p +} + +func InitEmptyAssignmentTupleContext(p *AssignmentTupleContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_assignmentTuple +} + +func (*AssignmentTupleContext) IsAssignmentTupleContext() {} + +func NewAssignmentTupleContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AssignmentTupleContext { + var p = new(AssignmentTupleContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_assignmentTuple + + return p +} + +func (s *AssignmentTupleContext) GetParser() antlr.Parser { return s.parser } + +func (s *AssignmentTupleContext) SyntaxBracketLr() ISyntaxBracketLrContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISyntaxBracketLrContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISyntaxBracketLrContext) +} + +func (s *AssignmentTupleContext) SyntaxBracketRr() ISyntaxBracketRrContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISyntaxBracketRrContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISyntaxBracketRrContext) +} + +func (s *AssignmentTupleContext) AllExpression() []IExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpressionContext); ok { + len++ + } + } + + tst := make([]IExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpressionContext); ok { + tst[i] = t.(IExpressionContext) + i++ + } + } + + return tst +} + +func (s *AssignmentTupleContext) Expression(i int) IExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *AssignmentTupleContext) AllSyntaxComma() []ISyntaxCommaContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISyntaxCommaContext); ok { + len++ + } + } + + tst := make([]ISyntaxCommaContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISyntaxCommaContext); ok { + tst[i] = t.(ISyntaxCommaContext) + i++ + } + } + + return tst +} + +func (s *AssignmentTupleContext) SyntaxComma(i int) ISyntaxCommaContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISyntaxCommaContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISyntaxCommaContext) +} + +func (s *AssignmentTupleContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AssignmentTupleContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *AssignmentTupleContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterAssignmentTuple(s) + } +} + +func (s *AssignmentTupleContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitAssignmentTuple(s) + } +} + +func (s *AssignmentTupleContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitAssignmentTuple(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) AssignmentTuple() (localctx IAssignmentTupleContext) { + localctx = NewAssignmentTupleContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 232, CqlParserRULE_assignmentTuple) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1712) + p.SyntaxBracketLr() + } + + { + p.SetState(1713) + p.Expression() + } + p.SetState(1719) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == CqlParserCOMMA { + { + p.SetState(1714) + p.SyntaxComma() + } + { + p.SetState(1715) + p.Expression() + } + + p.SetState(1721) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + { + p.SetState(1722) + p.SyntaxBracketRr() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IInsertContext is an interface to support dynamic dispatch. +type IInsertContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + KwInsert() IKwInsertContext + KwInto() IKwIntoContext + Table() ITableContext + InsertValuesSpec() IInsertValuesSpecContext + BeginBatch() IBeginBatchContext + Keyspace() IKeyspaceContext + DOT() antlr.TerminalNode + InsertColumnSpec() IInsertColumnSpecContext + IfNotExist() IIfNotExistContext + UsingTtlTimestamp() IUsingTtlTimestampContext + + // IsInsertContext differentiates from other interfaces. + IsInsertContext() +} + +type InsertContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyInsertContext() *InsertContext { + var p = new(InsertContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_insert + return p +} + +func InitEmptyInsertContext(p *InsertContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_insert +} + +func (*InsertContext) IsInsertContext() {} + +func NewInsertContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *InsertContext { + var p = new(InsertContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_insert + + return p +} + +func (s *InsertContext) GetParser() antlr.Parser { return s.parser } + +func (s *InsertContext) KwInsert() IKwInsertContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwInsertContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwInsertContext) +} + +func (s *InsertContext) KwInto() IKwIntoContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwIntoContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwIntoContext) +} + +func (s *InsertContext) Table() ITableContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITableContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITableContext) +} + +func (s *InsertContext) InsertValuesSpec() IInsertValuesSpecContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IInsertValuesSpecContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IInsertValuesSpecContext) +} + +func (s *InsertContext) BeginBatch() IBeginBatchContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IBeginBatchContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IBeginBatchContext) +} + +func (s *InsertContext) Keyspace() IKeyspaceContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKeyspaceContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKeyspaceContext) +} + +func (s *InsertContext) DOT() antlr.TerminalNode { + return s.GetToken(CqlParserDOT, 0) +} + +func (s *InsertContext) InsertColumnSpec() IInsertColumnSpecContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IInsertColumnSpecContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IInsertColumnSpecContext) +} + +func (s *InsertContext) IfNotExist() IIfNotExistContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIfNotExistContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIfNotExistContext) +} + +func (s *InsertContext) UsingTtlTimestamp() IUsingTtlTimestampContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUsingTtlTimestampContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUsingTtlTimestampContext) +} + +func (s *InsertContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *InsertContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *InsertContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterInsert(s) + } +} + +func (s *InsertContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitInsert(s) + } +} + +func (s *InsertContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitInsert(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) Insert() (localctx IInsertContext) { + localctx = NewInsertContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 234, CqlParserRULE_insert) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(1725) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == CqlParserK_BEGIN { + { + p.SetState(1724) + p.BeginBatch() + } + + } + { + p.SetState(1727) + p.KwInsert() + } + { + p.SetState(1728) + p.KwInto() + } + p.SetState(1732) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 137, p.GetParserRuleContext()) == 1 { + { + p.SetState(1729) + p.Keyspace() + } + { + p.SetState(1730) + p.Match(CqlParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(1734) + p.Table() + } + p.SetState(1736) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == CqlParserLR_BRACKET { + { + p.SetState(1735) + p.InsertColumnSpec() + } + + } + { + p.SetState(1738) + p.InsertValuesSpec() + } + p.SetState(1740) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == CqlParserK_IF { + { + p.SetState(1739) + p.IfNotExist() + } + + } + p.SetState(1743) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == CqlParserK_USING { + { + p.SetState(1742) + p.UsingTtlTimestamp() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IUsingTtlTimestampContext is an interface to support dynamic dispatch. +type IUsingTtlTimestampContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + KwUsing() IKwUsingContext + Ttl() ITtlContext + KwAnd() IKwAndContext + Timestamp() ITimestampContext + + // IsUsingTtlTimestampContext differentiates from other interfaces. + IsUsingTtlTimestampContext() +} + +type UsingTtlTimestampContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyUsingTtlTimestampContext() *UsingTtlTimestampContext { + var p = new(UsingTtlTimestampContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_usingTtlTimestamp + return p +} + +func InitEmptyUsingTtlTimestampContext(p *UsingTtlTimestampContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_usingTtlTimestamp +} + +func (*UsingTtlTimestampContext) IsUsingTtlTimestampContext() {} + +func NewUsingTtlTimestampContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *UsingTtlTimestampContext { + var p = new(UsingTtlTimestampContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_usingTtlTimestamp + + return p +} + +func (s *UsingTtlTimestampContext) GetParser() antlr.Parser { return s.parser } + +func (s *UsingTtlTimestampContext) KwUsing() IKwUsingContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwUsingContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwUsingContext) +} + +func (s *UsingTtlTimestampContext) Ttl() ITtlContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITtlContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITtlContext) +} + +func (s *UsingTtlTimestampContext) KwAnd() IKwAndContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwAndContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwAndContext) +} + +func (s *UsingTtlTimestampContext) Timestamp() ITimestampContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITimestampContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITimestampContext) +} + +func (s *UsingTtlTimestampContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *UsingTtlTimestampContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *UsingTtlTimestampContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterUsingTtlTimestamp(s) + } +} + +func (s *UsingTtlTimestampContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitUsingTtlTimestamp(s) + } +} + +func (s *UsingTtlTimestampContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitUsingTtlTimestamp(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) UsingTtlTimestamp() (localctx IUsingTtlTimestampContext) { + localctx = NewUsingTtlTimestampContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 236, CqlParserRULE_usingTtlTimestamp) + p.SetState(1761) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 141, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1745) + p.KwUsing() + } + { + p.SetState(1746) + p.Ttl() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(1748) + p.KwUsing() + } + { + p.SetState(1749) + p.Ttl() + } + { + p.SetState(1750) + p.KwAnd() + } + { + p.SetState(1751) + p.Timestamp() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(1753) + p.KwUsing() + } + { + p.SetState(1754) + p.Timestamp() + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(1756) + p.KwUsing() + } + { + p.SetState(1757) + p.Timestamp() + } + { + p.SetState(1758) + p.KwAnd() + } + { + p.SetState(1759) + p.Ttl() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ITimestampContext is an interface to support dynamic dispatch. +type ITimestampContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + KwTimestamp() IKwTimestampContext + DecimalLiteral() IDecimalLiteralContext + + // IsTimestampContext differentiates from other interfaces. + IsTimestampContext() +} + +type TimestampContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTimestampContext() *TimestampContext { + var p = new(TimestampContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_timestamp + return p +} + +func InitEmptyTimestampContext(p *TimestampContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_timestamp +} + +func (*TimestampContext) IsTimestampContext() {} + +func NewTimestampContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TimestampContext { + var p = new(TimestampContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_timestamp + + return p +} + +func (s *TimestampContext) GetParser() antlr.Parser { return s.parser } + +func (s *TimestampContext) KwTimestamp() IKwTimestampContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwTimestampContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwTimestampContext) +} + +func (s *TimestampContext) DecimalLiteral() IDecimalLiteralContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDecimalLiteralContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDecimalLiteralContext) +} + +func (s *TimestampContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *TimestampContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *TimestampContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterTimestamp(s) + } +} + +func (s *TimestampContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitTimestamp(s) + } +} + +func (s *TimestampContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitTimestamp(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) Timestamp() (localctx ITimestampContext) { + localctx = NewTimestampContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 238, CqlParserRULE_timestamp) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1763) + p.KwTimestamp() + } + { + p.SetState(1764) + p.DecimalLiteral() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ITtlContext is an interface to support dynamic dispatch. +type ITtlContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + KwTtl() IKwTtlContext + DecimalLiteral() IDecimalLiteralContext + + // IsTtlContext differentiates from other interfaces. + IsTtlContext() +} + +type TtlContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTtlContext() *TtlContext { + var p = new(TtlContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_ttl + return p +} + +func InitEmptyTtlContext(p *TtlContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_ttl +} + +func (*TtlContext) IsTtlContext() {} + +func NewTtlContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TtlContext { + var p = new(TtlContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_ttl + + return p +} + +func (s *TtlContext) GetParser() antlr.Parser { return s.parser } + +func (s *TtlContext) KwTtl() IKwTtlContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwTtlContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwTtlContext) +} + +func (s *TtlContext) DecimalLiteral() IDecimalLiteralContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDecimalLiteralContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDecimalLiteralContext) +} + +func (s *TtlContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *TtlContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *TtlContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterTtl(s) + } +} + +func (s *TtlContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitTtl(s) + } +} + +func (s *TtlContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitTtl(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) Ttl() (localctx ITtlContext) { + localctx = NewTtlContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 240, CqlParserRULE_ttl) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1766) + p.KwTtl() + } + { + p.SetState(1767) + p.DecimalLiteral() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IUsingTimestampSpecContext is an interface to support dynamic dispatch. +type IUsingTimestampSpecContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + KwUsing() IKwUsingContext + Timestamp() ITimestampContext + + // IsUsingTimestampSpecContext differentiates from other interfaces. + IsUsingTimestampSpecContext() +} + +type UsingTimestampSpecContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyUsingTimestampSpecContext() *UsingTimestampSpecContext { + var p = new(UsingTimestampSpecContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_usingTimestampSpec + return p +} + +func InitEmptyUsingTimestampSpecContext(p *UsingTimestampSpecContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_usingTimestampSpec +} + +func (*UsingTimestampSpecContext) IsUsingTimestampSpecContext() {} + +func NewUsingTimestampSpecContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *UsingTimestampSpecContext { + var p = new(UsingTimestampSpecContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_usingTimestampSpec + + return p +} + +func (s *UsingTimestampSpecContext) GetParser() antlr.Parser { return s.parser } + +func (s *UsingTimestampSpecContext) KwUsing() IKwUsingContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwUsingContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwUsingContext) +} + +func (s *UsingTimestampSpecContext) Timestamp() ITimestampContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITimestampContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITimestampContext) +} + +func (s *UsingTimestampSpecContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *UsingTimestampSpecContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *UsingTimestampSpecContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterUsingTimestampSpec(s) + } +} + +func (s *UsingTimestampSpecContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitUsingTimestampSpec(s) + } +} + +func (s *UsingTimestampSpecContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitUsingTimestampSpec(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) UsingTimestampSpec() (localctx IUsingTimestampSpecContext) { + localctx = NewUsingTimestampSpecContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 242, CqlParserRULE_usingTimestampSpec) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1769) + p.KwUsing() + } + { + p.SetState(1770) + p.Timestamp() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IIfNotExistContext is an interface to support dynamic dispatch. +type IIfNotExistContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + KwIf() IKwIfContext + KwNot() IKwNotContext + KwExists() IKwExistsContext + + // IsIfNotExistContext differentiates from other interfaces. + IsIfNotExistContext() +} + +type IfNotExistContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyIfNotExistContext() *IfNotExistContext { + var p = new(IfNotExistContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_ifNotExist + return p +} + +func InitEmptyIfNotExistContext(p *IfNotExistContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_ifNotExist +} + +func (*IfNotExistContext) IsIfNotExistContext() {} + +func NewIfNotExistContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *IfNotExistContext { + var p = new(IfNotExistContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_ifNotExist + + return p +} + +func (s *IfNotExistContext) GetParser() antlr.Parser { return s.parser } + +func (s *IfNotExistContext) KwIf() IKwIfContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwIfContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwIfContext) +} + +func (s *IfNotExistContext) KwNot() IKwNotContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwNotContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwNotContext) +} + +func (s *IfNotExistContext) KwExists() IKwExistsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwExistsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwExistsContext) +} + +func (s *IfNotExistContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *IfNotExistContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *IfNotExistContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterIfNotExist(s) + } +} + +func (s *IfNotExistContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitIfNotExist(s) + } +} + +func (s *IfNotExistContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitIfNotExist(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) IfNotExist() (localctx IIfNotExistContext) { + localctx = NewIfNotExistContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 244, CqlParserRULE_ifNotExist) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1772) + p.KwIf() + } + { + p.SetState(1773) + p.KwNot() + } + { + p.SetState(1774) + p.KwExists() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IIfExistContext is an interface to support dynamic dispatch. +type IIfExistContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + KwIf() IKwIfContext + KwExists() IKwExistsContext + + // IsIfExistContext differentiates from other interfaces. + IsIfExistContext() +} + +type IfExistContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyIfExistContext() *IfExistContext { + var p = new(IfExistContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_ifExist + return p +} + +func InitEmptyIfExistContext(p *IfExistContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_ifExist +} + +func (*IfExistContext) IsIfExistContext() {} + +func NewIfExistContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *IfExistContext { + var p = new(IfExistContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_ifExist + + return p +} + +func (s *IfExistContext) GetParser() antlr.Parser { return s.parser } + +func (s *IfExistContext) KwIf() IKwIfContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwIfContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwIfContext) +} + +func (s *IfExistContext) KwExists() IKwExistsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwExistsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwExistsContext) +} + +func (s *IfExistContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *IfExistContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *IfExistContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterIfExist(s) + } +} + +func (s *IfExistContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitIfExist(s) + } +} + +func (s *IfExistContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitIfExist(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) IfExist() (localctx IIfExistContext) { + localctx = NewIfExistContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 246, CqlParserRULE_ifExist) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1776) + p.KwIf() + } + { + p.SetState(1777) + p.KwExists() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IInsertValuesSpecContext is an interface to support dynamic dispatch. +type IInsertValuesSpecContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + KwValues() IKwValuesContext + LR_BRACKET() antlr.TerminalNode + ExpressionList() IExpressionListContext + RR_BRACKET() antlr.TerminalNode + KwJson() IKwJsonContext + Constant() IConstantContext + + // IsInsertValuesSpecContext differentiates from other interfaces. + IsInsertValuesSpecContext() +} + +type InsertValuesSpecContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyInsertValuesSpecContext() *InsertValuesSpecContext { + var p = new(InsertValuesSpecContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_insertValuesSpec + return p +} + +func InitEmptyInsertValuesSpecContext(p *InsertValuesSpecContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_insertValuesSpec +} + +func (*InsertValuesSpecContext) IsInsertValuesSpecContext() {} + +func NewInsertValuesSpecContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *InsertValuesSpecContext { + var p = new(InsertValuesSpecContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_insertValuesSpec + + return p +} + +func (s *InsertValuesSpecContext) GetParser() antlr.Parser { return s.parser } + +func (s *InsertValuesSpecContext) KwValues() IKwValuesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwValuesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwValuesContext) +} + +func (s *InsertValuesSpecContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(CqlParserLR_BRACKET, 0) +} + +func (s *InsertValuesSpecContext) ExpressionList() IExpressionListContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionListContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionListContext) +} + +func (s *InsertValuesSpecContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(CqlParserRR_BRACKET, 0) +} + +func (s *InsertValuesSpecContext) KwJson() IKwJsonContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwJsonContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwJsonContext) +} + +func (s *InsertValuesSpecContext) Constant() IConstantContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConstantContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IConstantContext) +} + +func (s *InsertValuesSpecContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *InsertValuesSpecContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *InsertValuesSpecContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterInsertValuesSpec(s) + } +} + +func (s *InsertValuesSpecContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitInsertValuesSpec(s) + } +} + +func (s *InsertValuesSpecContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitInsertValuesSpec(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) InsertValuesSpec() (localctx IInsertValuesSpecContext) { + localctx = NewInsertValuesSpecContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 248, CqlParserRULE_insertValuesSpec) + p.SetState(1787) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case CqlParserK_VALUES: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1779) + p.KwValues() + } + { + p.SetState(1780) + p.Match(CqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1781) + p.ExpressionList() + } + { + p.SetState(1782) + p.Match(CqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case CqlParserK_JSON: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(1784) + p.KwJson() + } + { + p.SetState(1785) + p.Constant() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IInsertColumnSpecContext is an interface to support dynamic dispatch. +type IInsertColumnSpecContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + LR_BRACKET() antlr.TerminalNode + ColumnList() IColumnListContext + RR_BRACKET() antlr.TerminalNode + + // IsInsertColumnSpecContext differentiates from other interfaces. + IsInsertColumnSpecContext() +} + +type InsertColumnSpecContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyInsertColumnSpecContext() *InsertColumnSpecContext { + var p = new(InsertColumnSpecContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_insertColumnSpec + return p +} + +func InitEmptyInsertColumnSpecContext(p *InsertColumnSpecContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_insertColumnSpec +} + +func (*InsertColumnSpecContext) IsInsertColumnSpecContext() {} + +func NewInsertColumnSpecContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *InsertColumnSpecContext { + var p = new(InsertColumnSpecContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_insertColumnSpec + + return p +} + +func (s *InsertColumnSpecContext) GetParser() antlr.Parser { return s.parser } + +func (s *InsertColumnSpecContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(CqlParserLR_BRACKET, 0) +} + +func (s *InsertColumnSpecContext) ColumnList() IColumnListContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumnListContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumnListContext) +} + +func (s *InsertColumnSpecContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(CqlParserRR_BRACKET, 0) +} + +func (s *InsertColumnSpecContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *InsertColumnSpecContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *InsertColumnSpecContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterInsertColumnSpec(s) + } +} + +func (s *InsertColumnSpecContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitInsertColumnSpec(s) + } +} + +func (s *InsertColumnSpecContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitInsertColumnSpec(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) InsertColumnSpec() (localctx IInsertColumnSpecContext) { + localctx = NewInsertColumnSpecContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 250, CqlParserRULE_insertColumnSpec) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1789) + p.Match(CqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1790) + p.ColumnList() + } + { + p.SetState(1791) + p.Match(CqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IColumnListContext is an interface to support dynamic dispatch. +type IColumnListContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllColumn() []IColumnContext + Column(i int) IColumnContext + AllSyntaxComma() []ISyntaxCommaContext + SyntaxComma(i int) ISyntaxCommaContext + + // IsColumnListContext differentiates from other interfaces. + IsColumnListContext() +} + +type ColumnListContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyColumnListContext() *ColumnListContext { + var p = new(ColumnListContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_columnList + return p +} + +func InitEmptyColumnListContext(p *ColumnListContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_columnList +} + +func (*ColumnListContext) IsColumnListContext() {} + +func NewColumnListContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ColumnListContext { + var p = new(ColumnListContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_columnList + + return p +} + +func (s *ColumnListContext) GetParser() antlr.Parser { return s.parser } + +func (s *ColumnListContext) AllColumn() []IColumnContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IColumnContext); ok { + len++ + } + } + + tst := make([]IColumnContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IColumnContext); ok { + tst[i] = t.(IColumnContext) + i++ + } + } + + return tst +} + +func (s *ColumnListContext) Column(i int) IColumnContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumnContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IColumnContext) +} + +func (s *ColumnListContext) AllSyntaxComma() []ISyntaxCommaContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISyntaxCommaContext); ok { + len++ + } + } + + tst := make([]ISyntaxCommaContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISyntaxCommaContext); ok { + tst[i] = t.(ISyntaxCommaContext) + i++ + } + } + + return tst +} + +func (s *ColumnListContext) SyntaxComma(i int) ISyntaxCommaContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISyntaxCommaContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISyntaxCommaContext) +} + +func (s *ColumnListContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ColumnListContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ColumnListContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterColumnList(s) + } +} + +func (s *ColumnListContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitColumnList(s) + } +} + +func (s *ColumnListContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitColumnList(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) ColumnList() (localctx IColumnListContext) { + localctx = NewColumnListContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 252, CqlParserRULE_columnList) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1793) + p.Column() + } + p.SetState(1799) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == CqlParserCOMMA { + { + p.SetState(1794) + p.SyntaxComma() + } + { + p.SetState(1795) + p.Column() + } + + p.SetState(1801) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IExpressionListContext is an interface to support dynamic dispatch. +type IExpressionListContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllExpression() []IExpressionContext + Expression(i int) IExpressionContext + AllSyntaxComma() []ISyntaxCommaContext + SyntaxComma(i int) ISyntaxCommaContext + + // IsExpressionListContext differentiates from other interfaces. + IsExpressionListContext() +} + +type ExpressionListContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyExpressionListContext() *ExpressionListContext { + var p = new(ExpressionListContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_expressionList + return p +} + +func InitEmptyExpressionListContext(p *ExpressionListContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_expressionList +} + +func (*ExpressionListContext) IsExpressionListContext() {} + +func NewExpressionListContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ExpressionListContext { + var p = new(ExpressionListContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_expressionList + + return p +} + +func (s *ExpressionListContext) GetParser() antlr.Parser { return s.parser } + +func (s *ExpressionListContext) AllExpression() []IExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpressionContext); ok { + len++ + } + } + + tst := make([]IExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpressionContext); ok { + tst[i] = t.(IExpressionContext) + i++ + } + } + + return tst +} + +func (s *ExpressionListContext) Expression(i int) IExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *ExpressionListContext) AllSyntaxComma() []ISyntaxCommaContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISyntaxCommaContext); ok { + len++ + } + } + + tst := make([]ISyntaxCommaContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISyntaxCommaContext); ok { + tst[i] = t.(ISyntaxCommaContext) + i++ + } + } + + return tst +} + +func (s *ExpressionListContext) SyntaxComma(i int) ISyntaxCommaContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISyntaxCommaContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISyntaxCommaContext) +} + +func (s *ExpressionListContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ExpressionListContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ExpressionListContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterExpressionList(s) + } +} + +func (s *ExpressionListContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitExpressionList(s) + } +} + +func (s *ExpressionListContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitExpressionList(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) ExpressionList() (localctx IExpressionListContext) { + localctx = NewExpressionListContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 254, CqlParserRULE_expressionList) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1802) + p.Expression() + } + p.SetState(1808) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == CqlParserCOMMA { + { + p.SetState(1803) + p.SyntaxComma() + } + { + p.SetState(1804) + p.Expression() + } + + p.SetState(1810) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IExpressionContext is an interface to support dynamic dispatch. +type IExpressionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Constant() IConstantContext + FunctionCall() IFunctionCallContext + AssignmentMap() IAssignmentMapContext + AssignmentSet() IAssignmentSetContext + AssignmentList() IAssignmentListContext + AssignmentTuple() IAssignmentTupleContext + + // IsExpressionContext differentiates from other interfaces. + IsExpressionContext() +} + +type ExpressionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyExpressionContext() *ExpressionContext { + var p = new(ExpressionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_expression + return p +} + +func InitEmptyExpressionContext(p *ExpressionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_expression +} + +func (*ExpressionContext) IsExpressionContext() {} + +func NewExpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ExpressionContext { + var p = new(ExpressionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_expression + + return p +} + +func (s *ExpressionContext) GetParser() antlr.Parser { return s.parser } + +func (s *ExpressionContext) Constant() IConstantContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConstantContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IConstantContext) +} + +func (s *ExpressionContext) FunctionCall() IFunctionCallContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunctionCallContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFunctionCallContext) +} + +func (s *ExpressionContext) AssignmentMap() IAssignmentMapContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAssignmentMapContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAssignmentMapContext) +} + +func (s *ExpressionContext) AssignmentSet() IAssignmentSetContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAssignmentSetContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAssignmentSetContext) +} + +func (s *ExpressionContext) AssignmentList() IAssignmentListContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAssignmentListContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAssignmentListContext) +} + +func (s *ExpressionContext) AssignmentTuple() IAssignmentTupleContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAssignmentTupleContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAssignmentTupleContext) +} + +func (s *ExpressionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ExpressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ExpressionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterExpression(s) + } +} + +func (s *ExpressionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitExpression(s) + } +} + +func (s *ExpressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitExpression(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) Expression() (localctx IExpressionContext) { + localctx = NewExpressionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 256, CqlParserRULE_expression) + p.SetState(1817) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 145, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1811) + p.Constant() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(1812) + p.FunctionCall() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(1813) + p.AssignmentMap() + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(1814) + p.AssignmentSet() + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(1815) + p.AssignmentList() + } + + case 6: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(1816) + p.AssignmentTuple() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISelect_Context is an interface to support dynamic dispatch. +type ISelect_Context interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + KwSelect() IKwSelectContext + SelectElements() ISelectElementsContext + FromSpec() IFromSpecContext + DistinctSpec() IDistinctSpecContext + KwJson() IKwJsonContext + WhereSpec() IWhereSpecContext + OrderSpec() IOrderSpecContext + LimitSpec() ILimitSpecContext + AllowFilteringSpec() IAllowFilteringSpecContext + + // IsSelect_Context differentiates from other interfaces. + IsSelect_Context() +} + +type Select_Context struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySelect_Context() *Select_Context { + var p = new(Select_Context) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_select_ + return p +} + +func InitEmptySelect_Context(p *Select_Context) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_select_ +} + +func (*Select_Context) IsSelect_Context() {} + +func NewSelect_Context(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Select_Context { + var p = new(Select_Context) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_select_ + + return p +} + +func (s *Select_Context) GetParser() antlr.Parser { return s.parser } + +func (s *Select_Context) KwSelect() IKwSelectContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwSelectContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwSelectContext) +} + +func (s *Select_Context) SelectElements() ISelectElementsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISelectElementsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISelectElementsContext) +} + +func (s *Select_Context) FromSpec() IFromSpecContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFromSpecContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFromSpecContext) +} + +func (s *Select_Context) DistinctSpec() IDistinctSpecContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDistinctSpecContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDistinctSpecContext) +} + +func (s *Select_Context) KwJson() IKwJsonContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwJsonContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwJsonContext) +} + +func (s *Select_Context) WhereSpec() IWhereSpecContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWhereSpecContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWhereSpecContext) +} + +func (s *Select_Context) OrderSpec() IOrderSpecContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOrderSpecContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOrderSpecContext) +} + +func (s *Select_Context) LimitSpec() ILimitSpecContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILimitSpecContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILimitSpecContext) +} + +func (s *Select_Context) AllowFilteringSpec() IAllowFilteringSpecContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAllowFilteringSpecContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAllowFilteringSpecContext) +} + +func (s *Select_Context) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Select_Context) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Select_Context) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterSelect_(s) + } +} + +func (s *Select_Context) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitSelect_(s) + } +} + +func (s *Select_Context) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitSelect_(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) Select_() (localctx ISelect_Context) { + localctx = NewSelect_Context(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 258, CqlParserRULE_select_) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1819) + p.KwSelect() + } + p.SetState(1821) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == CqlParserK_DISTINCT { + { + p.SetState(1820) + p.DistinctSpec() + } + + } + p.SetState(1824) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == CqlParserK_JSON { + { + p.SetState(1823) + p.KwJson() + } + + } + { + p.SetState(1826) + p.SelectElements() + } + { + p.SetState(1827) + p.FromSpec() + } + p.SetState(1829) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == CqlParserK_WHERE { + { + p.SetState(1828) + p.WhereSpec() + } + + } + p.SetState(1832) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == CqlParserK_ORDER { + { + p.SetState(1831) + p.OrderSpec() + } + + } + p.SetState(1835) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == CqlParserK_LIMIT { + { + p.SetState(1834) + p.LimitSpec() + } + + } + p.SetState(1838) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == CqlParserK_ALLOW { + { + p.SetState(1837) + p.AllowFilteringSpec() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAllowFilteringSpecContext is an interface to support dynamic dispatch. +type IAllowFilteringSpecContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + KwAllow() IKwAllowContext + KwFiltering() IKwFilteringContext + + // IsAllowFilteringSpecContext differentiates from other interfaces. + IsAllowFilteringSpecContext() +} + +type AllowFilteringSpecContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAllowFilteringSpecContext() *AllowFilteringSpecContext { + var p = new(AllowFilteringSpecContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_allowFilteringSpec + return p +} + +func InitEmptyAllowFilteringSpecContext(p *AllowFilteringSpecContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_allowFilteringSpec +} + +func (*AllowFilteringSpecContext) IsAllowFilteringSpecContext() {} + +func NewAllowFilteringSpecContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AllowFilteringSpecContext { + var p = new(AllowFilteringSpecContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_allowFilteringSpec + + return p +} + +func (s *AllowFilteringSpecContext) GetParser() antlr.Parser { return s.parser } + +func (s *AllowFilteringSpecContext) KwAllow() IKwAllowContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwAllowContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwAllowContext) +} + +func (s *AllowFilteringSpecContext) KwFiltering() IKwFilteringContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwFilteringContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwFilteringContext) +} + +func (s *AllowFilteringSpecContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AllowFilteringSpecContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *AllowFilteringSpecContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterAllowFilteringSpec(s) + } +} + +func (s *AllowFilteringSpecContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitAllowFilteringSpec(s) + } +} + +func (s *AllowFilteringSpecContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitAllowFilteringSpec(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) AllowFilteringSpec() (localctx IAllowFilteringSpecContext) { + localctx = NewAllowFilteringSpecContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 260, CqlParserRULE_allowFilteringSpec) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1840) + p.KwAllow() + } + { + p.SetState(1841) + p.KwFiltering() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ILimitSpecContext is an interface to support dynamic dispatch. +type ILimitSpecContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + KwLimit() IKwLimitContext + DecimalLiteral() IDecimalLiteralContext + + // IsLimitSpecContext differentiates from other interfaces. + IsLimitSpecContext() +} + +type LimitSpecContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyLimitSpecContext() *LimitSpecContext { + var p = new(LimitSpecContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_limitSpec + return p +} + +func InitEmptyLimitSpecContext(p *LimitSpecContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_limitSpec +} + +func (*LimitSpecContext) IsLimitSpecContext() {} + +func NewLimitSpecContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *LimitSpecContext { + var p = new(LimitSpecContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_limitSpec + + return p +} + +func (s *LimitSpecContext) GetParser() antlr.Parser { return s.parser } + +func (s *LimitSpecContext) KwLimit() IKwLimitContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwLimitContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwLimitContext) +} + +func (s *LimitSpecContext) DecimalLiteral() IDecimalLiteralContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDecimalLiteralContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDecimalLiteralContext) +} + +func (s *LimitSpecContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *LimitSpecContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *LimitSpecContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterLimitSpec(s) + } +} + +func (s *LimitSpecContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitLimitSpec(s) + } +} + +func (s *LimitSpecContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitLimitSpec(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) LimitSpec() (localctx ILimitSpecContext) { + localctx = NewLimitSpecContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 262, CqlParserRULE_limitSpec) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1843) + p.KwLimit() + } + { + p.SetState(1844) + p.DecimalLiteral() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IFromSpecContext is an interface to support dynamic dispatch. +type IFromSpecContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + KwFrom() IKwFromContext + FromSpecElement() IFromSpecElementContext + + // IsFromSpecContext differentiates from other interfaces. + IsFromSpecContext() +} + +type FromSpecContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFromSpecContext() *FromSpecContext { + var p = new(FromSpecContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_fromSpec + return p +} + +func InitEmptyFromSpecContext(p *FromSpecContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_fromSpec +} + +func (*FromSpecContext) IsFromSpecContext() {} + +func NewFromSpecContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FromSpecContext { + var p = new(FromSpecContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_fromSpec + + return p +} + +func (s *FromSpecContext) GetParser() antlr.Parser { return s.parser } + +func (s *FromSpecContext) KwFrom() IKwFromContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwFromContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwFromContext) +} + +func (s *FromSpecContext) FromSpecElement() IFromSpecElementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFromSpecElementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFromSpecElementContext) +} + +func (s *FromSpecContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *FromSpecContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *FromSpecContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterFromSpec(s) + } +} + +func (s *FromSpecContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitFromSpec(s) + } +} + +func (s *FromSpecContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitFromSpec(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) FromSpec() (localctx IFromSpecContext) { + localctx = NewFromSpecContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 264, CqlParserRULE_fromSpec) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1846) + p.KwFrom() + } + { + p.SetState(1847) + p.FromSpecElement() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IFromSpecElementContext is an interface to support dynamic dispatch. +type IFromSpecElementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllOBJECT_NAME() []antlr.TerminalNode + OBJECT_NAME(i int) antlr.TerminalNode + DOT() antlr.TerminalNode + + // IsFromSpecElementContext differentiates from other interfaces. + IsFromSpecElementContext() +} + +type FromSpecElementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFromSpecElementContext() *FromSpecElementContext { + var p = new(FromSpecElementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_fromSpecElement + return p +} + +func InitEmptyFromSpecElementContext(p *FromSpecElementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_fromSpecElement +} + +func (*FromSpecElementContext) IsFromSpecElementContext() {} + +func NewFromSpecElementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FromSpecElementContext { + var p = new(FromSpecElementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_fromSpecElement + + return p +} + +func (s *FromSpecElementContext) GetParser() antlr.Parser { return s.parser } + +func (s *FromSpecElementContext) AllOBJECT_NAME() []antlr.TerminalNode { + return s.GetTokens(CqlParserOBJECT_NAME) +} + +func (s *FromSpecElementContext) OBJECT_NAME(i int) antlr.TerminalNode { + return s.GetToken(CqlParserOBJECT_NAME, i) +} + +func (s *FromSpecElementContext) DOT() antlr.TerminalNode { + return s.GetToken(CqlParserDOT, 0) +} + +func (s *FromSpecElementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *FromSpecElementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *FromSpecElementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterFromSpecElement(s) + } +} + +func (s *FromSpecElementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitFromSpecElement(s) + } +} + +func (s *FromSpecElementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitFromSpecElement(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) FromSpecElement() (localctx IFromSpecElementContext) { + localctx = NewFromSpecElementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 266, CqlParserRULE_fromSpecElement) + p.SetState(1853) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 152, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1849) + p.Match(CqlParserOBJECT_NAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(1850) + p.Match(CqlParserOBJECT_NAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1851) + p.Match(CqlParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1852) + p.Match(CqlParserOBJECT_NAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOrderSpecContext is an interface to support dynamic dispatch. +type IOrderSpecContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + KwOrder() IKwOrderContext + KwBy() IKwByContext + OrderSpecElement() IOrderSpecElementContext + + // IsOrderSpecContext differentiates from other interfaces. + IsOrderSpecContext() +} + +type OrderSpecContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOrderSpecContext() *OrderSpecContext { + var p = new(OrderSpecContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_orderSpec + return p +} + +func InitEmptyOrderSpecContext(p *OrderSpecContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_orderSpec +} + +func (*OrderSpecContext) IsOrderSpecContext() {} + +func NewOrderSpecContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *OrderSpecContext { + var p = new(OrderSpecContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_orderSpec + + return p +} + +func (s *OrderSpecContext) GetParser() antlr.Parser { return s.parser } + +func (s *OrderSpecContext) KwOrder() IKwOrderContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwOrderContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwOrderContext) +} + +func (s *OrderSpecContext) KwBy() IKwByContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwByContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwByContext) +} + +func (s *OrderSpecContext) OrderSpecElement() IOrderSpecElementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOrderSpecElementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOrderSpecElementContext) +} + +func (s *OrderSpecContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *OrderSpecContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *OrderSpecContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterOrderSpec(s) + } +} + +func (s *OrderSpecContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitOrderSpec(s) + } +} + +func (s *OrderSpecContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitOrderSpec(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) OrderSpec() (localctx IOrderSpecContext) { + localctx = NewOrderSpecContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 268, CqlParserRULE_orderSpec) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1855) + p.KwOrder() + } + { + p.SetState(1856) + p.KwBy() + } + { + p.SetState(1857) + p.OrderSpecElement() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOrderSpecElementContext is an interface to support dynamic dispatch. +type IOrderSpecElementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + OBJECT_NAME() antlr.TerminalNode + KwAsc() IKwAscContext + KwDesc() IKwDescContext + + // IsOrderSpecElementContext differentiates from other interfaces. + IsOrderSpecElementContext() +} + +type OrderSpecElementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOrderSpecElementContext() *OrderSpecElementContext { + var p = new(OrderSpecElementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_orderSpecElement + return p +} + +func InitEmptyOrderSpecElementContext(p *OrderSpecElementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_orderSpecElement +} + +func (*OrderSpecElementContext) IsOrderSpecElementContext() {} + +func NewOrderSpecElementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *OrderSpecElementContext { + var p = new(OrderSpecElementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_orderSpecElement + + return p +} + +func (s *OrderSpecElementContext) GetParser() antlr.Parser { return s.parser } + +func (s *OrderSpecElementContext) OBJECT_NAME() antlr.TerminalNode { + return s.GetToken(CqlParserOBJECT_NAME, 0) +} + +func (s *OrderSpecElementContext) KwAsc() IKwAscContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwAscContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwAscContext) +} + +func (s *OrderSpecElementContext) KwDesc() IKwDescContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwDescContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwDescContext) +} + +func (s *OrderSpecElementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *OrderSpecElementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *OrderSpecElementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterOrderSpecElement(s) + } +} + +func (s *OrderSpecElementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitOrderSpecElement(s) + } +} + +func (s *OrderSpecElementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitOrderSpecElement(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) OrderSpecElement() (localctx IOrderSpecElementContext) { + localctx = NewOrderSpecElementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 270, CqlParserRULE_orderSpecElement) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1859) + p.Match(CqlParserOBJECT_NAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1862) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + switch p.GetTokenStream().LA(1) { + case CqlParserK_ASC: + { + p.SetState(1860) + p.KwAsc() + } + + case CqlParserK_DESC: + { + p.SetState(1861) + p.KwDesc() + } + + case CqlParserEOF, CqlParserSEMI, CqlParserMINUSMINUS, CqlParserK_ALLOW, CqlParserK_LIMIT: + + default: + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IWhereSpecContext is an interface to support dynamic dispatch. +type IWhereSpecContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + KwWhere() IKwWhereContext + RelationElements() IRelationElementsContext + + // IsWhereSpecContext differentiates from other interfaces. + IsWhereSpecContext() +} + +type WhereSpecContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyWhereSpecContext() *WhereSpecContext { + var p = new(WhereSpecContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_whereSpec + return p +} + +func InitEmptyWhereSpecContext(p *WhereSpecContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_whereSpec +} + +func (*WhereSpecContext) IsWhereSpecContext() {} + +func NewWhereSpecContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *WhereSpecContext { + var p = new(WhereSpecContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_whereSpec + + return p +} + +func (s *WhereSpecContext) GetParser() antlr.Parser { return s.parser } + +func (s *WhereSpecContext) KwWhere() IKwWhereContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwWhereContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwWhereContext) +} + +func (s *WhereSpecContext) RelationElements() IRelationElementsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRelationElementsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRelationElementsContext) +} + +func (s *WhereSpecContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *WhereSpecContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *WhereSpecContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterWhereSpec(s) + } +} + +func (s *WhereSpecContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitWhereSpec(s) + } +} + +func (s *WhereSpecContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitWhereSpec(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) WhereSpec() (localctx IWhereSpecContext) { + localctx = NewWhereSpecContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 272, CqlParserRULE_whereSpec) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1864) + p.KwWhere() + } + { + p.SetState(1865) + p.RelationElements() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDistinctSpecContext is an interface to support dynamic dispatch. +type IDistinctSpecContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + KwDistinct() IKwDistinctContext + + // IsDistinctSpecContext differentiates from other interfaces. + IsDistinctSpecContext() +} + +type DistinctSpecContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDistinctSpecContext() *DistinctSpecContext { + var p = new(DistinctSpecContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_distinctSpec + return p +} + +func InitEmptyDistinctSpecContext(p *DistinctSpecContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_distinctSpec +} + +func (*DistinctSpecContext) IsDistinctSpecContext() {} + +func NewDistinctSpecContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DistinctSpecContext { + var p = new(DistinctSpecContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_distinctSpec + + return p +} + +func (s *DistinctSpecContext) GetParser() antlr.Parser { return s.parser } + +func (s *DistinctSpecContext) KwDistinct() IKwDistinctContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwDistinctContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwDistinctContext) +} + +func (s *DistinctSpecContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *DistinctSpecContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *DistinctSpecContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterDistinctSpec(s) + } +} + +func (s *DistinctSpecContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitDistinctSpec(s) + } +} + +func (s *DistinctSpecContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitDistinctSpec(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) DistinctSpec() (localctx IDistinctSpecContext) { + localctx = NewDistinctSpecContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 274, CqlParserRULE_distinctSpec) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1867) + p.KwDistinct() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISelectElementsContext is an interface to support dynamic dispatch. +type ISelectElementsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetStar returns the star token. + GetStar() antlr.Token + + // SetStar sets the star token. + SetStar(antlr.Token) + + // Getter signatures + AllSelectElement() []ISelectElementContext + SelectElement(i int) ISelectElementContext + STAR() antlr.TerminalNode + AllSyntaxComma() []ISyntaxCommaContext + SyntaxComma(i int) ISyntaxCommaContext + + // IsSelectElementsContext differentiates from other interfaces. + IsSelectElementsContext() +} + +type SelectElementsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + star antlr.Token +} + +func NewEmptySelectElementsContext() *SelectElementsContext { + var p = new(SelectElementsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_selectElements + return p +} + +func InitEmptySelectElementsContext(p *SelectElementsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_selectElements +} + +func (*SelectElementsContext) IsSelectElementsContext() {} + +func NewSelectElementsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SelectElementsContext { + var p = new(SelectElementsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_selectElements + + return p +} + +func (s *SelectElementsContext) GetParser() antlr.Parser { return s.parser } + +func (s *SelectElementsContext) GetStar() antlr.Token { return s.star } + +func (s *SelectElementsContext) SetStar(v antlr.Token) { s.star = v } + +func (s *SelectElementsContext) AllSelectElement() []ISelectElementContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISelectElementContext); ok { + len++ + } + } + + tst := make([]ISelectElementContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISelectElementContext); ok { + tst[i] = t.(ISelectElementContext) + i++ + } + } + + return tst +} + +func (s *SelectElementsContext) SelectElement(i int) ISelectElementContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISelectElementContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISelectElementContext) +} + +func (s *SelectElementsContext) STAR() antlr.TerminalNode { + return s.GetToken(CqlParserSTAR, 0) +} + +func (s *SelectElementsContext) AllSyntaxComma() []ISyntaxCommaContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISyntaxCommaContext); ok { + len++ + } + } + + tst := make([]ISyntaxCommaContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISyntaxCommaContext); ok { + tst[i] = t.(ISyntaxCommaContext) + i++ + } + } + + return tst +} + +func (s *SelectElementsContext) SyntaxComma(i int) ISyntaxCommaContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISyntaxCommaContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISyntaxCommaContext) +} + +func (s *SelectElementsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SelectElementsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *SelectElementsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterSelectElements(s) + } +} + +func (s *SelectElementsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitSelectElements(s) + } +} + +func (s *SelectElementsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitSelectElements(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) SelectElements() (localctx ISelectElementsContext) { + localctx = NewSelectElementsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 276, CqlParserRULE_selectElements) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(1871) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case CqlParserSTAR: + { + p.SetState(1869) + + var _m = p.Match(CqlParserSTAR) + + localctx.(*SelectElementsContext).star = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case CqlParserK_UUID, CqlParserOBJECT_NAME: + { + p.SetState(1870) + p.SelectElement() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.SetState(1878) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == CqlParserCOMMA { + { + p.SetState(1873) + p.SyntaxComma() + } + { + p.SetState(1874) + p.SelectElement() + } + + p.SetState(1880) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISelectElementContext is an interface to support dynamic dispatch. +type ISelectElementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllOBJECT_NAME() []antlr.TerminalNode + OBJECT_NAME(i int) antlr.TerminalNode + DOT() antlr.TerminalNode + STAR() antlr.TerminalNode + KwAs() IKwAsContext + FunctionCall() IFunctionCallContext + + // IsSelectElementContext differentiates from other interfaces. + IsSelectElementContext() +} + +type SelectElementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySelectElementContext() *SelectElementContext { + var p = new(SelectElementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_selectElement + return p +} + +func InitEmptySelectElementContext(p *SelectElementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_selectElement +} + +func (*SelectElementContext) IsSelectElementContext() {} + +func NewSelectElementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SelectElementContext { + var p = new(SelectElementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_selectElement + + return p +} + +func (s *SelectElementContext) GetParser() antlr.Parser { return s.parser } + +func (s *SelectElementContext) AllOBJECT_NAME() []antlr.TerminalNode { + return s.GetTokens(CqlParserOBJECT_NAME) +} + +func (s *SelectElementContext) OBJECT_NAME(i int) antlr.TerminalNode { + return s.GetToken(CqlParserOBJECT_NAME, i) +} + +func (s *SelectElementContext) DOT() antlr.TerminalNode { + return s.GetToken(CqlParserDOT, 0) +} + +func (s *SelectElementContext) STAR() antlr.TerminalNode { + return s.GetToken(CqlParserSTAR, 0) +} + +func (s *SelectElementContext) KwAs() IKwAsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwAsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwAsContext) +} + +func (s *SelectElementContext) FunctionCall() IFunctionCallContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunctionCallContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFunctionCallContext) +} + +func (s *SelectElementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SelectElementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *SelectElementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterSelectElement(s) + } +} + +func (s *SelectElementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitSelectElement(s) + } +} + +func (s *SelectElementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitSelectElement(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) SelectElement() (localctx ISelectElementContext) { + localctx = NewSelectElementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 278, CqlParserRULE_selectElement) + var _la int + + p.SetState(1896) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 158, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1881) + p.Match(CqlParserOBJECT_NAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1882) + p.Match(CqlParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1883) + p.Match(CqlParserSTAR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(1884) + p.Match(CqlParserOBJECT_NAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1888) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == CqlParserK_AS { + { + p.SetState(1885) + p.KwAs() + } + { + p.SetState(1886) + p.Match(CqlParserOBJECT_NAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(1890) + p.FunctionCall() + } + p.SetState(1894) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == CqlParserK_AS { + { + p.SetState(1891) + p.KwAs() + } + { + p.SetState(1892) + p.Match(CqlParserOBJECT_NAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IRelationElementsContext is an interface to support dynamic dispatch. +type IRelationElementsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllRelationElement() []IRelationElementContext + RelationElement(i int) IRelationElementContext + AllKwAnd() []IKwAndContext + KwAnd(i int) IKwAndContext + + // IsRelationElementsContext differentiates from other interfaces. + IsRelationElementsContext() +} + +type RelationElementsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRelationElementsContext() *RelationElementsContext { + var p = new(RelationElementsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_relationElements + return p +} + +func InitEmptyRelationElementsContext(p *RelationElementsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_relationElements +} + +func (*RelationElementsContext) IsRelationElementsContext() {} + +func NewRelationElementsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *RelationElementsContext { + var p = new(RelationElementsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_relationElements + + return p +} + +func (s *RelationElementsContext) GetParser() antlr.Parser { return s.parser } + +func (s *RelationElementsContext) AllRelationElement() []IRelationElementContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IRelationElementContext); ok { + len++ + } + } + + tst := make([]IRelationElementContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IRelationElementContext); ok { + tst[i] = t.(IRelationElementContext) + i++ + } + } + + return tst +} + +func (s *RelationElementsContext) RelationElement(i int) IRelationElementContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRelationElementContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IRelationElementContext) +} + +func (s *RelationElementsContext) AllKwAnd() []IKwAndContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IKwAndContext); ok { + len++ + } + } + + tst := make([]IKwAndContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IKwAndContext); ok { + tst[i] = t.(IKwAndContext) + i++ + } + } + + return tst +} + +func (s *RelationElementsContext) KwAnd(i int) IKwAndContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwAndContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IKwAndContext) +} + +func (s *RelationElementsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *RelationElementsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *RelationElementsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterRelationElements(s) + } +} + +func (s *RelationElementsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitRelationElements(s) + } +} + +func (s *RelationElementsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitRelationElements(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) RelationElements() (localctx IRelationElementsContext) { + localctx = NewRelationElementsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 280, CqlParserRULE_relationElements) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1898) + p.RelationElement() + } + + p.SetState(1904) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == CqlParserK_AND { + { + p.SetState(1899) + p.KwAnd() + } + { + p.SetState(1900) + p.RelationElement() + } + + p.SetState(1906) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IRelationElementContext is an interface to support dynamic dispatch. +type IRelationElementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllOBJECT_NAME() []antlr.TerminalNode + OBJECT_NAME(i int) antlr.TerminalNode + Constant() IConstantContext + OPERATOR_EQ() antlr.TerminalNode + OPERATOR_LT() antlr.TerminalNode + OPERATOR_GT() antlr.TerminalNode + OPERATOR_LTE() antlr.TerminalNode + OPERATOR_GTE() antlr.TerminalNode + DOT() antlr.TerminalNode + AllFunctionCall() []IFunctionCallContext + FunctionCall(i int) IFunctionCallContext + KwIn() IKwInContext + AllLR_BRACKET() []antlr.TerminalNode + LR_BRACKET(i int) antlr.TerminalNode + AllRR_BRACKET() []antlr.TerminalNode + RR_BRACKET(i int) antlr.TerminalNode + FunctionArgs() IFunctionArgsContext + AllAssignmentTuple() []IAssignmentTupleContext + AssignmentTuple(i int) IAssignmentTupleContext + AllSyntaxComma() []ISyntaxCommaContext + SyntaxComma(i int) ISyntaxCommaContext + RelalationContainsKey() IRelalationContainsKeyContext + RelalationContains() IRelalationContainsContext + + // IsRelationElementContext differentiates from other interfaces. + IsRelationElementContext() +} + +type RelationElementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRelationElementContext() *RelationElementContext { + var p = new(RelationElementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_relationElement + return p +} + +func InitEmptyRelationElementContext(p *RelationElementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_relationElement +} + +func (*RelationElementContext) IsRelationElementContext() {} + +func NewRelationElementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *RelationElementContext { + var p = new(RelationElementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_relationElement + + return p +} + +func (s *RelationElementContext) GetParser() antlr.Parser { return s.parser } + +func (s *RelationElementContext) AllOBJECT_NAME() []antlr.TerminalNode { + return s.GetTokens(CqlParserOBJECT_NAME) +} + +func (s *RelationElementContext) OBJECT_NAME(i int) antlr.TerminalNode { + return s.GetToken(CqlParserOBJECT_NAME, i) +} + +func (s *RelationElementContext) Constant() IConstantContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConstantContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IConstantContext) +} + +func (s *RelationElementContext) OPERATOR_EQ() antlr.TerminalNode { + return s.GetToken(CqlParserOPERATOR_EQ, 0) +} + +func (s *RelationElementContext) OPERATOR_LT() antlr.TerminalNode { + return s.GetToken(CqlParserOPERATOR_LT, 0) +} + +func (s *RelationElementContext) OPERATOR_GT() antlr.TerminalNode { + return s.GetToken(CqlParserOPERATOR_GT, 0) +} + +func (s *RelationElementContext) OPERATOR_LTE() antlr.TerminalNode { + return s.GetToken(CqlParserOPERATOR_LTE, 0) +} + +func (s *RelationElementContext) OPERATOR_GTE() antlr.TerminalNode { + return s.GetToken(CqlParserOPERATOR_GTE, 0) +} + +func (s *RelationElementContext) DOT() antlr.TerminalNode { + return s.GetToken(CqlParserDOT, 0) +} + +func (s *RelationElementContext) AllFunctionCall() []IFunctionCallContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IFunctionCallContext); ok { + len++ + } + } + + tst := make([]IFunctionCallContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IFunctionCallContext); ok { + tst[i] = t.(IFunctionCallContext) + i++ + } + } + + return tst +} + +func (s *RelationElementContext) FunctionCall(i int) IFunctionCallContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunctionCallContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IFunctionCallContext) +} + +func (s *RelationElementContext) KwIn() IKwInContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwInContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwInContext) +} + +func (s *RelationElementContext) AllLR_BRACKET() []antlr.TerminalNode { + return s.GetTokens(CqlParserLR_BRACKET) +} + +func (s *RelationElementContext) LR_BRACKET(i int) antlr.TerminalNode { + return s.GetToken(CqlParserLR_BRACKET, i) +} + +func (s *RelationElementContext) AllRR_BRACKET() []antlr.TerminalNode { + return s.GetTokens(CqlParserRR_BRACKET) +} + +func (s *RelationElementContext) RR_BRACKET(i int) antlr.TerminalNode { + return s.GetToken(CqlParserRR_BRACKET, i) +} + +func (s *RelationElementContext) FunctionArgs() IFunctionArgsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunctionArgsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFunctionArgsContext) +} + +func (s *RelationElementContext) AllAssignmentTuple() []IAssignmentTupleContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IAssignmentTupleContext); ok { + len++ + } + } + + tst := make([]IAssignmentTupleContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IAssignmentTupleContext); ok { + tst[i] = t.(IAssignmentTupleContext) + i++ + } + } + + return tst +} + +func (s *RelationElementContext) AssignmentTuple(i int) IAssignmentTupleContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAssignmentTupleContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IAssignmentTupleContext) +} + +func (s *RelationElementContext) AllSyntaxComma() []ISyntaxCommaContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISyntaxCommaContext); ok { + len++ + } + } + + tst := make([]ISyntaxCommaContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISyntaxCommaContext); ok { + tst[i] = t.(ISyntaxCommaContext) + i++ + } + } + + return tst +} + +func (s *RelationElementContext) SyntaxComma(i int) ISyntaxCommaContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISyntaxCommaContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISyntaxCommaContext) +} + +func (s *RelationElementContext) RelalationContainsKey() IRelalationContainsKeyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRelalationContainsKeyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRelalationContainsKeyContext) +} + +func (s *RelationElementContext) RelalationContains() IRelalationContainsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRelalationContainsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRelalationContainsContext) +} + +func (s *RelationElementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *RelationElementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *RelationElementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterRelationElement(s) + } +} + +func (s *RelationElementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitRelationElement(s) + } +} + +func (s *RelationElementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitRelationElement(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) RelationElement() (localctx IRelationElementContext) { + localctx = NewRelationElementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 282, CqlParserRULE_relationElement) + var _la int + + p.SetState(1978) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 165, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1907) + p.Match(CqlParserOBJECT_NAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1908) + _la = p.GetTokenStream().LA(1) + + if !((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&16252928) != 0) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(1909) + p.Constant() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(1910) + p.Match(CqlParserOBJECT_NAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1911) + p.Match(CqlParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1912) + p.Match(CqlParserOBJECT_NAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1913) + _la = p.GetTokenStream().LA(1) + + if !((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&16252928) != 0) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(1914) + p.Constant() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(1915) + p.FunctionCall() + } + { + p.SetState(1916) + _la = p.GetTokenStream().LA(1) + + if !((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&16252928) != 0) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(1917) + p.Constant() + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(1919) + p.FunctionCall() + } + { + p.SetState(1920) + _la = p.GetTokenStream().LA(1) + + if !((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&16252928) != 0) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(1921) + p.FunctionCall() + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(1923) + p.Match(CqlParserOBJECT_NAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1924) + p.KwIn() + } + { + p.SetState(1925) + p.Match(CqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1927) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == CqlParserK_FALSE || _la == CqlParserK_NULL || ((int64((_la-126)) & ^0x3f) == 0 && ((int64(1)<<(_la-126))&61297773249537) != 0) { + { + p.SetState(1926) + p.FunctionArgs() + } + + } + { + p.SetState(1929) + p.Match(CqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 6: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(1931) + p.Match(CqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1932) + p.Match(CqlParserOBJECT_NAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1938) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == CqlParserCOMMA { + { + p.SetState(1933) + p.SyntaxComma() + } + { + p.SetState(1934) + p.Match(CqlParserOBJECT_NAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + p.SetState(1940) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(1941) + p.Match(CqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1942) + p.KwIn() + } + { + p.SetState(1943) + p.Match(CqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1944) + p.AssignmentTuple() + } + p.SetState(1950) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == CqlParserCOMMA { + { + p.SetState(1945) + p.SyntaxComma() + } + { + p.SetState(1946) + p.AssignmentTuple() + } + + p.SetState(1952) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(1953) + p.Match(CqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 7: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(1955) + p.Match(CqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1956) + p.Match(CqlParserOBJECT_NAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1962) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == CqlParserCOMMA { + { + p.SetState(1957) + p.SyntaxComma() + } + { + p.SetState(1958) + p.Match(CqlParserOBJECT_NAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + p.SetState(1964) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(1965) + p.Match(CqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1966) + _la = p.GetTokenStream().LA(1) + + if !((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&16252928) != 0) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + { + p.SetState(1967) + p.AssignmentTuple() + } + p.SetState(1973) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == CqlParserCOMMA { + { + p.SetState(1968) + p.SyntaxComma() + } + { + p.SetState(1969) + p.AssignmentTuple() + } + + p.SetState(1975) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case 8: + p.EnterOuterAlt(localctx, 8) + { + p.SetState(1976) + p.RelalationContainsKey() + } + + case 9: + p.EnterOuterAlt(localctx, 9) + { + p.SetState(1977) + p.RelalationContains() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IRelalationContainsContext is an interface to support dynamic dispatch. +type IRelalationContainsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + OBJECT_NAME() antlr.TerminalNode + KwContains() IKwContainsContext + Constant() IConstantContext + + // IsRelalationContainsContext differentiates from other interfaces. + IsRelalationContainsContext() +} + +type RelalationContainsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRelalationContainsContext() *RelalationContainsContext { + var p = new(RelalationContainsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_relalationContains + return p +} + +func InitEmptyRelalationContainsContext(p *RelalationContainsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_relalationContains +} + +func (*RelalationContainsContext) IsRelalationContainsContext() {} + +func NewRelalationContainsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *RelalationContainsContext { + var p = new(RelalationContainsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_relalationContains + + return p +} + +func (s *RelalationContainsContext) GetParser() antlr.Parser { return s.parser } + +func (s *RelalationContainsContext) OBJECT_NAME() antlr.TerminalNode { + return s.GetToken(CqlParserOBJECT_NAME, 0) +} + +func (s *RelalationContainsContext) KwContains() IKwContainsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwContainsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwContainsContext) +} + +func (s *RelalationContainsContext) Constant() IConstantContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConstantContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IConstantContext) +} + +func (s *RelalationContainsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *RelalationContainsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *RelalationContainsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterRelalationContains(s) + } +} + +func (s *RelalationContainsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitRelalationContains(s) + } +} + +func (s *RelalationContainsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitRelalationContains(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) RelalationContains() (localctx IRelalationContainsContext) { + localctx = NewRelalationContainsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 284, CqlParserRULE_relalationContains) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1980) + p.Match(CqlParserOBJECT_NAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1981) + p.KwContains() + } + { + p.SetState(1982) + p.Constant() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IRelalationContainsKeyContext is an interface to support dynamic dispatch. +type IRelalationContainsKeyContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + OBJECT_NAME() antlr.TerminalNode + Constant() IConstantContext + KwContains() IKwContainsContext + KwKey() IKwKeyContext + + // IsRelalationContainsKeyContext differentiates from other interfaces. + IsRelalationContainsKeyContext() +} + +type RelalationContainsKeyContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRelalationContainsKeyContext() *RelalationContainsKeyContext { + var p = new(RelalationContainsKeyContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_relalationContainsKey + return p +} + +func InitEmptyRelalationContainsKeyContext(p *RelalationContainsKeyContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_relalationContainsKey +} + +func (*RelalationContainsKeyContext) IsRelalationContainsKeyContext() {} + +func NewRelalationContainsKeyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *RelalationContainsKeyContext { + var p = new(RelalationContainsKeyContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_relalationContainsKey + + return p +} + +func (s *RelalationContainsKeyContext) GetParser() antlr.Parser { return s.parser } + +func (s *RelalationContainsKeyContext) OBJECT_NAME() antlr.TerminalNode { + return s.GetToken(CqlParserOBJECT_NAME, 0) +} + +func (s *RelalationContainsKeyContext) Constant() IConstantContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConstantContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IConstantContext) +} + +func (s *RelalationContainsKeyContext) KwContains() IKwContainsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwContainsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwContainsContext) +} + +func (s *RelalationContainsKeyContext) KwKey() IKwKeyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwKeyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwKeyContext) +} + +func (s *RelalationContainsKeyContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *RelalationContainsKeyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *RelalationContainsKeyContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterRelalationContainsKey(s) + } +} + +func (s *RelalationContainsKeyContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitRelalationContainsKey(s) + } +} + +func (s *RelalationContainsKeyContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitRelalationContainsKey(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) RelalationContainsKey() (localctx IRelalationContainsKeyContext) { + localctx = NewRelalationContainsKeyContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 286, CqlParserRULE_relalationContainsKey) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1984) + p.Match(CqlParserOBJECT_NAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + { + p.SetState(1985) + p.KwContains() + } + { + p.SetState(1986) + p.KwKey() + } + + { + p.SetState(1988) + p.Constant() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IFunctionCallContext is an interface to support dynamic dispatch. +type IFunctionCallContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + OBJECT_NAME() antlr.TerminalNode + LR_BRACKET() antlr.TerminalNode + STAR() antlr.TerminalNode + RR_BRACKET() antlr.TerminalNode + FunctionArgs() IFunctionArgsContext + K_UUID() antlr.TerminalNode + + // IsFunctionCallContext differentiates from other interfaces. + IsFunctionCallContext() +} + +type FunctionCallContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFunctionCallContext() *FunctionCallContext { + var p = new(FunctionCallContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_functionCall + return p +} + +func InitEmptyFunctionCallContext(p *FunctionCallContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_functionCall +} + +func (*FunctionCallContext) IsFunctionCallContext() {} + +func NewFunctionCallContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FunctionCallContext { + var p = new(FunctionCallContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_functionCall + + return p +} + +func (s *FunctionCallContext) GetParser() antlr.Parser { return s.parser } + +func (s *FunctionCallContext) OBJECT_NAME() antlr.TerminalNode { + return s.GetToken(CqlParserOBJECT_NAME, 0) +} + +func (s *FunctionCallContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(CqlParserLR_BRACKET, 0) +} + +func (s *FunctionCallContext) STAR() antlr.TerminalNode { + return s.GetToken(CqlParserSTAR, 0) +} + +func (s *FunctionCallContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(CqlParserRR_BRACKET, 0) +} + +func (s *FunctionCallContext) FunctionArgs() IFunctionArgsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunctionArgsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFunctionArgsContext) +} + +func (s *FunctionCallContext) K_UUID() antlr.TerminalNode { + return s.GetToken(CqlParserK_UUID, 0) +} + +func (s *FunctionCallContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *FunctionCallContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *FunctionCallContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterFunctionCall(s) + } +} + +func (s *FunctionCallContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitFunctionCall(s) + } +} + +func (s *FunctionCallContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitFunctionCall(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) FunctionCall() (localctx IFunctionCallContext) { + localctx = NewFunctionCallContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 288, CqlParserRULE_functionCall) + var _la int + + p.SetState(2003) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 167, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1990) + p.Match(CqlParserOBJECT_NAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1991) + p.Match(CqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1992) + p.Match(CqlParserSTAR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1993) + p.Match(CqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(1994) + p.Match(CqlParserOBJECT_NAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1995) + p.Match(CqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1997) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == CqlParserK_FALSE || _la == CqlParserK_NULL || ((int64((_la-126)) & ^0x3f) == 0 && ((int64(1)<<(_la-126))&61297773249537) != 0) { + { + p.SetState(1996) + p.FunctionArgs() + } + + } + { + p.SetState(1999) + p.Match(CqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(2000) + p.Match(CqlParserK_UUID) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2001) + p.Match(CqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2002) + p.Match(CqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IFunctionArgsContext is an interface to support dynamic dispatch. +type IFunctionArgsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllConstant() []IConstantContext + Constant(i int) IConstantContext + AllOBJECT_NAME() []antlr.TerminalNode + OBJECT_NAME(i int) antlr.TerminalNode + AllFunctionCall() []IFunctionCallContext + FunctionCall(i int) IFunctionCallContext + AllSyntaxComma() []ISyntaxCommaContext + SyntaxComma(i int) ISyntaxCommaContext + + // IsFunctionArgsContext differentiates from other interfaces. + IsFunctionArgsContext() +} + +type FunctionArgsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFunctionArgsContext() *FunctionArgsContext { + var p = new(FunctionArgsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_functionArgs + return p +} + +func InitEmptyFunctionArgsContext(p *FunctionArgsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_functionArgs +} + +func (*FunctionArgsContext) IsFunctionArgsContext() {} + +func NewFunctionArgsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FunctionArgsContext { + var p = new(FunctionArgsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_functionArgs + + return p +} + +func (s *FunctionArgsContext) GetParser() antlr.Parser { return s.parser } + +func (s *FunctionArgsContext) AllConstant() []IConstantContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IConstantContext); ok { + len++ + } + } + + tst := make([]IConstantContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IConstantContext); ok { + tst[i] = t.(IConstantContext) + i++ + } + } + + return tst +} + +func (s *FunctionArgsContext) Constant(i int) IConstantContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConstantContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IConstantContext) +} + +func (s *FunctionArgsContext) AllOBJECT_NAME() []antlr.TerminalNode { + return s.GetTokens(CqlParserOBJECT_NAME) +} + +func (s *FunctionArgsContext) OBJECT_NAME(i int) antlr.TerminalNode { + return s.GetToken(CqlParserOBJECT_NAME, i) +} + +func (s *FunctionArgsContext) AllFunctionCall() []IFunctionCallContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IFunctionCallContext); ok { + len++ + } + } + + tst := make([]IFunctionCallContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IFunctionCallContext); ok { + tst[i] = t.(IFunctionCallContext) + i++ + } + } + + return tst +} + +func (s *FunctionArgsContext) FunctionCall(i int) IFunctionCallContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunctionCallContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IFunctionCallContext) +} + +func (s *FunctionArgsContext) AllSyntaxComma() []ISyntaxCommaContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISyntaxCommaContext); ok { + len++ + } + } + + tst := make([]ISyntaxCommaContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISyntaxCommaContext); ok { + tst[i] = t.(ISyntaxCommaContext) + i++ + } + } + + return tst +} + +func (s *FunctionArgsContext) SyntaxComma(i int) ISyntaxCommaContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISyntaxCommaContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISyntaxCommaContext) +} + +func (s *FunctionArgsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *FunctionArgsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *FunctionArgsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterFunctionArgs(s) + } +} + +func (s *FunctionArgsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitFunctionArgs(s) + } +} + +func (s *FunctionArgsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitFunctionArgs(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) FunctionArgs() (localctx IFunctionArgsContext) { + localctx = NewFunctionArgsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 290, CqlParserRULE_functionArgs) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(2008) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 168, p.GetParserRuleContext()) { + case 1: + { + p.SetState(2005) + p.Constant() + } + + case 2: + { + p.SetState(2006) + p.Match(CqlParserOBJECT_NAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + { + p.SetState(2007) + p.FunctionCall() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + p.SetState(2018) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == CqlParserCOMMA { + { + p.SetState(2010) + p.SyntaxComma() + } + p.SetState(2014) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 169, p.GetParserRuleContext()) { + case 1: + { + p.SetState(2011) + p.Constant() + } + + case 2: + { + p.SetState(2012) + p.Match(CqlParserOBJECT_NAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + { + p.SetState(2013) + p.FunctionCall() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + p.SetState(2020) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IConstantContext is an interface to support dynamic dispatch. +type IConstantContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + UUID() antlr.TerminalNode + StringLiteral() IStringLiteralContext + DecimalLiteral() IDecimalLiteralContext + FloatLiteral() IFloatLiteralContext + HexadecimalLiteral() IHexadecimalLiteralContext + BooleanLiteral() IBooleanLiteralContext + CodeBlock() ICodeBlockContext + KwNull() IKwNullContext + + // IsConstantContext differentiates from other interfaces. + IsConstantContext() +} + +type ConstantContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyConstantContext() *ConstantContext { + var p = new(ConstantContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_constant + return p +} + +func InitEmptyConstantContext(p *ConstantContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_constant +} + +func (*ConstantContext) IsConstantContext() {} + +func NewConstantContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ConstantContext { + var p = new(ConstantContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_constant + + return p +} + +func (s *ConstantContext) GetParser() antlr.Parser { return s.parser } + +func (s *ConstantContext) UUID() antlr.TerminalNode { + return s.GetToken(CqlParserUUID, 0) +} + +func (s *ConstantContext) StringLiteral() IStringLiteralContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStringLiteralContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStringLiteralContext) +} + +func (s *ConstantContext) DecimalLiteral() IDecimalLiteralContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDecimalLiteralContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDecimalLiteralContext) +} + +func (s *ConstantContext) FloatLiteral() IFloatLiteralContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFloatLiteralContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFloatLiteralContext) +} + +func (s *ConstantContext) HexadecimalLiteral() IHexadecimalLiteralContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IHexadecimalLiteralContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IHexadecimalLiteralContext) +} + +func (s *ConstantContext) BooleanLiteral() IBooleanLiteralContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IBooleanLiteralContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IBooleanLiteralContext) +} + +func (s *ConstantContext) CodeBlock() ICodeBlockContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICodeBlockContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICodeBlockContext) +} + +func (s *ConstantContext) KwNull() IKwNullContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwNullContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwNullContext) +} + +func (s *ConstantContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ConstantContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ConstantContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterConstant(s) + } +} + +func (s *ConstantContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitConstant(s) + } +} + +func (s *ConstantContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitConstant(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) Constant() (localctx IConstantContext) { + localctx = NewConstantContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 292, CqlParserRULE_constant) + p.SetState(2029) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 171, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2021) + p.Match(CqlParserUUID) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(2022) + p.StringLiteral() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(2023) + p.DecimalLiteral() + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(2024) + p.FloatLiteral() + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(2025) + p.HexadecimalLiteral() + } + + case 6: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(2026) + p.BooleanLiteral() + } + + case 7: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(2027) + p.CodeBlock() + } + + case 8: + p.EnterOuterAlt(localctx, 8) + { + p.SetState(2028) + p.KwNull() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDecimalLiteralContext is an interface to support dynamic dispatch. +type IDecimalLiteralContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DECIMAL_LITERAL() antlr.TerminalNode + + // IsDecimalLiteralContext differentiates from other interfaces. + IsDecimalLiteralContext() +} + +type DecimalLiteralContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDecimalLiteralContext() *DecimalLiteralContext { + var p = new(DecimalLiteralContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_decimalLiteral + return p +} + +func InitEmptyDecimalLiteralContext(p *DecimalLiteralContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_decimalLiteral +} + +func (*DecimalLiteralContext) IsDecimalLiteralContext() {} + +func NewDecimalLiteralContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DecimalLiteralContext { + var p = new(DecimalLiteralContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_decimalLiteral + + return p +} + +func (s *DecimalLiteralContext) GetParser() antlr.Parser { return s.parser } + +func (s *DecimalLiteralContext) DECIMAL_LITERAL() antlr.TerminalNode { + return s.GetToken(CqlParserDECIMAL_LITERAL, 0) +} + +func (s *DecimalLiteralContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *DecimalLiteralContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *DecimalLiteralContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterDecimalLiteral(s) + } +} + +func (s *DecimalLiteralContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitDecimalLiteral(s) + } +} + +func (s *DecimalLiteralContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitDecimalLiteral(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) DecimalLiteral() (localctx IDecimalLiteralContext) { + localctx = NewDecimalLiteralContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 294, CqlParserRULE_decimalLiteral) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2031) + p.Match(CqlParserDECIMAL_LITERAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IFloatLiteralContext is an interface to support dynamic dispatch. +type IFloatLiteralContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DECIMAL_LITERAL() antlr.TerminalNode + FLOAT_LITERAL() antlr.TerminalNode + + // IsFloatLiteralContext differentiates from other interfaces. + IsFloatLiteralContext() +} + +type FloatLiteralContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFloatLiteralContext() *FloatLiteralContext { + var p = new(FloatLiteralContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_floatLiteral + return p +} + +func InitEmptyFloatLiteralContext(p *FloatLiteralContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_floatLiteral +} + +func (*FloatLiteralContext) IsFloatLiteralContext() {} + +func NewFloatLiteralContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FloatLiteralContext { + var p = new(FloatLiteralContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_floatLiteral + + return p +} + +func (s *FloatLiteralContext) GetParser() antlr.Parser { return s.parser } + +func (s *FloatLiteralContext) DECIMAL_LITERAL() antlr.TerminalNode { + return s.GetToken(CqlParserDECIMAL_LITERAL, 0) +} + +func (s *FloatLiteralContext) FLOAT_LITERAL() antlr.TerminalNode { + return s.GetToken(CqlParserFLOAT_LITERAL, 0) +} + +func (s *FloatLiteralContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *FloatLiteralContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *FloatLiteralContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterFloatLiteral(s) + } +} + +func (s *FloatLiteralContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitFloatLiteral(s) + } +} + +func (s *FloatLiteralContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitFloatLiteral(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) FloatLiteral() (localctx IFloatLiteralContext) { + localctx = NewFloatLiteralContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 296, CqlParserRULE_floatLiteral) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2033) + _la = p.GetTokenStream().LA(1) + + if !(_la == CqlParserDECIMAL_LITERAL || _la == CqlParserFLOAT_LITERAL) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IStringLiteralContext is an interface to support dynamic dispatch. +type IStringLiteralContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + STRING_LITERAL() antlr.TerminalNode + + // IsStringLiteralContext differentiates from other interfaces. + IsStringLiteralContext() +} + +type StringLiteralContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyStringLiteralContext() *StringLiteralContext { + var p = new(StringLiteralContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_stringLiteral + return p +} + +func InitEmptyStringLiteralContext(p *StringLiteralContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_stringLiteral +} + +func (*StringLiteralContext) IsStringLiteralContext() {} + +func NewStringLiteralContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *StringLiteralContext { + var p = new(StringLiteralContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_stringLiteral + + return p +} + +func (s *StringLiteralContext) GetParser() antlr.Parser { return s.parser } + +func (s *StringLiteralContext) STRING_LITERAL() antlr.TerminalNode { + return s.GetToken(CqlParserSTRING_LITERAL, 0) +} + +func (s *StringLiteralContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *StringLiteralContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *StringLiteralContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterStringLiteral(s) + } +} + +func (s *StringLiteralContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitStringLiteral(s) + } +} + +func (s *StringLiteralContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitStringLiteral(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) StringLiteral() (localctx IStringLiteralContext) { + localctx = NewStringLiteralContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 298, CqlParserRULE_stringLiteral) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2035) + p.Match(CqlParserSTRING_LITERAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IBooleanLiteralContext is an interface to support dynamic dispatch. +type IBooleanLiteralContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + K_TRUE() antlr.TerminalNode + K_FALSE() antlr.TerminalNode + + // IsBooleanLiteralContext differentiates from other interfaces. + IsBooleanLiteralContext() +} + +type BooleanLiteralContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyBooleanLiteralContext() *BooleanLiteralContext { + var p = new(BooleanLiteralContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_booleanLiteral + return p +} + +func InitEmptyBooleanLiteralContext(p *BooleanLiteralContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_booleanLiteral +} + +func (*BooleanLiteralContext) IsBooleanLiteralContext() {} + +func NewBooleanLiteralContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *BooleanLiteralContext { + var p = new(BooleanLiteralContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_booleanLiteral + + return p +} + +func (s *BooleanLiteralContext) GetParser() antlr.Parser { return s.parser } + +func (s *BooleanLiteralContext) K_TRUE() antlr.TerminalNode { + return s.GetToken(CqlParserK_TRUE, 0) +} + +func (s *BooleanLiteralContext) K_FALSE() antlr.TerminalNode { + return s.GetToken(CqlParserK_FALSE, 0) +} + +func (s *BooleanLiteralContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *BooleanLiteralContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *BooleanLiteralContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterBooleanLiteral(s) + } +} + +func (s *BooleanLiteralContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitBooleanLiteral(s) + } +} + +func (s *BooleanLiteralContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitBooleanLiteral(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) BooleanLiteral() (localctx IBooleanLiteralContext) { + localctx = NewBooleanLiteralContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 300, CqlParserRULE_booleanLiteral) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2037) + _la = p.GetTokenStream().LA(1) + + if !(_la == CqlParserK_FALSE || _la == CqlParserK_TRUE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IHexadecimalLiteralContext is an interface to support dynamic dispatch. +type IHexadecimalLiteralContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + HEXADECIMAL_LITERAL() antlr.TerminalNode + + // IsHexadecimalLiteralContext differentiates from other interfaces. + IsHexadecimalLiteralContext() +} + +type HexadecimalLiteralContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyHexadecimalLiteralContext() *HexadecimalLiteralContext { + var p = new(HexadecimalLiteralContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_hexadecimalLiteral + return p +} + +func InitEmptyHexadecimalLiteralContext(p *HexadecimalLiteralContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_hexadecimalLiteral +} + +func (*HexadecimalLiteralContext) IsHexadecimalLiteralContext() {} + +func NewHexadecimalLiteralContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *HexadecimalLiteralContext { + var p = new(HexadecimalLiteralContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_hexadecimalLiteral + + return p +} + +func (s *HexadecimalLiteralContext) GetParser() antlr.Parser { return s.parser } + +func (s *HexadecimalLiteralContext) HEXADECIMAL_LITERAL() antlr.TerminalNode { + return s.GetToken(CqlParserHEXADECIMAL_LITERAL, 0) +} + +func (s *HexadecimalLiteralContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *HexadecimalLiteralContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *HexadecimalLiteralContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterHexadecimalLiteral(s) + } +} + +func (s *HexadecimalLiteralContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitHexadecimalLiteral(s) + } +} + +func (s *HexadecimalLiteralContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitHexadecimalLiteral(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) HexadecimalLiteral() (localctx IHexadecimalLiteralContext) { + localctx = NewHexadecimalLiteralContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 302, CqlParserRULE_hexadecimalLiteral) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2039) + p.Match(CqlParserHEXADECIMAL_LITERAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IKeyspaceContext is an interface to support dynamic dispatch. +type IKeyspaceContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + OBJECT_NAME() antlr.TerminalNode + AllDQUOTE() []antlr.TerminalNode + DQUOTE(i int) antlr.TerminalNode + + // IsKeyspaceContext differentiates from other interfaces. + IsKeyspaceContext() +} + +type KeyspaceContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyKeyspaceContext() *KeyspaceContext { + var p = new(KeyspaceContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_keyspace + return p +} + +func InitEmptyKeyspaceContext(p *KeyspaceContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_keyspace +} + +func (*KeyspaceContext) IsKeyspaceContext() {} + +func NewKeyspaceContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KeyspaceContext { + var p = new(KeyspaceContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_keyspace + + return p +} + +func (s *KeyspaceContext) GetParser() antlr.Parser { return s.parser } + +func (s *KeyspaceContext) OBJECT_NAME() antlr.TerminalNode { + return s.GetToken(CqlParserOBJECT_NAME, 0) +} + +func (s *KeyspaceContext) AllDQUOTE() []antlr.TerminalNode { + return s.GetTokens(CqlParserDQUOTE) +} + +func (s *KeyspaceContext) DQUOTE(i int) antlr.TerminalNode { + return s.GetToken(CqlParserDQUOTE, i) +} + +func (s *KeyspaceContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *KeyspaceContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *KeyspaceContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterKeyspace(s) + } +} + +func (s *KeyspaceContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitKeyspace(s) + } +} + +func (s *KeyspaceContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitKeyspace(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) Keyspace() (localctx IKeyspaceContext) { + localctx = NewKeyspaceContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 304, CqlParserRULE_keyspace) + p.SetState(2045) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case CqlParserOBJECT_NAME: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2041) + p.Match(CqlParserOBJECT_NAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case CqlParserDQUOTE: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(2042) + p.Match(CqlParserDQUOTE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2043) + p.Match(CqlParserOBJECT_NAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2044) + p.Match(CqlParserDQUOTE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ITableContext is an interface to support dynamic dispatch. +type ITableContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + OBJECT_NAME() antlr.TerminalNode + AllDQUOTE() []antlr.TerminalNode + DQUOTE(i int) antlr.TerminalNode + + // IsTableContext differentiates from other interfaces. + IsTableContext() +} + +type TableContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTableContext() *TableContext { + var p = new(TableContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_table + return p +} + +func InitEmptyTableContext(p *TableContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_table +} + +func (*TableContext) IsTableContext() {} + +func NewTableContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TableContext { + var p = new(TableContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_table + + return p +} + +func (s *TableContext) GetParser() antlr.Parser { return s.parser } + +func (s *TableContext) OBJECT_NAME() antlr.TerminalNode { + return s.GetToken(CqlParserOBJECT_NAME, 0) +} + +func (s *TableContext) AllDQUOTE() []antlr.TerminalNode { + return s.GetTokens(CqlParserDQUOTE) +} + +func (s *TableContext) DQUOTE(i int) antlr.TerminalNode { + return s.GetToken(CqlParserDQUOTE, i) +} + +func (s *TableContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *TableContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *TableContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterTable(s) + } +} + +func (s *TableContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitTable(s) + } +} + +func (s *TableContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitTable(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) Table() (localctx ITableContext) { + localctx = NewTableContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 306, CqlParserRULE_table) + p.SetState(2051) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case CqlParserOBJECT_NAME: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2047) + p.Match(CqlParserOBJECT_NAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case CqlParserDQUOTE: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(2048) + p.Match(CqlParserDQUOTE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2049) + p.Match(CqlParserOBJECT_NAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2050) + p.Match(CqlParserDQUOTE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IColumnContext is an interface to support dynamic dispatch. +type IColumnContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + OBJECT_NAME() antlr.TerminalNode + AllDQUOTE() []antlr.TerminalNode + DQUOTE(i int) antlr.TerminalNode + + // IsColumnContext differentiates from other interfaces. + IsColumnContext() +} + +type ColumnContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyColumnContext() *ColumnContext { + var p = new(ColumnContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_column + return p +} + +func InitEmptyColumnContext(p *ColumnContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_column +} + +func (*ColumnContext) IsColumnContext() {} + +func NewColumnContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ColumnContext { + var p = new(ColumnContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_column + + return p +} + +func (s *ColumnContext) GetParser() antlr.Parser { return s.parser } + +func (s *ColumnContext) OBJECT_NAME() antlr.TerminalNode { + return s.GetToken(CqlParserOBJECT_NAME, 0) +} + +func (s *ColumnContext) AllDQUOTE() []antlr.TerminalNode { + return s.GetTokens(CqlParserDQUOTE) +} + +func (s *ColumnContext) DQUOTE(i int) antlr.TerminalNode { + return s.GetToken(CqlParserDQUOTE, i) +} + +func (s *ColumnContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ColumnContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ColumnContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterColumn(s) + } +} + +func (s *ColumnContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitColumn(s) + } +} + +func (s *ColumnContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitColumn(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) Column() (localctx IColumnContext) { + localctx = NewColumnContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 308, CqlParserRULE_column) + p.SetState(2057) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case CqlParserOBJECT_NAME: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2053) + p.Match(CqlParserOBJECT_NAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case CqlParserDQUOTE: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(2054) + p.Match(CqlParserDQUOTE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2055) + p.Match(CqlParserOBJECT_NAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2056) + p.Match(CqlParserDQUOTE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDataTypeContext is an interface to support dynamic dispatch. +type IDataTypeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DataTypeName() IDataTypeNameContext + DataTypeDefinition() IDataTypeDefinitionContext + + // IsDataTypeContext differentiates from other interfaces. + IsDataTypeContext() +} + +type DataTypeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDataTypeContext() *DataTypeContext { + var p = new(DataTypeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_dataType + return p +} + +func InitEmptyDataTypeContext(p *DataTypeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_dataType +} + +func (*DataTypeContext) IsDataTypeContext() {} + +func NewDataTypeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DataTypeContext { + var p = new(DataTypeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_dataType + + return p +} + +func (s *DataTypeContext) GetParser() antlr.Parser { return s.parser } + +func (s *DataTypeContext) DataTypeName() IDataTypeNameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDataTypeNameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDataTypeNameContext) +} + +func (s *DataTypeContext) DataTypeDefinition() IDataTypeDefinitionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDataTypeDefinitionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDataTypeDefinitionContext) +} + +func (s *DataTypeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *DataTypeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *DataTypeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterDataType(s) + } +} + +func (s *DataTypeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitDataType(s) + } +} + +func (s *DataTypeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitDataType(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) DataType() (localctx IDataTypeContext) { + localctx = NewDataTypeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 310, CqlParserRULE_dataType) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2059) + p.DataTypeName() + } + p.SetState(2061) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == CqlParserOPERATOR_LT { + { + p.SetState(2060) + p.DataTypeDefinition() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDataTypeNameContext is an interface to support dynamic dispatch. +type IDataTypeNameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + OBJECT_NAME() antlr.TerminalNode + K_TIMESTAMP() antlr.TerminalNode + K_SET() antlr.TerminalNode + K_ASCII() antlr.TerminalNode + K_BIGINT() antlr.TerminalNode + K_BLOB() antlr.TerminalNode + K_BOOLEAN() antlr.TerminalNode + K_COUNTER() antlr.TerminalNode + K_DATE() antlr.TerminalNode + K_DECIMAL() antlr.TerminalNode + K_DOUBLE() antlr.TerminalNode + K_FLOAT() antlr.TerminalNode + K_FROZEN() antlr.TerminalNode + K_INET() antlr.TerminalNode + K_INT() antlr.TerminalNode + K_LIST() antlr.TerminalNode + K_MAP() antlr.TerminalNode + K_SMALLINT() antlr.TerminalNode + K_TEXT() antlr.TerminalNode + K_TIME() antlr.TerminalNode + K_TIMEUUID() antlr.TerminalNode + K_TINYINT() antlr.TerminalNode + K_TUPLE() antlr.TerminalNode + K_VARCHAR() antlr.TerminalNode + K_VARINT() antlr.TerminalNode + K_UUID() antlr.TerminalNode + + // IsDataTypeNameContext differentiates from other interfaces. + IsDataTypeNameContext() +} + +type DataTypeNameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDataTypeNameContext() *DataTypeNameContext { + var p = new(DataTypeNameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_dataTypeName + return p +} + +func InitEmptyDataTypeNameContext(p *DataTypeNameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_dataTypeName +} + +func (*DataTypeNameContext) IsDataTypeNameContext() {} + +func NewDataTypeNameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DataTypeNameContext { + var p = new(DataTypeNameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_dataTypeName + + return p +} + +func (s *DataTypeNameContext) GetParser() antlr.Parser { return s.parser } + +func (s *DataTypeNameContext) OBJECT_NAME() antlr.TerminalNode { + return s.GetToken(CqlParserOBJECT_NAME, 0) +} + +func (s *DataTypeNameContext) K_TIMESTAMP() antlr.TerminalNode { + return s.GetToken(CqlParserK_TIMESTAMP, 0) +} + +func (s *DataTypeNameContext) K_SET() antlr.TerminalNode { + return s.GetToken(CqlParserK_SET, 0) +} + +func (s *DataTypeNameContext) K_ASCII() antlr.TerminalNode { + return s.GetToken(CqlParserK_ASCII, 0) +} + +func (s *DataTypeNameContext) K_BIGINT() antlr.TerminalNode { + return s.GetToken(CqlParserK_BIGINT, 0) +} + +func (s *DataTypeNameContext) K_BLOB() antlr.TerminalNode { + return s.GetToken(CqlParserK_BLOB, 0) +} + +func (s *DataTypeNameContext) K_BOOLEAN() antlr.TerminalNode { + return s.GetToken(CqlParserK_BOOLEAN, 0) +} + +func (s *DataTypeNameContext) K_COUNTER() antlr.TerminalNode { + return s.GetToken(CqlParserK_COUNTER, 0) +} + +func (s *DataTypeNameContext) K_DATE() antlr.TerminalNode { + return s.GetToken(CqlParserK_DATE, 0) +} + +func (s *DataTypeNameContext) K_DECIMAL() antlr.TerminalNode { + return s.GetToken(CqlParserK_DECIMAL, 0) +} + +func (s *DataTypeNameContext) K_DOUBLE() antlr.TerminalNode { + return s.GetToken(CqlParserK_DOUBLE, 0) +} + +func (s *DataTypeNameContext) K_FLOAT() antlr.TerminalNode { + return s.GetToken(CqlParserK_FLOAT, 0) +} + +func (s *DataTypeNameContext) K_FROZEN() antlr.TerminalNode { + return s.GetToken(CqlParserK_FROZEN, 0) +} + +func (s *DataTypeNameContext) K_INET() antlr.TerminalNode { + return s.GetToken(CqlParserK_INET, 0) +} + +func (s *DataTypeNameContext) K_INT() antlr.TerminalNode { + return s.GetToken(CqlParserK_INT, 0) +} + +func (s *DataTypeNameContext) K_LIST() antlr.TerminalNode { + return s.GetToken(CqlParserK_LIST, 0) +} + +func (s *DataTypeNameContext) K_MAP() antlr.TerminalNode { + return s.GetToken(CqlParserK_MAP, 0) +} + +func (s *DataTypeNameContext) K_SMALLINT() antlr.TerminalNode { + return s.GetToken(CqlParserK_SMALLINT, 0) +} + +func (s *DataTypeNameContext) K_TEXT() antlr.TerminalNode { + return s.GetToken(CqlParserK_TEXT, 0) +} + +func (s *DataTypeNameContext) K_TIME() antlr.TerminalNode { + return s.GetToken(CqlParserK_TIME, 0) +} + +func (s *DataTypeNameContext) K_TIMEUUID() antlr.TerminalNode { + return s.GetToken(CqlParserK_TIMEUUID, 0) +} + +func (s *DataTypeNameContext) K_TINYINT() antlr.TerminalNode { + return s.GetToken(CqlParserK_TINYINT, 0) +} + +func (s *DataTypeNameContext) K_TUPLE() antlr.TerminalNode { + return s.GetToken(CqlParserK_TUPLE, 0) +} + +func (s *DataTypeNameContext) K_VARCHAR() antlr.TerminalNode { + return s.GetToken(CqlParserK_VARCHAR, 0) +} + +func (s *DataTypeNameContext) K_VARINT() antlr.TerminalNode { + return s.GetToken(CqlParserK_VARINT, 0) +} + +func (s *DataTypeNameContext) K_UUID() antlr.TerminalNode { + return s.GetToken(CqlParserK_UUID, 0) +} + +func (s *DataTypeNameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *DataTypeNameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *DataTypeNameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterDataTypeName(s) + } +} + +func (s *DataTypeNameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitDataTypeName(s) + } +} + +func (s *DataTypeNameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitDataTypeName(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) DataTypeName() (localctx IDataTypeNameContext) { + localctx = NewDataTypeNameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 312, CqlParserRULE_dataTypeName) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2063) + _la = p.GetTokenStream().LA(1) + + if !((int64((_la-114)) & ^0x3f) == 0 && ((int64(1)<<(_la-114))&73183493680529665) != 0) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDataTypeDefinitionContext is an interface to support dynamic dispatch. +type IDataTypeDefinitionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SyntaxBracketLa() ISyntaxBracketLaContext + AllDataTypeName() []IDataTypeNameContext + DataTypeName(i int) IDataTypeNameContext + SyntaxBracketRa() ISyntaxBracketRaContext + AllSyntaxComma() []ISyntaxCommaContext + SyntaxComma(i int) ISyntaxCommaContext + + // IsDataTypeDefinitionContext differentiates from other interfaces. + IsDataTypeDefinitionContext() +} + +type DataTypeDefinitionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDataTypeDefinitionContext() *DataTypeDefinitionContext { + var p = new(DataTypeDefinitionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_dataTypeDefinition + return p +} + +func InitEmptyDataTypeDefinitionContext(p *DataTypeDefinitionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_dataTypeDefinition +} + +func (*DataTypeDefinitionContext) IsDataTypeDefinitionContext() {} + +func NewDataTypeDefinitionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DataTypeDefinitionContext { + var p = new(DataTypeDefinitionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_dataTypeDefinition + + return p +} + +func (s *DataTypeDefinitionContext) GetParser() antlr.Parser { return s.parser } + +func (s *DataTypeDefinitionContext) SyntaxBracketLa() ISyntaxBracketLaContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISyntaxBracketLaContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISyntaxBracketLaContext) +} + +func (s *DataTypeDefinitionContext) AllDataTypeName() []IDataTypeNameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IDataTypeNameContext); ok { + len++ + } + } + + tst := make([]IDataTypeNameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IDataTypeNameContext); ok { + tst[i] = t.(IDataTypeNameContext) + i++ + } + } + + return tst +} + +func (s *DataTypeDefinitionContext) DataTypeName(i int) IDataTypeNameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDataTypeNameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IDataTypeNameContext) +} + +func (s *DataTypeDefinitionContext) SyntaxBracketRa() ISyntaxBracketRaContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISyntaxBracketRaContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISyntaxBracketRaContext) +} + +func (s *DataTypeDefinitionContext) AllSyntaxComma() []ISyntaxCommaContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISyntaxCommaContext); ok { + len++ + } + } + + tst := make([]ISyntaxCommaContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISyntaxCommaContext); ok { + tst[i] = t.(ISyntaxCommaContext) + i++ + } + } + + return tst +} + +func (s *DataTypeDefinitionContext) SyntaxComma(i int) ISyntaxCommaContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISyntaxCommaContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISyntaxCommaContext) +} + +func (s *DataTypeDefinitionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *DataTypeDefinitionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *DataTypeDefinitionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterDataTypeDefinition(s) + } +} + +func (s *DataTypeDefinitionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitDataTypeDefinition(s) + } +} + +func (s *DataTypeDefinitionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitDataTypeDefinition(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) DataTypeDefinition() (localctx IDataTypeDefinitionContext) { + localctx = NewDataTypeDefinitionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 314, CqlParserRULE_dataTypeDefinition) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2065) + p.SyntaxBracketLa() + } + { + p.SetState(2066) + p.DataTypeName() + } + p.SetState(2072) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == CqlParserCOMMA { + { + p.SetState(2067) + p.SyntaxComma() + } + { + p.SetState(2068) + p.DataTypeName() + } + + p.SetState(2074) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(2075) + p.SyntaxBracketRa() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOrderDirectionContext is an interface to support dynamic dispatch. +type IOrderDirectionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + KwAsc() IKwAscContext + KwDesc() IKwDescContext + + // IsOrderDirectionContext differentiates from other interfaces. + IsOrderDirectionContext() +} + +type OrderDirectionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOrderDirectionContext() *OrderDirectionContext { + var p = new(OrderDirectionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_orderDirection + return p +} + +func InitEmptyOrderDirectionContext(p *OrderDirectionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_orderDirection +} + +func (*OrderDirectionContext) IsOrderDirectionContext() {} + +func NewOrderDirectionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *OrderDirectionContext { + var p = new(OrderDirectionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_orderDirection + + return p +} + +func (s *OrderDirectionContext) GetParser() antlr.Parser { return s.parser } + +func (s *OrderDirectionContext) KwAsc() IKwAscContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwAscContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwAscContext) +} + +func (s *OrderDirectionContext) KwDesc() IKwDescContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKwDescContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKwDescContext) +} + +func (s *OrderDirectionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *OrderDirectionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *OrderDirectionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterOrderDirection(s) + } +} + +func (s *OrderDirectionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitOrderDirection(s) + } +} + +func (s *OrderDirectionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitOrderDirection(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) OrderDirection() (localctx IOrderDirectionContext) { + localctx = NewOrderDirectionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 316, CqlParserRULE_orderDirection) + p.SetState(2079) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case CqlParserK_ASC: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2077) + p.KwAsc() + } + + case CqlParserK_DESC: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(2078) + p.KwDesc() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IRoleContext is an interface to support dynamic dispatch. +type IRoleContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + OBJECT_NAME() antlr.TerminalNode + + // IsRoleContext differentiates from other interfaces. + IsRoleContext() +} + +type RoleContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRoleContext() *RoleContext { + var p = new(RoleContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_role + return p +} + +func InitEmptyRoleContext(p *RoleContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_role +} + +func (*RoleContext) IsRoleContext() {} + +func NewRoleContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *RoleContext { + var p = new(RoleContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_role + + return p +} + +func (s *RoleContext) GetParser() antlr.Parser { return s.parser } + +func (s *RoleContext) OBJECT_NAME() antlr.TerminalNode { + return s.GetToken(CqlParserOBJECT_NAME, 0) +} + +func (s *RoleContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *RoleContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *RoleContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterRole(s) + } +} + +func (s *RoleContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitRole(s) + } +} + +func (s *RoleContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitRole(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) Role() (localctx IRoleContext) { + localctx = NewRoleContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 318, CqlParserRULE_role) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2081) + p.Match(CqlParserOBJECT_NAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ITriggerContext is an interface to support dynamic dispatch. +type ITriggerContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + OBJECT_NAME() antlr.TerminalNode + + // IsTriggerContext differentiates from other interfaces. + IsTriggerContext() +} + +type TriggerContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTriggerContext() *TriggerContext { + var p = new(TriggerContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_trigger + return p +} + +func InitEmptyTriggerContext(p *TriggerContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_trigger +} + +func (*TriggerContext) IsTriggerContext() {} + +func NewTriggerContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TriggerContext { + var p = new(TriggerContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_trigger + + return p +} + +func (s *TriggerContext) GetParser() antlr.Parser { return s.parser } + +func (s *TriggerContext) OBJECT_NAME() antlr.TerminalNode { + return s.GetToken(CqlParserOBJECT_NAME, 0) +} + +func (s *TriggerContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *TriggerContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *TriggerContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterTrigger(s) + } +} + +func (s *TriggerContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitTrigger(s) + } +} + +func (s *TriggerContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitTrigger(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) Trigger() (localctx ITriggerContext) { + localctx = NewTriggerContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 320, CqlParserRULE_trigger) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2083) + p.Match(CqlParserOBJECT_NAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ITriggerClassContext is an interface to support dynamic dispatch. +type ITriggerClassContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + StringLiteral() IStringLiteralContext + + // IsTriggerClassContext differentiates from other interfaces. + IsTriggerClassContext() +} + +type TriggerClassContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTriggerClassContext() *TriggerClassContext { + var p = new(TriggerClassContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_triggerClass + return p +} + +func InitEmptyTriggerClassContext(p *TriggerClassContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_triggerClass +} + +func (*TriggerClassContext) IsTriggerClassContext() {} + +func NewTriggerClassContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TriggerClassContext { + var p = new(TriggerClassContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_triggerClass + + return p +} + +func (s *TriggerClassContext) GetParser() antlr.Parser { return s.parser } + +func (s *TriggerClassContext) StringLiteral() IStringLiteralContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStringLiteralContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStringLiteralContext) +} + +func (s *TriggerClassContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *TriggerClassContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *TriggerClassContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterTriggerClass(s) + } +} + +func (s *TriggerClassContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitTriggerClass(s) + } +} + +func (s *TriggerClassContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitTriggerClass(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) TriggerClass() (localctx ITriggerClassContext) { + localctx = NewTriggerClassContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 322, CqlParserRULE_triggerClass) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2085) + p.StringLiteral() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IMaterializedViewContext is an interface to support dynamic dispatch. +type IMaterializedViewContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + OBJECT_NAME() antlr.TerminalNode + + // IsMaterializedViewContext differentiates from other interfaces. + IsMaterializedViewContext() +} + +type MaterializedViewContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyMaterializedViewContext() *MaterializedViewContext { + var p = new(MaterializedViewContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_materializedView + return p +} + +func InitEmptyMaterializedViewContext(p *MaterializedViewContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_materializedView +} + +func (*MaterializedViewContext) IsMaterializedViewContext() {} + +func NewMaterializedViewContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *MaterializedViewContext { + var p = new(MaterializedViewContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_materializedView + + return p +} + +func (s *MaterializedViewContext) GetParser() antlr.Parser { return s.parser } + +func (s *MaterializedViewContext) OBJECT_NAME() antlr.TerminalNode { + return s.GetToken(CqlParserOBJECT_NAME, 0) +} + +func (s *MaterializedViewContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *MaterializedViewContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *MaterializedViewContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterMaterializedView(s) + } +} + +func (s *MaterializedViewContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitMaterializedView(s) + } +} + +func (s *MaterializedViewContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitMaterializedView(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) MaterializedView() (localctx IMaterializedViewContext) { + localctx = NewMaterializedViewContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 324, CqlParserRULE_materializedView) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2087) + p.Match(CqlParserOBJECT_NAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IType_Context is an interface to support dynamic dispatch. +type IType_Context interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + OBJECT_NAME() antlr.TerminalNode + + // IsType_Context differentiates from other interfaces. + IsType_Context() +} + +type Type_Context struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyType_Context() *Type_Context { + var p = new(Type_Context) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_type_ + return p +} + +func InitEmptyType_Context(p *Type_Context) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_type_ +} + +func (*Type_Context) IsType_Context() {} + +func NewType_Context(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Type_Context { + var p = new(Type_Context) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_type_ + + return p +} + +func (s *Type_Context) GetParser() antlr.Parser { return s.parser } + +func (s *Type_Context) OBJECT_NAME() antlr.TerminalNode { + return s.GetToken(CqlParserOBJECT_NAME, 0) +} + +func (s *Type_Context) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Type_Context) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Type_Context) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterType_(s) + } +} + +func (s *Type_Context) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitType_(s) + } +} + +func (s *Type_Context) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitType_(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) Type_() (localctx IType_Context) { + localctx = NewType_Context(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 326, CqlParserRULE_type_) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2089) + p.Match(CqlParserOBJECT_NAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAggregateContext is an interface to support dynamic dispatch. +type IAggregateContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + OBJECT_NAME() antlr.TerminalNode + + // IsAggregateContext differentiates from other interfaces. + IsAggregateContext() +} + +type AggregateContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAggregateContext() *AggregateContext { + var p = new(AggregateContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_aggregate + return p +} + +func InitEmptyAggregateContext(p *AggregateContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_aggregate +} + +func (*AggregateContext) IsAggregateContext() {} + +func NewAggregateContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AggregateContext { + var p = new(AggregateContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_aggregate + + return p +} + +func (s *AggregateContext) GetParser() antlr.Parser { return s.parser } + +func (s *AggregateContext) OBJECT_NAME() antlr.TerminalNode { + return s.GetToken(CqlParserOBJECT_NAME, 0) +} + +func (s *AggregateContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AggregateContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *AggregateContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterAggregate(s) + } +} + +func (s *AggregateContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitAggregate(s) + } +} + +func (s *AggregateContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitAggregate(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) Aggregate() (localctx IAggregateContext) { + localctx = NewAggregateContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 328, CqlParserRULE_aggregate) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2091) + p.Match(CqlParserOBJECT_NAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IFunction_Context is an interface to support dynamic dispatch. +type IFunction_Context interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + OBJECT_NAME() antlr.TerminalNode + + // IsFunction_Context differentiates from other interfaces. + IsFunction_Context() +} + +type Function_Context struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFunction_Context() *Function_Context { + var p = new(Function_Context) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_function_ + return p +} + +func InitEmptyFunction_Context(p *Function_Context) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_function_ +} + +func (*Function_Context) IsFunction_Context() {} + +func NewFunction_Context(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Function_Context { + var p = new(Function_Context) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_function_ + + return p +} + +func (s *Function_Context) GetParser() antlr.Parser { return s.parser } + +func (s *Function_Context) OBJECT_NAME() antlr.TerminalNode { + return s.GetToken(CqlParserOBJECT_NAME, 0) +} + +func (s *Function_Context) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Function_Context) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Function_Context) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterFunction_(s) + } +} + +func (s *Function_Context) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitFunction_(s) + } +} + +func (s *Function_Context) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitFunction_(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) Function_() (localctx IFunction_Context) { + localctx = NewFunction_Context(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 330, CqlParserRULE_function_) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2093) + p.Match(CqlParserOBJECT_NAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ILanguageContext is an interface to support dynamic dispatch. +type ILanguageContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + OBJECT_NAME() antlr.TerminalNode + + // IsLanguageContext differentiates from other interfaces. + IsLanguageContext() +} + +type LanguageContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyLanguageContext() *LanguageContext { + var p = new(LanguageContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_language + return p +} + +func InitEmptyLanguageContext(p *LanguageContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_language +} + +func (*LanguageContext) IsLanguageContext() {} + +func NewLanguageContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *LanguageContext { + var p = new(LanguageContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_language + + return p +} + +func (s *LanguageContext) GetParser() antlr.Parser { return s.parser } + +func (s *LanguageContext) OBJECT_NAME() antlr.TerminalNode { + return s.GetToken(CqlParserOBJECT_NAME, 0) +} + +func (s *LanguageContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *LanguageContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *LanguageContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterLanguage(s) + } +} + +func (s *LanguageContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitLanguage(s) + } +} + +func (s *LanguageContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitLanguage(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) Language() (localctx ILanguageContext) { + localctx = NewLanguageContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 332, CqlParserRULE_language) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2095) + p.Match(CqlParserOBJECT_NAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IUserContext is an interface to support dynamic dispatch. +type IUserContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + OBJECT_NAME() antlr.TerminalNode + + // IsUserContext differentiates from other interfaces. + IsUserContext() +} + +type UserContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyUserContext() *UserContext { + var p = new(UserContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_user + return p +} + +func InitEmptyUserContext(p *UserContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_user +} + +func (*UserContext) IsUserContext() {} + +func NewUserContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *UserContext { + var p = new(UserContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_user + + return p +} + +func (s *UserContext) GetParser() antlr.Parser { return s.parser } + +func (s *UserContext) OBJECT_NAME() antlr.TerminalNode { + return s.GetToken(CqlParserOBJECT_NAME, 0) +} + +func (s *UserContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *UserContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *UserContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterUser(s) + } +} + +func (s *UserContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitUser(s) + } +} + +func (s *UserContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitUser(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) User() (localctx IUserContext) { + localctx = NewUserContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 334, CqlParserRULE_user) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2097) + p.Match(CqlParserOBJECT_NAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IPasswordContext is an interface to support dynamic dispatch. +type IPasswordContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + StringLiteral() IStringLiteralContext + + // IsPasswordContext differentiates from other interfaces. + IsPasswordContext() +} + +type PasswordContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPasswordContext() *PasswordContext { + var p = new(PasswordContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_password + return p +} + +func InitEmptyPasswordContext(p *PasswordContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_password +} + +func (*PasswordContext) IsPasswordContext() {} + +func NewPasswordContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PasswordContext { + var p = new(PasswordContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_password + + return p +} + +func (s *PasswordContext) GetParser() antlr.Parser { return s.parser } + +func (s *PasswordContext) StringLiteral() IStringLiteralContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStringLiteralContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStringLiteralContext) +} + +func (s *PasswordContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *PasswordContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *PasswordContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterPassword(s) + } +} + +func (s *PasswordContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitPassword(s) + } +} + +func (s *PasswordContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitPassword(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) Password() (localctx IPasswordContext) { + localctx = NewPasswordContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 336, CqlParserRULE_password) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2099) + p.StringLiteral() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IHashKeyContext is an interface to support dynamic dispatch. +type IHashKeyContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + OBJECT_NAME() antlr.TerminalNode + + // IsHashKeyContext differentiates from other interfaces. + IsHashKeyContext() +} + +type HashKeyContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyHashKeyContext() *HashKeyContext { + var p = new(HashKeyContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_hashKey + return p +} + +func InitEmptyHashKeyContext(p *HashKeyContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_hashKey +} + +func (*HashKeyContext) IsHashKeyContext() {} + +func NewHashKeyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *HashKeyContext { + var p = new(HashKeyContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_hashKey + + return p +} + +func (s *HashKeyContext) GetParser() antlr.Parser { return s.parser } + +func (s *HashKeyContext) OBJECT_NAME() antlr.TerminalNode { + return s.GetToken(CqlParserOBJECT_NAME, 0) +} + +func (s *HashKeyContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *HashKeyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *HashKeyContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterHashKey(s) + } +} + +func (s *HashKeyContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitHashKey(s) + } +} + +func (s *HashKeyContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitHashKey(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) HashKey() (localctx IHashKeyContext) { + localctx = NewHashKeyContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 338, CqlParserRULE_hashKey) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2101) + p.Match(CqlParserOBJECT_NAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IParamContext is an interface to support dynamic dispatch. +type IParamContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ParamName() IParamNameContext + DataType() IDataTypeContext + + // IsParamContext differentiates from other interfaces. + IsParamContext() +} + +type ParamContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyParamContext() *ParamContext { + var p = new(ParamContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_param + return p +} + +func InitEmptyParamContext(p *ParamContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_param +} + +func (*ParamContext) IsParamContext() {} + +func NewParamContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ParamContext { + var p = new(ParamContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_param + + return p +} + +func (s *ParamContext) GetParser() antlr.Parser { return s.parser } + +func (s *ParamContext) ParamName() IParamNameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IParamNameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IParamNameContext) +} + +func (s *ParamContext) DataType() IDataTypeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDataTypeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDataTypeContext) +} + +func (s *ParamContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ParamContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ParamContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterParam(s) + } +} + +func (s *ParamContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitParam(s) + } +} + +func (s *ParamContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitParam(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) Param() (localctx IParamContext) { + localctx = NewParamContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 340, CqlParserRULE_param) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2103) + p.ParamName() + } + { + p.SetState(2104) + p.DataType() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IParamNameContext is an interface to support dynamic dispatch. +type IParamNameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + OBJECT_NAME() antlr.TerminalNode + K_INPUT() antlr.TerminalNode + + // IsParamNameContext differentiates from other interfaces. + IsParamNameContext() +} + +type ParamNameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyParamNameContext() *ParamNameContext { + var p = new(ParamNameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_paramName + return p +} + +func InitEmptyParamNameContext(p *ParamNameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_paramName +} + +func (*ParamNameContext) IsParamNameContext() {} + +func NewParamNameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ParamNameContext { + var p = new(ParamNameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_paramName + + return p +} + +func (s *ParamNameContext) GetParser() antlr.Parser { return s.parser } + +func (s *ParamNameContext) OBJECT_NAME() antlr.TerminalNode { + return s.GetToken(CqlParserOBJECT_NAME, 0) +} + +func (s *ParamNameContext) K_INPUT() antlr.TerminalNode { + return s.GetToken(CqlParserK_INPUT, 0) +} + +func (s *ParamNameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ParamNameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ParamNameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterParamName(s) + } +} + +func (s *ParamNameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitParamName(s) + } +} + +func (s *ParamNameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitParamName(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) ParamName() (localctx IParamNameContext) { + localctx = NewParamNameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 342, CqlParserRULE_paramName) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2106) + _la = p.GetTokenStream().LA(1) + + if !(_la == CqlParserK_INPUT || _la == CqlParserOBJECT_NAME) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IKwAddContext is an interface to support dynamic dispatch. +type IKwAddContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + K_ADD() antlr.TerminalNode + + // IsKwAddContext differentiates from other interfaces. + IsKwAddContext() +} + +type KwAddContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyKwAddContext() *KwAddContext { + var p = new(KwAddContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_kwAdd + return p +} + +func InitEmptyKwAddContext(p *KwAddContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_kwAdd +} + +func (*KwAddContext) IsKwAddContext() {} + +func NewKwAddContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KwAddContext { + var p = new(KwAddContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_kwAdd + + return p +} + +func (s *KwAddContext) GetParser() antlr.Parser { return s.parser } + +func (s *KwAddContext) K_ADD() antlr.TerminalNode { + return s.GetToken(CqlParserK_ADD, 0) +} + +func (s *KwAddContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *KwAddContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *KwAddContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterKwAdd(s) + } +} + +func (s *KwAddContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitKwAdd(s) + } +} + +func (s *KwAddContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitKwAdd(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) KwAdd() (localctx IKwAddContext) { + localctx = NewKwAddContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 344, CqlParserRULE_kwAdd) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2108) + p.Match(CqlParserK_ADD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IKwAggregateContext is an interface to support dynamic dispatch. +type IKwAggregateContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + K_AGGREGATE() antlr.TerminalNode + + // IsKwAggregateContext differentiates from other interfaces. + IsKwAggregateContext() +} + +type KwAggregateContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyKwAggregateContext() *KwAggregateContext { + var p = new(KwAggregateContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_kwAggregate + return p +} + +func InitEmptyKwAggregateContext(p *KwAggregateContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_kwAggregate +} + +func (*KwAggregateContext) IsKwAggregateContext() {} + +func NewKwAggregateContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KwAggregateContext { + var p = new(KwAggregateContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_kwAggregate + + return p +} + +func (s *KwAggregateContext) GetParser() antlr.Parser { return s.parser } + +func (s *KwAggregateContext) K_AGGREGATE() antlr.TerminalNode { + return s.GetToken(CqlParserK_AGGREGATE, 0) +} + +func (s *KwAggregateContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *KwAggregateContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *KwAggregateContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterKwAggregate(s) + } +} + +func (s *KwAggregateContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitKwAggregate(s) + } +} + +func (s *KwAggregateContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitKwAggregate(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) KwAggregate() (localctx IKwAggregateContext) { + localctx = NewKwAggregateContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 346, CqlParserRULE_kwAggregate) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2110) + p.Match(CqlParserK_AGGREGATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IKwAllContext is an interface to support dynamic dispatch. +type IKwAllContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + K_ALL() antlr.TerminalNode + + // IsKwAllContext differentiates from other interfaces. + IsKwAllContext() +} + +type KwAllContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyKwAllContext() *KwAllContext { + var p = new(KwAllContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_kwAll + return p +} + +func InitEmptyKwAllContext(p *KwAllContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_kwAll +} + +func (*KwAllContext) IsKwAllContext() {} + +func NewKwAllContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KwAllContext { + var p = new(KwAllContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_kwAll + + return p +} + +func (s *KwAllContext) GetParser() antlr.Parser { return s.parser } + +func (s *KwAllContext) K_ALL() antlr.TerminalNode { + return s.GetToken(CqlParserK_ALL, 0) +} + +func (s *KwAllContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *KwAllContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *KwAllContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterKwAll(s) + } +} + +func (s *KwAllContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitKwAll(s) + } +} + +func (s *KwAllContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitKwAll(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) KwAll() (localctx IKwAllContext) { + localctx = NewKwAllContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 348, CqlParserRULE_kwAll) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2112) + p.Match(CqlParserK_ALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IKwAllPermissionsContext is an interface to support dynamic dispatch. +type IKwAllPermissionsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + K_ALL() antlr.TerminalNode + K_PERMISSIONS() antlr.TerminalNode + + // IsKwAllPermissionsContext differentiates from other interfaces. + IsKwAllPermissionsContext() +} + +type KwAllPermissionsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyKwAllPermissionsContext() *KwAllPermissionsContext { + var p = new(KwAllPermissionsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_kwAllPermissions + return p +} + +func InitEmptyKwAllPermissionsContext(p *KwAllPermissionsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_kwAllPermissions +} + +func (*KwAllPermissionsContext) IsKwAllPermissionsContext() {} + +func NewKwAllPermissionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KwAllPermissionsContext { + var p = new(KwAllPermissionsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_kwAllPermissions + + return p +} + +func (s *KwAllPermissionsContext) GetParser() antlr.Parser { return s.parser } + +func (s *KwAllPermissionsContext) K_ALL() antlr.TerminalNode { + return s.GetToken(CqlParserK_ALL, 0) +} + +func (s *KwAllPermissionsContext) K_PERMISSIONS() antlr.TerminalNode { + return s.GetToken(CqlParserK_PERMISSIONS, 0) +} + +func (s *KwAllPermissionsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *KwAllPermissionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *KwAllPermissionsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterKwAllPermissions(s) + } +} + +func (s *KwAllPermissionsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitKwAllPermissions(s) + } +} + +func (s *KwAllPermissionsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitKwAllPermissions(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) KwAllPermissions() (localctx IKwAllPermissionsContext) { + localctx = NewKwAllPermissionsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 350, CqlParserRULE_kwAllPermissions) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2114) + p.Match(CqlParserK_ALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2115) + p.Match(CqlParserK_PERMISSIONS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IKwAllowContext is an interface to support dynamic dispatch. +type IKwAllowContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + K_ALLOW() antlr.TerminalNode + + // IsKwAllowContext differentiates from other interfaces. + IsKwAllowContext() +} + +type KwAllowContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyKwAllowContext() *KwAllowContext { + var p = new(KwAllowContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_kwAllow + return p +} + +func InitEmptyKwAllowContext(p *KwAllowContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_kwAllow +} + +func (*KwAllowContext) IsKwAllowContext() {} + +func NewKwAllowContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KwAllowContext { + var p = new(KwAllowContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_kwAllow + + return p +} + +func (s *KwAllowContext) GetParser() antlr.Parser { return s.parser } + +func (s *KwAllowContext) K_ALLOW() antlr.TerminalNode { + return s.GetToken(CqlParserK_ALLOW, 0) +} + +func (s *KwAllowContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *KwAllowContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *KwAllowContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterKwAllow(s) + } +} + +func (s *KwAllowContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitKwAllow(s) + } +} + +func (s *KwAllowContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitKwAllow(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) KwAllow() (localctx IKwAllowContext) { + localctx = NewKwAllowContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 352, CqlParserRULE_kwAllow) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2117) + p.Match(CqlParserK_ALLOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IKwAlterContext is an interface to support dynamic dispatch. +type IKwAlterContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + K_ALTER() antlr.TerminalNode + + // IsKwAlterContext differentiates from other interfaces. + IsKwAlterContext() +} + +type KwAlterContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyKwAlterContext() *KwAlterContext { + var p = new(KwAlterContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_kwAlter + return p +} + +func InitEmptyKwAlterContext(p *KwAlterContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_kwAlter +} + +func (*KwAlterContext) IsKwAlterContext() {} + +func NewKwAlterContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KwAlterContext { + var p = new(KwAlterContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_kwAlter + + return p +} + +func (s *KwAlterContext) GetParser() antlr.Parser { return s.parser } + +func (s *KwAlterContext) K_ALTER() antlr.TerminalNode { + return s.GetToken(CqlParserK_ALTER, 0) +} + +func (s *KwAlterContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *KwAlterContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *KwAlterContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterKwAlter(s) + } +} + +func (s *KwAlterContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitKwAlter(s) + } +} + +func (s *KwAlterContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitKwAlter(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) KwAlter() (localctx IKwAlterContext) { + localctx = NewKwAlterContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 354, CqlParserRULE_kwAlter) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2119) + p.Match(CqlParserK_ALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IKwAndContext is an interface to support dynamic dispatch. +type IKwAndContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + K_AND() antlr.TerminalNode + + // IsKwAndContext differentiates from other interfaces. + IsKwAndContext() +} + +type KwAndContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyKwAndContext() *KwAndContext { + var p = new(KwAndContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_kwAnd + return p +} + +func InitEmptyKwAndContext(p *KwAndContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_kwAnd +} + +func (*KwAndContext) IsKwAndContext() {} + +func NewKwAndContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KwAndContext { + var p = new(KwAndContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_kwAnd + + return p +} + +func (s *KwAndContext) GetParser() antlr.Parser { return s.parser } + +func (s *KwAndContext) K_AND() antlr.TerminalNode { + return s.GetToken(CqlParserK_AND, 0) +} + +func (s *KwAndContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *KwAndContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *KwAndContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterKwAnd(s) + } +} + +func (s *KwAndContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitKwAnd(s) + } +} + +func (s *KwAndContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitKwAnd(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) KwAnd() (localctx IKwAndContext) { + localctx = NewKwAndContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 356, CqlParserRULE_kwAnd) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2121) + p.Match(CqlParserK_AND) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IKwApplyContext is an interface to support dynamic dispatch. +type IKwApplyContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + K_APPLY() antlr.TerminalNode + + // IsKwApplyContext differentiates from other interfaces. + IsKwApplyContext() +} + +type KwApplyContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyKwApplyContext() *KwApplyContext { + var p = new(KwApplyContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_kwApply + return p +} + +func InitEmptyKwApplyContext(p *KwApplyContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_kwApply +} + +func (*KwApplyContext) IsKwApplyContext() {} + +func NewKwApplyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KwApplyContext { + var p = new(KwApplyContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_kwApply + + return p +} + +func (s *KwApplyContext) GetParser() antlr.Parser { return s.parser } + +func (s *KwApplyContext) K_APPLY() antlr.TerminalNode { + return s.GetToken(CqlParserK_APPLY, 0) +} + +func (s *KwApplyContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *KwApplyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *KwApplyContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterKwApply(s) + } +} + +func (s *KwApplyContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitKwApply(s) + } +} + +func (s *KwApplyContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitKwApply(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) KwApply() (localctx IKwApplyContext) { + localctx = NewKwApplyContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 358, CqlParserRULE_kwApply) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2123) + p.Match(CqlParserK_APPLY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IKwAsContext is an interface to support dynamic dispatch. +type IKwAsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + K_AS() antlr.TerminalNode + + // IsKwAsContext differentiates from other interfaces. + IsKwAsContext() +} + +type KwAsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyKwAsContext() *KwAsContext { + var p = new(KwAsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_kwAs + return p +} + +func InitEmptyKwAsContext(p *KwAsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_kwAs +} + +func (*KwAsContext) IsKwAsContext() {} + +func NewKwAsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KwAsContext { + var p = new(KwAsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_kwAs + + return p +} + +func (s *KwAsContext) GetParser() antlr.Parser { return s.parser } + +func (s *KwAsContext) K_AS() antlr.TerminalNode { + return s.GetToken(CqlParserK_AS, 0) +} + +func (s *KwAsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *KwAsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *KwAsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterKwAs(s) + } +} + +func (s *KwAsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitKwAs(s) + } +} + +func (s *KwAsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitKwAs(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) KwAs() (localctx IKwAsContext) { + localctx = NewKwAsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 360, CqlParserRULE_kwAs) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2125) + p.Match(CqlParserK_AS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IKwAscContext is an interface to support dynamic dispatch. +type IKwAscContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + K_ASC() antlr.TerminalNode + + // IsKwAscContext differentiates from other interfaces. + IsKwAscContext() +} + +type KwAscContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyKwAscContext() *KwAscContext { + var p = new(KwAscContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_kwAsc + return p +} + +func InitEmptyKwAscContext(p *KwAscContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_kwAsc +} + +func (*KwAscContext) IsKwAscContext() {} + +func NewKwAscContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KwAscContext { + var p = new(KwAscContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_kwAsc + + return p +} + +func (s *KwAscContext) GetParser() antlr.Parser { return s.parser } + +func (s *KwAscContext) K_ASC() antlr.TerminalNode { + return s.GetToken(CqlParserK_ASC, 0) +} + +func (s *KwAscContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *KwAscContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *KwAscContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterKwAsc(s) + } +} + +func (s *KwAscContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitKwAsc(s) + } +} + +func (s *KwAscContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitKwAsc(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) KwAsc() (localctx IKwAscContext) { + localctx = NewKwAscContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 362, CqlParserRULE_kwAsc) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2127) + p.Match(CqlParserK_ASC) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IKwAuthorizeContext is an interface to support dynamic dispatch. +type IKwAuthorizeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + K_AUTHORIZE() antlr.TerminalNode + + // IsKwAuthorizeContext differentiates from other interfaces. + IsKwAuthorizeContext() +} + +type KwAuthorizeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyKwAuthorizeContext() *KwAuthorizeContext { + var p = new(KwAuthorizeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_kwAuthorize + return p +} + +func InitEmptyKwAuthorizeContext(p *KwAuthorizeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_kwAuthorize +} + +func (*KwAuthorizeContext) IsKwAuthorizeContext() {} + +func NewKwAuthorizeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KwAuthorizeContext { + var p = new(KwAuthorizeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_kwAuthorize + + return p +} + +func (s *KwAuthorizeContext) GetParser() antlr.Parser { return s.parser } + +func (s *KwAuthorizeContext) K_AUTHORIZE() antlr.TerminalNode { + return s.GetToken(CqlParserK_AUTHORIZE, 0) +} + +func (s *KwAuthorizeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *KwAuthorizeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *KwAuthorizeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterKwAuthorize(s) + } +} + +func (s *KwAuthorizeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitKwAuthorize(s) + } +} + +func (s *KwAuthorizeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitKwAuthorize(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) KwAuthorize() (localctx IKwAuthorizeContext) { + localctx = NewKwAuthorizeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 364, CqlParserRULE_kwAuthorize) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2129) + p.Match(CqlParserK_AUTHORIZE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IKwBatchContext is an interface to support dynamic dispatch. +type IKwBatchContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + K_BATCH() antlr.TerminalNode + + // IsKwBatchContext differentiates from other interfaces. + IsKwBatchContext() +} + +type KwBatchContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyKwBatchContext() *KwBatchContext { + var p = new(KwBatchContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_kwBatch + return p +} + +func InitEmptyKwBatchContext(p *KwBatchContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_kwBatch +} + +func (*KwBatchContext) IsKwBatchContext() {} + +func NewKwBatchContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KwBatchContext { + var p = new(KwBatchContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_kwBatch + + return p +} + +func (s *KwBatchContext) GetParser() antlr.Parser { return s.parser } + +func (s *KwBatchContext) K_BATCH() antlr.TerminalNode { + return s.GetToken(CqlParserK_BATCH, 0) +} + +func (s *KwBatchContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *KwBatchContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *KwBatchContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterKwBatch(s) + } +} + +func (s *KwBatchContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitKwBatch(s) + } +} + +func (s *KwBatchContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitKwBatch(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) KwBatch() (localctx IKwBatchContext) { + localctx = NewKwBatchContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 366, CqlParserRULE_kwBatch) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2131) + p.Match(CqlParserK_BATCH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IKwBeginContext is an interface to support dynamic dispatch. +type IKwBeginContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + K_BEGIN() antlr.TerminalNode + + // IsKwBeginContext differentiates from other interfaces. + IsKwBeginContext() +} + +type KwBeginContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyKwBeginContext() *KwBeginContext { + var p = new(KwBeginContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_kwBegin + return p +} + +func InitEmptyKwBeginContext(p *KwBeginContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_kwBegin +} + +func (*KwBeginContext) IsKwBeginContext() {} + +func NewKwBeginContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KwBeginContext { + var p = new(KwBeginContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_kwBegin + + return p +} + +func (s *KwBeginContext) GetParser() antlr.Parser { return s.parser } + +func (s *KwBeginContext) K_BEGIN() antlr.TerminalNode { + return s.GetToken(CqlParserK_BEGIN, 0) +} + +func (s *KwBeginContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *KwBeginContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *KwBeginContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterKwBegin(s) + } +} + +func (s *KwBeginContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitKwBegin(s) + } +} + +func (s *KwBeginContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitKwBegin(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) KwBegin() (localctx IKwBeginContext) { + localctx = NewKwBeginContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 368, CqlParserRULE_kwBegin) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2133) + p.Match(CqlParserK_BEGIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IKwByContext is an interface to support dynamic dispatch. +type IKwByContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + K_BY() antlr.TerminalNode + + // IsKwByContext differentiates from other interfaces. + IsKwByContext() +} + +type KwByContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyKwByContext() *KwByContext { + var p = new(KwByContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_kwBy + return p +} + +func InitEmptyKwByContext(p *KwByContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_kwBy +} + +func (*KwByContext) IsKwByContext() {} + +func NewKwByContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KwByContext { + var p = new(KwByContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_kwBy + + return p +} + +func (s *KwByContext) GetParser() antlr.Parser { return s.parser } + +func (s *KwByContext) K_BY() antlr.TerminalNode { + return s.GetToken(CqlParserK_BY, 0) +} + +func (s *KwByContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *KwByContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *KwByContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterKwBy(s) + } +} + +func (s *KwByContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitKwBy(s) + } +} + +func (s *KwByContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitKwBy(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) KwBy() (localctx IKwByContext) { + localctx = NewKwByContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 370, CqlParserRULE_kwBy) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2135) + p.Match(CqlParserK_BY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IKwCalledContext is an interface to support dynamic dispatch. +type IKwCalledContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + K_CALLED() antlr.TerminalNode + + // IsKwCalledContext differentiates from other interfaces. + IsKwCalledContext() +} + +type KwCalledContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyKwCalledContext() *KwCalledContext { + var p = new(KwCalledContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_kwCalled + return p +} + +func InitEmptyKwCalledContext(p *KwCalledContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_kwCalled +} + +func (*KwCalledContext) IsKwCalledContext() {} + +func NewKwCalledContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KwCalledContext { + var p = new(KwCalledContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_kwCalled + + return p +} + +func (s *KwCalledContext) GetParser() antlr.Parser { return s.parser } + +func (s *KwCalledContext) K_CALLED() antlr.TerminalNode { + return s.GetToken(CqlParserK_CALLED, 0) +} + +func (s *KwCalledContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *KwCalledContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *KwCalledContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterKwCalled(s) + } +} + +func (s *KwCalledContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitKwCalled(s) + } +} + +func (s *KwCalledContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitKwCalled(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) KwCalled() (localctx IKwCalledContext) { + localctx = NewKwCalledContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 372, CqlParserRULE_kwCalled) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2137) + p.Match(CqlParserK_CALLED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IKwClusteringContext is an interface to support dynamic dispatch. +type IKwClusteringContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + K_CLUSTERING() antlr.TerminalNode + + // IsKwClusteringContext differentiates from other interfaces. + IsKwClusteringContext() +} + +type KwClusteringContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyKwClusteringContext() *KwClusteringContext { + var p = new(KwClusteringContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_kwClustering + return p +} + +func InitEmptyKwClusteringContext(p *KwClusteringContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_kwClustering +} + +func (*KwClusteringContext) IsKwClusteringContext() {} + +func NewKwClusteringContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KwClusteringContext { + var p = new(KwClusteringContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_kwClustering + + return p +} + +func (s *KwClusteringContext) GetParser() antlr.Parser { return s.parser } + +func (s *KwClusteringContext) K_CLUSTERING() antlr.TerminalNode { + return s.GetToken(CqlParserK_CLUSTERING, 0) +} + +func (s *KwClusteringContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *KwClusteringContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *KwClusteringContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterKwClustering(s) + } +} + +func (s *KwClusteringContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitKwClustering(s) + } +} + +func (s *KwClusteringContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitKwClustering(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) KwClustering() (localctx IKwClusteringContext) { + localctx = NewKwClusteringContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 374, CqlParserRULE_kwClustering) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2139) + p.Match(CqlParserK_CLUSTERING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IKwCompactContext is an interface to support dynamic dispatch. +type IKwCompactContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + K_COMPACT() antlr.TerminalNode + + // IsKwCompactContext differentiates from other interfaces. + IsKwCompactContext() +} + +type KwCompactContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyKwCompactContext() *KwCompactContext { + var p = new(KwCompactContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_kwCompact + return p +} + +func InitEmptyKwCompactContext(p *KwCompactContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_kwCompact +} + +func (*KwCompactContext) IsKwCompactContext() {} + +func NewKwCompactContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KwCompactContext { + var p = new(KwCompactContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_kwCompact + + return p +} + +func (s *KwCompactContext) GetParser() antlr.Parser { return s.parser } + +func (s *KwCompactContext) K_COMPACT() antlr.TerminalNode { + return s.GetToken(CqlParserK_COMPACT, 0) +} + +func (s *KwCompactContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *KwCompactContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *KwCompactContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterKwCompact(s) + } +} + +func (s *KwCompactContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitKwCompact(s) + } +} + +func (s *KwCompactContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitKwCompact(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) KwCompact() (localctx IKwCompactContext) { + localctx = NewKwCompactContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 376, CqlParserRULE_kwCompact) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2141) + p.Match(CqlParserK_COMPACT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IKwContainsContext is an interface to support dynamic dispatch. +type IKwContainsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + K_CONTAINS() antlr.TerminalNode + + // IsKwContainsContext differentiates from other interfaces. + IsKwContainsContext() +} + +type KwContainsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyKwContainsContext() *KwContainsContext { + var p = new(KwContainsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_kwContains + return p +} + +func InitEmptyKwContainsContext(p *KwContainsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_kwContains +} + +func (*KwContainsContext) IsKwContainsContext() {} + +func NewKwContainsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KwContainsContext { + var p = new(KwContainsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_kwContains + + return p +} + +func (s *KwContainsContext) GetParser() antlr.Parser { return s.parser } + +func (s *KwContainsContext) K_CONTAINS() antlr.TerminalNode { + return s.GetToken(CqlParserK_CONTAINS, 0) +} + +func (s *KwContainsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *KwContainsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *KwContainsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterKwContains(s) + } +} + +func (s *KwContainsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitKwContains(s) + } +} + +func (s *KwContainsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitKwContains(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) KwContains() (localctx IKwContainsContext) { + localctx = NewKwContainsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 378, CqlParserRULE_kwContains) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2143) + p.Match(CqlParserK_CONTAINS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IKwCreateContext is an interface to support dynamic dispatch. +type IKwCreateContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + K_CREATE() antlr.TerminalNode + + // IsKwCreateContext differentiates from other interfaces. + IsKwCreateContext() +} + +type KwCreateContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyKwCreateContext() *KwCreateContext { + var p = new(KwCreateContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_kwCreate + return p +} + +func InitEmptyKwCreateContext(p *KwCreateContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_kwCreate +} + +func (*KwCreateContext) IsKwCreateContext() {} + +func NewKwCreateContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KwCreateContext { + var p = new(KwCreateContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_kwCreate + + return p +} + +func (s *KwCreateContext) GetParser() antlr.Parser { return s.parser } + +func (s *KwCreateContext) K_CREATE() antlr.TerminalNode { + return s.GetToken(CqlParserK_CREATE, 0) +} + +func (s *KwCreateContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *KwCreateContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *KwCreateContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterKwCreate(s) + } +} + +func (s *KwCreateContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitKwCreate(s) + } +} + +func (s *KwCreateContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitKwCreate(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) KwCreate() (localctx IKwCreateContext) { + localctx = NewKwCreateContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 380, CqlParserRULE_kwCreate) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2145) + p.Match(CqlParserK_CREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IKwDeleteContext is an interface to support dynamic dispatch. +type IKwDeleteContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + K_DELETE() antlr.TerminalNode + + // IsKwDeleteContext differentiates from other interfaces. + IsKwDeleteContext() +} + +type KwDeleteContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyKwDeleteContext() *KwDeleteContext { + var p = new(KwDeleteContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_kwDelete + return p +} + +func InitEmptyKwDeleteContext(p *KwDeleteContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_kwDelete +} + +func (*KwDeleteContext) IsKwDeleteContext() {} + +func NewKwDeleteContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KwDeleteContext { + var p = new(KwDeleteContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_kwDelete + + return p +} + +func (s *KwDeleteContext) GetParser() antlr.Parser { return s.parser } + +func (s *KwDeleteContext) K_DELETE() antlr.TerminalNode { + return s.GetToken(CqlParserK_DELETE, 0) +} + +func (s *KwDeleteContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *KwDeleteContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *KwDeleteContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterKwDelete(s) + } +} + +func (s *KwDeleteContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitKwDelete(s) + } +} + +func (s *KwDeleteContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitKwDelete(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) KwDelete() (localctx IKwDeleteContext) { + localctx = NewKwDeleteContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 382, CqlParserRULE_kwDelete) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2147) + p.Match(CqlParserK_DELETE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IKwDescContext is an interface to support dynamic dispatch. +type IKwDescContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + K_DESC() antlr.TerminalNode + + // IsKwDescContext differentiates from other interfaces. + IsKwDescContext() +} + +type KwDescContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyKwDescContext() *KwDescContext { + var p = new(KwDescContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_kwDesc + return p +} + +func InitEmptyKwDescContext(p *KwDescContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_kwDesc +} + +func (*KwDescContext) IsKwDescContext() {} + +func NewKwDescContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KwDescContext { + var p = new(KwDescContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_kwDesc + + return p +} + +func (s *KwDescContext) GetParser() antlr.Parser { return s.parser } + +func (s *KwDescContext) K_DESC() antlr.TerminalNode { + return s.GetToken(CqlParserK_DESC, 0) +} + +func (s *KwDescContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *KwDescContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *KwDescContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterKwDesc(s) + } +} + +func (s *KwDescContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitKwDesc(s) + } +} + +func (s *KwDescContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitKwDesc(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) KwDesc() (localctx IKwDescContext) { + localctx = NewKwDescContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 384, CqlParserRULE_kwDesc) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2149) + p.Match(CqlParserK_DESC) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IKwDescibeContext is an interface to support dynamic dispatch. +type IKwDescibeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + K_DESCRIBE() antlr.TerminalNode + + // IsKwDescibeContext differentiates from other interfaces. + IsKwDescibeContext() +} + +type KwDescibeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyKwDescibeContext() *KwDescibeContext { + var p = new(KwDescibeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_kwDescibe + return p +} + +func InitEmptyKwDescibeContext(p *KwDescibeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_kwDescibe +} + +func (*KwDescibeContext) IsKwDescibeContext() {} + +func NewKwDescibeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KwDescibeContext { + var p = new(KwDescibeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_kwDescibe + + return p +} + +func (s *KwDescibeContext) GetParser() antlr.Parser { return s.parser } + +func (s *KwDescibeContext) K_DESCRIBE() antlr.TerminalNode { + return s.GetToken(CqlParserK_DESCRIBE, 0) +} + +func (s *KwDescibeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *KwDescibeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *KwDescibeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterKwDescibe(s) + } +} + +func (s *KwDescibeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitKwDescibe(s) + } +} + +func (s *KwDescibeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitKwDescibe(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) KwDescibe() (localctx IKwDescibeContext) { + localctx = NewKwDescibeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 386, CqlParserRULE_kwDescibe) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2151) + p.Match(CqlParserK_DESCRIBE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IKwDistinctContext is an interface to support dynamic dispatch. +type IKwDistinctContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + K_DISTINCT() antlr.TerminalNode + + // IsKwDistinctContext differentiates from other interfaces. + IsKwDistinctContext() +} + +type KwDistinctContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyKwDistinctContext() *KwDistinctContext { + var p = new(KwDistinctContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_kwDistinct + return p +} + +func InitEmptyKwDistinctContext(p *KwDistinctContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_kwDistinct +} + +func (*KwDistinctContext) IsKwDistinctContext() {} + +func NewKwDistinctContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KwDistinctContext { + var p = new(KwDistinctContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_kwDistinct + + return p +} + +func (s *KwDistinctContext) GetParser() antlr.Parser { return s.parser } + +func (s *KwDistinctContext) K_DISTINCT() antlr.TerminalNode { + return s.GetToken(CqlParserK_DISTINCT, 0) +} + +func (s *KwDistinctContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *KwDistinctContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *KwDistinctContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterKwDistinct(s) + } +} + +func (s *KwDistinctContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitKwDistinct(s) + } +} + +func (s *KwDistinctContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitKwDistinct(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) KwDistinct() (localctx IKwDistinctContext) { + localctx = NewKwDistinctContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 388, CqlParserRULE_kwDistinct) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2153) + p.Match(CqlParserK_DISTINCT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IKwDropContext is an interface to support dynamic dispatch. +type IKwDropContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + K_DROP() antlr.TerminalNode + + // IsKwDropContext differentiates from other interfaces. + IsKwDropContext() +} + +type KwDropContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyKwDropContext() *KwDropContext { + var p = new(KwDropContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_kwDrop + return p +} + +func InitEmptyKwDropContext(p *KwDropContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_kwDrop +} + +func (*KwDropContext) IsKwDropContext() {} + +func NewKwDropContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KwDropContext { + var p = new(KwDropContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_kwDrop + + return p +} + +func (s *KwDropContext) GetParser() antlr.Parser { return s.parser } + +func (s *KwDropContext) K_DROP() antlr.TerminalNode { + return s.GetToken(CqlParserK_DROP, 0) +} + +func (s *KwDropContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *KwDropContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *KwDropContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterKwDrop(s) + } +} + +func (s *KwDropContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitKwDrop(s) + } +} + +func (s *KwDropContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitKwDrop(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) KwDrop() (localctx IKwDropContext) { + localctx = NewKwDropContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 390, CqlParserRULE_kwDrop) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2155) + p.Match(CqlParserK_DROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IKwDurableWritesContext is an interface to support dynamic dispatch. +type IKwDurableWritesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + K_DURABLE_WRITES() antlr.TerminalNode + + // IsKwDurableWritesContext differentiates from other interfaces. + IsKwDurableWritesContext() +} + +type KwDurableWritesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyKwDurableWritesContext() *KwDurableWritesContext { + var p = new(KwDurableWritesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_kwDurableWrites + return p +} + +func InitEmptyKwDurableWritesContext(p *KwDurableWritesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_kwDurableWrites +} + +func (*KwDurableWritesContext) IsKwDurableWritesContext() {} + +func NewKwDurableWritesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KwDurableWritesContext { + var p = new(KwDurableWritesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_kwDurableWrites + + return p +} + +func (s *KwDurableWritesContext) GetParser() antlr.Parser { return s.parser } + +func (s *KwDurableWritesContext) K_DURABLE_WRITES() antlr.TerminalNode { + return s.GetToken(CqlParserK_DURABLE_WRITES, 0) +} + +func (s *KwDurableWritesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *KwDurableWritesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *KwDurableWritesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterKwDurableWrites(s) + } +} + +func (s *KwDurableWritesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitKwDurableWrites(s) + } +} + +func (s *KwDurableWritesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitKwDurableWrites(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) KwDurableWrites() (localctx IKwDurableWritesContext) { + localctx = NewKwDurableWritesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 392, CqlParserRULE_kwDurableWrites) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2157) + p.Match(CqlParserK_DURABLE_WRITES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IKwEntriesContext is an interface to support dynamic dispatch. +type IKwEntriesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + K_ENTRIES() antlr.TerminalNode + + // IsKwEntriesContext differentiates from other interfaces. + IsKwEntriesContext() +} + +type KwEntriesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyKwEntriesContext() *KwEntriesContext { + var p = new(KwEntriesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_kwEntries + return p +} + +func InitEmptyKwEntriesContext(p *KwEntriesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_kwEntries +} + +func (*KwEntriesContext) IsKwEntriesContext() {} + +func NewKwEntriesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KwEntriesContext { + var p = new(KwEntriesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_kwEntries + + return p +} + +func (s *KwEntriesContext) GetParser() antlr.Parser { return s.parser } + +func (s *KwEntriesContext) K_ENTRIES() antlr.TerminalNode { + return s.GetToken(CqlParserK_ENTRIES, 0) +} + +func (s *KwEntriesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *KwEntriesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *KwEntriesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterKwEntries(s) + } +} + +func (s *KwEntriesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitKwEntries(s) + } +} + +func (s *KwEntriesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitKwEntries(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) KwEntries() (localctx IKwEntriesContext) { + localctx = NewKwEntriesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 394, CqlParserRULE_kwEntries) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2159) + p.Match(CqlParserK_ENTRIES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IKwExecuteContext is an interface to support dynamic dispatch. +type IKwExecuteContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + K_EXECUTE() antlr.TerminalNode + + // IsKwExecuteContext differentiates from other interfaces. + IsKwExecuteContext() +} + +type KwExecuteContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyKwExecuteContext() *KwExecuteContext { + var p = new(KwExecuteContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_kwExecute + return p +} + +func InitEmptyKwExecuteContext(p *KwExecuteContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_kwExecute +} + +func (*KwExecuteContext) IsKwExecuteContext() {} + +func NewKwExecuteContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KwExecuteContext { + var p = new(KwExecuteContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_kwExecute + + return p +} + +func (s *KwExecuteContext) GetParser() antlr.Parser { return s.parser } + +func (s *KwExecuteContext) K_EXECUTE() antlr.TerminalNode { + return s.GetToken(CqlParserK_EXECUTE, 0) +} + +func (s *KwExecuteContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *KwExecuteContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *KwExecuteContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterKwExecute(s) + } +} + +func (s *KwExecuteContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitKwExecute(s) + } +} + +func (s *KwExecuteContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitKwExecute(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) KwExecute() (localctx IKwExecuteContext) { + localctx = NewKwExecuteContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 396, CqlParserRULE_kwExecute) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2161) + p.Match(CqlParserK_EXECUTE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IKwExistsContext is an interface to support dynamic dispatch. +type IKwExistsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + K_EXISTS() antlr.TerminalNode + + // IsKwExistsContext differentiates from other interfaces. + IsKwExistsContext() +} + +type KwExistsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyKwExistsContext() *KwExistsContext { + var p = new(KwExistsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_kwExists + return p +} + +func InitEmptyKwExistsContext(p *KwExistsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_kwExists +} + +func (*KwExistsContext) IsKwExistsContext() {} + +func NewKwExistsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KwExistsContext { + var p = new(KwExistsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_kwExists + + return p +} + +func (s *KwExistsContext) GetParser() antlr.Parser { return s.parser } + +func (s *KwExistsContext) K_EXISTS() antlr.TerminalNode { + return s.GetToken(CqlParserK_EXISTS, 0) +} + +func (s *KwExistsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *KwExistsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *KwExistsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterKwExists(s) + } +} + +func (s *KwExistsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitKwExists(s) + } +} + +func (s *KwExistsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitKwExists(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) KwExists() (localctx IKwExistsContext) { + localctx = NewKwExistsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 398, CqlParserRULE_kwExists) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2163) + p.Match(CqlParserK_EXISTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IKwFilteringContext is an interface to support dynamic dispatch. +type IKwFilteringContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + K_FILTERING() antlr.TerminalNode + + // IsKwFilteringContext differentiates from other interfaces. + IsKwFilteringContext() +} + +type KwFilteringContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyKwFilteringContext() *KwFilteringContext { + var p = new(KwFilteringContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_kwFiltering + return p +} + +func InitEmptyKwFilteringContext(p *KwFilteringContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_kwFiltering +} + +func (*KwFilteringContext) IsKwFilteringContext() {} + +func NewKwFilteringContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KwFilteringContext { + var p = new(KwFilteringContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_kwFiltering + + return p +} + +func (s *KwFilteringContext) GetParser() antlr.Parser { return s.parser } + +func (s *KwFilteringContext) K_FILTERING() antlr.TerminalNode { + return s.GetToken(CqlParserK_FILTERING, 0) +} + +func (s *KwFilteringContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *KwFilteringContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *KwFilteringContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterKwFiltering(s) + } +} + +func (s *KwFilteringContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitKwFiltering(s) + } +} + +func (s *KwFilteringContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitKwFiltering(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) KwFiltering() (localctx IKwFilteringContext) { + localctx = NewKwFilteringContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 400, CqlParserRULE_kwFiltering) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2165) + p.Match(CqlParserK_FILTERING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IKwFinalfuncContext is an interface to support dynamic dispatch. +type IKwFinalfuncContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + K_FINALFUNC() antlr.TerminalNode + + // IsKwFinalfuncContext differentiates from other interfaces. + IsKwFinalfuncContext() +} + +type KwFinalfuncContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyKwFinalfuncContext() *KwFinalfuncContext { + var p = new(KwFinalfuncContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_kwFinalfunc + return p +} + +func InitEmptyKwFinalfuncContext(p *KwFinalfuncContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_kwFinalfunc +} + +func (*KwFinalfuncContext) IsKwFinalfuncContext() {} + +func NewKwFinalfuncContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KwFinalfuncContext { + var p = new(KwFinalfuncContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_kwFinalfunc + + return p +} + +func (s *KwFinalfuncContext) GetParser() antlr.Parser { return s.parser } + +func (s *KwFinalfuncContext) K_FINALFUNC() antlr.TerminalNode { + return s.GetToken(CqlParserK_FINALFUNC, 0) +} + +func (s *KwFinalfuncContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *KwFinalfuncContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *KwFinalfuncContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterKwFinalfunc(s) + } +} + +func (s *KwFinalfuncContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitKwFinalfunc(s) + } +} + +func (s *KwFinalfuncContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitKwFinalfunc(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) KwFinalfunc() (localctx IKwFinalfuncContext) { + localctx = NewKwFinalfuncContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 402, CqlParserRULE_kwFinalfunc) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2167) + p.Match(CqlParserK_FINALFUNC) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IKwFromContext is an interface to support dynamic dispatch. +type IKwFromContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + K_FROM() antlr.TerminalNode + + // IsKwFromContext differentiates from other interfaces. + IsKwFromContext() +} + +type KwFromContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyKwFromContext() *KwFromContext { + var p = new(KwFromContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_kwFrom + return p +} + +func InitEmptyKwFromContext(p *KwFromContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_kwFrom +} + +func (*KwFromContext) IsKwFromContext() {} + +func NewKwFromContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KwFromContext { + var p = new(KwFromContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_kwFrom + + return p +} + +func (s *KwFromContext) GetParser() antlr.Parser { return s.parser } + +func (s *KwFromContext) K_FROM() antlr.TerminalNode { + return s.GetToken(CqlParserK_FROM, 0) +} + +func (s *KwFromContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *KwFromContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *KwFromContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterKwFrom(s) + } +} + +func (s *KwFromContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitKwFrom(s) + } +} + +func (s *KwFromContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitKwFrom(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) KwFrom() (localctx IKwFromContext) { + localctx = NewKwFromContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 404, CqlParserRULE_kwFrom) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2169) + p.Match(CqlParserK_FROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IKwFullContext is an interface to support dynamic dispatch. +type IKwFullContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + K_FULL() antlr.TerminalNode + + // IsKwFullContext differentiates from other interfaces. + IsKwFullContext() +} + +type KwFullContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyKwFullContext() *KwFullContext { + var p = new(KwFullContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_kwFull + return p +} + +func InitEmptyKwFullContext(p *KwFullContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_kwFull +} + +func (*KwFullContext) IsKwFullContext() {} + +func NewKwFullContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KwFullContext { + var p = new(KwFullContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_kwFull + + return p +} + +func (s *KwFullContext) GetParser() antlr.Parser { return s.parser } + +func (s *KwFullContext) K_FULL() antlr.TerminalNode { + return s.GetToken(CqlParserK_FULL, 0) +} + +func (s *KwFullContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *KwFullContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *KwFullContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterKwFull(s) + } +} + +func (s *KwFullContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitKwFull(s) + } +} + +func (s *KwFullContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitKwFull(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) KwFull() (localctx IKwFullContext) { + localctx = NewKwFullContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 406, CqlParserRULE_kwFull) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2171) + p.Match(CqlParserK_FULL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IKwFunctionContext is an interface to support dynamic dispatch. +type IKwFunctionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + K_FUNCTION() antlr.TerminalNode + + // IsKwFunctionContext differentiates from other interfaces. + IsKwFunctionContext() +} + +type KwFunctionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyKwFunctionContext() *KwFunctionContext { + var p = new(KwFunctionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_kwFunction + return p +} + +func InitEmptyKwFunctionContext(p *KwFunctionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_kwFunction +} + +func (*KwFunctionContext) IsKwFunctionContext() {} + +func NewKwFunctionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KwFunctionContext { + var p = new(KwFunctionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_kwFunction + + return p +} + +func (s *KwFunctionContext) GetParser() antlr.Parser { return s.parser } + +func (s *KwFunctionContext) K_FUNCTION() antlr.TerminalNode { + return s.GetToken(CqlParserK_FUNCTION, 0) +} + +func (s *KwFunctionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *KwFunctionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *KwFunctionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterKwFunction(s) + } +} + +func (s *KwFunctionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitKwFunction(s) + } +} + +func (s *KwFunctionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitKwFunction(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) KwFunction() (localctx IKwFunctionContext) { + localctx = NewKwFunctionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 408, CqlParserRULE_kwFunction) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2173) + p.Match(CqlParserK_FUNCTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IKwFunctionsContext is an interface to support dynamic dispatch. +type IKwFunctionsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + K_FUNCTIONS() antlr.TerminalNode + + // IsKwFunctionsContext differentiates from other interfaces. + IsKwFunctionsContext() +} + +type KwFunctionsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyKwFunctionsContext() *KwFunctionsContext { + var p = new(KwFunctionsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_kwFunctions + return p +} + +func InitEmptyKwFunctionsContext(p *KwFunctionsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_kwFunctions +} + +func (*KwFunctionsContext) IsKwFunctionsContext() {} + +func NewKwFunctionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KwFunctionsContext { + var p = new(KwFunctionsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_kwFunctions + + return p +} + +func (s *KwFunctionsContext) GetParser() antlr.Parser { return s.parser } + +func (s *KwFunctionsContext) K_FUNCTIONS() antlr.TerminalNode { + return s.GetToken(CqlParserK_FUNCTIONS, 0) +} + +func (s *KwFunctionsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *KwFunctionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *KwFunctionsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterKwFunctions(s) + } +} + +func (s *KwFunctionsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitKwFunctions(s) + } +} + +func (s *KwFunctionsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitKwFunctions(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) KwFunctions() (localctx IKwFunctionsContext) { + localctx = NewKwFunctionsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 410, CqlParserRULE_kwFunctions) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2175) + p.Match(CqlParserK_FUNCTIONS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IKwGrantContext is an interface to support dynamic dispatch. +type IKwGrantContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + K_GRANT() antlr.TerminalNode + + // IsKwGrantContext differentiates from other interfaces. + IsKwGrantContext() +} + +type KwGrantContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyKwGrantContext() *KwGrantContext { + var p = new(KwGrantContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_kwGrant + return p +} + +func InitEmptyKwGrantContext(p *KwGrantContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_kwGrant +} + +func (*KwGrantContext) IsKwGrantContext() {} + +func NewKwGrantContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KwGrantContext { + var p = new(KwGrantContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_kwGrant + + return p +} + +func (s *KwGrantContext) GetParser() antlr.Parser { return s.parser } + +func (s *KwGrantContext) K_GRANT() antlr.TerminalNode { + return s.GetToken(CqlParserK_GRANT, 0) +} + +func (s *KwGrantContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *KwGrantContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *KwGrantContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterKwGrant(s) + } +} + +func (s *KwGrantContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitKwGrant(s) + } +} + +func (s *KwGrantContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitKwGrant(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) KwGrant() (localctx IKwGrantContext) { + localctx = NewKwGrantContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 412, CqlParserRULE_kwGrant) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2177) + p.Match(CqlParserK_GRANT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IKwIfContext is an interface to support dynamic dispatch. +type IKwIfContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + K_IF() antlr.TerminalNode + + // IsKwIfContext differentiates from other interfaces. + IsKwIfContext() +} + +type KwIfContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyKwIfContext() *KwIfContext { + var p = new(KwIfContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_kwIf + return p +} + +func InitEmptyKwIfContext(p *KwIfContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_kwIf +} + +func (*KwIfContext) IsKwIfContext() {} + +func NewKwIfContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KwIfContext { + var p = new(KwIfContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_kwIf + + return p +} + +func (s *KwIfContext) GetParser() antlr.Parser { return s.parser } + +func (s *KwIfContext) K_IF() antlr.TerminalNode { + return s.GetToken(CqlParserK_IF, 0) +} + +func (s *KwIfContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *KwIfContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *KwIfContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterKwIf(s) + } +} + +func (s *KwIfContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitKwIf(s) + } +} + +func (s *KwIfContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitKwIf(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) KwIf() (localctx IKwIfContext) { + localctx = NewKwIfContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 414, CqlParserRULE_kwIf) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2179) + p.Match(CqlParserK_IF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IKwInContext is an interface to support dynamic dispatch. +type IKwInContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + K_IN() antlr.TerminalNode + + // IsKwInContext differentiates from other interfaces. + IsKwInContext() +} + +type KwInContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyKwInContext() *KwInContext { + var p = new(KwInContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_kwIn + return p +} + +func InitEmptyKwInContext(p *KwInContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_kwIn +} + +func (*KwInContext) IsKwInContext() {} + +func NewKwInContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KwInContext { + var p = new(KwInContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_kwIn + + return p +} + +func (s *KwInContext) GetParser() antlr.Parser { return s.parser } + +func (s *KwInContext) K_IN() antlr.TerminalNode { + return s.GetToken(CqlParserK_IN, 0) +} + +func (s *KwInContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *KwInContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *KwInContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterKwIn(s) + } +} + +func (s *KwInContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitKwIn(s) + } +} + +func (s *KwInContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitKwIn(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) KwIn() (localctx IKwInContext) { + localctx = NewKwInContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 416, CqlParserRULE_kwIn) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2181) + p.Match(CqlParserK_IN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IKwIndexContext is an interface to support dynamic dispatch. +type IKwIndexContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + K_INDEX() antlr.TerminalNode + + // IsKwIndexContext differentiates from other interfaces. + IsKwIndexContext() +} + +type KwIndexContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyKwIndexContext() *KwIndexContext { + var p = new(KwIndexContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_kwIndex + return p +} + +func InitEmptyKwIndexContext(p *KwIndexContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_kwIndex +} + +func (*KwIndexContext) IsKwIndexContext() {} + +func NewKwIndexContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KwIndexContext { + var p = new(KwIndexContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_kwIndex + + return p +} + +func (s *KwIndexContext) GetParser() antlr.Parser { return s.parser } + +func (s *KwIndexContext) K_INDEX() antlr.TerminalNode { + return s.GetToken(CqlParserK_INDEX, 0) +} + +func (s *KwIndexContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *KwIndexContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *KwIndexContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterKwIndex(s) + } +} + +func (s *KwIndexContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitKwIndex(s) + } +} + +func (s *KwIndexContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitKwIndex(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) KwIndex() (localctx IKwIndexContext) { + localctx = NewKwIndexContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 418, CqlParserRULE_kwIndex) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2183) + p.Match(CqlParserK_INDEX) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IKwInitcondContext is an interface to support dynamic dispatch. +type IKwInitcondContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + K_INITCOND() antlr.TerminalNode + + // IsKwInitcondContext differentiates from other interfaces. + IsKwInitcondContext() +} + +type KwInitcondContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyKwInitcondContext() *KwInitcondContext { + var p = new(KwInitcondContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_kwInitcond + return p +} + +func InitEmptyKwInitcondContext(p *KwInitcondContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_kwInitcond +} + +func (*KwInitcondContext) IsKwInitcondContext() {} + +func NewKwInitcondContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KwInitcondContext { + var p = new(KwInitcondContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_kwInitcond + + return p +} + +func (s *KwInitcondContext) GetParser() antlr.Parser { return s.parser } + +func (s *KwInitcondContext) K_INITCOND() antlr.TerminalNode { + return s.GetToken(CqlParserK_INITCOND, 0) +} + +func (s *KwInitcondContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *KwInitcondContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *KwInitcondContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterKwInitcond(s) + } +} + +func (s *KwInitcondContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitKwInitcond(s) + } +} + +func (s *KwInitcondContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitKwInitcond(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) KwInitcond() (localctx IKwInitcondContext) { + localctx = NewKwInitcondContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 420, CqlParserRULE_kwInitcond) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2185) + p.Match(CqlParserK_INITCOND) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IKwInputContext is an interface to support dynamic dispatch. +type IKwInputContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + K_INPUT() antlr.TerminalNode + + // IsKwInputContext differentiates from other interfaces. + IsKwInputContext() +} + +type KwInputContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyKwInputContext() *KwInputContext { + var p = new(KwInputContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_kwInput + return p +} + +func InitEmptyKwInputContext(p *KwInputContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_kwInput +} + +func (*KwInputContext) IsKwInputContext() {} + +func NewKwInputContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KwInputContext { + var p = new(KwInputContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_kwInput + + return p +} + +func (s *KwInputContext) GetParser() antlr.Parser { return s.parser } + +func (s *KwInputContext) K_INPUT() antlr.TerminalNode { + return s.GetToken(CqlParserK_INPUT, 0) +} + +func (s *KwInputContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *KwInputContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *KwInputContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterKwInput(s) + } +} + +func (s *KwInputContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitKwInput(s) + } +} + +func (s *KwInputContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitKwInput(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) KwInput() (localctx IKwInputContext) { + localctx = NewKwInputContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 422, CqlParserRULE_kwInput) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2187) + p.Match(CqlParserK_INPUT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IKwInsertContext is an interface to support dynamic dispatch. +type IKwInsertContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + K_INSERT() antlr.TerminalNode + + // IsKwInsertContext differentiates from other interfaces. + IsKwInsertContext() +} + +type KwInsertContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyKwInsertContext() *KwInsertContext { + var p = new(KwInsertContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_kwInsert + return p +} + +func InitEmptyKwInsertContext(p *KwInsertContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_kwInsert +} + +func (*KwInsertContext) IsKwInsertContext() {} + +func NewKwInsertContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KwInsertContext { + var p = new(KwInsertContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_kwInsert + + return p +} + +func (s *KwInsertContext) GetParser() antlr.Parser { return s.parser } + +func (s *KwInsertContext) K_INSERT() antlr.TerminalNode { + return s.GetToken(CqlParserK_INSERT, 0) +} + +func (s *KwInsertContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *KwInsertContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *KwInsertContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterKwInsert(s) + } +} + +func (s *KwInsertContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitKwInsert(s) + } +} + +func (s *KwInsertContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitKwInsert(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) KwInsert() (localctx IKwInsertContext) { + localctx = NewKwInsertContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 424, CqlParserRULE_kwInsert) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2189) + p.Match(CqlParserK_INSERT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IKwIntoContext is an interface to support dynamic dispatch. +type IKwIntoContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + K_INTO() antlr.TerminalNode + + // IsKwIntoContext differentiates from other interfaces. + IsKwIntoContext() +} + +type KwIntoContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyKwIntoContext() *KwIntoContext { + var p = new(KwIntoContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_kwInto + return p +} + +func InitEmptyKwIntoContext(p *KwIntoContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_kwInto +} + +func (*KwIntoContext) IsKwIntoContext() {} + +func NewKwIntoContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KwIntoContext { + var p = new(KwIntoContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_kwInto + + return p +} + +func (s *KwIntoContext) GetParser() antlr.Parser { return s.parser } + +func (s *KwIntoContext) K_INTO() antlr.TerminalNode { + return s.GetToken(CqlParserK_INTO, 0) +} + +func (s *KwIntoContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *KwIntoContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *KwIntoContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterKwInto(s) + } +} + +func (s *KwIntoContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitKwInto(s) + } +} + +func (s *KwIntoContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitKwInto(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) KwInto() (localctx IKwIntoContext) { + localctx = NewKwIntoContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 426, CqlParserRULE_kwInto) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2191) + p.Match(CqlParserK_INTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IKwIsContext is an interface to support dynamic dispatch. +type IKwIsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + K_IS() antlr.TerminalNode + + // IsKwIsContext differentiates from other interfaces. + IsKwIsContext() +} + +type KwIsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyKwIsContext() *KwIsContext { + var p = new(KwIsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_kwIs + return p +} + +func InitEmptyKwIsContext(p *KwIsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_kwIs +} + +func (*KwIsContext) IsKwIsContext() {} + +func NewKwIsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KwIsContext { + var p = new(KwIsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_kwIs + + return p +} + +func (s *KwIsContext) GetParser() antlr.Parser { return s.parser } + +func (s *KwIsContext) K_IS() antlr.TerminalNode { + return s.GetToken(CqlParserK_IS, 0) +} + +func (s *KwIsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *KwIsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *KwIsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterKwIs(s) + } +} + +func (s *KwIsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitKwIs(s) + } +} + +func (s *KwIsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitKwIs(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) KwIs() (localctx IKwIsContext) { + localctx = NewKwIsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 428, CqlParserRULE_kwIs) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2193) + p.Match(CqlParserK_IS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IKwJsonContext is an interface to support dynamic dispatch. +type IKwJsonContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + K_JSON() antlr.TerminalNode + + // IsKwJsonContext differentiates from other interfaces. + IsKwJsonContext() +} + +type KwJsonContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyKwJsonContext() *KwJsonContext { + var p = new(KwJsonContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_kwJson + return p +} + +func InitEmptyKwJsonContext(p *KwJsonContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_kwJson +} + +func (*KwJsonContext) IsKwJsonContext() {} + +func NewKwJsonContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KwJsonContext { + var p = new(KwJsonContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_kwJson + + return p +} + +func (s *KwJsonContext) GetParser() antlr.Parser { return s.parser } + +func (s *KwJsonContext) K_JSON() antlr.TerminalNode { + return s.GetToken(CqlParserK_JSON, 0) +} + +func (s *KwJsonContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *KwJsonContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *KwJsonContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterKwJson(s) + } +} + +func (s *KwJsonContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitKwJson(s) + } +} + +func (s *KwJsonContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitKwJson(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) KwJson() (localctx IKwJsonContext) { + localctx = NewKwJsonContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 430, CqlParserRULE_kwJson) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2195) + p.Match(CqlParserK_JSON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IKwKeyContext is an interface to support dynamic dispatch. +type IKwKeyContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + K_KEY() antlr.TerminalNode + + // IsKwKeyContext differentiates from other interfaces. + IsKwKeyContext() +} + +type KwKeyContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyKwKeyContext() *KwKeyContext { + var p = new(KwKeyContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_kwKey + return p +} + +func InitEmptyKwKeyContext(p *KwKeyContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_kwKey +} + +func (*KwKeyContext) IsKwKeyContext() {} + +func NewKwKeyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KwKeyContext { + var p = new(KwKeyContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_kwKey + + return p +} + +func (s *KwKeyContext) GetParser() antlr.Parser { return s.parser } + +func (s *KwKeyContext) K_KEY() antlr.TerminalNode { + return s.GetToken(CqlParserK_KEY, 0) +} + +func (s *KwKeyContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *KwKeyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *KwKeyContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterKwKey(s) + } +} + +func (s *KwKeyContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitKwKey(s) + } +} + +func (s *KwKeyContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitKwKey(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) KwKey() (localctx IKwKeyContext) { + localctx = NewKwKeyContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 432, CqlParserRULE_kwKey) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2197) + p.Match(CqlParserK_KEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IKwKeysContext is an interface to support dynamic dispatch. +type IKwKeysContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + K_KEYS() antlr.TerminalNode + + // IsKwKeysContext differentiates from other interfaces. + IsKwKeysContext() +} + +type KwKeysContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyKwKeysContext() *KwKeysContext { + var p = new(KwKeysContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_kwKeys + return p +} + +func InitEmptyKwKeysContext(p *KwKeysContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_kwKeys +} + +func (*KwKeysContext) IsKwKeysContext() {} + +func NewKwKeysContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KwKeysContext { + var p = new(KwKeysContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_kwKeys + + return p +} + +func (s *KwKeysContext) GetParser() antlr.Parser { return s.parser } + +func (s *KwKeysContext) K_KEYS() antlr.TerminalNode { + return s.GetToken(CqlParserK_KEYS, 0) +} + +func (s *KwKeysContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *KwKeysContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *KwKeysContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterKwKeys(s) + } +} + +func (s *KwKeysContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitKwKeys(s) + } +} + +func (s *KwKeysContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitKwKeys(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) KwKeys() (localctx IKwKeysContext) { + localctx = NewKwKeysContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 434, CqlParserRULE_kwKeys) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2199) + p.Match(CqlParserK_KEYS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IKwKeyspaceContext is an interface to support dynamic dispatch. +type IKwKeyspaceContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + K_KEYSPACE() antlr.TerminalNode + + // IsKwKeyspaceContext differentiates from other interfaces. + IsKwKeyspaceContext() +} + +type KwKeyspaceContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyKwKeyspaceContext() *KwKeyspaceContext { + var p = new(KwKeyspaceContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_kwKeyspace + return p +} + +func InitEmptyKwKeyspaceContext(p *KwKeyspaceContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_kwKeyspace +} + +func (*KwKeyspaceContext) IsKwKeyspaceContext() {} + +func NewKwKeyspaceContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KwKeyspaceContext { + var p = new(KwKeyspaceContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_kwKeyspace + + return p +} + +func (s *KwKeyspaceContext) GetParser() antlr.Parser { return s.parser } + +func (s *KwKeyspaceContext) K_KEYSPACE() antlr.TerminalNode { + return s.GetToken(CqlParserK_KEYSPACE, 0) +} + +func (s *KwKeyspaceContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *KwKeyspaceContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *KwKeyspaceContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterKwKeyspace(s) + } +} + +func (s *KwKeyspaceContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitKwKeyspace(s) + } +} + +func (s *KwKeyspaceContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitKwKeyspace(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) KwKeyspace() (localctx IKwKeyspaceContext) { + localctx = NewKwKeyspaceContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 436, CqlParserRULE_kwKeyspace) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2201) + p.Match(CqlParserK_KEYSPACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IKwKeyspacesContext is an interface to support dynamic dispatch. +type IKwKeyspacesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + K_KEYSPACES() antlr.TerminalNode + + // IsKwKeyspacesContext differentiates from other interfaces. + IsKwKeyspacesContext() +} + +type KwKeyspacesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyKwKeyspacesContext() *KwKeyspacesContext { + var p = new(KwKeyspacesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_kwKeyspaces + return p +} + +func InitEmptyKwKeyspacesContext(p *KwKeyspacesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_kwKeyspaces +} + +func (*KwKeyspacesContext) IsKwKeyspacesContext() {} + +func NewKwKeyspacesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KwKeyspacesContext { + var p = new(KwKeyspacesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_kwKeyspaces + + return p +} + +func (s *KwKeyspacesContext) GetParser() antlr.Parser { return s.parser } + +func (s *KwKeyspacesContext) K_KEYSPACES() antlr.TerminalNode { + return s.GetToken(CqlParserK_KEYSPACES, 0) +} + +func (s *KwKeyspacesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *KwKeyspacesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *KwKeyspacesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterKwKeyspaces(s) + } +} + +func (s *KwKeyspacesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitKwKeyspaces(s) + } +} + +func (s *KwKeyspacesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitKwKeyspaces(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) KwKeyspaces() (localctx IKwKeyspacesContext) { + localctx = NewKwKeyspacesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 438, CqlParserRULE_kwKeyspaces) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2203) + p.Match(CqlParserK_KEYSPACES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IKwLanguageContext is an interface to support dynamic dispatch. +type IKwLanguageContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + K_LANGUAGE() antlr.TerminalNode + + // IsKwLanguageContext differentiates from other interfaces. + IsKwLanguageContext() +} + +type KwLanguageContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyKwLanguageContext() *KwLanguageContext { + var p = new(KwLanguageContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_kwLanguage + return p +} + +func InitEmptyKwLanguageContext(p *KwLanguageContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_kwLanguage +} + +func (*KwLanguageContext) IsKwLanguageContext() {} + +func NewKwLanguageContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KwLanguageContext { + var p = new(KwLanguageContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_kwLanguage + + return p +} + +func (s *KwLanguageContext) GetParser() antlr.Parser { return s.parser } + +func (s *KwLanguageContext) K_LANGUAGE() antlr.TerminalNode { + return s.GetToken(CqlParserK_LANGUAGE, 0) +} + +func (s *KwLanguageContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *KwLanguageContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *KwLanguageContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterKwLanguage(s) + } +} + +func (s *KwLanguageContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitKwLanguage(s) + } +} + +func (s *KwLanguageContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitKwLanguage(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) KwLanguage() (localctx IKwLanguageContext) { + localctx = NewKwLanguageContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 440, CqlParserRULE_kwLanguage) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2205) + p.Match(CqlParserK_LANGUAGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IKwLimitContext is an interface to support dynamic dispatch. +type IKwLimitContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + K_LIMIT() antlr.TerminalNode + + // IsKwLimitContext differentiates from other interfaces. + IsKwLimitContext() +} + +type KwLimitContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyKwLimitContext() *KwLimitContext { + var p = new(KwLimitContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_kwLimit + return p +} + +func InitEmptyKwLimitContext(p *KwLimitContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_kwLimit +} + +func (*KwLimitContext) IsKwLimitContext() {} + +func NewKwLimitContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KwLimitContext { + var p = new(KwLimitContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_kwLimit + + return p +} + +func (s *KwLimitContext) GetParser() antlr.Parser { return s.parser } + +func (s *KwLimitContext) K_LIMIT() antlr.TerminalNode { + return s.GetToken(CqlParserK_LIMIT, 0) +} + +func (s *KwLimitContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *KwLimitContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *KwLimitContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterKwLimit(s) + } +} + +func (s *KwLimitContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitKwLimit(s) + } +} + +func (s *KwLimitContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitKwLimit(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) KwLimit() (localctx IKwLimitContext) { + localctx = NewKwLimitContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 442, CqlParserRULE_kwLimit) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2207) + p.Match(CqlParserK_LIMIT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IKwListContext is an interface to support dynamic dispatch. +type IKwListContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + K_LIST() antlr.TerminalNode + + // IsKwListContext differentiates from other interfaces. + IsKwListContext() +} + +type KwListContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyKwListContext() *KwListContext { + var p = new(KwListContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_kwList + return p +} + +func InitEmptyKwListContext(p *KwListContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_kwList +} + +func (*KwListContext) IsKwListContext() {} + +func NewKwListContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KwListContext { + var p = new(KwListContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_kwList + + return p +} + +func (s *KwListContext) GetParser() antlr.Parser { return s.parser } + +func (s *KwListContext) K_LIST() antlr.TerminalNode { + return s.GetToken(CqlParserK_LIST, 0) +} + +func (s *KwListContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *KwListContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *KwListContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterKwList(s) + } +} + +func (s *KwListContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitKwList(s) + } +} + +func (s *KwListContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitKwList(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) KwList() (localctx IKwListContext) { + localctx = NewKwListContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 444, CqlParserRULE_kwList) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2209) + p.Match(CqlParserK_LIST) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IKwLoggedContext is an interface to support dynamic dispatch. +type IKwLoggedContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + K_LOGGED() antlr.TerminalNode + + // IsKwLoggedContext differentiates from other interfaces. + IsKwLoggedContext() +} + +type KwLoggedContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyKwLoggedContext() *KwLoggedContext { + var p = new(KwLoggedContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_kwLogged + return p +} + +func InitEmptyKwLoggedContext(p *KwLoggedContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_kwLogged +} + +func (*KwLoggedContext) IsKwLoggedContext() {} + +func NewKwLoggedContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KwLoggedContext { + var p = new(KwLoggedContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_kwLogged + + return p +} + +func (s *KwLoggedContext) GetParser() antlr.Parser { return s.parser } + +func (s *KwLoggedContext) K_LOGGED() antlr.TerminalNode { + return s.GetToken(CqlParserK_LOGGED, 0) +} + +func (s *KwLoggedContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *KwLoggedContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *KwLoggedContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterKwLogged(s) + } +} + +func (s *KwLoggedContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitKwLogged(s) + } +} + +func (s *KwLoggedContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitKwLogged(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) KwLogged() (localctx IKwLoggedContext) { + localctx = NewKwLoggedContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 446, CqlParserRULE_kwLogged) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2211) + p.Match(CqlParserK_LOGGED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IKwLoginContext is an interface to support dynamic dispatch. +type IKwLoginContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + K_LOGIN() antlr.TerminalNode + + // IsKwLoginContext differentiates from other interfaces. + IsKwLoginContext() +} + +type KwLoginContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyKwLoginContext() *KwLoginContext { + var p = new(KwLoginContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_kwLogin + return p +} + +func InitEmptyKwLoginContext(p *KwLoginContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_kwLogin +} + +func (*KwLoginContext) IsKwLoginContext() {} + +func NewKwLoginContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KwLoginContext { + var p = new(KwLoginContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_kwLogin + + return p +} + +func (s *KwLoginContext) GetParser() antlr.Parser { return s.parser } + +func (s *KwLoginContext) K_LOGIN() antlr.TerminalNode { + return s.GetToken(CqlParserK_LOGIN, 0) +} + +func (s *KwLoginContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *KwLoginContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *KwLoginContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterKwLogin(s) + } +} + +func (s *KwLoginContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitKwLogin(s) + } +} + +func (s *KwLoginContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitKwLogin(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) KwLogin() (localctx IKwLoginContext) { + localctx = NewKwLoginContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 448, CqlParserRULE_kwLogin) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2213) + p.Match(CqlParserK_LOGIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IKwMaterializedContext is an interface to support dynamic dispatch. +type IKwMaterializedContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + K_MATERIALIZED() antlr.TerminalNode + + // IsKwMaterializedContext differentiates from other interfaces. + IsKwMaterializedContext() +} + +type KwMaterializedContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyKwMaterializedContext() *KwMaterializedContext { + var p = new(KwMaterializedContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_kwMaterialized + return p +} + +func InitEmptyKwMaterializedContext(p *KwMaterializedContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_kwMaterialized +} + +func (*KwMaterializedContext) IsKwMaterializedContext() {} + +func NewKwMaterializedContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KwMaterializedContext { + var p = new(KwMaterializedContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_kwMaterialized + + return p +} + +func (s *KwMaterializedContext) GetParser() antlr.Parser { return s.parser } + +func (s *KwMaterializedContext) K_MATERIALIZED() antlr.TerminalNode { + return s.GetToken(CqlParserK_MATERIALIZED, 0) +} + +func (s *KwMaterializedContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *KwMaterializedContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *KwMaterializedContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterKwMaterialized(s) + } +} + +func (s *KwMaterializedContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitKwMaterialized(s) + } +} + +func (s *KwMaterializedContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitKwMaterialized(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) KwMaterialized() (localctx IKwMaterializedContext) { + localctx = NewKwMaterializedContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 450, CqlParserRULE_kwMaterialized) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2215) + p.Match(CqlParserK_MATERIALIZED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IKwModifyContext is an interface to support dynamic dispatch. +type IKwModifyContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + K_MODIFY() antlr.TerminalNode + + // IsKwModifyContext differentiates from other interfaces. + IsKwModifyContext() +} + +type KwModifyContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyKwModifyContext() *KwModifyContext { + var p = new(KwModifyContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_kwModify + return p +} + +func InitEmptyKwModifyContext(p *KwModifyContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_kwModify +} + +func (*KwModifyContext) IsKwModifyContext() {} + +func NewKwModifyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KwModifyContext { + var p = new(KwModifyContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_kwModify + + return p +} + +func (s *KwModifyContext) GetParser() antlr.Parser { return s.parser } + +func (s *KwModifyContext) K_MODIFY() antlr.TerminalNode { + return s.GetToken(CqlParserK_MODIFY, 0) +} + +func (s *KwModifyContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *KwModifyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *KwModifyContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterKwModify(s) + } +} + +func (s *KwModifyContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitKwModify(s) + } +} + +func (s *KwModifyContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitKwModify(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) KwModify() (localctx IKwModifyContext) { + localctx = NewKwModifyContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 452, CqlParserRULE_kwModify) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2217) + p.Match(CqlParserK_MODIFY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IKwNosuperuserContext is an interface to support dynamic dispatch. +type IKwNosuperuserContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + K_NOSUPERUSER() antlr.TerminalNode + + // IsKwNosuperuserContext differentiates from other interfaces. + IsKwNosuperuserContext() +} + +type KwNosuperuserContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyKwNosuperuserContext() *KwNosuperuserContext { + var p = new(KwNosuperuserContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_kwNosuperuser + return p +} + +func InitEmptyKwNosuperuserContext(p *KwNosuperuserContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_kwNosuperuser +} + +func (*KwNosuperuserContext) IsKwNosuperuserContext() {} + +func NewKwNosuperuserContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KwNosuperuserContext { + var p = new(KwNosuperuserContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_kwNosuperuser + + return p +} + +func (s *KwNosuperuserContext) GetParser() antlr.Parser { return s.parser } + +func (s *KwNosuperuserContext) K_NOSUPERUSER() antlr.TerminalNode { + return s.GetToken(CqlParserK_NOSUPERUSER, 0) +} + +func (s *KwNosuperuserContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *KwNosuperuserContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *KwNosuperuserContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterKwNosuperuser(s) + } +} + +func (s *KwNosuperuserContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitKwNosuperuser(s) + } +} + +func (s *KwNosuperuserContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitKwNosuperuser(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) KwNosuperuser() (localctx IKwNosuperuserContext) { + localctx = NewKwNosuperuserContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 454, CqlParserRULE_kwNosuperuser) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2219) + p.Match(CqlParserK_NOSUPERUSER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IKwNorecursiveContext is an interface to support dynamic dispatch. +type IKwNorecursiveContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + K_NORECURSIVE() antlr.TerminalNode + + // IsKwNorecursiveContext differentiates from other interfaces. + IsKwNorecursiveContext() +} + +type KwNorecursiveContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyKwNorecursiveContext() *KwNorecursiveContext { + var p = new(KwNorecursiveContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_kwNorecursive + return p +} + +func InitEmptyKwNorecursiveContext(p *KwNorecursiveContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_kwNorecursive +} + +func (*KwNorecursiveContext) IsKwNorecursiveContext() {} + +func NewKwNorecursiveContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KwNorecursiveContext { + var p = new(KwNorecursiveContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_kwNorecursive + + return p +} + +func (s *KwNorecursiveContext) GetParser() antlr.Parser { return s.parser } + +func (s *KwNorecursiveContext) K_NORECURSIVE() antlr.TerminalNode { + return s.GetToken(CqlParserK_NORECURSIVE, 0) +} + +func (s *KwNorecursiveContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *KwNorecursiveContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *KwNorecursiveContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterKwNorecursive(s) + } +} + +func (s *KwNorecursiveContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitKwNorecursive(s) + } +} + +func (s *KwNorecursiveContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitKwNorecursive(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) KwNorecursive() (localctx IKwNorecursiveContext) { + localctx = NewKwNorecursiveContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 456, CqlParserRULE_kwNorecursive) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2221) + p.Match(CqlParserK_NORECURSIVE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IKwNotContext is an interface to support dynamic dispatch. +type IKwNotContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + K_NOT() antlr.TerminalNode + + // IsKwNotContext differentiates from other interfaces. + IsKwNotContext() +} + +type KwNotContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyKwNotContext() *KwNotContext { + var p = new(KwNotContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_kwNot + return p +} + +func InitEmptyKwNotContext(p *KwNotContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_kwNot +} + +func (*KwNotContext) IsKwNotContext() {} + +func NewKwNotContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KwNotContext { + var p = new(KwNotContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_kwNot + + return p +} + +func (s *KwNotContext) GetParser() antlr.Parser { return s.parser } + +func (s *KwNotContext) K_NOT() antlr.TerminalNode { + return s.GetToken(CqlParserK_NOT, 0) +} + +func (s *KwNotContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *KwNotContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *KwNotContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterKwNot(s) + } +} + +func (s *KwNotContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitKwNot(s) + } +} + +func (s *KwNotContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitKwNot(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) KwNot() (localctx IKwNotContext) { + localctx = NewKwNotContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 458, CqlParserRULE_kwNot) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2223) + p.Match(CqlParserK_NOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IKwNullContext is an interface to support dynamic dispatch. +type IKwNullContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + K_NULL() antlr.TerminalNode + + // IsKwNullContext differentiates from other interfaces. + IsKwNullContext() +} + +type KwNullContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyKwNullContext() *KwNullContext { + var p = new(KwNullContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_kwNull + return p +} + +func InitEmptyKwNullContext(p *KwNullContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_kwNull +} + +func (*KwNullContext) IsKwNullContext() {} + +func NewKwNullContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KwNullContext { + var p = new(KwNullContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_kwNull + + return p +} + +func (s *KwNullContext) GetParser() antlr.Parser { return s.parser } + +func (s *KwNullContext) K_NULL() antlr.TerminalNode { + return s.GetToken(CqlParserK_NULL, 0) +} + +func (s *KwNullContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *KwNullContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *KwNullContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterKwNull(s) + } +} + +func (s *KwNullContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitKwNull(s) + } +} + +func (s *KwNullContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitKwNull(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) KwNull() (localctx IKwNullContext) { + localctx = NewKwNullContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 460, CqlParserRULE_kwNull) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2225) + p.Match(CqlParserK_NULL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IKwOfContext is an interface to support dynamic dispatch. +type IKwOfContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + K_OF() antlr.TerminalNode + + // IsKwOfContext differentiates from other interfaces. + IsKwOfContext() +} + +type KwOfContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyKwOfContext() *KwOfContext { + var p = new(KwOfContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_kwOf + return p +} + +func InitEmptyKwOfContext(p *KwOfContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_kwOf +} + +func (*KwOfContext) IsKwOfContext() {} + +func NewKwOfContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KwOfContext { + var p = new(KwOfContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_kwOf + + return p +} + +func (s *KwOfContext) GetParser() antlr.Parser { return s.parser } + +func (s *KwOfContext) K_OF() antlr.TerminalNode { + return s.GetToken(CqlParserK_OF, 0) +} + +func (s *KwOfContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *KwOfContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *KwOfContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterKwOf(s) + } +} + +func (s *KwOfContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitKwOf(s) + } +} + +func (s *KwOfContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitKwOf(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) KwOf() (localctx IKwOfContext) { + localctx = NewKwOfContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 462, CqlParserRULE_kwOf) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2227) + p.Match(CqlParserK_OF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IKwOnContext is an interface to support dynamic dispatch. +type IKwOnContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + K_ON() antlr.TerminalNode + + // IsKwOnContext differentiates from other interfaces. + IsKwOnContext() +} + +type KwOnContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyKwOnContext() *KwOnContext { + var p = new(KwOnContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_kwOn + return p +} + +func InitEmptyKwOnContext(p *KwOnContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_kwOn +} + +func (*KwOnContext) IsKwOnContext() {} + +func NewKwOnContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KwOnContext { + var p = new(KwOnContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_kwOn + + return p +} + +func (s *KwOnContext) GetParser() antlr.Parser { return s.parser } + +func (s *KwOnContext) K_ON() antlr.TerminalNode { + return s.GetToken(CqlParserK_ON, 0) +} + +func (s *KwOnContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *KwOnContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *KwOnContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterKwOn(s) + } +} + +func (s *KwOnContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitKwOn(s) + } +} + +func (s *KwOnContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitKwOn(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) KwOn() (localctx IKwOnContext) { + localctx = NewKwOnContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 464, CqlParserRULE_kwOn) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2229) + p.Match(CqlParserK_ON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IKwOptionsContext is an interface to support dynamic dispatch. +type IKwOptionsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + K_OPTIONS() antlr.TerminalNode + + // IsKwOptionsContext differentiates from other interfaces. + IsKwOptionsContext() +} + +type KwOptionsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyKwOptionsContext() *KwOptionsContext { + var p = new(KwOptionsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_kwOptions + return p +} + +func InitEmptyKwOptionsContext(p *KwOptionsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_kwOptions +} + +func (*KwOptionsContext) IsKwOptionsContext() {} + +func NewKwOptionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KwOptionsContext { + var p = new(KwOptionsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_kwOptions + + return p +} + +func (s *KwOptionsContext) GetParser() antlr.Parser { return s.parser } + +func (s *KwOptionsContext) K_OPTIONS() antlr.TerminalNode { + return s.GetToken(CqlParserK_OPTIONS, 0) +} + +func (s *KwOptionsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *KwOptionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *KwOptionsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterKwOptions(s) + } +} + +func (s *KwOptionsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitKwOptions(s) + } +} + +func (s *KwOptionsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitKwOptions(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) KwOptions() (localctx IKwOptionsContext) { + localctx = NewKwOptionsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 466, CqlParserRULE_kwOptions) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2231) + p.Match(CqlParserK_OPTIONS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IKwOrContext is an interface to support dynamic dispatch. +type IKwOrContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + K_OR() antlr.TerminalNode + + // IsKwOrContext differentiates from other interfaces. + IsKwOrContext() +} + +type KwOrContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyKwOrContext() *KwOrContext { + var p = new(KwOrContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_kwOr + return p +} + +func InitEmptyKwOrContext(p *KwOrContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_kwOr +} + +func (*KwOrContext) IsKwOrContext() {} + +func NewKwOrContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KwOrContext { + var p = new(KwOrContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_kwOr + + return p +} + +func (s *KwOrContext) GetParser() antlr.Parser { return s.parser } + +func (s *KwOrContext) K_OR() antlr.TerminalNode { + return s.GetToken(CqlParserK_OR, 0) +} + +func (s *KwOrContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *KwOrContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *KwOrContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterKwOr(s) + } +} + +func (s *KwOrContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitKwOr(s) + } +} + +func (s *KwOrContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitKwOr(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) KwOr() (localctx IKwOrContext) { + localctx = NewKwOrContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 468, CqlParserRULE_kwOr) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2233) + p.Match(CqlParserK_OR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IKwOrderContext is an interface to support dynamic dispatch. +type IKwOrderContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + K_ORDER() antlr.TerminalNode + + // IsKwOrderContext differentiates from other interfaces. + IsKwOrderContext() +} + +type KwOrderContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyKwOrderContext() *KwOrderContext { + var p = new(KwOrderContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_kwOrder + return p +} + +func InitEmptyKwOrderContext(p *KwOrderContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_kwOrder +} + +func (*KwOrderContext) IsKwOrderContext() {} + +func NewKwOrderContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KwOrderContext { + var p = new(KwOrderContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_kwOrder + + return p +} + +func (s *KwOrderContext) GetParser() antlr.Parser { return s.parser } + +func (s *KwOrderContext) K_ORDER() antlr.TerminalNode { + return s.GetToken(CqlParserK_ORDER, 0) +} + +func (s *KwOrderContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *KwOrderContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *KwOrderContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterKwOrder(s) + } +} + +func (s *KwOrderContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitKwOrder(s) + } +} + +func (s *KwOrderContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitKwOrder(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) KwOrder() (localctx IKwOrderContext) { + localctx = NewKwOrderContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 470, CqlParserRULE_kwOrder) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2235) + p.Match(CqlParserK_ORDER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IKwPasswordContext is an interface to support dynamic dispatch. +type IKwPasswordContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + K_PASSWORD() antlr.TerminalNode + + // IsKwPasswordContext differentiates from other interfaces. + IsKwPasswordContext() +} + +type KwPasswordContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyKwPasswordContext() *KwPasswordContext { + var p = new(KwPasswordContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_kwPassword + return p +} + +func InitEmptyKwPasswordContext(p *KwPasswordContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_kwPassword +} + +func (*KwPasswordContext) IsKwPasswordContext() {} + +func NewKwPasswordContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KwPasswordContext { + var p = new(KwPasswordContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_kwPassword + + return p +} + +func (s *KwPasswordContext) GetParser() antlr.Parser { return s.parser } + +func (s *KwPasswordContext) K_PASSWORD() antlr.TerminalNode { + return s.GetToken(CqlParserK_PASSWORD, 0) +} + +func (s *KwPasswordContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *KwPasswordContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *KwPasswordContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterKwPassword(s) + } +} + +func (s *KwPasswordContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitKwPassword(s) + } +} + +func (s *KwPasswordContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitKwPassword(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) KwPassword() (localctx IKwPasswordContext) { + localctx = NewKwPasswordContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 472, CqlParserRULE_kwPassword) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2237) + p.Match(CqlParserK_PASSWORD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IKwPrimaryContext is an interface to support dynamic dispatch. +type IKwPrimaryContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + K_PRIMARY() antlr.TerminalNode + + // IsKwPrimaryContext differentiates from other interfaces. + IsKwPrimaryContext() +} + +type KwPrimaryContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyKwPrimaryContext() *KwPrimaryContext { + var p = new(KwPrimaryContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_kwPrimary + return p +} + +func InitEmptyKwPrimaryContext(p *KwPrimaryContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_kwPrimary +} + +func (*KwPrimaryContext) IsKwPrimaryContext() {} + +func NewKwPrimaryContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KwPrimaryContext { + var p = new(KwPrimaryContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_kwPrimary + + return p +} + +func (s *KwPrimaryContext) GetParser() antlr.Parser { return s.parser } + +func (s *KwPrimaryContext) K_PRIMARY() antlr.TerminalNode { + return s.GetToken(CqlParserK_PRIMARY, 0) +} + +func (s *KwPrimaryContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *KwPrimaryContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *KwPrimaryContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterKwPrimary(s) + } +} + +func (s *KwPrimaryContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitKwPrimary(s) + } +} + +func (s *KwPrimaryContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitKwPrimary(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) KwPrimary() (localctx IKwPrimaryContext) { + localctx = NewKwPrimaryContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 474, CqlParserRULE_kwPrimary) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2239) + p.Match(CqlParserK_PRIMARY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IKwRenameContext is an interface to support dynamic dispatch. +type IKwRenameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + K_RENAME() antlr.TerminalNode + + // IsKwRenameContext differentiates from other interfaces. + IsKwRenameContext() +} + +type KwRenameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyKwRenameContext() *KwRenameContext { + var p = new(KwRenameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_kwRename + return p +} + +func InitEmptyKwRenameContext(p *KwRenameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_kwRename +} + +func (*KwRenameContext) IsKwRenameContext() {} + +func NewKwRenameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KwRenameContext { + var p = new(KwRenameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_kwRename + + return p +} + +func (s *KwRenameContext) GetParser() antlr.Parser { return s.parser } + +func (s *KwRenameContext) K_RENAME() antlr.TerminalNode { + return s.GetToken(CqlParserK_RENAME, 0) +} + +func (s *KwRenameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *KwRenameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *KwRenameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterKwRename(s) + } +} + +func (s *KwRenameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitKwRename(s) + } +} + +func (s *KwRenameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitKwRename(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) KwRename() (localctx IKwRenameContext) { + localctx = NewKwRenameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 476, CqlParserRULE_kwRename) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2241) + p.Match(CqlParserK_RENAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IKwReplaceContext is an interface to support dynamic dispatch. +type IKwReplaceContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + K_REPLACE() antlr.TerminalNode + + // IsKwReplaceContext differentiates from other interfaces. + IsKwReplaceContext() +} + +type KwReplaceContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyKwReplaceContext() *KwReplaceContext { + var p = new(KwReplaceContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_kwReplace + return p +} + +func InitEmptyKwReplaceContext(p *KwReplaceContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_kwReplace +} + +func (*KwReplaceContext) IsKwReplaceContext() {} + +func NewKwReplaceContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KwReplaceContext { + var p = new(KwReplaceContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_kwReplace + + return p +} + +func (s *KwReplaceContext) GetParser() antlr.Parser { return s.parser } + +func (s *KwReplaceContext) K_REPLACE() antlr.TerminalNode { + return s.GetToken(CqlParserK_REPLACE, 0) +} + +func (s *KwReplaceContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *KwReplaceContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *KwReplaceContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterKwReplace(s) + } +} + +func (s *KwReplaceContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitKwReplace(s) + } +} + +func (s *KwReplaceContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitKwReplace(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) KwReplace() (localctx IKwReplaceContext) { + localctx = NewKwReplaceContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 478, CqlParserRULE_kwReplace) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2243) + p.Match(CqlParserK_REPLACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IKwReplicationContext is an interface to support dynamic dispatch. +type IKwReplicationContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + K_REPLICATION() antlr.TerminalNode + + // IsKwReplicationContext differentiates from other interfaces. + IsKwReplicationContext() +} + +type KwReplicationContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyKwReplicationContext() *KwReplicationContext { + var p = new(KwReplicationContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_kwReplication + return p +} + +func InitEmptyKwReplicationContext(p *KwReplicationContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_kwReplication +} + +func (*KwReplicationContext) IsKwReplicationContext() {} + +func NewKwReplicationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KwReplicationContext { + var p = new(KwReplicationContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_kwReplication + + return p +} + +func (s *KwReplicationContext) GetParser() antlr.Parser { return s.parser } + +func (s *KwReplicationContext) K_REPLICATION() antlr.TerminalNode { + return s.GetToken(CqlParserK_REPLICATION, 0) +} + +func (s *KwReplicationContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *KwReplicationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *KwReplicationContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterKwReplication(s) + } +} + +func (s *KwReplicationContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitKwReplication(s) + } +} + +func (s *KwReplicationContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitKwReplication(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) KwReplication() (localctx IKwReplicationContext) { + localctx = NewKwReplicationContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 480, CqlParserRULE_kwReplication) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2245) + p.Match(CqlParserK_REPLICATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IKwReturnsContext is an interface to support dynamic dispatch. +type IKwReturnsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + K_RETURNS() antlr.TerminalNode + + // IsKwReturnsContext differentiates from other interfaces. + IsKwReturnsContext() +} + +type KwReturnsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyKwReturnsContext() *KwReturnsContext { + var p = new(KwReturnsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_kwReturns + return p +} + +func InitEmptyKwReturnsContext(p *KwReturnsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_kwReturns +} + +func (*KwReturnsContext) IsKwReturnsContext() {} + +func NewKwReturnsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KwReturnsContext { + var p = new(KwReturnsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_kwReturns + + return p +} + +func (s *KwReturnsContext) GetParser() antlr.Parser { return s.parser } + +func (s *KwReturnsContext) K_RETURNS() antlr.TerminalNode { + return s.GetToken(CqlParserK_RETURNS, 0) +} + +func (s *KwReturnsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *KwReturnsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *KwReturnsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterKwReturns(s) + } +} + +func (s *KwReturnsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitKwReturns(s) + } +} + +func (s *KwReturnsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitKwReturns(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) KwReturns() (localctx IKwReturnsContext) { + localctx = NewKwReturnsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 482, CqlParserRULE_kwReturns) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2247) + p.Match(CqlParserK_RETURNS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IKwRoleContext is an interface to support dynamic dispatch. +type IKwRoleContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + K_ROLE() antlr.TerminalNode + + // IsKwRoleContext differentiates from other interfaces. + IsKwRoleContext() +} + +type KwRoleContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyKwRoleContext() *KwRoleContext { + var p = new(KwRoleContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_kwRole + return p +} + +func InitEmptyKwRoleContext(p *KwRoleContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_kwRole +} + +func (*KwRoleContext) IsKwRoleContext() {} + +func NewKwRoleContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KwRoleContext { + var p = new(KwRoleContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_kwRole + + return p +} + +func (s *KwRoleContext) GetParser() antlr.Parser { return s.parser } + +func (s *KwRoleContext) K_ROLE() antlr.TerminalNode { + return s.GetToken(CqlParserK_ROLE, 0) +} + +func (s *KwRoleContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *KwRoleContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *KwRoleContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterKwRole(s) + } +} + +func (s *KwRoleContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitKwRole(s) + } +} + +func (s *KwRoleContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitKwRole(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) KwRole() (localctx IKwRoleContext) { + localctx = NewKwRoleContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 484, CqlParserRULE_kwRole) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2249) + p.Match(CqlParserK_ROLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IKwRolesContext is an interface to support dynamic dispatch. +type IKwRolesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + K_ROLES() antlr.TerminalNode + + // IsKwRolesContext differentiates from other interfaces. + IsKwRolesContext() +} + +type KwRolesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyKwRolesContext() *KwRolesContext { + var p = new(KwRolesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_kwRoles + return p +} + +func InitEmptyKwRolesContext(p *KwRolesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_kwRoles +} + +func (*KwRolesContext) IsKwRolesContext() {} + +func NewKwRolesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KwRolesContext { + var p = new(KwRolesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_kwRoles + + return p +} + +func (s *KwRolesContext) GetParser() antlr.Parser { return s.parser } + +func (s *KwRolesContext) K_ROLES() antlr.TerminalNode { + return s.GetToken(CqlParserK_ROLES, 0) +} + +func (s *KwRolesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *KwRolesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *KwRolesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterKwRoles(s) + } +} + +func (s *KwRolesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitKwRoles(s) + } +} + +func (s *KwRolesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitKwRoles(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) KwRoles() (localctx IKwRolesContext) { + localctx = NewKwRolesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 486, CqlParserRULE_kwRoles) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2251) + p.Match(CqlParserK_ROLES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IKwSelectContext is an interface to support dynamic dispatch. +type IKwSelectContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + K_SELECT() antlr.TerminalNode + + // IsKwSelectContext differentiates from other interfaces. + IsKwSelectContext() +} + +type KwSelectContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyKwSelectContext() *KwSelectContext { + var p = new(KwSelectContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_kwSelect + return p +} + +func InitEmptyKwSelectContext(p *KwSelectContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_kwSelect +} + +func (*KwSelectContext) IsKwSelectContext() {} + +func NewKwSelectContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KwSelectContext { + var p = new(KwSelectContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_kwSelect + + return p +} + +func (s *KwSelectContext) GetParser() antlr.Parser { return s.parser } + +func (s *KwSelectContext) K_SELECT() antlr.TerminalNode { + return s.GetToken(CqlParserK_SELECT, 0) +} + +func (s *KwSelectContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *KwSelectContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *KwSelectContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterKwSelect(s) + } +} + +func (s *KwSelectContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitKwSelect(s) + } +} + +func (s *KwSelectContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitKwSelect(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) KwSelect() (localctx IKwSelectContext) { + localctx = NewKwSelectContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 488, CqlParserRULE_kwSelect) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2253) + p.Match(CqlParserK_SELECT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IKwSetContext is an interface to support dynamic dispatch. +type IKwSetContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + K_SET() antlr.TerminalNode + + // IsKwSetContext differentiates from other interfaces. + IsKwSetContext() +} + +type KwSetContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyKwSetContext() *KwSetContext { + var p = new(KwSetContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_kwSet + return p +} + +func InitEmptyKwSetContext(p *KwSetContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_kwSet +} + +func (*KwSetContext) IsKwSetContext() {} + +func NewKwSetContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KwSetContext { + var p = new(KwSetContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_kwSet + + return p +} + +func (s *KwSetContext) GetParser() antlr.Parser { return s.parser } + +func (s *KwSetContext) K_SET() antlr.TerminalNode { + return s.GetToken(CqlParserK_SET, 0) +} + +func (s *KwSetContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *KwSetContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *KwSetContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterKwSet(s) + } +} + +func (s *KwSetContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitKwSet(s) + } +} + +func (s *KwSetContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitKwSet(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) KwSet() (localctx IKwSetContext) { + localctx = NewKwSetContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 490, CqlParserRULE_kwSet) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2255) + p.Match(CqlParserK_SET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IKwSfuncContext is an interface to support dynamic dispatch. +type IKwSfuncContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + K_SFUNC() antlr.TerminalNode + + // IsKwSfuncContext differentiates from other interfaces. + IsKwSfuncContext() +} + +type KwSfuncContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyKwSfuncContext() *KwSfuncContext { + var p = new(KwSfuncContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_kwSfunc + return p +} + +func InitEmptyKwSfuncContext(p *KwSfuncContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_kwSfunc +} + +func (*KwSfuncContext) IsKwSfuncContext() {} + +func NewKwSfuncContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KwSfuncContext { + var p = new(KwSfuncContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_kwSfunc + + return p +} + +func (s *KwSfuncContext) GetParser() antlr.Parser { return s.parser } + +func (s *KwSfuncContext) K_SFUNC() antlr.TerminalNode { + return s.GetToken(CqlParserK_SFUNC, 0) +} + +func (s *KwSfuncContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *KwSfuncContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *KwSfuncContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterKwSfunc(s) + } +} + +func (s *KwSfuncContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitKwSfunc(s) + } +} + +func (s *KwSfuncContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitKwSfunc(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) KwSfunc() (localctx IKwSfuncContext) { + localctx = NewKwSfuncContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 492, CqlParserRULE_kwSfunc) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2257) + p.Match(CqlParserK_SFUNC) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IKwStorageContext is an interface to support dynamic dispatch. +type IKwStorageContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + K_STORAGE() antlr.TerminalNode + + // IsKwStorageContext differentiates from other interfaces. + IsKwStorageContext() +} + +type KwStorageContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyKwStorageContext() *KwStorageContext { + var p = new(KwStorageContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_kwStorage + return p +} + +func InitEmptyKwStorageContext(p *KwStorageContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_kwStorage +} + +func (*KwStorageContext) IsKwStorageContext() {} + +func NewKwStorageContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KwStorageContext { + var p = new(KwStorageContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_kwStorage + + return p +} + +func (s *KwStorageContext) GetParser() antlr.Parser { return s.parser } + +func (s *KwStorageContext) K_STORAGE() antlr.TerminalNode { + return s.GetToken(CqlParserK_STORAGE, 0) +} + +func (s *KwStorageContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *KwStorageContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *KwStorageContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterKwStorage(s) + } +} + +func (s *KwStorageContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitKwStorage(s) + } +} + +func (s *KwStorageContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitKwStorage(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) KwStorage() (localctx IKwStorageContext) { + localctx = NewKwStorageContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 494, CqlParserRULE_kwStorage) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2259) + p.Match(CqlParserK_STORAGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IKwStypeContext is an interface to support dynamic dispatch. +type IKwStypeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + K_STYPE() antlr.TerminalNode + + // IsKwStypeContext differentiates from other interfaces. + IsKwStypeContext() +} + +type KwStypeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyKwStypeContext() *KwStypeContext { + var p = new(KwStypeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_kwStype + return p +} + +func InitEmptyKwStypeContext(p *KwStypeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_kwStype +} + +func (*KwStypeContext) IsKwStypeContext() {} + +func NewKwStypeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KwStypeContext { + var p = new(KwStypeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_kwStype + + return p +} + +func (s *KwStypeContext) GetParser() antlr.Parser { return s.parser } + +func (s *KwStypeContext) K_STYPE() antlr.TerminalNode { + return s.GetToken(CqlParserK_STYPE, 0) +} + +func (s *KwStypeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *KwStypeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *KwStypeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterKwStype(s) + } +} + +func (s *KwStypeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitKwStype(s) + } +} + +func (s *KwStypeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitKwStype(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) KwStype() (localctx IKwStypeContext) { + localctx = NewKwStypeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 496, CqlParserRULE_kwStype) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2261) + p.Match(CqlParserK_STYPE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IKwSuperuserContext is an interface to support dynamic dispatch. +type IKwSuperuserContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + K_SUPERUSER() antlr.TerminalNode + + // IsKwSuperuserContext differentiates from other interfaces. + IsKwSuperuserContext() +} + +type KwSuperuserContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyKwSuperuserContext() *KwSuperuserContext { + var p = new(KwSuperuserContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_kwSuperuser + return p +} + +func InitEmptyKwSuperuserContext(p *KwSuperuserContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_kwSuperuser +} + +func (*KwSuperuserContext) IsKwSuperuserContext() {} + +func NewKwSuperuserContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KwSuperuserContext { + var p = new(KwSuperuserContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_kwSuperuser + + return p +} + +func (s *KwSuperuserContext) GetParser() antlr.Parser { return s.parser } + +func (s *KwSuperuserContext) K_SUPERUSER() antlr.TerminalNode { + return s.GetToken(CqlParserK_SUPERUSER, 0) +} + +func (s *KwSuperuserContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *KwSuperuserContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *KwSuperuserContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterKwSuperuser(s) + } +} + +func (s *KwSuperuserContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitKwSuperuser(s) + } +} + +func (s *KwSuperuserContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitKwSuperuser(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) KwSuperuser() (localctx IKwSuperuserContext) { + localctx = NewKwSuperuserContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 498, CqlParserRULE_kwSuperuser) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2263) + p.Match(CqlParserK_SUPERUSER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IKwTableContext is an interface to support dynamic dispatch. +type IKwTableContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + K_TABLE() antlr.TerminalNode + + // IsKwTableContext differentiates from other interfaces. + IsKwTableContext() +} + +type KwTableContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyKwTableContext() *KwTableContext { + var p = new(KwTableContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_kwTable + return p +} + +func InitEmptyKwTableContext(p *KwTableContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_kwTable +} + +func (*KwTableContext) IsKwTableContext() {} + +func NewKwTableContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KwTableContext { + var p = new(KwTableContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_kwTable + + return p +} + +func (s *KwTableContext) GetParser() antlr.Parser { return s.parser } + +func (s *KwTableContext) K_TABLE() antlr.TerminalNode { + return s.GetToken(CqlParserK_TABLE, 0) +} + +func (s *KwTableContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *KwTableContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *KwTableContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterKwTable(s) + } +} + +func (s *KwTableContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitKwTable(s) + } +} + +func (s *KwTableContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitKwTable(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) KwTable() (localctx IKwTableContext) { + localctx = NewKwTableContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 500, CqlParserRULE_kwTable) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2265) + p.Match(CqlParserK_TABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IKwTimestampContext is an interface to support dynamic dispatch. +type IKwTimestampContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + K_TIMESTAMP() antlr.TerminalNode + + // IsKwTimestampContext differentiates from other interfaces. + IsKwTimestampContext() +} + +type KwTimestampContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyKwTimestampContext() *KwTimestampContext { + var p = new(KwTimestampContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_kwTimestamp + return p +} + +func InitEmptyKwTimestampContext(p *KwTimestampContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_kwTimestamp +} + +func (*KwTimestampContext) IsKwTimestampContext() {} + +func NewKwTimestampContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KwTimestampContext { + var p = new(KwTimestampContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_kwTimestamp + + return p +} + +func (s *KwTimestampContext) GetParser() antlr.Parser { return s.parser } + +func (s *KwTimestampContext) K_TIMESTAMP() antlr.TerminalNode { + return s.GetToken(CqlParserK_TIMESTAMP, 0) +} + +func (s *KwTimestampContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *KwTimestampContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *KwTimestampContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterKwTimestamp(s) + } +} + +func (s *KwTimestampContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitKwTimestamp(s) + } +} + +func (s *KwTimestampContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitKwTimestamp(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) KwTimestamp() (localctx IKwTimestampContext) { + localctx = NewKwTimestampContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 502, CqlParserRULE_kwTimestamp) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2267) + p.Match(CqlParserK_TIMESTAMP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IKwToContext is an interface to support dynamic dispatch. +type IKwToContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + K_TO() antlr.TerminalNode + + // IsKwToContext differentiates from other interfaces. + IsKwToContext() +} + +type KwToContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyKwToContext() *KwToContext { + var p = new(KwToContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_kwTo + return p +} + +func InitEmptyKwToContext(p *KwToContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_kwTo +} + +func (*KwToContext) IsKwToContext() {} + +func NewKwToContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KwToContext { + var p = new(KwToContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_kwTo + + return p +} + +func (s *KwToContext) GetParser() antlr.Parser { return s.parser } + +func (s *KwToContext) K_TO() antlr.TerminalNode { + return s.GetToken(CqlParserK_TO, 0) +} + +func (s *KwToContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *KwToContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *KwToContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterKwTo(s) + } +} + +func (s *KwToContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitKwTo(s) + } +} + +func (s *KwToContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitKwTo(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) KwTo() (localctx IKwToContext) { + localctx = NewKwToContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 504, CqlParserRULE_kwTo) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2269) + p.Match(CqlParserK_TO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IKwTriggerContext is an interface to support dynamic dispatch. +type IKwTriggerContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + K_TRIGGER() antlr.TerminalNode + + // IsKwTriggerContext differentiates from other interfaces. + IsKwTriggerContext() +} + +type KwTriggerContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyKwTriggerContext() *KwTriggerContext { + var p = new(KwTriggerContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_kwTrigger + return p +} + +func InitEmptyKwTriggerContext(p *KwTriggerContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_kwTrigger +} + +func (*KwTriggerContext) IsKwTriggerContext() {} + +func NewKwTriggerContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KwTriggerContext { + var p = new(KwTriggerContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_kwTrigger + + return p +} + +func (s *KwTriggerContext) GetParser() antlr.Parser { return s.parser } + +func (s *KwTriggerContext) K_TRIGGER() antlr.TerminalNode { + return s.GetToken(CqlParserK_TRIGGER, 0) +} + +func (s *KwTriggerContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *KwTriggerContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *KwTriggerContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterKwTrigger(s) + } +} + +func (s *KwTriggerContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitKwTrigger(s) + } +} + +func (s *KwTriggerContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitKwTrigger(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) KwTrigger() (localctx IKwTriggerContext) { + localctx = NewKwTriggerContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 506, CqlParserRULE_kwTrigger) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2271) + p.Match(CqlParserK_TRIGGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IKwTruncateContext is an interface to support dynamic dispatch. +type IKwTruncateContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + K_TRUNCATE() antlr.TerminalNode + + // IsKwTruncateContext differentiates from other interfaces. + IsKwTruncateContext() +} + +type KwTruncateContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyKwTruncateContext() *KwTruncateContext { + var p = new(KwTruncateContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_kwTruncate + return p +} + +func InitEmptyKwTruncateContext(p *KwTruncateContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_kwTruncate +} + +func (*KwTruncateContext) IsKwTruncateContext() {} + +func NewKwTruncateContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KwTruncateContext { + var p = new(KwTruncateContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_kwTruncate + + return p +} + +func (s *KwTruncateContext) GetParser() antlr.Parser { return s.parser } + +func (s *KwTruncateContext) K_TRUNCATE() antlr.TerminalNode { + return s.GetToken(CqlParserK_TRUNCATE, 0) +} + +func (s *KwTruncateContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *KwTruncateContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *KwTruncateContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterKwTruncate(s) + } +} + +func (s *KwTruncateContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitKwTruncate(s) + } +} + +func (s *KwTruncateContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitKwTruncate(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) KwTruncate() (localctx IKwTruncateContext) { + localctx = NewKwTruncateContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 508, CqlParserRULE_kwTruncate) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2273) + p.Match(CqlParserK_TRUNCATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IKwTtlContext is an interface to support dynamic dispatch. +type IKwTtlContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + K_TTL() antlr.TerminalNode + + // IsKwTtlContext differentiates from other interfaces. + IsKwTtlContext() +} + +type KwTtlContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyKwTtlContext() *KwTtlContext { + var p = new(KwTtlContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_kwTtl + return p +} + +func InitEmptyKwTtlContext(p *KwTtlContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_kwTtl +} + +func (*KwTtlContext) IsKwTtlContext() {} + +func NewKwTtlContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KwTtlContext { + var p = new(KwTtlContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_kwTtl + + return p +} + +func (s *KwTtlContext) GetParser() antlr.Parser { return s.parser } + +func (s *KwTtlContext) K_TTL() antlr.TerminalNode { + return s.GetToken(CqlParserK_TTL, 0) +} + +func (s *KwTtlContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *KwTtlContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *KwTtlContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterKwTtl(s) + } +} + +func (s *KwTtlContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitKwTtl(s) + } +} + +func (s *KwTtlContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitKwTtl(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) KwTtl() (localctx IKwTtlContext) { + localctx = NewKwTtlContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 510, CqlParserRULE_kwTtl) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2275) + p.Match(CqlParserK_TTL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IKwTypeContext is an interface to support dynamic dispatch. +type IKwTypeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + K_TYPE() antlr.TerminalNode + + // IsKwTypeContext differentiates from other interfaces. + IsKwTypeContext() +} + +type KwTypeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyKwTypeContext() *KwTypeContext { + var p = new(KwTypeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_kwType + return p +} + +func InitEmptyKwTypeContext(p *KwTypeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_kwType +} + +func (*KwTypeContext) IsKwTypeContext() {} + +func NewKwTypeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KwTypeContext { + var p = new(KwTypeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_kwType + + return p +} + +func (s *KwTypeContext) GetParser() antlr.Parser { return s.parser } + +func (s *KwTypeContext) K_TYPE() antlr.TerminalNode { + return s.GetToken(CqlParserK_TYPE, 0) +} + +func (s *KwTypeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *KwTypeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *KwTypeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterKwType(s) + } +} + +func (s *KwTypeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitKwType(s) + } +} + +func (s *KwTypeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitKwType(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) KwType() (localctx IKwTypeContext) { + localctx = NewKwTypeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 512, CqlParserRULE_kwType) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2277) + p.Match(CqlParserK_TYPE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IKwUnloggedContext is an interface to support dynamic dispatch. +type IKwUnloggedContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + K_UNLOGGED() antlr.TerminalNode + + // IsKwUnloggedContext differentiates from other interfaces. + IsKwUnloggedContext() +} + +type KwUnloggedContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyKwUnloggedContext() *KwUnloggedContext { + var p = new(KwUnloggedContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_kwUnlogged + return p +} + +func InitEmptyKwUnloggedContext(p *KwUnloggedContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_kwUnlogged +} + +func (*KwUnloggedContext) IsKwUnloggedContext() {} + +func NewKwUnloggedContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KwUnloggedContext { + var p = new(KwUnloggedContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_kwUnlogged + + return p +} + +func (s *KwUnloggedContext) GetParser() antlr.Parser { return s.parser } + +func (s *KwUnloggedContext) K_UNLOGGED() antlr.TerminalNode { + return s.GetToken(CqlParserK_UNLOGGED, 0) +} + +func (s *KwUnloggedContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *KwUnloggedContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *KwUnloggedContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterKwUnlogged(s) + } +} + +func (s *KwUnloggedContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitKwUnlogged(s) + } +} + +func (s *KwUnloggedContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitKwUnlogged(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) KwUnlogged() (localctx IKwUnloggedContext) { + localctx = NewKwUnloggedContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 514, CqlParserRULE_kwUnlogged) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2279) + p.Match(CqlParserK_UNLOGGED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IKwUpdateContext is an interface to support dynamic dispatch. +type IKwUpdateContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + K_UPDATE() antlr.TerminalNode + + // IsKwUpdateContext differentiates from other interfaces. + IsKwUpdateContext() +} + +type KwUpdateContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyKwUpdateContext() *KwUpdateContext { + var p = new(KwUpdateContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_kwUpdate + return p +} + +func InitEmptyKwUpdateContext(p *KwUpdateContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_kwUpdate +} + +func (*KwUpdateContext) IsKwUpdateContext() {} + +func NewKwUpdateContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KwUpdateContext { + var p = new(KwUpdateContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_kwUpdate + + return p +} + +func (s *KwUpdateContext) GetParser() antlr.Parser { return s.parser } + +func (s *KwUpdateContext) K_UPDATE() antlr.TerminalNode { + return s.GetToken(CqlParserK_UPDATE, 0) +} + +func (s *KwUpdateContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *KwUpdateContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *KwUpdateContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterKwUpdate(s) + } +} + +func (s *KwUpdateContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitKwUpdate(s) + } +} + +func (s *KwUpdateContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitKwUpdate(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) KwUpdate() (localctx IKwUpdateContext) { + localctx = NewKwUpdateContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 516, CqlParserRULE_kwUpdate) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2281) + p.Match(CqlParserK_UPDATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IKwUseContext is an interface to support dynamic dispatch. +type IKwUseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + K_USE() antlr.TerminalNode + + // IsKwUseContext differentiates from other interfaces. + IsKwUseContext() +} + +type KwUseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyKwUseContext() *KwUseContext { + var p = new(KwUseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_kwUse + return p +} + +func InitEmptyKwUseContext(p *KwUseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_kwUse +} + +func (*KwUseContext) IsKwUseContext() {} + +func NewKwUseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KwUseContext { + var p = new(KwUseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_kwUse + + return p +} + +func (s *KwUseContext) GetParser() antlr.Parser { return s.parser } + +func (s *KwUseContext) K_USE() antlr.TerminalNode { + return s.GetToken(CqlParserK_USE, 0) +} + +func (s *KwUseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *KwUseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *KwUseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterKwUse(s) + } +} + +func (s *KwUseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitKwUse(s) + } +} + +func (s *KwUseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitKwUse(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) KwUse() (localctx IKwUseContext) { + localctx = NewKwUseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 518, CqlParserRULE_kwUse) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2283) + p.Match(CqlParserK_USE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IKwUserContext is an interface to support dynamic dispatch. +type IKwUserContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + K_USER() antlr.TerminalNode + + // IsKwUserContext differentiates from other interfaces. + IsKwUserContext() +} + +type KwUserContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyKwUserContext() *KwUserContext { + var p = new(KwUserContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_kwUser + return p +} + +func InitEmptyKwUserContext(p *KwUserContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_kwUser +} + +func (*KwUserContext) IsKwUserContext() {} + +func NewKwUserContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KwUserContext { + var p = new(KwUserContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_kwUser + + return p +} + +func (s *KwUserContext) GetParser() antlr.Parser { return s.parser } + +func (s *KwUserContext) K_USER() antlr.TerminalNode { + return s.GetToken(CqlParserK_USER, 0) +} + +func (s *KwUserContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *KwUserContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *KwUserContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterKwUser(s) + } +} + +func (s *KwUserContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitKwUser(s) + } +} + +func (s *KwUserContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitKwUser(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) KwUser() (localctx IKwUserContext) { + localctx = NewKwUserContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 520, CqlParserRULE_kwUser) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2285) + p.Match(CqlParserK_USER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IKwUsingContext is an interface to support dynamic dispatch. +type IKwUsingContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + K_USING() antlr.TerminalNode + + // IsKwUsingContext differentiates from other interfaces. + IsKwUsingContext() +} + +type KwUsingContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyKwUsingContext() *KwUsingContext { + var p = new(KwUsingContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_kwUsing + return p +} + +func InitEmptyKwUsingContext(p *KwUsingContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_kwUsing +} + +func (*KwUsingContext) IsKwUsingContext() {} + +func NewKwUsingContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KwUsingContext { + var p = new(KwUsingContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_kwUsing + + return p +} + +func (s *KwUsingContext) GetParser() antlr.Parser { return s.parser } + +func (s *KwUsingContext) K_USING() antlr.TerminalNode { + return s.GetToken(CqlParserK_USING, 0) +} + +func (s *KwUsingContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *KwUsingContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *KwUsingContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterKwUsing(s) + } +} + +func (s *KwUsingContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitKwUsing(s) + } +} + +func (s *KwUsingContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitKwUsing(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) KwUsing() (localctx IKwUsingContext) { + localctx = NewKwUsingContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 522, CqlParserRULE_kwUsing) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2287) + p.Match(CqlParserK_USING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IKwValuesContext is an interface to support dynamic dispatch. +type IKwValuesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + K_VALUES() antlr.TerminalNode + + // IsKwValuesContext differentiates from other interfaces. + IsKwValuesContext() +} + +type KwValuesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyKwValuesContext() *KwValuesContext { + var p = new(KwValuesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_kwValues + return p +} + +func InitEmptyKwValuesContext(p *KwValuesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_kwValues +} + +func (*KwValuesContext) IsKwValuesContext() {} + +func NewKwValuesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KwValuesContext { + var p = new(KwValuesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_kwValues + + return p +} + +func (s *KwValuesContext) GetParser() antlr.Parser { return s.parser } + +func (s *KwValuesContext) K_VALUES() antlr.TerminalNode { + return s.GetToken(CqlParserK_VALUES, 0) +} + +func (s *KwValuesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *KwValuesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *KwValuesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterKwValues(s) + } +} + +func (s *KwValuesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitKwValues(s) + } +} + +func (s *KwValuesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitKwValues(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) KwValues() (localctx IKwValuesContext) { + localctx = NewKwValuesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 524, CqlParserRULE_kwValues) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2289) + p.Match(CqlParserK_VALUES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IKwViewContext is an interface to support dynamic dispatch. +type IKwViewContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + K_VIEW() antlr.TerminalNode + + // IsKwViewContext differentiates from other interfaces. + IsKwViewContext() +} + +type KwViewContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyKwViewContext() *KwViewContext { + var p = new(KwViewContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_kwView + return p +} + +func InitEmptyKwViewContext(p *KwViewContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_kwView +} + +func (*KwViewContext) IsKwViewContext() {} + +func NewKwViewContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KwViewContext { + var p = new(KwViewContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_kwView + + return p +} + +func (s *KwViewContext) GetParser() antlr.Parser { return s.parser } + +func (s *KwViewContext) K_VIEW() antlr.TerminalNode { + return s.GetToken(CqlParserK_VIEW, 0) +} + +func (s *KwViewContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *KwViewContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *KwViewContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterKwView(s) + } +} + +func (s *KwViewContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitKwView(s) + } +} + +func (s *KwViewContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitKwView(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) KwView() (localctx IKwViewContext) { + localctx = NewKwViewContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 526, CqlParserRULE_kwView) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2291) + p.Match(CqlParserK_VIEW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IKwWhereContext is an interface to support dynamic dispatch. +type IKwWhereContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + K_WHERE() antlr.TerminalNode + + // IsKwWhereContext differentiates from other interfaces. + IsKwWhereContext() +} + +type KwWhereContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyKwWhereContext() *KwWhereContext { + var p = new(KwWhereContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_kwWhere + return p +} + +func InitEmptyKwWhereContext(p *KwWhereContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_kwWhere +} + +func (*KwWhereContext) IsKwWhereContext() {} + +func NewKwWhereContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KwWhereContext { + var p = new(KwWhereContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_kwWhere + + return p +} + +func (s *KwWhereContext) GetParser() antlr.Parser { return s.parser } + +func (s *KwWhereContext) K_WHERE() antlr.TerminalNode { + return s.GetToken(CqlParserK_WHERE, 0) +} + +func (s *KwWhereContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *KwWhereContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *KwWhereContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterKwWhere(s) + } +} + +func (s *KwWhereContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitKwWhere(s) + } +} + +func (s *KwWhereContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitKwWhere(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) KwWhere() (localctx IKwWhereContext) { + localctx = NewKwWhereContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 528, CqlParserRULE_kwWhere) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2293) + p.Match(CqlParserK_WHERE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IKwWithContext is an interface to support dynamic dispatch. +type IKwWithContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + K_WITH() antlr.TerminalNode + + // IsKwWithContext differentiates from other interfaces. + IsKwWithContext() +} + +type KwWithContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyKwWithContext() *KwWithContext { + var p = new(KwWithContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_kwWith + return p +} + +func InitEmptyKwWithContext(p *KwWithContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_kwWith +} + +func (*KwWithContext) IsKwWithContext() {} + +func NewKwWithContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KwWithContext { + var p = new(KwWithContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_kwWith + + return p +} + +func (s *KwWithContext) GetParser() antlr.Parser { return s.parser } + +func (s *KwWithContext) K_WITH() antlr.TerminalNode { + return s.GetToken(CqlParserK_WITH, 0) +} + +func (s *KwWithContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *KwWithContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *KwWithContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterKwWith(s) + } +} + +func (s *KwWithContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitKwWith(s) + } +} + +func (s *KwWithContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitKwWith(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) KwWith() (localctx IKwWithContext) { + localctx = NewKwWithContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 530, CqlParserRULE_kwWith) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2295) + p.Match(CqlParserK_WITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IKwRevokeContext is an interface to support dynamic dispatch. +type IKwRevokeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + K_REVOKE() antlr.TerminalNode + + // IsKwRevokeContext differentiates from other interfaces. + IsKwRevokeContext() +} + +type KwRevokeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyKwRevokeContext() *KwRevokeContext { + var p = new(KwRevokeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_kwRevoke + return p +} + +func InitEmptyKwRevokeContext(p *KwRevokeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_kwRevoke +} + +func (*KwRevokeContext) IsKwRevokeContext() {} + +func NewKwRevokeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KwRevokeContext { + var p = new(KwRevokeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_kwRevoke + + return p +} + +func (s *KwRevokeContext) GetParser() antlr.Parser { return s.parser } + +func (s *KwRevokeContext) K_REVOKE() antlr.TerminalNode { + return s.GetToken(CqlParserK_REVOKE, 0) +} + +func (s *KwRevokeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *KwRevokeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *KwRevokeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterKwRevoke(s) + } +} + +func (s *KwRevokeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitKwRevoke(s) + } +} + +func (s *KwRevokeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitKwRevoke(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) KwRevoke() (localctx IKwRevokeContext) { + localctx = NewKwRevokeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 532, CqlParserRULE_kwRevoke) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2297) + p.Match(CqlParserK_REVOKE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISyntaxBracketLrContext is an interface to support dynamic dispatch. +type ISyntaxBracketLrContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + LR_BRACKET() antlr.TerminalNode + + // IsSyntaxBracketLrContext differentiates from other interfaces. + IsSyntaxBracketLrContext() +} + +type SyntaxBracketLrContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySyntaxBracketLrContext() *SyntaxBracketLrContext { + var p = new(SyntaxBracketLrContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_syntaxBracketLr + return p +} + +func InitEmptySyntaxBracketLrContext(p *SyntaxBracketLrContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_syntaxBracketLr +} + +func (*SyntaxBracketLrContext) IsSyntaxBracketLrContext() {} + +func NewSyntaxBracketLrContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SyntaxBracketLrContext { + var p = new(SyntaxBracketLrContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_syntaxBracketLr + + return p +} + +func (s *SyntaxBracketLrContext) GetParser() antlr.Parser { return s.parser } + +func (s *SyntaxBracketLrContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(CqlParserLR_BRACKET, 0) +} + +func (s *SyntaxBracketLrContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SyntaxBracketLrContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *SyntaxBracketLrContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterSyntaxBracketLr(s) + } +} + +func (s *SyntaxBracketLrContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitSyntaxBracketLr(s) + } +} + +func (s *SyntaxBracketLrContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitSyntaxBracketLr(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) SyntaxBracketLr() (localctx ISyntaxBracketLrContext) { + localctx = NewSyntaxBracketLrContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 534, CqlParserRULE_syntaxBracketLr) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2299) + p.Match(CqlParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISyntaxBracketRrContext is an interface to support dynamic dispatch. +type ISyntaxBracketRrContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + RR_BRACKET() antlr.TerminalNode + + // IsSyntaxBracketRrContext differentiates from other interfaces. + IsSyntaxBracketRrContext() +} + +type SyntaxBracketRrContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySyntaxBracketRrContext() *SyntaxBracketRrContext { + var p = new(SyntaxBracketRrContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_syntaxBracketRr + return p +} + +func InitEmptySyntaxBracketRrContext(p *SyntaxBracketRrContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_syntaxBracketRr +} + +func (*SyntaxBracketRrContext) IsSyntaxBracketRrContext() {} + +func NewSyntaxBracketRrContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SyntaxBracketRrContext { + var p = new(SyntaxBracketRrContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_syntaxBracketRr + + return p +} + +func (s *SyntaxBracketRrContext) GetParser() antlr.Parser { return s.parser } + +func (s *SyntaxBracketRrContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(CqlParserRR_BRACKET, 0) +} + +func (s *SyntaxBracketRrContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SyntaxBracketRrContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *SyntaxBracketRrContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterSyntaxBracketRr(s) + } +} + +func (s *SyntaxBracketRrContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitSyntaxBracketRr(s) + } +} + +func (s *SyntaxBracketRrContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitSyntaxBracketRr(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) SyntaxBracketRr() (localctx ISyntaxBracketRrContext) { + localctx = NewSyntaxBracketRrContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 536, CqlParserRULE_syntaxBracketRr) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2301) + p.Match(CqlParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISyntaxBracketLcContext is an interface to support dynamic dispatch. +type ISyntaxBracketLcContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + LC_BRACKET() antlr.TerminalNode + + // IsSyntaxBracketLcContext differentiates from other interfaces. + IsSyntaxBracketLcContext() +} + +type SyntaxBracketLcContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySyntaxBracketLcContext() *SyntaxBracketLcContext { + var p = new(SyntaxBracketLcContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_syntaxBracketLc + return p +} + +func InitEmptySyntaxBracketLcContext(p *SyntaxBracketLcContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_syntaxBracketLc +} + +func (*SyntaxBracketLcContext) IsSyntaxBracketLcContext() {} + +func NewSyntaxBracketLcContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SyntaxBracketLcContext { + var p = new(SyntaxBracketLcContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_syntaxBracketLc + + return p +} + +func (s *SyntaxBracketLcContext) GetParser() antlr.Parser { return s.parser } + +func (s *SyntaxBracketLcContext) LC_BRACKET() antlr.TerminalNode { + return s.GetToken(CqlParserLC_BRACKET, 0) +} + +func (s *SyntaxBracketLcContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SyntaxBracketLcContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *SyntaxBracketLcContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterSyntaxBracketLc(s) + } +} + +func (s *SyntaxBracketLcContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitSyntaxBracketLc(s) + } +} + +func (s *SyntaxBracketLcContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitSyntaxBracketLc(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) SyntaxBracketLc() (localctx ISyntaxBracketLcContext) { + localctx = NewSyntaxBracketLcContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 538, CqlParserRULE_syntaxBracketLc) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2303) + p.Match(CqlParserLC_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISyntaxBracketRcContext is an interface to support dynamic dispatch. +type ISyntaxBracketRcContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + RC_BRACKET() antlr.TerminalNode + + // IsSyntaxBracketRcContext differentiates from other interfaces. + IsSyntaxBracketRcContext() +} + +type SyntaxBracketRcContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySyntaxBracketRcContext() *SyntaxBracketRcContext { + var p = new(SyntaxBracketRcContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_syntaxBracketRc + return p +} + +func InitEmptySyntaxBracketRcContext(p *SyntaxBracketRcContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_syntaxBracketRc +} + +func (*SyntaxBracketRcContext) IsSyntaxBracketRcContext() {} + +func NewSyntaxBracketRcContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SyntaxBracketRcContext { + var p = new(SyntaxBracketRcContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_syntaxBracketRc + + return p +} + +func (s *SyntaxBracketRcContext) GetParser() antlr.Parser { return s.parser } + +func (s *SyntaxBracketRcContext) RC_BRACKET() antlr.TerminalNode { + return s.GetToken(CqlParserRC_BRACKET, 0) +} + +func (s *SyntaxBracketRcContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SyntaxBracketRcContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *SyntaxBracketRcContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterSyntaxBracketRc(s) + } +} + +func (s *SyntaxBracketRcContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitSyntaxBracketRc(s) + } +} + +func (s *SyntaxBracketRcContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitSyntaxBracketRc(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) SyntaxBracketRc() (localctx ISyntaxBracketRcContext) { + localctx = NewSyntaxBracketRcContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 540, CqlParserRULE_syntaxBracketRc) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2305) + p.Match(CqlParserRC_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISyntaxBracketLaContext is an interface to support dynamic dispatch. +type ISyntaxBracketLaContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + OPERATOR_LT() antlr.TerminalNode + + // IsSyntaxBracketLaContext differentiates from other interfaces. + IsSyntaxBracketLaContext() +} + +type SyntaxBracketLaContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySyntaxBracketLaContext() *SyntaxBracketLaContext { + var p = new(SyntaxBracketLaContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_syntaxBracketLa + return p +} + +func InitEmptySyntaxBracketLaContext(p *SyntaxBracketLaContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_syntaxBracketLa +} + +func (*SyntaxBracketLaContext) IsSyntaxBracketLaContext() {} + +func NewSyntaxBracketLaContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SyntaxBracketLaContext { + var p = new(SyntaxBracketLaContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_syntaxBracketLa + + return p +} + +func (s *SyntaxBracketLaContext) GetParser() antlr.Parser { return s.parser } + +func (s *SyntaxBracketLaContext) OPERATOR_LT() antlr.TerminalNode { + return s.GetToken(CqlParserOPERATOR_LT, 0) +} + +func (s *SyntaxBracketLaContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SyntaxBracketLaContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *SyntaxBracketLaContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterSyntaxBracketLa(s) + } +} + +func (s *SyntaxBracketLaContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitSyntaxBracketLa(s) + } +} + +func (s *SyntaxBracketLaContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitSyntaxBracketLa(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) SyntaxBracketLa() (localctx ISyntaxBracketLaContext) { + localctx = NewSyntaxBracketLaContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 542, CqlParserRULE_syntaxBracketLa) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2307) + p.Match(CqlParserOPERATOR_LT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISyntaxBracketRaContext is an interface to support dynamic dispatch. +type ISyntaxBracketRaContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + OPERATOR_GT() antlr.TerminalNode + + // IsSyntaxBracketRaContext differentiates from other interfaces. + IsSyntaxBracketRaContext() +} + +type SyntaxBracketRaContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySyntaxBracketRaContext() *SyntaxBracketRaContext { + var p = new(SyntaxBracketRaContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_syntaxBracketRa + return p +} + +func InitEmptySyntaxBracketRaContext(p *SyntaxBracketRaContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_syntaxBracketRa +} + +func (*SyntaxBracketRaContext) IsSyntaxBracketRaContext() {} + +func NewSyntaxBracketRaContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SyntaxBracketRaContext { + var p = new(SyntaxBracketRaContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_syntaxBracketRa + + return p +} + +func (s *SyntaxBracketRaContext) GetParser() antlr.Parser { return s.parser } + +func (s *SyntaxBracketRaContext) OPERATOR_GT() antlr.TerminalNode { + return s.GetToken(CqlParserOPERATOR_GT, 0) +} + +func (s *SyntaxBracketRaContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SyntaxBracketRaContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *SyntaxBracketRaContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterSyntaxBracketRa(s) + } +} + +func (s *SyntaxBracketRaContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitSyntaxBracketRa(s) + } +} + +func (s *SyntaxBracketRaContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitSyntaxBracketRa(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) SyntaxBracketRa() (localctx ISyntaxBracketRaContext) { + localctx = NewSyntaxBracketRaContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 544, CqlParserRULE_syntaxBracketRa) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2309) + p.Match(CqlParserOPERATOR_GT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISyntaxBracketLsContext is an interface to support dynamic dispatch. +type ISyntaxBracketLsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + LS_BRACKET() antlr.TerminalNode + + // IsSyntaxBracketLsContext differentiates from other interfaces. + IsSyntaxBracketLsContext() +} + +type SyntaxBracketLsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySyntaxBracketLsContext() *SyntaxBracketLsContext { + var p = new(SyntaxBracketLsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_syntaxBracketLs + return p +} + +func InitEmptySyntaxBracketLsContext(p *SyntaxBracketLsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_syntaxBracketLs +} + +func (*SyntaxBracketLsContext) IsSyntaxBracketLsContext() {} + +func NewSyntaxBracketLsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SyntaxBracketLsContext { + var p = new(SyntaxBracketLsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_syntaxBracketLs + + return p +} + +func (s *SyntaxBracketLsContext) GetParser() antlr.Parser { return s.parser } + +func (s *SyntaxBracketLsContext) LS_BRACKET() antlr.TerminalNode { + return s.GetToken(CqlParserLS_BRACKET, 0) +} + +func (s *SyntaxBracketLsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SyntaxBracketLsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *SyntaxBracketLsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterSyntaxBracketLs(s) + } +} + +func (s *SyntaxBracketLsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitSyntaxBracketLs(s) + } +} + +func (s *SyntaxBracketLsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitSyntaxBracketLs(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) SyntaxBracketLs() (localctx ISyntaxBracketLsContext) { + localctx = NewSyntaxBracketLsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 546, CqlParserRULE_syntaxBracketLs) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2311) + p.Match(CqlParserLS_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISyntaxBracketRsContext is an interface to support dynamic dispatch. +type ISyntaxBracketRsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + RS_BRACKET() antlr.TerminalNode + + // IsSyntaxBracketRsContext differentiates from other interfaces. + IsSyntaxBracketRsContext() +} + +type SyntaxBracketRsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySyntaxBracketRsContext() *SyntaxBracketRsContext { + var p = new(SyntaxBracketRsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_syntaxBracketRs + return p +} + +func InitEmptySyntaxBracketRsContext(p *SyntaxBracketRsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_syntaxBracketRs +} + +func (*SyntaxBracketRsContext) IsSyntaxBracketRsContext() {} + +func NewSyntaxBracketRsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SyntaxBracketRsContext { + var p = new(SyntaxBracketRsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_syntaxBracketRs + + return p +} + +func (s *SyntaxBracketRsContext) GetParser() antlr.Parser { return s.parser } + +func (s *SyntaxBracketRsContext) RS_BRACKET() antlr.TerminalNode { + return s.GetToken(CqlParserRS_BRACKET, 0) +} + +func (s *SyntaxBracketRsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SyntaxBracketRsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *SyntaxBracketRsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterSyntaxBracketRs(s) + } +} + +func (s *SyntaxBracketRsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitSyntaxBracketRs(s) + } +} + +func (s *SyntaxBracketRsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitSyntaxBracketRs(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) SyntaxBracketRs() (localctx ISyntaxBracketRsContext) { + localctx = NewSyntaxBracketRsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 548, CqlParserRULE_syntaxBracketRs) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2313) + p.Match(CqlParserRS_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISyntaxCommaContext is an interface to support dynamic dispatch. +type ISyntaxCommaContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + COMMA() antlr.TerminalNode + + // IsSyntaxCommaContext differentiates from other interfaces. + IsSyntaxCommaContext() +} + +type SyntaxCommaContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySyntaxCommaContext() *SyntaxCommaContext { + var p = new(SyntaxCommaContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_syntaxComma + return p +} + +func InitEmptySyntaxCommaContext(p *SyntaxCommaContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_syntaxComma +} + +func (*SyntaxCommaContext) IsSyntaxCommaContext() {} + +func NewSyntaxCommaContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SyntaxCommaContext { + var p = new(SyntaxCommaContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_syntaxComma + + return p +} + +func (s *SyntaxCommaContext) GetParser() antlr.Parser { return s.parser } + +func (s *SyntaxCommaContext) COMMA() antlr.TerminalNode { + return s.GetToken(CqlParserCOMMA, 0) +} + +func (s *SyntaxCommaContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SyntaxCommaContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *SyntaxCommaContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterSyntaxComma(s) + } +} + +func (s *SyntaxCommaContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitSyntaxComma(s) + } +} + +func (s *SyntaxCommaContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitSyntaxComma(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) SyntaxComma() (localctx ISyntaxCommaContext) { + localctx = NewSyntaxCommaContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 550, CqlParserRULE_syntaxComma) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2315) + p.Match(CqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISyntaxColonContext is an interface to support dynamic dispatch. +type ISyntaxColonContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + COLON() antlr.TerminalNode + + // IsSyntaxColonContext differentiates from other interfaces. + IsSyntaxColonContext() +} + +type SyntaxColonContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySyntaxColonContext() *SyntaxColonContext { + var p = new(SyntaxColonContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_syntaxColon + return p +} + +func InitEmptySyntaxColonContext(p *SyntaxColonContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = CqlParserRULE_syntaxColon +} + +func (*SyntaxColonContext) IsSyntaxColonContext() {} + +func NewSyntaxColonContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SyntaxColonContext { + var p = new(SyntaxColonContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = CqlParserRULE_syntaxColon + + return p +} + +func (s *SyntaxColonContext) GetParser() antlr.Parser { return s.parser } + +func (s *SyntaxColonContext) COLON() antlr.TerminalNode { + return s.GetToken(CqlParserCOLON, 0) +} + +func (s *SyntaxColonContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SyntaxColonContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *SyntaxColonContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.EnterSyntaxColon(s) + } +} + +func (s *SyntaxColonContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(CqlParserListener); ok { + listenerT.ExitSyntaxColon(s) + } +} + +func (s *SyntaxColonContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case CqlParserVisitor: + return t.VisitSyntaxColon(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *CqlParser) SyntaxColon() (localctx ISyntaxColonContext) { + localctx = NewSyntaxColonContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 552, CqlParserRULE_syntaxColon) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2317) + p.Match(CqlParserCOLON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} diff --git a/cql/cql_parser_error_listener.go b/cql/cql_parser_error_listener.go new file mode 100644 index 0000000..63fa8ad --- /dev/null +++ b/cql/cql_parser_error_listener.go @@ -0,0 +1,38 @@ +package cql + +import ( + "fmt" + "github.com/antlr4-go/antlr/v4" +) + +// ParseError represents a CQL parsing error with position information +type ParseError struct { + Line int + Column int + Msg string +} + +func (e *ParseError) Error() string { + return fmt.Sprintf("line %d:%d %s", e.Line, e.Column, e.Msg) +} + +// ErrorListener collects parsing errors +type ErrorListener struct { + *antlr.DefaultErrorListener + Errors []ParseError +} + +func NewErrorListener() *ErrorListener { + return &ErrorListener{ + DefaultErrorListener: &antlr.DefaultErrorListener{}, + Errors: make([]ParseError, 0), + } +} + +func (l *ErrorListener) SyntaxError(recognizer antlr.Recognizer, offendingSymbol interface{}, line, column int, msg string, e antlr.RecognitionException) { + l.Errors = append(l.Errors, ParseError{ + Line: line, + Column: column, + Msg: msg, + }) +} \ No newline at end of file diff --git a/cql/cqlparser_base_listener.go b/cql/cqlparser_base_listener.go new file mode 100644 index 0000000..50c8437 --- /dev/null +++ b/cql/cqlparser_base_listener.go @@ -0,0 +1,1687 @@ +// Code generated from CqlParser.g4 by ANTLR 4.13.2. DO NOT EDIT. + +package cql // CqlParser +import "github.com/antlr4-go/antlr/v4" + +// BaseCqlParserListener is a complete listener for a parse tree produced by CqlParser. +type BaseCqlParserListener struct{} + +var _ CqlParserListener = &BaseCqlParserListener{} + +// VisitTerminal is called when a terminal node is visited. +func (s *BaseCqlParserListener) VisitTerminal(node antlr.TerminalNode) {} + +// VisitErrorNode is called when an error node is visited. +func (s *BaseCqlParserListener) VisitErrorNode(node antlr.ErrorNode) {} + +// EnterEveryRule is called when any rule is entered. +func (s *BaseCqlParserListener) EnterEveryRule(ctx antlr.ParserRuleContext) {} + +// ExitEveryRule is called when any rule is exited. +func (s *BaseCqlParserListener) ExitEveryRule(ctx antlr.ParserRuleContext) {} + +// EnterRoot is called when production root is entered. +func (s *BaseCqlParserListener) EnterRoot(ctx *RootContext) {} + +// ExitRoot is called when production root is exited. +func (s *BaseCqlParserListener) ExitRoot(ctx *RootContext) {} + +// EnterCqls is called when production cqls is entered. +func (s *BaseCqlParserListener) EnterCqls(ctx *CqlsContext) {} + +// ExitCqls is called when production cqls is exited. +func (s *BaseCqlParserListener) ExitCqls(ctx *CqlsContext) {} + +// EnterStatementSeparator is called when production statementSeparator is entered. +func (s *BaseCqlParserListener) EnterStatementSeparator(ctx *StatementSeparatorContext) {} + +// ExitStatementSeparator is called when production statementSeparator is exited. +func (s *BaseCqlParserListener) ExitStatementSeparator(ctx *StatementSeparatorContext) {} + +// EnterEmpty_ is called when production empty_ is entered. +func (s *BaseCqlParserListener) EnterEmpty_(ctx *Empty_Context) {} + +// ExitEmpty_ is called when production empty_ is exited. +func (s *BaseCqlParserListener) ExitEmpty_(ctx *Empty_Context) {} + +// EnterCql is called when production cql is entered. +func (s *BaseCqlParserListener) EnterCql(ctx *CqlContext) {} + +// ExitCql is called when production cql is exited. +func (s *BaseCqlParserListener) ExitCql(ctx *CqlContext) {} + +// EnterRevoke is called when production revoke is entered. +func (s *BaseCqlParserListener) EnterRevoke(ctx *RevokeContext) {} + +// ExitRevoke is called when production revoke is exited. +func (s *BaseCqlParserListener) ExitRevoke(ctx *RevokeContext) {} + +// EnterListRoles is called when production listRoles is entered. +func (s *BaseCqlParserListener) EnterListRoles(ctx *ListRolesContext) {} + +// ExitListRoles is called when production listRoles is exited. +func (s *BaseCqlParserListener) ExitListRoles(ctx *ListRolesContext) {} + +// EnterListPermissions is called when production listPermissions is entered. +func (s *BaseCqlParserListener) EnterListPermissions(ctx *ListPermissionsContext) {} + +// ExitListPermissions is called when production listPermissions is exited. +func (s *BaseCqlParserListener) ExitListPermissions(ctx *ListPermissionsContext) {} + +// EnterGrant is called when production grant is entered. +func (s *BaseCqlParserListener) EnterGrant(ctx *GrantContext) {} + +// ExitGrant is called when production grant is exited. +func (s *BaseCqlParserListener) ExitGrant(ctx *GrantContext) {} + +// EnterPriviledge is called when production priviledge is entered. +func (s *BaseCqlParserListener) EnterPriviledge(ctx *PriviledgeContext) {} + +// ExitPriviledge is called when production priviledge is exited. +func (s *BaseCqlParserListener) ExitPriviledge(ctx *PriviledgeContext) {} + +// EnterResource is called when production resource is entered. +func (s *BaseCqlParserListener) EnterResource(ctx *ResourceContext) {} + +// ExitResource is called when production resource is exited. +func (s *BaseCqlParserListener) ExitResource(ctx *ResourceContext) {} + +// EnterCreateUser is called when production createUser is entered. +func (s *BaseCqlParserListener) EnterCreateUser(ctx *CreateUserContext) {} + +// ExitCreateUser is called when production createUser is exited. +func (s *BaseCqlParserListener) ExitCreateUser(ctx *CreateUserContext) {} + +// EnterCreateRole is called when production createRole is entered. +func (s *BaseCqlParserListener) EnterCreateRole(ctx *CreateRoleContext) {} + +// ExitCreateRole is called when production createRole is exited. +func (s *BaseCqlParserListener) ExitCreateRole(ctx *CreateRoleContext) {} + +// EnterCreateType is called when production createType is entered. +func (s *BaseCqlParserListener) EnterCreateType(ctx *CreateTypeContext) {} + +// ExitCreateType is called when production createType is exited. +func (s *BaseCqlParserListener) ExitCreateType(ctx *CreateTypeContext) {} + +// EnterTypeMemberColumnList is called when production typeMemberColumnList is entered. +func (s *BaseCqlParserListener) EnterTypeMemberColumnList(ctx *TypeMemberColumnListContext) {} + +// ExitTypeMemberColumnList is called when production typeMemberColumnList is exited. +func (s *BaseCqlParserListener) ExitTypeMemberColumnList(ctx *TypeMemberColumnListContext) {} + +// EnterCreateTrigger is called when production createTrigger is entered. +func (s *BaseCqlParserListener) EnterCreateTrigger(ctx *CreateTriggerContext) {} + +// ExitCreateTrigger is called when production createTrigger is exited. +func (s *BaseCqlParserListener) ExitCreateTrigger(ctx *CreateTriggerContext) {} + +// EnterCreateMaterializedView is called when production createMaterializedView is entered. +func (s *BaseCqlParserListener) EnterCreateMaterializedView(ctx *CreateMaterializedViewContext) {} + +// ExitCreateMaterializedView is called when production createMaterializedView is exited. +func (s *BaseCqlParserListener) ExitCreateMaterializedView(ctx *CreateMaterializedViewContext) {} + +// EnterMaterializedViewWhere is called when production materializedViewWhere is entered. +func (s *BaseCqlParserListener) EnterMaterializedViewWhere(ctx *MaterializedViewWhereContext) {} + +// ExitMaterializedViewWhere is called when production materializedViewWhere is exited. +func (s *BaseCqlParserListener) ExitMaterializedViewWhere(ctx *MaterializedViewWhereContext) {} + +// EnterColumnNotNullList is called when production columnNotNullList is entered. +func (s *BaseCqlParserListener) EnterColumnNotNullList(ctx *ColumnNotNullListContext) {} + +// ExitColumnNotNullList is called when production columnNotNullList is exited. +func (s *BaseCqlParserListener) ExitColumnNotNullList(ctx *ColumnNotNullListContext) {} + +// EnterColumnNotNull is called when production columnNotNull is entered. +func (s *BaseCqlParserListener) EnterColumnNotNull(ctx *ColumnNotNullContext) {} + +// ExitColumnNotNull is called when production columnNotNull is exited. +func (s *BaseCqlParserListener) ExitColumnNotNull(ctx *ColumnNotNullContext) {} + +// EnterMaterializedViewOptions is called when production materializedViewOptions is entered. +func (s *BaseCqlParserListener) EnterMaterializedViewOptions(ctx *MaterializedViewOptionsContext) {} + +// ExitMaterializedViewOptions is called when production materializedViewOptions is exited. +func (s *BaseCqlParserListener) ExitMaterializedViewOptions(ctx *MaterializedViewOptionsContext) {} + +// EnterCreateKeyspace is called when production createKeyspace is entered. +func (s *BaseCqlParserListener) EnterCreateKeyspace(ctx *CreateKeyspaceContext) {} + +// ExitCreateKeyspace is called when production createKeyspace is exited. +func (s *BaseCqlParserListener) ExitCreateKeyspace(ctx *CreateKeyspaceContext) {} + +// EnterCreateFunction is called when production createFunction is entered. +func (s *BaseCqlParserListener) EnterCreateFunction(ctx *CreateFunctionContext) {} + +// ExitCreateFunction is called when production createFunction is exited. +func (s *BaseCqlParserListener) ExitCreateFunction(ctx *CreateFunctionContext) {} + +// EnterCodeBlock is called when production codeBlock is entered. +func (s *BaseCqlParserListener) EnterCodeBlock(ctx *CodeBlockContext) {} + +// ExitCodeBlock is called when production codeBlock is exited. +func (s *BaseCqlParserListener) ExitCodeBlock(ctx *CodeBlockContext) {} + +// EnterParamList is called when production paramList is entered. +func (s *BaseCqlParserListener) EnterParamList(ctx *ParamListContext) {} + +// ExitParamList is called when production paramList is exited. +func (s *BaseCqlParserListener) ExitParamList(ctx *ParamListContext) {} + +// EnterReturnMode is called when production returnMode is entered. +func (s *BaseCqlParserListener) EnterReturnMode(ctx *ReturnModeContext) {} + +// ExitReturnMode is called when production returnMode is exited. +func (s *BaseCqlParserListener) ExitReturnMode(ctx *ReturnModeContext) {} + +// EnterCreateAggregate is called when production createAggregate is entered. +func (s *BaseCqlParserListener) EnterCreateAggregate(ctx *CreateAggregateContext) {} + +// ExitCreateAggregate is called when production createAggregate is exited. +func (s *BaseCqlParserListener) ExitCreateAggregate(ctx *CreateAggregateContext) {} + +// EnterInitCondDefinition is called when production initCondDefinition is entered. +func (s *BaseCqlParserListener) EnterInitCondDefinition(ctx *InitCondDefinitionContext) {} + +// ExitInitCondDefinition is called when production initCondDefinition is exited. +func (s *BaseCqlParserListener) ExitInitCondDefinition(ctx *InitCondDefinitionContext) {} + +// EnterInitCondHash is called when production initCondHash is entered. +func (s *BaseCqlParserListener) EnterInitCondHash(ctx *InitCondHashContext) {} + +// ExitInitCondHash is called when production initCondHash is exited. +func (s *BaseCqlParserListener) ExitInitCondHash(ctx *InitCondHashContext) {} + +// EnterInitCondHashItem is called when production initCondHashItem is entered. +func (s *BaseCqlParserListener) EnterInitCondHashItem(ctx *InitCondHashItemContext) {} + +// ExitInitCondHashItem is called when production initCondHashItem is exited. +func (s *BaseCqlParserListener) ExitInitCondHashItem(ctx *InitCondHashItemContext) {} + +// EnterInitCondListNested is called when production initCondListNested is entered. +func (s *BaseCqlParserListener) EnterInitCondListNested(ctx *InitCondListNestedContext) {} + +// ExitInitCondListNested is called when production initCondListNested is exited. +func (s *BaseCqlParserListener) ExitInitCondListNested(ctx *InitCondListNestedContext) {} + +// EnterInitCondList is called when production initCondList is entered. +func (s *BaseCqlParserListener) EnterInitCondList(ctx *InitCondListContext) {} + +// ExitInitCondList is called when production initCondList is exited. +func (s *BaseCqlParserListener) ExitInitCondList(ctx *InitCondListContext) {} + +// EnterOrReplace is called when production orReplace is entered. +func (s *BaseCqlParserListener) EnterOrReplace(ctx *OrReplaceContext) {} + +// ExitOrReplace is called when production orReplace is exited. +func (s *BaseCqlParserListener) ExitOrReplace(ctx *OrReplaceContext) {} + +// EnterAlterUser is called when production alterUser is entered. +func (s *BaseCqlParserListener) EnterAlterUser(ctx *AlterUserContext) {} + +// ExitAlterUser is called when production alterUser is exited. +func (s *BaseCqlParserListener) ExitAlterUser(ctx *AlterUserContext) {} + +// EnterUserPassword is called when production userPassword is entered. +func (s *BaseCqlParserListener) EnterUserPassword(ctx *UserPasswordContext) {} + +// ExitUserPassword is called when production userPassword is exited. +func (s *BaseCqlParserListener) ExitUserPassword(ctx *UserPasswordContext) {} + +// EnterUserSuperUser is called when production userSuperUser is entered. +func (s *BaseCqlParserListener) EnterUserSuperUser(ctx *UserSuperUserContext) {} + +// ExitUserSuperUser is called when production userSuperUser is exited. +func (s *BaseCqlParserListener) ExitUserSuperUser(ctx *UserSuperUserContext) {} + +// EnterAlterType is called when production alterType is entered. +func (s *BaseCqlParserListener) EnterAlterType(ctx *AlterTypeContext) {} + +// ExitAlterType is called when production alterType is exited. +func (s *BaseCqlParserListener) ExitAlterType(ctx *AlterTypeContext) {} + +// EnterAlterTypeOperation is called when production alterTypeOperation is entered. +func (s *BaseCqlParserListener) EnterAlterTypeOperation(ctx *AlterTypeOperationContext) {} + +// ExitAlterTypeOperation is called when production alterTypeOperation is exited. +func (s *BaseCqlParserListener) ExitAlterTypeOperation(ctx *AlterTypeOperationContext) {} + +// EnterAlterTypeRename is called when production alterTypeRename is entered. +func (s *BaseCqlParserListener) EnterAlterTypeRename(ctx *AlterTypeRenameContext) {} + +// ExitAlterTypeRename is called when production alterTypeRename is exited. +func (s *BaseCqlParserListener) ExitAlterTypeRename(ctx *AlterTypeRenameContext) {} + +// EnterAlterTypeRenameList is called when production alterTypeRenameList is entered. +func (s *BaseCqlParserListener) EnterAlterTypeRenameList(ctx *AlterTypeRenameListContext) {} + +// ExitAlterTypeRenameList is called when production alterTypeRenameList is exited. +func (s *BaseCqlParserListener) ExitAlterTypeRenameList(ctx *AlterTypeRenameListContext) {} + +// EnterAlterTypeRenameItem is called when production alterTypeRenameItem is entered. +func (s *BaseCqlParserListener) EnterAlterTypeRenameItem(ctx *AlterTypeRenameItemContext) {} + +// ExitAlterTypeRenameItem is called when production alterTypeRenameItem is exited. +func (s *BaseCqlParserListener) ExitAlterTypeRenameItem(ctx *AlterTypeRenameItemContext) {} + +// EnterAlterTypeAdd is called when production alterTypeAdd is entered. +func (s *BaseCqlParserListener) EnterAlterTypeAdd(ctx *AlterTypeAddContext) {} + +// ExitAlterTypeAdd is called when production alterTypeAdd is exited. +func (s *BaseCqlParserListener) ExitAlterTypeAdd(ctx *AlterTypeAddContext) {} + +// EnterAlterTypeAlterType is called when production alterTypeAlterType is entered. +func (s *BaseCqlParserListener) EnterAlterTypeAlterType(ctx *AlterTypeAlterTypeContext) {} + +// ExitAlterTypeAlterType is called when production alterTypeAlterType is exited. +func (s *BaseCqlParserListener) ExitAlterTypeAlterType(ctx *AlterTypeAlterTypeContext) {} + +// EnterAlterTable is called when production alterTable is entered. +func (s *BaseCqlParserListener) EnterAlterTable(ctx *AlterTableContext) {} + +// ExitAlterTable is called when production alterTable is exited. +func (s *BaseCqlParserListener) ExitAlterTable(ctx *AlterTableContext) {} + +// EnterAlterTableOperation is called when production alterTableOperation is entered. +func (s *BaseCqlParserListener) EnterAlterTableOperation(ctx *AlterTableOperationContext) {} + +// ExitAlterTableOperation is called when production alterTableOperation is exited. +func (s *BaseCqlParserListener) ExitAlterTableOperation(ctx *AlterTableOperationContext) {} + +// EnterAlterTableWith is called when production alterTableWith is entered. +func (s *BaseCqlParserListener) EnterAlterTableWith(ctx *AlterTableWithContext) {} + +// ExitAlterTableWith is called when production alterTableWith is exited. +func (s *BaseCqlParserListener) ExitAlterTableWith(ctx *AlterTableWithContext) {} + +// EnterAlterTableRename is called when production alterTableRename is entered. +func (s *BaseCqlParserListener) EnterAlterTableRename(ctx *AlterTableRenameContext) {} + +// ExitAlterTableRename is called when production alterTableRename is exited. +func (s *BaseCqlParserListener) ExitAlterTableRename(ctx *AlterTableRenameContext) {} + +// EnterAlterTableDropCompactStorage is called when production alterTableDropCompactStorage is entered. +func (s *BaseCqlParserListener) EnterAlterTableDropCompactStorage(ctx *AlterTableDropCompactStorageContext) { +} + +// ExitAlterTableDropCompactStorage is called when production alterTableDropCompactStorage is exited. +func (s *BaseCqlParserListener) ExitAlterTableDropCompactStorage(ctx *AlterTableDropCompactStorageContext) { +} + +// EnterAlterTableDropColumns is called when production alterTableDropColumns is entered. +func (s *BaseCqlParserListener) EnterAlterTableDropColumns(ctx *AlterTableDropColumnsContext) {} + +// ExitAlterTableDropColumns is called when production alterTableDropColumns is exited. +func (s *BaseCqlParserListener) ExitAlterTableDropColumns(ctx *AlterTableDropColumnsContext) {} + +// EnterAlterTableDropColumnList is called when production alterTableDropColumnList is entered. +func (s *BaseCqlParserListener) EnterAlterTableDropColumnList(ctx *AlterTableDropColumnListContext) {} + +// ExitAlterTableDropColumnList is called when production alterTableDropColumnList is exited. +func (s *BaseCqlParserListener) ExitAlterTableDropColumnList(ctx *AlterTableDropColumnListContext) {} + +// EnterAlterTableAdd is called when production alterTableAdd is entered. +func (s *BaseCqlParserListener) EnterAlterTableAdd(ctx *AlterTableAddContext) {} + +// ExitAlterTableAdd is called when production alterTableAdd is exited. +func (s *BaseCqlParserListener) ExitAlterTableAdd(ctx *AlterTableAddContext) {} + +// EnterAlterTableColumnDefinition is called when production alterTableColumnDefinition is entered. +func (s *BaseCqlParserListener) EnterAlterTableColumnDefinition(ctx *AlterTableColumnDefinitionContext) { +} + +// ExitAlterTableColumnDefinition is called when production alterTableColumnDefinition is exited. +func (s *BaseCqlParserListener) ExitAlterTableColumnDefinition(ctx *AlterTableColumnDefinitionContext) { +} + +// EnterAlterRole is called when production alterRole is entered. +func (s *BaseCqlParserListener) EnterAlterRole(ctx *AlterRoleContext) {} + +// ExitAlterRole is called when production alterRole is exited. +func (s *BaseCqlParserListener) ExitAlterRole(ctx *AlterRoleContext) {} + +// EnterRoleWith is called when production roleWith is entered. +func (s *BaseCqlParserListener) EnterRoleWith(ctx *RoleWithContext) {} + +// ExitRoleWith is called when production roleWith is exited. +func (s *BaseCqlParserListener) ExitRoleWith(ctx *RoleWithContext) {} + +// EnterRoleWithOptions is called when production roleWithOptions is entered. +func (s *BaseCqlParserListener) EnterRoleWithOptions(ctx *RoleWithOptionsContext) {} + +// ExitRoleWithOptions is called when production roleWithOptions is exited. +func (s *BaseCqlParserListener) ExitRoleWithOptions(ctx *RoleWithOptionsContext) {} + +// EnterAlterMaterializedView is called when production alterMaterializedView is entered. +func (s *BaseCqlParserListener) EnterAlterMaterializedView(ctx *AlterMaterializedViewContext) {} + +// ExitAlterMaterializedView is called when production alterMaterializedView is exited. +func (s *BaseCqlParserListener) ExitAlterMaterializedView(ctx *AlterMaterializedViewContext) {} + +// EnterDropUser is called when production dropUser is entered. +func (s *BaseCqlParserListener) EnterDropUser(ctx *DropUserContext) {} + +// ExitDropUser is called when production dropUser is exited. +func (s *BaseCqlParserListener) ExitDropUser(ctx *DropUserContext) {} + +// EnterDropType is called when production dropType is entered. +func (s *BaseCqlParserListener) EnterDropType(ctx *DropTypeContext) {} + +// ExitDropType is called when production dropType is exited. +func (s *BaseCqlParserListener) ExitDropType(ctx *DropTypeContext) {} + +// EnterDropMaterializedView is called when production dropMaterializedView is entered. +func (s *BaseCqlParserListener) EnterDropMaterializedView(ctx *DropMaterializedViewContext) {} + +// ExitDropMaterializedView is called when production dropMaterializedView is exited. +func (s *BaseCqlParserListener) ExitDropMaterializedView(ctx *DropMaterializedViewContext) {} + +// EnterDropAggregate is called when production dropAggregate is entered. +func (s *BaseCqlParserListener) EnterDropAggregate(ctx *DropAggregateContext) {} + +// ExitDropAggregate is called when production dropAggregate is exited. +func (s *BaseCqlParserListener) ExitDropAggregate(ctx *DropAggregateContext) {} + +// EnterDropFunction is called when production dropFunction is entered. +func (s *BaseCqlParserListener) EnterDropFunction(ctx *DropFunctionContext) {} + +// ExitDropFunction is called when production dropFunction is exited. +func (s *BaseCqlParserListener) ExitDropFunction(ctx *DropFunctionContext) {} + +// EnterDropTrigger is called when production dropTrigger is entered. +func (s *BaseCqlParserListener) EnterDropTrigger(ctx *DropTriggerContext) {} + +// ExitDropTrigger is called when production dropTrigger is exited. +func (s *BaseCqlParserListener) ExitDropTrigger(ctx *DropTriggerContext) {} + +// EnterDropRole is called when production dropRole is entered. +func (s *BaseCqlParserListener) EnterDropRole(ctx *DropRoleContext) {} + +// ExitDropRole is called when production dropRole is exited. +func (s *BaseCqlParserListener) ExitDropRole(ctx *DropRoleContext) {} + +// EnterDropTable is called when production dropTable is entered. +func (s *BaseCqlParserListener) EnterDropTable(ctx *DropTableContext) {} + +// ExitDropTable is called when production dropTable is exited. +func (s *BaseCqlParserListener) ExitDropTable(ctx *DropTableContext) {} + +// EnterDropKeyspace is called when production dropKeyspace is entered. +func (s *BaseCqlParserListener) EnterDropKeyspace(ctx *DropKeyspaceContext) {} + +// ExitDropKeyspace is called when production dropKeyspace is exited. +func (s *BaseCqlParserListener) ExitDropKeyspace(ctx *DropKeyspaceContext) {} + +// EnterDropIndex is called when production dropIndex is entered. +func (s *BaseCqlParserListener) EnterDropIndex(ctx *DropIndexContext) {} + +// ExitDropIndex is called when production dropIndex is exited. +func (s *BaseCqlParserListener) ExitDropIndex(ctx *DropIndexContext) {} + +// EnterCreateTable is called when production createTable is entered. +func (s *BaseCqlParserListener) EnterCreateTable(ctx *CreateTableContext) {} + +// ExitCreateTable is called when production createTable is exited. +func (s *BaseCqlParserListener) ExitCreateTable(ctx *CreateTableContext) {} + +// EnterWithElement is called when production withElement is entered. +func (s *BaseCqlParserListener) EnterWithElement(ctx *WithElementContext) {} + +// ExitWithElement is called when production withElement is exited. +func (s *BaseCqlParserListener) ExitWithElement(ctx *WithElementContext) {} + +// EnterTableOptions is called when production tableOptions is entered. +func (s *BaseCqlParserListener) EnterTableOptions(ctx *TableOptionsContext) {} + +// ExitTableOptions is called when production tableOptions is exited. +func (s *BaseCqlParserListener) ExitTableOptions(ctx *TableOptionsContext) {} + +// EnterClusteringOrder is called when production clusteringOrder is entered. +func (s *BaseCqlParserListener) EnterClusteringOrder(ctx *ClusteringOrderContext) {} + +// ExitClusteringOrder is called when production clusteringOrder is exited. +func (s *BaseCqlParserListener) ExitClusteringOrder(ctx *ClusteringOrderContext) {} + +// EnterTableOptionItem is called when production tableOptionItem is entered. +func (s *BaseCqlParserListener) EnterTableOptionItem(ctx *TableOptionItemContext) {} + +// ExitTableOptionItem is called when production tableOptionItem is exited. +func (s *BaseCqlParserListener) ExitTableOptionItem(ctx *TableOptionItemContext) {} + +// EnterTableOptionName is called when production tableOptionName is entered. +func (s *BaseCqlParserListener) EnterTableOptionName(ctx *TableOptionNameContext) {} + +// ExitTableOptionName is called when production tableOptionName is exited. +func (s *BaseCqlParserListener) ExitTableOptionName(ctx *TableOptionNameContext) {} + +// EnterTableOptionValue is called when production tableOptionValue is entered. +func (s *BaseCqlParserListener) EnterTableOptionValue(ctx *TableOptionValueContext) {} + +// ExitTableOptionValue is called when production tableOptionValue is exited. +func (s *BaseCqlParserListener) ExitTableOptionValue(ctx *TableOptionValueContext) {} + +// EnterOptionHash is called when production optionHash is entered. +func (s *BaseCqlParserListener) EnterOptionHash(ctx *OptionHashContext) {} + +// ExitOptionHash is called when production optionHash is exited. +func (s *BaseCqlParserListener) ExitOptionHash(ctx *OptionHashContext) {} + +// EnterOptionHashItem is called when production optionHashItem is entered. +func (s *BaseCqlParserListener) EnterOptionHashItem(ctx *OptionHashItemContext) {} + +// ExitOptionHashItem is called when production optionHashItem is exited. +func (s *BaseCqlParserListener) ExitOptionHashItem(ctx *OptionHashItemContext) {} + +// EnterOptionHashKey is called when production optionHashKey is entered. +func (s *BaseCqlParserListener) EnterOptionHashKey(ctx *OptionHashKeyContext) {} + +// ExitOptionHashKey is called when production optionHashKey is exited. +func (s *BaseCqlParserListener) ExitOptionHashKey(ctx *OptionHashKeyContext) {} + +// EnterOptionHashValue is called when production optionHashValue is entered. +func (s *BaseCqlParserListener) EnterOptionHashValue(ctx *OptionHashValueContext) {} + +// ExitOptionHashValue is called when production optionHashValue is exited. +func (s *BaseCqlParserListener) ExitOptionHashValue(ctx *OptionHashValueContext) {} + +// EnterColumnDefinitionList is called when production columnDefinitionList is entered. +func (s *BaseCqlParserListener) EnterColumnDefinitionList(ctx *ColumnDefinitionListContext) {} + +// ExitColumnDefinitionList is called when production columnDefinitionList is exited. +func (s *BaseCqlParserListener) ExitColumnDefinitionList(ctx *ColumnDefinitionListContext) {} + +// EnterColumnDefinition is called when production columnDefinition is entered. +func (s *BaseCqlParserListener) EnterColumnDefinition(ctx *ColumnDefinitionContext) {} + +// ExitColumnDefinition is called when production columnDefinition is exited. +func (s *BaseCqlParserListener) ExitColumnDefinition(ctx *ColumnDefinitionContext) {} + +// EnterPrimaryKeyColumn is called when production primaryKeyColumn is entered. +func (s *BaseCqlParserListener) EnterPrimaryKeyColumn(ctx *PrimaryKeyColumnContext) {} + +// ExitPrimaryKeyColumn is called when production primaryKeyColumn is exited. +func (s *BaseCqlParserListener) ExitPrimaryKeyColumn(ctx *PrimaryKeyColumnContext) {} + +// EnterPrimaryKeyElement is called when production primaryKeyElement is entered. +func (s *BaseCqlParserListener) EnterPrimaryKeyElement(ctx *PrimaryKeyElementContext) {} + +// ExitPrimaryKeyElement is called when production primaryKeyElement is exited. +func (s *BaseCqlParserListener) ExitPrimaryKeyElement(ctx *PrimaryKeyElementContext) {} + +// EnterPrimaryKeyDefinition is called when production primaryKeyDefinition is entered. +func (s *BaseCqlParserListener) EnterPrimaryKeyDefinition(ctx *PrimaryKeyDefinitionContext) {} + +// ExitPrimaryKeyDefinition is called when production primaryKeyDefinition is exited. +func (s *BaseCqlParserListener) ExitPrimaryKeyDefinition(ctx *PrimaryKeyDefinitionContext) {} + +// EnterSinglePrimaryKey is called when production singlePrimaryKey is entered. +func (s *BaseCqlParserListener) EnterSinglePrimaryKey(ctx *SinglePrimaryKeyContext) {} + +// ExitSinglePrimaryKey is called when production singlePrimaryKey is exited. +func (s *BaseCqlParserListener) ExitSinglePrimaryKey(ctx *SinglePrimaryKeyContext) {} + +// EnterCompoundKey is called when production compoundKey is entered. +func (s *BaseCqlParserListener) EnterCompoundKey(ctx *CompoundKeyContext) {} + +// ExitCompoundKey is called when production compoundKey is exited. +func (s *BaseCqlParserListener) ExitCompoundKey(ctx *CompoundKeyContext) {} + +// EnterCompositeKey is called when production compositeKey is entered. +func (s *BaseCqlParserListener) EnterCompositeKey(ctx *CompositeKeyContext) {} + +// ExitCompositeKey is called when production compositeKey is exited. +func (s *BaseCqlParserListener) ExitCompositeKey(ctx *CompositeKeyContext) {} + +// EnterPartitionKeyList is called when production partitionKeyList is entered. +func (s *BaseCqlParserListener) EnterPartitionKeyList(ctx *PartitionKeyListContext) {} + +// ExitPartitionKeyList is called when production partitionKeyList is exited. +func (s *BaseCqlParserListener) ExitPartitionKeyList(ctx *PartitionKeyListContext) {} + +// EnterClusteringKeyList is called when production clusteringKeyList is entered. +func (s *BaseCqlParserListener) EnterClusteringKeyList(ctx *ClusteringKeyListContext) {} + +// ExitClusteringKeyList is called when production clusteringKeyList is exited. +func (s *BaseCqlParserListener) ExitClusteringKeyList(ctx *ClusteringKeyListContext) {} + +// EnterPartitionKey is called when production partitionKey is entered. +func (s *BaseCqlParserListener) EnterPartitionKey(ctx *PartitionKeyContext) {} + +// ExitPartitionKey is called when production partitionKey is exited. +func (s *BaseCqlParserListener) ExitPartitionKey(ctx *PartitionKeyContext) {} + +// EnterClusteringKey is called when production clusteringKey is entered. +func (s *BaseCqlParserListener) EnterClusteringKey(ctx *ClusteringKeyContext) {} + +// ExitClusteringKey is called when production clusteringKey is exited. +func (s *BaseCqlParserListener) ExitClusteringKey(ctx *ClusteringKeyContext) {} + +// EnterApplyBatch is called when production applyBatch is entered. +func (s *BaseCqlParserListener) EnterApplyBatch(ctx *ApplyBatchContext) {} + +// ExitApplyBatch is called when production applyBatch is exited. +func (s *BaseCqlParserListener) ExitApplyBatch(ctx *ApplyBatchContext) {} + +// EnterBeginBatch is called when production beginBatch is entered. +func (s *BaseCqlParserListener) EnterBeginBatch(ctx *BeginBatchContext) {} + +// ExitBeginBatch is called when production beginBatch is exited. +func (s *BaseCqlParserListener) ExitBeginBatch(ctx *BeginBatchContext) {} + +// EnterBatchType is called when production batchType is entered. +func (s *BaseCqlParserListener) EnterBatchType(ctx *BatchTypeContext) {} + +// ExitBatchType is called when production batchType is exited. +func (s *BaseCqlParserListener) ExitBatchType(ctx *BatchTypeContext) {} + +// EnterAlterKeyspace is called when production alterKeyspace is entered. +func (s *BaseCqlParserListener) EnterAlterKeyspace(ctx *AlterKeyspaceContext) {} + +// ExitAlterKeyspace is called when production alterKeyspace is exited. +func (s *BaseCqlParserListener) ExitAlterKeyspace(ctx *AlterKeyspaceContext) {} + +// EnterReplicationList is called when production replicationList is entered. +func (s *BaseCqlParserListener) EnterReplicationList(ctx *ReplicationListContext) {} + +// ExitReplicationList is called when production replicationList is exited. +func (s *BaseCqlParserListener) ExitReplicationList(ctx *ReplicationListContext) {} + +// EnterReplicationListItem is called when production replicationListItem is entered. +func (s *BaseCqlParserListener) EnterReplicationListItem(ctx *ReplicationListItemContext) {} + +// ExitReplicationListItem is called when production replicationListItem is exited. +func (s *BaseCqlParserListener) ExitReplicationListItem(ctx *ReplicationListItemContext) {} + +// EnterDurableWrites is called when production durableWrites is entered. +func (s *BaseCqlParserListener) EnterDurableWrites(ctx *DurableWritesContext) {} + +// ExitDurableWrites is called when production durableWrites is exited. +func (s *BaseCqlParserListener) ExitDurableWrites(ctx *DurableWritesContext) {} + +// EnterUse_ is called when production use_ is entered. +func (s *BaseCqlParserListener) EnterUse_(ctx *Use_Context) {} + +// ExitUse_ is called when production use_ is exited. +func (s *BaseCqlParserListener) ExitUse_(ctx *Use_Context) {} + +// EnterTruncate is called when production truncate is entered. +func (s *BaseCqlParserListener) EnterTruncate(ctx *TruncateContext) {} + +// ExitTruncate is called when production truncate is exited. +func (s *BaseCqlParserListener) ExitTruncate(ctx *TruncateContext) {} + +// EnterCreateIndex is called when production createIndex is entered. +func (s *BaseCqlParserListener) EnterCreateIndex(ctx *CreateIndexContext) {} + +// ExitCreateIndex is called when production createIndex is exited. +func (s *BaseCqlParserListener) ExitCreateIndex(ctx *CreateIndexContext) {} + +// EnterIndexName is called when production indexName is entered. +func (s *BaseCqlParserListener) EnterIndexName(ctx *IndexNameContext) {} + +// ExitIndexName is called when production indexName is exited. +func (s *BaseCqlParserListener) ExitIndexName(ctx *IndexNameContext) {} + +// EnterIndexColumnSpec is called when production indexColumnSpec is entered. +func (s *BaseCqlParserListener) EnterIndexColumnSpec(ctx *IndexColumnSpecContext) {} + +// ExitIndexColumnSpec is called when production indexColumnSpec is exited. +func (s *BaseCqlParserListener) ExitIndexColumnSpec(ctx *IndexColumnSpecContext) {} + +// EnterIndexKeysSpec is called when production indexKeysSpec is entered. +func (s *BaseCqlParserListener) EnterIndexKeysSpec(ctx *IndexKeysSpecContext) {} + +// ExitIndexKeysSpec is called when production indexKeysSpec is exited. +func (s *BaseCqlParserListener) ExitIndexKeysSpec(ctx *IndexKeysSpecContext) {} + +// EnterIndexEntriesSSpec is called when production indexEntriesSSpec is entered. +func (s *BaseCqlParserListener) EnterIndexEntriesSSpec(ctx *IndexEntriesSSpecContext) {} + +// ExitIndexEntriesSSpec is called when production indexEntriesSSpec is exited. +func (s *BaseCqlParserListener) ExitIndexEntriesSSpec(ctx *IndexEntriesSSpecContext) {} + +// EnterIndexFullSpec is called when production indexFullSpec is entered. +func (s *BaseCqlParserListener) EnterIndexFullSpec(ctx *IndexFullSpecContext) {} + +// ExitIndexFullSpec is called when production indexFullSpec is exited. +func (s *BaseCqlParserListener) ExitIndexFullSpec(ctx *IndexFullSpecContext) {} + +// EnterDelete_ is called when production delete_ is entered. +func (s *BaseCqlParserListener) EnterDelete_(ctx *Delete_Context) {} + +// ExitDelete_ is called when production delete_ is exited. +func (s *BaseCqlParserListener) ExitDelete_(ctx *Delete_Context) {} + +// EnterDeleteColumnList is called when production deleteColumnList is entered. +func (s *BaseCqlParserListener) EnterDeleteColumnList(ctx *DeleteColumnListContext) {} + +// ExitDeleteColumnList is called when production deleteColumnList is exited. +func (s *BaseCqlParserListener) ExitDeleteColumnList(ctx *DeleteColumnListContext) {} + +// EnterDeleteColumnItem is called when production deleteColumnItem is entered. +func (s *BaseCqlParserListener) EnterDeleteColumnItem(ctx *DeleteColumnItemContext) {} + +// ExitDeleteColumnItem is called when production deleteColumnItem is exited. +func (s *BaseCqlParserListener) ExitDeleteColumnItem(ctx *DeleteColumnItemContext) {} + +// EnterUpdate is called when production update is entered. +func (s *BaseCqlParserListener) EnterUpdate(ctx *UpdateContext) {} + +// ExitUpdate is called when production update is exited. +func (s *BaseCqlParserListener) ExitUpdate(ctx *UpdateContext) {} + +// EnterIfSpec is called when production ifSpec is entered. +func (s *BaseCqlParserListener) EnterIfSpec(ctx *IfSpecContext) {} + +// ExitIfSpec is called when production ifSpec is exited. +func (s *BaseCqlParserListener) ExitIfSpec(ctx *IfSpecContext) {} + +// EnterIfConditionList is called when production ifConditionList is entered. +func (s *BaseCqlParserListener) EnterIfConditionList(ctx *IfConditionListContext) {} + +// ExitIfConditionList is called when production ifConditionList is exited. +func (s *BaseCqlParserListener) ExitIfConditionList(ctx *IfConditionListContext) {} + +// EnterIfCondition is called when production ifCondition is entered. +func (s *BaseCqlParserListener) EnterIfCondition(ctx *IfConditionContext) {} + +// ExitIfCondition is called when production ifCondition is exited. +func (s *BaseCqlParserListener) ExitIfCondition(ctx *IfConditionContext) {} + +// EnterAssignments is called when production assignments is entered. +func (s *BaseCqlParserListener) EnterAssignments(ctx *AssignmentsContext) {} + +// ExitAssignments is called when production assignments is exited. +func (s *BaseCqlParserListener) ExitAssignments(ctx *AssignmentsContext) {} + +// EnterAssignmentElement is called when production assignmentElement is entered. +func (s *BaseCqlParserListener) EnterAssignmentElement(ctx *AssignmentElementContext) {} + +// ExitAssignmentElement is called when production assignmentElement is exited. +func (s *BaseCqlParserListener) ExitAssignmentElement(ctx *AssignmentElementContext) {} + +// EnterAssignmentSet is called when production assignmentSet is entered. +func (s *BaseCqlParserListener) EnterAssignmentSet(ctx *AssignmentSetContext) {} + +// ExitAssignmentSet is called when production assignmentSet is exited. +func (s *BaseCqlParserListener) ExitAssignmentSet(ctx *AssignmentSetContext) {} + +// EnterAssignmentMap is called when production assignmentMap is entered. +func (s *BaseCqlParserListener) EnterAssignmentMap(ctx *AssignmentMapContext) {} + +// ExitAssignmentMap is called when production assignmentMap is exited. +func (s *BaseCqlParserListener) ExitAssignmentMap(ctx *AssignmentMapContext) {} + +// EnterAssignmentList is called when production assignmentList is entered. +func (s *BaseCqlParserListener) EnterAssignmentList(ctx *AssignmentListContext) {} + +// ExitAssignmentList is called when production assignmentList is exited. +func (s *BaseCqlParserListener) ExitAssignmentList(ctx *AssignmentListContext) {} + +// EnterAssignmentTuple is called when production assignmentTuple is entered. +func (s *BaseCqlParserListener) EnterAssignmentTuple(ctx *AssignmentTupleContext) {} + +// ExitAssignmentTuple is called when production assignmentTuple is exited. +func (s *BaseCqlParserListener) ExitAssignmentTuple(ctx *AssignmentTupleContext) {} + +// EnterInsert is called when production insert is entered. +func (s *BaseCqlParserListener) EnterInsert(ctx *InsertContext) {} + +// ExitInsert is called when production insert is exited. +func (s *BaseCqlParserListener) ExitInsert(ctx *InsertContext) {} + +// EnterUsingTtlTimestamp is called when production usingTtlTimestamp is entered. +func (s *BaseCqlParserListener) EnterUsingTtlTimestamp(ctx *UsingTtlTimestampContext) {} + +// ExitUsingTtlTimestamp is called when production usingTtlTimestamp is exited. +func (s *BaseCqlParserListener) ExitUsingTtlTimestamp(ctx *UsingTtlTimestampContext) {} + +// EnterTimestamp is called when production timestamp is entered. +func (s *BaseCqlParserListener) EnterTimestamp(ctx *TimestampContext) {} + +// ExitTimestamp is called when production timestamp is exited. +func (s *BaseCqlParserListener) ExitTimestamp(ctx *TimestampContext) {} + +// EnterTtl is called when production ttl is entered. +func (s *BaseCqlParserListener) EnterTtl(ctx *TtlContext) {} + +// ExitTtl is called when production ttl is exited. +func (s *BaseCqlParserListener) ExitTtl(ctx *TtlContext) {} + +// EnterUsingTimestampSpec is called when production usingTimestampSpec is entered. +func (s *BaseCqlParserListener) EnterUsingTimestampSpec(ctx *UsingTimestampSpecContext) {} + +// ExitUsingTimestampSpec is called when production usingTimestampSpec is exited. +func (s *BaseCqlParserListener) ExitUsingTimestampSpec(ctx *UsingTimestampSpecContext) {} + +// EnterIfNotExist is called when production ifNotExist is entered. +func (s *BaseCqlParserListener) EnterIfNotExist(ctx *IfNotExistContext) {} + +// ExitIfNotExist is called when production ifNotExist is exited. +func (s *BaseCqlParserListener) ExitIfNotExist(ctx *IfNotExistContext) {} + +// EnterIfExist is called when production ifExist is entered. +func (s *BaseCqlParserListener) EnterIfExist(ctx *IfExistContext) {} + +// ExitIfExist is called when production ifExist is exited. +func (s *BaseCqlParserListener) ExitIfExist(ctx *IfExistContext) {} + +// EnterInsertValuesSpec is called when production insertValuesSpec is entered. +func (s *BaseCqlParserListener) EnterInsertValuesSpec(ctx *InsertValuesSpecContext) {} + +// ExitInsertValuesSpec is called when production insertValuesSpec is exited. +func (s *BaseCqlParserListener) ExitInsertValuesSpec(ctx *InsertValuesSpecContext) {} + +// EnterInsertColumnSpec is called when production insertColumnSpec is entered. +func (s *BaseCqlParserListener) EnterInsertColumnSpec(ctx *InsertColumnSpecContext) {} + +// ExitInsertColumnSpec is called when production insertColumnSpec is exited. +func (s *BaseCqlParserListener) ExitInsertColumnSpec(ctx *InsertColumnSpecContext) {} + +// EnterColumnList is called when production columnList is entered. +func (s *BaseCqlParserListener) EnterColumnList(ctx *ColumnListContext) {} + +// ExitColumnList is called when production columnList is exited. +func (s *BaseCqlParserListener) ExitColumnList(ctx *ColumnListContext) {} + +// EnterExpressionList is called when production expressionList is entered. +func (s *BaseCqlParserListener) EnterExpressionList(ctx *ExpressionListContext) {} + +// ExitExpressionList is called when production expressionList is exited. +func (s *BaseCqlParserListener) ExitExpressionList(ctx *ExpressionListContext) {} + +// EnterExpression is called when production expression is entered. +func (s *BaseCqlParserListener) EnterExpression(ctx *ExpressionContext) {} + +// ExitExpression is called when production expression is exited. +func (s *BaseCqlParserListener) ExitExpression(ctx *ExpressionContext) {} + +// EnterSelect_ is called when production select_ is entered. +func (s *BaseCqlParserListener) EnterSelect_(ctx *Select_Context) {} + +// ExitSelect_ is called when production select_ is exited. +func (s *BaseCqlParserListener) ExitSelect_(ctx *Select_Context) {} + +// EnterAllowFilteringSpec is called when production allowFilteringSpec is entered. +func (s *BaseCqlParserListener) EnterAllowFilteringSpec(ctx *AllowFilteringSpecContext) {} + +// ExitAllowFilteringSpec is called when production allowFilteringSpec is exited. +func (s *BaseCqlParserListener) ExitAllowFilteringSpec(ctx *AllowFilteringSpecContext) {} + +// EnterLimitSpec is called when production limitSpec is entered. +func (s *BaseCqlParserListener) EnterLimitSpec(ctx *LimitSpecContext) {} + +// ExitLimitSpec is called when production limitSpec is exited. +func (s *BaseCqlParserListener) ExitLimitSpec(ctx *LimitSpecContext) {} + +// EnterFromSpec is called when production fromSpec is entered. +func (s *BaseCqlParserListener) EnterFromSpec(ctx *FromSpecContext) {} + +// ExitFromSpec is called when production fromSpec is exited. +func (s *BaseCqlParserListener) ExitFromSpec(ctx *FromSpecContext) {} + +// EnterFromSpecElement is called when production fromSpecElement is entered. +func (s *BaseCqlParserListener) EnterFromSpecElement(ctx *FromSpecElementContext) {} + +// ExitFromSpecElement is called when production fromSpecElement is exited. +func (s *BaseCqlParserListener) ExitFromSpecElement(ctx *FromSpecElementContext) {} + +// EnterOrderSpec is called when production orderSpec is entered. +func (s *BaseCqlParserListener) EnterOrderSpec(ctx *OrderSpecContext) {} + +// ExitOrderSpec is called when production orderSpec is exited. +func (s *BaseCqlParserListener) ExitOrderSpec(ctx *OrderSpecContext) {} + +// EnterOrderSpecElement is called when production orderSpecElement is entered. +func (s *BaseCqlParserListener) EnterOrderSpecElement(ctx *OrderSpecElementContext) {} + +// ExitOrderSpecElement is called when production orderSpecElement is exited. +func (s *BaseCqlParserListener) ExitOrderSpecElement(ctx *OrderSpecElementContext) {} + +// EnterWhereSpec is called when production whereSpec is entered. +func (s *BaseCqlParserListener) EnterWhereSpec(ctx *WhereSpecContext) {} + +// ExitWhereSpec is called when production whereSpec is exited. +func (s *BaseCqlParserListener) ExitWhereSpec(ctx *WhereSpecContext) {} + +// EnterDistinctSpec is called when production distinctSpec is entered. +func (s *BaseCqlParserListener) EnterDistinctSpec(ctx *DistinctSpecContext) {} + +// ExitDistinctSpec is called when production distinctSpec is exited. +func (s *BaseCqlParserListener) ExitDistinctSpec(ctx *DistinctSpecContext) {} + +// EnterSelectElements is called when production selectElements is entered. +func (s *BaseCqlParserListener) EnterSelectElements(ctx *SelectElementsContext) {} + +// ExitSelectElements is called when production selectElements is exited. +func (s *BaseCqlParserListener) ExitSelectElements(ctx *SelectElementsContext) {} + +// EnterSelectElement is called when production selectElement is entered. +func (s *BaseCqlParserListener) EnterSelectElement(ctx *SelectElementContext) {} + +// ExitSelectElement is called when production selectElement is exited. +func (s *BaseCqlParserListener) ExitSelectElement(ctx *SelectElementContext) {} + +// EnterRelationElements is called when production relationElements is entered. +func (s *BaseCqlParserListener) EnterRelationElements(ctx *RelationElementsContext) {} + +// ExitRelationElements is called when production relationElements is exited. +func (s *BaseCqlParserListener) ExitRelationElements(ctx *RelationElementsContext) {} + +// EnterRelationElement is called when production relationElement is entered. +func (s *BaseCqlParserListener) EnterRelationElement(ctx *RelationElementContext) {} + +// ExitRelationElement is called when production relationElement is exited. +func (s *BaseCqlParserListener) ExitRelationElement(ctx *RelationElementContext) {} + +// EnterRelalationContains is called when production relalationContains is entered. +func (s *BaseCqlParserListener) EnterRelalationContains(ctx *RelalationContainsContext) {} + +// ExitRelalationContains is called when production relalationContains is exited. +func (s *BaseCqlParserListener) ExitRelalationContains(ctx *RelalationContainsContext) {} + +// EnterRelalationContainsKey is called when production relalationContainsKey is entered. +func (s *BaseCqlParserListener) EnterRelalationContainsKey(ctx *RelalationContainsKeyContext) {} + +// ExitRelalationContainsKey is called when production relalationContainsKey is exited. +func (s *BaseCqlParserListener) ExitRelalationContainsKey(ctx *RelalationContainsKeyContext) {} + +// EnterFunctionCall is called when production functionCall is entered. +func (s *BaseCqlParserListener) EnterFunctionCall(ctx *FunctionCallContext) {} + +// ExitFunctionCall is called when production functionCall is exited. +func (s *BaseCqlParserListener) ExitFunctionCall(ctx *FunctionCallContext) {} + +// EnterFunctionArgs is called when production functionArgs is entered. +func (s *BaseCqlParserListener) EnterFunctionArgs(ctx *FunctionArgsContext) {} + +// ExitFunctionArgs is called when production functionArgs is exited. +func (s *BaseCqlParserListener) ExitFunctionArgs(ctx *FunctionArgsContext) {} + +// EnterConstant is called when production constant is entered. +func (s *BaseCqlParserListener) EnterConstant(ctx *ConstantContext) {} + +// ExitConstant is called when production constant is exited. +func (s *BaseCqlParserListener) ExitConstant(ctx *ConstantContext) {} + +// EnterDecimalLiteral is called when production decimalLiteral is entered. +func (s *BaseCqlParserListener) EnterDecimalLiteral(ctx *DecimalLiteralContext) {} + +// ExitDecimalLiteral is called when production decimalLiteral is exited. +func (s *BaseCqlParserListener) ExitDecimalLiteral(ctx *DecimalLiteralContext) {} + +// EnterFloatLiteral is called when production floatLiteral is entered. +func (s *BaseCqlParserListener) EnterFloatLiteral(ctx *FloatLiteralContext) {} + +// ExitFloatLiteral is called when production floatLiteral is exited. +func (s *BaseCqlParserListener) ExitFloatLiteral(ctx *FloatLiteralContext) {} + +// EnterStringLiteral is called when production stringLiteral is entered. +func (s *BaseCqlParserListener) EnterStringLiteral(ctx *StringLiteralContext) {} + +// ExitStringLiteral is called when production stringLiteral is exited. +func (s *BaseCqlParserListener) ExitStringLiteral(ctx *StringLiteralContext) {} + +// EnterBooleanLiteral is called when production booleanLiteral is entered. +func (s *BaseCqlParserListener) EnterBooleanLiteral(ctx *BooleanLiteralContext) {} + +// ExitBooleanLiteral is called when production booleanLiteral is exited. +func (s *BaseCqlParserListener) ExitBooleanLiteral(ctx *BooleanLiteralContext) {} + +// EnterHexadecimalLiteral is called when production hexadecimalLiteral is entered. +func (s *BaseCqlParserListener) EnterHexadecimalLiteral(ctx *HexadecimalLiteralContext) {} + +// ExitHexadecimalLiteral is called when production hexadecimalLiteral is exited. +func (s *BaseCqlParserListener) ExitHexadecimalLiteral(ctx *HexadecimalLiteralContext) {} + +// EnterKeyspace is called when production keyspace is entered. +func (s *BaseCqlParserListener) EnterKeyspace(ctx *KeyspaceContext) {} + +// ExitKeyspace is called when production keyspace is exited. +func (s *BaseCqlParserListener) ExitKeyspace(ctx *KeyspaceContext) {} + +// EnterTable is called when production table is entered. +func (s *BaseCqlParserListener) EnterTable(ctx *TableContext) {} + +// ExitTable is called when production table is exited. +func (s *BaseCqlParserListener) ExitTable(ctx *TableContext) {} + +// EnterColumn is called when production column is entered. +func (s *BaseCqlParserListener) EnterColumn(ctx *ColumnContext) {} + +// ExitColumn is called when production column is exited. +func (s *BaseCqlParserListener) ExitColumn(ctx *ColumnContext) {} + +// EnterDataType is called when production dataType is entered. +func (s *BaseCqlParserListener) EnterDataType(ctx *DataTypeContext) {} + +// ExitDataType is called when production dataType is exited. +func (s *BaseCqlParserListener) ExitDataType(ctx *DataTypeContext) {} + +// EnterDataTypeName is called when production dataTypeName is entered. +func (s *BaseCqlParserListener) EnterDataTypeName(ctx *DataTypeNameContext) {} + +// ExitDataTypeName is called when production dataTypeName is exited. +func (s *BaseCqlParserListener) ExitDataTypeName(ctx *DataTypeNameContext) {} + +// EnterDataTypeDefinition is called when production dataTypeDefinition is entered. +func (s *BaseCqlParserListener) EnterDataTypeDefinition(ctx *DataTypeDefinitionContext) {} + +// ExitDataTypeDefinition is called when production dataTypeDefinition is exited. +func (s *BaseCqlParserListener) ExitDataTypeDefinition(ctx *DataTypeDefinitionContext) {} + +// EnterOrderDirection is called when production orderDirection is entered. +func (s *BaseCqlParserListener) EnterOrderDirection(ctx *OrderDirectionContext) {} + +// ExitOrderDirection is called when production orderDirection is exited. +func (s *BaseCqlParserListener) ExitOrderDirection(ctx *OrderDirectionContext) {} + +// EnterRole is called when production role is entered. +func (s *BaseCqlParserListener) EnterRole(ctx *RoleContext) {} + +// ExitRole is called when production role is exited. +func (s *BaseCqlParserListener) ExitRole(ctx *RoleContext) {} + +// EnterTrigger is called when production trigger is entered. +func (s *BaseCqlParserListener) EnterTrigger(ctx *TriggerContext) {} + +// ExitTrigger is called when production trigger is exited. +func (s *BaseCqlParserListener) ExitTrigger(ctx *TriggerContext) {} + +// EnterTriggerClass is called when production triggerClass is entered. +func (s *BaseCqlParserListener) EnterTriggerClass(ctx *TriggerClassContext) {} + +// ExitTriggerClass is called when production triggerClass is exited. +func (s *BaseCqlParserListener) ExitTriggerClass(ctx *TriggerClassContext) {} + +// EnterMaterializedView is called when production materializedView is entered. +func (s *BaseCqlParserListener) EnterMaterializedView(ctx *MaterializedViewContext) {} + +// ExitMaterializedView is called when production materializedView is exited. +func (s *BaseCqlParserListener) ExitMaterializedView(ctx *MaterializedViewContext) {} + +// EnterType_ is called when production type_ is entered. +func (s *BaseCqlParserListener) EnterType_(ctx *Type_Context) {} + +// ExitType_ is called when production type_ is exited. +func (s *BaseCqlParserListener) ExitType_(ctx *Type_Context) {} + +// EnterAggregate is called when production aggregate is entered. +func (s *BaseCqlParserListener) EnterAggregate(ctx *AggregateContext) {} + +// ExitAggregate is called when production aggregate is exited. +func (s *BaseCqlParserListener) ExitAggregate(ctx *AggregateContext) {} + +// EnterFunction_ is called when production function_ is entered. +func (s *BaseCqlParserListener) EnterFunction_(ctx *Function_Context) {} + +// ExitFunction_ is called when production function_ is exited. +func (s *BaseCqlParserListener) ExitFunction_(ctx *Function_Context) {} + +// EnterLanguage is called when production language is entered. +func (s *BaseCqlParserListener) EnterLanguage(ctx *LanguageContext) {} + +// ExitLanguage is called when production language is exited. +func (s *BaseCqlParserListener) ExitLanguage(ctx *LanguageContext) {} + +// EnterUser is called when production user is entered. +func (s *BaseCqlParserListener) EnterUser(ctx *UserContext) {} + +// ExitUser is called when production user is exited. +func (s *BaseCqlParserListener) ExitUser(ctx *UserContext) {} + +// EnterPassword is called when production password is entered. +func (s *BaseCqlParserListener) EnterPassword(ctx *PasswordContext) {} + +// ExitPassword is called when production password is exited. +func (s *BaseCqlParserListener) ExitPassword(ctx *PasswordContext) {} + +// EnterHashKey is called when production hashKey is entered. +func (s *BaseCqlParserListener) EnterHashKey(ctx *HashKeyContext) {} + +// ExitHashKey is called when production hashKey is exited. +func (s *BaseCqlParserListener) ExitHashKey(ctx *HashKeyContext) {} + +// EnterParam is called when production param is entered. +func (s *BaseCqlParserListener) EnterParam(ctx *ParamContext) {} + +// ExitParam is called when production param is exited. +func (s *BaseCqlParserListener) ExitParam(ctx *ParamContext) {} + +// EnterParamName is called when production paramName is entered. +func (s *BaseCqlParserListener) EnterParamName(ctx *ParamNameContext) {} + +// ExitParamName is called when production paramName is exited. +func (s *BaseCqlParserListener) ExitParamName(ctx *ParamNameContext) {} + +// EnterKwAdd is called when production kwAdd is entered. +func (s *BaseCqlParserListener) EnterKwAdd(ctx *KwAddContext) {} + +// ExitKwAdd is called when production kwAdd is exited. +func (s *BaseCqlParserListener) ExitKwAdd(ctx *KwAddContext) {} + +// EnterKwAggregate is called when production kwAggregate is entered. +func (s *BaseCqlParserListener) EnterKwAggregate(ctx *KwAggregateContext) {} + +// ExitKwAggregate is called when production kwAggregate is exited. +func (s *BaseCqlParserListener) ExitKwAggregate(ctx *KwAggregateContext) {} + +// EnterKwAll is called when production kwAll is entered. +func (s *BaseCqlParserListener) EnterKwAll(ctx *KwAllContext) {} + +// ExitKwAll is called when production kwAll is exited. +func (s *BaseCqlParserListener) ExitKwAll(ctx *KwAllContext) {} + +// EnterKwAllPermissions is called when production kwAllPermissions is entered. +func (s *BaseCqlParserListener) EnterKwAllPermissions(ctx *KwAllPermissionsContext) {} + +// ExitKwAllPermissions is called when production kwAllPermissions is exited. +func (s *BaseCqlParserListener) ExitKwAllPermissions(ctx *KwAllPermissionsContext) {} + +// EnterKwAllow is called when production kwAllow is entered. +func (s *BaseCqlParserListener) EnterKwAllow(ctx *KwAllowContext) {} + +// ExitKwAllow is called when production kwAllow is exited. +func (s *BaseCqlParserListener) ExitKwAllow(ctx *KwAllowContext) {} + +// EnterKwAlter is called when production kwAlter is entered. +func (s *BaseCqlParserListener) EnterKwAlter(ctx *KwAlterContext) {} + +// ExitKwAlter is called when production kwAlter is exited. +func (s *BaseCqlParserListener) ExitKwAlter(ctx *KwAlterContext) {} + +// EnterKwAnd is called when production kwAnd is entered. +func (s *BaseCqlParserListener) EnterKwAnd(ctx *KwAndContext) {} + +// ExitKwAnd is called when production kwAnd is exited. +func (s *BaseCqlParserListener) ExitKwAnd(ctx *KwAndContext) {} + +// EnterKwApply is called when production kwApply is entered. +func (s *BaseCqlParserListener) EnterKwApply(ctx *KwApplyContext) {} + +// ExitKwApply is called when production kwApply is exited. +func (s *BaseCqlParserListener) ExitKwApply(ctx *KwApplyContext) {} + +// EnterKwAs is called when production kwAs is entered. +func (s *BaseCqlParserListener) EnterKwAs(ctx *KwAsContext) {} + +// ExitKwAs is called when production kwAs is exited. +func (s *BaseCqlParserListener) ExitKwAs(ctx *KwAsContext) {} + +// EnterKwAsc is called when production kwAsc is entered. +func (s *BaseCqlParserListener) EnterKwAsc(ctx *KwAscContext) {} + +// ExitKwAsc is called when production kwAsc is exited. +func (s *BaseCqlParserListener) ExitKwAsc(ctx *KwAscContext) {} + +// EnterKwAuthorize is called when production kwAuthorize is entered. +func (s *BaseCqlParserListener) EnterKwAuthorize(ctx *KwAuthorizeContext) {} + +// ExitKwAuthorize is called when production kwAuthorize is exited. +func (s *BaseCqlParserListener) ExitKwAuthorize(ctx *KwAuthorizeContext) {} + +// EnterKwBatch is called when production kwBatch is entered. +func (s *BaseCqlParserListener) EnterKwBatch(ctx *KwBatchContext) {} + +// ExitKwBatch is called when production kwBatch is exited. +func (s *BaseCqlParserListener) ExitKwBatch(ctx *KwBatchContext) {} + +// EnterKwBegin is called when production kwBegin is entered. +func (s *BaseCqlParserListener) EnterKwBegin(ctx *KwBeginContext) {} + +// ExitKwBegin is called when production kwBegin is exited. +func (s *BaseCqlParserListener) ExitKwBegin(ctx *KwBeginContext) {} + +// EnterKwBy is called when production kwBy is entered. +func (s *BaseCqlParserListener) EnterKwBy(ctx *KwByContext) {} + +// ExitKwBy is called when production kwBy is exited. +func (s *BaseCqlParserListener) ExitKwBy(ctx *KwByContext) {} + +// EnterKwCalled is called when production kwCalled is entered. +func (s *BaseCqlParserListener) EnterKwCalled(ctx *KwCalledContext) {} + +// ExitKwCalled is called when production kwCalled is exited. +func (s *BaseCqlParserListener) ExitKwCalled(ctx *KwCalledContext) {} + +// EnterKwClustering is called when production kwClustering is entered. +func (s *BaseCqlParserListener) EnterKwClustering(ctx *KwClusteringContext) {} + +// ExitKwClustering is called when production kwClustering is exited. +func (s *BaseCqlParserListener) ExitKwClustering(ctx *KwClusteringContext) {} + +// EnterKwCompact is called when production kwCompact is entered. +func (s *BaseCqlParserListener) EnterKwCompact(ctx *KwCompactContext) {} + +// ExitKwCompact is called when production kwCompact is exited. +func (s *BaseCqlParserListener) ExitKwCompact(ctx *KwCompactContext) {} + +// EnterKwContains is called when production kwContains is entered. +func (s *BaseCqlParserListener) EnterKwContains(ctx *KwContainsContext) {} + +// ExitKwContains is called when production kwContains is exited. +func (s *BaseCqlParserListener) ExitKwContains(ctx *KwContainsContext) {} + +// EnterKwCreate is called when production kwCreate is entered. +func (s *BaseCqlParserListener) EnterKwCreate(ctx *KwCreateContext) {} + +// ExitKwCreate is called when production kwCreate is exited. +func (s *BaseCqlParserListener) ExitKwCreate(ctx *KwCreateContext) {} + +// EnterKwDelete is called when production kwDelete is entered. +func (s *BaseCqlParserListener) EnterKwDelete(ctx *KwDeleteContext) {} + +// ExitKwDelete is called when production kwDelete is exited. +func (s *BaseCqlParserListener) ExitKwDelete(ctx *KwDeleteContext) {} + +// EnterKwDesc is called when production kwDesc is entered. +func (s *BaseCqlParserListener) EnterKwDesc(ctx *KwDescContext) {} + +// ExitKwDesc is called when production kwDesc is exited. +func (s *BaseCqlParserListener) ExitKwDesc(ctx *KwDescContext) {} + +// EnterKwDescibe is called when production kwDescibe is entered. +func (s *BaseCqlParserListener) EnterKwDescibe(ctx *KwDescibeContext) {} + +// ExitKwDescibe is called when production kwDescibe is exited. +func (s *BaseCqlParserListener) ExitKwDescibe(ctx *KwDescibeContext) {} + +// EnterKwDistinct is called when production kwDistinct is entered. +func (s *BaseCqlParserListener) EnterKwDistinct(ctx *KwDistinctContext) {} + +// ExitKwDistinct is called when production kwDistinct is exited. +func (s *BaseCqlParserListener) ExitKwDistinct(ctx *KwDistinctContext) {} + +// EnterKwDrop is called when production kwDrop is entered. +func (s *BaseCqlParserListener) EnterKwDrop(ctx *KwDropContext) {} + +// ExitKwDrop is called when production kwDrop is exited. +func (s *BaseCqlParserListener) ExitKwDrop(ctx *KwDropContext) {} + +// EnterKwDurableWrites is called when production kwDurableWrites is entered. +func (s *BaseCqlParserListener) EnterKwDurableWrites(ctx *KwDurableWritesContext) {} + +// ExitKwDurableWrites is called when production kwDurableWrites is exited. +func (s *BaseCqlParserListener) ExitKwDurableWrites(ctx *KwDurableWritesContext) {} + +// EnterKwEntries is called when production kwEntries is entered. +func (s *BaseCqlParserListener) EnterKwEntries(ctx *KwEntriesContext) {} + +// ExitKwEntries is called when production kwEntries is exited. +func (s *BaseCqlParserListener) ExitKwEntries(ctx *KwEntriesContext) {} + +// EnterKwExecute is called when production kwExecute is entered. +func (s *BaseCqlParserListener) EnterKwExecute(ctx *KwExecuteContext) {} + +// ExitKwExecute is called when production kwExecute is exited. +func (s *BaseCqlParserListener) ExitKwExecute(ctx *KwExecuteContext) {} + +// EnterKwExists is called when production kwExists is entered. +func (s *BaseCqlParserListener) EnterKwExists(ctx *KwExistsContext) {} + +// ExitKwExists is called when production kwExists is exited. +func (s *BaseCqlParserListener) ExitKwExists(ctx *KwExistsContext) {} + +// EnterKwFiltering is called when production kwFiltering is entered. +func (s *BaseCqlParserListener) EnterKwFiltering(ctx *KwFilteringContext) {} + +// ExitKwFiltering is called when production kwFiltering is exited. +func (s *BaseCqlParserListener) ExitKwFiltering(ctx *KwFilteringContext) {} + +// EnterKwFinalfunc is called when production kwFinalfunc is entered. +func (s *BaseCqlParserListener) EnterKwFinalfunc(ctx *KwFinalfuncContext) {} + +// ExitKwFinalfunc is called when production kwFinalfunc is exited. +func (s *BaseCqlParserListener) ExitKwFinalfunc(ctx *KwFinalfuncContext) {} + +// EnterKwFrom is called when production kwFrom is entered. +func (s *BaseCqlParserListener) EnterKwFrom(ctx *KwFromContext) {} + +// ExitKwFrom is called when production kwFrom is exited. +func (s *BaseCqlParserListener) ExitKwFrom(ctx *KwFromContext) {} + +// EnterKwFull is called when production kwFull is entered. +func (s *BaseCqlParserListener) EnterKwFull(ctx *KwFullContext) {} + +// ExitKwFull is called when production kwFull is exited. +func (s *BaseCqlParserListener) ExitKwFull(ctx *KwFullContext) {} + +// EnterKwFunction is called when production kwFunction is entered. +func (s *BaseCqlParserListener) EnterKwFunction(ctx *KwFunctionContext) {} + +// ExitKwFunction is called when production kwFunction is exited. +func (s *BaseCqlParserListener) ExitKwFunction(ctx *KwFunctionContext) {} + +// EnterKwFunctions is called when production kwFunctions is entered. +func (s *BaseCqlParserListener) EnterKwFunctions(ctx *KwFunctionsContext) {} + +// ExitKwFunctions is called when production kwFunctions is exited. +func (s *BaseCqlParserListener) ExitKwFunctions(ctx *KwFunctionsContext) {} + +// EnterKwGrant is called when production kwGrant is entered. +func (s *BaseCqlParserListener) EnterKwGrant(ctx *KwGrantContext) {} + +// ExitKwGrant is called when production kwGrant is exited. +func (s *BaseCqlParserListener) ExitKwGrant(ctx *KwGrantContext) {} + +// EnterKwIf is called when production kwIf is entered. +func (s *BaseCqlParserListener) EnterKwIf(ctx *KwIfContext) {} + +// ExitKwIf is called when production kwIf is exited. +func (s *BaseCqlParserListener) ExitKwIf(ctx *KwIfContext) {} + +// EnterKwIn is called when production kwIn is entered. +func (s *BaseCqlParserListener) EnterKwIn(ctx *KwInContext) {} + +// ExitKwIn is called when production kwIn is exited. +func (s *BaseCqlParserListener) ExitKwIn(ctx *KwInContext) {} + +// EnterKwIndex is called when production kwIndex is entered. +func (s *BaseCqlParserListener) EnterKwIndex(ctx *KwIndexContext) {} + +// ExitKwIndex is called when production kwIndex is exited. +func (s *BaseCqlParserListener) ExitKwIndex(ctx *KwIndexContext) {} + +// EnterKwInitcond is called when production kwInitcond is entered. +func (s *BaseCqlParserListener) EnterKwInitcond(ctx *KwInitcondContext) {} + +// ExitKwInitcond is called when production kwInitcond is exited. +func (s *BaseCqlParserListener) ExitKwInitcond(ctx *KwInitcondContext) {} + +// EnterKwInput is called when production kwInput is entered. +func (s *BaseCqlParserListener) EnterKwInput(ctx *KwInputContext) {} + +// ExitKwInput is called when production kwInput is exited. +func (s *BaseCqlParserListener) ExitKwInput(ctx *KwInputContext) {} + +// EnterKwInsert is called when production kwInsert is entered. +func (s *BaseCqlParserListener) EnterKwInsert(ctx *KwInsertContext) {} + +// ExitKwInsert is called when production kwInsert is exited. +func (s *BaseCqlParserListener) ExitKwInsert(ctx *KwInsertContext) {} + +// EnterKwInto is called when production kwInto is entered. +func (s *BaseCqlParserListener) EnterKwInto(ctx *KwIntoContext) {} + +// ExitKwInto is called when production kwInto is exited. +func (s *BaseCqlParserListener) ExitKwInto(ctx *KwIntoContext) {} + +// EnterKwIs is called when production kwIs is entered. +func (s *BaseCqlParserListener) EnterKwIs(ctx *KwIsContext) {} + +// ExitKwIs is called when production kwIs is exited. +func (s *BaseCqlParserListener) ExitKwIs(ctx *KwIsContext) {} + +// EnterKwJson is called when production kwJson is entered. +func (s *BaseCqlParserListener) EnterKwJson(ctx *KwJsonContext) {} + +// ExitKwJson is called when production kwJson is exited. +func (s *BaseCqlParserListener) ExitKwJson(ctx *KwJsonContext) {} + +// EnterKwKey is called when production kwKey is entered. +func (s *BaseCqlParserListener) EnterKwKey(ctx *KwKeyContext) {} + +// ExitKwKey is called when production kwKey is exited. +func (s *BaseCqlParserListener) ExitKwKey(ctx *KwKeyContext) {} + +// EnterKwKeys is called when production kwKeys is entered. +func (s *BaseCqlParserListener) EnterKwKeys(ctx *KwKeysContext) {} + +// ExitKwKeys is called when production kwKeys is exited. +func (s *BaseCqlParserListener) ExitKwKeys(ctx *KwKeysContext) {} + +// EnterKwKeyspace is called when production kwKeyspace is entered. +func (s *BaseCqlParserListener) EnterKwKeyspace(ctx *KwKeyspaceContext) {} + +// ExitKwKeyspace is called when production kwKeyspace is exited. +func (s *BaseCqlParserListener) ExitKwKeyspace(ctx *KwKeyspaceContext) {} + +// EnterKwKeyspaces is called when production kwKeyspaces is entered. +func (s *BaseCqlParserListener) EnterKwKeyspaces(ctx *KwKeyspacesContext) {} + +// ExitKwKeyspaces is called when production kwKeyspaces is exited. +func (s *BaseCqlParserListener) ExitKwKeyspaces(ctx *KwKeyspacesContext) {} + +// EnterKwLanguage is called when production kwLanguage is entered. +func (s *BaseCqlParserListener) EnterKwLanguage(ctx *KwLanguageContext) {} + +// ExitKwLanguage is called when production kwLanguage is exited. +func (s *BaseCqlParserListener) ExitKwLanguage(ctx *KwLanguageContext) {} + +// EnterKwLimit is called when production kwLimit is entered. +func (s *BaseCqlParserListener) EnterKwLimit(ctx *KwLimitContext) {} + +// ExitKwLimit is called when production kwLimit is exited. +func (s *BaseCqlParserListener) ExitKwLimit(ctx *KwLimitContext) {} + +// EnterKwList is called when production kwList is entered. +func (s *BaseCqlParserListener) EnterKwList(ctx *KwListContext) {} + +// ExitKwList is called when production kwList is exited. +func (s *BaseCqlParserListener) ExitKwList(ctx *KwListContext) {} + +// EnterKwLogged is called when production kwLogged is entered. +func (s *BaseCqlParserListener) EnterKwLogged(ctx *KwLoggedContext) {} + +// ExitKwLogged is called when production kwLogged is exited. +func (s *BaseCqlParserListener) ExitKwLogged(ctx *KwLoggedContext) {} + +// EnterKwLogin is called when production kwLogin is entered. +func (s *BaseCqlParserListener) EnterKwLogin(ctx *KwLoginContext) {} + +// ExitKwLogin is called when production kwLogin is exited. +func (s *BaseCqlParserListener) ExitKwLogin(ctx *KwLoginContext) {} + +// EnterKwMaterialized is called when production kwMaterialized is entered. +func (s *BaseCqlParserListener) EnterKwMaterialized(ctx *KwMaterializedContext) {} + +// ExitKwMaterialized is called when production kwMaterialized is exited. +func (s *BaseCqlParserListener) ExitKwMaterialized(ctx *KwMaterializedContext) {} + +// EnterKwModify is called when production kwModify is entered. +func (s *BaseCqlParserListener) EnterKwModify(ctx *KwModifyContext) {} + +// ExitKwModify is called when production kwModify is exited. +func (s *BaseCqlParserListener) ExitKwModify(ctx *KwModifyContext) {} + +// EnterKwNosuperuser is called when production kwNosuperuser is entered. +func (s *BaseCqlParserListener) EnterKwNosuperuser(ctx *KwNosuperuserContext) {} + +// ExitKwNosuperuser is called when production kwNosuperuser is exited. +func (s *BaseCqlParserListener) ExitKwNosuperuser(ctx *KwNosuperuserContext) {} + +// EnterKwNorecursive is called when production kwNorecursive is entered. +func (s *BaseCqlParserListener) EnterKwNorecursive(ctx *KwNorecursiveContext) {} + +// ExitKwNorecursive is called when production kwNorecursive is exited. +func (s *BaseCqlParserListener) ExitKwNorecursive(ctx *KwNorecursiveContext) {} + +// EnterKwNot is called when production kwNot is entered. +func (s *BaseCqlParserListener) EnterKwNot(ctx *KwNotContext) {} + +// ExitKwNot is called when production kwNot is exited. +func (s *BaseCqlParserListener) ExitKwNot(ctx *KwNotContext) {} + +// EnterKwNull is called when production kwNull is entered. +func (s *BaseCqlParserListener) EnterKwNull(ctx *KwNullContext) {} + +// ExitKwNull is called when production kwNull is exited. +func (s *BaseCqlParserListener) ExitKwNull(ctx *KwNullContext) {} + +// EnterKwOf is called when production kwOf is entered. +func (s *BaseCqlParserListener) EnterKwOf(ctx *KwOfContext) {} + +// ExitKwOf is called when production kwOf is exited. +func (s *BaseCqlParserListener) ExitKwOf(ctx *KwOfContext) {} + +// EnterKwOn is called when production kwOn is entered. +func (s *BaseCqlParserListener) EnterKwOn(ctx *KwOnContext) {} + +// ExitKwOn is called when production kwOn is exited. +func (s *BaseCqlParserListener) ExitKwOn(ctx *KwOnContext) {} + +// EnterKwOptions is called when production kwOptions is entered. +func (s *BaseCqlParserListener) EnterKwOptions(ctx *KwOptionsContext) {} + +// ExitKwOptions is called when production kwOptions is exited. +func (s *BaseCqlParserListener) ExitKwOptions(ctx *KwOptionsContext) {} + +// EnterKwOr is called when production kwOr is entered. +func (s *BaseCqlParserListener) EnterKwOr(ctx *KwOrContext) {} + +// ExitKwOr is called when production kwOr is exited. +func (s *BaseCqlParserListener) ExitKwOr(ctx *KwOrContext) {} + +// EnterKwOrder is called when production kwOrder is entered. +func (s *BaseCqlParserListener) EnterKwOrder(ctx *KwOrderContext) {} + +// ExitKwOrder is called when production kwOrder is exited. +func (s *BaseCqlParserListener) ExitKwOrder(ctx *KwOrderContext) {} + +// EnterKwPassword is called when production kwPassword is entered. +func (s *BaseCqlParserListener) EnterKwPassword(ctx *KwPasswordContext) {} + +// ExitKwPassword is called when production kwPassword is exited. +func (s *BaseCqlParserListener) ExitKwPassword(ctx *KwPasswordContext) {} + +// EnterKwPrimary is called when production kwPrimary is entered. +func (s *BaseCqlParserListener) EnterKwPrimary(ctx *KwPrimaryContext) {} + +// ExitKwPrimary is called when production kwPrimary is exited. +func (s *BaseCqlParserListener) ExitKwPrimary(ctx *KwPrimaryContext) {} + +// EnterKwRename is called when production kwRename is entered. +func (s *BaseCqlParserListener) EnterKwRename(ctx *KwRenameContext) {} + +// ExitKwRename is called when production kwRename is exited. +func (s *BaseCqlParserListener) ExitKwRename(ctx *KwRenameContext) {} + +// EnterKwReplace is called when production kwReplace is entered. +func (s *BaseCqlParserListener) EnterKwReplace(ctx *KwReplaceContext) {} + +// ExitKwReplace is called when production kwReplace is exited. +func (s *BaseCqlParserListener) ExitKwReplace(ctx *KwReplaceContext) {} + +// EnterKwReplication is called when production kwReplication is entered. +func (s *BaseCqlParserListener) EnterKwReplication(ctx *KwReplicationContext) {} + +// ExitKwReplication is called when production kwReplication is exited. +func (s *BaseCqlParserListener) ExitKwReplication(ctx *KwReplicationContext) {} + +// EnterKwReturns is called when production kwReturns is entered. +func (s *BaseCqlParserListener) EnterKwReturns(ctx *KwReturnsContext) {} + +// ExitKwReturns is called when production kwReturns is exited. +func (s *BaseCqlParserListener) ExitKwReturns(ctx *KwReturnsContext) {} + +// EnterKwRole is called when production kwRole is entered. +func (s *BaseCqlParserListener) EnterKwRole(ctx *KwRoleContext) {} + +// ExitKwRole is called when production kwRole is exited. +func (s *BaseCqlParserListener) ExitKwRole(ctx *KwRoleContext) {} + +// EnterKwRoles is called when production kwRoles is entered. +func (s *BaseCqlParserListener) EnterKwRoles(ctx *KwRolesContext) {} + +// ExitKwRoles is called when production kwRoles is exited. +func (s *BaseCqlParserListener) ExitKwRoles(ctx *KwRolesContext) {} + +// EnterKwSelect is called when production kwSelect is entered. +func (s *BaseCqlParserListener) EnterKwSelect(ctx *KwSelectContext) {} + +// ExitKwSelect is called when production kwSelect is exited. +func (s *BaseCqlParserListener) ExitKwSelect(ctx *KwSelectContext) {} + +// EnterKwSet is called when production kwSet is entered. +func (s *BaseCqlParserListener) EnterKwSet(ctx *KwSetContext) {} + +// ExitKwSet is called when production kwSet is exited. +func (s *BaseCqlParserListener) ExitKwSet(ctx *KwSetContext) {} + +// EnterKwSfunc is called when production kwSfunc is entered. +func (s *BaseCqlParserListener) EnterKwSfunc(ctx *KwSfuncContext) {} + +// ExitKwSfunc is called when production kwSfunc is exited. +func (s *BaseCqlParserListener) ExitKwSfunc(ctx *KwSfuncContext) {} + +// EnterKwStorage is called when production kwStorage is entered. +func (s *BaseCqlParserListener) EnterKwStorage(ctx *KwStorageContext) {} + +// ExitKwStorage is called when production kwStorage is exited. +func (s *BaseCqlParserListener) ExitKwStorage(ctx *KwStorageContext) {} + +// EnterKwStype is called when production kwStype is entered. +func (s *BaseCqlParserListener) EnterKwStype(ctx *KwStypeContext) {} + +// ExitKwStype is called when production kwStype is exited. +func (s *BaseCqlParserListener) ExitKwStype(ctx *KwStypeContext) {} + +// EnterKwSuperuser is called when production kwSuperuser is entered. +func (s *BaseCqlParserListener) EnterKwSuperuser(ctx *KwSuperuserContext) {} + +// ExitKwSuperuser is called when production kwSuperuser is exited. +func (s *BaseCqlParserListener) ExitKwSuperuser(ctx *KwSuperuserContext) {} + +// EnterKwTable is called when production kwTable is entered. +func (s *BaseCqlParserListener) EnterKwTable(ctx *KwTableContext) {} + +// ExitKwTable is called when production kwTable is exited. +func (s *BaseCqlParserListener) ExitKwTable(ctx *KwTableContext) {} + +// EnterKwTimestamp is called when production kwTimestamp is entered. +func (s *BaseCqlParserListener) EnterKwTimestamp(ctx *KwTimestampContext) {} + +// ExitKwTimestamp is called when production kwTimestamp is exited. +func (s *BaseCqlParserListener) ExitKwTimestamp(ctx *KwTimestampContext) {} + +// EnterKwTo is called when production kwTo is entered. +func (s *BaseCqlParserListener) EnterKwTo(ctx *KwToContext) {} + +// ExitKwTo is called when production kwTo is exited. +func (s *BaseCqlParserListener) ExitKwTo(ctx *KwToContext) {} + +// EnterKwTrigger is called when production kwTrigger is entered. +func (s *BaseCqlParserListener) EnterKwTrigger(ctx *KwTriggerContext) {} + +// ExitKwTrigger is called when production kwTrigger is exited. +func (s *BaseCqlParserListener) ExitKwTrigger(ctx *KwTriggerContext) {} + +// EnterKwTruncate is called when production kwTruncate is entered. +func (s *BaseCqlParserListener) EnterKwTruncate(ctx *KwTruncateContext) {} + +// ExitKwTruncate is called when production kwTruncate is exited. +func (s *BaseCqlParserListener) ExitKwTruncate(ctx *KwTruncateContext) {} + +// EnterKwTtl is called when production kwTtl is entered. +func (s *BaseCqlParserListener) EnterKwTtl(ctx *KwTtlContext) {} + +// ExitKwTtl is called when production kwTtl is exited. +func (s *BaseCqlParserListener) ExitKwTtl(ctx *KwTtlContext) {} + +// EnterKwType is called when production kwType is entered. +func (s *BaseCqlParserListener) EnterKwType(ctx *KwTypeContext) {} + +// ExitKwType is called when production kwType is exited. +func (s *BaseCqlParserListener) ExitKwType(ctx *KwTypeContext) {} + +// EnterKwUnlogged is called when production kwUnlogged is entered. +func (s *BaseCqlParserListener) EnterKwUnlogged(ctx *KwUnloggedContext) {} + +// ExitKwUnlogged is called when production kwUnlogged is exited. +func (s *BaseCqlParserListener) ExitKwUnlogged(ctx *KwUnloggedContext) {} + +// EnterKwUpdate is called when production kwUpdate is entered. +func (s *BaseCqlParserListener) EnterKwUpdate(ctx *KwUpdateContext) {} + +// ExitKwUpdate is called when production kwUpdate is exited. +func (s *BaseCqlParserListener) ExitKwUpdate(ctx *KwUpdateContext) {} + +// EnterKwUse is called when production kwUse is entered. +func (s *BaseCqlParserListener) EnterKwUse(ctx *KwUseContext) {} + +// ExitKwUse is called when production kwUse is exited. +func (s *BaseCqlParserListener) ExitKwUse(ctx *KwUseContext) {} + +// EnterKwUser is called when production kwUser is entered. +func (s *BaseCqlParserListener) EnterKwUser(ctx *KwUserContext) {} + +// ExitKwUser is called when production kwUser is exited. +func (s *BaseCqlParserListener) ExitKwUser(ctx *KwUserContext) {} + +// EnterKwUsing is called when production kwUsing is entered. +func (s *BaseCqlParserListener) EnterKwUsing(ctx *KwUsingContext) {} + +// ExitKwUsing is called when production kwUsing is exited. +func (s *BaseCqlParserListener) ExitKwUsing(ctx *KwUsingContext) {} + +// EnterKwValues is called when production kwValues is entered. +func (s *BaseCqlParserListener) EnterKwValues(ctx *KwValuesContext) {} + +// ExitKwValues is called when production kwValues is exited. +func (s *BaseCqlParserListener) ExitKwValues(ctx *KwValuesContext) {} + +// EnterKwView is called when production kwView is entered. +func (s *BaseCqlParserListener) EnterKwView(ctx *KwViewContext) {} + +// ExitKwView is called when production kwView is exited. +func (s *BaseCqlParserListener) ExitKwView(ctx *KwViewContext) {} + +// EnterKwWhere is called when production kwWhere is entered. +func (s *BaseCqlParserListener) EnterKwWhere(ctx *KwWhereContext) {} + +// ExitKwWhere is called when production kwWhere is exited. +func (s *BaseCqlParserListener) ExitKwWhere(ctx *KwWhereContext) {} + +// EnterKwWith is called when production kwWith is entered. +func (s *BaseCqlParserListener) EnterKwWith(ctx *KwWithContext) {} + +// ExitKwWith is called when production kwWith is exited. +func (s *BaseCqlParserListener) ExitKwWith(ctx *KwWithContext) {} + +// EnterKwRevoke is called when production kwRevoke is entered. +func (s *BaseCqlParserListener) EnterKwRevoke(ctx *KwRevokeContext) {} + +// ExitKwRevoke is called when production kwRevoke is exited. +func (s *BaseCqlParserListener) ExitKwRevoke(ctx *KwRevokeContext) {} + +// EnterSyntaxBracketLr is called when production syntaxBracketLr is entered. +func (s *BaseCqlParserListener) EnterSyntaxBracketLr(ctx *SyntaxBracketLrContext) {} + +// ExitSyntaxBracketLr is called when production syntaxBracketLr is exited. +func (s *BaseCqlParserListener) ExitSyntaxBracketLr(ctx *SyntaxBracketLrContext) {} + +// EnterSyntaxBracketRr is called when production syntaxBracketRr is entered. +func (s *BaseCqlParserListener) EnterSyntaxBracketRr(ctx *SyntaxBracketRrContext) {} + +// ExitSyntaxBracketRr is called when production syntaxBracketRr is exited. +func (s *BaseCqlParserListener) ExitSyntaxBracketRr(ctx *SyntaxBracketRrContext) {} + +// EnterSyntaxBracketLc is called when production syntaxBracketLc is entered. +func (s *BaseCqlParserListener) EnterSyntaxBracketLc(ctx *SyntaxBracketLcContext) {} + +// ExitSyntaxBracketLc is called when production syntaxBracketLc is exited. +func (s *BaseCqlParserListener) ExitSyntaxBracketLc(ctx *SyntaxBracketLcContext) {} + +// EnterSyntaxBracketRc is called when production syntaxBracketRc is entered. +func (s *BaseCqlParserListener) EnterSyntaxBracketRc(ctx *SyntaxBracketRcContext) {} + +// ExitSyntaxBracketRc is called when production syntaxBracketRc is exited. +func (s *BaseCqlParserListener) ExitSyntaxBracketRc(ctx *SyntaxBracketRcContext) {} + +// EnterSyntaxBracketLa is called when production syntaxBracketLa is entered. +func (s *BaseCqlParserListener) EnterSyntaxBracketLa(ctx *SyntaxBracketLaContext) {} + +// ExitSyntaxBracketLa is called when production syntaxBracketLa is exited. +func (s *BaseCqlParserListener) ExitSyntaxBracketLa(ctx *SyntaxBracketLaContext) {} + +// EnterSyntaxBracketRa is called when production syntaxBracketRa is entered. +func (s *BaseCqlParserListener) EnterSyntaxBracketRa(ctx *SyntaxBracketRaContext) {} + +// ExitSyntaxBracketRa is called when production syntaxBracketRa is exited. +func (s *BaseCqlParserListener) ExitSyntaxBracketRa(ctx *SyntaxBracketRaContext) {} + +// EnterSyntaxBracketLs is called when production syntaxBracketLs is entered. +func (s *BaseCqlParserListener) EnterSyntaxBracketLs(ctx *SyntaxBracketLsContext) {} + +// ExitSyntaxBracketLs is called when production syntaxBracketLs is exited. +func (s *BaseCqlParserListener) ExitSyntaxBracketLs(ctx *SyntaxBracketLsContext) {} + +// EnterSyntaxBracketRs is called when production syntaxBracketRs is entered. +func (s *BaseCqlParserListener) EnterSyntaxBracketRs(ctx *SyntaxBracketRsContext) {} + +// ExitSyntaxBracketRs is called when production syntaxBracketRs is exited. +func (s *BaseCqlParserListener) ExitSyntaxBracketRs(ctx *SyntaxBracketRsContext) {} + +// EnterSyntaxComma is called when production syntaxComma is entered. +func (s *BaseCqlParserListener) EnterSyntaxComma(ctx *SyntaxCommaContext) {} + +// ExitSyntaxComma is called when production syntaxComma is exited. +func (s *BaseCqlParserListener) ExitSyntaxComma(ctx *SyntaxCommaContext) {} + +// EnterSyntaxColon is called when production syntaxColon is entered. +func (s *BaseCqlParserListener) EnterSyntaxColon(ctx *SyntaxColonContext) {} + +// ExitSyntaxColon is called when production syntaxColon is exited. +func (s *BaseCqlParserListener) ExitSyntaxColon(ctx *SyntaxColonContext) {} diff --git a/cql/cqlparser_base_visitor.go b/cql/cqlparser_base_visitor.go new file mode 100644 index 0000000..27122c6 --- /dev/null +++ b/cql/cqlparser_base_visitor.go @@ -0,0 +1,1116 @@ +// Code generated from CqlParser.g4 by ANTLR 4.13.2. DO NOT EDIT. + +package cql // CqlParser +import "github.com/antlr4-go/antlr/v4" + +type BaseCqlParserVisitor struct { + *antlr.BaseParseTreeVisitor +} + +func (v *BaseCqlParserVisitor) VisitRoot(ctx *RootContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitCqls(ctx *CqlsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitStatementSeparator(ctx *StatementSeparatorContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitEmpty_(ctx *Empty_Context) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitCql(ctx *CqlContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitRevoke(ctx *RevokeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitListRoles(ctx *ListRolesContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitListPermissions(ctx *ListPermissionsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitGrant(ctx *GrantContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitPriviledge(ctx *PriviledgeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitResource(ctx *ResourceContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitCreateUser(ctx *CreateUserContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitCreateRole(ctx *CreateRoleContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitCreateType(ctx *CreateTypeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitTypeMemberColumnList(ctx *TypeMemberColumnListContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitCreateTrigger(ctx *CreateTriggerContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitCreateMaterializedView(ctx *CreateMaterializedViewContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitMaterializedViewWhere(ctx *MaterializedViewWhereContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitColumnNotNullList(ctx *ColumnNotNullListContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitColumnNotNull(ctx *ColumnNotNullContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitMaterializedViewOptions(ctx *MaterializedViewOptionsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitCreateKeyspace(ctx *CreateKeyspaceContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitCreateFunction(ctx *CreateFunctionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitCodeBlock(ctx *CodeBlockContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitParamList(ctx *ParamListContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitReturnMode(ctx *ReturnModeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitCreateAggregate(ctx *CreateAggregateContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitInitCondDefinition(ctx *InitCondDefinitionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitInitCondHash(ctx *InitCondHashContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitInitCondHashItem(ctx *InitCondHashItemContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitInitCondListNested(ctx *InitCondListNestedContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitInitCondList(ctx *InitCondListContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitOrReplace(ctx *OrReplaceContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitAlterUser(ctx *AlterUserContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitUserPassword(ctx *UserPasswordContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitUserSuperUser(ctx *UserSuperUserContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitAlterType(ctx *AlterTypeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitAlterTypeOperation(ctx *AlterTypeOperationContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitAlterTypeRename(ctx *AlterTypeRenameContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitAlterTypeRenameList(ctx *AlterTypeRenameListContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitAlterTypeRenameItem(ctx *AlterTypeRenameItemContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitAlterTypeAdd(ctx *AlterTypeAddContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitAlterTypeAlterType(ctx *AlterTypeAlterTypeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitAlterTable(ctx *AlterTableContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitAlterTableOperation(ctx *AlterTableOperationContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitAlterTableWith(ctx *AlterTableWithContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitAlterTableRename(ctx *AlterTableRenameContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitAlterTableDropCompactStorage(ctx *AlterTableDropCompactStorageContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitAlterTableDropColumns(ctx *AlterTableDropColumnsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitAlterTableDropColumnList(ctx *AlterTableDropColumnListContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitAlterTableAdd(ctx *AlterTableAddContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitAlterTableColumnDefinition(ctx *AlterTableColumnDefinitionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitAlterRole(ctx *AlterRoleContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitRoleWith(ctx *RoleWithContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitRoleWithOptions(ctx *RoleWithOptionsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitAlterMaterializedView(ctx *AlterMaterializedViewContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitDropUser(ctx *DropUserContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitDropType(ctx *DropTypeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitDropMaterializedView(ctx *DropMaterializedViewContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitDropAggregate(ctx *DropAggregateContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitDropFunction(ctx *DropFunctionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitDropTrigger(ctx *DropTriggerContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitDropRole(ctx *DropRoleContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitDropTable(ctx *DropTableContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitDropKeyspace(ctx *DropKeyspaceContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitDropIndex(ctx *DropIndexContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitCreateTable(ctx *CreateTableContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitWithElement(ctx *WithElementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitTableOptions(ctx *TableOptionsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitClusteringOrder(ctx *ClusteringOrderContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitTableOptionItem(ctx *TableOptionItemContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitTableOptionName(ctx *TableOptionNameContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitTableOptionValue(ctx *TableOptionValueContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitOptionHash(ctx *OptionHashContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitOptionHashItem(ctx *OptionHashItemContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitOptionHashKey(ctx *OptionHashKeyContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitOptionHashValue(ctx *OptionHashValueContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitColumnDefinitionList(ctx *ColumnDefinitionListContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitColumnDefinition(ctx *ColumnDefinitionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitPrimaryKeyColumn(ctx *PrimaryKeyColumnContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitPrimaryKeyElement(ctx *PrimaryKeyElementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitPrimaryKeyDefinition(ctx *PrimaryKeyDefinitionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitSinglePrimaryKey(ctx *SinglePrimaryKeyContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitCompoundKey(ctx *CompoundKeyContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitCompositeKey(ctx *CompositeKeyContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitPartitionKeyList(ctx *PartitionKeyListContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitClusteringKeyList(ctx *ClusteringKeyListContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitPartitionKey(ctx *PartitionKeyContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitClusteringKey(ctx *ClusteringKeyContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitApplyBatch(ctx *ApplyBatchContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitBeginBatch(ctx *BeginBatchContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitBatchType(ctx *BatchTypeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitAlterKeyspace(ctx *AlterKeyspaceContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitReplicationList(ctx *ReplicationListContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitReplicationListItem(ctx *ReplicationListItemContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitDurableWrites(ctx *DurableWritesContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitUse_(ctx *Use_Context) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitTruncate(ctx *TruncateContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitCreateIndex(ctx *CreateIndexContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitIndexName(ctx *IndexNameContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitIndexColumnSpec(ctx *IndexColumnSpecContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitIndexKeysSpec(ctx *IndexKeysSpecContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitIndexEntriesSSpec(ctx *IndexEntriesSSpecContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitIndexFullSpec(ctx *IndexFullSpecContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitDelete_(ctx *Delete_Context) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitDeleteColumnList(ctx *DeleteColumnListContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitDeleteColumnItem(ctx *DeleteColumnItemContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitUpdate(ctx *UpdateContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitIfSpec(ctx *IfSpecContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitIfConditionList(ctx *IfConditionListContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitIfCondition(ctx *IfConditionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitAssignments(ctx *AssignmentsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitAssignmentElement(ctx *AssignmentElementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitAssignmentSet(ctx *AssignmentSetContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitAssignmentMap(ctx *AssignmentMapContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitAssignmentList(ctx *AssignmentListContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitAssignmentTuple(ctx *AssignmentTupleContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitInsert(ctx *InsertContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitUsingTtlTimestamp(ctx *UsingTtlTimestampContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitTimestamp(ctx *TimestampContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitTtl(ctx *TtlContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitUsingTimestampSpec(ctx *UsingTimestampSpecContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitIfNotExist(ctx *IfNotExistContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitIfExist(ctx *IfExistContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitInsertValuesSpec(ctx *InsertValuesSpecContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitInsertColumnSpec(ctx *InsertColumnSpecContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitColumnList(ctx *ColumnListContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitExpressionList(ctx *ExpressionListContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitExpression(ctx *ExpressionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitSelect_(ctx *Select_Context) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitAllowFilteringSpec(ctx *AllowFilteringSpecContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitLimitSpec(ctx *LimitSpecContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitFromSpec(ctx *FromSpecContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitFromSpecElement(ctx *FromSpecElementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitOrderSpec(ctx *OrderSpecContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitOrderSpecElement(ctx *OrderSpecElementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitWhereSpec(ctx *WhereSpecContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitDistinctSpec(ctx *DistinctSpecContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitSelectElements(ctx *SelectElementsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitSelectElement(ctx *SelectElementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitRelationElements(ctx *RelationElementsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitRelationElement(ctx *RelationElementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitRelalationContains(ctx *RelalationContainsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitRelalationContainsKey(ctx *RelalationContainsKeyContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitFunctionCall(ctx *FunctionCallContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitFunctionArgs(ctx *FunctionArgsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitConstant(ctx *ConstantContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitDecimalLiteral(ctx *DecimalLiteralContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitFloatLiteral(ctx *FloatLiteralContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitStringLiteral(ctx *StringLiteralContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitBooleanLiteral(ctx *BooleanLiteralContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitHexadecimalLiteral(ctx *HexadecimalLiteralContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitKeyspace(ctx *KeyspaceContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitTable(ctx *TableContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitColumn(ctx *ColumnContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitDataType(ctx *DataTypeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitDataTypeName(ctx *DataTypeNameContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitDataTypeDefinition(ctx *DataTypeDefinitionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitOrderDirection(ctx *OrderDirectionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitRole(ctx *RoleContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitTrigger(ctx *TriggerContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitTriggerClass(ctx *TriggerClassContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitMaterializedView(ctx *MaterializedViewContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitType_(ctx *Type_Context) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitAggregate(ctx *AggregateContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitFunction_(ctx *Function_Context) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitLanguage(ctx *LanguageContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitUser(ctx *UserContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitPassword(ctx *PasswordContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitHashKey(ctx *HashKeyContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitParam(ctx *ParamContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitParamName(ctx *ParamNameContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitKwAdd(ctx *KwAddContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitKwAggregate(ctx *KwAggregateContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitKwAll(ctx *KwAllContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitKwAllPermissions(ctx *KwAllPermissionsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitKwAllow(ctx *KwAllowContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitKwAlter(ctx *KwAlterContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitKwAnd(ctx *KwAndContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitKwApply(ctx *KwApplyContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitKwAs(ctx *KwAsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitKwAsc(ctx *KwAscContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitKwAuthorize(ctx *KwAuthorizeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitKwBatch(ctx *KwBatchContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitKwBegin(ctx *KwBeginContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitKwBy(ctx *KwByContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitKwCalled(ctx *KwCalledContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitKwClustering(ctx *KwClusteringContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitKwCompact(ctx *KwCompactContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitKwContains(ctx *KwContainsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitKwCreate(ctx *KwCreateContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitKwDelete(ctx *KwDeleteContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitKwDesc(ctx *KwDescContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitKwDescibe(ctx *KwDescibeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitKwDistinct(ctx *KwDistinctContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitKwDrop(ctx *KwDropContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitKwDurableWrites(ctx *KwDurableWritesContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitKwEntries(ctx *KwEntriesContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitKwExecute(ctx *KwExecuteContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitKwExists(ctx *KwExistsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitKwFiltering(ctx *KwFilteringContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitKwFinalfunc(ctx *KwFinalfuncContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitKwFrom(ctx *KwFromContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitKwFull(ctx *KwFullContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitKwFunction(ctx *KwFunctionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitKwFunctions(ctx *KwFunctionsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitKwGrant(ctx *KwGrantContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitKwIf(ctx *KwIfContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitKwIn(ctx *KwInContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitKwIndex(ctx *KwIndexContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitKwInitcond(ctx *KwInitcondContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitKwInput(ctx *KwInputContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitKwInsert(ctx *KwInsertContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitKwInto(ctx *KwIntoContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitKwIs(ctx *KwIsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitKwJson(ctx *KwJsonContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitKwKey(ctx *KwKeyContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitKwKeys(ctx *KwKeysContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitKwKeyspace(ctx *KwKeyspaceContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitKwKeyspaces(ctx *KwKeyspacesContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitKwLanguage(ctx *KwLanguageContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitKwLimit(ctx *KwLimitContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitKwList(ctx *KwListContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitKwLogged(ctx *KwLoggedContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitKwLogin(ctx *KwLoginContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitKwMaterialized(ctx *KwMaterializedContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitKwModify(ctx *KwModifyContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitKwNosuperuser(ctx *KwNosuperuserContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitKwNorecursive(ctx *KwNorecursiveContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitKwNot(ctx *KwNotContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitKwNull(ctx *KwNullContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitKwOf(ctx *KwOfContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitKwOn(ctx *KwOnContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitKwOptions(ctx *KwOptionsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitKwOr(ctx *KwOrContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitKwOrder(ctx *KwOrderContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitKwPassword(ctx *KwPasswordContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitKwPrimary(ctx *KwPrimaryContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitKwRename(ctx *KwRenameContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitKwReplace(ctx *KwReplaceContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitKwReplication(ctx *KwReplicationContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitKwReturns(ctx *KwReturnsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitKwRole(ctx *KwRoleContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitKwRoles(ctx *KwRolesContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitKwSelect(ctx *KwSelectContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitKwSet(ctx *KwSetContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitKwSfunc(ctx *KwSfuncContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitKwStorage(ctx *KwStorageContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitKwStype(ctx *KwStypeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitKwSuperuser(ctx *KwSuperuserContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitKwTable(ctx *KwTableContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitKwTimestamp(ctx *KwTimestampContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitKwTo(ctx *KwToContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitKwTrigger(ctx *KwTriggerContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitKwTruncate(ctx *KwTruncateContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitKwTtl(ctx *KwTtlContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitKwType(ctx *KwTypeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitKwUnlogged(ctx *KwUnloggedContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitKwUpdate(ctx *KwUpdateContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitKwUse(ctx *KwUseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitKwUser(ctx *KwUserContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitKwUsing(ctx *KwUsingContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitKwValues(ctx *KwValuesContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitKwView(ctx *KwViewContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitKwWhere(ctx *KwWhereContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitKwWith(ctx *KwWithContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitKwRevoke(ctx *KwRevokeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitSyntaxBracketLr(ctx *SyntaxBracketLrContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitSyntaxBracketRr(ctx *SyntaxBracketRrContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitSyntaxBracketLc(ctx *SyntaxBracketLcContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitSyntaxBracketRc(ctx *SyntaxBracketRcContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitSyntaxBracketLa(ctx *SyntaxBracketLaContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitSyntaxBracketRa(ctx *SyntaxBracketRaContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitSyntaxBracketLs(ctx *SyntaxBracketLsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitSyntaxBracketRs(ctx *SyntaxBracketRsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitSyntaxComma(ctx *SyntaxCommaContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseCqlParserVisitor) VisitSyntaxColon(ctx *SyntaxColonContext) interface{} { + return v.VisitChildren(ctx) +} diff --git a/cql/cqlparser_listener.go b/cql/cqlparser_listener.go new file mode 100644 index 0000000..d7ea59b --- /dev/null +++ b/cql/cqlparser_listener.go @@ -0,0 +1,1671 @@ +// Code generated from CqlParser.g4 by ANTLR 4.13.2. DO NOT EDIT. + +package cql // CqlParser +import "github.com/antlr4-go/antlr/v4" + +// CqlParserListener is a complete listener for a parse tree produced by CqlParser. +type CqlParserListener interface { + antlr.ParseTreeListener + + // EnterRoot is called when entering the root production. + EnterRoot(c *RootContext) + + // EnterCqls is called when entering the cqls production. + EnterCqls(c *CqlsContext) + + // EnterStatementSeparator is called when entering the statementSeparator production. + EnterStatementSeparator(c *StatementSeparatorContext) + + // EnterEmpty_ is called when entering the empty_ production. + EnterEmpty_(c *Empty_Context) + + // EnterCql is called when entering the cql production. + EnterCql(c *CqlContext) + + // EnterRevoke is called when entering the revoke production. + EnterRevoke(c *RevokeContext) + + // EnterListRoles is called when entering the listRoles production. + EnterListRoles(c *ListRolesContext) + + // EnterListPermissions is called when entering the listPermissions production. + EnterListPermissions(c *ListPermissionsContext) + + // EnterGrant is called when entering the grant production. + EnterGrant(c *GrantContext) + + // EnterPriviledge is called when entering the priviledge production. + EnterPriviledge(c *PriviledgeContext) + + // EnterResource is called when entering the resource production. + EnterResource(c *ResourceContext) + + // EnterCreateUser is called when entering the createUser production. + EnterCreateUser(c *CreateUserContext) + + // EnterCreateRole is called when entering the createRole production. + EnterCreateRole(c *CreateRoleContext) + + // EnterCreateType is called when entering the createType production. + EnterCreateType(c *CreateTypeContext) + + // EnterTypeMemberColumnList is called when entering the typeMemberColumnList production. + EnterTypeMemberColumnList(c *TypeMemberColumnListContext) + + // EnterCreateTrigger is called when entering the createTrigger production. + EnterCreateTrigger(c *CreateTriggerContext) + + // EnterCreateMaterializedView is called when entering the createMaterializedView production. + EnterCreateMaterializedView(c *CreateMaterializedViewContext) + + // EnterMaterializedViewWhere is called when entering the materializedViewWhere production. + EnterMaterializedViewWhere(c *MaterializedViewWhereContext) + + // EnterColumnNotNullList is called when entering the columnNotNullList production. + EnterColumnNotNullList(c *ColumnNotNullListContext) + + // EnterColumnNotNull is called when entering the columnNotNull production. + EnterColumnNotNull(c *ColumnNotNullContext) + + // EnterMaterializedViewOptions is called when entering the materializedViewOptions production. + EnterMaterializedViewOptions(c *MaterializedViewOptionsContext) + + // EnterCreateKeyspace is called when entering the createKeyspace production. + EnterCreateKeyspace(c *CreateKeyspaceContext) + + // EnterCreateFunction is called when entering the createFunction production. + EnterCreateFunction(c *CreateFunctionContext) + + // EnterCodeBlock is called when entering the codeBlock production. + EnterCodeBlock(c *CodeBlockContext) + + // EnterParamList is called when entering the paramList production. + EnterParamList(c *ParamListContext) + + // EnterReturnMode is called when entering the returnMode production. + EnterReturnMode(c *ReturnModeContext) + + // EnterCreateAggregate is called when entering the createAggregate production. + EnterCreateAggregate(c *CreateAggregateContext) + + // EnterInitCondDefinition is called when entering the initCondDefinition production. + EnterInitCondDefinition(c *InitCondDefinitionContext) + + // EnterInitCondHash is called when entering the initCondHash production. + EnterInitCondHash(c *InitCondHashContext) + + // EnterInitCondHashItem is called when entering the initCondHashItem production. + EnterInitCondHashItem(c *InitCondHashItemContext) + + // EnterInitCondListNested is called when entering the initCondListNested production. + EnterInitCondListNested(c *InitCondListNestedContext) + + // EnterInitCondList is called when entering the initCondList production. + EnterInitCondList(c *InitCondListContext) + + // EnterOrReplace is called when entering the orReplace production. + EnterOrReplace(c *OrReplaceContext) + + // EnterAlterUser is called when entering the alterUser production. + EnterAlterUser(c *AlterUserContext) + + // EnterUserPassword is called when entering the userPassword production. + EnterUserPassword(c *UserPasswordContext) + + // EnterUserSuperUser is called when entering the userSuperUser production. + EnterUserSuperUser(c *UserSuperUserContext) + + // EnterAlterType is called when entering the alterType production. + EnterAlterType(c *AlterTypeContext) + + // EnterAlterTypeOperation is called when entering the alterTypeOperation production. + EnterAlterTypeOperation(c *AlterTypeOperationContext) + + // EnterAlterTypeRename is called when entering the alterTypeRename production. + EnterAlterTypeRename(c *AlterTypeRenameContext) + + // EnterAlterTypeRenameList is called when entering the alterTypeRenameList production. + EnterAlterTypeRenameList(c *AlterTypeRenameListContext) + + // EnterAlterTypeRenameItem is called when entering the alterTypeRenameItem production. + EnterAlterTypeRenameItem(c *AlterTypeRenameItemContext) + + // EnterAlterTypeAdd is called when entering the alterTypeAdd production. + EnterAlterTypeAdd(c *AlterTypeAddContext) + + // EnterAlterTypeAlterType is called when entering the alterTypeAlterType production. + EnterAlterTypeAlterType(c *AlterTypeAlterTypeContext) + + // EnterAlterTable is called when entering the alterTable production. + EnterAlterTable(c *AlterTableContext) + + // EnterAlterTableOperation is called when entering the alterTableOperation production. + EnterAlterTableOperation(c *AlterTableOperationContext) + + // EnterAlterTableWith is called when entering the alterTableWith production. + EnterAlterTableWith(c *AlterTableWithContext) + + // EnterAlterTableRename is called when entering the alterTableRename production. + EnterAlterTableRename(c *AlterTableRenameContext) + + // EnterAlterTableDropCompactStorage is called when entering the alterTableDropCompactStorage production. + EnterAlterTableDropCompactStorage(c *AlterTableDropCompactStorageContext) + + // EnterAlterTableDropColumns is called when entering the alterTableDropColumns production. + EnterAlterTableDropColumns(c *AlterTableDropColumnsContext) + + // EnterAlterTableDropColumnList is called when entering the alterTableDropColumnList production. + EnterAlterTableDropColumnList(c *AlterTableDropColumnListContext) + + // EnterAlterTableAdd is called when entering the alterTableAdd production. + EnterAlterTableAdd(c *AlterTableAddContext) + + // EnterAlterTableColumnDefinition is called when entering the alterTableColumnDefinition production. + EnterAlterTableColumnDefinition(c *AlterTableColumnDefinitionContext) + + // EnterAlterRole is called when entering the alterRole production. + EnterAlterRole(c *AlterRoleContext) + + // EnterRoleWith is called when entering the roleWith production. + EnterRoleWith(c *RoleWithContext) + + // EnterRoleWithOptions is called when entering the roleWithOptions production. + EnterRoleWithOptions(c *RoleWithOptionsContext) + + // EnterAlterMaterializedView is called when entering the alterMaterializedView production. + EnterAlterMaterializedView(c *AlterMaterializedViewContext) + + // EnterDropUser is called when entering the dropUser production. + EnterDropUser(c *DropUserContext) + + // EnterDropType is called when entering the dropType production. + EnterDropType(c *DropTypeContext) + + // EnterDropMaterializedView is called when entering the dropMaterializedView production. + EnterDropMaterializedView(c *DropMaterializedViewContext) + + // EnterDropAggregate is called when entering the dropAggregate production. + EnterDropAggregate(c *DropAggregateContext) + + // EnterDropFunction is called when entering the dropFunction production. + EnterDropFunction(c *DropFunctionContext) + + // EnterDropTrigger is called when entering the dropTrigger production. + EnterDropTrigger(c *DropTriggerContext) + + // EnterDropRole is called when entering the dropRole production. + EnterDropRole(c *DropRoleContext) + + // EnterDropTable is called when entering the dropTable production. + EnterDropTable(c *DropTableContext) + + // EnterDropKeyspace is called when entering the dropKeyspace production. + EnterDropKeyspace(c *DropKeyspaceContext) + + // EnterDropIndex is called when entering the dropIndex production. + EnterDropIndex(c *DropIndexContext) + + // EnterCreateTable is called when entering the createTable production. + EnterCreateTable(c *CreateTableContext) + + // EnterWithElement is called when entering the withElement production. + EnterWithElement(c *WithElementContext) + + // EnterTableOptions is called when entering the tableOptions production. + EnterTableOptions(c *TableOptionsContext) + + // EnterClusteringOrder is called when entering the clusteringOrder production. + EnterClusteringOrder(c *ClusteringOrderContext) + + // EnterTableOptionItem is called when entering the tableOptionItem production. + EnterTableOptionItem(c *TableOptionItemContext) + + // EnterTableOptionName is called when entering the tableOptionName production. + EnterTableOptionName(c *TableOptionNameContext) + + // EnterTableOptionValue is called when entering the tableOptionValue production. + EnterTableOptionValue(c *TableOptionValueContext) + + // EnterOptionHash is called when entering the optionHash production. + EnterOptionHash(c *OptionHashContext) + + // EnterOptionHashItem is called when entering the optionHashItem production. + EnterOptionHashItem(c *OptionHashItemContext) + + // EnterOptionHashKey is called when entering the optionHashKey production. + EnterOptionHashKey(c *OptionHashKeyContext) + + // EnterOptionHashValue is called when entering the optionHashValue production. + EnterOptionHashValue(c *OptionHashValueContext) + + // EnterColumnDefinitionList is called when entering the columnDefinitionList production. + EnterColumnDefinitionList(c *ColumnDefinitionListContext) + + // EnterColumnDefinition is called when entering the columnDefinition production. + EnterColumnDefinition(c *ColumnDefinitionContext) + + // EnterPrimaryKeyColumn is called when entering the primaryKeyColumn production. + EnterPrimaryKeyColumn(c *PrimaryKeyColumnContext) + + // EnterPrimaryKeyElement is called when entering the primaryKeyElement production. + EnterPrimaryKeyElement(c *PrimaryKeyElementContext) + + // EnterPrimaryKeyDefinition is called when entering the primaryKeyDefinition production. + EnterPrimaryKeyDefinition(c *PrimaryKeyDefinitionContext) + + // EnterSinglePrimaryKey is called when entering the singlePrimaryKey production. + EnterSinglePrimaryKey(c *SinglePrimaryKeyContext) + + // EnterCompoundKey is called when entering the compoundKey production. + EnterCompoundKey(c *CompoundKeyContext) + + // EnterCompositeKey is called when entering the compositeKey production. + EnterCompositeKey(c *CompositeKeyContext) + + // EnterPartitionKeyList is called when entering the partitionKeyList production. + EnterPartitionKeyList(c *PartitionKeyListContext) + + // EnterClusteringKeyList is called when entering the clusteringKeyList production. + EnterClusteringKeyList(c *ClusteringKeyListContext) + + // EnterPartitionKey is called when entering the partitionKey production. + EnterPartitionKey(c *PartitionKeyContext) + + // EnterClusteringKey is called when entering the clusteringKey production. + EnterClusteringKey(c *ClusteringKeyContext) + + // EnterApplyBatch is called when entering the applyBatch production. + EnterApplyBatch(c *ApplyBatchContext) + + // EnterBeginBatch is called when entering the beginBatch production. + EnterBeginBatch(c *BeginBatchContext) + + // EnterBatchType is called when entering the batchType production. + EnterBatchType(c *BatchTypeContext) + + // EnterAlterKeyspace is called when entering the alterKeyspace production. + EnterAlterKeyspace(c *AlterKeyspaceContext) + + // EnterReplicationList is called when entering the replicationList production. + EnterReplicationList(c *ReplicationListContext) + + // EnterReplicationListItem is called when entering the replicationListItem production. + EnterReplicationListItem(c *ReplicationListItemContext) + + // EnterDurableWrites is called when entering the durableWrites production. + EnterDurableWrites(c *DurableWritesContext) + + // EnterUse_ is called when entering the use_ production. + EnterUse_(c *Use_Context) + + // EnterTruncate is called when entering the truncate production. + EnterTruncate(c *TruncateContext) + + // EnterCreateIndex is called when entering the createIndex production. + EnterCreateIndex(c *CreateIndexContext) + + // EnterIndexName is called when entering the indexName production. + EnterIndexName(c *IndexNameContext) + + // EnterIndexColumnSpec is called when entering the indexColumnSpec production. + EnterIndexColumnSpec(c *IndexColumnSpecContext) + + // EnterIndexKeysSpec is called when entering the indexKeysSpec production. + EnterIndexKeysSpec(c *IndexKeysSpecContext) + + // EnterIndexEntriesSSpec is called when entering the indexEntriesSSpec production. + EnterIndexEntriesSSpec(c *IndexEntriesSSpecContext) + + // EnterIndexFullSpec is called when entering the indexFullSpec production. + EnterIndexFullSpec(c *IndexFullSpecContext) + + // EnterDelete_ is called when entering the delete_ production. + EnterDelete_(c *Delete_Context) + + // EnterDeleteColumnList is called when entering the deleteColumnList production. + EnterDeleteColumnList(c *DeleteColumnListContext) + + // EnterDeleteColumnItem is called when entering the deleteColumnItem production. + EnterDeleteColumnItem(c *DeleteColumnItemContext) + + // EnterUpdate is called when entering the update production. + EnterUpdate(c *UpdateContext) + + // EnterIfSpec is called when entering the ifSpec production. + EnterIfSpec(c *IfSpecContext) + + // EnterIfConditionList is called when entering the ifConditionList production. + EnterIfConditionList(c *IfConditionListContext) + + // EnterIfCondition is called when entering the ifCondition production. + EnterIfCondition(c *IfConditionContext) + + // EnterAssignments is called when entering the assignments production. + EnterAssignments(c *AssignmentsContext) + + // EnterAssignmentElement is called when entering the assignmentElement production. + EnterAssignmentElement(c *AssignmentElementContext) + + // EnterAssignmentSet is called when entering the assignmentSet production. + EnterAssignmentSet(c *AssignmentSetContext) + + // EnterAssignmentMap is called when entering the assignmentMap production. + EnterAssignmentMap(c *AssignmentMapContext) + + // EnterAssignmentList is called when entering the assignmentList production. + EnterAssignmentList(c *AssignmentListContext) + + // EnterAssignmentTuple is called when entering the assignmentTuple production. + EnterAssignmentTuple(c *AssignmentTupleContext) + + // EnterInsert is called when entering the insert production. + EnterInsert(c *InsertContext) + + // EnterUsingTtlTimestamp is called when entering the usingTtlTimestamp production. + EnterUsingTtlTimestamp(c *UsingTtlTimestampContext) + + // EnterTimestamp is called when entering the timestamp production. + EnterTimestamp(c *TimestampContext) + + // EnterTtl is called when entering the ttl production. + EnterTtl(c *TtlContext) + + // EnterUsingTimestampSpec is called when entering the usingTimestampSpec production. + EnterUsingTimestampSpec(c *UsingTimestampSpecContext) + + // EnterIfNotExist is called when entering the ifNotExist production. + EnterIfNotExist(c *IfNotExistContext) + + // EnterIfExist is called when entering the ifExist production. + EnterIfExist(c *IfExistContext) + + // EnterInsertValuesSpec is called when entering the insertValuesSpec production. + EnterInsertValuesSpec(c *InsertValuesSpecContext) + + // EnterInsertColumnSpec is called when entering the insertColumnSpec production. + EnterInsertColumnSpec(c *InsertColumnSpecContext) + + // EnterColumnList is called when entering the columnList production. + EnterColumnList(c *ColumnListContext) + + // EnterExpressionList is called when entering the expressionList production. + EnterExpressionList(c *ExpressionListContext) + + // EnterExpression is called when entering the expression production. + EnterExpression(c *ExpressionContext) + + // EnterSelect_ is called when entering the select_ production. + EnterSelect_(c *Select_Context) + + // EnterAllowFilteringSpec is called when entering the allowFilteringSpec production. + EnterAllowFilteringSpec(c *AllowFilteringSpecContext) + + // EnterLimitSpec is called when entering the limitSpec production. + EnterLimitSpec(c *LimitSpecContext) + + // EnterFromSpec is called when entering the fromSpec production. + EnterFromSpec(c *FromSpecContext) + + // EnterFromSpecElement is called when entering the fromSpecElement production. + EnterFromSpecElement(c *FromSpecElementContext) + + // EnterOrderSpec is called when entering the orderSpec production. + EnterOrderSpec(c *OrderSpecContext) + + // EnterOrderSpecElement is called when entering the orderSpecElement production. + EnterOrderSpecElement(c *OrderSpecElementContext) + + // EnterWhereSpec is called when entering the whereSpec production. + EnterWhereSpec(c *WhereSpecContext) + + // EnterDistinctSpec is called when entering the distinctSpec production. + EnterDistinctSpec(c *DistinctSpecContext) + + // EnterSelectElements is called when entering the selectElements production. + EnterSelectElements(c *SelectElementsContext) + + // EnterSelectElement is called when entering the selectElement production. + EnterSelectElement(c *SelectElementContext) + + // EnterRelationElements is called when entering the relationElements production. + EnterRelationElements(c *RelationElementsContext) + + // EnterRelationElement is called when entering the relationElement production. + EnterRelationElement(c *RelationElementContext) + + // EnterRelalationContains is called when entering the relalationContains production. + EnterRelalationContains(c *RelalationContainsContext) + + // EnterRelalationContainsKey is called when entering the relalationContainsKey production. + EnterRelalationContainsKey(c *RelalationContainsKeyContext) + + // EnterFunctionCall is called when entering the functionCall production. + EnterFunctionCall(c *FunctionCallContext) + + // EnterFunctionArgs is called when entering the functionArgs production. + EnterFunctionArgs(c *FunctionArgsContext) + + // EnterConstant is called when entering the constant production. + EnterConstant(c *ConstantContext) + + // EnterDecimalLiteral is called when entering the decimalLiteral production. + EnterDecimalLiteral(c *DecimalLiteralContext) + + // EnterFloatLiteral is called when entering the floatLiteral production. + EnterFloatLiteral(c *FloatLiteralContext) + + // EnterStringLiteral is called when entering the stringLiteral production. + EnterStringLiteral(c *StringLiteralContext) + + // EnterBooleanLiteral is called when entering the booleanLiteral production. + EnterBooleanLiteral(c *BooleanLiteralContext) + + // EnterHexadecimalLiteral is called when entering the hexadecimalLiteral production. + EnterHexadecimalLiteral(c *HexadecimalLiteralContext) + + // EnterKeyspace is called when entering the keyspace production. + EnterKeyspace(c *KeyspaceContext) + + // EnterTable is called when entering the table production. + EnterTable(c *TableContext) + + // EnterColumn is called when entering the column production. + EnterColumn(c *ColumnContext) + + // EnterDataType is called when entering the dataType production. + EnterDataType(c *DataTypeContext) + + // EnterDataTypeName is called when entering the dataTypeName production. + EnterDataTypeName(c *DataTypeNameContext) + + // EnterDataTypeDefinition is called when entering the dataTypeDefinition production. + EnterDataTypeDefinition(c *DataTypeDefinitionContext) + + // EnterOrderDirection is called when entering the orderDirection production. + EnterOrderDirection(c *OrderDirectionContext) + + // EnterRole is called when entering the role production. + EnterRole(c *RoleContext) + + // EnterTrigger is called when entering the trigger production. + EnterTrigger(c *TriggerContext) + + // EnterTriggerClass is called when entering the triggerClass production. + EnterTriggerClass(c *TriggerClassContext) + + // EnterMaterializedView is called when entering the materializedView production. + EnterMaterializedView(c *MaterializedViewContext) + + // EnterType_ is called when entering the type_ production. + EnterType_(c *Type_Context) + + // EnterAggregate is called when entering the aggregate production. + EnterAggregate(c *AggregateContext) + + // EnterFunction_ is called when entering the function_ production. + EnterFunction_(c *Function_Context) + + // EnterLanguage is called when entering the language production. + EnterLanguage(c *LanguageContext) + + // EnterUser is called when entering the user production. + EnterUser(c *UserContext) + + // EnterPassword is called when entering the password production. + EnterPassword(c *PasswordContext) + + // EnterHashKey is called when entering the hashKey production. + EnterHashKey(c *HashKeyContext) + + // EnterParam is called when entering the param production. + EnterParam(c *ParamContext) + + // EnterParamName is called when entering the paramName production. + EnterParamName(c *ParamNameContext) + + // EnterKwAdd is called when entering the kwAdd production. + EnterKwAdd(c *KwAddContext) + + // EnterKwAggregate is called when entering the kwAggregate production. + EnterKwAggregate(c *KwAggregateContext) + + // EnterKwAll is called when entering the kwAll production. + EnterKwAll(c *KwAllContext) + + // EnterKwAllPermissions is called when entering the kwAllPermissions production. + EnterKwAllPermissions(c *KwAllPermissionsContext) + + // EnterKwAllow is called when entering the kwAllow production. + EnterKwAllow(c *KwAllowContext) + + // EnterKwAlter is called when entering the kwAlter production. + EnterKwAlter(c *KwAlterContext) + + // EnterKwAnd is called when entering the kwAnd production. + EnterKwAnd(c *KwAndContext) + + // EnterKwApply is called when entering the kwApply production. + EnterKwApply(c *KwApplyContext) + + // EnterKwAs is called when entering the kwAs production. + EnterKwAs(c *KwAsContext) + + // EnterKwAsc is called when entering the kwAsc production. + EnterKwAsc(c *KwAscContext) + + // EnterKwAuthorize is called when entering the kwAuthorize production. + EnterKwAuthorize(c *KwAuthorizeContext) + + // EnterKwBatch is called when entering the kwBatch production. + EnterKwBatch(c *KwBatchContext) + + // EnterKwBegin is called when entering the kwBegin production. + EnterKwBegin(c *KwBeginContext) + + // EnterKwBy is called when entering the kwBy production. + EnterKwBy(c *KwByContext) + + // EnterKwCalled is called when entering the kwCalled production. + EnterKwCalled(c *KwCalledContext) + + // EnterKwClustering is called when entering the kwClustering production. + EnterKwClustering(c *KwClusteringContext) + + // EnterKwCompact is called when entering the kwCompact production. + EnterKwCompact(c *KwCompactContext) + + // EnterKwContains is called when entering the kwContains production. + EnterKwContains(c *KwContainsContext) + + // EnterKwCreate is called when entering the kwCreate production. + EnterKwCreate(c *KwCreateContext) + + // EnterKwDelete is called when entering the kwDelete production. + EnterKwDelete(c *KwDeleteContext) + + // EnterKwDesc is called when entering the kwDesc production. + EnterKwDesc(c *KwDescContext) + + // EnterKwDescibe is called when entering the kwDescibe production. + EnterKwDescibe(c *KwDescibeContext) + + // EnterKwDistinct is called when entering the kwDistinct production. + EnterKwDistinct(c *KwDistinctContext) + + // EnterKwDrop is called when entering the kwDrop production. + EnterKwDrop(c *KwDropContext) + + // EnterKwDurableWrites is called when entering the kwDurableWrites production. + EnterKwDurableWrites(c *KwDurableWritesContext) + + // EnterKwEntries is called when entering the kwEntries production. + EnterKwEntries(c *KwEntriesContext) + + // EnterKwExecute is called when entering the kwExecute production. + EnterKwExecute(c *KwExecuteContext) + + // EnterKwExists is called when entering the kwExists production. + EnterKwExists(c *KwExistsContext) + + // EnterKwFiltering is called when entering the kwFiltering production. + EnterKwFiltering(c *KwFilteringContext) + + // EnterKwFinalfunc is called when entering the kwFinalfunc production. + EnterKwFinalfunc(c *KwFinalfuncContext) + + // EnterKwFrom is called when entering the kwFrom production. + EnterKwFrom(c *KwFromContext) + + // EnterKwFull is called when entering the kwFull production. + EnterKwFull(c *KwFullContext) + + // EnterKwFunction is called when entering the kwFunction production. + EnterKwFunction(c *KwFunctionContext) + + // EnterKwFunctions is called when entering the kwFunctions production. + EnterKwFunctions(c *KwFunctionsContext) + + // EnterKwGrant is called when entering the kwGrant production. + EnterKwGrant(c *KwGrantContext) + + // EnterKwIf is called when entering the kwIf production. + EnterKwIf(c *KwIfContext) + + // EnterKwIn is called when entering the kwIn production. + EnterKwIn(c *KwInContext) + + // EnterKwIndex is called when entering the kwIndex production. + EnterKwIndex(c *KwIndexContext) + + // EnterKwInitcond is called when entering the kwInitcond production. + EnterKwInitcond(c *KwInitcondContext) + + // EnterKwInput is called when entering the kwInput production. + EnterKwInput(c *KwInputContext) + + // EnterKwInsert is called when entering the kwInsert production. + EnterKwInsert(c *KwInsertContext) + + // EnterKwInto is called when entering the kwInto production. + EnterKwInto(c *KwIntoContext) + + // EnterKwIs is called when entering the kwIs production. + EnterKwIs(c *KwIsContext) + + // EnterKwJson is called when entering the kwJson production. + EnterKwJson(c *KwJsonContext) + + // EnterKwKey is called when entering the kwKey production. + EnterKwKey(c *KwKeyContext) + + // EnterKwKeys is called when entering the kwKeys production. + EnterKwKeys(c *KwKeysContext) + + // EnterKwKeyspace is called when entering the kwKeyspace production. + EnterKwKeyspace(c *KwKeyspaceContext) + + // EnterKwKeyspaces is called when entering the kwKeyspaces production. + EnterKwKeyspaces(c *KwKeyspacesContext) + + // EnterKwLanguage is called when entering the kwLanguage production. + EnterKwLanguage(c *KwLanguageContext) + + // EnterKwLimit is called when entering the kwLimit production. + EnterKwLimit(c *KwLimitContext) + + // EnterKwList is called when entering the kwList production. + EnterKwList(c *KwListContext) + + // EnterKwLogged is called when entering the kwLogged production. + EnterKwLogged(c *KwLoggedContext) + + // EnterKwLogin is called when entering the kwLogin production. + EnterKwLogin(c *KwLoginContext) + + // EnterKwMaterialized is called when entering the kwMaterialized production. + EnterKwMaterialized(c *KwMaterializedContext) + + // EnterKwModify is called when entering the kwModify production. + EnterKwModify(c *KwModifyContext) + + // EnterKwNosuperuser is called when entering the kwNosuperuser production. + EnterKwNosuperuser(c *KwNosuperuserContext) + + // EnterKwNorecursive is called when entering the kwNorecursive production. + EnterKwNorecursive(c *KwNorecursiveContext) + + // EnterKwNot is called when entering the kwNot production. + EnterKwNot(c *KwNotContext) + + // EnterKwNull is called when entering the kwNull production. + EnterKwNull(c *KwNullContext) + + // EnterKwOf is called when entering the kwOf production. + EnterKwOf(c *KwOfContext) + + // EnterKwOn is called when entering the kwOn production. + EnterKwOn(c *KwOnContext) + + // EnterKwOptions is called when entering the kwOptions production. + EnterKwOptions(c *KwOptionsContext) + + // EnterKwOr is called when entering the kwOr production. + EnterKwOr(c *KwOrContext) + + // EnterKwOrder is called when entering the kwOrder production. + EnterKwOrder(c *KwOrderContext) + + // EnterKwPassword is called when entering the kwPassword production. + EnterKwPassword(c *KwPasswordContext) + + // EnterKwPrimary is called when entering the kwPrimary production. + EnterKwPrimary(c *KwPrimaryContext) + + // EnterKwRename is called when entering the kwRename production. + EnterKwRename(c *KwRenameContext) + + // EnterKwReplace is called when entering the kwReplace production. + EnterKwReplace(c *KwReplaceContext) + + // EnterKwReplication is called when entering the kwReplication production. + EnterKwReplication(c *KwReplicationContext) + + // EnterKwReturns is called when entering the kwReturns production. + EnterKwReturns(c *KwReturnsContext) + + // EnterKwRole is called when entering the kwRole production. + EnterKwRole(c *KwRoleContext) + + // EnterKwRoles is called when entering the kwRoles production. + EnterKwRoles(c *KwRolesContext) + + // EnterKwSelect is called when entering the kwSelect production. + EnterKwSelect(c *KwSelectContext) + + // EnterKwSet is called when entering the kwSet production. + EnterKwSet(c *KwSetContext) + + // EnterKwSfunc is called when entering the kwSfunc production. + EnterKwSfunc(c *KwSfuncContext) + + // EnterKwStorage is called when entering the kwStorage production. + EnterKwStorage(c *KwStorageContext) + + // EnterKwStype is called when entering the kwStype production. + EnterKwStype(c *KwStypeContext) + + // EnterKwSuperuser is called when entering the kwSuperuser production. + EnterKwSuperuser(c *KwSuperuserContext) + + // EnterKwTable is called when entering the kwTable production. + EnterKwTable(c *KwTableContext) + + // EnterKwTimestamp is called when entering the kwTimestamp production. + EnterKwTimestamp(c *KwTimestampContext) + + // EnterKwTo is called when entering the kwTo production. + EnterKwTo(c *KwToContext) + + // EnterKwTrigger is called when entering the kwTrigger production. + EnterKwTrigger(c *KwTriggerContext) + + // EnterKwTruncate is called when entering the kwTruncate production. + EnterKwTruncate(c *KwTruncateContext) + + // EnterKwTtl is called when entering the kwTtl production. + EnterKwTtl(c *KwTtlContext) + + // EnterKwType is called when entering the kwType production. + EnterKwType(c *KwTypeContext) + + // EnterKwUnlogged is called when entering the kwUnlogged production. + EnterKwUnlogged(c *KwUnloggedContext) + + // EnterKwUpdate is called when entering the kwUpdate production. + EnterKwUpdate(c *KwUpdateContext) + + // EnterKwUse is called when entering the kwUse production. + EnterKwUse(c *KwUseContext) + + // EnterKwUser is called when entering the kwUser production. + EnterKwUser(c *KwUserContext) + + // EnterKwUsing is called when entering the kwUsing production. + EnterKwUsing(c *KwUsingContext) + + // EnterKwValues is called when entering the kwValues production. + EnterKwValues(c *KwValuesContext) + + // EnterKwView is called when entering the kwView production. + EnterKwView(c *KwViewContext) + + // EnterKwWhere is called when entering the kwWhere production. + EnterKwWhere(c *KwWhereContext) + + // EnterKwWith is called when entering the kwWith production. + EnterKwWith(c *KwWithContext) + + // EnterKwRevoke is called when entering the kwRevoke production. + EnterKwRevoke(c *KwRevokeContext) + + // EnterSyntaxBracketLr is called when entering the syntaxBracketLr production. + EnterSyntaxBracketLr(c *SyntaxBracketLrContext) + + // EnterSyntaxBracketRr is called when entering the syntaxBracketRr production. + EnterSyntaxBracketRr(c *SyntaxBracketRrContext) + + // EnterSyntaxBracketLc is called when entering the syntaxBracketLc production. + EnterSyntaxBracketLc(c *SyntaxBracketLcContext) + + // EnterSyntaxBracketRc is called when entering the syntaxBracketRc production. + EnterSyntaxBracketRc(c *SyntaxBracketRcContext) + + // EnterSyntaxBracketLa is called when entering the syntaxBracketLa production. + EnterSyntaxBracketLa(c *SyntaxBracketLaContext) + + // EnterSyntaxBracketRa is called when entering the syntaxBracketRa production. + EnterSyntaxBracketRa(c *SyntaxBracketRaContext) + + // EnterSyntaxBracketLs is called when entering the syntaxBracketLs production. + EnterSyntaxBracketLs(c *SyntaxBracketLsContext) + + // EnterSyntaxBracketRs is called when entering the syntaxBracketRs production. + EnterSyntaxBracketRs(c *SyntaxBracketRsContext) + + // EnterSyntaxComma is called when entering the syntaxComma production. + EnterSyntaxComma(c *SyntaxCommaContext) + + // EnterSyntaxColon is called when entering the syntaxColon production. + EnterSyntaxColon(c *SyntaxColonContext) + + // ExitRoot is called when exiting the root production. + ExitRoot(c *RootContext) + + // ExitCqls is called when exiting the cqls production. + ExitCqls(c *CqlsContext) + + // ExitStatementSeparator is called when exiting the statementSeparator production. + ExitStatementSeparator(c *StatementSeparatorContext) + + // ExitEmpty_ is called when exiting the empty_ production. + ExitEmpty_(c *Empty_Context) + + // ExitCql is called when exiting the cql production. + ExitCql(c *CqlContext) + + // ExitRevoke is called when exiting the revoke production. + ExitRevoke(c *RevokeContext) + + // ExitListRoles is called when exiting the listRoles production. + ExitListRoles(c *ListRolesContext) + + // ExitListPermissions is called when exiting the listPermissions production. + ExitListPermissions(c *ListPermissionsContext) + + // ExitGrant is called when exiting the grant production. + ExitGrant(c *GrantContext) + + // ExitPriviledge is called when exiting the priviledge production. + ExitPriviledge(c *PriviledgeContext) + + // ExitResource is called when exiting the resource production. + ExitResource(c *ResourceContext) + + // ExitCreateUser is called when exiting the createUser production. + ExitCreateUser(c *CreateUserContext) + + // ExitCreateRole is called when exiting the createRole production. + ExitCreateRole(c *CreateRoleContext) + + // ExitCreateType is called when exiting the createType production. + ExitCreateType(c *CreateTypeContext) + + // ExitTypeMemberColumnList is called when exiting the typeMemberColumnList production. + ExitTypeMemberColumnList(c *TypeMemberColumnListContext) + + // ExitCreateTrigger is called when exiting the createTrigger production. + ExitCreateTrigger(c *CreateTriggerContext) + + // ExitCreateMaterializedView is called when exiting the createMaterializedView production. + ExitCreateMaterializedView(c *CreateMaterializedViewContext) + + // ExitMaterializedViewWhere is called when exiting the materializedViewWhere production. + ExitMaterializedViewWhere(c *MaterializedViewWhereContext) + + // ExitColumnNotNullList is called when exiting the columnNotNullList production. + ExitColumnNotNullList(c *ColumnNotNullListContext) + + // ExitColumnNotNull is called when exiting the columnNotNull production. + ExitColumnNotNull(c *ColumnNotNullContext) + + // ExitMaterializedViewOptions is called when exiting the materializedViewOptions production. + ExitMaterializedViewOptions(c *MaterializedViewOptionsContext) + + // ExitCreateKeyspace is called when exiting the createKeyspace production. + ExitCreateKeyspace(c *CreateKeyspaceContext) + + // ExitCreateFunction is called when exiting the createFunction production. + ExitCreateFunction(c *CreateFunctionContext) + + // ExitCodeBlock is called when exiting the codeBlock production. + ExitCodeBlock(c *CodeBlockContext) + + // ExitParamList is called when exiting the paramList production. + ExitParamList(c *ParamListContext) + + // ExitReturnMode is called when exiting the returnMode production. + ExitReturnMode(c *ReturnModeContext) + + // ExitCreateAggregate is called when exiting the createAggregate production. + ExitCreateAggregate(c *CreateAggregateContext) + + // ExitInitCondDefinition is called when exiting the initCondDefinition production. + ExitInitCondDefinition(c *InitCondDefinitionContext) + + // ExitInitCondHash is called when exiting the initCondHash production. + ExitInitCondHash(c *InitCondHashContext) + + // ExitInitCondHashItem is called when exiting the initCondHashItem production. + ExitInitCondHashItem(c *InitCondHashItemContext) + + // ExitInitCondListNested is called when exiting the initCondListNested production. + ExitInitCondListNested(c *InitCondListNestedContext) + + // ExitInitCondList is called when exiting the initCondList production. + ExitInitCondList(c *InitCondListContext) + + // ExitOrReplace is called when exiting the orReplace production. + ExitOrReplace(c *OrReplaceContext) + + // ExitAlterUser is called when exiting the alterUser production. + ExitAlterUser(c *AlterUserContext) + + // ExitUserPassword is called when exiting the userPassword production. + ExitUserPassword(c *UserPasswordContext) + + // ExitUserSuperUser is called when exiting the userSuperUser production. + ExitUserSuperUser(c *UserSuperUserContext) + + // ExitAlterType is called when exiting the alterType production. + ExitAlterType(c *AlterTypeContext) + + // ExitAlterTypeOperation is called when exiting the alterTypeOperation production. + ExitAlterTypeOperation(c *AlterTypeOperationContext) + + // ExitAlterTypeRename is called when exiting the alterTypeRename production. + ExitAlterTypeRename(c *AlterTypeRenameContext) + + // ExitAlterTypeRenameList is called when exiting the alterTypeRenameList production. + ExitAlterTypeRenameList(c *AlterTypeRenameListContext) + + // ExitAlterTypeRenameItem is called when exiting the alterTypeRenameItem production. + ExitAlterTypeRenameItem(c *AlterTypeRenameItemContext) + + // ExitAlterTypeAdd is called when exiting the alterTypeAdd production. + ExitAlterTypeAdd(c *AlterTypeAddContext) + + // ExitAlterTypeAlterType is called when exiting the alterTypeAlterType production. + ExitAlterTypeAlterType(c *AlterTypeAlterTypeContext) + + // ExitAlterTable is called when exiting the alterTable production. + ExitAlterTable(c *AlterTableContext) + + // ExitAlterTableOperation is called when exiting the alterTableOperation production. + ExitAlterTableOperation(c *AlterTableOperationContext) + + // ExitAlterTableWith is called when exiting the alterTableWith production. + ExitAlterTableWith(c *AlterTableWithContext) + + // ExitAlterTableRename is called when exiting the alterTableRename production. + ExitAlterTableRename(c *AlterTableRenameContext) + + // ExitAlterTableDropCompactStorage is called when exiting the alterTableDropCompactStorage production. + ExitAlterTableDropCompactStorage(c *AlterTableDropCompactStorageContext) + + // ExitAlterTableDropColumns is called when exiting the alterTableDropColumns production. + ExitAlterTableDropColumns(c *AlterTableDropColumnsContext) + + // ExitAlterTableDropColumnList is called when exiting the alterTableDropColumnList production. + ExitAlterTableDropColumnList(c *AlterTableDropColumnListContext) + + // ExitAlterTableAdd is called when exiting the alterTableAdd production. + ExitAlterTableAdd(c *AlterTableAddContext) + + // ExitAlterTableColumnDefinition is called when exiting the alterTableColumnDefinition production. + ExitAlterTableColumnDefinition(c *AlterTableColumnDefinitionContext) + + // ExitAlterRole is called when exiting the alterRole production. + ExitAlterRole(c *AlterRoleContext) + + // ExitRoleWith is called when exiting the roleWith production. + ExitRoleWith(c *RoleWithContext) + + // ExitRoleWithOptions is called when exiting the roleWithOptions production. + ExitRoleWithOptions(c *RoleWithOptionsContext) + + // ExitAlterMaterializedView is called when exiting the alterMaterializedView production. + ExitAlterMaterializedView(c *AlterMaterializedViewContext) + + // ExitDropUser is called when exiting the dropUser production. + ExitDropUser(c *DropUserContext) + + // ExitDropType is called when exiting the dropType production. + ExitDropType(c *DropTypeContext) + + // ExitDropMaterializedView is called when exiting the dropMaterializedView production. + ExitDropMaterializedView(c *DropMaterializedViewContext) + + // ExitDropAggregate is called when exiting the dropAggregate production. + ExitDropAggregate(c *DropAggregateContext) + + // ExitDropFunction is called when exiting the dropFunction production. + ExitDropFunction(c *DropFunctionContext) + + // ExitDropTrigger is called when exiting the dropTrigger production. + ExitDropTrigger(c *DropTriggerContext) + + // ExitDropRole is called when exiting the dropRole production. + ExitDropRole(c *DropRoleContext) + + // ExitDropTable is called when exiting the dropTable production. + ExitDropTable(c *DropTableContext) + + // ExitDropKeyspace is called when exiting the dropKeyspace production. + ExitDropKeyspace(c *DropKeyspaceContext) + + // ExitDropIndex is called when exiting the dropIndex production. + ExitDropIndex(c *DropIndexContext) + + // ExitCreateTable is called when exiting the createTable production. + ExitCreateTable(c *CreateTableContext) + + // ExitWithElement is called when exiting the withElement production. + ExitWithElement(c *WithElementContext) + + // ExitTableOptions is called when exiting the tableOptions production. + ExitTableOptions(c *TableOptionsContext) + + // ExitClusteringOrder is called when exiting the clusteringOrder production. + ExitClusteringOrder(c *ClusteringOrderContext) + + // ExitTableOptionItem is called when exiting the tableOptionItem production. + ExitTableOptionItem(c *TableOptionItemContext) + + // ExitTableOptionName is called when exiting the tableOptionName production. + ExitTableOptionName(c *TableOptionNameContext) + + // ExitTableOptionValue is called when exiting the tableOptionValue production. + ExitTableOptionValue(c *TableOptionValueContext) + + // ExitOptionHash is called when exiting the optionHash production. + ExitOptionHash(c *OptionHashContext) + + // ExitOptionHashItem is called when exiting the optionHashItem production. + ExitOptionHashItem(c *OptionHashItemContext) + + // ExitOptionHashKey is called when exiting the optionHashKey production. + ExitOptionHashKey(c *OptionHashKeyContext) + + // ExitOptionHashValue is called when exiting the optionHashValue production. + ExitOptionHashValue(c *OptionHashValueContext) + + // ExitColumnDefinitionList is called when exiting the columnDefinitionList production. + ExitColumnDefinitionList(c *ColumnDefinitionListContext) + + // ExitColumnDefinition is called when exiting the columnDefinition production. + ExitColumnDefinition(c *ColumnDefinitionContext) + + // ExitPrimaryKeyColumn is called when exiting the primaryKeyColumn production. + ExitPrimaryKeyColumn(c *PrimaryKeyColumnContext) + + // ExitPrimaryKeyElement is called when exiting the primaryKeyElement production. + ExitPrimaryKeyElement(c *PrimaryKeyElementContext) + + // ExitPrimaryKeyDefinition is called when exiting the primaryKeyDefinition production. + ExitPrimaryKeyDefinition(c *PrimaryKeyDefinitionContext) + + // ExitSinglePrimaryKey is called when exiting the singlePrimaryKey production. + ExitSinglePrimaryKey(c *SinglePrimaryKeyContext) + + // ExitCompoundKey is called when exiting the compoundKey production. + ExitCompoundKey(c *CompoundKeyContext) + + // ExitCompositeKey is called when exiting the compositeKey production. + ExitCompositeKey(c *CompositeKeyContext) + + // ExitPartitionKeyList is called when exiting the partitionKeyList production. + ExitPartitionKeyList(c *PartitionKeyListContext) + + // ExitClusteringKeyList is called when exiting the clusteringKeyList production. + ExitClusteringKeyList(c *ClusteringKeyListContext) + + // ExitPartitionKey is called when exiting the partitionKey production. + ExitPartitionKey(c *PartitionKeyContext) + + // ExitClusteringKey is called when exiting the clusteringKey production. + ExitClusteringKey(c *ClusteringKeyContext) + + // ExitApplyBatch is called when exiting the applyBatch production. + ExitApplyBatch(c *ApplyBatchContext) + + // ExitBeginBatch is called when exiting the beginBatch production. + ExitBeginBatch(c *BeginBatchContext) + + // ExitBatchType is called when exiting the batchType production. + ExitBatchType(c *BatchTypeContext) + + // ExitAlterKeyspace is called when exiting the alterKeyspace production. + ExitAlterKeyspace(c *AlterKeyspaceContext) + + // ExitReplicationList is called when exiting the replicationList production. + ExitReplicationList(c *ReplicationListContext) + + // ExitReplicationListItem is called when exiting the replicationListItem production. + ExitReplicationListItem(c *ReplicationListItemContext) + + // ExitDurableWrites is called when exiting the durableWrites production. + ExitDurableWrites(c *DurableWritesContext) + + // ExitUse_ is called when exiting the use_ production. + ExitUse_(c *Use_Context) + + // ExitTruncate is called when exiting the truncate production. + ExitTruncate(c *TruncateContext) + + // ExitCreateIndex is called when exiting the createIndex production. + ExitCreateIndex(c *CreateIndexContext) + + // ExitIndexName is called when exiting the indexName production. + ExitIndexName(c *IndexNameContext) + + // ExitIndexColumnSpec is called when exiting the indexColumnSpec production. + ExitIndexColumnSpec(c *IndexColumnSpecContext) + + // ExitIndexKeysSpec is called when exiting the indexKeysSpec production. + ExitIndexKeysSpec(c *IndexKeysSpecContext) + + // ExitIndexEntriesSSpec is called when exiting the indexEntriesSSpec production. + ExitIndexEntriesSSpec(c *IndexEntriesSSpecContext) + + // ExitIndexFullSpec is called when exiting the indexFullSpec production. + ExitIndexFullSpec(c *IndexFullSpecContext) + + // ExitDelete_ is called when exiting the delete_ production. + ExitDelete_(c *Delete_Context) + + // ExitDeleteColumnList is called when exiting the deleteColumnList production. + ExitDeleteColumnList(c *DeleteColumnListContext) + + // ExitDeleteColumnItem is called when exiting the deleteColumnItem production. + ExitDeleteColumnItem(c *DeleteColumnItemContext) + + // ExitUpdate is called when exiting the update production. + ExitUpdate(c *UpdateContext) + + // ExitIfSpec is called when exiting the ifSpec production. + ExitIfSpec(c *IfSpecContext) + + // ExitIfConditionList is called when exiting the ifConditionList production. + ExitIfConditionList(c *IfConditionListContext) + + // ExitIfCondition is called when exiting the ifCondition production. + ExitIfCondition(c *IfConditionContext) + + // ExitAssignments is called when exiting the assignments production. + ExitAssignments(c *AssignmentsContext) + + // ExitAssignmentElement is called when exiting the assignmentElement production. + ExitAssignmentElement(c *AssignmentElementContext) + + // ExitAssignmentSet is called when exiting the assignmentSet production. + ExitAssignmentSet(c *AssignmentSetContext) + + // ExitAssignmentMap is called when exiting the assignmentMap production. + ExitAssignmentMap(c *AssignmentMapContext) + + // ExitAssignmentList is called when exiting the assignmentList production. + ExitAssignmentList(c *AssignmentListContext) + + // ExitAssignmentTuple is called when exiting the assignmentTuple production. + ExitAssignmentTuple(c *AssignmentTupleContext) + + // ExitInsert is called when exiting the insert production. + ExitInsert(c *InsertContext) + + // ExitUsingTtlTimestamp is called when exiting the usingTtlTimestamp production. + ExitUsingTtlTimestamp(c *UsingTtlTimestampContext) + + // ExitTimestamp is called when exiting the timestamp production. + ExitTimestamp(c *TimestampContext) + + // ExitTtl is called when exiting the ttl production. + ExitTtl(c *TtlContext) + + // ExitUsingTimestampSpec is called when exiting the usingTimestampSpec production. + ExitUsingTimestampSpec(c *UsingTimestampSpecContext) + + // ExitIfNotExist is called when exiting the ifNotExist production. + ExitIfNotExist(c *IfNotExistContext) + + // ExitIfExist is called when exiting the ifExist production. + ExitIfExist(c *IfExistContext) + + // ExitInsertValuesSpec is called when exiting the insertValuesSpec production. + ExitInsertValuesSpec(c *InsertValuesSpecContext) + + // ExitInsertColumnSpec is called when exiting the insertColumnSpec production. + ExitInsertColumnSpec(c *InsertColumnSpecContext) + + // ExitColumnList is called when exiting the columnList production. + ExitColumnList(c *ColumnListContext) + + // ExitExpressionList is called when exiting the expressionList production. + ExitExpressionList(c *ExpressionListContext) + + // ExitExpression is called when exiting the expression production. + ExitExpression(c *ExpressionContext) + + // ExitSelect_ is called when exiting the select_ production. + ExitSelect_(c *Select_Context) + + // ExitAllowFilteringSpec is called when exiting the allowFilteringSpec production. + ExitAllowFilteringSpec(c *AllowFilteringSpecContext) + + // ExitLimitSpec is called when exiting the limitSpec production. + ExitLimitSpec(c *LimitSpecContext) + + // ExitFromSpec is called when exiting the fromSpec production. + ExitFromSpec(c *FromSpecContext) + + // ExitFromSpecElement is called when exiting the fromSpecElement production. + ExitFromSpecElement(c *FromSpecElementContext) + + // ExitOrderSpec is called when exiting the orderSpec production. + ExitOrderSpec(c *OrderSpecContext) + + // ExitOrderSpecElement is called when exiting the orderSpecElement production. + ExitOrderSpecElement(c *OrderSpecElementContext) + + // ExitWhereSpec is called when exiting the whereSpec production. + ExitWhereSpec(c *WhereSpecContext) + + // ExitDistinctSpec is called when exiting the distinctSpec production. + ExitDistinctSpec(c *DistinctSpecContext) + + // ExitSelectElements is called when exiting the selectElements production. + ExitSelectElements(c *SelectElementsContext) + + // ExitSelectElement is called when exiting the selectElement production. + ExitSelectElement(c *SelectElementContext) + + // ExitRelationElements is called when exiting the relationElements production. + ExitRelationElements(c *RelationElementsContext) + + // ExitRelationElement is called when exiting the relationElement production. + ExitRelationElement(c *RelationElementContext) + + // ExitRelalationContains is called when exiting the relalationContains production. + ExitRelalationContains(c *RelalationContainsContext) + + // ExitRelalationContainsKey is called when exiting the relalationContainsKey production. + ExitRelalationContainsKey(c *RelalationContainsKeyContext) + + // ExitFunctionCall is called when exiting the functionCall production. + ExitFunctionCall(c *FunctionCallContext) + + // ExitFunctionArgs is called when exiting the functionArgs production. + ExitFunctionArgs(c *FunctionArgsContext) + + // ExitConstant is called when exiting the constant production. + ExitConstant(c *ConstantContext) + + // ExitDecimalLiteral is called when exiting the decimalLiteral production. + ExitDecimalLiteral(c *DecimalLiteralContext) + + // ExitFloatLiteral is called when exiting the floatLiteral production. + ExitFloatLiteral(c *FloatLiteralContext) + + // ExitStringLiteral is called when exiting the stringLiteral production. + ExitStringLiteral(c *StringLiteralContext) + + // ExitBooleanLiteral is called when exiting the booleanLiteral production. + ExitBooleanLiteral(c *BooleanLiteralContext) + + // ExitHexadecimalLiteral is called when exiting the hexadecimalLiteral production. + ExitHexadecimalLiteral(c *HexadecimalLiteralContext) + + // ExitKeyspace is called when exiting the keyspace production. + ExitKeyspace(c *KeyspaceContext) + + // ExitTable is called when exiting the table production. + ExitTable(c *TableContext) + + // ExitColumn is called when exiting the column production. + ExitColumn(c *ColumnContext) + + // ExitDataType is called when exiting the dataType production. + ExitDataType(c *DataTypeContext) + + // ExitDataTypeName is called when exiting the dataTypeName production. + ExitDataTypeName(c *DataTypeNameContext) + + // ExitDataTypeDefinition is called when exiting the dataTypeDefinition production. + ExitDataTypeDefinition(c *DataTypeDefinitionContext) + + // ExitOrderDirection is called when exiting the orderDirection production. + ExitOrderDirection(c *OrderDirectionContext) + + // ExitRole is called when exiting the role production. + ExitRole(c *RoleContext) + + // ExitTrigger is called when exiting the trigger production. + ExitTrigger(c *TriggerContext) + + // ExitTriggerClass is called when exiting the triggerClass production. + ExitTriggerClass(c *TriggerClassContext) + + // ExitMaterializedView is called when exiting the materializedView production. + ExitMaterializedView(c *MaterializedViewContext) + + // ExitType_ is called when exiting the type_ production. + ExitType_(c *Type_Context) + + // ExitAggregate is called when exiting the aggregate production. + ExitAggregate(c *AggregateContext) + + // ExitFunction_ is called when exiting the function_ production. + ExitFunction_(c *Function_Context) + + // ExitLanguage is called when exiting the language production. + ExitLanguage(c *LanguageContext) + + // ExitUser is called when exiting the user production. + ExitUser(c *UserContext) + + // ExitPassword is called when exiting the password production. + ExitPassword(c *PasswordContext) + + // ExitHashKey is called when exiting the hashKey production. + ExitHashKey(c *HashKeyContext) + + // ExitParam is called when exiting the param production. + ExitParam(c *ParamContext) + + // ExitParamName is called when exiting the paramName production. + ExitParamName(c *ParamNameContext) + + // ExitKwAdd is called when exiting the kwAdd production. + ExitKwAdd(c *KwAddContext) + + // ExitKwAggregate is called when exiting the kwAggregate production. + ExitKwAggregate(c *KwAggregateContext) + + // ExitKwAll is called when exiting the kwAll production. + ExitKwAll(c *KwAllContext) + + // ExitKwAllPermissions is called when exiting the kwAllPermissions production. + ExitKwAllPermissions(c *KwAllPermissionsContext) + + // ExitKwAllow is called when exiting the kwAllow production. + ExitKwAllow(c *KwAllowContext) + + // ExitKwAlter is called when exiting the kwAlter production. + ExitKwAlter(c *KwAlterContext) + + // ExitKwAnd is called when exiting the kwAnd production. + ExitKwAnd(c *KwAndContext) + + // ExitKwApply is called when exiting the kwApply production. + ExitKwApply(c *KwApplyContext) + + // ExitKwAs is called when exiting the kwAs production. + ExitKwAs(c *KwAsContext) + + // ExitKwAsc is called when exiting the kwAsc production. + ExitKwAsc(c *KwAscContext) + + // ExitKwAuthorize is called when exiting the kwAuthorize production. + ExitKwAuthorize(c *KwAuthorizeContext) + + // ExitKwBatch is called when exiting the kwBatch production. + ExitKwBatch(c *KwBatchContext) + + // ExitKwBegin is called when exiting the kwBegin production. + ExitKwBegin(c *KwBeginContext) + + // ExitKwBy is called when exiting the kwBy production. + ExitKwBy(c *KwByContext) + + // ExitKwCalled is called when exiting the kwCalled production. + ExitKwCalled(c *KwCalledContext) + + // ExitKwClustering is called when exiting the kwClustering production. + ExitKwClustering(c *KwClusteringContext) + + // ExitKwCompact is called when exiting the kwCompact production. + ExitKwCompact(c *KwCompactContext) + + // ExitKwContains is called when exiting the kwContains production. + ExitKwContains(c *KwContainsContext) + + // ExitKwCreate is called when exiting the kwCreate production. + ExitKwCreate(c *KwCreateContext) + + // ExitKwDelete is called when exiting the kwDelete production. + ExitKwDelete(c *KwDeleteContext) + + // ExitKwDesc is called when exiting the kwDesc production. + ExitKwDesc(c *KwDescContext) + + // ExitKwDescibe is called when exiting the kwDescibe production. + ExitKwDescibe(c *KwDescibeContext) + + // ExitKwDistinct is called when exiting the kwDistinct production. + ExitKwDistinct(c *KwDistinctContext) + + // ExitKwDrop is called when exiting the kwDrop production. + ExitKwDrop(c *KwDropContext) + + // ExitKwDurableWrites is called when exiting the kwDurableWrites production. + ExitKwDurableWrites(c *KwDurableWritesContext) + + // ExitKwEntries is called when exiting the kwEntries production. + ExitKwEntries(c *KwEntriesContext) + + // ExitKwExecute is called when exiting the kwExecute production. + ExitKwExecute(c *KwExecuteContext) + + // ExitKwExists is called when exiting the kwExists production. + ExitKwExists(c *KwExistsContext) + + // ExitKwFiltering is called when exiting the kwFiltering production. + ExitKwFiltering(c *KwFilteringContext) + + // ExitKwFinalfunc is called when exiting the kwFinalfunc production. + ExitKwFinalfunc(c *KwFinalfuncContext) + + // ExitKwFrom is called when exiting the kwFrom production. + ExitKwFrom(c *KwFromContext) + + // ExitKwFull is called when exiting the kwFull production. + ExitKwFull(c *KwFullContext) + + // ExitKwFunction is called when exiting the kwFunction production. + ExitKwFunction(c *KwFunctionContext) + + // ExitKwFunctions is called when exiting the kwFunctions production. + ExitKwFunctions(c *KwFunctionsContext) + + // ExitKwGrant is called when exiting the kwGrant production. + ExitKwGrant(c *KwGrantContext) + + // ExitKwIf is called when exiting the kwIf production. + ExitKwIf(c *KwIfContext) + + // ExitKwIn is called when exiting the kwIn production. + ExitKwIn(c *KwInContext) + + // ExitKwIndex is called when exiting the kwIndex production. + ExitKwIndex(c *KwIndexContext) + + // ExitKwInitcond is called when exiting the kwInitcond production. + ExitKwInitcond(c *KwInitcondContext) + + // ExitKwInput is called when exiting the kwInput production. + ExitKwInput(c *KwInputContext) + + // ExitKwInsert is called when exiting the kwInsert production. + ExitKwInsert(c *KwInsertContext) + + // ExitKwInto is called when exiting the kwInto production. + ExitKwInto(c *KwIntoContext) + + // ExitKwIs is called when exiting the kwIs production. + ExitKwIs(c *KwIsContext) + + // ExitKwJson is called when exiting the kwJson production. + ExitKwJson(c *KwJsonContext) + + // ExitKwKey is called when exiting the kwKey production. + ExitKwKey(c *KwKeyContext) + + // ExitKwKeys is called when exiting the kwKeys production. + ExitKwKeys(c *KwKeysContext) + + // ExitKwKeyspace is called when exiting the kwKeyspace production. + ExitKwKeyspace(c *KwKeyspaceContext) + + // ExitKwKeyspaces is called when exiting the kwKeyspaces production. + ExitKwKeyspaces(c *KwKeyspacesContext) + + // ExitKwLanguage is called when exiting the kwLanguage production. + ExitKwLanguage(c *KwLanguageContext) + + // ExitKwLimit is called when exiting the kwLimit production. + ExitKwLimit(c *KwLimitContext) + + // ExitKwList is called when exiting the kwList production. + ExitKwList(c *KwListContext) + + // ExitKwLogged is called when exiting the kwLogged production. + ExitKwLogged(c *KwLoggedContext) + + // ExitKwLogin is called when exiting the kwLogin production. + ExitKwLogin(c *KwLoginContext) + + // ExitKwMaterialized is called when exiting the kwMaterialized production. + ExitKwMaterialized(c *KwMaterializedContext) + + // ExitKwModify is called when exiting the kwModify production. + ExitKwModify(c *KwModifyContext) + + // ExitKwNosuperuser is called when exiting the kwNosuperuser production. + ExitKwNosuperuser(c *KwNosuperuserContext) + + // ExitKwNorecursive is called when exiting the kwNorecursive production. + ExitKwNorecursive(c *KwNorecursiveContext) + + // ExitKwNot is called when exiting the kwNot production. + ExitKwNot(c *KwNotContext) + + // ExitKwNull is called when exiting the kwNull production. + ExitKwNull(c *KwNullContext) + + // ExitKwOf is called when exiting the kwOf production. + ExitKwOf(c *KwOfContext) + + // ExitKwOn is called when exiting the kwOn production. + ExitKwOn(c *KwOnContext) + + // ExitKwOptions is called when exiting the kwOptions production. + ExitKwOptions(c *KwOptionsContext) + + // ExitKwOr is called when exiting the kwOr production. + ExitKwOr(c *KwOrContext) + + // ExitKwOrder is called when exiting the kwOrder production. + ExitKwOrder(c *KwOrderContext) + + // ExitKwPassword is called when exiting the kwPassword production. + ExitKwPassword(c *KwPasswordContext) + + // ExitKwPrimary is called when exiting the kwPrimary production. + ExitKwPrimary(c *KwPrimaryContext) + + // ExitKwRename is called when exiting the kwRename production. + ExitKwRename(c *KwRenameContext) + + // ExitKwReplace is called when exiting the kwReplace production. + ExitKwReplace(c *KwReplaceContext) + + // ExitKwReplication is called when exiting the kwReplication production. + ExitKwReplication(c *KwReplicationContext) + + // ExitKwReturns is called when exiting the kwReturns production. + ExitKwReturns(c *KwReturnsContext) + + // ExitKwRole is called when exiting the kwRole production. + ExitKwRole(c *KwRoleContext) + + // ExitKwRoles is called when exiting the kwRoles production. + ExitKwRoles(c *KwRolesContext) + + // ExitKwSelect is called when exiting the kwSelect production. + ExitKwSelect(c *KwSelectContext) + + // ExitKwSet is called when exiting the kwSet production. + ExitKwSet(c *KwSetContext) + + // ExitKwSfunc is called when exiting the kwSfunc production. + ExitKwSfunc(c *KwSfuncContext) + + // ExitKwStorage is called when exiting the kwStorage production. + ExitKwStorage(c *KwStorageContext) + + // ExitKwStype is called when exiting the kwStype production. + ExitKwStype(c *KwStypeContext) + + // ExitKwSuperuser is called when exiting the kwSuperuser production. + ExitKwSuperuser(c *KwSuperuserContext) + + // ExitKwTable is called when exiting the kwTable production. + ExitKwTable(c *KwTableContext) + + // ExitKwTimestamp is called when exiting the kwTimestamp production. + ExitKwTimestamp(c *KwTimestampContext) + + // ExitKwTo is called when exiting the kwTo production. + ExitKwTo(c *KwToContext) + + // ExitKwTrigger is called when exiting the kwTrigger production. + ExitKwTrigger(c *KwTriggerContext) + + // ExitKwTruncate is called when exiting the kwTruncate production. + ExitKwTruncate(c *KwTruncateContext) + + // ExitKwTtl is called when exiting the kwTtl production. + ExitKwTtl(c *KwTtlContext) + + // ExitKwType is called when exiting the kwType production. + ExitKwType(c *KwTypeContext) + + // ExitKwUnlogged is called when exiting the kwUnlogged production. + ExitKwUnlogged(c *KwUnloggedContext) + + // ExitKwUpdate is called when exiting the kwUpdate production. + ExitKwUpdate(c *KwUpdateContext) + + // ExitKwUse is called when exiting the kwUse production. + ExitKwUse(c *KwUseContext) + + // ExitKwUser is called when exiting the kwUser production. + ExitKwUser(c *KwUserContext) + + // ExitKwUsing is called when exiting the kwUsing production. + ExitKwUsing(c *KwUsingContext) + + // ExitKwValues is called when exiting the kwValues production. + ExitKwValues(c *KwValuesContext) + + // ExitKwView is called when exiting the kwView production. + ExitKwView(c *KwViewContext) + + // ExitKwWhere is called when exiting the kwWhere production. + ExitKwWhere(c *KwWhereContext) + + // ExitKwWith is called when exiting the kwWith production. + ExitKwWith(c *KwWithContext) + + // ExitKwRevoke is called when exiting the kwRevoke production. + ExitKwRevoke(c *KwRevokeContext) + + // ExitSyntaxBracketLr is called when exiting the syntaxBracketLr production. + ExitSyntaxBracketLr(c *SyntaxBracketLrContext) + + // ExitSyntaxBracketRr is called when exiting the syntaxBracketRr production. + ExitSyntaxBracketRr(c *SyntaxBracketRrContext) + + // ExitSyntaxBracketLc is called when exiting the syntaxBracketLc production. + ExitSyntaxBracketLc(c *SyntaxBracketLcContext) + + // ExitSyntaxBracketRc is called when exiting the syntaxBracketRc production. + ExitSyntaxBracketRc(c *SyntaxBracketRcContext) + + // ExitSyntaxBracketLa is called when exiting the syntaxBracketLa production. + ExitSyntaxBracketLa(c *SyntaxBracketLaContext) + + // ExitSyntaxBracketRa is called when exiting the syntaxBracketRa production. + ExitSyntaxBracketRa(c *SyntaxBracketRaContext) + + // ExitSyntaxBracketLs is called when exiting the syntaxBracketLs production. + ExitSyntaxBracketLs(c *SyntaxBracketLsContext) + + // ExitSyntaxBracketRs is called when exiting the syntaxBracketRs production. + ExitSyntaxBracketRs(c *SyntaxBracketRsContext) + + // ExitSyntaxComma is called when exiting the syntaxComma production. + ExitSyntaxComma(c *SyntaxCommaContext) + + // ExitSyntaxColon is called when exiting the syntaxColon production. + ExitSyntaxColon(c *SyntaxColonContext) +} diff --git a/cql/cqlparser_visitor.go b/cql/cqlparser_visitor.go new file mode 100644 index 0000000..f827b5f --- /dev/null +++ b/cql/cqlparser_visitor.go @@ -0,0 +1,840 @@ +// Code generated from CqlParser.g4 by ANTLR 4.13.2. DO NOT EDIT. + +package cql // CqlParser +import "github.com/antlr4-go/antlr/v4" + +// A complete Visitor for a parse tree produced by CqlParser. +type CqlParserVisitor interface { + antlr.ParseTreeVisitor + + // Visit a parse tree produced by CqlParser#root. + VisitRoot(ctx *RootContext) interface{} + + // Visit a parse tree produced by CqlParser#cqls. + VisitCqls(ctx *CqlsContext) interface{} + + // Visit a parse tree produced by CqlParser#statementSeparator. + VisitStatementSeparator(ctx *StatementSeparatorContext) interface{} + + // Visit a parse tree produced by CqlParser#empty_. + VisitEmpty_(ctx *Empty_Context) interface{} + + // Visit a parse tree produced by CqlParser#cql. + VisitCql(ctx *CqlContext) interface{} + + // Visit a parse tree produced by CqlParser#revoke. + VisitRevoke(ctx *RevokeContext) interface{} + + // Visit a parse tree produced by CqlParser#listRoles. + VisitListRoles(ctx *ListRolesContext) interface{} + + // Visit a parse tree produced by CqlParser#listPermissions. + VisitListPermissions(ctx *ListPermissionsContext) interface{} + + // Visit a parse tree produced by CqlParser#grant. + VisitGrant(ctx *GrantContext) interface{} + + // Visit a parse tree produced by CqlParser#priviledge. + VisitPriviledge(ctx *PriviledgeContext) interface{} + + // Visit a parse tree produced by CqlParser#resource. + VisitResource(ctx *ResourceContext) interface{} + + // Visit a parse tree produced by CqlParser#createUser. + VisitCreateUser(ctx *CreateUserContext) interface{} + + // Visit a parse tree produced by CqlParser#createRole. + VisitCreateRole(ctx *CreateRoleContext) interface{} + + // Visit a parse tree produced by CqlParser#createType. + VisitCreateType(ctx *CreateTypeContext) interface{} + + // Visit a parse tree produced by CqlParser#typeMemberColumnList. + VisitTypeMemberColumnList(ctx *TypeMemberColumnListContext) interface{} + + // Visit a parse tree produced by CqlParser#createTrigger. + VisitCreateTrigger(ctx *CreateTriggerContext) interface{} + + // Visit a parse tree produced by CqlParser#createMaterializedView. + VisitCreateMaterializedView(ctx *CreateMaterializedViewContext) interface{} + + // Visit a parse tree produced by CqlParser#materializedViewWhere. + VisitMaterializedViewWhere(ctx *MaterializedViewWhereContext) interface{} + + // Visit a parse tree produced by CqlParser#columnNotNullList. + VisitColumnNotNullList(ctx *ColumnNotNullListContext) interface{} + + // Visit a parse tree produced by CqlParser#columnNotNull. + VisitColumnNotNull(ctx *ColumnNotNullContext) interface{} + + // Visit a parse tree produced by CqlParser#materializedViewOptions. + VisitMaterializedViewOptions(ctx *MaterializedViewOptionsContext) interface{} + + // Visit a parse tree produced by CqlParser#createKeyspace. + VisitCreateKeyspace(ctx *CreateKeyspaceContext) interface{} + + // Visit a parse tree produced by CqlParser#createFunction. + VisitCreateFunction(ctx *CreateFunctionContext) interface{} + + // Visit a parse tree produced by CqlParser#codeBlock. + VisitCodeBlock(ctx *CodeBlockContext) interface{} + + // Visit a parse tree produced by CqlParser#paramList. + VisitParamList(ctx *ParamListContext) interface{} + + // Visit a parse tree produced by CqlParser#returnMode. + VisitReturnMode(ctx *ReturnModeContext) interface{} + + // Visit a parse tree produced by CqlParser#createAggregate. + VisitCreateAggregate(ctx *CreateAggregateContext) interface{} + + // Visit a parse tree produced by CqlParser#initCondDefinition. + VisitInitCondDefinition(ctx *InitCondDefinitionContext) interface{} + + // Visit a parse tree produced by CqlParser#initCondHash. + VisitInitCondHash(ctx *InitCondHashContext) interface{} + + // Visit a parse tree produced by CqlParser#initCondHashItem. + VisitInitCondHashItem(ctx *InitCondHashItemContext) interface{} + + // Visit a parse tree produced by CqlParser#initCondListNested. + VisitInitCondListNested(ctx *InitCondListNestedContext) interface{} + + // Visit a parse tree produced by CqlParser#initCondList. + VisitInitCondList(ctx *InitCondListContext) interface{} + + // Visit a parse tree produced by CqlParser#orReplace. + VisitOrReplace(ctx *OrReplaceContext) interface{} + + // Visit a parse tree produced by CqlParser#alterUser. + VisitAlterUser(ctx *AlterUserContext) interface{} + + // Visit a parse tree produced by CqlParser#userPassword. + VisitUserPassword(ctx *UserPasswordContext) interface{} + + // Visit a parse tree produced by CqlParser#userSuperUser. + VisitUserSuperUser(ctx *UserSuperUserContext) interface{} + + // Visit a parse tree produced by CqlParser#alterType. + VisitAlterType(ctx *AlterTypeContext) interface{} + + // Visit a parse tree produced by CqlParser#alterTypeOperation. + VisitAlterTypeOperation(ctx *AlterTypeOperationContext) interface{} + + // Visit a parse tree produced by CqlParser#alterTypeRename. + VisitAlterTypeRename(ctx *AlterTypeRenameContext) interface{} + + // Visit a parse tree produced by CqlParser#alterTypeRenameList. + VisitAlterTypeRenameList(ctx *AlterTypeRenameListContext) interface{} + + // Visit a parse tree produced by CqlParser#alterTypeRenameItem. + VisitAlterTypeRenameItem(ctx *AlterTypeRenameItemContext) interface{} + + // Visit a parse tree produced by CqlParser#alterTypeAdd. + VisitAlterTypeAdd(ctx *AlterTypeAddContext) interface{} + + // Visit a parse tree produced by CqlParser#alterTypeAlterType. + VisitAlterTypeAlterType(ctx *AlterTypeAlterTypeContext) interface{} + + // Visit a parse tree produced by CqlParser#alterTable. + VisitAlterTable(ctx *AlterTableContext) interface{} + + // Visit a parse tree produced by CqlParser#alterTableOperation. + VisitAlterTableOperation(ctx *AlterTableOperationContext) interface{} + + // Visit a parse tree produced by CqlParser#alterTableWith. + VisitAlterTableWith(ctx *AlterTableWithContext) interface{} + + // Visit a parse tree produced by CqlParser#alterTableRename. + VisitAlterTableRename(ctx *AlterTableRenameContext) interface{} + + // Visit a parse tree produced by CqlParser#alterTableDropCompactStorage. + VisitAlterTableDropCompactStorage(ctx *AlterTableDropCompactStorageContext) interface{} + + // Visit a parse tree produced by CqlParser#alterTableDropColumns. + VisitAlterTableDropColumns(ctx *AlterTableDropColumnsContext) interface{} + + // Visit a parse tree produced by CqlParser#alterTableDropColumnList. + VisitAlterTableDropColumnList(ctx *AlterTableDropColumnListContext) interface{} + + // Visit a parse tree produced by CqlParser#alterTableAdd. + VisitAlterTableAdd(ctx *AlterTableAddContext) interface{} + + // Visit a parse tree produced by CqlParser#alterTableColumnDefinition. + VisitAlterTableColumnDefinition(ctx *AlterTableColumnDefinitionContext) interface{} + + // Visit a parse tree produced by CqlParser#alterRole. + VisitAlterRole(ctx *AlterRoleContext) interface{} + + // Visit a parse tree produced by CqlParser#roleWith. + VisitRoleWith(ctx *RoleWithContext) interface{} + + // Visit a parse tree produced by CqlParser#roleWithOptions. + VisitRoleWithOptions(ctx *RoleWithOptionsContext) interface{} + + // Visit a parse tree produced by CqlParser#alterMaterializedView. + VisitAlterMaterializedView(ctx *AlterMaterializedViewContext) interface{} + + // Visit a parse tree produced by CqlParser#dropUser. + VisitDropUser(ctx *DropUserContext) interface{} + + // Visit a parse tree produced by CqlParser#dropType. + VisitDropType(ctx *DropTypeContext) interface{} + + // Visit a parse tree produced by CqlParser#dropMaterializedView. + VisitDropMaterializedView(ctx *DropMaterializedViewContext) interface{} + + // Visit a parse tree produced by CqlParser#dropAggregate. + VisitDropAggregate(ctx *DropAggregateContext) interface{} + + // Visit a parse tree produced by CqlParser#dropFunction. + VisitDropFunction(ctx *DropFunctionContext) interface{} + + // Visit a parse tree produced by CqlParser#dropTrigger. + VisitDropTrigger(ctx *DropTriggerContext) interface{} + + // Visit a parse tree produced by CqlParser#dropRole. + VisitDropRole(ctx *DropRoleContext) interface{} + + // Visit a parse tree produced by CqlParser#dropTable. + VisitDropTable(ctx *DropTableContext) interface{} + + // Visit a parse tree produced by CqlParser#dropKeyspace. + VisitDropKeyspace(ctx *DropKeyspaceContext) interface{} + + // Visit a parse tree produced by CqlParser#dropIndex. + VisitDropIndex(ctx *DropIndexContext) interface{} + + // Visit a parse tree produced by CqlParser#createTable. + VisitCreateTable(ctx *CreateTableContext) interface{} + + // Visit a parse tree produced by CqlParser#withElement. + VisitWithElement(ctx *WithElementContext) interface{} + + // Visit a parse tree produced by CqlParser#tableOptions. + VisitTableOptions(ctx *TableOptionsContext) interface{} + + // Visit a parse tree produced by CqlParser#clusteringOrder. + VisitClusteringOrder(ctx *ClusteringOrderContext) interface{} + + // Visit a parse tree produced by CqlParser#tableOptionItem. + VisitTableOptionItem(ctx *TableOptionItemContext) interface{} + + // Visit a parse tree produced by CqlParser#tableOptionName. + VisitTableOptionName(ctx *TableOptionNameContext) interface{} + + // Visit a parse tree produced by CqlParser#tableOptionValue. + VisitTableOptionValue(ctx *TableOptionValueContext) interface{} + + // Visit a parse tree produced by CqlParser#optionHash. + VisitOptionHash(ctx *OptionHashContext) interface{} + + // Visit a parse tree produced by CqlParser#optionHashItem. + VisitOptionHashItem(ctx *OptionHashItemContext) interface{} + + // Visit a parse tree produced by CqlParser#optionHashKey. + VisitOptionHashKey(ctx *OptionHashKeyContext) interface{} + + // Visit a parse tree produced by CqlParser#optionHashValue. + VisitOptionHashValue(ctx *OptionHashValueContext) interface{} + + // Visit a parse tree produced by CqlParser#columnDefinitionList. + VisitColumnDefinitionList(ctx *ColumnDefinitionListContext) interface{} + + // Visit a parse tree produced by CqlParser#columnDefinition. + VisitColumnDefinition(ctx *ColumnDefinitionContext) interface{} + + // Visit a parse tree produced by CqlParser#primaryKeyColumn. + VisitPrimaryKeyColumn(ctx *PrimaryKeyColumnContext) interface{} + + // Visit a parse tree produced by CqlParser#primaryKeyElement. + VisitPrimaryKeyElement(ctx *PrimaryKeyElementContext) interface{} + + // Visit a parse tree produced by CqlParser#primaryKeyDefinition. + VisitPrimaryKeyDefinition(ctx *PrimaryKeyDefinitionContext) interface{} + + // Visit a parse tree produced by CqlParser#singlePrimaryKey. + VisitSinglePrimaryKey(ctx *SinglePrimaryKeyContext) interface{} + + // Visit a parse tree produced by CqlParser#compoundKey. + VisitCompoundKey(ctx *CompoundKeyContext) interface{} + + // Visit a parse tree produced by CqlParser#compositeKey. + VisitCompositeKey(ctx *CompositeKeyContext) interface{} + + // Visit a parse tree produced by CqlParser#partitionKeyList. + VisitPartitionKeyList(ctx *PartitionKeyListContext) interface{} + + // Visit a parse tree produced by CqlParser#clusteringKeyList. + VisitClusteringKeyList(ctx *ClusteringKeyListContext) interface{} + + // Visit a parse tree produced by CqlParser#partitionKey. + VisitPartitionKey(ctx *PartitionKeyContext) interface{} + + // Visit a parse tree produced by CqlParser#clusteringKey. + VisitClusteringKey(ctx *ClusteringKeyContext) interface{} + + // Visit a parse tree produced by CqlParser#applyBatch. + VisitApplyBatch(ctx *ApplyBatchContext) interface{} + + // Visit a parse tree produced by CqlParser#beginBatch. + VisitBeginBatch(ctx *BeginBatchContext) interface{} + + // Visit a parse tree produced by CqlParser#batchType. + VisitBatchType(ctx *BatchTypeContext) interface{} + + // Visit a parse tree produced by CqlParser#alterKeyspace. + VisitAlterKeyspace(ctx *AlterKeyspaceContext) interface{} + + // Visit a parse tree produced by CqlParser#replicationList. + VisitReplicationList(ctx *ReplicationListContext) interface{} + + // Visit a parse tree produced by CqlParser#replicationListItem. + VisitReplicationListItem(ctx *ReplicationListItemContext) interface{} + + // Visit a parse tree produced by CqlParser#durableWrites. + VisitDurableWrites(ctx *DurableWritesContext) interface{} + + // Visit a parse tree produced by CqlParser#use_. + VisitUse_(ctx *Use_Context) interface{} + + // Visit a parse tree produced by CqlParser#truncate. + VisitTruncate(ctx *TruncateContext) interface{} + + // Visit a parse tree produced by CqlParser#createIndex. + VisitCreateIndex(ctx *CreateIndexContext) interface{} + + // Visit a parse tree produced by CqlParser#indexName. + VisitIndexName(ctx *IndexNameContext) interface{} + + // Visit a parse tree produced by CqlParser#indexColumnSpec. + VisitIndexColumnSpec(ctx *IndexColumnSpecContext) interface{} + + // Visit a parse tree produced by CqlParser#indexKeysSpec. + VisitIndexKeysSpec(ctx *IndexKeysSpecContext) interface{} + + // Visit a parse tree produced by CqlParser#indexEntriesSSpec. + VisitIndexEntriesSSpec(ctx *IndexEntriesSSpecContext) interface{} + + // Visit a parse tree produced by CqlParser#indexFullSpec. + VisitIndexFullSpec(ctx *IndexFullSpecContext) interface{} + + // Visit a parse tree produced by CqlParser#delete_. + VisitDelete_(ctx *Delete_Context) interface{} + + // Visit a parse tree produced by CqlParser#deleteColumnList. + VisitDeleteColumnList(ctx *DeleteColumnListContext) interface{} + + // Visit a parse tree produced by CqlParser#deleteColumnItem. + VisitDeleteColumnItem(ctx *DeleteColumnItemContext) interface{} + + // Visit a parse tree produced by CqlParser#update. + VisitUpdate(ctx *UpdateContext) interface{} + + // Visit a parse tree produced by CqlParser#ifSpec. + VisitIfSpec(ctx *IfSpecContext) interface{} + + // Visit a parse tree produced by CqlParser#ifConditionList. + VisitIfConditionList(ctx *IfConditionListContext) interface{} + + // Visit a parse tree produced by CqlParser#ifCondition. + VisitIfCondition(ctx *IfConditionContext) interface{} + + // Visit a parse tree produced by CqlParser#assignments. + VisitAssignments(ctx *AssignmentsContext) interface{} + + // Visit a parse tree produced by CqlParser#assignmentElement. + VisitAssignmentElement(ctx *AssignmentElementContext) interface{} + + // Visit a parse tree produced by CqlParser#assignmentSet. + VisitAssignmentSet(ctx *AssignmentSetContext) interface{} + + // Visit a parse tree produced by CqlParser#assignmentMap. + VisitAssignmentMap(ctx *AssignmentMapContext) interface{} + + // Visit a parse tree produced by CqlParser#assignmentList. + VisitAssignmentList(ctx *AssignmentListContext) interface{} + + // Visit a parse tree produced by CqlParser#assignmentTuple. + VisitAssignmentTuple(ctx *AssignmentTupleContext) interface{} + + // Visit a parse tree produced by CqlParser#insert. + VisitInsert(ctx *InsertContext) interface{} + + // Visit a parse tree produced by CqlParser#usingTtlTimestamp. + VisitUsingTtlTimestamp(ctx *UsingTtlTimestampContext) interface{} + + // Visit a parse tree produced by CqlParser#timestamp. + VisitTimestamp(ctx *TimestampContext) interface{} + + // Visit a parse tree produced by CqlParser#ttl. + VisitTtl(ctx *TtlContext) interface{} + + // Visit a parse tree produced by CqlParser#usingTimestampSpec. + VisitUsingTimestampSpec(ctx *UsingTimestampSpecContext) interface{} + + // Visit a parse tree produced by CqlParser#ifNotExist. + VisitIfNotExist(ctx *IfNotExistContext) interface{} + + // Visit a parse tree produced by CqlParser#ifExist. + VisitIfExist(ctx *IfExistContext) interface{} + + // Visit a parse tree produced by CqlParser#insertValuesSpec. + VisitInsertValuesSpec(ctx *InsertValuesSpecContext) interface{} + + // Visit a parse tree produced by CqlParser#insertColumnSpec. + VisitInsertColumnSpec(ctx *InsertColumnSpecContext) interface{} + + // Visit a parse tree produced by CqlParser#columnList. + VisitColumnList(ctx *ColumnListContext) interface{} + + // Visit a parse tree produced by CqlParser#expressionList. + VisitExpressionList(ctx *ExpressionListContext) interface{} + + // Visit a parse tree produced by CqlParser#expression. + VisitExpression(ctx *ExpressionContext) interface{} + + // Visit a parse tree produced by CqlParser#select_. + VisitSelect_(ctx *Select_Context) interface{} + + // Visit a parse tree produced by CqlParser#allowFilteringSpec. + VisitAllowFilteringSpec(ctx *AllowFilteringSpecContext) interface{} + + // Visit a parse tree produced by CqlParser#limitSpec. + VisitLimitSpec(ctx *LimitSpecContext) interface{} + + // Visit a parse tree produced by CqlParser#fromSpec. + VisitFromSpec(ctx *FromSpecContext) interface{} + + // Visit a parse tree produced by CqlParser#fromSpecElement. + VisitFromSpecElement(ctx *FromSpecElementContext) interface{} + + // Visit a parse tree produced by CqlParser#orderSpec. + VisitOrderSpec(ctx *OrderSpecContext) interface{} + + // Visit a parse tree produced by CqlParser#orderSpecElement. + VisitOrderSpecElement(ctx *OrderSpecElementContext) interface{} + + // Visit a parse tree produced by CqlParser#whereSpec. + VisitWhereSpec(ctx *WhereSpecContext) interface{} + + // Visit a parse tree produced by CqlParser#distinctSpec. + VisitDistinctSpec(ctx *DistinctSpecContext) interface{} + + // Visit a parse tree produced by CqlParser#selectElements. + VisitSelectElements(ctx *SelectElementsContext) interface{} + + // Visit a parse tree produced by CqlParser#selectElement. + VisitSelectElement(ctx *SelectElementContext) interface{} + + // Visit a parse tree produced by CqlParser#relationElements. + VisitRelationElements(ctx *RelationElementsContext) interface{} + + // Visit a parse tree produced by CqlParser#relationElement. + VisitRelationElement(ctx *RelationElementContext) interface{} + + // Visit a parse tree produced by CqlParser#relalationContains. + VisitRelalationContains(ctx *RelalationContainsContext) interface{} + + // Visit a parse tree produced by CqlParser#relalationContainsKey. + VisitRelalationContainsKey(ctx *RelalationContainsKeyContext) interface{} + + // Visit a parse tree produced by CqlParser#functionCall. + VisitFunctionCall(ctx *FunctionCallContext) interface{} + + // Visit a parse tree produced by CqlParser#functionArgs. + VisitFunctionArgs(ctx *FunctionArgsContext) interface{} + + // Visit a parse tree produced by CqlParser#constant. + VisitConstant(ctx *ConstantContext) interface{} + + // Visit a parse tree produced by CqlParser#decimalLiteral. + VisitDecimalLiteral(ctx *DecimalLiteralContext) interface{} + + // Visit a parse tree produced by CqlParser#floatLiteral. + VisitFloatLiteral(ctx *FloatLiteralContext) interface{} + + // Visit a parse tree produced by CqlParser#stringLiteral. + VisitStringLiteral(ctx *StringLiteralContext) interface{} + + // Visit a parse tree produced by CqlParser#booleanLiteral. + VisitBooleanLiteral(ctx *BooleanLiteralContext) interface{} + + // Visit a parse tree produced by CqlParser#hexadecimalLiteral. + VisitHexadecimalLiteral(ctx *HexadecimalLiteralContext) interface{} + + // Visit a parse tree produced by CqlParser#keyspace. + VisitKeyspace(ctx *KeyspaceContext) interface{} + + // Visit a parse tree produced by CqlParser#table. + VisitTable(ctx *TableContext) interface{} + + // Visit a parse tree produced by CqlParser#column. + VisitColumn(ctx *ColumnContext) interface{} + + // Visit a parse tree produced by CqlParser#dataType. + VisitDataType(ctx *DataTypeContext) interface{} + + // Visit a parse tree produced by CqlParser#dataTypeName. + VisitDataTypeName(ctx *DataTypeNameContext) interface{} + + // Visit a parse tree produced by CqlParser#dataTypeDefinition. + VisitDataTypeDefinition(ctx *DataTypeDefinitionContext) interface{} + + // Visit a parse tree produced by CqlParser#orderDirection. + VisitOrderDirection(ctx *OrderDirectionContext) interface{} + + // Visit a parse tree produced by CqlParser#role. + VisitRole(ctx *RoleContext) interface{} + + // Visit a parse tree produced by CqlParser#trigger. + VisitTrigger(ctx *TriggerContext) interface{} + + // Visit a parse tree produced by CqlParser#triggerClass. + VisitTriggerClass(ctx *TriggerClassContext) interface{} + + // Visit a parse tree produced by CqlParser#materializedView. + VisitMaterializedView(ctx *MaterializedViewContext) interface{} + + // Visit a parse tree produced by CqlParser#type_. + VisitType_(ctx *Type_Context) interface{} + + // Visit a parse tree produced by CqlParser#aggregate. + VisitAggregate(ctx *AggregateContext) interface{} + + // Visit a parse tree produced by CqlParser#function_. + VisitFunction_(ctx *Function_Context) interface{} + + // Visit a parse tree produced by CqlParser#language. + VisitLanguage(ctx *LanguageContext) interface{} + + // Visit a parse tree produced by CqlParser#user. + VisitUser(ctx *UserContext) interface{} + + // Visit a parse tree produced by CqlParser#password. + VisitPassword(ctx *PasswordContext) interface{} + + // Visit a parse tree produced by CqlParser#hashKey. + VisitHashKey(ctx *HashKeyContext) interface{} + + // Visit a parse tree produced by CqlParser#param. + VisitParam(ctx *ParamContext) interface{} + + // Visit a parse tree produced by CqlParser#paramName. + VisitParamName(ctx *ParamNameContext) interface{} + + // Visit a parse tree produced by CqlParser#kwAdd. + VisitKwAdd(ctx *KwAddContext) interface{} + + // Visit a parse tree produced by CqlParser#kwAggregate. + VisitKwAggregate(ctx *KwAggregateContext) interface{} + + // Visit a parse tree produced by CqlParser#kwAll. + VisitKwAll(ctx *KwAllContext) interface{} + + // Visit a parse tree produced by CqlParser#kwAllPermissions. + VisitKwAllPermissions(ctx *KwAllPermissionsContext) interface{} + + // Visit a parse tree produced by CqlParser#kwAllow. + VisitKwAllow(ctx *KwAllowContext) interface{} + + // Visit a parse tree produced by CqlParser#kwAlter. + VisitKwAlter(ctx *KwAlterContext) interface{} + + // Visit a parse tree produced by CqlParser#kwAnd. + VisitKwAnd(ctx *KwAndContext) interface{} + + // Visit a parse tree produced by CqlParser#kwApply. + VisitKwApply(ctx *KwApplyContext) interface{} + + // Visit a parse tree produced by CqlParser#kwAs. + VisitKwAs(ctx *KwAsContext) interface{} + + // Visit a parse tree produced by CqlParser#kwAsc. + VisitKwAsc(ctx *KwAscContext) interface{} + + // Visit a parse tree produced by CqlParser#kwAuthorize. + VisitKwAuthorize(ctx *KwAuthorizeContext) interface{} + + // Visit a parse tree produced by CqlParser#kwBatch. + VisitKwBatch(ctx *KwBatchContext) interface{} + + // Visit a parse tree produced by CqlParser#kwBegin. + VisitKwBegin(ctx *KwBeginContext) interface{} + + // Visit a parse tree produced by CqlParser#kwBy. + VisitKwBy(ctx *KwByContext) interface{} + + // Visit a parse tree produced by CqlParser#kwCalled. + VisitKwCalled(ctx *KwCalledContext) interface{} + + // Visit a parse tree produced by CqlParser#kwClustering. + VisitKwClustering(ctx *KwClusteringContext) interface{} + + // Visit a parse tree produced by CqlParser#kwCompact. + VisitKwCompact(ctx *KwCompactContext) interface{} + + // Visit a parse tree produced by CqlParser#kwContains. + VisitKwContains(ctx *KwContainsContext) interface{} + + // Visit a parse tree produced by CqlParser#kwCreate. + VisitKwCreate(ctx *KwCreateContext) interface{} + + // Visit a parse tree produced by CqlParser#kwDelete. + VisitKwDelete(ctx *KwDeleteContext) interface{} + + // Visit a parse tree produced by CqlParser#kwDesc. + VisitKwDesc(ctx *KwDescContext) interface{} + + // Visit a parse tree produced by CqlParser#kwDescibe. + VisitKwDescibe(ctx *KwDescibeContext) interface{} + + // Visit a parse tree produced by CqlParser#kwDistinct. + VisitKwDistinct(ctx *KwDistinctContext) interface{} + + // Visit a parse tree produced by CqlParser#kwDrop. + VisitKwDrop(ctx *KwDropContext) interface{} + + // Visit a parse tree produced by CqlParser#kwDurableWrites. + VisitKwDurableWrites(ctx *KwDurableWritesContext) interface{} + + // Visit a parse tree produced by CqlParser#kwEntries. + VisitKwEntries(ctx *KwEntriesContext) interface{} + + // Visit a parse tree produced by CqlParser#kwExecute. + VisitKwExecute(ctx *KwExecuteContext) interface{} + + // Visit a parse tree produced by CqlParser#kwExists. + VisitKwExists(ctx *KwExistsContext) interface{} + + // Visit a parse tree produced by CqlParser#kwFiltering. + VisitKwFiltering(ctx *KwFilteringContext) interface{} + + // Visit a parse tree produced by CqlParser#kwFinalfunc. + VisitKwFinalfunc(ctx *KwFinalfuncContext) interface{} + + // Visit a parse tree produced by CqlParser#kwFrom. + VisitKwFrom(ctx *KwFromContext) interface{} + + // Visit a parse tree produced by CqlParser#kwFull. + VisitKwFull(ctx *KwFullContext) interface{} + + // Visit a parse tree produced by CqlParser#kwFunction. + VisitKwFunction(ctx *KwFunctionContext) interface{} + + // Visit a parse tree produced by CqlParser#kwFunctions. + VisitKwFunctions(ctx *KwFunctionsContext) interface{} + + // Visit a parse tree produced by CqlParser#kwGrant. + VisitKwGrant(ctx *KwGrantContext) interface{} + + // Visit a parse tree produced by CqlParser#kwIf. + VisitKwIf(ctx *KwIfContext) interface{} + + // Visit a parse tree produced by CqlParser#kwIn. + VisitKwIn(ctx *KwInContext) interface{} + + // Visit a parse tree produced by CqlParser#kwIndex. + VisitKwIndex(ctx *KwIndexContext) interface{} + + // Visit a parse tree produced by CqlParser#kwInitcond. + VisitKwInitcond(ctx *KwInitcondContext) interface{} + + // Visit a parse tree produced by CqlParser#kwInput. + VisitKwInput(ctx *KwInputContext) interface{} + + // Visit a parse tree produced by CqlParser#kwInsert. + VisitKwInsert(ctx *KwInsertContext) interface{} + + // Visit a parse tree produced by CqlParser#kwInto. + VisitKwInto(ctx *KwIntoContext) interface{} + + // Visit a parse tree produced by CqlParser#kwIs. + VisitKwIs(ctx *KwIsContext) interface{} + + // Visit a parse tree produced by CqlParser#kwJson. + VisitKwJson(ctx *KwJsonContext) interface{} + + // Visit a parse tree produced by CqlParser#kwKey. + VisitKwKey(ctx *KwKeyContext) interface{} + + // Visit a parse tree produced by CqlParser#kwKeys. + VisitKwKeys(ctx *KwKeysContext) interface{} + + // Visit a parse tree produced by CqlParser#kwKeyspace. + VisitKwKeyspace(ctx *KwKeyspaceContext) interface{} + + // Visit a parse tree produced by CqlParser#kwKeyspaces. + VisitKwKeyspaces(ctx *KwKeyspacesContext) interface{} + + // Visit a parse tree produced by CqlParser#kwLanguage. + VisitKwLanguage(ctx *KwLanguageContext) interface{} + + // Visit a parse tree produced by CqlParser#kwLimit. + VisitKwLimit(ctx *KwLimitContext) interface{} + + // Visit a parse tree produced by CqlParser#kwList. + VisitKwList(ctx *KwListContext) interface{} + + // Visit a parse tree produced by CqlParser#kwLogged. + VisitKwLogged(ctx *KwLoggedContext) interface{} + + // Visit a parse tree produced by CqlParser#kwLogin. + VisitKwLogin(ctx *KwLoginContext) interface{} + + // Visit a parse tree produced by CqlParser#kwMaterialized. + VisitKwMaterialized(ctx *KwMaterializedContext) interface{} + + // Visit a parse tree produced by CqlParser#kwModify. + VisitKwModify(ctx *KwModifyContext) interface{} + + // Visit a parse tree produced by CqlParser#kwNosuperuser. + VisitKwNosuperuser(ctx *KwNosuperuserContext) interface{} + + // Visit a parse tree produced by CqlParser#kwNorecursive. + VisitKwNorecursive(ctx *KwNorecursiveContext) interface{} + + // Visit a parse tree produced by CqlParser#kwNot. + VisitKwNot(ctx *KwNotContext) interface{} + + // Visit a parse tree produced by CqlParser#kwNull. + VisitKwNull(ctx *KwNullContext) interface{} + + // Visit a parse tree produced by CqlParser#kwOf. + VisitKwOf(ctx *KwOfContext) interface{} + + // Visit a parse tree produced by CqlParser#kwOn. + VisitKwOn(ctx *KwOnContext) interface{} + + // Visit a parse tree produced by CqlParser#kwOptions. + VisitKwOptions(ctx *KwOptionsContext) interface{} + + // Visit a parse tree produced by CqlParser#kwOr. + VisitKwOr(ctx *KwOrContext) interface{} + + // Visit a parse tree produced by CqlParser#kwOrder. + VisitKwOrder(ctx *KwOrderContext) interface{} + + // Visit a parse tree produced by CqlParser#kwPassword. + VisitKwPassword(ctx *KwPasswordContext) interface{} + + // Visit a parse tree produced by CqlParser#kwPrimary. + VisitKwPrimary(ctx *KwPrimaryContext) interface{} + + // Visit a parse tree produced by CqlParser#kwRename. + VisitKwRename(ctx *KwRenameContext) interface{} + + // Visit a parse tree produced by CqlParser#kwReplace. + VisitKwReplace(ctx *KwReplaceContext) interface{} + + // Visit a parse tree produced by CqlParser#kwReplication. + VisitKwReplication(ctx *KwReplicationContext) interface{} + + // Visit a parse tree produced by CqlParser#kwReturns. + VisitKwReturns(ctx *KwReturnsContext) interface{} + + // Visit a parse tree produced by CqlParser#kwRole. + VisitKwRole(ctx *KwRoleContext) interface{} + + // Visit a parse tree produced by CqlParser#kwRoles. + VisitKwRoles(ctx *KwRolesContext) interface{} + + // Visit a parse tree produced by CqlParser#kwSelect. + VisitKwSelect(ctx *KwSelectContext) interface{} + + // Visit a parse tree produced by CqlParser#kwSet. + VisitKwSet(ctx *KwSetContext) interface{} + + // Visit a parse tree produced by CqlParser#kwSfunc. + VisitKwSfunc(ctx *KwSfuncContext) interface{} + + // Visit a parse tree produced by CqlParser#kwStorage. + VisitKwStorage(ctx *KwStorageContext) interface{} + + // Visit a parse tree produced by CqlParser#kwStype. + VisitKwStype(ctx *KwStypeContext) interface{} + + // Visit a parse tree produced by CqlParser#kwSuperuser. + VisitKwSuperuser(ctx *KwSuperuserContext) interface{} + + // Visit a parse tree produced by CqlParser#kwTable. + VisitKwTable(ctx *KwTableContext) interface{} + + // Visit a parse tree produced by CqlParser#kwTimestamp. + VisitKwTimestamp(ctx *KwTimestampContext) interface{} + + // Visit a parse tree produced by CqlParser#kwTo. + VisitKwTo(ctx *KwToContext) interface{} + + // Visit a parse tree produced by CqlParser#kwTrigger. + VisitKwTrigger(ctx *KwTriggerContext) interface{} + + // Visit a parse tree produced by CqlParser#kwTruncate. + VisitKwTruncate(ctx *KwTruncateContext) interface{} + + // Visit a parse tree produced by CqlParser#kwTtl. + VisitKwTtl(ctx *KwTtlContext) interface{} + + // Visit a parse tree produced by CqlParser#kwType. + VisitKwType(ctx *KwTypeContext) interface{} + + // Visit a parse tree produced by CqlParser#kwUnlogged. + VisitKwUnlogged(ctx *KwUnloggedContext) interface{} + + // Visit a parse tree produced by CqlParser#kwUpdate. + VisitKwUpdate(ctx *KwUpdateContext) interface{} + + // Visit a parse tree produced by CqlParser#kwUse. + VisitKwUse(ctx *KwUseContext) interface{} + + // Visit a parse tree produced by CqlParser#kwUser. + VisitKwUser(ctx *KwUserContext) interface{} + + // Visit a parse tree produced by CqlParser#kwUsing. + VisitKwUsing(ctx *KwUsingContext) interface{} + + // Visit a parse tree produced by CqlParser#kwValues. + VisitKwValues(ctx *KwValuesContext) interface{} + + // Visit a parse tree produced by CqlParser#kwView. + VisitKwView(ctx *KwViewContext) interface{} + + // Visit a parse tree produced by CqlParser#kwWhere. + VisitKwWhere(ctx *KwWhereContext) interface{} + + // Visit a parse tree produced by CqlParser#kwWith. + VisitKwWith(ctx *KwWithContext) interface{} + + // Visit a parse tree produced by CqlParser#kwRevoke. + VisitKwRevoke(ctx *KwRevokeContext) interface{} + + // Visit a parse tree produced by CqlParser#syntaxBracketLr. + VisitSyntaxBracketLr(ctx *SyntaxBracketLrContext) interface{} + + // Visit a parse tree produced by CqlParser#syntaxBracketRr. + VisitSyntaxBracketRr(ctx *SyntaxBracketRrContext) interface{} + + // Visit a parse tree produced by CqlParser#syntaxBracketLc. + VisitSyntaxBracketLc(ctx *SyntaxBracketLcContext) interface{} + + // Visit a parse tree produced by CqlParser#syntaxBracketRc. + VisitSyntaxBracketRc(ctx *SyntaxBracketRcContext) interface{} + + // Visit a parse tree produced by CqlParser#syntaxBracketLa. + VisitSyntaxBracketLa(ctx *SyntaxBracketLaContext) interface{} + + // Visit a parse tree produced by CqlParser#syntaxBracketRa. + VisitSyntaxBracketRa(ctx *SyntaxBracketRaContext) interface{} + + // Visit a parse tree produced by CqlParser#syntaxBracketLs. + VisitSyntaxBracketLs(ctx *SyntaxBracketLsContext) interface{} + + // Visit a parse tree produced by CqlParser#syntaxBracketRs. + VisitSyntaxBracketRs(ctx *SyntaxBracketRsContext) interface{} + + // Visit a parse tree produced by CqlParser#syntaxComma. + VisitSyntaxComma(ctx *SyntaxCommaContext) interface{} + + // Visit a parse tree produced by CqlParser#syntaxColon. + VisitSyntaxColon(ctx *SyntaxColonContext) interface{} +} diff --git a/cql/examples/alterKeyspace.cql b/cql/examples/alterKeyspace.cql new file mode 100644 index 0000000..93f7780 --- /dev/null +++ b/cql/examples/alterKeyspace.cql @@ -0,0 +1,6 @@ +ALTER KEYSPACE cycling +WITH REPLICATION = { + 'class' : 'NetworkTopologyStrategy', + 'datacenter1' : 3 } + AND DURABLE_WRITES = false ; + \ No newline at end of file diff --git a/cql/examples/alterMaterializedView.cql b/cql/examples/alterMaterializedView.cql new file mode 100644 index 0000000..539e755 --- /dev/null +++ b/cql/examples/alterMaterializedView.cql @@ -0,0 +1,3 @@ +ALTER MATERIALIZED VIEW cycling.cyclist_by_age +WITH comment = 'A most excellent and useful view' +AND bloom_filter_fp_chance = 0.02; diff --git a/cql/examples/alterRole.cql b/cql/examples/alterRole.cql new file mode 100644 index 0000000..b201860 --- /dev/null +++ b/cql/examples/alterRole.cql @@ -0,0 +1 @@ +ALTER ROLE coach WITH PASSWORD='bestTeam'; diff --git a/cql/examples/alterTable.cql b/cql/examples/alterTable.cql new file mode 100644 index 0000000..85bbe5f --- /dev/null +++ b/cql/examples/alterTable.cql @@ -0,0 +1,5 @@ +ALTER TABLE cycling_comments +WITH compression = { + 'sstable_compression' : 'DeflateCompressor', + 'chunk_length_kb' : 64 }; + diff --git a/cql/examples/alterType.cql b/cql/examples/alterType.cql new file mode 100644 index 0000000..ae99ca5 --- /dev/null +++ b/cql/examples/alterType.cql @@ -0,0 +1,4 @@ +ALTER TYPE cycling.fullname +RENAME middlename TO middle +AND lastname to last +AND firstname to first; diff --git a/cql/examples/alterUser.cql b/cql/examples/alterUser.cql new file mode 100644 index 0000000..c2e8eaf --- /dev/null +++ b/cql/examples/alterUser.cql @@ -0,0 +1 @@ +ALTER USER moss WITH PASSWORD 'bestReceiver'; \ No newline at end of file diff --git a/cql/examples/applyBatch.cql b/cql/examples/applyBatch.cql new file mode 100644 index 0000000..189b601 --- /dev/null +++ b/cql/examples/applyBatch.cql @@ -0,0 +1 @@ +APPLY BATCH; \ No newline at end of file diff --git a/cql/examples/createAggregate.cql b/cql/examples/createAggregate.cql new file mode 100644 index 0000000..31ee5d4 --- /dev/null +++ b/cql/examples/createAggregate.cql @@ -0,0 +1,5 @@ +CREATE AGGREGATE cycling.average(int) +SFUNC avgState +STYPE tuple +FINALFUNC avgFinal +INITCOND (0,0); \ No newline at end of file diff --git a/cql/examples/createFunction.cql b/cql/examples/createFunction.cql new file mode 100644 index 0000000..7ace8ea --- /dev/null +++ b/cql/examples/createFunction.cql @@ -0,0 +1,16 @@ +CREATE OR REPLACE FUNCTION cycling.avgFinal ( state tuple ) +CALLED ON NULL INPUT +RETURNS double +LANGUAGE java AS + $$ double r = 0; + if (state.getInt(0) == 0) return null; + r = state.getLong(1); + r/= state.getInt(0); + return Double.valueOf(r); $$ +; + +CREATE OR REPLACE FUNCTION setMin(input set) RETURNS NULL ON NULL INPUT RETURNS int LANGUAGE java AS ' + int min = Integer.MAX_VALUE; + for (Object i : input) { min = Math.min(min, (Integer) i); } + return min; + '; diff --git a/cql/examples/createIndex.cql b/cql/examples/createIndex.cql new file mode 100644 index 0000000..eaf745b --- /dev/null +++ b/cql/examples/createIndex.cql @@ -0,0 +1,4 @@ + CREATE INDEX user_state + ON myschema.users (state); + +CREATE INDEX ON myschema.users (zip); \ No newline at end of file diff --git a/cql/examples/createKeyspace.cql b/cql/examples/createKeyspace.cql new file mode 100644 index 0000000..759cba2 --- /dev/null +++ b/cql/examples/createKeyspace.cql @@ -0,0 +1,6 @@ +CREATE KEYSPACE cycling + WITH REPLICATION = { + 'class' : 'SimpleStrategy', + 'replication_factor' : 1 + }; + \ No newline at end of file diff --git a/cql/examples/createMaterializedView.cql b/cql/examples/createMaterializedView.cql new file mode 100644 index 0000000..b4d1620 --- /dev/null +++ b/cql/examples/createMaterializedView.cql @@ -0,0 +1,7 @@ +CREATE MATERIALIZED VIEW cycling.cyclist_by_age +AS SELECT age, name, country +FROM cycling.cyclist_mv +WHERE age IS NOT NULL AND cid IS NOT NULL +PRIMARY KEY (age, cid) +WITH caching = { 'keys' : 'ALL', 'rows_per_partition' : '100' } + AND comment = 'Based on table cyclist' ; \ No newline at end of file diff --git a/cql/examples/createRole.cql b/cql/examples/createRole.cql new file mode 100644 index 0000000..590783c --- /dev/null +++ b/cql/examples/createRole.cql @@ -0,0 +1,3 @@ +CREATE ROLE coach +WITH PASSWORD = 'All4One2day!' +AND LOGIN = true; \ No newline at end of file diff --git a/cql/examples/createTable.cql b/cql/examples/createTable.cql new file mode 100644 index 0000000..ab98b7c --- /dev/null +++ b/cql/examples/createTable.cql @@ -0,0 +1,5 @@ +CREATE TABLE cycling.race_winners ( + race_name text, + race_position int, + cyclist_name FROZEN, + PRIMARY KEY (race_name, race_position)); diff --git a/cql/examples/createTrigger.cql b/cql/examples/createTrigger.cql new file mode 100644 index 0000000..af59c5f --- /dev/null +++ b/cql/examples/createTrigger.cql @@ -0,0 +1 @@ +DROP TRIGGER trigger_name ON table_name; diff --git a/cql/examples/createType.cql b/cql/examples/createType.cql new file mode 100644 index 0000000..0137925 --- /dev/null +++ b/cql/examples/createType.cql @@ -0,0 +1,6 @@ +CREATE TYPE cycling.basic_info ( + birthday timestamp, + nationality text, + weight text, + height text +); \ No newline at end of file diff --git a/cql/examples/createUser.cql b/cql/examples/createUser.cql new file mode 100644 index 0000000..b6c6af3 --- /dev/null +++ b/cql/examples/createUser.cql @@ -0,0 +1 @@ +CREATE USER newuser WITH PASSWORD 'password'; \ No newline at end of file diff --git a/cql/examples/delete.cql b/cql/examples/delete.cql new file mode 100644 index 0000000..8345ac5 --- /dev/null +++ b/cql/examples/delete.cql @@ -0,0 +1,8 @@ +DELETE firstname, lastname FROM cycling.cyclist_name +WHERE id = e7ae5cf3-d358-4d99-b900-85902fda9bb0; +DELETE FROM cycling.cyclist_name +WHERE id =e7ae5cf3-d358-4d99-b900-85902fda9bb0 +if firstname='Alex' and lastname='Smith'; +DELETE id FROM cyclist_id +WHERE lastname = 'WELTEN' and firstname = 'Bram' +IF EXISTS; diff --git a/cql/examples/dropAggregate.cql b/cql/examples/dropAggregate.cql new file mode 100644 index 0000000..0392a20 --- /dev/null +++ b/cql/examples/dropAggregate.cql @@ -0,0 +1 @@ +DROP AGGREGATE IF EXISTS cycling.avgState; \ No newline at end of file diff --git a/cql/examples/dropFunction.cql b/cql/examples/dropFunction.cql new file mode 100644 index 0000000..93605fc --- /dev/null +++ b/cql/examples/dropFunction.cql @@ -0,0 +1 @@ +DROP FUNCTION IF EXISTS cycling.fLog; \ No newline at end of file diff --git a/cql/examples/dropIndex.cql b/cql/examples/dropIndex.cql new file mode 100644 index 0000000..7a44cad --- /dev/null +++ b/cql/examples/dropIndex.cql @@ -0,0 +1 @@ +DROP INDEX cycling.ryear; \ No newline at end of file diff --git a/cql/examples/dropKeyspace.cql b/cql/examples/dropKeyspace.cql new file mode 100644 index 0000000..e86c66c --- /dev/null +++ b/cql/examples/dropKeyspace.cql @@ -0,0 +1 @@ +DROP KEYSPACE cycling; diff --git a/cql/examples/dropMaterializedView.cql b/cql/examples/dropMaterializedView.cql new file mode 100644 index 0000000..9ad58b0 --- /dev/null +++ b/cql/examples/dropMaterializedView.cql @@ -0,0 +1 @@ +DROP MATERIALIZED VIEW cycling.cyclist_by_age; \ No newline at end of file diff --git a/cql/examples/dropRole.cql b/cql/examples/dropRole.cql new file mode 100644 index 0000000..9c48b1d --- /dev/null +++ b/cql/examples/dropRole.cql @@ -0,0 +1 @@ +DROP ROLE IF EXISTS team_manager; diff --git a/cql/examples/dropTable.cql b/cql/examples/dropTable.cql new file mode 100644 index 0000000..49059e6 --- /dev/null +++ b/cql/examples/dropTable.cql @@ -0,0 +1 @@ +DROP TABLE cycling.cyclist_name; \ No newline at end of file diff --git a/cql/examples/dropTrigger.cql b/cql/examples/dropTrigger.cql new file mode 100644 index 0000000..df05957 --- /dev/null +++ b/cql/examples/dropTrigger.cql @@ -0,0 +1 @@ +DROP TRIGGER trigger_name ON ks.table_name; \ No newline at end of file diff --git a/cql/examples/dropType.cql b/cql/examples/dropType.cql new file mode 100644 index 0000000..931272c --- /dev/null +++ b/cql/examples/dropType.cql @@ -0,0 +1 @@ +DROP TYPE cycling.basic_info ; diff --git a/cql/examples/dropUser.cql b/cql/examples/dropUser.cql new file mode 100644 index 0000000..26a82e6 --- /dev/null +++ b/cql/examples/dropUser.cql @@ -0,0 +1 @@ +DROP USER IF EXISTS boone; \ No newline at end of file diff --git a/cql/examples/grant.cql b/cql/examples/grant.cql new file mode 100644 index 0000000..9f1f015 --- /dev/null +++ b/cql/examples/grant.cql @@ -0,0 +1,10 @@ +GRANT SELECT ON ALL KEYSPACES TO coach; +GRANT MODIFY ON KEYSPACE field TO manager; +GRANT ALTER ON KEYSPACE cycling TO coach; +GRANT ALL PERMISSIONS ON cycling.name TO coach; +GRANT ALL ON KEYSPACE cycling TO cycling_admin; + + + + + diff --git a/cql/examples/insert.cql b/cql/examples/insert.cql new file mode 100644 index 0000000..5bb20a9 --- /dev/null +++ b/cql/examples/insert.cql @@ -0,0 +1,25 @@ +INSERT INTO cycling.cyclist_name (id, lastname, firstname) + VALUES (6ab09bec-e68e-48d9-a5f8-97e6fb4c9b47, 'KRUIKSWIJK','Steven') + USING TTL 86400 AND TIMESTAMP 123456789; + + + INSERT INTO cycling.cyclist_categories (id,lastname,categories) + VALUES( + '6ab09bec-e68e-48d9-a5f8-97e6fb4c9b47', + 'KRUIJSWIJK', + {'GC', 'Time-trial', 'Sprint'}); + +INSERT INTO cycling.cyclist_categories JSON + '{"category": "", "points":780, "id": "6ab09bec-e68e-48d9-a5f8-97e6fb4c9b47"}'; + +INSERT INTO cycling.cyclist_teams (id,lastname,teams) + VALUES(5b6962dd-3f90-4c93-8f61-eabfa4a803e2,'VOS',$$Women's Tour of New Zealand$$); + +INSERT INTO cycling.route(race_id,race_name,lat_long) VALUES (500, 'Name', ('Champagne', (46.833,6.65))); + +INSERT INTO "students"("id", "address", "name", "[age]", "age", "colu'mn1", "colu68mn1", "height") values + (740, 'hongkong','alice',null,32,'','',172); + +INSERT INTO test(a,b,c,d) values(1,['listtext1','listtext2'],{'settext1','settext2'},{'mapkey1':'mapvale2','mapkey2':'mapvalue2'}); + +INSERT INTO PERSON (id, name) VALUES (uuid(), 'fullname'); diff --git a/cql/examples/listPermissions.cql b/cql/examples/listPermissions.cql new file mode 100644 index 0000000..b0269b3 --- /dev/null +++ b/cql/examples/listPermissions.cql @@ -0,0 +1,5 @@ +LIST ALL +OF coach; +LIST ALL; +LIST ALL +ON cyclist.name; \ No newline at end of file diff --git a/cql/examples/listRoles.cql b/cql/examples/listRoles.cql new file mode 100644 index 0000000..0e0f712 --- /dev/null +++ b/cql/examples/listRoles.cql @@ -0,0 +1,3 @@ +LIST ROLES; +LIST ROLES +OF manager; diff --git a/cql/examples/revoke.cql b/cql/examples/revoke.cql new file mode 100644 index 0000000..fdd3b4b --- /dev/null +++ b/cql/examples/revoke.cql @@ -0,0 +1,6 @@ +REVOKE SELECT +ON cycling.name +FROM manager; +REVOKE ALTER +ON ALL ROLES +FROM coach; \ No newline at end of file diff --git a/cql/examples/select.cql b/cql/examples/select.cql new file mode 100644 index 0000000..11d2492 --- /dev/null +++ b/cql/examples/select.cql @@ -0,0 +1,41 @@ +SELECT event_id, + dateOf(created_at) AS creation_date, + blobAsText(content) AS content + FROM timeline; + + SELECT COUNT(*) +FROM system.IndexInfo; + +SELECT lastname +FROM cycling.cyclist_name +LIMIT 50000; + +SELECT id, lastname, teams +FROM cycling.cyclist_career_teams +WHERE id=5b6962dd-3f90-4c93-8f61-eabfa4a803e2; + + +SELECT * FROM cycling.cyclist_category; + +SELECT * FROM cycling.cyclist_category WHERE category = 'SPRINT'; + +SELECT category, points, lastname FROM cycling.cyclist_category; + +SELECT * From cycling.cyclist_name LIMIT 3; + +SELECT * FROM cycling.cyclist_cat_pts WHERE category = 'GC' ORDER BY points ASC; + +SELECT race_name, point_id, lat_long AS CITY_LATITUDE_LONGITUDE FROM cycling.route; + +SELECT * FROM cycling.upcoming_calendar WHERE year = 2015 AND month = 06; + +select json name, checkin_id, time_stamp from checkin; + +select name, checkin_id, toJson(time_stamp) from checkin; + +SELECT * FROM cycling.calendar WHERE race_id IN (100, 101, 102) AND (race_start_date, race_end_date) IN (('2015-01-01','2015-02-02'), ('2016-01-01','2016-02-02')); + +SELECT * FROM cycling.calendar WHERE race_id IN (100, 101, 102) AND (race_start, race_end) >= ('2015-01-01', '2015-02-02'); + +SELECT * FROM cycling.race_times WHERE race_name = '17th Santos Tour Down Under' and race_time >= '19:15:19' AND race_time <= '19:15:39'; + diff --git a/cql/examples/tableOptions.cql b/cql/examples/tableOptions.cql new file mode 100644 index 0000000..6c4024e --- /dev/null +++ b/cql/examples/tableOptions.cql @@ -0,0 +1,9 @@ +CREATE TABLE alphabet ( + a int, + b int, + c int, + PRIMARY KEY ((a), b, c) +) +WITH COMPACT STORAGE +AND CLUSTERING ORDER BY (b ASC, c DESC) +AND default_time_to_live = 300; diff --git a/cql/examples/truncate.cql b/cql/examples/truncate.cql new file mode 100644 index 0000000..5cd7466 --- /dev/null +++ b/cql/examples/truncate.cql @@ -0,0 +1,2 @@ +TRUNCATE cycling.user_activity; +TRUNCATE TABLE cycling.user_activity; \ No newline at end of file diff --git a/cql/examples/update.cql b/cql/examples/update.cql new file mode 100644 index 0000000..ff06f88 --- /dev/null +++ b/cql/examples/update.cql @@ -0,0 +1,29 @@ + UPDATE cycling.cyclist_name + SET comments ='Rides hard, gets along with others, a real winner' + WHERE id = fb372533-eb95-4bb4-8685-6ef61e994caa IF EXISTS; + + UPDATE cycling.cyclists + SET firstname = 'Marianne', + lastname = 'VOS' + WHERE id = 88b8fd18-b1ed-4e96-bf79-4280797cba80; + UPDATE cycling.cyclists + SET firstname = 'Anna', lastname = 'VAN DER BREGGEN' WHERE id = e7cd5752-bc0d-4157-a80f-7523add8dbcd; + + + UPDATE cycling.upcoming_calendar + SET events = ['Tour de France'] + events WHERE year=2015 AND month=06; + + + + UPDATE users + SET state = 'TX' + WHERE user_uuid + IN (88b8fd18-b1ed-4e96-bf79-4280797cba80, + 06a8913c-c0d6-477c-937d-6c1b69a95d43, + bc108776-7cb5-477f-917d-869c12dfffa8); + + UPDATE cyclist.cyclist_career_teams SET teams = teams + {'Team DSB - Ballast Nedam'} WHERE id = 88b8fd18-b1ed-4e96-bf79-4280797cba80; + + UPDATE cyclist.cyclist_career_teams SET teams = teams - {'WOMBATS'} WHERE id = 88b8fd18-b1ed-4e96-bf79-4280797cba80; + + UPDATE cyclist.cyclist_career_teams SET teams = {} WHERE id = 88b8fd18-b1ed-4e96-bf79-4280797cba80; \ No newline at end of file diff --git a/cql/examples/use.cql b/cql/examples/use.cql new file mode 100644 index 0000000..8c066c9 --- /dev/null +++ b/cql/examples/use.cql @@ -0,0 +1,3 @@ +USE key_name; +USE PortfolioDemo; +USE "Excalibur"; diff --git a/cql/parser.go b/cql/parser.go new file mode 100644 index 0000000..f069181 --- /dev/null +++ b/cql/parser.go @@ -0,0 +1,39 @@ +package cql + +import ( + "fmt" + "github.com/antlr4-go/antlr/v4" +) + +// ParseCQL parses a CQL statement and returns the parse tree. +func ParseCQL(statement string) (antlr.Tree, error) { + lexer := NewCqlLexer(antlr.NewInputStream(statement)) + stream := antlr.NewCommonTokenStream(lexer, antlr.TokenDefaultChannel) + p := NewCqlParser(stream) + + // Remove default error listeners + lexer.RemoveErrorListeners() + p.RemoveErrorListeners() + + // Add custom error listener to capture errors + lexerErrors := NewErrorListener() + parserErrors := NewErrorListener() + + lexer.AddErrorListener(lexerErrors) + p.AddErrorListener(parserErrors) + + p.BuildParseTrees = true + + // Parse from root rule + tree := p.Root() + + // Check for errors + if len(lexerErrors.Errors) > 0 { + return nil, fmt.Errorf("lexer error: %v", lexerErrors.Errors[0].Error()) + } + if len(parserErrors.Errors) > 0 { + return nil, fmt.Errorf("parser error: %v", parserErrors.Errors[0].Error()) + } + + return tree, nil +} \ No newline at end of file diff --git a/cql/parser_test.go b/cql/parser_test.go new file mode 100644 index 0000000..3b888b0 --- /dev/null +++ b/cql/parser_test.go @@ -0,0 +1,203 @@ +package cql_test + +import ( + "fmt" + "os" + "path" + "testing" + "time" + + "github.com/antlr4-go/antlr/v4" + cqlparser "github.com/bytebase/parser/cql" + "github.com/stretchr/testify/require" +) + +type CustomErrorListener struct { + errors int +} + +func NewCustomErrorListener() *CustomErrorListener { + return new(CustomErrorListener) +} + +func (l *CustomErrorListener) SyntaxError(recognizer antlr.Recognizer, offendingSymbol interface{}, line, column int, msg string, e antlr.RecognitionException) { + l.errors += 1 + antlr.ConsoleErrorListenerINSTANCE.SyntaxError(recognizer, offendingSymbol, line, column, msg, e) +} + +func (l *CustomErrorListener) ReportAmbiguity(recognizer antlr.Parser, dfa *antlr.DFA, startIndex, stopIndex int, exact bool, ambigAlts *antlr.BitSet, configs *antlr.ATNConfigSet) { + antlr.ConsoleErrorListenerINSTANCE.ReportAmbiguity(recognizer, dfa, startIndex, stopIndex, exact, ambigAlts, configs) +} + +func (l *CustomErrorListener) ReportAttemptingFullContext(recognizer antlr.Parser, dfa *antlr.DFA, startIndex, stopIndex int, conflictingAlts *antlr.BitSet, configs *antlr.ATNConfigSet) { + antlr.ConsoleErrorListenerINSTANCE.ReportAttemptingFullContext(recognizer, dfa, startIndex, stopIndex, conflictingAlts, configs) +} + +func (l *CustomErrorListener) ReportContextSensitivity(recognizer antlr.Parser, dfa *antlr.DFA, startIndex, stopIndex, prediction int, configs *antlr.ATNConfigSet) { + antlr.ConsoleErrorListenerINSTANCE.ReportContextSensitivity(recognizer, dfa, startIndex, stopIndex, prediction, configs) +} + +func TestCQLParser(t *testing.T) { + examples, err := os.ReadDir("examples") + require.NoError(t, err) + + for _, file := range examples { + filePath := path.Join("examples", file.Name()) + t.Run(filePath, func(t *testing.T) { + t.Parallel() + // read all the bytes from the file + data, err := os.ReadFile(filePath) + require.NoError(t, err) + + input := antlr.NewInputStream(string(data)) + + lexer := cqlparser.NewCqlLexer(input) + + stream := antlr.NewCommonTokenStream(lexer, 0) + p := cqlparser.NewCqlParser(stream) + + lexerErrors := &CustomErrorListener{} + lexer.RemoveErrorListeners() + lexer.AddErrorListener(lexerErrors) + + parserErrors := &CustomErrorListener{} + p.RemoveErrorListeners() + p.AddErrorListener(parserErrors) + + p.BuildParseTrees = true + + tree := p.Root() + + require.Equal(t, 0, lexerErrors.errors) + require.Equal(t, 0, parserErrors.errors) + + start := 0 + stop := stream.Size() - 1 + for i := 0; i < stream.Size(); i++ { + if stream.Get(i).GetChannel() == antlr.TokenDefaultChannel { + start = i + break + } + } + for i := stream.Size() - 1; i >= 0; i-- { + if stream.Get(i).GetChannel() == antlr.TokenDefaultChannel { + stop = i + break + } + } + + require.NotNil(t, tree) + require.NotEqual(t, 0, stop-start) + }) + } +} + +func TestParseCQL(t *testing.T) { + type args struct { + statement string + } + tests := []struct { + name string + args args + }{ + { + name: "CREATE KEYSPACE", + args: args{ + statement: `CREATE KEYSPACE test_keyspace WITH replication = {'class': 'SimpleStrategy', 'replication_factor': 3} AND durable_writes = true;`, + }, + }, + { + name: "CREATE TABLE", + args: args{ + statement: `CREATE TABLE users (id UUID PRIMARY KEY, username text, email text, created_at timestamp);`, + }, + }, + { + name: "INSERT", + args: args{ + statement: `INSERT INTO users (id, username, email, created_at) VALUES (uuid(), 'john_doe', 'john@example.com', toTimestamp(now()));`, + }, + }, + { + name: "SELECT", + args: args{ + statement: `SELECT * FROM users WHERE id = 123e4567-e89b-12d3-a456-426614174000;`, + }, + }, + { + name: "UPDATE", + args: args{ + statement: `UPDATE users SET email = 'newemail@example.com' WHERE id = 123e4567-e89b-12d3-a456-426614174000;`, + }, + }, + { + name: "DELETE", + args: args{ + statement: `DELETE FROM users WHERE id = 123e4567-e89b-12d3-a456-426614174000;`, + }, + }, + { + name: "CREATE INDEX", + args: args{ + statement: `CREATE INDEX ON users (email);`, + }, + }, + { + name: "ALTER TABLE", + args: args{ + statement: `ALTER TABLE users ADD phone text;`, + }, + }, + { + name: "DROP TABLE", + args: args{ + statement: `DROP TABLE IF EXISTS users;`, + }, + }, + { + name: "BATCH", + args: args{ + statement: `BEGIN BATCH + INSERT INTO users (id, username) VALUES (uuid(), 'user1'); + INSERT INTO users (id, username) VALUES (uuid(), 'user2'); + APPLY BATCH;`, + }, + }, + } + + start := time.Now() + defer func() { + t.Logf("Time elapsed: %v", time.Since(start)) + }() + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + tree, err := cqlparser.ParseCQL(tt.args.statement) + require.NoError(t, err) + require.NotNil(t, tree) + }) + } +} + +func TestCQLParserPerformance(t *testing.T) { + statement := `CREATE TABLE users (id UUID PRIMARY KEY, username text, email text, created_at timestamp);` + + iterations := 1000 + start := time.Now() + + for i := 0; i < iterations; i++ { + tree, err := cqlparser.ParseCQL(statement) + require.NoError(t, err) + require.NotNil(t, tree) + } + + elapsed := time.Since(start) + perIteration := elapsed / time.Duration(iterations) + + t.Logf("Parsed %d statements in %v", iterations, elapsed) + t.Logf("Average time per parse: %v", perIteration) + + // Ensure parsing is reasonably fast (< 10ms per statement) + require.Less(t, perIteration, 10*time.Millisecond, + fmt.Sprintf("Parsing too slow: %v per statement", perIteration)) +} \ No newline at end of file