sqlparser.java

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

    private Column datatype(boolean isEscape) throws SQLException{
		SQLToken token;
		int dataType;
		if(isEscape){
			token = nextToken( MISSING_SQL_DATATYPE );
			switch(token.value){
				case SQLTokenizer.SQL_BIGINT: 			dataType = SQLTokenizer.BIGINT;		break;
				case SQLTokenizer.SQL_BINARY:			dataType = SQLTokenizer.BINARY; 	break;
				case SQLTokenizer.SQL_BIT:				dataType = SQLTokenizer.BIT;		break;
				case SQLTokenizer.SQL_CHAR:				dataType = SQLTokenizer.CHAR;		break;
				case SQLTokenizer.SQL_DATE:				dataType = SQLTokenizer.DATE;		break;
				case SQLTokenizer.SQL_DECIMAL:			dataType = SQLTokenizer.DECIMAL;	break;
				case SQLTokenizer.SQL_DOUBLE:			dataType = SQLTokenizer.DOUBLE;		break;
				case SQLTokenizer.SQL_FLOAT:			dataType = SQLTokenizer.FLOAT;		break;
				case SQLTokenizer.SQL_INTEGER:			dataType = SQLTokenizer.INT;		break;
				case SQLTokenizer.SQL_LONGVARBINARY:	dataType = SQLTokenizer.LONGVARBINARY;break;
				case SQLTokenizer.SQL_LONGVARCHAR:		dataType = SQLTokenizer.LONGVARCHAR;break;
				case SQLTokenizer.SQL_REAL:				dataType = SQLTokenizer.REAL;		break;
				case SQLTokenizer.SQL_SMALLINT:			dataType = SQLTokenizer.SMALLINT;	break;
				case SQLTokenizer.SQL_TIME:				dataType = SQLTokenizer.TIME;		break;
				case SQLTokenizer.SQL_TIMESTAMP:		dataType = SQLTokenizer.TIMESTAMP;	break;
				case SQLTokenizer.SQL_TINYINT:			dataType = SQLTokenizer.TINYINT;	break;
				case SQLTokenizer.SQL_VARBINARY:		dataType = SQLTokenizer.VARBINARY;	break;
				case SQLTokenizer.SQL_VARCHAR:			dataType = SQLTokenizer.VARCHAR;	break;
				default: throw new Error();
			}
		}else{
			token = nextToken( MISSING_DATATYPE );
			dataType = token.value;
		}
		Column col = new Column();

		// zweiteiliger Datentyp
		if(dataType == SQLTokenizer.LONG){
			token = nextToken();
			if(token != null && token.value == SQLTokenizer.RAW){
				dataType = SQLTokenizer.LONGVARBINARY;
			}else{
				dataType = SQLTokenizer.LONGVARCHAR;
				previousToken();
			}
		}

		switch(dataType){
			case SQLTokenizer.RAW:
				dataType = SQLTokenizer.VARBINARY;
				// no break;
			case SQLTokenizer.CHAR:
			case SQLTokenizer.VARCHAR:
			case SQLTokenizer.NCHAR:
			case SQLTokenizer.NVARCHAR:
			case SQLTokenizer.BINARY:
			case SQLTokenizer.VARBINARY:
			{
				// maximale Spaltengr鲞e ermitteln
                token = nextToken();
				int displaySize;
				if(token == null || token.value != SQLTokenizer.PARENTHESIS_L){
					displaySize = 30;
                    previousToken();
				}else{
					token = nextToken( MISSING_EXPRESSION );
					try{
						displaySize = Integer.parseInt(token.getName(sql) );
					}catch(Exception e){
						throw createSyntaxError(token, MISSING_NUMBERVALUE );
					}
					nextToken( MISSING_PARENTHESIS_R );
				}
				col.setPrecision( displaySize );
				break;
			}
			case SQLTokenizer.SYSNAME:
				col.setPrecision(255);
				dataType = SQLTokenizer.VARCHAR;
				break;
			case SQLTokenizer.COUNTER:
				col.setAutoIncrement(true);
				dataType = SQLTokenizer.INT;
				break;
			case SQLTokenizer.NUMERIC:
			case SQLTokenizer.DECIMAL:
                token = nextToken();
				if(token != null && token.value == SQLTokenizer.PARENTHESIS_L){
					// read the precision of the data type
					token = nextToken( MISSING_EXPRESSION );
					int value;
					try{
						value = Integer.parseInt(token.getName(sql) );
					}catch(Exception e){
						throw createSyntaxError(token, MISSING_NUMBERVALUE );
					}
					col.setPrecision(value);
					token = nextToken( MISSING_COMMA_PARENTHESIS );
					if(token.value == SQLTokenizer.COMMA){
						// read the scale of the data type
						token = nextToken( MISSING_EXPRESSION );
						try{
							value = Integer.parseInt(token.getName(sql) );
						}catch(Exception e){
							throw createSyntaxError(token, MISSING_NUMBERVALUE );
						}
						col.setScale(value);
						nextToken( MISSING_PARENTHESIS_R );
					}
				}else{
					col.setPrecision(18); //default Precision for decimal and numeric
                    previousToken();
				}
				break;
		}
		col.setDataType( dataType );
		return col;
    }
    
    private CommandCreateView createView() throws SQLException{
    	String viewName = nextIdentifier();

		nextToken(MISSING_AS);
		SQLToken token = nextToken(MISSING_SELECT);
		CommandCreateView cmd = new CommandCreateView( con.log, viewName );
		
		cmd.sql = new String(sql, token.offset, sql.length-token.offset );
		select(); //Parse to check for valid
        return cmd;
    }


    private CommandTable createIndex(boolean unique) throws SQLException{
        String indexName = nextIdentifier();
        nextToken(MISSING_ON);
        String catalog;
        String tableName = catalog = nextIdentifier();
        tableName = nextIdentiferPart(tableName);
        if(tableName == catalog) catalog = null;
        CommandTable cmd = new CommandTable( con.log, catalog, tableName, SQLTokenizer.INDEX );
        Expressions expressions = new Expressions();
        Strings columns = new Strings();
        expressionDefList( cmd, expressions, columns );
        IndexDescription indexDesc = new IndexDescription( 
                indexName, 
                tableName, 
                unique ? SQLTokenizer.UNIQUE : SQLTokenizer.INDEX, 
                        expressions, 
                        columns);
        //TODO Create Index
        throw Utils.createSQLException("UnsupportedOperation Create Index");
    }

    private CommandCreateDatabase createProcedure() throws SQLException{
        //TODO Create Procedure
        throw Utils.createSQLException("UnsupportedOperation Create Procedure");
    }

    private Command drop() throws SQLException{
        SQLToken tokenType = nextToken(COMMANDS_DROP);
        
		String catalog;
		String name = catalog = nextIdentifier();
        name = nextIdentiferPart( name );
        if(name == catalog) catalog = null;

        switch(tokenType.value){
            case SQLTokenizer.DATABASE:
            case SQLTokenizer.TABLE:
            case SQLTokenizer.VIEW:
            case SQLTokenizer.INDEX:
            case SQLTokenizer.PROCEDURE:
            	return new CommandDrop( con.log, catalog, name, tokenType.value);
            default:
                throw createSyntaxError( tokenType, COMMANDS_DROP );
        }
    }


    private Command alter() throws SQLException{
    	SQLToken tokenType = nextToken(COMMANDS_ALTER);
		String catalog;
		String tableName = catalog = nextIdentifier();
        switch(tokenType.value){
        case SQLTokenizer.TABLE:
        case SQLTokenizer.VIEW:
        case SQLTokenizer.INDEX:
        case SQLTokenizer.PROCEDURE:
            tableName = nextIdentiferPart(tableName);
            if(tableName == catalog) catalog = null;
        }
        switch(tokenType.value){
    	//case SQLTokenizer.DATABASE:
        case SQLTokenizer.TABLE:
            return alterTable( catalog, tableName );
        //case SQLTokenizer.VIEW:
        //case SQLTokenizer.INDEX:
        //case SQLTokenizer.PROCEDURE:
        default:
        	throw Utils.createUnsupportedException("ALTER " + tokenType.getName( sql ));
        }
    }
    
    
    Command alterTable( String catalog, String name ) throws SQLException{
    	SQLToken tokenType = nextToken(MISSING_ADD_ALTER_DROP);
        CommandTable cmd = new CommandTable( con.log, catalog, name, tokenType.value );
    	switch(tokenType.value){
    	case SQLTokenizer.ADD:
    		SQLToken token;
    		do{
    			token = nextToken( MISSING_IDENTIFIER );
    			token = addColumn( token, cmd );
    		}while(token != null && token.value == SQLTokenizer.COMMA );

    		return cmd;
    	default:
            throw Utils.createUnsupportedException("ALTER TABLE " + tokenType.getName( sql ));
    	}
    }
    

    private CommandSet set() throws SQLException{
        SQLToken token = nextToken( COMMANDS_SET );
        switch(token.value){
            case SQLTokenizer.TRANSACTION:
                return setTransaction();
            default:
                throw new Error();
        }
    }

    private CommandSet setTransaction() throws SQLException{
        SQLToken token = nextToken( MISSING_ISOLATION );
        token = nextToken( MISSING_LEVEL );
        token = nextToken( COMMANDS_TRANS_LEVEL );
        CommandSet cmd = new CommandSet( con.log, SQLTokenizer.LEVEL );
        switch(token.value){
            case SQLTokenizer.READ:
                token = nextToken( MISSING_COMM_UNCOMM );
                switch(token.value){
                    case SQLTokenizer.COMMITTED:
                        cmd.isolationLevel = Connection.TRANSACTION_READ_COMMITTED;
                        break;
                    case SQLTokenizer.UNCOMMITTED:
                        cmd.isolationLevel = Connection.TRANSACTION_READ_UNCOMMITTED;
                        break;
                    default:
                        throw new Error();
                }
                return cmd;
            case SQLTokenizer.REPEATABLE:
                token = nextToken( MISSING_READ );
                cmd.isolationLevel = Connection.TRANSACTION_REPEATABLE_READ;
                return cmd;
            case SQLTokenizer.SERIALIZABLE:
                cmd.isolationLevel = Connection.TRANSACTION_SERIALIZABLE;
                return cmd;
            default:
                throw new Error();
        }


    }

    private Command execute() throws SQLException{
        //TODO Execute
        throw Utils.createSQLException("UnsupportedOperation Execute");
    }

    /**
     * Read a Expression list in parenthesis like of VALUES() or functions. 
     * The left parenthesis is already consumed.
     * 
     * @param cmd is needed to add parameters "?" with addParameter() 
     * @see #expressionDefList
     */ 
    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 params
				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);
						//kein 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();