📄 sqlparser.java
字号:
private Expressions expressionParenthesisList(Command cmd) throws SQLException{
Expressions list = new Expressions();
{
SQLToken token = nextToken();
if(token != null && token.value == SQLTokenizer.PARENTHESIS_R){
// empty list like functions without parameters
return list;
}
previousToken();
}
while(true){
list.add( expression(cmd, 0) );
SQLToken token = nextToken(MISSING_COMMA_PARENTHESIS);
switch(token.value){
case SQLTokenizer.PARENTHESIS_R:
return list;
case SQLTokenizer.COMMA:
continue;
default:
throw new Error();
}
}
}
/**
* Read a list of expressions. The list is limit from specific SQL keywords like SELECT, GROUP BY, ORDER BY
*/
private Expressions expressionTokenList(Command cmd, int listType) throws SQLException{
Expressions list = new Expressions();
while(true){
Expression expr = expression(cmd, 0);
list.add( expr );
SQLToken token = nextToken();
if(listType == SQLTokenizer.ORDER && token != null){
switch(token.value){
case SQLTokenizer.DESC:
expr.setAlias(SQLTokenizer.DESC_STR);
//no break;
case SQLTokenizer.ASC:
token = nextToken();
}
}
if(token == null) {
previousToken();
return list;
}
switch(token.value){
case SQLTokenizer.COMMA:
continue;
default:
if(isKeyword(token) ){
previousToken();
return list;
}
throw createSyntaxError( token, MISSING_TOKEN_LIST);
}
}
}
private void expressionDefList(Command cmd, Expressions expressions, Strings columns) throws SQLException{
SQLToken token = nextToken();
if(token.value != SQLTokenizer.PARENTHESIS_L) throw createSyntaxError(token, MISSING_PARENTHESIS_L );
Loop:
while(true){
int offset = token.offset + token.length;
token = nextToken();
if(token != null) offset = token.offset;
previousToken();
expressions.add( expression(cmd, 0) );
SQLToken last = lastToken();
int length = last.offset + last.length - offset;
columns.add( new String( sql, offset, length ) );
token = nextToken(MISSING_COMMA_PARENTHESIS);
switch(token.value){
case SQLTokenizer.PARENTHESIS_R:
break Loop;
case SQLTokenizer.COMMA:
continue;
default:
throw new Error();
}
}
}
/**
* Read a complex expression that can be build from multiple atomic expressions.
* @param cmd is needed to add parameters "?" with addParameter()
* @param previousOperationLevel the level of the left operation.
*/
private Expression expression(Command cmd, int previousOperationLevel) throws SQLException{
SQLToken token = nextToken(MISSING_EXPRESSION);
Expression leftExpr;
switch(token.value){
case SQLTokenizer.NOT:
leftExpr = new ExpressionArithmetic( expression( cmd, ExpressionArithmetic.NOT / 10), ExpressionArithmetic.NOT);
break;
case SQLTokenizer.MINUS:
leftExpr = new ExpressionArithmetic( expression( cmd, ExpressionArithmetic.NEGATIVE / 10), ExpressionArithmetic.NEGATIVE);
break;
case SQLTokenizer.TILDE:
leftExpr = new ExpressionArithmetic( expression( cmd, ExpressionArithmetic.BIT_NOT / 10), ExpressionArithmetic.BIT_NOT);
break;
case SQLTokenizer.PARENTHESIS_L:
leftExpr = expression( cmd, 0);
token = nextToken(MISSING_PARENTHESIS_R);
break;
default:
leftExpr = expressionSingle( cmd, token);
}
boolean isNot = false;
while((token = nextToken()) != null){
Expression rightExpr;
int operation = ExpressionArithmetic.getOperationFromToken(token.value);
int level = operation / 10;
if(previousOperationLevel >= level){
previousToken();
return leftExpr;
}
switch(token.value){
case SQLTokenizer.PLUS:
case SQLTokenizer.MINUS:
case SQLTokenizer.ASTERISK:
case SQLTokenizer.SLACH:
case SQLTokenizer.PERCENT:
case SQLTokenizer.EQUALS:
case SQLTokenizer.LESSER:
case SQLTokenizer.LESSER_EQU:
case SQLTokenizer.GREATER:
case SQLTokenizer.GREATER_EQU:
case SQLTokenizer.UNEQUALS:
case SQLTokenizer.LIKE:
case SQLTokenizer.OR:
case SQLTokenizer.AND:
case SQLTokenizer.BIT_AND:
case SQLTokenizer.BIT_OR:
case SQLTokenizer.BIT_XOR:
rightExpr = expression( cmd, level );
leftExpr = new ExpressionArithmetic( leftExpr, rightExpr, operation );
break;
case SQLTokenizer.BETWEEN:
rightExpr = expression( cmd, ExpressionArithmetic.AND );
nextToken( MISSING_AND );
Expression rightExpr2 = expression( cmd, level );
leftExpr = new ExpressionArithmetic( leftExpr, rightExpr, rightExpr2, operation );
break;
case SQLTokenizer.IN:
nextToken(MISSING_PARENTHESIS_L);
token = nextToken(MISSING_EXPRESSION);
if(token.value == SQLTokenizer.SELECT){
CommandSelect cmdSel = select();
leftExpr = new ExpressionInSelect( con, leftExpr, cmdSel, operation );
nextToken(MISSING_PARENTHESIS_R);
}else{
previousToken();
Expressions list = expressionParenthesisList( cmd );
leftExpr = new ExpressionArithmetic( leftExpr, list, operation );
}
break;
case SQLTokenizer.IS:
token = nextToken(MISSING_NOT_NULL);
if(token.value == SQLTokenizer.NOT){
nextToken(MISSING_NULL);
operation++;
}
leftExpr = new ExpressionArithmetic( leftExpr, operation );
break;
case SQLTokenizer.NOT:
token = nextToken(MISSING_BETWEEN_IN);
previousToken();
isNot = true;
continue;
default:
previousToken();
return leftExpr;
}
if(isNot){
isNot = false;
leftExpr = new ExpressionArithmetic( leftExpr, ExpressionArithmetic.NOT);
}
}
previousToken();
return leftExpr;
}
/**
* This method parse a single expression like 12, 'qwert', 0x3F or a column name.
*
* @param cmd is needed to add parameters "?" with addParameter()
*/
private Expression expressionSingle(Command cmd, SQLToken token) throws SQLException{
boolean isMinus = false;
if(token != null){
switch(token.value){
case SQLTokenizer.NULL:
return new ExpressionValue( null, SQLTokenizer.NULL );
case SQLTokenizer.STRING:
return new ExpressionValue( token.getName(null), SQLTokenizer.VARCHAR );
case SQLTokenizer.IDENTIFIER:
{
String name = getIdentifier( token );
ExpressionName expr = new ExpressionName( name );
SQLToken token2 = nextToken();
if(token2 != null && token2.value == SQLTokenizer.POINT){
expr.setNameAfterTableAlias( nextIdentifier() );
}else{
previousToken();
}
return expr;
}
case SQLTokenizer.TRUE:
return new ExpressionValue( Boolean.TRUE, SQLTokenizer.BOOLEAN );
case SQLTokenizer.FALSE:
return new ExpressionValue( Boolean.FALSE, SQLTokenizer.BOOLEAN );
case SQLTokenizer.ESCAPE_L:{
token = nextToken(COMMANDS_ESCAPE);
SQLToken para = nextToken(MISSING_EXPRESSION);
Expression expr;
switch(token.value){
case SQLTokenizer.D: // date escape sequence
expr = new ExpressionValue( DateTime.valueOf(para.getName(sql), SQLTokenizer.DATE), SQLTokenizer.DATE );
break;
case SQLTokenizer.T: // time escape sequence
expr = new ExpressionValue( DateTime.valueOf(para.getName(sql), SQLTokenizer.TIME), SQLTokenizer.TIME );
break;
case SQLTokenizer.TS: // timestamp escape sequence
expr = new ExpressionValue( DateTime.valueOf(para.getName(sql), SQLTokenizer.TIMESTAMP), SQLTokenizer.TIMESTAMP );
break;
case SQLTokenizer.FN: // function escape sequence
nextToken(MISSING_PARENTHESIS_L);
expr = function(cmd, para, true);
break;
case SQLTokenizer.CALL: // call escape sequence
throw new java.lang.UnsupportedOperationException("call escape sequence");
default: throw new Error();
}
token = nextToken( ESCAPE_MISSING_CLOSE );
return expr;
}
case SQLTokenizer.QUESTION:
ExpressionValue param = new ExpressionValue();
cmd.addParameter( param );
return param;
case SQLTokenizer.CASE:
return caseExpr(cmd);
case SQLTokenizer.MINUS:
case SQLTokenizer.PLUS:
// sign detection
do{
if(token.value == SQLTokenizer.MINUS)
isMinus = !isMinus;
token = nextToken();
if(token == null) throw createSyntaxError( token, MISSING_EXPRESSION );
}while(token.value == SQLTokenizer.MINUS || token.value == SQLTokenizer.PLUS);
// no Break
default:
SQLToken token2 = nextToken();
if(token2 != null && token2.value == SQLTokenizer.PARENTHESIS_L){
if(isMinus)
return new ExpressionArithmetic( function( cmd, token, false ), ExpressionArithmetic.NEGATIVE );
return function( cmd, token, false );
}else{
// constant expression or identifier
char chr1 = sql[ token.offset ];
if(chr1 == '$'){
previousToken();
String tok = new String(sql, token.offset+1, token.length-1);
if(isMinus) tok = "-" + tok;
return new ExpressionValue( new Money(Double.parseDouble(tok)), SQLTokenizer.MONEY );
}
String tok = new String(sql, token.offset, token.length);
if((chr1 >= '0' && '9' >= chr1) || chr1 == '.'){
previousToken();
// first character is a digit
if(token.length>1 && (sql[ token.offset +1 ] | 0x20) == 'x'){
// binary data as hex
if(isMinus) {
throw createSyntaxError(token, Language.STXADD_OPER_MINUS);
}
return new ExpressionValue( Utils.hex2bytes( sql, token.offset+2, token.length-2), SQLTokenizer.VARBINARY );
}
if(isMinus) tok = "-" + tok;
if(Utils.indexOf( '.', sql, token.offset, token.length ) >= 0 ||
Utils.indexOf( 'e', sql, token.offset, token.length ) >= 0){
return new ExpressionValue( new Double(tok), SQLTokenizer.DOUBLE );
}else{
try{
return new ExpressionValue( new Integer(tok), SQLTokenizer.INT );
}catch(NumberFormatException e){
return new ExpressionValue( new Long(tok), SQLTokenizer.BIGINT );
}
}
}else{
// identifier
checkValidIdentifier( tok, token );
ExpressionName expr = new ExpressionName(tok);
if(token2 != null && token2.value == SQLTokenizer.POINT){
expr.setNameAfterTableAlias( nextIdentifier() );
}else{
previousToken();
}
if(isMinus)
return new ExpressionArithmetic( expr, ExpressionArithmetic.NEGATIVE );
return expr;
}
}
}
}
return null;
}
ExpressionFunctionCase caseExpr(final Command cmd) throws SQLException{
ExpressionFunctionCase expr = new ExpressionFunctionCase();
SQLToken token = nextToken(MISSING_EXPRESSION);
Expression input = null;
if(token.value != SQLTokenizer.WHEN){
// simple CASE Syntax
previousToken();
input = expression(cmd, 0);
token = nextToken(MISSING_WHEN_ELSE_END);
}
while(true){
switch(token.value){
case SQLTokenizer.WHEN:
Expression condition = expression(cmd, 0);
if(input != null){
// simple CASE Syntax
condition = new ExpressionArithmetic( input, condition, ExpressionArithmetic.EQUALS);
}
nextToken(MISSING_THEN);
Expression result = expression(cmd, 0);
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -