Antlr标识符与和不匹配

使用Antlr 3.5规则：

ID
 : ':'? ('a'..'z' | 'A'..'Z' | '_') ('a'..'z' | 'A'..'Z' | '0'..'9' | '_')*
 ;

不匹配：标准

有人能解释一下原因吗

下面是完整的语法。您可以使用规则colname对照“标准”进行测试

语法Sql；
选择权{
语言=Java；
输出=AST；
}
@rulecatch{catch（识别异常e）{throw e；}}
@标题{
包com.something.antlr.sql；
导入java.util.ArrayList；
}
@lexer:：header{
包com.something.antlr.sql；
}
@成员{
私有列表表=新的ArrayList（）；
private List columns=new ArrayList（）；
私有StringBuilder JoinClaires=新StringBuilder（）；
带子句字符串的私有字符串；
私有字符串表串；
私有字符串columnsAsString；
私有字符串聚合；
私有字符串，其中为字符串；
私有字符串orderByAsString；
私有字符串groupByAsString；
私有字符串limitAsString；
公共列表getTables（）{
返回表；
}
公共字符串getColumnsAsString（）{
返回列字符串；
}
公共列表getColumns（）{
返回列；
}
公共字符串getTablesString（）{
返回表串；
}
公共字符串getJoinClauseAssString（）{
return join子句.toString（）；
}
公共字符串getWhereClauseAssString（）{
返回一个字符串；
}
公共字符串getOrderByAsString（）{
返回orderByAsString；
}
公共字符串getAggregate（）{
总回报；
}
公共字符串getGroupByAsString（）{
返回groupByAsString；
}
公共字符串getWithClauseAssString（）{
返回带子句的字符串；
}
公共字符串getLimitAsString（）{
返回限制字符串；
}
}
sql\u语句
：sqleof；
catch[RecognitionException e]{throw e；}
sql
:
（附条款）？
{withClauseAsString=$with_子句.text；}
选择不同的？（顶级LPAREN？t=数字或参数？）？柱？
{
StringBuilder sb=新的StringBuilder（）；
如果（$DISTINCT.text！=null）{
某人附加（“不同”）；
}
如果（$TOP.text！=null）{
某人加上（“顶”）；
}
如果（$t.text！=null）{
某人加上（“”）；
如果（$LPAREN.text！=null）{
某人加上（“”）；
}
某人追加（$t.text）；
如果（$RPAREN.text！=null）{
某人加上（“）”；
}
某人加上（“”）；
}
sb.append（$columns.text）；
columnsAsString=sb.toString（）；
}
(
从桌子上*
{tableasstring=$tables.text；}
（连接类型？连接子句）*
{
字符串joinClauseAssString=“”；
if（$join_type.text！=null）{
joinClauseAsString=$join_type.text+“”；
}
if（$join_clause.text！=null）{
JoinClauseAssString+=$join_子句.text；
}
if（joinClauseAsString.length（）>0）{
联合条款。附加（“\n”）；
joinClauses.append（JoinClauseAssString）；
}
}
（何处条款）？
{whereClauseAsString=$where_子句.text；}
（按订单条款）？
{orderByAsString=$order_by_子句.text；}
（分组条款）？
{groupByAsString=$groupbyu子句.text；}
（限制t2=数量或参数）？
{
如果（$t2.text！=null）{
limitAsString=“limit”+$t2.text；
}
}
（联合所有？alt_sql）？
)?
;
不假思索
:
身份证件
;
with_子句
:
是否具有_ident（LPAREN列或RPAREN列）？作为alt_sql
;
alt_sql
:
阿尔帕伦？
(
选择不同的？（顶部编号或参数）列？
从桌子上*
（连接类型？连接子句）*
（何处条款）？
（按订单条款）？
（分组条款）？
（限制数量）？
（联合所有？alt_sql）？
)
帕伦？
;
存在\u选择
:
从表格中选择数字（WHERE_子句）？
;
in_选择
:
从表中选择colname（WHERE\u子句）？
;
colname\u或\u操作数
:
colname | LPAREN ID RPAREN | RANGE | CONSTANT | TICK'*'TICK | alt|u sql
;
案例检验
:
（ID“）？函数（计算函数）*运算符（ID |编号）
;
科尔曼
:
//CASE WHEN CASE|u test（（AND | OR）CASE|u test）*然后（NUMBER | ID）ELSE（NUMBER | ID）结束别名
CASE（where|u logical THEN（ID | NUMBER | LITERAL））+ELSE（ID | NUMBER | LITERAL）结束别名
|
col=ID别名？
{
c列=新列（$col.text，“”）；
增加（c）栏；
}
|
tbl=ID'.'列=ID（':'ID）？别名
{
列c=新列（$tbl.text++“++$col.text，$alias.text）；
增加（c）栏；
}
|
（ID“）？“*”
|
（ID“）？func_name=函数别名？
{
列c=新列（$func_name.text，$alias.text）；
增加（c）栏；
}
|
列=（ID'：'ID）
{
c列=新列（$col.text，“”）；
增加（c）栏；
}
|
（“？”| NUMBER | LITERAL）（（“：：”| AS）ID）？
{
列c=新列（“？”，“”）；
增加（c）栏；
}
;
柱
:
（colname（CONCAT colname）*|alt_sql别名？）（'，'（colname（CONCAT colname）*|alt_sql别名？）*
;
数据表名
:
身份证别名？
{
Table tbl=新表（$ID.text，$alias.text）；
表.添加（待定）；
}
|
（ID“）？函数别名？
|
t=表LPAREN func=ID LPAREN参数RPAREN RPAREN别名？
{
Table tbl=新表（$t.text+”（“+$func.text+”（“+$arguments.text+”），$alias.text）；
表.添加（待定）；
}
;
论据
:
参数（“，”参数）*
;
论点
:
科尔曼
;
桌子
：tablename（'，'tablename）*；
加入sql
:
LPAREN
选择不同的？柱
从桌子上*
（其中WHERE_条款）RPAREN别名
关于where_表达式
;
连接类型
:
（“左”“外”？|“左”“外”？|“左”“外”？）|（“右”“外”？|“右”“外”？|“右”“外”？）
;
联合条款
：（alt_sql alias | tablename alias？| colname）在where_子句上
;
别名
:
作为？身份证件
;
存在(u)条款
:
存在LPAREN存在\u选择RPAREN
;
in_条款
:
LPAREN（LPAREN在|选择RPAREN别名？|在|值中）（“，”（LPAREN在|选择RPAREN别名？|在|值中））*RPAREN
;
in_值
:
（数字|文字）
grammar Sql;

