com.foundationdb.sql.jdbc.largeobject.BlobOutputStream Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of fdb-sql-layer-jdbc Show documentation
The FoundationDB SQL Layer Driver for JDBC4
There is a newer version: 2.1-0-jdbc41
/*-------------------------------------------------------------------------
*
* Copyright (c) 2003-2011, PostgreSQL Global Development Group
*
*
*-------------------------------------------------------------------------
*/
package com.foundationdb.sql.jdbc.largeobject;

import java.io.IOException;
import java.io.OutputStream;
import java.sql.SQLException;

/**
 *     This implements a basic output stream that writes to a LargeObject
 */
public class BlobOutputStream extends OutputStream
{
    /**
     * The parent LargeObject
     */
    private LargeObject lo;

    /**
     * Buffer
     */
    private byte buf[];

    /**
     * Size of the buffer (default 1K)
     */
    private int bsize;

    /**
     * Position within the buffer
     */
    private int bpos;

    /**
     * Create an OutputStream to a large object
     * @param lo LargeObject
     */
    public BlobOutputStream(LargeObject lo)
    {
        this(lo, 1024);
    }

    /**
     * Create an OutputStream to a large object
     * @param lo LargeObject
     * @param bsize The size of the buffer used to improve performance
     */
    public BlobOutputStream(LargeObject lo, int bsize)
    {
        this.lo = lo;
        this.bsize = bsize;
        buf = new byte[bsize];
        bpos = 0;
    }

    public void write(int b) throws java.io.IOException
    {
        checkClosed();
        try
        {
            if (bpos >= bsize)
            {
                lo.write(buf);
                bpos = 0;
            }
            buf[bpos++] = (byte)b;
        }
        catch (SQLException se)
        {
            throw new IOException(se.toString());
        }
    }

    public void write(byte[] buf, int off, int len) throws java.io.IOException
    {
        checkClosed();
        try
        {
            // If we have any internally buffered data, send it first
            if ( bpos > 0 )
                flush();

            if ( off == 0 && len == buf.length )
                lo.write(buf); // save a buffer creation and copy since full buffer written
            else
                lo.write(buf, off, len);
        }
        catch (SQLException se)
        {
            throw new IOException(se.toString());
        }
    }


    /**
     * Flushes this output stream and forces any buffered output bytes
     * to be written out. The general contract of flush is
     * that calling it is an indication that, if any bytes previously
     * written have been buffered by the implementation of the output
     * stream, such bytes should immediately be written to their
     * intended destination.
     *
     * @exception  IOException if an I/O error occurs.
     */
    public void flush() throws IOException
    {
        checkClosed();
        try
        {
            if (bpos > 0)
                lo.write(buf, 0, bpos);
            bpos = 0;
        }
        catch (SQLException se)
        {
            throw new IOException(se.toString());
        }
    }

    /**
     * Closes this output stream and releases any system resources
     * associated with this stream. The general contract of close
     * is that it closes the output stream. A closed stream cannot perform
     * output operations and cannot be reopened.
     * 
     * The close method of OutputStream does nothing.
     *
     * @exception  IOException if an I/O error occurs.
     */
    public void close() throws IOException
    {
        if (lo != null) {
            try
            {
                flush();
                lo.close();
                lo = null;
            }
            catch (SQLException se)
            {
                throw new IOException(se.toString());
            }
        }
    }

    private void checkClosed() throws IOException
    {
        if (lo == null)
            throw new IOException("BlobOutputStream is closed");
    }

}