mysqlparser.jj

mysql集群

	boolean not = false;
	Expression expression = null;
	List<Expression> list = null;
	
}
{
    ["NOT"{not = true;}] "IN" "(" (LOOKAHEAD(2) list=SQLExpressionList() | expression = FullSelectStatement()) ")" {
    	
    	if(list == null){
    		return expression;	
    	}
    	if(list.size()==1){
    		
    		Expression item = list.get(0);
    		ComparisonExpression comparativeExpression = new ComparisonExpression();
    		comparativeExpression.setExpression(item);
    		comparativeExpression.setComparison(not?Comparative.NotEquivalent:Comparative.Equivalent);
	    		
    		if(inputExpression instanceof ColumnExpression){
				((ColumnExpression)inputExpression).setExpression(comparativeExpression);
				return 	inputExpression;
    		}else{
    			return comparativeExpression;
    		}
    		
    	}else{
    		BaseExpressionList baseList = null;
    		if(not){
    			baseList = new AndExpression(null);
    		}else{
    			baseList = new OrExpression(null);
    		}
    		
	    	for(Expression item:list){
	    		
	    		ComparisonExpression comparativeExpression = new ComparisonExpression();
    			comparativeExpression.setExpression(item);
    			comparativeExpression.setComparison(not?Comparative.NotEquivalent:Comparative.Equivalent);
	    		if(inputExpression instanceof ColumnExpression){
	    			ColumnExpression columnExpression = new ColumnExpression();
	    			columnExpression.setExpression(comparativeExpression);
	    			columnExpression.setColumn(((ColumnExpression)inputExpression).getColumn());
		    		baseList.addExpression(columnExpression);
	    		}else{
	    			baseList.addExpression(comparativeExpression);
	    		}
	    	}
	    	return baseList;
    	}
    }
}

Expression SQLBetweenClause(Expression inputExpression)      :
{
	boolean not = false;
	Expression minExpression = null;
	Expression maxExpression = null;
	
}
{
    ["NOT"{not = true;}] "BETWEEN" minExpression = SQLSimpleExpression() "AND" maxExpression = SQLSimpleExpression(){
    	ComparisonExpression comparativeMinExpression = new ComparisonExpression();
    	comparativeMinExpression.setExpression(minExpression);
    	comparativeMinExpression.setComparison(Comparative.GreaterThanOrEqual);
    	
    	ComparisonExpression comparativeMaxExpression = new ComparisonExpression();
    	comparativeMaxExpression.setExpression(maxExpression);
    	comparativeMaxExpression.setComparison(Comparative.LessThanOrEqual);
    	AndExpression andExpression = new AndExpression();
    	if(inputExpression instanceof ColumnExpression){
    		ColumnExpression columnMinExpression = new ColumnExpression();
			columnMinExpression.setExpression(comparativeMinExpression);
			columnMinExpression.setColumn(((ColumnExpression)inputExpression).getColumn());
			
			ColumnExpression columnMaxExpression = new ColumnExpression();
			columnMaxExpression.setExpression(comparativeMaxExpression);
			columnMaxExpression.setColumn(((ColumnExpression)inputExpression).getColumn());
			
			andExpression.addExpression(columnMinExpression);
			andExpression.addExpression(columnMaxExpression);
    	}else{
    		andExpression.addExpression(comparativeMinExpression);
    		andExpression.addExpression(comparativeMaxExpression);
    	}
    	
		return reverseExpression(not,andExpression);
    }
}

Expression SQLLikeClause()      :
{
	Expression expression = null;
	boolean not = false;
}
{
	["NOT"{not = true;}] "LIKE" expression = SQLSimpleExpression(){
		ComparisonExpression comparisonExpression = new ComparisonExpression();
		comparisonExpression.setExpression(expression);
		comparisonExpression.setComparison(not?Comparative.NotLike:Comparative.Like);
		return comparisonExpression;	
	}
}

Expression SQLSimpleExpression()      :
{
	Expression expression = null;
	Token token = null;
}
{
    (expression= SQLAddSubtractExpression()){
    	
    	return expression;	
    } 
}