options {
  language = Java;
  output = AST;
}

@rulecatch {catch (RecognitionException e) { throw e;}}

@header {
  package com.something.antlr.sql;
  import java.util.ArrayList;
}

@lexer::header {
  package com.something.antlr.sql;
}

@members {
 private List<Table> tables = new ArrayList<Table>();
 private List<Column> columns = new ArrayList<Column>();

 private StringBuilder joinClauses = new StringBuilder();

 private String withClauseAsString;
 private String tablesAsString;
 private String columnsAsString;
 private String aggregate;
 private String whereClauseAsString;
 private String orderByAsString;
 private String groupByAsString;
 private String limitAsString;

 public List<Table> getTables() {
  return tables;
 }

 public String getColumnsAsString() {
    return columnsAsString;
 }

 public List<Column> getColumns() {
    return columns;
 }

 public String getTablesAsString() {
    return tablesAsString;
 }

 public String getJoinClauseAsString() {
    return joinClauses.toString();
 }

 public String getWhereClauseAsString() {
    return whereClauseAsString;
 }

 public String getOrderByAsString() {
    return orderByAsString;
 }

 public String getAggregate() {
    return aggregate;
 }

 public String getGroupByAsString() {
    return groupByAsString;
 }

 public String getWithClauseAsString() {
    return withClauseAsString;
 }

 public String getLimitAsString() {
    return limitAsString;
 }


}


sql_statement
  : sql EOF;
   catch [RecognitionException e]{ throw e;}

