public SerialClob(char[] ch) throws SQLException, SerialException 
{
        // %%% JMB. Agreed. Add code here to throw a SQLException if no
        // support is available for locatorsUpdateCopy=false
        // Serializing locators is not supported.
        len = ch.length;
        buf = new char[(int)len];
        for (int i = 0; i <  len ; i++){
           buf[i] = ch[i];
        }
        origLen = len;
}

Constructs a SerialClob object that is a serialized version of the given char array.

The new SerialClob object is initialized with the data from the char array, thus allowing disconnected RowSet objects to establish a serialized Clob object without touching the data source.

Parameters:

ch - the char array representing the Clob object to be serialized

Throws:

SerialException - if an error occurs during serialization

SQLException - if a SQL error occurs

 public SerialClob(Clob clob) throws SQLException, SerialException 
{
        if (clob == null) {
            throw new SQLException("Cannot instantiate a SerialClob " +
                "object with a null Clob object");
        }
        len = clob.length();
        this.clob = clob;
        buf = new char[(int)len];
        int read = 0;
        int offset = 0;
        BufferedReader reader;
        if ( (((reader = new BufferedReader(clob.getCharacterStream())) == null)) &&
            (clob.getAsciiStream() == null)) {
            throw new SQLException("Invalid Clob object. Calls to getCharacterStream " +
                "and getAsciiStream return null which cannot be serialized.");
        }
        try {
            do {
                read = reader.read(buf, offset, (int)(len - offset));
                offset += read;
            } while (read  > 0);
        } catch (java.io.IOException ex) {
            throw new SerialException("SerialClob: " + ex.getMessage());
        }
        origLen = len;
}

Constructs a SerialClob object that is a serialized version of the given Clob object.

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

Note: The Clob object supplied to this constructor cannot return null for the Clob.getCharacterStream() and Clob.getAsciiStream methods. This SerialClob constructor cannot serialize a Clob object in this instance and will throw an SQLException object.

Parameters:

clob - the Clob object from which this SerialClob object is to be constructed; cannot be null

Throws:

SerialException - if an error occurs during serialization

SQLException - if a SQL error occurs in capturing the CLOB; if the Clob object is a null; or if both the Clob.getCharacterStream() and Clob.getAsciiStream() methods on the Clob return a null

Also see:

java.sql.Clob

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

 public InputStream getAsciiStream() throws SQLException, SerialException 
{
       if (this.clob != null) {
             return this.clob.getAsciiStream();
         } else {
             throw new SerialException("Unsupported operation. SerialClob cannot " +
                "return a the CLOB value as an ascii stream, unless instantiated " +
                "with a fully implemented Clob object.");
         }
}

Retrieves the CLOB value designated by this SerialClob object as an ascii stream. This method forwards the getAsciiStream call to the underlying Clob object in the event that this SerialClob object is instantiated with a Clob object. If this SerialClob object is instantiated with a char array, a SerialException object is thrown.

 public Reader getCharacterStream() throws SerialException 
{
        return (java.io.Reader) new CharArrayReader(buf);
}

Returns this SerialClob object's data as a stream of Unicode characters. Unlike the related method, getAsciiStream, a stream is produced regardless of whether the SerialClob object was created with a Clob object or a char array.

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

 public String getSubString(long pos,
    int length) throws SerialException 
{
        if (pos <  1 || pos  > this.length()) {
            throw new SerialException("Invalid position in BLOB object set");
        }
        if ((pos-1) + length  > this.length()) {
            throw new SerialException("Invalid position and substring length");
        }
        try {
            return new String(buf, (int)pos - 1, length);
        } catch (StringIndexOutOfBoundsException e) {
            throw new SerialException("StringIndexOutOfBoundsException: " +
                e.getMessage());
        }
}

Returns a copy of the substring contained in this SerialClob object, starting at the given position and continuing for the specified number or characters.

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

Retrieves the number of characters in this SerialClob object's array of characters.

 public long position(String searchStr,
    long start) throws SQLException, SerialException 
{
        if (start <  1 || start  > len) {
            return -1;
        }
        char pattern[] = searchStr.toCharArray();
        int pos = (int)start-1;
        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 SerialClob object where the given String object begins, starting the search at the specified position. This method returns -1 if the pattern is not found.

 public long position(Clob searchStr,
    long start) throws SQLException, SerialException 
{
        return position(searchStr.getSubString(1,(int)searchStr.length()), start);
}

Returns the position in this SerialClob object where the given Clob signature begins, starting the search at the specified position. This method returns -1 if the pattern is not found.

 public OutputStream setAsciiStream(long pos) throws SQLException, SerialException 
{
         if (this.clob.setAsciiStream(pos) != null) {
             return this.clob.setAsciiStream(pos);
         } else {
             throw new SerialException("Unsupported operation. SerialClob cannot " +
                "return a writable ascii stream\n unless instantiated with a Clob object " +
                "that has a setAsciiStream() implementation");
         }
}

Retrieves a stream to be used to write Ascii characters to the CLOB value that this SerialClob object represents, starting at position pos. This method forwards the setAsciiStream() call to the underlying Clob object in the event that this SerialClob object is instantiated with a Clob object. If this SerialClob object is instantiated with a char array, a SerialException object is thrown.

 public Writer setCharacterStream(long pos) throws SQLException, SerialException 
{
        if (this.clob.setCharacterStream(pos) != null) {
            return this.clob.setCharacterStream(pos);
        } else {
            throw new SerialException("Unsupported operation. SerialClob cannot " +
                "return a writable character stream\n unless instantiated with a Clob object " +
                "that has a setCharacterStream implementation");
        }
}

Retrieves a stream to be used to write a stream of Unicode characters to the CLOB value that this SerialClob object represents, at position pos. This method forwards the setCharacterStream() call to the underlying Clob object in the event that this SerialClob object is instantiated with a Clob object. If this SerialClob object is instantiated with a char array, a SerialException is thrown.

 public int setString(long pos,
    String str) throws SerialException 
{
        return (setString(pos, str, 0, str.length()));
}

Writes the given Java String to the CLOB value that this SerialClob object represents, at the position pos.

 public int setString(long pos,
    String str,
    int offset,
    int length) throws SerialException 
{
        String temp = str.substring(offset);
        char cPattern[] = temp.toCharArray();
        if (offset <  0 || offset  > str.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)  > str.length()) {
            // need check to ensure 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--;  //values in the array are at position one less
        while ( i <  length || (offset + i +1) <  (str.length() - offset ) ) {
            this.buf[(int)pos + i ] = cPattern[offset + i ];
            i++;
        }
        return i;
}

Writes len characters of str, starting at character offset, to the CLOB value that this Clob represents.

 public  void truncate(long length) throws SerialException 
{
         if (length  > len) {
            throw new SerialException
               ("Length more than what can be truncated");
         } else {
              len = length;
              // re-size the buffer
              if (len == 0) {
                  buf = new char[] {};
              } else {
                buf = (this.getSubString(1, (int)len)).toCharArray();
              }
         }
}

Truncates the CLOB value that this SerialClob object represents so that it has a length of len characters.

Truncating a SerialClob object to length 0 has the effect of clearing its contents.