sqlparser.java

這是一個油Java實作的資料庫系統 是個入門的好材料

					expr.addCase(condition, result);
					break;
				case SQLTokenizer.ELSE:
					expr.setElseResult(expression(cmd, 0));
					break;
				case SQLTokenizer.END:
					expr.setEnd();
					return expr;
				default:
					throw new Error();
			}
			token = nextToken(MISSING_WHEN_ELSE_END);
		}
    }
    

    /**
     * Parse any functions. The left parenthesis is already consumed from token list.
     * @param token the SQLToken of the function
     * @param isEscape If the function is a FN ESCAPE sequence
     */ 
    private Expression function( Command cmd, SQLToken token, boolean isEscape ) throws SQLException{
        Expression expr;
        switch(token.value){
        	case SQLTokenizer.CONVERT:{
        		Column col;
        		Expression style = null;
        		if(isEscape){
        			expr = expression( cmd, 0);
					nextToken(MISSING_COMMA);
					col = datatype(isEscape);
        		}else{
	        		col = datatype(isEscape);
	        		nextToken(MISSING_COMMA);
					expr = expression( cmd, 0);
					token = nextToken(MISSING_COMMA_PARENTHESIS);
					if(token.value == SQLTokenizer.COMMA){
						style = expression( cmd, 0);
					}else
						previousToken();
        		}
        		nextToken(MISSING_PARENTHESIS_R);
        		return new ExpressionFunctionConvert( col, expr, style );
        	}
        	case SQLTokenizer.CAST:
        		expr = expression( cmd, 0);
        		nextToken(MISSING_AS);
        		Column col = datatype(false);
        		nextToken(MISSING_PARENTHESIS_R);
        		return new ExpressionFunctionConvert( col, expr, null );
			case SQLTokenizer.TIMESTAMPDIFF:
				token = nextToken(MISSING_INTERVALS);
				nextToken(MISSING_COMMA);
				expr = expression( cmd, 0);
				nextToken(MISSING_COMMA);
				expr = new ExpressionFunctionTimestampDiff( token.value, expr, expression( cmd, 0));
				nextToken(MISSING_PARENTHESIS_R);
				return expr;
			case SQLTokenizer.TIMESTAMPADD:
				token = nextToken(MISSING_INTERVALS);
				nextToken(MISSING_COMMA);
				expr = expression( cmd, 0);
				nextToken(MISSING_COMMA);
				expr = new ExpressionFunctionTimestampAdd( token.value, expr, expression( cmd, 0));
				nextToken(MISSING_PARENTHESIS_R);
				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.BITLEN:
                invalidParamCount = (paramCount != 1);
                expr = new ExpressionFunctionBitLen();
                break;
            case SQLTokenizer.CHARLEN:
            case SQLTokenizer.CHARACTLEN:
                invalidParamCount = (paramCount != 1);
                expr = new ExpressionFunctionCharLen();
                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.OCTETLEN:
                invalidParamCount = (paramCount != 1);
                expr = new ExpressionFunctionOctetLen();
                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:
            case SQLTokenizer.CURRENTDATE:
            	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);