sql
:
  (WITH with_clause)?
    {withClauseAsString = $with_clause.text;}
  SELECT DISTINCT? (TOP LPAREN? t=number_or_param RPAREN?)? columns?
      {
        StringBuilder sb = new StringBuilder();

        if ($DISTINCT.text != null) {
          sb.append(" distinct ");
        }

        if ($TOP.text != null) {
          sb.append(" top ");
        }

        if ($t.text != null) {
          sb.append(" ");
          if ($LPAREN.text != null) {
            sb.append("(");
          }
          sb.append($t.text);
          if ($RPAREN.text != null) {
            sb.append(")");
          }
          sb.append(" ");
        }

        sb.append($columns.text);
        columnsAsString = sb.toString();
      }
      (
      FROM tables*
           {tablesAsString = $tables.text;}

    (join_type? JOIN join_clause)*
     {
       String joinClauseAsString = "";

       if ($join_type.text != null) {
         joinClauseAsString = $join_type.text + " ";
       }

       if ($join_clause.text != null) {
        joinClauseAsString += $join_clause.text;
       }

       if (joinClauseAsString.length() > 0) {
          joinClauses.append("\n ");
          joinClauses.append(joinClauseAsString);
       }

     }

    (WHERE where_clause)?
          {whereClauseAsString = $where_clause.text;}

    (ORDER_BY order_by_clause)?
          {orderByAsString = $order_by_clause.text;}

    (GROUP_BY group_by_clause)?
          {groupByAsString = $group_by_clause.text;}
    (LIMIT t2=number_or_param)?
          {
            if ($t2.text != null) {
              limitAsString = " limit " + $t2.text;
            }
          }

    (UNION ALL? alt_sql)?
    )?
  ;


with_ident
:
  ID
;

with_clause
:
  with_ident (LPAREN columns RPAREN)? AS alt_sql
;


alt_sql
:
  LPAREN?
  (
  SELECT DISTINCT? (TOP number_or_param)? columns?
    FROM tables*
    (join_type? JOIN join_clause)*
    (WHERE where_clause)?
    (ORDER_BY order_by_clause)?
    (GROUP_BY group_by_clause)?
    (LIMIT NUMBER)?
    (UNION ALL? alt_sql)?
  )
  RPAREN?
;

exists_select
:
  SELECT NUMBER FROM tables (WHERE where_clause)?
;

in_select
:
  SELECT colname FROM tables (WHERE where_clause)?
;

colname_or_operand
:
 colname | LPAREN ID RPAREN | RANGE | CONSTANT |  TICK '*' TICK | alt_sql
;

case_test
:
  (ID '.')? function (CALC function)* operator (ID | NUMBER)
;

colname
:
  //CASE WHEN case_test ( (AND | OR) case_test)* THEN (NUMBER | ID) ELSE (NUMBER | ID) END alias
  CASE (WHEN where_logical THEN (ID | NUMBER | LITERAL))+ ELSE (ID | NUMBER | LITERAL) END alias
  |
  col = ID alias?
    {
    Column c = new Column($col.text, "");
    columns.add(c);
    }
  |
  tbl=ID '.' col=ID ('::' ID)? alias?
    {
    Column c = new Column($tbl.text + "." + $col.text, $alias.text);
    columns.add(c);
    }
  |
  (ID '.')? '*'
  |
  (ID '.')? func_name = function alias?
    {
    Column c = new Column($func_name.text, $alias.text);
    columns.add(c);
    }
  |
  col = (ID '::' ID)
    {
    Column c = new Column($col.text, "");
    columns.add(c);
    }
  |
  ('?' | NUMBER | LITERAL) (('::' | AS) ID)?
    {
    Column c = new Column("?", "");
    columns.add(c);
  }
;

columns
:
  (colname (CONCAT colname)* | alt_sql alias?) (',' (colname (CONCAT colname)* | alt_sql alias?))*
;

tablename
:
  ID alias?
    {
    Table tbl = new Table($ID.text, $alias.text);
    tables.add(tbl);
    }
  |
  (ID '.')? function alias?
  |
  t = TABLE LPAREN func = ID LPAREN arguments RPAREN RPAREN alias?
    {
    Table tbl = new Table($t.text + "(" + $func.text + "(" + $arguments.text + ")" + ")", $alias.text);
    tables.add(tbl);
    }
;

arguments
:
  argument (',' argument)*
;

argument
:
  colname
;

tables
  : tablename (',' tablename)*;


join_sql
:
  LPAREN
  SELECT DISTINCT? columns
  FROM tables*
  (WHERE where_clause) RPAREN alias
  ON where_expression
;


join_type
:
  ('left' 'outer'? | 'LEFT' 'OUTER'? | 'Left' 'Outer'?) | ('right' 'outer'? | 'RIGHT' 'OUTER'?  | 'Right' 'Outer'?)
;