Expression SQLAddSubtractExpression()      :
{
	Expression expression = null;
	Expression otherExpression = null;
	Token token = null;
	Function function;
	FunctionExpression superExpression = null;
}
{
       (expression = SQLMultiplicativeExpression() ((token = "+" | token = "-" | token = "||") otherExpression = SQLMultiplicativeExpression(){
		    function = getFunction(token.image.toUpperCase());
		    if(function == null) return null;
		    FunctionExpression functionExpression = new FunctionExpression();
		    functionExpression.setFunction(function);
       		if(superExpression == null){
       			functionExpression.addArgExpression(expression);
		    	functionExpression.addArgExpression(otherExpression);
       		}else{
       			functionExpression.addArgExpression(superExpression);
       			functionExpression.addArgExpression(otherExpression);
       		}
       		superExpression = functionExpression;
       })*){
       		if(superExpression == null){
       			return expression;
       		}else{
       			return superExpression;
       		}
       }
}



Expression SQLMultiplicativeExpression()      :
{
	FunctionExpression functionExpression;
	Expression expression;
	Expression otherExpression;
	Token token;
}
{
  expression = SQLUnaryExpression() ( (token = "*" | token = "/"  | token= "%" | token = "MOD" | token = "DIV" ) otherExpression = SQLUnaryExpression(){
  	Function function = getFunction(token.image.toUpperCase());
  	if(function != null && expression != null && otherExpression != null){
	  	functionExpression = new FunctionExpression();
	    functionExpression.setFunction(function);
	    functionExpression.addArgExpression(expression);
	    functionExpression.addArgExpression(otherExpression);
	    expression = functionExpression;
  	}
  	
  })*{
  	return expression;
  }
}


/**
void SQLExpotentExpression() #void:
{}
{
    SQLUnaryExpression() //( "**" SQLUnaryExpression())*
}
**/

Expression SQLUnaryExpression()      :
{
	Expression expression;
	boolean isSub = false;
}
{
    ["+" | "-"{isSub=true;}] expression = SQLPrimaryExpression(){
    	if(isSub){
    		Function function = getFunction("-");
    		if(function != null){
	    		FunctionExpression funExp = new FunctionExpression();
	    		ConstantExpression consExp = new ConstantExpression(0);
	    		funExp.addArgExpression(consExp);
	    		funExp.addArgExpression(expression);
	    		funExp.setFunction(function);
	    		return funExp;
    		}else{
    			return null;	
    		}
    	}
    	return expression;
    }
}


Expression SQLPrimaryExpression()      :
{
	Token t = null;
	Column column = null;
	Expression expression = null;
	Comparable value = null;
}
{(
t=<K_NULL>{
	return new ConstantExpression(null);
}
|t=<K_TRUE> {
		return new ConstantExpression(Boolean.TRUE);
	}
|	t=<K_FALSE> {
		return new ConstantExpression(Boolean.FALSE);
	}
|   t=<INTEGER_LITERAL>{
	
		try {
			value = Long.valueOf(t.image);
		} 
		catch (Exception e) {
		}
	return new ConstantExpression(value);
}
|   t=<FLOATING_POINT_LITERAL> {
	try {
		value = new BigDecimal(t.image);
	} 
	catch (Exception e) {
	}
	return new ConstantExpression(value);
}

|  t= <STRING_LITERAL>{
	// strip away double quotes at end of string
		String temp = (t.image).substring(1,t.image.length()-1);
		// replace escape characters
		temp = replaceEscape(temp);
		return new ConstantExpression(temp);
}
|  t= <S_PARAMETER_MARKER>{
	int index = parameterIndex++;
	return new ParameterExpression(index);
}
| ("INTERVAL" expression=SQLExpression() (token = "YEAR" | token = "MONTH" | token = "DAY" | token = "HOUR" | token = "MINUTE" | token = "SECOND" | token = "MICROSECOND")){
		if(token != null){
    		int field = -1;
    		if(token.image.equalsIgnoreCase("YEAR")){
    			field = Calendar.YEAR;
    		}else if(token.image.equalsIgnoreCase("MONTH")){
    			field = Calendar.MONTH;
    		}else if(token.image.equalsIgnoreCase("DAY")){
    			field = Calendar.DATE;
    		}else if(token.image.equalsIgnoreCase("WEEK")){
    			field = Calendar.DATE;
    			FunctionExpression funExp = new FunctionExpression();
    			funExp.setFunction(this.getFunction("*"));
    			funExp.addArgExpression(expression);
    			funExp.addArgExpression(new ConstantExpression(7));
    			expression = funExp;
    		}else if(token.image.equalsIgnoreCase("HOUR")){
    			field = Calendar.HOUR;
    		}else if(token.image.equalsIgnoreCase("MINUTE")){
    			field = Calendar.MINUTE;
    		}else if(token.image.equalsIgnoreCase("SECOND")){
    			field = Calendar.SECOND;
    		}else if(token.image.equalsIgnoreCase("MICROSECOND")){
    			field = Calendar.MILLISECOND;
    			FunctionExpression funExp = new FunctionExpression();
    			funExp.setFunction(this.getFunction("/"));
    			funExp.addArgExpression(expression);
    			funExp.addArgExpression(new ConstantExpression(1000));
    			expression = funExp;
    		}
    		FunctionExpression funExp = new FunctionExpression();
    		funExp.setFunction(timeConverter);
    		funExp.addArgExpression(expression);
    		return funExp;
    	}
}
|   CastFunctionCall()
|   CaseStatement()
|   LOOKAHEAD({ getFunction(getToken(1).image.toUpperCase())!= null }) expression = OverloadedFunctionCall()
|   ("(" expression=SQLExpression() ")")
|   LOOKAHEAD(EntityName() [ "." EntityName() ["." EntityName()]] "(" ) FunctionCall()
|  column = ColumnName(){
	ColumnExpression columnExpression = new ColumnExpression();
	columnExpression.setColumn(column);
	return 	columnExpression;
}){
	return expression;
}
}
void FunctionCall()       :
{}
{
    // caters the following
    // function(args)
    // package.function(args)
    // user.package.function(args)

    // however note that "distinct/all/*" can be only used with
    // inbuilt functions but no distinction is made between inbuilt
    // function and custom functions

    EntityName() [ "." EntityName() ["." EntityName()]]
    "(" ["DISTINCT" | "ALL"] (SQLExpressionList() | "*") ")"
}


