github.com/rohankumardubey/aresdb@v0.0.2-0.20190517170215-e54e3ca06b9c/query/sql/SqlBase.g4 (about)

     1  /*
     2   * Licensed under the Apache License, Version 2.0 (the "License");
     3   * you may not use this file except in compliance with the License.
     4   * You may obtain a copy of the License at
     5   *
     6   *     http://www.apache.org/licenses/LICENSE-2.0
     7   *
     8   * Unless required by applicable law or agreed to in writing, software
     9   * distributed under the License is distributed on an "AS IS" BASIS,
    10   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    11   * See the License for the specific language governing permissions and
    12   * limitations under the License.
    13   */
    14  
    15  grammar SqlBase;
    16  
    17  tokens {
    18      DELIMITER
    19  }
    20  
    21  singleStatement
    22      : statement EOF
    23      ;
    24  
    25  singleExpression
    26      : expression EOF
    27      ;
    28  
    29  statement
    30      : query                                                            #statementDefault
    31      | USE schema=identifier                                            #use
    32      | USE catalog=identifier '.' schema=identifier                     #use
    33      | CREATE SCHEMA (IF NOT EXISTS)? qualifiedName
    34          (WITH properties)?                                             #createSchema
    35      | DROP SCHEMA (IF EXISTS)? qualifiedName (CASCADE | RESTRICT)?     #dropSchema
    36      | ALTER SCHEMA qualifiedName RENAME TO identifier                  #renameSchema
    37      | CREATE TABLE (IF NOT EXISTS)? qualifiedName columnAliases?
    38          (COMMENT sql_string)?
    39          (WITH properties)? AS (query | '('query')')
    40          (WITH (NO)? DATA)?                                             #createTableAsSelect
    41      | CREATE TABLE (IF NOT EXISTS)? qualifiedName
    42          '(' tableElement (',' tableElement)* ')'
    43           (COMMENT sql_string)?
    44           (WITH properties)?                                            #createTable
    45      | DROP TABLE (IF EXISTS)? qualifiedName                            #dropTable
    46      | INSERT INTO qualifiedName columnAliases? query                   #insertInto
    47      | DELETE FROM qualifiedName (WHERE booleanExpression)?             #delete
    48      | ALTER TABLE from=qualifiedName RENAME TO to=qualifiedName        #renameTable
    49      | ALTER TABLE tableName=qualifiedName
    50          RENAME COLUMN from=identifier TO to=identifier                 #renameColumn
    51      | ALTER TABLE tableName=qualifiedName
    52          DROP COLUMN column=qualifiedName                               #dropColumn
    53      | ALTER TABLE tableName=qualifiedName
    54          ADD COLUMN column=columnDefinition                             #addColumn
    55      | CREATE (OR REPLACE)? VIEW qualifiedName AS query                 #createView
    56      | DROP VIEW (IF EXISTS)? qualifiedName                             #dropView
    57      | CALL qualifiedName '(' (callArgument (',' callArgument)*)? ')'   #call
    58      | GRANT
    59          (privilege (',' privilege)* | ALL PRIVILEGES)
    60          ON TABLE? qualifiedName TO grantee=identifier
    61          (WITH GRANT OPTION)?                                           #grant
    62      | REVOKE
    63          (GRANT OPTION FOR)?
    64          (privilege (',' privilege)* | ALL PRIVILEGES)
    65          ON TABLE? qualifiedName FROM grantee=identifier                #revoke
    66      | SHOW GRANTS
    67          (ON TABLE? qualifiedName)?                                     #showGrants
    68      | EXPLAIN ANALYZE? VERBOSE?
    69          ('(' explainOption (',' explainOption)* ')')? statement        #explain
    70      | SHOW CREATE TABLE qualifiedName                                  #showCreateTable
    71      | SHOW CREATE VIEW qualifiedName                                   #showCreateView
    72      | SHOW TABLES ((FROM | IN) qualifiedName)?
    73          (LIKE pattern=sql_string (ESCAPE escape=sql_string)?)?                 #showTables
    74      | SHOW SCHEMAS ((FROM | IN) identifier)?
    75          (LIKE pattern=sql_string (ESCAPE escape=sql_string)?)?                 #showSchemas
    76      | SHOW CATALOGS (LIKE pattern=sql_string)?                             #showCatalogs
    77      | SHOW COLUMNS (FROM | IN) qualifiedName                           #showColumns
    78      | SHOW STATS (FOR | ON) qualifiedName                              #showStats
    79      | SHOW STATS FOR '(' querySpecification ')'                        #showStatsForQuery
    80      | DESCRIBE qualifiedName                                           #showColumns
    81      | DESC qualifiedName                                               #showColumns
    82      | SHOW FUNCTIONS                                                   #showFunctions
    83      | SHOW SESSION                                                     #showSession
    84      | SET SESSION qualifiedName EQ expression                          #setSession
    85      | RESET SESSION qualifiedName                                      #resetSession
    86      | SHOW PARTITIONS (FROM | IN) qualifiedName
    87          (WHERE booleanExpression)?
    88          (ORDER BY sortItem (',' sortItem)*)?
    89          (LIMIT limit=(INTEGER_VALUE | ALL))?                           #showPartitions
    90      | PREPARE identifier FROM statement                                #prepare
    91      | DEALLOCATE PREPARE identifier                                    #deallocate
    92      | EXECUTE identifier (USING expression (',' expression)*)?         #execute
    93      | DESCRIBE INPUT identifier                                        #describeInput
    94      | DESCRIBE OUTPUT identifier                                       #describeOutput
    95      ;
    96  
    97  query
    98      :  with? queryNoWith
    99      ;
   100  
   101  with
   102      : WITH RECURSIVE? namedQuery (',' namedQuery)*
   103      ;
   104  
   105  tableElement
   106      : columnDefinition
   107      | likeClause
   108      ;
   109  
   110  columnDefinition
   111      : identifier sqltype (COMMENT sql_string)?
   112      ;
   113  
   114  likeClause
   115      : LIKE qualifiedName (optionType=(INCLUDING | EXCLUDING) PROPERTIES)?
   116      ;
   117  
   118  properties
   119      : '(' property (',' property)* ')'
   120      ;
   121  
   122  property
   123      : identifier EQ expression
   124      ;
   125  
   126  queryNoWith:
   127        queryTerm
   128        (ORDER BY sortItem (',' sortItem)*)?
   129        (LIMIT limit=(INTEGER_VALUE | ALL))?
   130      ;
   131  
   132  queryTerm
   133      : queryPrimary                                                             #queryTermDefault
   134      | left=queryTerm operator=INTERSECT setQuantifier? right=queryTerm         #setOperation
   135      | left=queryTerm operator=(UNION | EXCEPT) setQuantifier? right=queryTerm  #setOperation
   136      ;
   137  
   138  queryPrimary
   139      : querySpecification                   #queryPrimaryDefault
   140      | TABLE qualifiedName                  #table
   141      | VALUES expression (',' expression)*  #inlineTable
   142      | '(' queryNoWith  ')'                 #subquery
   143      ;
   144  
   145  sortItem
   146      : expression ordering=(ASC | DESC)? (NULLS nullOrdering=(FIRST | LAST))?
   147      ;
   148  
   149  querySpecification
   150      : SELECT setQuantifier? selectItem (',' selectItem)*
   151        (FROM relation (',' relation)*)?
   152        (WHERE where=booleanExpression)?
   153        (GROUP BY groupBy)?
   154        (HAVING having=booleanExpression)?
   155      ;
   156  
   157  groupBy
   158      : setQuantifier? groupingElement (',' groupingElement)*
   159      ;
   160  
   161  groupingElement
   162      : groupingExpressions                                               #singleGroupingSet
   163      | ROLLUP '(' (qualifiedName (',' qualifiedName)*)? ')'              #rollup
   164      | CUBE '(' (qualifiedName (',' qualifiedName)*)? ')'                #cube
   165      | GROUPING SETS '(' groupingSet (',' groupingSet)* ')'              #multipleGroupingSets
   166      ;
   167  
   168  groupingExpressions
   169      : '(' (expression (',' expression)*)? ')'
   170      | expression
   171      ;
   172  
   173  groupingSet
   174      : '(' (qualifiedName (',' qualifiedName)*)? ')'
   175      | qualifiedName
   176      ;
   177  
   178  namedQuery
   179      : name=identifier (columnAliases)? AS '(' query ')'
   180      ;
   181  
   182  setQuantifier
   183      : DISTINCT
   184      | ALL
   185      ;
   186  
   187  selectItem
   188      : expression (AS? identifier)?  #selectSingle
   189      | qualifiedName '.' ASTERISK    #selectAll
   190      | ASTERISK                      #selectAll
   191      ;
   192  
   193  relation
   194      : left=relation
   195        ( CROSS JOIN right=sampledRelation
   196        | joinType JOIN rightRelation=relation joinCriteria
   197        | NATURAL joinType JOIN right=sampledRelation
   198        )                                           #joinRelation
   199      | sampledRelation                             #relationDefault
   200      ;
   201  
   202  joinType
   203      : INNER?
   204      | LEFT OUTER?
   205      | RIGHT OUTER?
   206      | FULL OUTER?
   207      ;
   208  
   209  joinCriteria
   210      : ON booleanExpression
   211      | USING '(' identifier (',' identifier)* ')'
   212      ;
   213  
   214  sampledRelation
   215      : aliasedRelation (
   216          TABLESAMPLE sampleType '(' percentage=expression ')'
   217        )?
   218      ;
   219  
   220  sampleType
   221      : BERNOULLI
   222      | SYSTEM
   223      ;
   224  
   225  aliasedRelation
   226      : relationPrimary (AS? identifier columnAliases?)?
   227      ;
   228  
   229  columnAliases
   230      : '(' identifier (',' identifier)* ')'
   231      ;
   232  
   233  relationPrimary
   234      : qualifiedName                                                   #tableName
   235      | '(' query ')'                                                   #subqueryRelation
   236      | UNNEST '(' expression (',' expression)* ')' (WITH ORDINALITY)?  #unnest
   237      | LATERAL '(' query ')'                                           #lateral
   238      | '(' relation ')'                                                #parenthesizedRelation
   239      ;
   240  
   241  expression
   242      : booleanExpression
   243      ;
   244  
   245  booleanExpression
   246      : predicated                                                   #booleanDefault
   247      | NOT booleanExpression                                        #logicalNot
   248      | left=booleanExpression operator=AND right=booleanExpression  #logicalBinary
   249      | left=booleanExpression operator=OR right=booleanExpression   #logicalBinary
   250      ;
   251  
   252  // workaround for:
   253  //  https://github.com/antlr/antlr4/issues/780
   254  //  https://github.com/antlr/antlr4/issues/781
   255  predicated
   256      : valueExpression predicate[$valueExpression.ctx]?
   257      ;
   258  
   259  // fix golang compiler error: no package name
   260  predicate[antlr.ParserRuleContext value]
   261      : comparisonOperator right=valueExpression                            #comparison
   262      | comparisonOperator comparisonQuantifier '(' query ')'               #quantifiedComparison
   263      | NOT? BETWEEN lower=valueExpression AND upper=valueExpression        #between
   264      | NOT? IN '(' expression (',' expression)* ')'                        #inList
   265      | NOT? IN '(' query ')'                                               #inSubquery
   266      | NOT? LIKE pattern=valueExpression (ESCAPE escape=valueExpression)?  #like
   267      | IS NOT? NULL                                                        #nullPredicate
   268      | IS NOT? DISTINCT FROM right=valueExpression                         #distinctFrom
   269      ;
   270  
   271  valueExpression
   272      : primaryExpression                                                                 #valueExpressionDefault
   273      | valueExpression AT timeZoneSpecifier                                              #atTimeZone
   274      | operator=(MINUS | PLUS) valueExpression                                           #arithmeticUnary
   275      | left=valueExpression operator=(ASTERISK | SLASH | PERCENT) right=valueExpression  #arithmeticBinary
   276      | left=valueExpression operator=(PLUS | MINUS) right=valueExpression                #arithmeticBinary
   277      | left=valueExpression CONCAT right=valueExpression                                 #concatenation
   278      ;
   279  
   280  primaryExpression
   281      : NULL                                                                                #nullLiteral
   282      | interval                                                                            #intervalLiteral
   283      | identifier sql_string                                                                   #typeConstructor
   284      | DOUBLE_PRECISION sql_string                                                             #typeConstructor
   285      | number                                                                              #numericLiteral
   286      | booleanValue                                                                        #booleanLiteral
   287      | sql_string                                                                              #stringLiteral
   288      | BINARY_LITERAL                                                                      #binaryLiteral
   289      | '?'                                                                                 #parameter
   290      | POSITION '(' valueExpression IN valueExpression ')'                                 #position
   291      | '(' expression (',' expression)+ ')'                                                #rowConstructor
   292      | ROW '(' expression (',' expression)* ')'                                            #rowConstructor
   293      | qualifiedName '(' ASTERISK ')' filter?                                              #functionCall
   294      | qualifiedName '(' (setQuantifier? expression (',' expression)*)?
   295          (ORDER BY sortItem (',' sortItem)*)? ')' filter?                                  #functionCall
   296      | identifier '->' expression                                                          #lambda
   297      | '(' (identifier (',' identifier)*)? ')' '->' expression                             #lambda
   298      | '(' query ')'                                                                       #subqueryExpression
   299      // This is an extension to ANSI SQL, which considers EXISTS to be a <boolean expression>
   300      | EXISTS '(' query ')'                                                                #exists
   301      | CASE valueExpression whenClause+ (ELSE elseExpression=expression)? END              #simpleCase
   302      | CASE whenClause+ (ELSE elseExpression=expression)? END                              #searchedCase
   303      | CAST '(' expression AS sqltype ')'                                                     #cast
   304      | TRY_CAST '(' expression AS sqltype ')'                                                 #cast
   305      | ARRAY '[' (expression (',' expression)*)? ']'                                       #arrayConstructor
   306      | value=primaryExpression '[' index=valueExpression ']'                               #subscript
   307      | identifier                                                                          #columnReference
   308      | base=primaryExpression '.' fieldName=identifier                                     #dereference
   309      | name=CURRENT_DATE                                                                   #specialDateTimeFunction
   310      | name=CURRENT_TIME ('(' precision=INTEGER_VALUE ')')?                                #specialDateTimeFunction
   311      | name=CURRENT_TIMESTAMP ('(' precision=INTEGER_VALUE ')')?                           #specialDateTimeFunction
   312      | name=LOCALTIME ('(' precision=INTEGER_VALUE ')')?                                   #specialDateTimeFunction
   313      | name=LOCALTIMESTAMP ('(' precision=INTEGER_VALUE ')')?                              #specialDateTimeFunction
   314      | name=CURRENT_USER                                                                   #currentUser
   315      | SUBSTRING '(' valueExpression FROM valueExpression (FOR valueExpression)? ')'       #substring
   316      | NORMALIZE '(' valueExpression (',' normalForm)? ')'                                 #normalize
   317      | EXTRACT '(' identifier FROM valueExpression ')'                                     #extract
   318      | '(' expression ')'                                                                  #parenthesizedExpression
   319      | GROUPING '(' (qualifiedName (',' qualifiedName)*)? ')'                              #groupingOperation
   320      ;
   321  
   322  sql_string
   323      : STRING                                #basicStringLiteral
   324      | UNICODE_STRING (UESCAPE STRING)?      #unicodeStringLiteral
   325      ;
   326  
   327  timeZoneSpecifier
   328      : TIME ZONE interval  #timeZoneInterval
   329      | TIME ZONE sql_string    #timeZoneString
   330      ;
   331  
   332  comparisonOperator
   333      : EQ | NEQ | LT | LTE | GT | GTE
   334      ;
   335  
   336  comparisonQuantifier
   337      : ALL | SOME | ANY
   338      ;
   339  
   340  booleanValue
   341      : TRUE | FALSE
   342      ;
   343  
   344  interval
   345      : INTERVAL sign=(PLUS | MINUS)? sql_string from=intervalField (TO to=intervalField)?
   346      ;
   347  
   348  intervalField
   349      : YEAR | MONTH | DAY | HOUR | MINUTE | SECOND
   350      ;
   351  
   352  normalForm
   353      : NFD | NFC | NFKD | NFKC
   354      ;
   355  
   356  // fix golang fmt error
   357  sqltype
   358      : sqltype ARRAY
   359      | ARRAY '<' sqltype '>'
   360      | MAP '<' sqltype ',' sqltype '>'
   361      | ROW '(' identifier sqltype (',' identifier sqltype)* ')'
   362      | baseType ('(' typeParameter (',' typeParameter)* ')')?
   363      | INTERVAL from=intervalField TO to=intervalField
   364      ;
   365  
   366  typeParameter
   367      : INTEGER_VALUE | sqltype
   368      ;
   369  
   370  baseType
   371      : TIME_WITH_TIME_ZONE
   372      | TIMESTAMP_WITH_TIME_ZONE
   373      | DOUBLE_PRECISION
   374      | identifier
   375      ;
   376  
   377  whenClause
   378      : WHEN condition=expression THEN result=expression
   379      ;
   380  
   381  filter
   382      : FILTER '(' WHERE booleanExpression ')'
   383      ;
   384  
   385  
   386  explainOption
   387      : FORMAT value=(TEXT | GRAPHVIZ)                   #explainFormat
   388      | TYPE value=(LOGICAL | DISTRIBUTED | VALIDATE)    #explainType
   389      ;
   390  
   391  
   392  callArgument
   393      : expression                    #positionalArgument
   394      | identifier '=>' expression    #namedArgument
   395      ;
   396  
   397  privilege
   398      : SELECT | DELETE | INSERT | identifier
   399      ;
   400  
   401  qualifiedName
   402      : identifier ('.' identifier)*
   403      ;
   404  
   405  identifier
   406      : IDENTIFIER             #unquotedIdentifier
   407      | QUOTED_IDENTIFIER      #quotedIdentifier
   408      | nonReserved            #unquotedIdentifier
   409      | BACKQUOTED_IDENTIFIER  #backQuotedIdentifier
   410      | DIGIT_IDENTIFIER       #digitIdentifier
   411      ;
   412  
   413  number
   414      : DECIMAL_VALUE  #decimalLiteral
   415      | DOUBLE_VALUE   #doubleLiteral
   416      | INTEGER_VALUE  #integerLiteral
   417      ;
   418  
   419  nonReserved
   420      // IMPORTANT: this rule must only contain tokens. Nested rules are not supported. See SqlParser.exitNonReserved
   421      : ADD | ALL | ANALYZE | ANY | ARRAY | ASC | AT
   422      | BERNOULLI
   423      | CALL | CASCADE | CATALOGS | COALESCE | COLUMN | COLUMNS | COMMENT | COMMIT | COMMITTED | CURRENT
   424      | DATA | DATE | DAY | DESC | DISTRIBUTED
   425      | EXCLUDING | EXPLAIN
   426      | FILTER | FIRST | FOLLOWING | FORMAT | FUNCTIONS
   427      | GRANT | GRANTS | GRAPHVIZ
   428      | HOUR
   429      | IF | INCLUDING | INPUT | INTEGER | INTERVAL | ISOLATION
   430      | LAST | LATERAL | LEVEL | LIMIT | LOGICAL
   431      | MAP | MINUTE | MONTH
   432      | NFC | NFD | NFKC | NFKD | NO | NULLIF | NULLS
   433      | ONLY | OPTION | ORDINALITY | OUTPUT | OVER
   434      | PARTITION | PARTITIONS | POSITION | PRECEDING | PRIVILEGES | PROPERTIES | PUBLIC
   435      | RANGE | READ | RENAME | REPEATABLE | REPLACE | RESET | RESTRICT | REVOKE | ROLLBACK | ROW | ROWS
   436      | SCHEMA | SCHEMAS | SECOND | SERIALIZABLE | SESSION | SET | SETS
   437      | SHOW | SMALLINT | SOME | START | STATS | SUBSTRING | SYSTEM
   438      | TABLES | TABLESAMPLE | TEXT | TIME | TIMESTAMP | TINYINT | TO | TRANSACTION | TRY_CAST | TYPE
   439      | UNBOUNDED | UNCOMMITTED | USE
   440      | VALIDATE | VERBOSE | VIEW
   441      | WORK | WRITE
   442      | YEAR
   443      | ZONE
   444      ;
   445  
   446  ADD: 'ADD';
   447  ALL: 'ALL';
   448  ALTER: 'ALTER';
   449  ANALYZE: 'ANALYZE';
   450  AND: 'AND';
   451  ANY: 'ANY';
   452  ARRAY: 'ARRAY';
   453  AS: 'AS';
   454  ASC: 'ASC';
   455  AT: 'AT';
   456  BERNOULLI: 'BERNOULLI';
   457  BETWEEN: 'BETWEEN';
   458  BY: 'BY';
   459  CALL: 'CALL';
   460  CASCADE: 'CASCADE';
   461  CASE: 'CASE';
   462  CAST: 'CAST';
   463  CATALOGS: 'CATALOGS';
   464  COALESCE: 'COALESCE';
   465  COLUMN: 'COLUMN';
   466  COLUMNS: 'COLUMNS';
   467  COMMENT: 'COMMENT';
   468  COMMITTED: 'COMMITTED';
   469  CONSTRAINT: 'CONSTRAINT';
   470  CREATE: 'CREATE';
   471  CROSS: 'CROSS';
   472  CUBE: 'CUBE';
   473  CURRENT: 'CURRENT';
   474  CURRENT_DATE: 'CURRENT_DATE';
   475  CURRENT_TIME: 'CURRENT_TIME';
   476  CURRENT_TIMESTAMP: 'CURRENT_TIMESTAMP';
   477  CURRENT_USER: 'CURRENT_USER';
   478  DATA: 'DATA';
   479  DATE: 'DATE';
   480  DAY: 'DAY';
   481  DEALLOCATE: 'DEALLOCATE';
   482  DELETE: 'DELETE';
   483  DESC: 'DESC';
   484  DESCRIBE: 'DESCRIBE';
   485  DISTINCT: 'DISTINCT';
   486  DISTRIBUTED: 'DISTRIBUTED';
   487  DROP: 'DROP';
   488  ELSE: 'ELSE';
   489  END: 'END';
   490  ESCAPE: 'ESCAPE';
   491  EXCEPT: 'EXCEPT';
   492  EXCLUDING: 'EXCLUDING';
   493  EXECUTE: 'EXECUTE';
   494  EXISTS: 'EXISTS';
   495  EXPLAIN: 'EXPLAIN';
   496  EXTRACT: 'EXTRACT';
   497  FALSE: 'FALSE';
   498  FILTER: 'FILTER';
   499  FIRST: 'FIRST';
   500  FOLLOWING: 'FOLLOWING';
   501  FOR: 'FOR';
   502  FORMAT: 'FORMAT';
   503  FROM: 'FROM';
   504  FULL: 'FULL';
   505  FUNCTIONS: 'FUNCTIONS';
   506  GRANT: 'GRANT';
   507  GRANTS: 'GRANTS';
   508  GRAPHVIZ: 'GRAPHVIZ';
   509  GROUP: 'GROUP';
   510  GROUPING: 'GROUPING';
   511  HAVING: 'HAVING';
   512  HOUR: 'HOUR';
   513  IF: 'IF';
   514  IN: 'IN';
   515  INCLUDING: 'INCLUDING';
   516  INNER: 'INNER';
   517  INPUT: 'INPUT';
   518  INSERT: 'INSERT';
   519  INTEGER: 'INTEGER';
   520  INTERSECT: 'INTERSECT';
   521  INTERVAL: 'INTERVAL';
   522  INTO: 'INTO';
   523  IS: 'IS';
   524  JOIN: 'JOIN';
   525  LAST: 'LAST';
   526  LATERAL: 'LATERAL';
   527  LEFT: 'LEFT';
   528  LEVEL: 'LEVEL';
   529  LIKE: 'LIKE';
   530  LIMIT: 'LIMIT';
   531  LOCALTIME: 'LOCALTIME';
   532  LOCALTIMESTAMP: 'LOCALTIMESTAMP';
   533  LOGICAL: 'LOGICAL';
   534  MAP: 'MAP';
   535  MINUTE: 'MINUTE';
   536  MONTH: 'MONTH';
   537  NATURAL: 'NATURAL';
   538  NFC : 'NFC';
   539  NFD : 'NFD';
   540  NFKC : 'NFKC';
   541  NFKD : 'NFKD';
   542  NO: 'NO';
   543  NORMALIZE: 'NORMALIZE';
   544  NOT: 'NOT';
   545  NULL: 'NULL';
   546  NULLIF: 'NULLIF';
   547  NULLS: 'NULLS';
   548  ON: 'ON';
   549  ONLY: 'ONLY';
   550  OPTION: 'OPTION';
   551  OR: 'OR';
   552  ORDER: 'ORDER';
   553  ORDINALITY: 'ORDINALITY';
   554  OUTER: 'OUTER';
   555  OUTPUT: 'OUTPUT';
   556  OVER: 'OVER';
   557  PARTITION: 'PARTITION';
   558  PARTITIONS: 'PARTITIONS';
   559  POSITION: 'POSITION';
   560  PRECEDING: 'PRECEDING';
   561  PREPARE: 'PREPARE';
   562  PRIVILEGES: 'PRIVILEGES';
   563  PROPERTIES: 'PROPERTIES';
   564  PUBLIC: 'PUBLIC';
   565  RANGE: 'RANGE';
   566  READ: 'READ';
   567  RECURSIVE: 'RECURSIVE';
   568  RENAME: 'RENAME';
   569  REPEATABLE: 'REPEATABLE';
   570  REPLACE: 'REPLACE';
   571  RESET: 'RESET';
   572  RESTRICT: 'RESTRICT';
   573  REVOKE: 'REVOKE';
   574  RIGHT: 'RIGHT';
   575  ROLLBACK: 'ROLLBACK';
   576  ROLLUP: 'ROLLUP';
   577  ROW: 'ROW';
   578  ROWS: 'ROWS';
   579  SCHEMA: 'SCHEMA';
   580  SCHEMAS: 'SCHEMAS';
   581  SECOND: 'SECOND';
   582  SELECT: 'SELECT';
   583  SERIALIZABLE: 'SERIALIZABLE';
   584  SESSION: 'SESSION';
   585  SET: 'SET';
   586  SETS: 'SETS';
   587  SHOW: 'SHOW';
   588  SMALLINT: 'SMALLINT';
   589  SOME: 'SOME';
   590  START: 'START';
   591  STATS: 'STATS';
   592  SUBSTRING: 'SUBSTRING';
   593  SYSTEM: 'SYSTEM';
   594  TABLE: 'TABLE';
   595  TABLES: 'TABLES';
   596  TABLESAMPLE: 'TABLESAMPLE';
   597  TEXT: 'TEXT';
   598  THEN: 'THEN';
   599  TIME: 'TIME';
   600  TIMESTAMP: 'TIMESTAMP';
   601  TINYINT: 'TINYINT';
   602  TO: 'TO';
   603  TRUE: 'TRUE';
   604  TRY_CAST: 'TRY_CAST';
   605  TYPE: 'TYPE';
   606  UESCAPE: 'UESCAPE';
   607  UNBOUNDED: 'UNBOUNDED';
   608  UNCOMMITTED: 'UNCOMMITTED';
   609  UNION: 'UNION';
   610  UNNEST: 'UNNEST';
   611  USE: 'USE';
   612  USING: 'USING';
   613  VALIDATE: 'VALIDATE';
   614  VALUES: 'VALUES';
   615  VERBOSE: 'VERBOSE';
   616  VIEW: 'VIEW';
   617  WHEN: 'WHEN';
   618  WHERE: 'WHERE';
   619  WITH: 'WITH';
   620  WORK: 'WORK';
   621  WRITE: 'WRITE';
   622  YEAR: 'YEAR';
   623  ZONE: 'ZONE';
   624  
   625  EQ  : '=';
   626  NEQ : '<>' | '!=';
   627  LT  : '<';
   628  LTE : '<=';
   629  GT  : '>';
   630  GTE : '>=';
   631  
   632  PLUS: '+';
   633  MINUS: '-';
   634  ASTERISK: '*';
   635  SLASH: '/';
   636  PERCENT: '%';
   637  CONCAT: '||';
   638  
   639  STRING
   640      : '\'' ( ~'\'' | '\'\'' )* '\''
   641      ;
   642  
   643  UNICODE_STRING
   644      : 'U&\'' ( ~'\'' | '\'\'' )* '\''
   645      ;
   646  
   647  // Note: we allow any character inside the binary literal and validate
   648  // its a correct literal when the AST is being constructed. This
   649  // allows us to provide more meaningful error messages to the user
   650  BINARY_LITERAL
   651      :  'X\'' (~'\'')* '\''
   652      ;
   653  
   654  INTEGER_VALUE
   655      : DIGIT+
   656      ;
   657  
   658  DECIMAL_VALUE
   659      : DIGIT+ '.' DIGIT*
   660      | '.' DIGIT+
   661      ;
   662  
   663  DOUBLE_VALUE
   664      : DIGIT+ ('.' DIGIT*)? EXPONENT
   665      | '.' DIGIT+ EXPONENT
   666      ;
   667  
   668  IDENTIFIER
   669      : (LETTER | '_') (LETTER | DIGIT | '_' | '@' | ':')*
   670      ;
   671  
   672  DIGIT_IDENTIFIER
   673      : DIGIT (LETTER | DIGIT | '_' | '@' | ':')+
   674      ;
   675  
   676  QUOTED_IDENTIFIER
   677      : '"' ( ~'"' | '""' )* '"'
   678      ;
   679  
   680  BACKQUOTED_IDENTIFIER
   681      : '`' ( ~'`' | '``' )* '`'
   682      ;
   683  
   684  TIME_WITH_TIME_ZONE
   685      : 'TIME' WS 'WITH' WS 'TIME' WS 'ZONE'
   686      ;
   687  
   688  TIMESTAMP_WITH_TIME_ZONE
   689      : 'TIMESTAMP' WS 'WITH' WS 'TIME' WS 'ZONE'
   690      ;
   691  
   692  DOUBLE_PRECISION
   693      : 'DOUBLE' WS 'PRECISION'
   694      ;
   695  
   696  fragment EXPONENT
   697      : 'E' [+-]? DIGIT+
   698      ;
   699  
   700  fragment DIGIT
   701      : [0-9]
   702      ;
   703  
   704  fragment LETTER
   705      : [A-Z]
   706      ;
   707  
   708  SIMPLE_COMMENT
   709      : '--' ~[\r\n]* '\r'? '\n'? -> channel(HIDDEN)
   710      ;
   711  
   712  BRACKETED_COMMENT
   713      : '/*' .*? '*/' -> channel(HIDDEN)
   714      ;
   715  
   716  WS
   717      : [ \r\n\t]+ -> channel(HIDDEN)
   718      ;
   719  
   720  // Catch-all for anything we can't recognize.
   721  // We use this to be able to ignore and recover all the text
   722  // when splitting statements with DelimiterLexer
   723  UNRECOGNIZED
   724      : .
   725      ;