storeimpl.java

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

                ((page[ offset++ ] & 0xFF) << 8) |
                ((page[ offset++ ] & 0xFF));
    }

    void writeDouble(double value){
        writeLong( Double.doubleToLongBits(value) );
    }

    double readDouble(){
        return Double.longBitsToDouble( readLong() );
    }

    void writeFloat(float value){
        writeInt( Float.floatToIntBits(value) );
    }

    float readFloat(){
        return Float.intBitsToFloat( readInt() );
    }

    void writeNumeric( MutableNumeric num){
        writeByte( num.getInternalValue().length );
        writeByte( num.getScale() );
        writeByte( num.getSignum() );
        for(int i=0; i<num.getInternalValue().length; i++){
            writeInt( num.getInternalValue()[i] );
        }
    }

    MutableNumeric readNumeric(){
        int[] value = new int[ readByte() ];
        int scale   = readByte();
        int signum  = readByte();
        for(int i=0; i<value.length; i++){
            value[i] = readInt();
        }
        return new MutableNumeric( signum, value, scale );
    }

    void writeTimestamp( long ts){
        writeLong( ts );
    }

    long readTimestamp(){
        return readLong();
    }

    void writeTime( long time){
        writeInt( (int)((time / 1000) % 86400) );
    }

    long readTime(){
        return readInt() * 1000L;
    }

    void writeDate( long date){
        writeInt( (int)(date / 86400000));
    }

    long readDate(){
        return readInt() * 86400000L;
    }

    void writeSmallDateTime( long datetime){
        writeInt( (int)(datetime / 60000));
    }

    long readSmallDateTime(){
        return readInt() * 60000L;
    }

    void writeString( String strDaten ) throws SQLException{
        writeString( strDaten, Short.MAX_VALUE, true );
    }

    void writeString( String strDaten, int lengthColumn, boolean varchar ) throws SQLException{
        char[] daten = strDaten.toCharArray();
        int length = daten.length;

        if(lengthColumn < length){
            throw SmallSQLException.create(Language.VALUE_STR_TOOLARGE);
        }
		if(varchar) lengthColumn = length;
    	int newSize = offset + 2 + 2*lengthColumn;
        if(newSize > page.length) resizePage(newSize);

        writeShort( lengthColumn );
        writeChars( daten );
        for(int i=length; i<lengthColumn; i++){
            page[ offset++ ] = ' ';
            page[ offset++ ] = 0;
        }
    }

    String readString(){
        int length = readShort();
        return new String( readChars(length) );
    }

    void writeBytes(byte[] daten){
        int newSize = offset + daten.length;
        if(newSize > page.length) resizePage(newSize );
        System.arraycopy( daten, 0, page, offset, daten.length);
        offset += daten.length;
    }

    void writeBytes(byte[] daten, int off, int length){
        int newSize = offset + length;
        if(newSize > page.length) resizePage(newSize );
        System.arraycopy( daten, off, page, offset, length);
        offset += length;
    }

    byte[] readBytes(int length){
        byte[] daten = new byte[length];
        System.arraycopy( page, offset, daten, 0, length);
        offset += length;
        return daten;
    }

    void writeBinary( byte[] daten, int lengthColumn, boolean varBinary ) throws SQLException{
        int length = daten.length;

        if(lengthColumn < length){
        	Object params = new Object[] { new Integer(length), new Integer(lengthColumn) };
            throw SmallSQLException.create(Language.VALUE_BIN_TOOLARGE, params);
        }
        if(varBinary) lengthColumn = length;
    	int newSize = offset + 2 + lengthColumn;
        if(newSize > page.length) resizePage(newSize);

        page[ offset++ ] = (byte)(lengthColumn >> 8);
        page[ offset++ ] = (byte)(lengthColumn);
        writeBytes( daten );
        if(!varBinary){
            for(int i=length; i<lengthColumn; i++){
                page[ offset++ ] = 0;
            }
        }
    }

    byte[] readBinary(){
        int length = readShort();
        return readBytes(length);
    }

    void writeLongBinary( byte[] daten ) throws Exception{
        StoreImpl store = table.getLobStore( ((TableStorePage)storePage).con, daten.length + 4, SQLTokenizer.LONGVARBINARY);
        store.writeInt( daten.length );
        store.writeBytes( daten );
        writeLong( store.writeFinsh(null) );
    }

    byte[] readLongBinary() throws Exception{
        long filePos = readLong();
        StoreImpl store = table.getLobStore( ((TableStorePage)storePage).con, filePos, SQLTokenizer.SELECT );
        return store.readBytes( store.readInt() );
    }

    void writeChars(char[] daten){
        int length = daten.length;
        int newSize = offset + 2*length;
        if(newSize > page.length) resizePage(newSize );
        for(int i=0; i<length; i++){
            char c = daten[i];
            page[ offset++ ] = (byte)(c);
            page[ offset++ ] = (byte)(c >> 8);
        }
    }

    char[] readChars(int length){
        char[] daten = new char[length];
        for(int i=0; i<length; i++){
            daten[i] = (char)((page[ offset++ ] & 0xFF) | (page[ offset++ ] << 8));
        }
        return daten;
    }

    void writeLongString(String daten) throws Exception{
        char[] chars = daten.toCharArray();
        StoreImpl store = table.getLobStore( ((TableStorePage)storePage).con, chars.length * 2L + 4, SQLTokenizer.LONGVARBINARY);
        store.writeInt( chars.length );
        store.writeChars( chars );
        writeLong( store.writeFinsh(null) );
    }

    String readLongString() throws Exception{
        long filePos = readLong();
        StoreImpl store = table.getLobStore( ((TableStorePage)storePage).con, filePos, SQLTokenizer.SELECT );
        if(store == null) throw SmallSQLException.create(Language.LOB_DELETED);
        return new String(store.readChars( store.readInt() ) );
    }
	

    void writeColumn( Table table, Column column ) throws Exception{
    	int newSize = offset + 25;
        if(newSize > page.length) resizePage(newSize);

        writeByte   ( column.getFlag() );
        writeString ( column.getName() );
        writeShort  ( column.getDataType() );
		writeInt    ( column.getPrecision() );
		writeByte   ( column.getScale() );
		offset += column.initAutoIncrement( table, storePage.raFile, filePos+offset);
		String def = column.getDefaultDefinition();
		writeBoolean( def == null );
		if(def != null)
			writeString ( column.getDefaultDefinition() );
    }

	
	/**
	 * Read a single Column description on the current file offset.
	 * @param table The parent table of the column.
	 * @param tableFormatVersion the file version of the table.
	 * @return
	 * @throws Exception
	 */
    Column readColumn(Table table, int tableFormatVersion) throws Exception{
        Column column = new Column();
        column.setFlag( readByte() );
        column.setName( readString() );
        column.setDataType( readShort() );
		int precision;
		if(tableFormatVersion == TableView.TABLE_VIEW_OLD_VERSION)
			precision = readByte();
		else
			precision = readInt();
		column.setPrecision( precision );
		column.setScale( readByte() );
		offset += column.initAutoIncrement( table, storePage.raFile, filePos+offset);
		if(!readBoolean()){
			String def = readString();
			column.setDefaultValue( new SQLParser().parseExpression(def), def);
		}
        return column;
    }
 
    
    void copyValueFrom( StoreImpl store, int valueOffset, int length){
		System.arraycopy( store.page, valueOffset, this.page, this.offset, length);
		this.offset += length;
    }

    
    /**
     * Here are pass only Expression instead of Objects to optimize 
     * it for native data (no object).
     * The value of offset must be correctly. 
     * @param expr the value that should be written
     * @param column a description of the target column
     * @throws Exception if any error occur like conversions or io exceptions
     */
    void writeExpression( Expression expr, Column column) throws Exception{
        boolean isNull = expr.isNull();
        if(isNull && !column.isNullable()){
            throw SmallSQLException.create(Language.VALUE_NULL_INVALID, column.getName());
        }
        int dataType = column.getDataType();
        if(isNull){
            writeBoolean(true); //true - is null
            switch(dataType){
                case SQLTokenizer.BIT:
                case SQLTokenizer.BOOLEAN:
                case SQLTokenizer.TINYINT:
                    offset++;
                    break;
                case SQLTokenizer.SMALLINT:
                case SQLTokenizer.BINARY:
                case SQLTokenizer.VARBINARY:
                case SQLTokenizer.CHAR:
                case SQLTokenizer.NCHAR:
                case SQLTokenizer.VARCHAR:
                case SQLTokenizer.NVARCHAR:
                    offset += 2;
                    break;
                case SQLTokenizer.INT:
                case SQLTokenizer.REAL:
                case SQLTokenizer.SMALLMONEY:
                case SQLTokenizer.TIME:
                case SQLTokenizer.DATE:
                case SQLTokenizer.SMALLDATETIME:
                    offset += 4;
                    break;
                case SQLTokenizer.BIGINT:
                case SQLTokenizer.FLOAT:
                case SQLTokenizer.DOUBLE:
                case SQLTokenizer.MONEY:
                case SQLTokenizer.JAVA_OBJECT:
                case SQLTokenizer.LONGVARBINARY:
                case SQLTokenizer.BLOB:
				case SQLTokenizer.CLOB:
				case SQLTokenizer.NCLOB:
                case SQLTokenizer.LONGNVARCHAR:
                case SQLTokenizer.LONGVARCHAR:
                case SQLTokenizer.TIMESTAMP:
                    offset += 8;
                    break;
                case SQLTokenizer.UNIQUEIDENTIFIER:
                    offset += 16;
                    break;
                case SQLTokenizer.NUMERIC:
                case SQLTokenizer.DECIMAL:
                    offset += 3;
                    break;
                default: throw new Error();
            }
            return;
        }
        writeBoolean(false); // false - is not null
       	column.setNewAutoIncrementValue(expr);
        switch(dataType){
            case SQLTokenizer.BIT:
            case SQLTokenizer.BOOLEAN:
                    writeBoolean( expr.getBoolean() );
                    break;
            case SQLTokenizer.BINARY:
            case SQLTokenizer.VARBINARY:
                    writeBinary( expr.getBytes(), column.getPrecision(), dataType != SQLTokenizer.BINARY );
                    break;
            case SQLTokenizer.TINYINT:
                    writeByte( expr.getInt() );
                    break;
            case SQLTokenizer.SMALLINT:
                    writeShort( expr.getInt() );
                    break;
            case SQLTokenizer.INT:
                    writeInt( expr.getInt() );
                    break;
            case SQLTokenizer.BIGINT:
                    writeLong( expr.getLong() );
                    break;
            case SQLTokenizer.REAL:
                    writeFloat( expr.getFloat() );
                    break;
            case SQLTokenizer.FLOAT:
            case SQLTokenizer.DOUBLE:
                    writeDouble( expr.getDouble() );
                    break;
            case SQLTokenizer.MONEY:
                    writeLong( expr.getMoney() );
                    break;
            case SQLTokenizer.SMALLMONEY:
                    writeInt( (int)expr.getMoney() );
                    break;
            case SQLTokenizer.NUMERIC:
            case SQLTokenizer.DECIMAL:
            		MutableNumeric numeric = expr.getNumeric();
            		numeric.setScale( column.getScale() );
                    writeNumeric( numeric );
                    break;
            case SQLTokenizer.CHAR:
            case SQLTokenizer.NCHAR:
                    writeString( expr.getString(), column.getDisplaySize(), false );
                    break;
            case SQLTokenizer.VARCHAR:
            case SQLTokenizer.NVARCHAR:
                    writeString( expr.getString(), column.getDisplaySize(), true );
                    break;
			case SQLTokenizer.CLOB:
			case SQLTokenizer.NCLOB:
            case SQLTokenizer.LONGNVARCHAR:
            case SQLTokenizer.LONGVARCHAR:
                    writeLongString( expr.getString() );
                    break;
            case SQLTokenizer.JAVA_OBJECT:
                    // FIXME a MemoryStream can be faster because there are no additional array copy
                    ByteArrayOutputStream baos = new ByteArrayOutputStream();
                    ObjectOutputStream oos = new ObjectOutputStream(baos);
                    oos.writeObject( expr.getObject() );
                    writeLongBinary( baos.toByteArray() );
                    break;
            case SQLTokenizer.LONGVARBINARY:
            case SQLTokenizer.BLOB:
                    writeLongBinary( expr.getBytes() );
                    break;