void CastFunctionCall()      :
{}
{
	//Cast funciton in DB2 is very different from all other functions
	"CAST" "(" SQLSimpleExpression() "AS" DataTypes() ")"
}

String FunctionName() :
{
  Token t = null;
}
{
	(t=<K_INSERT>
	| t=<K_MOD>
	| t=<K_MICROSECOND>
	| t=<K_YEAR>
	| t=<K_DAY>
	| t=<K_MINUTE>
	| t=<K_MONTH>
	| t=<K_HOUR>
	| t=<K_SECOND>
	|t=<IDENTIFIER>
	)
	{
		if(t != null){
			return t.image.toUpperCase();
		}else{
			return null;	
		}
	}
}

//This covers all over loaded functions that are using keyword and can not be captured by
//generic function defination
Expression OverloadedFunctionCall()      :
{
	Expression expression = null;
	Function function = null;
	Token functionNameToken = null;
	String functionName = null;
	FunctionExpression funExpression = null;
	boolean nullExp = false;
	
}
{
	functionName = FunctionName(){
		funExpression = new FunctionExpression();
		function = getFunction(functionName);
		funExpression.setFunction(function);
	}
	(["(" [ expression = SQLSimpleExpression(){
			if(funExpression != null){
				if(expression == null){
					nullExp = true;
				}
				funExpression.addArgExpression(expression);
			}
		 }] ("," expression = SQLSimpleExpression(){
			if(funExpression != null){
				if(expression == null){
					nullExp = true;
				}
				funExpression.addArgExpression(expression);
			} 	
		})* ")"]){
			if(nullExp){
				return null;	
			}else{
				return funExpression;
			}
		}	
	
	/**
        ("DATE"{functionName="DATE";} "(" SQLSimpleExpression() ")"
        | "TIME"{functionName="TIME";} "(" SQLSimpleExpression() ")"
        | "TIMESTAMP"{functionName="TIMESTAMP";} "(" SQLSimpleExpression() ["," SQLSimpleExpression() ] ")"
        | "FLOAT"{functionName="FLOAT";} "(" SQLSimpleExpression() ")"
        | "DOUBLE"{functionName="DOUBLE";} "(" SQLSimpleExpression() ")"
        | "INTEGER"{functionName="INTEGER";} "(" SQLSimpleExpression() ")"
        | "INT"{functionName="INT";} "(" SQLSimpleExpression() ")"
        | "DECIMAL"{functionName="DECIMAL";} "(" SQLSimpleExpression() ["," <FLOATING_POINT_LITERAL> ["," <FLOATING_POINT_LITERAL> ["," <FLOATING_POINT_LITERAL>]]] ")"
        | "DEC"{functionName="DEC";} "(" SQLSimpleExpression() ["," <FLOATING_POINT_LITERAL> ["," <FLOATING_POINT_LITERAL> ["," <FLOATING_POINT_LITERAL>]]]  ")"
        | "LEFT"{functionName="LEFT";} "(" SQLSimpleExpression() "," <FLOATING_POINT_LITERAL> ")"
        | "NOW"{functionName="NOW";} "(" [SQLSimpleExpression()] ")"
        | "SYSDATE"{functionName="NOW";} "(" [SQLSimpleExpression()] ")"
        | "RIGHT"{functionName="RIGHT";} "(" SQLSimpleExpression() "," <FLOATING_POINT_LITERAL> ")"
        | "VARCHAR"{functionName="VARCHAR";} "(" SQLSimpleExpression() ["," <FLOATING_POINT_LITERAL>] ")"
        | "CHAR"{functionName="CHAR";} "(" SQLSimpleExpression() ["," <FLOATING_POINT_LITERAL>] ")"
        | "DAY"{functionName="DAY";} "(" SQLSimpleExpression() ")"
        | "DAYS"{functionName="DAYS";} "(" SQLSimpleExpression() ")"
        | "HOUR"{functionName="HOUR";} "(" SQLSimpleExpression() ")"
        | "MICROSECOND"{functionName="MICROSECOND";} "(" SQLSimpleExpression() ")"
        | "MINUTE"{functionName="MINUTE";} "(" SQLSimpleExpression() ")"
        | "MONTH"{functionName="MONTH";} "(" SQLSimpleExpression() ")"
        | "SECOND"{functionName="SECOND";} "(" SQLSimpleExpression() ")"
        | "YEAR"{functionName="YEAR";} "(" SQLSimpleExpression() ")"
        | "CURRENT_TIMESTAMP"{functionName="NOW";}
		| "CURRENT_TIME"{functionName="CURRENT_TIME";}
		| "CURRENT_DATE"{functionName="CURRENT_DATE";}
        | "TO_DATE"{functionName="TO_DATE";} "("expression = SQLSimpleExpression() ")"){
        	function = getFunction(functionName);
        	if(function == null){return null;}
        	FunctionExpression funExpression = new FunctionExpression();
        	funExpression.setFunction(function);
        	if(expression != null){
        		funExpression.addArgExpression(expression);
        	}
        	return funExpression;
        }
        **/
}

