Neo4查询语言Cypher3.0.7在antlr4下的文法(原创分享）

本人网上找了很久都没有一个比较好的cypher文法，于是花了一段时间研究cypher和编写基于antlr4下的cypher文法。

希望对想用做cypher相关工具的朋友有一点用，欢迎交流。

珍重声明：该文法经过测试，能够在ANTLRWorks2.1下正确运行，并通过了官网上示例测试。

但不表示完美的，如有朋友用它是发现问题，请提交问题到项目git下或者在文章下留言。

另外由于csdn没有转针对antrl文法代码的着色方案，因此选择了actionscript语言着色，还可以看。

官网示例：https://neo4j.com/docs/developer-manual/3.0/cypher/
项目git地址：https://github.com/yoyoma214/Cypher-Antlr4-Grammer

 /*
  * MIT license
  * Copyright (C) 2016/12/10 adam
  */

 grammar Cypher;

 document: (unionQuery |  callClause | dropConstraint | dropIndexClause | importClause) ';'?;
 directive: CYPHER directiveItem (',' directiveItem )*;
 directiveItem:  id EQUAL expression ;
 createNode: CREATE assignGraphRelation (',' assignGraphRelation)*;
 unwind: UNWIND expression (AS id)? ;
 //merge;
 mergeClause: MERGE graphRelation mergeClauseOn*;
 mergeClauseOn:mergeOnCreate | mergeOnMatch;
 mergeOnCreate:  ON CREATE setClause;
 mergeOnMatch:  ON MATCH setClause;
 setClause: SET setClauseItem (',' setClauseItem)*;
 setClauseItem: assignExpression | setMap | setAddMap | setLabel ;
 setMap: id EQUAL(PARAMETER | nodePropertyList );
 setAddMap: id ADDEQUAL (PARAMETER | nodePropertyList );
 setLabel: id labelVar+;
 assignExpression: idPath EQUAL expression;
 procedure: idPath  expressionList? ;
 //index
 createIndexClause: CREATE INDEX ON labelVar '(' id ')';
 createUnique: CREATE UNIQUE graphRelation ( ',' graphRelation )*;
 useIndexClause: USING INDEX id labelVar '(' id ')';
 useScanClause: USING SCAN id labelVar ;
 useJoinClause: USING JOIN id (',' id)* ;
 dropIndexClause: DROP INDEX ON labelVar '(' id ')';
 callClause: CALL procedure (YIELD id)? returnClause?;
 createConstraint: CREATE CONSTRAINT ON (node | graphRelation) assert_;
 dropConstraint: DROP CONSTRAINT ON graphRelation assert_;
 assert_: ASSERT_ expression;
 unionQuery: directive? query unionClause* ;
 unionClause: UNION ALL? query;
 query: PROFILE? startClause?  (matchOrWith)*
        modifyCluase*
        returnClause? ;
 modifyCluase:createClause | mergeClause |setClause | deleteClause | removeClause | foreachClause;
 startClause: START  assignGraphRelation (',' assignGraphRelation)*;
 matchOrWith: matchClause |  unwind  | withClause;
 createClause:  createIndexClause | createUnique | createConstraint | createNode   ; //| createNodeMap
 matchClause : matchClauseItem+ (useIndexClause | useScanClause | useJoinClause)*
         whereClause?  ;
 matchClauseItem: OPTIONAL? MATCH assignGraphRelation (',' assignGraphRelation)*;
 assignGraphRelation: (id EQUAL)? (relationIndex | nodeIndex | graphRelation |  builtInCall);
 nodeIndex:  NODE labelVar '(' (id EQUAL expression | indexQueryString) ')';
 relationIndex: RELATIONSHIP labelVar '(' (id EQUAL expression | indexQueryString) ')';
 indexQueryString:STRING;

 whereClause: WHERE expression ;
 fetchVar:  fetchOneVar | allVar;
 fetchOneVar:( DISTINCT? idPath | expression) (AS var)?;
 allVar: MULIT;
 withClause:WITH fetchVar(',' fetchVar)*  orderBy? skipClause? limitClause? whereClause?;
 orderBy: ORDER BY orderByItem (',' orderByItem)*;
 orderByItem: idPath (ASC | DESC)?;
 skipClause: SKIP expression;
 limitClause: LIMIT expression;
 returnClause: RETURN fetchVar(',' fetchVar)* orderBy? skipClause? limitClause?;

 deleteClause: DETACH? DELETE deleteItem  (',' deleteItem)*;
 deleteItem:var | graphRelation;
 removeClause: removeLabel | removeProperty;
 removeLabel: REMOVE var+;
 removeProperty: REMOVE idPath;

 updateClause: SET updateItem (',' updateItem )*;
 updateItem: idPath EQUAL expression;

 foreachClause: FOREACH '(' var IN expression '|' (setClause | createClause) ')';

 nodePropertyList: json | PARAMETER;
 node : nodeEmpty | nodeNotEmpty ;
 nodeNotEmpty:  '(' id? labelVar*   nodePropertyList? ')' ;
 nodeEmpty: NIL;
 idPath: id ('.' id)*;

 graphRelation: node |  node relation*;
 relation: (relationToNext | relationToPrev | relationToBoth )
           node;

 relationToNext:'-' relationType?  ARROWAHEAD;
 relationToPrev:ARROWBACK relationType? '-';
 relationToBoth:'-' relationType? '-';
 relationType:  '['matchTag relationTypeRestrict? nodePropertyList? ']';
 matchTag: var? labelVar? ;
 relationTypeRestrict: relationTypeCounterRange | relationTypeCounterAll | relationTypeIdList ;
 relationTypeCounterRange: MULIT INTEGER? (DOUBLEDOT  INTEGER)? ;
 relationTypeCounterAll: MULIT ALL ;
 relationTypeIdList: labelVar ('|' labelVar)*;

 importClause: usingPeriodicCommit?
               loadCvs
               matchClause?
               modifyCluase*;    

 loadCvs:LOAD CSV (WITH HEADERS)? FROM STRING (AS id)? (FIELDTERMINATOR STRING)? ;
 usingPeriodicCommit:USING PERIODIC COMMIT integerCypher?;

 //expression
 expression   :   conditionalOrExpression ;
 conditionalOrExpression   :   conditionalAndExpression ( OR conditionalAndExpression )* ;
 conditionalAndExpression   :   valueLogical ( AND valueLogical )* ;
 valueLogical   :   relationalExpression ;

 argList   :   NIL | '(' DISTINCT? expression ( ',' expression )* ')'  ;
 expressionList   :   NIL | '(' expression ( ',' expression )* ')'  ;
 relationalExpression   : NOT? (relationalExpressionChain | relationalExpressionIsNull | relationalExpressionString | relationalExpressionIn | relationalExpresionExists | graphRelation | caseExpression | relationalIsUnique);
 relationalExpressionIn:numericExpression (  IN expression | NOT IN expression )? ;
 relationalExpressionChain: numericExpression relationalExpressionChainTtem* ;
 relationalExpressionChainTtem:(LT | LT_EQUAL |GT | GT_EQUAL |EQUAL | NOT_EQUAL |XOR ) numericExpression;

 relationalExpressionIsNull: numericExpression IS NULL;
 relationalExpressionString: relationalExpressionStartsWith | relationalExpressionEndsWith | relationalExpressionContains | relationalExpressionRegular;
 relationalExpressionStartsWith: numericExpression STARTS WITH STRING;
 relationalExpressionEndsWith: numericExpression ENDS WITH STRING;
 relationalExpressionContains: numericExpression CONTAINS STRING;
 relationalExpressionRegular:numericExpression EQUAL_REGUALR STRING;

 relationalIsUnique: idPath IS UNIQUE;

 relationalExpresionExists: EXISTS '(' expression ')';

 numericExpression   :   additiveExpression ;

 additiveExpression   :   multiplicativeExpression additiveExpressionRightPart* ;

 additiveExpressionRightPart:addMultiplicativeExpression | subtractionMultiplicativeExpression | additiveExpressionMulti;

 addMultiplicativeExpression : ADD multiplicativeExpression;

 subtractionMultiplicativeExpression: SUBTRACTION multiplicativeExpression ;

 multiplicativeExpression   :   unaryExpression multiplicativeExpressionItem* ;

 additiveExpressionMulti:
                            numericLiteral  multiplicativeExpressionItem *
                       ;
 multiplicativeExpressionItem:
                                  (MULIT | DIVISION) unaryExpression
                              ;
 unaryExpression   :
                       NEGATE primaryExpression
                     | ADD primaryExpression
                     | SUBTRACTION primaryExpression
                     | NOT primaryExpression
                     | primaryExpression ;

 primaryExpression   :
                      caseExpression
                     |brackettedExpression
                     |anyVal
                     |listExpression
                     |list
                     |primaryExpressionChain;

 rangeExpression: '[' numericLiteral DOUBLEDOT numericLiteral ']';
 primaryExpressionChain:
                           primaryExpressionChainItem primaryExpressionChainRightPart*
                       ;

 primaryExpressionChainRightPart:listFetch | '.' primaryExpressionChainItem | rangeExpression;

 primaryExpressionChainItem:
                               builtInCall | id
                           ;

 caseExpression: CASE expression? caseExpressionWhen+ caseExpressionElse? END ;
 caseExpressionWhen: WHEN expression THEN  expression;
 caseExpressionElse: ELSE expression;
 listExpression: listExpressionAll | listExpressionAny | listExpressionNone | listExpressionSingle;
 listExpressionExist:listExpressionAll | listExpressionAny | listExpressionNone | listExpressionSingle;
 listExpressionAll: ALL '('var IN expression WHERE listExpressionCondition  ')';
 listExpressionAny: ANY '('var IN expression WHERE listExpressionCondition  ')';
 listExpressionNone: NONE '('var IN expression WHERE listExpressionCondition  ')';
 listExpressionSingle: SINGLE '('var IN expression WHERE listExpressionCondition  ')';
 listExpressionCondition:  EXISTS '(' idPath  ')' | expression ;
 list: '[' anyVal (',' anyVal)* ']';
 listFetch : '[' expression ']';
 var : id ;
 brackettedExpression   :   '(' expression ')' ;
 builtInCall   :     pathFunc |  nodesFunc  | relationshipsFunc |extractFunc | filterFunc | absFunc | randFunc | roundFunc | sqrtFunc |signFunc | sinFunc | cosFunc |
            tanFunc | cotFunc |  asinFunc |  acosFunc | atanFunc |  atan2Func |  haversinFunc | degreesFunc | radiansFunc | pi | log10Func| logFunc | expFunc | e | countAllFunc |
            countFunc | collectFunc | sumFunc | avgFunc |  minFunc |  maxFunc |percentileDiscFunc | percentileContFunc | stdevFunc | stdevpFunc | toStringFunc | replaceStrFunc | substringStrFunc | leftStrFunc | rightStrFunc | trimStrFunc | ltrimStrFunc|
 rtrimStrFunc | upperStrFunc | lowerStrFunc | splitStrFunc | reverseStrFunc | lengthStrFunc | nodeId | rangeFunc | typeFunc | shortestPathFunc | allShortestPathsFunc | relsFunc | toLowerFunc |toInt | labelsFunc | timestampFunc | sizeFunc |
 coalesceFunc | headFunc | lastFunc | startNodeFunc | endNodeFunc | propertiesFunc | toFloatFunc |keysFunc | tailFunc | reduceFunc | floorFunc;

 pathFunc: LENGTH '(' expression ')';
 nodesFunc: NODES '(' expression ')';
 relationshipsFunc: RELATIONSHIPS '(' expression ')';
 extractFunc: EXTRACT '(' var IN expression '|' expression ')';
 filterFunc: FILTER  '(' var IN expression WHERE relationalExpression ')';
 absFunc: ABS '(' expression ')';
 randFunc:RAND NIL;
 roundFunc:ROUND '(' expression ')';
 sqrtFunc: SQRT '(' expression ')';
 signFunc: SIGN '(' expression ')';
 sinFunc:SIN '(' expression ')';
 cosFunc:COS '(' expression ')';
 tanFunc:TAN '(' expression ')';
 cotFunc:COT '(' expression ')';
 asinFunc:ASIN '(' expression ')';
 acosFunc:ACOS '(' expression ')';
 atanFunc:ATAN '(' expression ')';
 atan2Func:ATAN2 '(' expression ',' expression ')';
 haversinFunc:HAVERSIN '(' expression ')';
 degreesFunc:DEGREES '(' expression ')';
 radiansFunc:RADIANS '(' expression ')';
 pi:PI NIL;
 log10Func:LOG10 '(' expression ')';
 logFunc:LOG '(' expression ')';
 expFunc:EXP '(' expression ')';
 e: EFUNC NIL;
 countAllFunc:COUNT '(' '*' ')';
 countFunc:COUNT '(' DISTINCT? idPath ')';
 collectFunc:COLLECT '(' idPath ')';
 sumFunc:SUM '(' idPath ')';
 avgFunc:AVG '(' idPath ')';
 minFunc:MIN '(' idPath ')';
 maxFunc:MAX '(' idPath ')';
 percentileDiscFunc:PERCENTILEDISC '(' idPath ',' numericLiteral ')';
 percentileContFunc:PERCENTILECONT '(' idPath ',' numericLiteral ')';
 stdevFunc:STDEV '(' expression ')';
 stdevpFunc:STDEVP '(' expression ')';
 toStringFunc:TOSTRING '(' expression ')';
 replaceStrFunc:REPLACE '(' expression ',' expression ',' expression ')';
 substringStrFunc:SUBSTRING '(' expression ',' INTEGER (',' INTEGER)? ')';
 leftStrFunc:LEFT '(' expression ',' INTEGER ')';
 rightStrFunc:RIGHT '(' expression ',' INTEGER ')';
 trimStrFunc:TRIM '(' expression ')';
 ltrimStrFunc:LTRIM '(' expression ')';
 rtrimStrFunc:RTRIM '(' expression ')';
 upperStrFunc:UPPER '(' expression ')';
 lowerStrFunc:LOWER '(' expression ')';
 splitStrFunc:SPLIT '(' expression ',' STRING ')';
 reverseStrFunc:REVERSE '(' expression ')';
 lengthStrFunc:LENGTH '(' expression ')';
 nodeId: IDFUNC '(' id ')';
 rangeFunc: RANGE '(' expression ',' expression (',' expression)? ')';
 typeFunc: TYPE '(' id ')';
 shortestPathFunc: SHORTESTPATH '(' expression ')';
 relsFunc: RELS '(' expression ')';
 allShortestPathsFunc: ALLSHORTESTPATHS '(' expression ')';
 toLowerFunc: TOLOWER '(' expression ')';
 toInt:TOINT '(' expression ')';
 labelsFunc: LABELS '(' expression ')';
 timestampFunc:TIMESTAMP NIL;
 sizeFunc: SIZE '(' expression ')';
 coalesceFunc: COALESCE expressionList;
 headFunc: HEAD '(' expression ')';
 lastFunc: LAST '(' expression ')';
 startNodeFunc: STARTNODE '(' expression ')';
 endNodeFunc: ENDNODE '(' expression ')';
 propertiesFunc:PROPERTIES  '(' expression ')';
 toFloatFunc: TOFLOAT  '(' expression ')';
 keysFunc: KEYS '(' expression ')';
 tailFunc: TAIL '(' expression ')';
 reduceFunc: REDUCE '(' accumulator EQUAL expression ',' ID IN expression '|' expression ')';
 accumulator : ID;
 floorFunc: FLOOR '(' expression ')';     

 graphElment: id labelVar;

 anyVal :  STRING | BOOLEAN | NULL | parameterPath | numericLiteral |graphElment | idPath | json ;

 //json
 json:   jsonObject
     |   jsonArray
     ;

 jsonObject
     :   ('{' jsonField (',' jsonField)* '}'
             |   '{' '}' // empty object
         )
     ;
 jsonArray
     :   '['list ']'
     |   '[' ']' // empty array
     ;

 jsonField:   id ':' expression;

 numericLiteral: integerCypher | decimalCypher | doubleCypher ;
 integerCypher   :   ('+'| '-')? INTEGER ;
 decimalCypher   :   ('+'| '-')? DECIMAL ;
 doubleCypher   :   ('+'| '-')? DOUBLE ;

 parameterPath: PARAMETER ('.' id )*;
 labelVar: ':' id ;
 id: ID | MATCH | OPTIONAL | WITH | SKIP | LIMIT | UNION | RETURN | DETACH |REMOVE|SET|CALL|YIELD|CONSTRAINT|ON|ASSERT_|DROP|
     UNWIND|MERGE|INDEX|USING|SCAN|JOIN|FOREACH|CSV|IN|NOT|AND|OR|XOR|CASE|WHEN|ELSE|IS|UNIQUE|NULL|STARTS|START|ENDS|
     END|CONTAINS|THEN|ALL|ANY|NONE|SINGLE|COUNT|DISTINCT|SUM|MIN|MAX|AVG|WHERE|SELECT|AS|FROM|BY|ORDER|ASC|DESC|LOAD|
     CREATE|DELETE|EXISTS|HEADERS|FIELDTERMINATOR|PERIODIC|COMMIT|PROFILE|CYPHER|LENGTH|NODES|NODE|RELATIONSHIP|
     RELATIONSHIPS|EXTRACT|FILTER|ABS|RAND|ROUND|SQRT|SIGN|COS|TAN|COT|ASIN|ACOS|ATAN|ATAN2|HAVERSIN|SIN|DEGREES|RADIANS|
     PI|LOG10|LOG|EXP|EFUNC|COLLECT|PERCENTILEDISC|PERCENTILECONT|STDEVP|STDEV|TOSTRING|REPLACE|SUBSTRING|LEFT|RIGHT|TRIM|
     LTRIM|RTRIM|UPPER|LOWER|SPLIT|REVERSE|IDFUNC|RANGE|TYPE|SHORTESTPATH|RELS|ALLSHORTESTPATHS|TOLOWER|TOINT|LABELS|
     TIMESTAMP|SIZE|COALESCE|HEAD|LAST|STARTNODE|ENDNODE|PROPERTIES|TOFLOAT|KEYS|TAIL|REDUCE|FLOOR;
 PARAMETER: '{' WS* (PN_CHARS_U ( PN_CHARS_U | [0-9])*) WS* '}';
 LBRACE: '{';
 RBRACE: '}';
 MATCH: M A T C H;
 OPTIONAL: O P T I O N A L;
 WITH: W I T H;
 SKIP: S K I P;
 LIMIT: L I M I T;
 UNION: U N I O N;
 RETURN: R E T U R N;
 DETACH: D E T A C H;
 REMOVE: R E M O V E;
 SET: S E T;
 CALL: C A L L ;
 YIELD: Y I E L D;
 CONSTRAINT: C O N S T R A I N T;
 ON: O N;
 ASSERT_: A S S E R T;
 DROP : D R O P ;
 UNWIND :U N W I N D ;
 MERGE: M E R G E;
 INDEX: I N D E X;
 USING : U S I N G;
 SCAN:S C A N;
 JOIN:J O I N;
 FOREACH: F O R E A C H;
 CSV: C S V;
 IN:I N;
 NOT:N O T;
 AND: A N D ;
 OR: O R;
 XOR:X O R;

 CASE: C A S E;
 WHEN : W H E N;
 ELSE : E L S E;
 IS: I S;
 UNIQUE:U N I Q U E;
 NULL: N U L L ;
 STARTS: S T A R T S;
 START: S T A R T;
 ENDS: E N D S;
 END: E N D;
 CONTAINS: C O N T A I N S;
 THEN: T H E N;
 ALL : A L L;
 ANY: A N Y ;
 NONE: N O N E;
 SINGLE: S I N G L E;
 BOOLEAN : BOOL_VAL_TRUE | BOOL_VAL_FALSE;
 COUNT : C O U N T;
 DISTINCT : D I S T I N C T;
 SUM : S U M;
 MIN : M I N;
 MAX : M A X;
 AVG : A V G;
 WHERE: W H E R E;
 SELECT:S E L E C T;
 AS:A S;
 FROM:F R O M;
 BY:B Y;
 ORDER:O R D E R;
 ASC:A S C;
 DESC:D E S C;
 LOAD:L O A D;
 CREATE:C R E A T E;
 DELETE:D E L E T E;
 EXISTS:E X I S T S;
 HEADERS:H E A D E R S;
 FIELDTERMINATOR:F I E L D T E R M I N A T O R;
 PERIODIC:P E R I O D I C;
 COMMIT: C O M M I T;
 PROFILE:P R O F I L E;
 CYPHER:C Y P H E R ;

 LENGTH : L E N G T H;
 NODES : N O D E S;
 NODE:N O D E;
 RELATIONSHIP:R E L A T I O N S H I P;
 RELATIONSHIPS:R E L A T I O N S H I P S;
 EXTRACT:E X T R A C T;
 FILTER:F I L T E R;
 ABS:A B S;
 RAND:R A N D;
 ROUND:R O U N D;
 SQRT:S Q R T;
 SIGN:S I G N;
 COS:C O S;
 TAN:T A N;
 COT:C O T;
 ASIN:A S I N;
 ACOS:A C O S;
 ATAN:A T A N;
 ATAN2:A T A N '2';
 HAVERSIN:H A V E R S I N;
 SIN:S I N;
 DEGREES:D E G R E E S;
 RADIANS:R A D I A N S;
 PI:P I;
 LOG10:L O G '10';
 LOG:L O G;
 EXP:E X P;
 EFUNC:E;
 COLLECT:C O L L E C T;
 PERCENTILEDISC:P E R C E N T I L E D I S C;
 PERCENTILECONT:P E R C E N T I L E C O N T;
 STDEVP:S T D E V P;
 STDEV:S T D E V;
 TOSTRING:T O S T R I N G;
 REPLACE:R E P L A C E;
 SUBSTRING:S U B S T R I N G;
 LEFT:L E F T;
 RIGHT:R I G H T;
 TRIM:T R I M;
 LTRIM:L T R I M;
 RTRIM:R T R I M;
 UPPER:U P P E R;
 LOWER:L O W E R;
 SPLIT:S P L I T;
 REVERSE:R E V E R S E;
 IDFUNC:I D;
 RANGE: R A N G E;
 TYPE: T Y P E;
 SHORTESTPATH: S H O R T E S T P A T H;
 RELS:R E L S;
 ALLSHORTESTPATHS:A L L S H O R T E S T P A T H S;
 TOLOWER:T O L O W E R ;
 TOINT: T O I N T ;
 LABELS:L A B E L S;
 TIMESTAMP:T I M E S T A M P;
 SIZE:S I Z E;
 COALESCE:C O A L E S C E;
 HEAD: H E A D;
 LAST:L A S T;
 STARTNODE: S T A R T N O D E;
 ENDNODE:E N D N O D E;
 PROPERTIES:P R O P E R T I E S;
 TOFLOAT:T O F L O A T;
 KEYS:K E Y S;
 TAIL:T A I L;
 REDUCE:R E D U C E;
 FLOOR:F L O O R;

 EQUAL_REGUALR:'=~';
 ADDEQUAL: '+=';
 NOT_EQUAL:'<>';
 LT_EQUAL:'<=';
 GT_EQUAL:'>=';
 DOUBLEDOT: '..';
 ARROWAHEAD :'->';
 ARROWBACK:'<-';
 LT:'<';
 GT:'>';
 EQUAL:'=';
 NEGATE:'!';
 DOT:'.';
 MULIT:'*';
 ADD :'+';
 SUBTRACTION:'-';
 DIVISION:'/';
 STRING: STRING_VAL1 | STRING_VAL2;
 INTEGER   :   [0-9]+ ;
 DECIMAL   :   [0-9]* '.' [0-9]+ ;
 DOUBLE   :   [0-9]+ '.' [0-9]+ EXPONENT | '.' ([0-9])+ EXPONENT | ([0-9])+ EXPONENT ;
 NIL   :   '(' ')' ;
 WS   :   ('\u0020' | '\u0009' | '\u000D' | '\u000A') {skip();} ;
 ANON   :   '[' ']' ;
 ID: (PN_CHARS_U ( PN_CHARS_U | [0-9])*) | ('`' (ESC | ~[`\\])* '`');

 fragment STRING_VAL1   :   '\'' (ESC | ~['\\])* '\'' ;
 fragment STRING_VAL2   :   '\"' (ESC | ~["\\])* '\"' ;
 fragment BOOL_VAL_TRUE:'true';
 fragment BOOL_VAL_FALSE:'false';
 fragment ESC :   '\\' (['\\/bfnrt]);
 fragment EXPONENT   :   'e' [+-]? [0-9]+ ;
 fragment ECHAR   :   '\\' [tbnrf\\"'] ;
 fragment PN_CHARS_BASE   :   (A|B|C|D|E|F|G|H|I|J|K|L|M|N|O|P|Q|R|S|T|U|V|W|X|Y|Z) | [\u00C0-\u00D6] | [\u00D8-\u00F6] | [\u00F8-\u02FF] | [\u0370-\u037D] | [\u037F-\u1FFF] | [\u200C-\u200D] | [\u2070-\u218F] | [\u2C00-\u2FEF] | [\u3001-\uD7FF] | [\uF900-\uFDCF] | [\uFDF0-\uFFFD];// | [\u10000-\uEFFFF] ;
 fragment PN_CHARS_U   :   PN_CHARS_BASE | '_' ;
 fragment PN_CHARS   :   PN_CHARS_U | '-' | [0-9] | '\u00B7' | [\u0300-\u036F] | [\u203F-\u2040] ;

 fragment A:[aA];
 fragment B:[bB];
 fragment C:[cC];
 fragment D:[dD];
 fragment E:[eE];
 fragment F:[fF];
 fragment G:[gG];
 fragment H:[hH];
 fragment I:[iI];
 fragment J:[jJ];
 fragment K:[kK];
 fragment L:[lL];
 fragment M:[mM];
 fragment N:[nN];
 fragment O:[oO];
 fragment P:[pP];
 fragment Q:[qQ];
 fragment R:[rR];
 fragment S:[sS];
 fragment T:[tT];
 fragment U:[uU];
 fragment V:[vV];
 fragment W:[wW];
 fragment X:[xX];
 fragment Y:[yY];
 fragment Z:[zZ];