public SerialBlob(byte[] b) throws SQLException, SerialException 
{
        len = b.length;
        buf = new byte[(int)len];
        for(int i = 0; i <  len; i++) {
           buf[i] = b[i];
        }
        origLen = len;
}

Constructs a SerialBlob object that is a serialized version of the given byte array.

The new SerialBlob object is initialized with the data from the byte array, thus allowing disconnected RowSet objects to establish serialized Blob objects without touching the data source.

Parameters:

b - the byte array containing the data for the Blob object to be serialized

Throws:

SerialException - if an error occurs during serialization

SQLException - if a SQL errors occurs

 public SerialBlob(Blob blob) throws SQLException, SerialException 
{
        if (blob == null) {
            throw new SQLException("Cannot instantiate a SerialBlob " +
                 "object with a null Blob object");
        }
        len = blob.length();
        buf = blob.getBytes(1, (int)len );
        this.blob = blob;
         //if ( len <  10240000)
         // len = 10240000;
        origLen = len;
}

Constructs a SerialBlob object that is a serialized version of the given Blob object.

The new SerialBlob object is initialized with the data from the Blob object; therefore, the Blob object should have previously brought the SQL BLOB value's data over to the client from the database. Otherwise, the new SerialBlob object will contain no data.

Parameters:

blob - the Blob object from which this SerialBlob object is to be constructed; cannot be null.

Throws:

SerialException - if an error occurs during serialization

SQLException - if the Blob passed to this to this constructor is a null.

Also see:

java.sql.Blob

 public  void free() throws SQLException 
{
        throw new java.lang.UnsupportedOperationException("Not supported");
}

This method frees the Blob object and releases the resources that it holds. Blob object. The object is invalid once the free method is called. If free is called multiple times, the subsequent calls to free are treated as a no-op.

 public InputStream getBinaryStream() throws SerialException 
{
         InputStream stream = new ByteArrayInputStream(buf);
         return (java.io.InputStream)stream;
}

Returns this SerialBlob object as an input stream. Unlike the related method, setBinaryStream, a stream is produced regardless of whether the SerialBlob was created with a Blob object or a byte array.

 public InputStream getBinaryStream(long pos,
    long length) throws SQLException 
{
        throw new java.lang.UnsupportedOperationException("Not supported");
}

Returns an InputStream object that contains a partial Blob value, starting with the byte specified by pos, which is length bytes in length.

 public byte[] getBytes(long pos,
    int length) throws SerialException 
{
        if (length  > len) {
            length = (int)len;
        }
        if (pos <  1 || length - pos <  0 ) {
            throw new SerialException("Invalid arguments: position cannot be less that 1");
        }
        pos--; // correct pos to array index
        byte[] b = new byte[length];
        for (int i = 0; i <  length; i++) {
            b[i] = this.buf[(int)pos];
            pos++;
        }
        return b;
}

Copies the specified number of bytes, starting at the given position, from this SerialBlob object to another array of bytes.

Note that if the given number of bytes to be copied is larger than the length of this SerialBlob object's array of bytes, the given number will be shortened to the array's length.

 public long length() throws SerialException 
{
        return len;
}

Retrieves the number of bytes in this SerialBlob object's array of bytes.

 public long position(byte[] pattern,
    long start) throws SQLException, SerialException 
{
        if (start <  1 || start  > len) {
            return -1;
        }
        int pos = (int)start-1; // internally Blobs are stored as arrays.
        int i = 0;
        long patlen = pattern.length;
        while (pos <  len) {
            if (pattern[i] == buf[pos]) {
                if (i + 1 == patlen) {
                    return (pos + 1) - (patlen - 1);
                }
                i++; pos++; // increment pos, and i
            } else if (pattern[i] != buf[pos]) {
                pos++; // increment pos only
            }
        }
        return -1; // not found
}

Returns the position in this SerialBlob object where the given pattern of bytes begins, starting the search at the specified position.

 public long position(Blob pattern,
    long start) throws SQLException, SerialException 
{
        return position(pattern.getBytes(1, (int)(pattern.length())), start);
}

Returns the position in this SerialBlob object where the given Blob object begins, starting the search at the specified position.

 public OutputStream setBinaryStream(long pos) throws SQLException, SerialException 
{
        if (this.blob.setBinaryStream(pos) != null) {
            return this.blob.setBinaryStream(pos);
        } else {
            throw new SerialException("Unsupported operation. SerialBlob cannot " +
                "return a writable binary stream, unless instantiated with a Blob object " +
                "that provides a setBinaryStream() implementation");
        }
}

Retrieves a stream that can be used to write to the BLOB value that this Blob object represents. The stream begins at position pos. This method forwards the setBinaryStream() call to the underlying Blob in the event that this SerialBlob object is instantiated with a Blob. If this SerialBlob is instantiated with a byte array, a SerialException is thrown.

 public int setBytes(long pos,
    byte[] bytes) throws SQLException, SerialException 
{
        return (setBytes(pos, bytes, 0, bytes.length));
}

Writes the given array of bytes to the BLOB value that this Blob object represents, starting at position pos, and returns the number of bytes written.

 public int setBytes(long pos,
    byte[] bytes,
    int offset,
    int length) throws SQLException, SerialException 
{
        if (offset <  0 || offset  > bytes.length) {
            throw new SerialException("Invalid offset in byte array set");
        }
        if (pos <  1 || pos  > this.length()) {
            throw new SerialException("Invalid position in BLOB object set");
        }
        if ((long)(length)  > origLen) {
            throw new SerialException("Buffer is not sufficient to hold the value");
        }
        if ((length + offset)  > bytes.length) {
            throw new SerialException("Invalid OffSet. Cannot have combined offset " +
                "and length that is greater that the Blob buffer");
        }
        int i = 0;
        pos--; // correct to array indexing
        while ( i <  length || (offset + i +1) <  (bytes.length-offset) ) {
            this.buf[(int)pos + i] = bytes[offset + i ];
            i++;
        }
        return i;
}

Writes all or part of the given byte array to the BLOB value that this Blob object represents and returns the number of bytes written. Writing starts at position pos in the BLOB value; len bytes from the given byte array are written.

 public  void truncate(long length) throws SerialException 
{
         if (length  > len) {
            throw new SerialException
               ("Length more than what can be truncated");
         } else if((int)length == 0) {
              buf = new byte[0];
              len = length;
         } else {
              len = length;
              buf = this.getBytes(1, (int)len);
         }
}

Truncates the BLOB value that this Blob object represents to be len bytes in length.