sqlparser.java

java 数据库 功能强大 效率高 SmallSQL Database is a free DBMS library for the Java(tm) platform. It runs on

				return expr;
        }
		Expressions paramList = expressionParenthesisList(cmd);
        int paramCount = paramList.size();
        Expression[] params = paramList.toArray();
        boolean invalidParamCount;
        switch(token.value){
        // numeric functions:
            case SQLTokenizer.ABS:
                invalidParamCount = (paramCount != 1);
                expr = new ExpressionFunctionAbs();
                break;
            case SQLTokenizer.ACOS:
                invalidParamCount = (paramCount != 1);
                expr = new ExpressionFunctionACos();
                break;
            case SQLTokenizer.ASIN:
                invalidParamCount = (paramCount != 1);
                expr = new ExpressionFunctionASin();
                break;
            case SQLTokenizer.ATAN:
                invalidParamCount = (paramCount != 1);
                expr = new ExpressionFunctionATan();
                break;
            case SQLTokenizer.ATAN2:
                invalidParamCount = (paramCount != 2);
                expr = new ExpressionFunctionATan2();
                break;
            case SQLTokenizer.CEILING:
                invalidParamCount = (paramCount != 1);
                expr = new ExpressionFunctionCeiling();
                break;
            case SQLTokenizer.COS:
                invalidParamCount = (paramCount != 1);
                expr = new ExpressionFunctionCos();
                break;
            case SQLTokenizer.COT:
                invalidParamCount = (paramCount != 1);
                expr = new ExpressionFunctionCot();
                break;
            case SQLTokenizer.DEGREES:
                invalidParamCount = (paramCount != 1);
                expr = new ExpressionFunctionDegrees();
                break;
            case SQLTokenizer.EXP:
                invalidParamCount = (paramCount != 1);
                expr = new ExpressionFunctionExp();
                break;
            case SQLTokenizer.FLOOR:
                invalidParamCount = (paramCount != 1);
                expr = new ExpressionFunctionFloor();
                break;
            case SQLTokenizer.LOG:
                invalidParamCount = (paramCount != 1);
                expr = new ExpressionFunctionLog();
                break;
            case SQLTokenizer.LOG10:
                invalidParamCount = (paramCount != 1);
                expr = new ExpressionFunctionLog10();
                break;
            case SQLTokenizer.MOD:
                invalidParamCount = (paramCount != 2);
                expr = new ExpressionFunctionMod();
                break;
            case SQLTokenizer.PI:
                invalidParamCount = (paramCount != 0);
                expr = new ExpressionFunctionPI();
                break;
            case SQLTokenizer.POWER:
                invalidParamCount = (paramCount != 2);
                expr = new ExpressionFunctionPower();
                break;
            case SQLTokenizer.RADIANS:
                invalidParamCount = (paramCount != 1);
                expr = new ExpressionFunctionRadians();
                break;
            case SQLTokenizer.RAND:
                invalidParamCount =  (paramCount != 0) && (paramCount != 1);
                expr = new ExpressionFunctionRand();
                break;
            case SQLTokenizer.ROUND:
                invalidParamCount =  (paramCount != 2);
                expr = new ExpressionFunctionRound();
                break;
            case SQLTokenizer.SIN:
                invalidParamCount = (paramCount != 1);
                expr = new ExpressionFunctionSin();
                break;
            case SQLTokenizer.SIGN:
                invalidParamCount = (paramCount != 1);
                expr = new ExpressionFunctionSign();
                break;
            case SQLTokenizer.SQRT:
                invalidParamCount = (paramCount != 1);
                expr = new ExpressionFunctionSqrt();
                break;
            case SQLTokenizer.TAN:
                invalidParamCount = (paramCount != 1);
                expr = new ExpressionFunctionTan();
                break;
            case SQLTokenizer.TRUNCATE:
                invalidParamCount =  (paramCount != 2);
                expr = new ExpressionFunctionTruncate();
                break;
         
        // string functions:
			case SQLTokenizer.ASCII:
				invalidParamCount = (paramCount != 1);
				expr = new ExpressionFunctionAscii();
				break;
			case SQLTokenizer.CHAR:
				invalidParamCount = (paramCount != 1);
				expr = new ExpressionFunctionChar();
				break;
            case SQLTokenizer.CONCAT:
                if(paramCount != 2){
                    invalidParamCount = true;
                    expr = null;//only for compiler
                    break;
                }
                invalidParamCount = false;
                expr = new ExpressionArithmetic( params[0], params[1], ExpressionArithmetic.ADD);
                break;
            case SQLTokenizer.DIFFERENCE:
                invalidParamCount = (paramCount != 2);
                expr = new ExpressionFunctionDifference();
                break;
            case SQLTokenizer.INSERT:
                invalidParamCount = (paramCount != 4);
                expr = new ExpressionFunctionInsert();
                break;
            case SQLTokenizer.LCASE:
                invalidParamCount = (paramCount != 1);
                expr = new ExpressionFunctionLCase();
                break;
            case SQLTokenizer.LEFT:
                invalidParamCount = (paramCount != 2);
                expr = new ExpressionFunctionLeft();
                break;
			case SQLTokenizer.LENGTH:
				invalidParamCount = (paramCount != 1);
				expr = new ExpressionFunctionLength();
				break;
            case SQLTokenizer.LOCATE:
            	invalidParamCount = (paramCount != 2) && (paramCount != 3);
            	expr = new ExpressionFunctionLocate();
            	break;
            case SQLTokenizer.LTRIM:
                invalidParamCount = (paramCount != 1);
                expr = new ExpressionFunctionLTrim();
                break;
            case SQLTokenizer.REPEAT:
                invalidParamCount = (paramCount != 2);
                expr = new ExpressionFunctionRepeat();
                break;
            case SQLTokenizer.REPLACE:
                invalidParamCount = (paramCount != 3);
                expr = new ExpressionFunctionReplace();
                break;
			case SQLTokenizer.RIGHT:
				invalidParamCount = (paramCount != 2);
				expr = new ExpressionFunctionRight();
				break;
            case SQLTokenizer.RTRIM:
                invalidParamCount = (paramCount != 1);
                expr = new ExpressionFunctionRTrim();
                break;
            case SQLTokenizer.SPACE:
                invalidParamCount = (paramCount != 1);
                expr = new ExpressionFunctionSpace();
                break;
            case SQLTokenizer.SOUNDEX:
                invalidParamCount = (paramCount != 1);
                expr = new ExpressionFunctionSoundex();
                break;
			case SQLTokenizer.SUBSTRING:
				invalidParamCount = (paramCount != 3);
				expr = new ExpressionFunctionSubstring();
				break;
            case SQLTokenizer.UCASE:
                invalidParamCount = (paramCount != 1);
                expr = new ExpressionFunctionUCase();
                break;
                
        // date time functions
            case SQLTokenizer.CURDATE:
            	invalidParamCount = (paramCount != 0);
				expr = new ExpressionValue( new DateTime(DateTime.now(), SQLTokenizer.DATE), SQLTokenizer.DATE);
				break;
            case SQLTokenizer.CURTIME:
            	invalidParamCount = (paramCount != 0);
				expr = new ExpressionValue( new DateTime(DateTime.now(), SQLTokenizer.TIME), SQLTokenizer.TIME);
				break;
            case SQLTokenizer.DAYOFMONTH:
            	invalidParamCount = (paramCount != 1);
				expr = new ExpressionFunctionDayOfMonth();
				break;
            case SQLTokenizer.DAYOFWEEK:
            	invalidParamCount = (paramCount != 1);
				expr = new ExpressionFunctionDayOfWeek();
				break;
            case SQLTokenizer.DAYOFYEAR:
            	invalidParamCount = (paramCount != 1);
				expr = new ExpressionFunctionDayOfYear();
				break;
            case SQLTokenizer.HOUR:
            	invalidParamCount = (paramCount != 1);
				expr = new ExpressionFunctionHour();
				break;
            case SQLTokenizer.MINUTE:
            	invalidParamCount = (paramCount != 1);
				expr = new ExpressionFunctionMinute();
				break;
            case SQLTokenizer.MONTH:
            	invalidParamCount = (paramCount != 1);
				expr = new ExpressionFunctionMonth();
				break;
            case SQLTokenizer.NOW:
            	invalidParamCount = (paramCount != 0);
				expr = new ExpressionValue( new DateTime(DateTime.now(), SQLTokenizer.TIMESTAMP), SQLTokenizer.TIMESTAMP);
				break;
            	
        // system functions:
            case SQLTokenizer.IIF:
        		invalidParamCount = (paramCount != 3);
            	expr = new ExpressionFunctionIIF();
        		break;
        	case SQLTokenizer.SWITCH:
        		invalidParamCount = (paramCount % 2 != 0);
        		ExpressionFunctionCase exprCase = new ExpressionFunctionCase();
        		for(int i=0; i < paramCount-1; i +=2)
        			exprCase.addCase(params[i], params[i+1] );
        		exprCase.setEnd();
        		expr = exprCase;
        		break;
        	case SQLTokenizer.IFNULL:
        		switch(paramCount){
        			case 1:
        				return new ExpressionArithmetic( params[0], ExpressionArithmetic.ISNULL );
        			case 2:        				
        				invalidParamCount = false;
        				expr = new ExpressionFunctionIIF();
        				Expression[] newParams = new Expression[3];
        				newParams[0] = new ExpressionArithmetic( params[0], ExpressionArithmetic.ISNULL );
        				newParams[1] = params[1];
        				newParams[2] = params[0];        				
        				params = newParams;
        				paramCount = 3;
        				break;
        			default:
        				invalidParamCount = true;
        				expr = null; // only for Compiler
        		}
        		break;
                    
        // now come the aggregate functions
            case SQLTokenizer.COUNT:
					invalidParamCount = (paramCount != 1);
					if(params[0].getType() == Expression.NAME){
						//detect special case COUNT(*)
						ExpressionName param = (ExpressionName)params[0];
						if("*".equals(param.getName()) && param.getTableAlias() == null){
							params[0] = new ExpressionValue();
						}
					}
					expr = new ExpressionName( Expression.COUNT );
					break;
			case SQLTokenizer.SUM:
					invalidParamCount = (paramCount != 1);
					expr = new ExpressionName( Expression.SUM );
					break;
			case SQLTokenizer.MAX:
					invalidParamCount = (paramCount != 1);
					expr = new ExpressionName( Expression.MAX );
					break;
			case SQLTokenizer.MIN:
					invalidParamCount = (paramCount != 1);
					expr = new ExpressionName( Expression.MIN );
					break;
			case SQLTokenizer.FIRST:
					invalidParamCount = (paramCount != 1);
					expr = new ExpressionName( Expression.FIRST );
					break;
			case SQLTokenizer.LAST:
					invalidParamCount = (paramCount != 1);
					expr = new ExpressionName( Expression.LAST );
					break;
			case SQLTokenizer.AVG:
					if(paramCount != 1){
                        invalidParamCount = true;
                        expr = null;//Only for the compiler
                        break;
                    }
					expr = new ExpressionName( Expression.SUM );
					expr.setParams( params );
					Expression expr2 = new ExpressionName( Expression.COUNT );
					expr2.setParams( params );
					expr = new ExpressionArithmetic( expr, expr2, ExpressionArithmetic.DIV );
					return expr;
            default: throw createSyntaxError(token, "Unknown function.");
        }
        if(invalidParamCount) throw createSyntaxError( token, "Invalid parameter count." );
        expr.setParams( params );
        return expr;
    }

    /**
     * read a table or view name in a FROM clause. If the keyword AS exists then read it also the alias
     */
    private RowSource tableSource( Command cmd, DataSources tables) throws SQLException{
        SQLToken token = nextToken(MISSING_EXPRESSION);
        switch(token.value){
            case SQLTokenizer.PARENTHESIS_L: // (
                    return rowSource( cmd, tables, SQLTokenizer.PARENTHESIS_R );
            case SQLTokenizer.ESCAPE_L: // {
                    token = nextToken(MISSING_OJ);
                    return rowSource( cmd, tables, SQLTokenizer.ESCAPE_R );
            case SQLTokenizer.SELECT:
            		// inner select
            		ViewResult viewResult = new ViewResult( con, select() );
            		tables.add(viewResult);
            		return viewResult;
        }
        String catalog = null;
        String name = getIdentifier( token );
		token = nextToken();
		//check if the table name include a database name
		if(token != null && token.value == SQLTokenizer.POINT){
			catalog = name;
			name = nextIdentifier();
			token = nextToken();
		}
		//TableResult table = new TableResult();
		//table.setName( catalog, name );
		TableView tableView = Database.getTableView( con, ca