storedrecordheader.java

derby database source code.good for you.

		this.overflowId     = overflowHandle.getId();
	}

    public void setOverflowFields(StoredRecordHeader loadFromTarget)
    {
		this.status         = (loadFromTarget.status | RECORD_OVERFLOW);
		this.id             = loadFromTarget.id;
		this.numberFields   = loadFromTarget.numberFields;
        this.firstField     = loadFromTarget.firstField;
		handle              = null;
    }


	public final void setNumberFields(int numberFields) 
    {
		this.numberFields = numberFields;
	}

    /**************************************************************************
     * Public Methods implmenting read/write of Storable Interface:
     **************************************************************************
     */
	public int write(OutputStream out) 
        throws IOException 
    {
        // check consistency of the status field - this has caught
        // byte writing corruptions in StoredPage in the past.
        if (SanityManager.DEBUG)
        {
            if ((status & ~RECORD_VALID_MASK) != 0)
            	SanityManager.THROWASSERT(
                	"Invalid status in StoredRecordHeaader = " + status);
        }

        // write status
		int len = 1;
		out.write(status);

        // write id
		len += CompressedNumber.writeInt(out, id);
		

        // write overflow information for overflow record headers
		if (hasOverflow()) 
        {
			// if overflow bit is set, then write the overflow pointer info.
			len += CompressedNumber.writeLong(out, overflowPage);
			len += CompressedNumber.writeInt(out, overflowId);
		}

        // write first field info for long row parts
		if (hasFirstField()) 
        {
			len += CompressedNumber.writeInt(out, firstField);
		}

        // write number of fields, except in the case of a record header
        // which is solely a pointer to another row portion.
        //
		// see read
		if (!hasOverflow() || hasFirstField())
			len += CompressedNumber.writeInt(out, numberFields);

		return len;
	}

	public void read(java.io.ObjectInput in) 
        throws IOException 
    {

        // read status
		status = in.read();
		if (status < 0)
			throw new EOFException();

        // check consistency of the status field - this has caught
        // byte writing corruptions in StoredPage in the past.
        if (SanityManager.DEBUG)
        {
            if ((status & ~RECORD_VALID_MASK) != 0)
            	SanityManager.THROWASSERT(
                	"Invalid status in StoredRecordHeader = " + status);
        }

        // read the record id
		id = CompressedNumber.readInt(in);

        // initialize the overflow pointer based on status.
		if (hasOverflow()) 
        {
			overflowPage = CompressedNumber.readLong(in);
			overflowId   = CompressedNumber.readInt(in);

		} 
        else 
        {
			overflowPage = 0;
			overflowId   = 0;
		}

        // initialize the 1st field overflow pointer based on status.
		if (hasFirstField()) 
        {
			firstField = CompressedNumber.readInt(in);
		} 
        else 
        {
			firstField = 0;
		}
	
		// In releases prior to 1.3 an overflow record was handled
		// by an overflow header pointing to a complete record on
		// another page. This header had the has overflow bit set but not
		// the has first field bit. This header also did not have the
		// number of fields written out, but it can be seen as
		// a header with 0 fields and a first field of 0.
		if (!hasOverflow() || hasFirstField())
			numberFields = CompressedNumber.readInt(in);
		else
			numberFields = 0;

		handle = null;
	}

    private int readId(
    byte[]  data,
    int     offset)
    {
		int value = data[offset++];

        if ((value & ~0x3f) == 0)
        {
            // value stored in this byte.
            id = value;

            return(1);
        }
		else if ((value & 0x80) == 0)
		{
            // value is stored in 2 bytes.  only use low 6 bits from 1st byte.

            id = (((value & 0x3f) << 8) | (data[offset] & 0xff));

            return(2);
		}
        else
        {
            // value is stored in 4 bytes.  only use low 7 bits from 1st byte.
            id = 
                ((value          & 0x7f) << 24) |
                ((data[offset++] & 0xff) << 16) |
                ((data[offset++] & 0xff) <<  8) |
                ((data[offset]   & 0xff)      );

            return(4);
        }
    }
    private int readOverFlowPage(
    byte[]  data,
    int     offset)
    {
		int int_value = data[offset++];

        if ((int_value & ~0x3f) == 0)
        {
            // test for small case first - assuming this is usual case.
            // this is stored in 2 bytes.

            overflowPage = ((int_value << 8) | (data[offset] & 0xff));

            return(2);
		}
		else if ((int_value & 0x80) == 0)
		{
            // value is stored in 4 bytes.  only use low 6 bits from 1st byte.

            overflowPage = 
                ((int_value      & 0x3f) << 24) |
                ((data[offset++] & 0xff) << 16) |
                ((data[offset++] & 0xff) <<  8) |
                ((data[offset]   & 0xff)      );

            return(4);

		} 
        else
		{
            // value is stored in 8 bytes.  only use low 6 bits from 1st byte.
            overflowPage = 
                (((long) (int_value      & 0x7f)) << 56) |
                (((long) (data[offset++] & 0xff)) << 48) |
                (((long) (data[offset++] & 0xff)) << 40) |
                (((long) (data[offset++] & 0xff)) << 32) |
                (((long) (data[offset++] & 0xff)) << 24) |
                (((long) (data[offset++] & 0xff)) << 16) |
                (((long) (data[offset++] & 0xff)) <<  8) |
                (((long) (data[offset]   & 0xff))      );

            return(8);
		}
    }
    private int readOverFlowId(
    byte[]  data,
    int     offset)
    {
		int value = data[offset++];

        if ((value & ~0x3f) == 0)
        {
            // length stored in this byte.
            overflowId = value;

            return(1);
        }
		else if ((value & 0x80) == 0)
		{
            // length is stored in 2 bytes.  only use low 6 bits from 1st byte.

            overflowId = (((value & 0x3f) << 8) | (data[offset] & 0xff));

            return(2);
		}
        else
        {
            // length is stored in 4 bytes.  only use low 7 bits from 1st byte.
            overflowId = 
                ((value          & 0x7f) << 24) |
                ((data[offset++] & 0xff) << 16) |
                ((data[offset++] & 0xff) <<  8) |
                ((data[offset]   & 0xff)      );

            return(4);
        }
    }
    private int readFirstField(
    byte[]  data,
    int     offset)
    {
		int value = data[offset++];

        if ((value & ~0x3f) == 0)
        {
            // length stored in this byte.
            firstField = value;

            return(1);
        }
		else if ((value & 0x80) == 0)
		{
            // length is stored in 2 bytes.  only use low 6 bits from 1st byte.

            firstField = (((value & 0x3f) << 8) | (data[offset] & 0xff));

            return(2);
		}
        else
        {
            // length is stored in 4 bytes.  only use low 7 bits from 1st byte.
            firstField = 
                ((value          & 0x7f) << 24) |
                ((data[offset++] & 0xff) << 16) |
                ((data[offset++] & 0xff) <<  8) |
                ((data[offset]   & 0xff)      );

            return(4);
        }
    }
    private void readNumberFields(
    byte[]  data,
    int     offset)
    {
		int value = data[offset++];

        if ((value & ~0x3f) == 0)
        {
            // length stored in this byte.
            numberFields = value;
        }
		else if ((value & 0x80) == 0)
		{
            // length is stored in 2 bytes.  only use low 6 bits from 1st byte.

            numberFields = (((value & 0x3f) << 8) | (data[offset] & 0xff));
		}
        else
        {
            // length is stored in 4 bytes.  only use low 7 bits from 1st byte.
            numberFields = 
                ((value          & 0x7f) << 24) |
                ((data[offset++] & 0xff) << 16) |
                ((data[offset++] & 0xff) <<  8) |
                ((data[offset]   & 0xff)      );
        }
    }


	private void read(
    byte[]  data,
    int     offset)
    {
        status = data[offset++];

		int value = data[offset++];

        if ((value & ~0x3f) == 0)
        {
            // value stored in this byte.
            id = value;
        }
		else if ((value & 0x80) == 0)
		{
            // value is stored in 2 bytes.  only use low 6 bits from 1st byte.

            id = (((value & 0x3f) << 8) | (data[offset++] & 0xff));
		}
        else
        {
            // value is stored in 4 bytes.  only use low 7 bits from 1st byte.
            id = 
                ((value          & 0x7f) << 24) |
                ((data[offset++] & 0xff) << 16) |
                ((data[offset++] & 0xff) <<  8) |
                ((data[offset++] & 0xff)      );
        }

        if ((status & (RECORD_OVERFLOW | RECORD_HAS_FIRST_FIELD)) == 0)
        {
            // usual case, not a record overflow and does not have first field
			overflowPage = 0;
			overflowId   = 0;
            firstField   = 0;

            readNumberFields(data, offset);
        }
        else if ((status & RECORD_OVERFLOW) == 0)
        {
            // not overflow, and has first field set.
			overflowPage = 0;
			overflowId   = 0;

            offset += readFirstField(data, offset);

            readNumberFields(data, offset);
        }
        else
        {
            // is an overflow field

            offset += readOverFlowPage(data, offset);
            offset += readOverFlowId(data, offset);

            if (hasFirstField())
            {
                offset += readFirstField(data, offset);
                readNumberFields(data, offset);
            }
            else
            {
                firstField   = 0;
                numberFields = 0;
            }
		}

        handle = null;

        return;
	}


	public String toString()
	{
		if (SanityManager.DEBUG)
		{
			String str = "recordHeader: Id=" + getId();
			
			str += "\n  isDeleted     = " + isDeleted();
			str += "\n  hasOverflow   = " + hasOverflow();
			str += "\n  hasFirstField = " + hasFirstField();
			str += "\n  numberFields  = " + getNumberFields();
			str += "\n  firstField    = " + getFirstField();
			str += "\n  overflowPage  = " + getOverflowPage();
			str += "\n  overflowId    = " + getOverflowId();

			return str;
		}
		else
        {
			return null;
        }
	}
}