join_clause
  :  (alt_sql alias | tablename alias? | colname) ON where_clause
  ;

alias
:
  AS? ID
;


exists_clause
:
  EXISTS LPAREN exists_select RPAREN
;

in_clause
:
  LPAREN (LPAREN in_select RPAREN alias? | in_values) (',' (LPAREN in_select RPAREN alias? | in_values))* RPAREN
;

in_values
:
  (NUMBER | LITERAL) (',' (NUMBER | LITERAL))*
;

where_expression
:
  LPAREN* ((colname operator (colname_or_operand | in_clause)) | exists_clause?) RPAREN*
;

where_logical
:
  LPAREN* where_expression ((AND | OR) where_expression)* RPAREN*
;

where_clause
:
  where_logical ((AND | OR) where_logical)*
;

number_or_param
:
  NUMBER | '?'
;

order_by
:
  (ID | NUMBER) (ASC | DESC)?
;

order_by_clause
  : order_by (',' order_by)*;

group_by_clause
:
  ID ('.' ID)? (',' ID ('.' ID)?)*
;

BETWEEN
:
 'between' | 'BETWEEN' | 'Between'
;


operator
  : '=' | '<' | '>' | '<=' | '>=' | '<>' | 'is' | 'Is' | 'IS' | BETWEEN |  IN |  'like' | '&lt;=' | '&gt;=' | '&lt;&gt;';

CALC
:
  '+' | '-' | '/'
;

function
:
  ID LPAREN DISTINCT? arguments? RPAREN ('::' ID)?
;

CONSTANT
:
  TICK ID TICK
;

LITERAL
:
  TICK .* TICK
;

TABLE : ('t' | 'T') ('a' | 'A') ('b' | 'B') ('l' | 'L') ('e' | 'E');
WITH : 'with' | 'WITH' | 'With';
SELECT : 'select' | 'SELECT' | 'Select';
DISTINCT : ('d' | 'D') ('i' | 'I') ('s' | 'S') ('t' | 'T') ('i' | 'I') ('n' | 'N') ('c' | 'C') ('t' | 'T');
TOP : 'top' | 'TOP' | 'Top';
CASE : ('case' | 'Case' | 'CASE');
WHEN: ('when' | 'When' | 'WHEN');
THEN : 'then' | 'Then' | 'THEN';
ELSE : 'else' | 'Else' | 'ELSE';
END : 'end' | 'END' | 'End';
FROM : 'from' | 'FROM' | 'From';
EXISTS : 'exists' | 'EXISTS' | 'Exists';
WHERE : 'where' | 'WHERE'| 'Where';
JOIN : ('left' | 'LEFT' | 'Left' | 'right' | 'RIGHT' | 'Right')? 'join' | 'Join' | 'JOIN';
ON : 'on' | 'ON' | 'On';
AND : ('a' | 'A') ('n' | 'N') ('d' | 'D');
AS : ('a' | 'A') ('s' | 'S');
OR : ('o' | 'O') ('r' | 'R');
IN : 'in' | 'IN' | 'In';
ORDER_BY : ('o' | 'O') ('r' | 'R') ('d' | 'D') ('e' | 'E') ('r' | 'R') ' ' ('b' | 'B') ('y' | 'Y');
ASC : ('a' | 'A') ('s' | 'S') ('c' | 'C');
DESC : ('d' | 'D') ('e' | 'E') ('s' | 'S') ('c' | 'C');
GROUP_BY : 'group by';
UNION : ('u' | 'U') ('n' | 'N') ('i' | 'I') ('o' | 'O') ('n' | 'N');
ALL :  ('a' | 'A') ('l' | 'L') ('l' | 'L');
LIMIT : 'limit' | 'LIMIT' | 'Limit';
CONCAT : '||';
TICK: '\u0027';

LPAREN
: '('
;

RPAREN
: ')'
;

RANGE
:
  (ID | '?') AND (ID | '?')
;

NUMBER
  : ('0'..'9')+;

ID
 : ':'?('a'..'z' | 'A'..'Z' | '_')('a'..'z' | 'A'..'Z' | '0'..'9' | '_')*;

WHITESPACE
 : (' ' | '\t' | '\n' | '\r' | '\f')+  {$channel = HIDDEN;};

RANGE
 : (ID | '?') AND (ID | '?')
 ;

range
 : (ID | '?') AND (ID | '?')
 ;