void DataTypes()      :
{}
{
    (       "CHAR"
        |   "VARCHAR"
        |   "VARCHAR2"
        |   "DECIMAL"
        |   "INTEGER"
        |   "INT"
        |   "NUMBER"
        |   "NUMERIC"
        |   "REAL"
        |   "FLOAT"
    ) [ "(" <FLOATING_POINT_LITERAL> [ "," <FLOATING_POINT_LITERAL> ] ")" ]

    |   "DATE"
    |   "TIME"
    |   "TIMESTAMP"
    |   "BOOLEAN"
}

void ForUpdateClause() :
{}
{
    "FOR" "UPDATE" ["OF" ColumnName() ("," ColumnName())*] [<K_NOWAIT>]
}

void ReadOnlyClause() :
{}
{
	"FOR" ("FETCH" | "READ") "ONLY"
}

void OptimizeForClause() :
{}
{
	"OPTIMIZE" "FOR" <FLOATING_POINT_LITERAL> (<IDENTIFIER>|<S_COMMA_IDENTIFIER>)

}

void WithClause() :
{}
{
	"WITH" (<IDENTIFIER>|<S_COMMA_IDENTIFIER>) [<IDENTIFIER> <IDENTIFIER> <IDENTIFIER>]
}

void QuerynoClause() :
{}
{
	"QUERYNO" <FLOATING_POINT_LITERAL>
}

void FetchFirstClause() :
{}
{
	"FETCH" <IDENTIFIER> [<FLOATING_POINT_LITERAL>] <IDENTIFIER> "ONLY"
}